help! confusing "const"?

Discussion in 'C++' started by Luna Moon, Jul 6, 2008.

  1. Luna Moon

    Luna Moon Guest

    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!
    Luna Moon, Jul 6, 2008
    #1
    1. Advertising

  2. 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-lite/const-correctness.html


    --
    Christian Hackl
    Christian Hackl, Jul 6, 2008
    #2
    1. Advertising

  3. Luna Moon

    Jim Langston Guest

    "Luna Moon" <> wrote in message
    news:...
    > 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)
    Jim Langston, Jul 6, 2008
    #3
  4. Luna Moon

    Eric Pruneau Guest

    "Luna Moon" <> a écrit dans le message de news:
    ...
    > 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;
    }
    Eric Pruneau, Jul 6, 2008
    #4
  5. Luna Moon

    Jerry Coffin Guest

    In article <xI8ck.535$>,
    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.
    Jerry Coffin, Jul 6, 2008
    #5
  6. Luna Moon

    James Kanze Guest

    On Jul 6, 8:15 pm, 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?


    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:
    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
    James Kanze, Jul 7, 2008
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Replies:
    11
    Views:
    1,099
  2. Javier
    Replies:
    2
    Views:
    559
    James Kanze
    Sep 4, 2007
  3. 0m
    Replies:
    26
    Views:
    1,111
    Tim Rentsch
    Nov 10, 2008
  4. fungus
    Replies:
    13
    Views:
    886
    fungus
    Oct 31, 2008
  5. Replies:
    2
    Views:
    540
    Andrew Koenig
    Feb 9, 2009
Loading...

Share This Page