Ambiguous conversion

[Nikola]

Hello,
I'm writing a String class for C++ and I'm getting the following error
message when using operator[]:

test.cpp: In function ‘int main()’:
test.cpp:7: error: ISO C++ says that these are ambiguous, even though
the worst conversion for the first is better than the worst conversion
for the second:
string.h:19: note: candidate 1: char Types::String::operator[](unsigned
int) const
test.cpp:7: note: candidate 2: operator[](char*, int) <built-in>

This is the declaration of the String class (implementation not included):

#ifndef _NIKOLA_STRING
#define _NIKOLA_STRING

namespace Types {
class String {
private:
char *_String;

public:
String();
String(const char *Value);
String(const String &Source);
~String();

bool operator==(const String &Value);
String &operator=(const char *Value);
String &operator+=(const String &Value);
String &operator+=(char Value);
char operator[](unsigned int Index) const;
const String operator+(const String &Value) const;
const String operator+(char Value) const;
operator char*();

int Length() const;
String Trim() const;
};
}

#endif

and this is how I'm using it:

#include "string.h"

using namespace Types;

int main() {
String SomeString = "12345";
char a = SomeString[1];
return 0;
}

Clearly, I want to use my own overloaded operator[], however for some
reason the compiler (and standard) considers this ambiguous. What am I
doing wrong, i.e. how do I make the program use my overloaded
operator[], considering I DON'T want to dispose of my typecast operator
overload

operator char*();

Thanks,
Nikola

[Victor Bazarov]

Nikola wrote:

Hello,
I'm writing a String class for C++ and I'm getting the following error
message when using operator[]:

test.cpp: In function ‘int main()’:
test.cpp:7: error: ISO C++ says that these are ambiguous, even though
the worst conversion for the first is better than the worst conversion
for the second:
string.h:19: note: candidate 1: char Types::String::operator[](unsigned
int) const
test.cpp:7: note: candidate 2: operator[](char*, int) <built-in>

This is the declaration of the String class (implementation not included):

#ifndef _NIKOLA_STRING
#define _NIKOLA_STRING

namespace Types {
class String {
private:
char *_String;

public:
String();
String(const char *Value);
String(const String &Source);
~String();

bool operator==(const String &Value);
String &operator=(const char *Value);
String &operator+=(const String &Value);
String &operator+=(char Value);
char operator[](unsigned int Index) const;
const String operator+(const String &Value) const;
const String operator+(char Value) const;
operator char*();

int Length() const;
String Trim() const;
};
}

#endif

and this is how I'm using it:

#include "string.h"

using namespace Types;

int main() {
String SomeString = "12345";
char a = SomeString[1];
return 0;
}

Clearly, I want to use my own overloaded operator[], however for some
reason the compiler (and standard) considers this ambiguous. What am I
doing wrong, i.e. how do I make the program use my overloaded
operator[], considering I DON'T want to dispose of my typecast operator
overload

operator char*();

Replace

char a = SomeString[1];

with

char a = SomeString::operator[](1);

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Nikola]

Victor Bazarov wrote:

>
Replace

char a = SomeString[1];

with

char a = SomeString::operator[](1);

V

test.cpp: In function ‘int main()’:
test.cpp:7: error: ‘SomeString’ is not a class or namespace

char a = String::operator[](1);

also doesn't work. Doesn't the operator[] need to be declared static for
this?

[Nikola]

Nikola wrote:

Victor Bazarov wrote:

>>
Replace

char a = SomeString[1];

with

char a = SomeString::operator[](1);

V

test.cpp: In function ‘int main()’:
test.cpp:7: error: ‘SomeString’ is not a class or namespace

char a = String::operator[](1);

also doesn't work. Doesn't the operator[] need to be declared static for
this?

.... that is, along with the fact that it needs 2 arguments in that case
also, in which case I'm better of just making a member function that
does the same thing and takes 1 argument.

[Nikola]

Victor Bazarov wrote:

>
Replace

char a = SomeString[1];

with

char a = SomeString::operator[](1);

V

Or you mean

char a = SomeString.operator[](1);

to which I say that a member function beats this syntax by far.

Sorry for multiple responses, it's been a long day.

Nikola

[Victor Bazarov]

Nikola wrote:

Victor Bazarov wrote:

>>
Replace

char a = SomeString[1];

with

char a = SomeString::operator[](1);

V

Or you mean

char a = SomeString.operator[](1);

to which I say that a member function beats this syntax by far.

Of course, it was an oversight on my part, good that you caught it.
Yes, you're correct, a named member function would be easier on the
eyes, and that's why 'std::string' does *not* define the conversion
function (no operator char const*), but instead has 'data' and 'c_str'
member functions.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[kwikius]

Nikola wrote:

Hello,
I'm writing a String class for C++ and I'm getting the following error
message when using operator[]:

test.cpp: In function ‘int main()’:
test.cpp:7: error: ISO C++ says that these are ambiguous, even though
the worst conversion for the first is better than the worst conversion
for the second:
string.h:19: note: candidate 1: char Types::String::operator[](unsigned
int) const
test.cpp:7: note: candidate 2: operator[](char*, int) <built-in>

