pointer vs reference

[Eric Kaplan]

what are the difference between the following 4 variables?

const int * start
int* const start
int const& start
Request(int const& start);

 

[Jim Langston]

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).

 

[Eric Kaplan]

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]

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)

 

[Jim Langston]

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.

 

[Eric Kaplan]

so start is a reference = memory address?

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

??

 

[Jim Langston]

so start is a reference = memory address?

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

??

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]

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.

 

[Eric Kaplan]

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";
}

 

[Erik Wikström]

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.

 

[James Kanze]

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.

 

[Matthias Buelow]

-- 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;

 

[Bo Persson]

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