help! confusing "const"?

[Luna Moon]

Hi all,

I just couldn't get myself clear about the usage of "const" in front
of and/or behind variables, pointers, classes, objects and
functions...

It's too confusing... any good clear article/tutorial that can help
me?

Thanks a lot!

 

[Christian Hackl]

I just couldn't get myself clear about the usage of "const" in front
of and/or behind variables, pointers, classes, objects and
functions...

It's too confusing... any good clear article/tutorial that can help
me?

http://www.parashift.com/c++-faq-lite/const-correctness.html

 

[Jim Langston]

Hi all,

I just couldn't get myself clear about the usage of "const" in front
of and/or behind variables, pointers, classes, objects and
functions...

It's too confusing... any good clear article/tutorial that can help
me?

Thanks a lot!

const just means "this isn't going to change." and what it's next to states
what isn't going to change.

const <type> Varname; Contents of VarName isn't going to change.
<type> const Varname; Same as above.
<type> const * Varname; Contents of Varname won't change.
<type> * const Varname; Where Varname points to won't change
<type> function() const; Used for classes, function will not change
anything for the class.
<type> function<const <type> Varname); Contents of local variable Vaname
will not change.

The easiest way is to read it from right to left. I.E.

const <type> Varname.
Read fom Varname to the left. "Varname is a <type> that is constant."
<type> const Varname
"Varname is a constant <type>" Same as above can be done either way.
<type> const * Varname; "Varname is a pointer to a constant <type>"
<type> * const Varname; "Varname is a constant pointer to <type>"

The only one I don't do this for is for a const on a function. I just know
it's a constant function.
<type> :Functionname( <type> parm ) const
That function doen't change anything about the class (not allowed to change
class variables)

 

[Eric Pruneau]

Hi all,

I just couldn't get myself clear about the usage of "const" in front
of and/or behind variables, pointers, classes, objects and
functions...

It's too confusing... any good clear article/tutorial that can help
me?

Thanks a lot!

int main()
{
int notConst = 1;

const int a1 = 0; // a constant integer
int const a2 = 0; // same as a1
a1++; // error a1 is const
a2++; // error a2 is const

const int& a3 = notConst;
int const& a4 = notConst;
notConst++; // Ok it is not const
a3++; // error a3 is const even if it is a reference to a non const
variable
a4 = a1; // error, a4 is just like a3

const int *a5 = &notConst; // pointer to a const value (notConst can be
changed but not via a5)
int const* a6 = &a1; // same as a5
// now it is getting interesting
*a5 = 45; // error trying to change the value a5 is pointing to
a5 = NULL; // ok the value a5 was pointing to is not changed.
a6 = &notConst; // ok a1 has not changed
*a6 = 7; // error notConst cannot be changed via a6

// same error here as with a3 and a4
const& int a7 = a3;
a7++; // error
a7 = a3; // error

// a8 is a const pointer to a non const int
int* const a8 = &a1; // error must point to a non const value
int* const a9 = &notConst; // ok
*a9 = 8; // ok, the pointer has not changed, only the value it point to
a9 = NULL; // error, trying to change the pointer

// const pointer to a const value
const int* const a10 = &notConst;
*a10 = 9; // error
int const* const a11 = &notConst; // same as a10
int const* const a12 = &a1;
a12 = NULL; // error
*a2 = 99; // error

return 0;
}

 

[Jerry Coffin]

[ ... ]

const just means "this isn't going to change." and what it's next to states
what isn't going to change.

Not really. It really means something close to 'read-only'. It's
possible (for example) to define a pointer to something that's both
const AND volatile, meaning this code won't change it, but something
else might. Even the "read-only" requires a few qualifications of its
own -- a const member function can't write to normal members of the
object on which it's invoked, but it can write to mutable members.

 

[James Kanze]

I just couldn't get myself clear about the usage of "const" in
front of and/or behind variables, pointers, classes, objects
and functions...

It's too confusing... any good clear article/tutorial that can
help me?

It's not really that complicated. The simplest rule when
writing code is that the const goes behind whatever it's
modifying. In a lot of cases, the language doesn't give you a
choice, so you might as well be consistent. (It also helps in
understanding the effects of const when typedef's are involved.)

Beyond that, const has two more or less distinct meanings. If
it applies to an object, it means that the object itself is
const, and any attempt to modify it is undefined behavior---the
compiler can put it in write only memory, or simply assume that
its value hasn't changed, for optimization purposes. (There is
one exception to this: mutable members of const class type
objects.)

The second involves the way const works in the type system: the
type "int const" is not the same type as "int", and there are
operations which are allowed on an expression of type "int", but
not on an expression of type "int const". As explained above,
if the expression denotes an actual object of the type const,
those operations result in undefined behavior, but of course, a
const type can appear in expressions even when no const object
is involved. Thus, the typename "int const*" refers to a
pointer to a const int, and "int *const" refers to a const
pointer to a (non-const) int: both declare an object of pointer
type, but in the case of the first, this object (the pointer) is
not const; the only role of the const here is in the type
system. The type system also has the concept of a const member
function; in this case, the const affects the type of the this
pointer, which becomes T const*, rather than T*.

Note too that when you define a class yourself, you can more or
less define what "const" means when applied to that class.
Thus, for example, std::vector defines const to mean that you
cannot modify the elements in the vector (or more correctly, the
elements in the vector are also "const", with whatever meaning
const has for them), even though they are separate "objects".