This is the declaration of the String class (implementation not included):

#ifndef _NIKOLA_STRING
#define _NIKOLA_STRING

namespace Types {
class String {

char operator[](unsigned int Index) const;

operator char*();

};

and this is how I'm using it:

#include "string.h"

using namespace Types;

int main() {
String SomeString = "12345";
char a = SomeString[1];
return 0;
}

Clearly, I want to use my own overloaded operator[], however for some
reason the compiler (and standard) considers this ambiguous. What am I
doing wrong, i.e. how do I make the program use my overloaded
operator[], considering I DON'T want to dispose of my typecast operator
overload

operator char*();

Thanks,
Nikola

The problem occurs because int argument to array is not quite the same
as unsigned int, conversion is required , hence ambiguous with char*
conversion.

You can resolve the problem in several ways.
Locally you can call only with unsigned int

SomeString[1u]

You can resolve by changing the signature of array operator

in SomeString ..

char operator[] (int) const;

better, You can resolve it by using a template to allow multiple arg types

template <typename Ioperator[] ( I i)const;

best, In the last version you can use a constraint to restrict to any
integral types. google for enable_if ,is_integral etc..

In this way compiler sees the array operator as a better match because
the argument doesnt require conversion to another type.

regards
Andy Little

[kwikius]

kwikius wrote:

Nikola wrote:

>Hello,
I'm writing a String class for C++ and I'm getting the following error
message when using operator[]:

test.cpp: In function ‘int main()’:
test.cpp:7: error: ISO C++ says that these are ambiguous, even though
the worst conversion for the first is better than the worst conversion
for the second:
string.h:19: note: candidate 1: char
Types::String::operator[](unsigned int) const
test.cpp:7: note: candidate 2: operator[](char*, int) <built-in>

This is the declaration of the String class (implementation not
included):

#ifndef _NIKOLA_STRING
#define _NIKOLA_STRING

namespace Types {
class String {

> char operator[](unsigned int Index) const;

> operator char*();

> };

>and this is how I'm using it:

#include "string.h"

using namespace Types;

int main() {
String SomeString = "12345";
char a = SomeString[1];
return 0;
}

Clearly, I want to use my own overloaded operator[], however for some
reason the compiler (and standard) considers this ambiguous. What am I
doing wrong, i.e. how do I make the program use my overloaded
operator[], considering I DON'T want to dispose of my typecast
operator overload

operator char*();

Thanks,
Nikola

The problem occurs because int argument to array is not quite the same
as unsigned int, conversion is required , hence ambiguous with char*
conversion.

You can resolve the problem in several ways.
Locally you can call only with unsigned int

SomeString[1u]

You can resolve by changing the signature of array operator

in SomeString ..

char operator[] (int) const;

better, You can resolve it by using a template to allow multiple arg types

//############################################

template <typename Ioperator[] ( I i)const;

//#################################

should be
template <typename Ichar operator[] ( I i)const;

regards
Andy Little

[peter koch]

On 20 Aug., 14:24, Nikola <[e-mail]:

Hello,
I'm writing a String class for C++ and I'm getting the following error
message when using operator[]:

test.cpp: In function ‘int main()’:
test.cpp:7: error: ISO C++ says that these are ambiguous, even though
the worst conversion for the first is better than the worst conversion
for the second:
string.h:19: note: candidate 1: char Types::String::operator[](unsigned
int) const
test.cpp:7: note: candidate 2: operator[](char*, int) <built-in>

This is the declaration of the String class (implementation not included):

#ifndef _NIKOLA_STRING
#define _NIKOLA_STRING

namespace Types {
* class String {
* private:
* *char *_String;

* public:
* *String();
* *String(const char *Value);
* *String(const String &Source);
* *~String();

* *bool operator==(const String &Value);
* *String &operator=(const char *Value);
* *String &operator+=(const String &Value);
* *String &operator+=(char Value);
* *char operator[](unsigned int Index) const;
* *const String operator+(const String &Value) const;
* *const String operator+(char Value) const;
* *operator char*();

* *int Length() const;
* *String Trim() const;
* };

}

#endif

and this is how I'm using it:

#include "string.h"

using namespace Types;

int main() {
* String SomeString = "12345";
* char a = SomeString[1];
* return 0;

}

Clearly, I want to use my own overloaded operator[], however for some
reason the compiler (and standard) considers this ambiguous. What am I
doing wrong, i.e. how do I make the program use my overloaded
operator[], considering I DON'T want to dispose of my typecast operator
overload

operator char*();

Thanks,
Nikola

The problem is your operator char*. In the offending line the compiler
can either convert your Somestring to const and then call operator[].
Alternatively it can convert to char* using your user-supplied
operator and then use simple pointer-arithmetic to get the second
element.
A solution would be to also provide a non-const operator[], but it is
better to get rid of your operator char* which could be quite
dangerous in real code. Yes - I am aware that you don't want to do
that, but it is still a better idea ;-)

/Peter