What is a reference in C?

I have just started C++ and have come across references and have not understood completely.

References , as i read is an alternative name for an object.Why use that instead of directly acce开发者_开发问答ssing the object as any operation on references is directly reflected on the object ...?

1. Why and when are they used ?
2. Is ist like a constant pointer that is referenced each time it is used ... ?

And , it says

 double& dr = 1;  ----  says it is an error (some lavalue needed) 
 const double& cdr = 1;  ---- says it is ok. 

i dont understand it properly..So please explain why it is so ...

Thank You...:)

---

Why use that instead of directly accessing the object as any operation on references is directly reflected on the object ...?

C++ passes parameters by value, meaning if you have a function such as:

void foo(MyObject o) { ... }

By default C++ will make a copy of a MyObject, not directly use the object being passed in. So, one use of references is to ensure you are working on the same object:

void foo(MyObject &o) { ...}

Or, if you aren't modifying o:

void foo(const MyObject &o) { ... }

---

References are another way of what was originally in C code like this

void fubarSquare(int *x){
  int y = *x;
  *x = y * y;
}

// typical invocation
int z = 2;
fubarSquare(&z);
// now z is 4

with references in C++ it would be like this

void fubarSquareCpp(int& x){
   x = x * x;
}

// typical invocation
int z = 2;
fubarSquareCpp(z);
// now z is 4

It's a neater syntactical way of using a call-by-reference parameter instead of using the C's notation asterisk/star to indicate a pointer and as a call-by-reference parameter...and modifying the parameter directly outside of the function...

Have a look at Bjarne Stoustrap's page here which covers how C++ is and also here on the technical faq here

---

A reference is basically a pointer that looks like an object. It is very very hard to get a NULL reference though you can go through hoops and create one.

With regards to your example, 1 is an rvalue or a result. It is just a temporary variable and can not be modified. Thus you can't take a non const reference to it. However you can take a const reference to it. This means you can't change the value of the reference.

Here is an example of creating a NULL reference. Don't do it!

int * x = (int *)NULL;
int & y = *x;

---

I agree with you. using references as just an alias name is not very useful. It is more useful if you consider it as an immutable pointer. But not that useful in fact.

Practically, it is used to define clean interfaces. For example when you define:

int foo(const int& param);

You say that param is a read-only parameter in foo.

Do not forget that you MUST assign a value to a reference.

See the C++ faqlite on references for more

my2c

---

References improve the syntax, so no pointer dereference needed. Assuming Base is a class that may be derived from:

void someFunction(Base b)
{
    b.function();
    // b is a copy of what was passed - probably performance issues
    // possible unintended object slicing - you only get the Base part of it
    // no virtual function call
    // no changes to b visible outside the function
}

void someFunction(Base* b)
{
    b->function();
    // a shortcut for (*b).function();
    // b is the same object that was passed to the function
    // possible virtual call
    // changes visible outside the function
}

void someFunction(Base& b)
{
    b.function();
    // b is the same object that was passed to the function
    // possible virtual call
    // changes visible outside the function
}

References are like constant pointers (NOT pointers to constants - i.e. you can change the object, but you can't change to what you're pointing). const reference is a reference through which you can do things that can be done on const object.

References are also good, because you can't have a null reference

---

Give the wikipedia article a good read through. To sum it up, references are more friendly version of pointers which are commonly used to pass objects as references into functions without worrying about a null pointer.

To explain the example:

---

Think of the number 1 represented as a variable. When compiled, this number is put into the global section of the memory which can be referenced by the program, but not modified.

So it is of type: const int

double &dr = 1 is trying to assign dr (a reference to a double) to the const int 1. Since 1 is a constant, the compiler will not allow you to make a non-constant reference to it.

In the second line:

const double &dr = 1 is trying to assign dr (a constant reference to a double) the const int 1. This works because the reference is also const and therefore can point to a const int.

EDIT The const int is converted to a const double before assigned.

---

References are language entitities that represent another object they refer to. Nonconst references are lvalues, and must be initialized with an lvalue. They can be useful like this:

int& x=condition ? array[1] : array[2];
int& y=condition ? array[0] : array[3];
x+=y;
y=0;

When used as a function parameter, they tell the caller he has to pass an lvalue that might be written to by the function:

void set1(int& x) { x=1; }

int foo;
set1(foo); // ok, foo is 1
set1(foo+1); // not OK, not lvalue

Const references, on the other hand, can be bound to rvalues. In function parameters, they are usually used to avoid excessive copies:

void niceness(std::string s); // the string would be copied by its copy-ctor
void niceness(const std::string& s); // the caller's string would be used

Note that this may or may not yield faster code.

When const-references are used in normal code, they can bind rvalues, too, and as a special rule, they extend the lifetime of the object they are bound to. This is what you saw in your code:

const double& d=1; // OK, bind a rvalue to a const-ref
double& d=1; // Bad, need lvalue

All references are polymorphic, like pointers:

class A { virtual void f(); }
class B : public A { void f(); }

B b;
A& ar=b;
ar.f(); // calls B::f()

and all references are aliases like pointers:

int f(int& a, const int& b)
{
  a=1;
  return b;
}

int x;
f(x, 42); // ==42, foo=1
x=42;
f(x, x); // ==1 (not 42), foo=1

---

double& dr = 1; // 1.0 would be more clear

Is invalid because 1 is viewed to be of type const double so if you want a reference to that variable you need to have a reference to a const double so

const double& dr = 1.0;

Is correct.

---

Utility of references is most visible in the context of passing parameters to functions.

I.e,

int a;

func definition: void foo (int& param) {param = 1;}

func call: foo(a);

The way as 'param' aliases 'a' is clean and its intention is easily understood by a reader of this code as well as compiler that may optimize away when inlining any additional memory allocation needed for the reference.

---

Passing a reference to a function and then having the function use the reference is almost like passing a pointer to the function and then having the function dereference the pointer. In many cases, the machine-code implementation will be identical. There are some differences, though, especially in the case of functions that get expanded inline. If a variable is passed by reference to an inline function, the compiler will often be able to substitute the variable itself--even if stored in a machine register--when expanding the function. By contrast, if one takes the address of a variable and passes that as a pointer to a function which then dereferences it, the compiler is less likely to figure out that optimization unless it determines not only that--at least for one particular expansion of the function--the pointer will always point to that variable, but also that the pointer will not be used anywhere else (if the pointer was used elsewhere, the variable could not be kept in a register).