By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
432,175 Members | 1,710 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 432,175 IT Pros & Developers. It's quick & easy.

help! confusing "const"?

P: n/a
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!
Jul 6 '08 #1
Share this Question
Share on Google+
7 Replies


P: n/a
Luna Moon wrote:
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-lit...rrectness.html
--
Christian Hackl
Jul 6 '08 #2

P: n/a

"Luna Moon" <lu**********@gmail.comwrote in message
news:22**********************************@x41g2000 hsb.googlegroups.com...
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
What you're calling 'variables, pointers, and objects' are
all known as 'objects' in C++. Any object can be made const
or not. THere's no such thing as a const function (however
there can be a const pointer to a function.

A 'class' is just another name for 'type'. Keep the above
in mind when reading the link I cite below.
functions...

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

Thanks a lot!
http://www.timfanelli.com/item/26

-Mike
Jul 6 '08 #3

P: n/a

"Mike Wahler" <mk******@mkwahler.netwrote in message
news:kN******************************@earthlink.co m...
all known as 'objects' in C++. Any object can be made const
or not. THere's no such thing as a const function (however
there can be a const pointer to a function.
I misspoke. There is indeed a construct known as a 'const
member function'. Its declaration takes the form:

T func() const;

This indicates that the function will not modify the
state of the object for which it was invoked. An
attempt to do so should cause a compiler diagnostic.
-Mike
Jul 6 '08 #4

P: n/a
"Luna Moon" <lu**********@gmail.comwrote in message
news:22**********************************@x41g2000 hsb.googlegroups.com...
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 <typeVarname; Contents of VarName isn't going to change.
<typeconst Varname; Same as above.
<typeconst * Varname; Contents of Varname won't change.
<type* const Varname; Where Varname points to won't change
<typefunction() const; Used for classes, function will not change
anything for the class.
<typefunction<const <typeVarname); Contents of local variable Vaname
will not change.

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

const <typeVarname.
Read fom Varname to the left. "Varname is a <typethat is constant."
<typeconst Varname
"Varname is a constant <type>" Same as above can be done either way.
<typeconst * 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( <typeparm ) const
That function doen't change anything about the class (not allowed to change
class variables)

Jul 6 '08 #5

P: n/a

"Luna Moon" <lu**********@gmail.coma écrit dans le message de news:
22**********************************...oglegroups.com...
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;
}
Jul 6 '08 #6

P: n/a
In article <xI***************@newsfe05.lga>, ta*******@rocketmail.com
says...

[ ... ]
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.

--
Later,
Jerry.

The universe is a figment of its own imagination.
Jul 6 '08 #7

P: n/a
On Jul 6, 8:15 pm, Luna Moon <lunamoonm...@gmail.comwrote:
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".

--
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, +33 (0)1 30 23 00 34
Jul 7 '08 #8

This discussion thread is closed

Replies have been disabled for this discussion.