Ambiguous function call

If someone wouldn't mind here...
I'm getting an ambiguous function call here due to two overloaded operators and would like to know if there's a way around it.

The ambiguous line is:

Code:

---

hFileDirs = FindFirstFile(pArgs->strFolder + _T("\\*.*"), &fDataDirs);

---

pArgs->strFolder is Strings::CStringEx

And the overloads in Strings::CStringEx are:

Code:

---

CTmplString operator + (const T* strData) const;
CTmplString operator + (const CTmplString& rSrc);

---

CStringEx is just a typedef for:

Code:

---

typedef CTmplString<TCHAR> CStringEx;

---

And the compile errors I get:

Code:

---

error C2666: 'Strings::CTmplString<T>::operator +' : 2 overloads have similar conversions
1>        with
1>        [
1>            T=wchar_t
1>        ]
1>        could be 'Strings::CTmplString<T> Strings::CTmplString<T>::operator +(const Strings::CTmplString<T> &)'
1>        with
1>        [
1>            T=wchar_t
1>        ]
1>        or      'Strings::CTmplString<T> Strings::CTmplString<T>::operator +(const T *) const'
1>        with
1>        [
1>            T=wchar_t
1>        ]
1>        while trying to match the argument list '(Strings::CStringEx, const wchar_t [5])'
1>        note: qualification adjustment (const/volatile) may be causing the ambiguity

---

Any idea what to do about this situation?
I'm looking for any ideas/advice.
Thanks.

Just a wild guess based on the "qualification adjustment (const/volatile) may be causing the ambiguity" note in the error message: what if you make this const correct:

Code:

---

CTmplString operator + (const CTmplString& rSrc);

---

by changing it to:

Code:

---

CTmplString operator + (const CTmplString& rSrc) const;

---

?

Right! I forgot about that. I always tend to forget putting const in some places.
Yep, now it compiles fine. Thanks.

Why is binary + a member at all? If you have a proper +=, + should always be implemented in terms of that.

I'm not 100% sure what you mean. But I did overload operator + to allow the above code. Internally in the class, it will just construct a temp object and call operator +=.
But I also realized I don't need a operator + for the object itself. A constant character pointer is enough.

Quote:

---

I'm not 100% sure what you mean. But I did overload operator + to allow the above code. Internally in the class, it will just construct a temp object and call operator +=.

---

This is, uh, related to the idea of preferring to write functions as non-member non-friend functions.

Yeah, but also, syntax such as 'a' == mystr is not to my liking, so I prefer to have the operators as member functions, because I can get away with it.
My test suite hasn't let me down yet.

Quote:

---

Yeah, but also, syntax such as 'a' == mystr is not to my liking

---

You could enforce that by declaring as explicit the constructor that takes a char.

I'm not trying to hinder functionality :O
I'm merely avoiding implementing functionality that I don't need.

Quote:

---

Originally Posted by Elysia

I'm not 100% sure what you mean. But I did overload operator + to allow the above code. Internally in the class, it will just construct a temp object and call operator +=.
But I also realized I don't need a operator + for the object itself. A constant character pointer is enough.

---

Given

Code:

---

class foo
{
public:
  foo &operator +=(const foo &rhs);
};

---

The canonical way of implementing + is like this:

Code:

---

foo operator +(const foo &lhs, const foo &rhs)
{
  foo t(lhs);
  t += rhs;
  return t;
}

---

Or, if your most important compiler doesn't support NRVO:

Code:

---

foo operator +(foo lhs, const foo &rhs)
{
  return lhs += rhs;
}

---

The pattern is so ubiquitous that Boost even has it pre-packaged in the Operators library.

Code:

---

class foo : public boost::addable<foo>
{
public:
  foo &operator +=(const foo &rhs);
};

---

No operator+ at all. It's implemented by the library.

The right-hand is just added to the left-hand in other words.
So in order to skip operator +, I would just derive from boost::addable?

Yep. And by deriving from boost::addable<ExString, const char *> you even get the mixed versions for free.

Cool! Will have to try that out when I get home.
So much good stuff hidden in boost that I really don't know!