Ambiguous operator?

I'm getting an ambiguous operator error, and I'm not sure why.
I've dumbed down the example. Can anyone spot the problem?

Code:

---

template<typename T, bool ReadOnly> class buffered_stream_iterator;

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);

template<typename T, bool ReadOnly>
class buffered_stream_iterator:
        public std::iterator<std::random_access_iterator_tag, T>
{
public:
        template<typename ThisT, bool ReadOnly, typename T2> friend T2& operator += (T2& lhs, const buffered_stream_iterator<ThisT, ReadOnly>& rhs);
};

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs)
{
        return lhs;
}

int main()
{
        buffered_stream_iterator<wchar_t, false> Test;
        int n = 0;
        n += Test;
        return 0;
}

---

Quote:

---

1>error C2593: 'operator +=' is ambiguous
1> could be 'T2 &operator +=<ElemType_t,false,int>(T2 &,const buffered_stream_iterator<T,ReadOnly> &)' [found using argument-dependent lookup]
1> with
1> [
1> T2=int,
1> T=ElemType_t,
1> ReadOnly=false
1> ]
1> or 'T2 &operator +=<ElemType_t,false,int>(T2 &,const buffered_stream_iterator<T,ReadOnly> &)'
1> with
1> [
1> T2=int,
1> T=ElemType_t,
1> ReadOnly=false
1> ]
1> while trying to match the argument list '(int, buffered_stream_iterator<T,ReadOnly>)'
1> with
1> [
1> T=ElemType_t,
1> ReadOnly=false
1> ]

---

I'd appreciate any help.

It compiles and runs fine in GCC once the errors are fixed due to BufType not being defined for the 2 structs that use it, and the template variables that are shadowed.

Okay... Now that you mention it, it does compile on VC10, but not on VC8.
This is just plain weird... not to mention disturbing and problematic.
Sorry about missing types and shadowed templates. I did compile it, but as always, VC8 doesn't always compile templates. And never complains about shadowed templates which I tend to forget. I updated the code sample anyway in case anyone else wants to have a look...

I remember I haven't installed any service packs... let's see if SP1 helps.

You've still got the shadowed parameters, Elysia. Should be something like:

Code:

---

        template<typename ThisT, bool ThisReadOnly, typename T2>
        friend T2& operator += (T2& lhs, const buffered_stream_iterator<ThisT, ThisReadOnly>& rhs);

---

I know... I didn't fix it. But I fixed it now.
But I am in a predicament here...
VS8 doesn't compile the code.
VS9 doesn't work - installation borked thanks to VS10 installer(s).
VS10 is too slow to be a productive IDE...

>> VS8 doesn't compile the code.

Really? The updated code?

>> VS9 doesn't work - installation borked thanks to VS10 installer(s).

Yes, that can be pretty annoying.

>> VS10 is too slow to be a productive IDE...

Hmm, I've never tried it myself. Is it really that bad?

Quote:

---

Originally Posted by Sebastiani

Really? The updated code?

---

The updated code doesn't work either...

Quote:

---

Yes, that can be pretty annoying.

---

Ah, but here's something better.
I figure the problem is with the dotCrapwork. But it requires 3.5 and since 3.5 is part of Win7, it's impossible to reinstall it. Great work, Microsoft.

Quote:

---

Hmm, I've never tried it myself. Is it really that bad?

---

Performance is horrible. You should do yourself a favor and not try it.
It starts super slow. It closes super slow.
The live-compile compiles far too slow to be of any use (you keep getting errors way after they're gone and they appear way after you actually write the piece and the Error List gets cluttered with IntelliSense errors all the while).
Not to mention it crashes often, and is just broken - it's not even possible to add Unit Tests for C++.
Ah, and they removed the global path options in favor of unintelligible property sheets which are difficult to find and edit.
It's not a beta. It's a pre-alpha.

I think it will be a great product in the end, but right now, it's a bug fest.

>> The updated code doesn't work either...

Just curious, but does VS8 compile this?:

Code:

---

template<typename T, bool ReadOnly>
class buffered_stream_iterator:
        public std::iterator<std::random_access_iterator_tag, T>
{
public:
        friend T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);
};

---

>> Ah, but here's something better. I figure the problem is with the dotCrapwork. But it requires 3.5 and since 3.5 is part of Win7, it's impossible to reinstall it. Great work, Microsoft.

Just a shot in the dark here, but perhaps you can uninstall VS10, make sure the registry doesn't have any VS9 remnants, and then reinstall VS9? Come to think of it, there's a slight chance that VS10 is actually running slow because of some botched values in the registry related to VS9. I've actually had that problem before with a Java installation.

