operator overload with namespace

[Jason C]

Hi, I am coming from C background and trying to learn C++. So bear with
me if the answer to my question is obvious.
I am trying to overload the "+" operator in different namespaces, like
this:
namespace A
{
std::string operator+(std::string const &a, std::string const &b);
}

namespace B
{
std::string operator+(std::string const &a, std::string const &b);
}

How do I explicitly call the + operator in either namespace, rather
than the + operator defined in the std::string?

[Victor Bazarov]

Jason C wrote:

Hi, I am coming from C background and trying to learn C++. So bear with
me if the answer to my question is obvious.
I am trying to overload the "+" operator in different namespaces, like
this:
namespace A
{
std::string operator+(std::string const &a, std::string const &b);
}

namespace B
{
std::string operator+(std::string const &a, std::string const &b);
}

How do I explicitly call the + operator in either namespace, rather
than the + operator defined in the std::string?

To explicitly call an operator function you have to spell its name.

string result = B::operator + ( myfirststring, mysecondstring );

V

[Jason C]

Thanks for the quick reply. I have another question:
if I do this:

using namespace A;

std::string s1, s2, s3;

s1 = s2 + s3;

Would the + operator defined within the string class take precedence
over my custom + operator function?

[Larry Brasfield]

"Jason C" <ni********@gmail.com> wrote in message
news:11**********************@o13g2000cwo.googlegr oups.com...

Hi, I am coming from C background and trying to learn C++. So bear with
me if the answer to my question is obvious.
I am trying to overload the "+" operator in different namespaces, like
this:
namespace A
{
std::string operator+(std::string const &a, std::string const &b);
}

namespace B
{
std::string operator+(std::string const &a, std::string const &b);
}

How do I explicitly call the + operator in either namespace, rather
than the + operator defined in the std::string?

While it is not quite explicit, in the strictest sense,
exploiting the lookup rules together with explicit
localized import of namespaces may get the effect
you want. Consider this code:

#include <string>
#include <iostream>
#include <sstream>

namespace Concat {
std::string operator+(std::string & l, std::string & r) {
return std::operator+(l,r);
}
}

namespace Summer {
int operator+(std::string & l, std::string & r) {
std::istringstream lss(l), rss(r);
int il, ir;
lss >> il;
rss >> ir;
return il+ir;
}
}

int main() {
std::string lhs = "12";
std::string rhs = "34";
{
using namespace Concat;
std::cout << lhs + rhs << "\n";
}
{
using namespace Summer;
std::cout << lhs + rhs << "\n";
}
}
--
--Larry Brasfield
email: do***********************@hotmail.com
Above views may belong only to me.

[Victor Bazarov]

Jason C wrote:

Thanks for the quick reply. I have another question:
if I do this:

using namespace A;

std::string s1, s2, s3;

s1 = s2 + s3;

Would the + operator defined within the string class take precedence
over my custom + operator function?

This is a good question. IIRC, it will be ambiguous because the compiler
won't be able to decide between the member and the non-member.

V

[Fraser Ross]

"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:EN*******************@newsread1.mlpsca01.us.t o.verio.net...

Jason C wrote:

Thanks for the quick reply. I have another question:
if I do this:

using namespace A;

std::string s1, s2, s3;

s1 = s2 + s3;

Would the + operator defined within the string class take precedence
over my custom + operator function?

This is a good question. IIRC, it will be ambiguous because the compiler
won't be able to decide between the member and the non-member.

The non-member would have to be in an in-scope namespace or the global
namespace. The original post had one in a namespace which is why I'm
mentioning this.

Fraser.

[Victor Bazarov]

"Fraser Ross" <fraserATmembers.v21.co.unitedkingdom> wrote...

"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:EN*******************@newsread1.mlpsca01.us.t o.verio.net...

Jason C wrote:

> Thanks for the quick reply. I have another question:
>
>
> if I do this:
>
> using namespace A;
>
> std::string s1, s2, s3;
>
> s1 = s2 + s3;
>
> Would the + operator defined within the string class take precedence
> over my custom + operator function?
>

This is a good question. IIRC, it will be ambiguous because the compiler
won't be able to decide between the member and the non-member.

The non-member would have to be in an in-scope namespace or the global
namespace. The original post had one in a namespace which is why I'm
mentioning this.

I am not sure I understand your note. Jason asked a different question,
AFAIUI. Do you see the "using" directive right after "if I do this:"?
Do you think it should make any difference compared to the original
example? Just curious...

[Marcelo Pinto]

Victor Bazarov <v.********@comAcast.net> wrote in message news:<EN*******************@newsread1.mlpsca01.us. to.verio.net>...

Jason C wrote:

Thanks for the quick reply. I have another question:
if I do this:

using namespace A;

std::string s1, s2, s3;

s1 = s2 + s3;

Would the + operator defined within the string class take precedence
over my custom + operator function?

This is a good question. IIRC, it will be ambiguous because the compiler
won't be able to decide between the member and the non-member.

V

I believe that Koenig lookup would require that the string operator be called.

Marcelo Pinto

[Victor Bazarov]

Marcelo Pinto wrote:

Victor Bazarov <v.********@comAcast.net> wrote in message news:<EN*******************@newsread1.mlpsca01.us. to.verio.net>...

Jason C wrote:

Thanks for the quick reply. I have another question:
if I do this:

using namespace A;

std::string s1, s2, s3;

s1 = s2 + s3;

Would the + operator defined within the string class take precedence
over my custom + operator function?

This is a good question. IIRC, it will be ambiguous because the compiler
won't be able to decide between the member and the non-member.

V

I believe that Koenig lookup would require that the string operator be called.

Koenig lookup only governs what functions are _found_, not what functions
are chosen from the overloaded set.

V