How is a reference different from a pointer in implementation? [duplicate]

Answer 1

C++ references are largely a syntactic mechanism.

Consider

int x;
int &y = x;
int *z = &x;

The expression (*z) is the same thing as (y).

Aside from saving you typing a few characters, the only language thing going on here is that as reference cannot be null.

Answer 2

Most references are implemented using a pointer variable i.e. a reference usually takes up one word of memory. However, a reference that is used purely locally can - and often is - eliminated by the optimizer. For example:

  struct S { int a, int b[100]; };  
  void do_something(const vector<S>& v)
  {
    for (int i=0; i<v.size(); ++i) {
        int*& p = v[i].b;
          for (int j=0; j<100; ++j) cout <<p[j];
  }

In this case, p needs not be stored in memory (maybe it just exists in a register, maybe it disappears into the instructions).

Answer 3

References are just good for you as a C++ programmer. The compiler implements references as pointers anyway so it doesn't care if you use a pointer or a reference.

References is, like you said, better than pointers in many cases because they protect the callee from bad input (bad pointers often results in seg faults) and you can also set them to const, which provides better protection from changes than setting a pointer to const.

Answer 4

One example where reference ought to be used instead of pointers:

enum day
{
    Mon, Tue, Wed, Thu, Fri, Sat, Sun
};

day d;

day *operator++(day *d);

The operator ++ can be invoked using ++&d, which does not look that intuitive.

One big catch here is that all overloaded operator functions must either be a member of a class, or have a parameter of type T, T &, or T const &, where T is a class or enumeration type. So, in this case day *operator++(day *d); won't even compile.

It works fine using reference i.e.

day &operator++(day &d);

which can be invoked simply as ++d;

Here is a nice article from where I got this example.

cheers

Answer 5

Use references when you can, and pointers when you need to. Reasons you'd need to use a pointer:

1. There might not be an object for it to point at (null pointer, no null references).
2. You might need to refer to different objects during its lifetime.
3. You might need to refer to a whole array of objects (but std::vector is usually better).

There are, however, cases where the usage of the two doesn't really overlap at all, and you simply can't substitute one for the other. For one obvious example, consider the following code:

template <class T, size_t N>
size_t size(T(&matrix)[N]) {
    return N;
}

This allows you to find the size of an array:

int array1[some_size];
int array2[some_other_size];

size_t n = size(array1);  // retrieves `some_size`
size_t m = size(array2);  // retrieves `some_other_size`

...but it simply won't compile if you try to pass a pointer to it:

int *x = new int[some_size];

size_t n = size(x);    // won't compile

At very best it seems to make little sense to write the code to receive a pointer when part of its point is to reject being passed a pointer.

Answer 6

References are pointers in disguise, or at least that's a safe way to think of them.

One reason for them is because C and C++ don't have "var" parameters, as in Pascal etc. Using a reference gives you something very close to that, but unlike "var", it can also be used elsewhere - e.g. to give you a quick shorthand for something else...

int& alias = thing.blah [foo]->bar;
handle (alias, alias+1, alias*2);

References are also returned by a lot of functions, meaning the "result" of the function can be written to as well as read, as in...

std::deque<int>  mydeque;
mydeque.push_back (1);
mydeque.back () += 1;  //  increment the top item on the stack

The same functionality could be achieved using a pointer, but a reference is more convenient. The usual term is "syntactic sugar".

A useful (but not completely reliable) fact about references is that you're less likely to accidentally change the underlying pointer, since it takes a bit of work to access that pointer rather than the pointed-to value. This is a helpful hint to choosing - use the one that creates the least clutter in your code.