«

Hi,

Is it considered bad form to have the subscript operator return a
const reference variable? If not, what is the proper way to do it?
My question was prompted by the code below, my problematic attempt to
implement a subscript operator that returns a const reference. The
dubious code is marked at the end.

<code>

//MyClass is a large class we don't want to copy alot
//MyClass has a "char getChar()" function
class MyClass;

class SubscriptTest {
private:
std::vector<MyClass> _vect;
public:
SubscriptTest() {};
void addObj(MyClass mc) {_vect.push_back(mc);}
const MyClass& operator[] (char ch) const {return
lookUpByChar(ch);}
};

const MyClass& SubscriptTest::lookUpByChar(char ch) const {
for (unsigned i=0; i<_vect.size(); i++) {
if (_vect[i].getChar() == ch)
return i;
}

//PROBLEM IS HERE
return *(new MyClass); //return value here needed to compile
}

</code>

The problem is what to return when the lookup fails. Creating a
default value via new, as I do above, seems wrong -- it wastes memory
and requires tracking the objects created and then destroying them in
Subscript's destructor.

Another option would be to create the default value as static variable
inside the lookUpByChar function or as a member variable of
SubscriptTest, and have the function always return a reference to
that. That seems reasonable to me, but I still wasn't sure.

Does anyone have any thoughts/suggestions?

Thanks,
cpp

cppaddict wrote:

> Hi,
>
> Is it considered bad form to have the subscript operator return a
> const reference variable?

No, not for the const version of it. It's actually the preferred way.

> If not, what is the proper way to do it?
> My question was prompted by the code below, my problematic attempt to
> implement a subscript operator that returns a const reference. The
> dubious code is marked at the end.
>
> <code>
>
> //MyClass is a large class we don't want to copy alot
> //MyClass has a "char getChar()" function
> class MyClass;
>
> class SubscriptTest {
> private:
> std::vector<MyClass> _vect;
> public:
> SubscriptTest() {};
> void addObj(MyClass mc) {_vect.push_back(mc);}
> const MyClass& operator[] (char ch) const {return
> lookUpByChar(ch);}
> };
>
> const MyClass& SubscriptTest::lookUpByChar(char ch) const {
> for (unsigned i=0; i<_vect.size(); i++) {
> if (_vect[i].getChar() == ch)
> return i;
> }
>
> //PROBLEM IS HERE
> return *(new MyClass); //return value here needed to compile
> }
>
> </code>
>
> The problem is what to return when the lookup fails. Creating a
> default value via new, as I do above, seems wrong -- it wastes memory
> and requires tracking the objects created and then destroying them in
> Subscript's destructor.
>
> Another option would be to create the default value as static variable
> inside the lookUpByChar function or as a member variable of
> SubscriptTest, and have the function always return a reference to
> that. That seems reasonable to me, but I still wasn't sure.
>
> Does anyone have any thoughts/suggestions?

Throw an exception.

>> Does anyone have any thoughts/suggestions?
>
>Throw an exception.

Rolf,

Doesn't the compiler require a return statement no matter what? It
seems to for me. Am I missing something?

Thanks,
cpp

cppaddict wrote:

>
>>> Does anyone have any thoughts/suggestions?
>>
>>Throw an exception.
>
> Rolf,
>
> Doesn't the compiler require a return statement no matter what?

Not if that code path can't be reached anyway. Actually, my compiler.
You could just write:

const MyClass& SubscriptTest::lookUpByChar(char ch) const {
********for (unsigned i=0; i<_vect.size(); i++) {
****************if (_vect[i].getChar() == ch)
************************return i;
********}
********
throw SomeException("character not found");
********return MyClass(); //shut the compiler up
}

Yes, this would mean reuturning a reference to a temporary, but since
it's never actually reached, it doesn't hurt.

Rolf Magnus wrote:

> Not if that code path can't be reached anyway. Actually, my compiler.