But yeah, that really sucks. Good luck - and if things don't work out you can always use GCC with the IDE of your choosing. :p

It almost seems like the compiler is treating the forward-declaration of the template operator as an actual template definition. Have you tried removing that forward declaration, and moving the template definition to before the class definition?

Quote:

---

Originally Posted by Sebastiani

>> The updated code doesn't work either...

Just curious, but does VS8 compile this?:

Code:

---

template<typename T, bool ReadOnly>
class buffered_stream_iterator:
        public std::iterator<std::random_access_iterator_tag, T>
{
public:
        friend T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);
};

---

---

How so? T2 isn't declared.
Should I add a typename T2 in a template perhaps?

Quote:

---

Just a shot in the dark here, but perhaps you can uninstall VS10, make sure the registry doesn't have any VS9 remnants, and then reinstall VS9? Come to think of it, there's a slight chance that VS10 is actually running slow because of some botched values in the registry related to VS9. I've actually had that problem before with a Java installation.

---

No... I've uninstalled VS10 and reinstall VS9 several times, but it refuses to work. I've also tried the Visual Studio Uninstaller tool to get rid of 9, but no go. I'm stuck until I reinstall Windows. Such a nice thing. Or stick with VS8 'til I can get VS10. Hopefully they'll provide Professional to students for free.

Quote:

---

But yeah, that really sucks. Good luck - and if things don't work out you can always use GCC with the IDE of your choosing. :p

---

An interesting tidbit is that VS10 should work with any compiler. But I don't know easy that will be...
But another IDE and compiler is probably out of the question. It would be a pain to get used to another one.
Sigh. I'll have to think on that one.

Quote:

---

Originally Posted by brewbuck

It almost seems like the compiler is treating the forward-declaration of the template operator as an actual template definition. Have you tried removing that forward declaration, and moving the template definition to before the class definition?

---

No go with that either. The compiler still treats them as two different template definitions.

Maybe I just have to write member wrappers that the operators call and make the operators inline. Thinking on that actually makes sense, since template friend non-class operators are usually a pain to add.

>> Should I add a typename T2 in a template perhaps?

Whoops, sorry. Yes, that's what I meant. :p

>> An interesting tidbit is that VS10 should work with any compiler. But I don't know easy that will be... But another IDE and compiler is probably out of the question. It would be a pain to get used to another one. Sigh. I'll have to think on that one.

True. Well I wouldn't know what to recommend anyway, as I don't actually use an IDE and have never found one that I liked much. Besides that, I've heard VS *is* the best IDE out there from almost everyone, so you may not even be satisfied with what's available anyway. =/

(NOT A SOLUTION!)
This code compiles:

Code:

---

#include <iterator>

template<typename T, bool ReadOnly> class buffered_stream_iterator;

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);

template<typename T, bool ReadOnly>
class buffered_stream_iterator:
        public std::iterator<std::random_access_iterator_tag, T>
{
public:
        template<typename T2> friend T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);
};

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs)
{
        return lhs;
}

int main()
{
        buffered_stream_iterator<wchar_t, false> Test;
        int n = 0;
        n += Test;
        return 0;
}

---

It seems that the friend declaration in the class must not include extra template parameters. This is what is throwing the compiler off, thinking it's another operator. Using the parameters defined for the class works.

O_o

That shouldn't work at all.

What suite is compiling and linking this while honoring "friend"--allowing access to private members?

Soma

Ah yes, from one problem to the other. Template friends are just a pain; this solves the ambiguous operator, but fails to make the friend declaration work. Wonderful, that's what I call it.
Good thing I decided to use an easier approach.

I'm not even going to bother with this approach anymore >_<

EDIT:
Actually, this works!

Code:

---

#include <iterator>
#include <iostream>

template<typename T, bool ReadOnly> class buffered_stream_iterator;

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);

template<typename T, bool ReadOnly>
class buffered_stream_iterator:
        public std::iterator<std::random_access_iterator_tag, T>
{
public:
        template<typename, bool, typename T2> friend T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs);

private:
        int m_Test;
};

template<typename T, bool ReadOnly, typename T2> T2& operator += (T2& lhs, const buffered_stream_iterator<T, ReadOnly>& rhs)
{
        std::cout << rhs.m_Test;
        return lhs;
}

int main()
{
        buffered_stream_iterator<wchar_t, false> Test;
        int n = 0;
        n += Test;
        return 0;
}

---