subscript overloading

[josh]

Hi I've a dubt!

when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????

int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // reference return
}

const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // const reference return
}

 

[=?iso-8859-1?q?Erik_Wikstr=F6m?=]

Hi I've a dubt!

when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????

int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // reference return

}

const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // const reference return

}

The const version is used when the object who's function/operator is
called. Consider the following two functions:

void foo(Array& a) {
int i = a[0]; // Non-const used
}

void bar(const Array& a)
int i = a[0]; // Const used
}

 

[=?iso-8859-1?q?Erik_Wikstr=F6m?=]

Hi I've a dubt!

when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????

int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // reference return

}

const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );

return ptr[ subscript ]; // const reference return

}

The const version is used when the object who's function/operator is
called. Consider the following two functions:

What I meant was that "The const version is used when the object who's
function/operator is called is const."

 

[josh]

Hi I've a dubt!
when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????
int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // reference return
}
const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // const reference return
}

The const version is used when the object who's function/operator is
called. Consider the following two functions:

What I meant was that "The const version is used when the object who's
function/operator is called is const."

Ok I understand that but in my code I have:

Array integers1( 7 ); // non const

// use overloaded subscript operator to create rvalue
cout << "integers1[5] is " << integers1[ 5 ] << '\n';

// use overloaded subscript operator to create lvalue
cout << "Assigning 1000 to integers1[5]\n";
integers1[ 5 ] = 1000;

so integers1 is not declared as const and then how the compiler can
know
what must be used?

 

[Fei Liu]

Hi I've a dubt!
when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????
int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // reference return
}
const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // const reference return
}
The const version is used when the object who's function/operator is
called. Consider the following two functions:

What I meant was that "The const version is used when the object who's
function/operator is called is const."

Ok I understand that but in my code I have:

Array integers1( 7 ); // non const

// use overloaded subscript operator to create rvalue
cout << "integers1[5] is " << integers1[ 5 ] << '\n';

// use overloaded subscript operator to create lvalue
cout << "Assigning 1000 to integers1[5]\n";
integers1[ 5 ] = 1000;

so integers1 is not declared as const and then how the compiler can
know
what must be used?

cout << integers1[5] is translated to:
function prototype: template <typename T>
std:stream & operator << (std:stream & os, const T & t);

std:stream & operator<< <int>(std:stream &, const int & integers1[5]);

Fei

 

[Fei Liu]

On Feb 16, 11:34 am, "Erik Wikström" <[email protected]>
wrote:



Hi I've a dubt!
when we have overloaded functions the compiler chooses the right
being based on the argument lists...but when we have two subscript
overloaded functions it resolves them being based on the const type.
Infact if I use the Array on the left side i.e like a1[2] = 111
then it uses the first while if I use cout << a1[2] it uses the
second...
why????
int &Array:perator[]( int subscript )
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // reference return
}
const int &Array:perator[]( int subscript ) const
{
// check for subscript out of range error
assert( 0 <= subscript && subscript < size );
return ptr[ subscript ]; // const reference return
}
The const version is used when the object who's function/operator is
called. Consider the following two functions:
What I meant was that "The const version is used when the object who's
function/operator is called is const."

Ok I understand that but in my code I have:

Array integers1( 7 ); // non const

// use overloaded subscript operator to create rvalue
cout << "integers1[5] is " << integers1[ 5 ] << '\n';

// use overloaded subscript operator to create lvalue
cout << "Assigning 1000 to integers1[5]\n";
integers1[ 5 ] = 1000;

so integers1 is not declared as const and then how the compiler can
know
what must be used?

cout << integers1[5] is translated to:
function prototype: template <typename T>
std:stream & operator << (std:stream & os, const T & t);

std:stream & operator<< <int>(std:stream &, const int & integers1[5]);

Fei

Check attached example to understand what's going on beneath the hood:

#include <iostream>
#include <string>
namespace intrinsic{
template <typename T>
std:stream & operator << (std:stream & os, const T & x){
return os << x;
}
}
namespace composite{
template <typename T>
std:stream & operator << (std:stream & os, const T & x){
return std:perator << (os, x);
}
}

int main(){

int x = 3;
intrinsic:perator << (std::cout, x);
intrinsic:perator << <int>(std::cout, x);
composite:perator << <std::string>(std::cout, "hello, world");
std::string y = "Hello, world";
composite:perator << (std::cout, y);
}

 

[Marcus Kwok]

Ok I understand that but in my code I have:

Array integers1( 7 ); // non const

// use overloaded subscript operator to create rvalue
cout << "integers1[5] is " << integers1[ 5 ] << '\n';

// use overloaded subscript operator to create lvalue
cout << "Assigning 1000 to integers1[5]\n";
integers1[ 5 ] = 1000;

so integers1 is not declared as const and then how the compiler can
know
what must be used?

In both cases, the non-const version will be called, since the original
integers1 object is non-const.

To check, you could add an output statement (e.g., cout << "non-const";
or cout << "const" to both of the subscript operators to verify which
one is called.