Insert "gives a warning if there is a return statement that can never be
reached" at a place of your choice.

In article <>,
cppaddict <> wrote:

>Hi,
>
>Is it considered bad form to have the subscript operator return a
>const reference variable? If not, what is the proper way to do it?
>My question was prompted by the code below, my problematic attempt to
>implement a subscript operator that returns a const reference. The
>dubious code is marked at the end.
>
><code>
>
>//MyClass is a large class we don't want to copy alot
>//MyClass has a "char getChar()" function
>class MyClass;
>
>class SubscriptTest {
> private:
> std::vector<MyClass> _vect;
> public:
> SubscriptTest() {};
> void addObj(MyClass mc) {_vect.push_back(mc);}
> const MyClass& operator[] (char ch) const {return
>lookUpByChar(ch);}
>};
>
>const MyClass& SubscriptTest::lookUpByChar(char ch) const {
> for (unsigned i=0; i<_vect.size(); i++) {
> if (_vect[i].getChar() == ch)
> return i;
> }
>
> //PROBLEM IS HERE
> return *(new MyClass); //return value here needed to compile
>}
>
></code>
>
>The problem is what to return when the lookup fails. Creating a
>default value via new, as I do above, seems wrong -- it wastes memory
>and requires tracking the objects created and then destroying them in
>Subscript's destructor.
>
>Another option would be to create the default value as static variable
>inside the lookUpByChar function or as a member variable of
>SubscriptTest, and have the function always return a reference to
>that. That seems reasonable to me, but I still wasn't sure.
>
>Does anyone have any thoughts/suggestions?

The const version and the non-const version of op[] should do the same
thing if the item isn't in the container.

You have a few choices, declare the behavior undefined (thats how op[]
is defined in vector,) insert an element (the way op[] works in map,) or
throw an exception (like vector::at does.)

What is best for the code that uses your container?

"Rolf Magnus" <> wrote in message
news:cac1un$jgs$02$...

> throw SomeException("character not found");
> return MyClass(); //shut the compiler up
> }

> Yes, this would mean reuturning a reference to a temporary, but
since
> it's never actually reached, it doesn't hurt.

Isn't there a #pragma to disable specific warnings for one or more
instances/lines? I've never used pragma, but this might be a good
place for it, if that's how it's used.

Rolf Magnus wrote:

> cppaddict wrote:
>
>> Hi,
>>
>> Is it considered bad form to have the subscript operator return a
>> const reference variable?
>
> No, not for the const version of it. It's actually the preferred way.

This is rather arguable and senseless outside a context.

There is a rule of thumb: when in doubt do what built-in types do. Consider the operator[]'s behavior applied to a pointer - it always returns a pointee type reference, no matter whether the pointer itself is cv-qualified or not.

char c(0);
char* p1 = &c; // non-const pointer, non-const pointee
char* const p2 = &c; // const pointer, non-const pointee

char& r1 = *p1;
char& r2 = *p2;

--
Maxim Yegorushkin

>The const version and the non-const version of op[] should do the same
>thing if the item isn't in the container.

In my case, wouldn't it violate encapsulation to have a non-const
version? Essentially, that would be returning a refernece to private
data.

>You have a few choices, declare the behavior undefined (thats how op[]
>is defined in vector,)

How do you declare behaviour as undefined?

Thanks,
cpp

>This is rather arguable and senseless outside a context.
>
>There is a rule of thumb: when in doubt do what built-in types do. Consider the operator[]'s behavior applied to a pointer - it always returns a pointee type reference, no matter whether the pointer itself is cv-qualified or not.
>
>char c(0);
>char* p1 = &c; // non-const pointer, non-const pointee
>char* const p2 = &c; // const pointer, non-const pointee
>
>char& r1 = *p1;
>char& r2 = *p2;

Maxim,

It's not clear to me what point you are trying to make or what advice
you are trying to give with this example. Could you please explain?

Thanks,
cpp