pointer vs reference

Discussion in 'C++' started by Eric Kaplan, Apr 5, 2008.

  1. Eric Kaplan

    Eric Kaplan Guest

    what are the difference between the following 4 variables?

    const int * start
    int* const start
    int const& start
    Request(int const& start);
     
    Eric Kaplan, Apr 5, 2008
    #1
    1. Advertising

  2. Eric Kaplan

    Jim Langston Guest

    Eric Kaplan wrote:
    > what are the difference between the following 4 variables?


    Read right to left.

    > const int * start


    start is a pointer to an int that is constant (the int doesn't change).

    > int* const start


    start is a constant pointer to an int (the pointer doesn't change)

    > int const& start


    start is a reference to a constant int (the int doesn't change).

    > Request(int const& start);


    start is a reference to a constant int (the int doesn't change).

    --
    Jim Langston
     
    Jim Langston, Apr 5, 2008
    #2
    1. Advertising

  3. Eric Kaplan

    Eric Kaplan Guest

    more specific - for passing parameter, what's different between & OR *

    pointer vs reference ??

    Request(string const& start, string const& end);
    Request(string const* start, string const* end);
     
    Eric Kaplan, Apr 5, 2008
    #3
  4. Eric Kaplan

    Eric Kaplan Guest

    I suppose the following is exact same thing right?

    int * const start
    int const * start

    both means the pointer is constant - (pointer always point to same
    address)
     
    Eric Kaplan, Apr 5, 2008
    #4
  5. Eric Kaplan

    Jim Langston Guest

    Eric Kaplan wrote:
    > more specific - for passing parameter, what's different between & OR *
    >
    > pointer vs reference ??
    >
    > Request(string const& start, string const& end);
    > Request(string const* start, string const* end);


    A reference is an alias. It is similar to a pointer but with some changes.
    The most obvious is using a reference you don't have to dereference the
    variable to get the value.

    void Foo( int* Bax )
    {
    // To get the value of the integer we have to derefernce the pointer.
    std::cout << *Bax << "\n";
    }

    void Bar( int& Bax )
    {
    // The get the value of the integer we just use the variable
    std::cout << Bax << "\n";
    }

    There are other differences, such that a refernce must be initialized. It
    can not have an unitialized value. Nor can a reference be reseated. Once a
    reference is created it points to something, and will continue to point to
    that thing until it is destroyed/goes out of scope.

    int A = 10;
    int B = 20;
    int* Foo = &A;
    int& Bar = A;

    Foo = &B; // legal. Foo now points to B.
    Bar = B; // legal, but te value of A changed, not where Bar points.

    For any futher information I would suggest you read a book or search the
    web.




    --
    Jim Langston
     
    Jim Langston, Apr 5, 2008
    #5
  6. Eric Kaplan

    Eric Kaplan Guest

    so start is a reference = memory address?

    content of start is likely to be something like -
    0x12349870h

    ??

    >> int const& start

    >
    >start is a reference to a constant int (the int doesn't change).
     
    Eric Kaplan, Apr 5, 2008
    #6
  7. Eric Kaplan

    Jim Langston Guest

    Eric Kaplan wrote:
    > so start is a reference = memory address?
    >
    > content of start is likely to be something like -
    > 0x12349870h
    >
    > ??
    >
    >>> int const& start

    >>
    >> start is a reference to a constant int (the int doesn't change).


    A reference doesn't actually exist. A reference is an alias. The compiler
    is free to do that however it wishes. The compiler may actually use the
    original variable, or the address, or some other method. You shouldn't
    count on how the compiler does it as it may change from compiler to compiler
    and even from compiler version to version.

    --
    Jim Langston
     
    Jim Langston, Apr 5, 2008
    #7
  8. Eric Kaplan

    Jim Langston Guest

    Eric Kaplan wrote:
    > I suppose the following is exact same thing right?
    >
    > int * const start
    > int const * start
    >
    > both means the pointer is constant - (pointer always point to same
    > address)


    No. Those are not the same.
    const int* start;
    int const* start;
    are exactly the same.

    int* const start;
    start is a constant *pointer* to an int. You can not reseat the poniter.
    You can not change where the pointer is pointing to. In fact you better
    initialize it since you can't change it. But you can change the integer
    that the pointer points to.

    int const * start;
    start is a pointer to a constant *integer* You can not change the value of
    what the pointer points to, but you are free to make the pointer point to
    some other memory location.


    --
    Jim Langston
     
    Jim Langston, Apr 5, 2008
    #8
  9. Eric Kaplan

    Eric Kaplan Guest

    Is there are time where I should not use a pointer parameter or
    reference parameter?

    OR it's just a matter of my taste? both will do the same thing right??

    basically both doesn't pass a copy of value.

    ================

    void Foo( int* Bax )
    {
    // To get the value of the integer we have to derefernce the
    pointer.
    std::cout << *Bax << "\n";
    }

    void Bar( int& Bax )
    {
    // The get the value of the integer we just use the variable
    std::cout << Bax << "\n";
    }
     
    Eric Kaplan, Apr 5, 2008
    #9
  10. On 2008-04-05 03:46, Eric Kaplan wrote:
    > Is there are time where I should not use a pointer parameter or
    > reference parameter?
    >
    > OR it's just a matter of my taste? both will do the same thing right??
    >
    > basically both doesn't pass a copy of value.


    Right, so when you create a function you need to decide how to pass the
    arguments, the first choice is whether to pass by value or by reference
    (using either a reference or a pointer), and it seem like you know the
    difference already. If you decide to pass by reference you have to
    choose between references and pointers, my rule of thumb is to use
    references whenever I can and pointers only when I must (there are some
    things that can only be achieved by using pointers).

    Notice also that for small types (like the builtin once and other small
    classes) it might sometimes be faster to pass a const copy instead of a
    reference. If you need speed use a profiler and test which is the
    fastest in your case.

    --
    Erik Wikström
     
    Erik Wikström, Apr 5, 2008
    #10
  11. Eric Kaplan

    James Kanze Guest

    On 5 avr, 02:33, "Jim Langston" <> wrote:
    > Eric Kaplan wrote:
    > > more specific - for passing parameter, what's different
    > > between & OR *


    > > pointer vs reference ??


    > > Request(string const& start, string const& end);
    > > Request(string const* start, string const* end);


    > A reference is an alias. It is similar to a pointer but with
    > some changes.


    [...]

    Good posting, but you missed the two most obvious differences
    from the user's point of view (and thus, to take into
    consideration when designing the interface):

    -- A reference cannot be null; it must designate an actual
    object. If you want an optional value, you'll have to use a
    pointer.

    -- A pointer cannot be initialized to point to a temporary. If
    you want your client to be able to pass the results of an
    arbitrary expression, then you must use a reference to
    const.

    Because of these considerations, from a user's point of view, a
    reference to a const is actually more like pass by value than a
    pointer, i.e. given:

    void func1( std::string ) ;
    void func2( std::string const& ) ;
    void func3( std::string const* ) ;

    , there is almost no difference between the first two for the
    user; it is the third that is different.

    --
    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, Apr 5, 2008
    #11
  12. James Kanze wrote:

    > -- A reference cannot be null; it must designate an actual
    > object. If you want an optional value, you'll have to use a
    > pointer.


    What about: int &r = *(int *)0;
     
    Matthias Buelow, Apr 7, 2008
    #12
  13. Eric Kaplan

    Bo Persson Guest

    Matthias Buelow wrote:
    > James Kanze wrote:
    >
    >> -- A reference cannot be null; it must designate an actual
    >> object. If you want an optional value, you'll have to use a
    >> pointer.

    >
    > What about: int &r = *(int *)0;


    No, that is invalid. As soon as you dereference a null pointer, your
    code has undefined behavior. This happens before you get a reference
    to null.


    Bo Persson
     
    Bo Persson, Apr 7, 2008
    #13
    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. sam pal
    Replies:
    3
    Views:
    567
    E. Robert Tisdale
    Jul 16, 2003
  2. Replies:
    10
    Views:
    717
    Chris Torek
    Feb 4, 2005
  3. Replies:
    4
    Views:
    405
    Andre Kostur
    Dec 24, 2007
  4. mathieu
    Replies:
    8
    Views:
    518
    Juha Nieminen
    Aug 31, 2008
  5. A
    Replies:
    7
    Views:
    644
Loading...

Share This Page