Question about operator overloading

[Rafael Anschau]

In this case, how does the compiler knows which to run, given
that both operators receive the same parameter ?
class String
{
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;

//Which one gets runed ? If not based on parameters then based on
what ?
};

Thanks

[Kai-Uwe Bux]

Rafael Anschau wrote:

In this case, how does the compiler knows which to run, given
that both operators receive the same parameter ?
class String
{
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;

//Which one gets runed ? If not based on parameters then based on
what ?

In the expression str[index], index is a visible parameter to operator[],
but str also enters the picture. If str is a const object, then the const
member function will be chosen; and if str is non-const, the non-const
member function will be chosen.
Best

Kai-Uwe Bux

[ltcmelo]

On May 15, 5:35*pm, Rafael Anschau <[e-mail]:

In this case, how does the compiler knows which to run, given
that both operators receive the same parameter ?

class String
*{
* // overloaded operators
*char & operator[](int offset);
*char operator[](int offset) const;

//Which one gets runed ? If not based on parameters then based on
what ?

};

Hi.

If you apply the operator[] on a constant String, the compiler will
automatically select the const version of it. This could happen, for
example, in a function like the one below:

void doSomething(const String& s)
{
//Here, the const version of operator[] would be chosen.
}

As an additional note, you could write the const version of your
operator like this:

class String
{
//...
const char& operator[](int offset) const;
};
--
Leandro T. C. Melo

[Rafael Anschau]

Interesting, the only semantic description I have for const(after
a method) is that it doesn´t change the object´s member data. Are
there other places where const may have other meanings(aside from data
types
like "const int a=10;" etc, and operators) ?

Thanks,

Rafael

[lunar_lty]

On May 16, 4:35*am, Rafael Anschau <[e-mail]:

In this case, how does the compiler knows which to run, given
that both operators receive the same parameter ?

class String
*{
* // overloaded operators
*char & operator[](int offset);
*char operator[](int offset) const;

//Which one gets runed ? If not based on parameters then based on
what ?

};

Thanks

The compiler will do the corrent thing for you.
Augument liks this :
String s("aa");
char c = s[0]; // call char operator[](int offset) const;
s[0] = 'c'; // call char & operator[](int offset);

That is the difference you want.

[Stuart Golodetz]

lunar_lty wrote:

On May 16, 4:35 am, Rafael Anschau <[e-mail]:

>In this case, how does the compiler knows which to run, given
that both operators receive the same parameter ?

class String
{
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;

//Which one gets runed ? If not based on parameters then based on
what ?

};

Thanks

The compiler will do the corrent thing for you.
Augument liks this :
String s("aa");
char c = s[0]; // call char operator[](int offset) const;
s[0] = 'c'; // call char & operator[](int offset);

That is the difference you want.

Actually they both call the non-const version in your example. Consider
the following analogous program:

#include <iostream>

struct S
{
char c;

S(char c_) : c(c_) {}

char& operator()()
{
std::cout << "non-const" << std::endl;
return c;
}

char operator()() const
{
std::cout << "const" << std::endl;
return c;
}
};

int main()
{
S s('a');
char c = s();
s() = 'b';
const S& cs = s;
std::cout << cs() << std::endl;

return 0;
}

This prints:

non-const
non-const
const
b

In other words, the first call is to the non-const operator() - not the
const one as you suggested. It's the constness (or otherwise) of the
instance of S which is determining which method/operator gets called. In
the case of cs, it's a reference to a const S, so only const methods of
S can be called on it.

Regards,
Stu

[James Kanze]

On 16 mai, 16:17, Rafael Anschau <[e-mail]:

Interesting, the only semantic description I have for const(after
a method) is that it doesn´t change the object´s member data. Are
there other places where const may have other meanings(aside from data
types like "const int a=10;" etc, and operators) ?

const is part of the type system, and plays a defined role
anywhere types are significant.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]