Fun with const

[Alex Buell]

Consider:

const bool func() {}

and

bool func() const {}

Are they different?
--
http://www.munted.org.uk

Take a nap, it saves lives.

[Vector]

Yes

First one is function returning constant bool and the second one is
constant member function.

[Tomás]

Alex Buell posted:

const bool func() {}

This may or may not be a member function -- the code snippet is too small
to tell.

The function takes no arguments.

The function returns a const bool by value.
bool func() const {}

This is a const member function.

The function takes no arguments.

The function returns a bool by value.

Are they different?

I presume you're alluding to the difference between:

int SomeFunc();

int const SomeFunc();
To my knowledge, there's no discernable difference if you're dealing with
a primitive type -- however there certainly is a difference when dealing
with a fancy class type:
int main()
{
SomeFunc().SomeNonConstMemberFunction();

/* Above line won't work if const object
is returned by value. */
}

-Tomás

[Luke Meyers]

Tomás wrote:

I presume you're alluding to the difference between:

int SomeFunc();

int const SomeFunc();

To my knowledge, there's no discernable difference if you're dealing with
a primitive type

In the latter case, the return value cannot be used as an lvalue.
There's generally no reason to *want* to use it as an lvalue, so it's
often good to make return-by-value types const to prevent accidents.

One other point -- these two functions do not have different
signatures.

Luke

[Rolf Magnus]

Luke Meyers wrote:

Tomás wrote:

I presume you're alluding to the difference between:

int SomeFunc();

int const SomeFunc();

To my knowledge, there's no discernable difference if you're dealing with
a primitive type

In the latter case, the return value cannot be used as an lvalue.
There's generally no reason to *want* to use it as an lvalue,

std::auto_ptr<MyClass> createObject();

[Tomás]

Luke Meyers posted:

Tomás wrote:

I presume you're alluding to the difference between:

int SomeFunc();

int const SomeFunc();

To my knowledge, there's no discernable difference if you're dealing
with a primitive type

In the latter case, the return value cannot be used as an lvalue.
There's generally no reason to *want* to use it as an lvalue, so it's
often good to make return-by-value types const to prevent accidents.

You worded that paragraph as if the opposite was true for the version
whose return value isn't const.

Neither of them can be used as an L-value:

int ReturnModifiableByValue();
int const ReturnConstByValue();

int main()
{
ReturnModifiableByValue() = 7; /* ERROR */

ReturnConstByValue() = 3;
}
-Tomás

[Luke Meyers]

Tomás wrote:

Luke Meyers posted:

In the latter case, the return value cannot be used as an lvalue.
There's generally no reason to *want* to use it as an lvalue, so it's
often good to make return-by-value types const to prevent accidents.

You worded that paragraph as if the opposite was true for the version
whose return value isn't const.

Neither of them can be used as an L-value:

This falls under the category of "could swear I heard that somewhere,
can't remember the cite, and should have confirmed it before posting."
Thanks.

Luke