Pointers and Reference looks similar but there are some difference between both of them. POINTER Its not necessary to initialize the pointer at the time of declaration. Like Code: int a = 10; int *P = &a; //It is not necessary Another way is : Code: int a = 10; int *P; P = &a; You can create the array of Pointer. You can assign NULL to the pointer like Code: int *P = NULL; //Valid You can use pointer to pointer. REFERENCE Its necessary to initialize the Reference at the time of declaration. Like Code: int &a = 10; int &a; //Error here but not in case of Pointer. You can not create the Array of reference. You can not assign NULL to the reference like Code: int &a = NULL; //Error You can not use reference to reference.
good one.....but what would you say if i write in .NET or even in JAVA FileStream fs; // (or using any other class) What is FileStream -> a pointer or a reference ? Can you elaborate it for other platforms ?
Reference is the other name given to the same variable. Pointer is new variable created which can contain address of another variable. Try an experiment Code: # include<iostream> using namespace std; int main() { int i = 90; // variable int &j = i; // reference int *P; // pointer P =&i; cout<<endl<< "address of variable :i" <<&i; cout<< endl << "address of reference: j" <<&j; cout<<endl<<"address of pointer : P"<<&P; return 0; } OUTPUT: address of variable i: i0012FEDC address of reference j: 0012FEDC address of pointer p: 0012FEE0 so you see the address of i and reference j is same , address of pointer P is different.
In C++ a reference variable is internally implemented as a constant pointer, and that is why it is necessary to initiallize a reference variable during declaration... as it is treated as a constant variable (pointer) internally.
That is incorrect, zaka. A reference is a second name (alias) for an object. You can't name something that doesn't exist, therefore you have to specify the object being aliased when you declare the reference. When a reference is passed as an argument, a copy of the objects address is passed. This is one fewer levels of indirection than when a pointer to the object is passed.
pointer is variable which holds the address of another variable ,another function and incomplete in C. incomplete means ----------void *p; it's a generic pionter ,we can not allocate memory by dynamically with this . size of pointer is depending on the memory model.
In C#, the object of a Class 1. is a reference ? or 2. is a STACK to HEAP pointer ? the objects shouldn't go into the HEAP ? if they are references of the class instances.
pointer is not necessary to initialize the pointer at the time of declaration and reference to initialize the Reference at the time of declaration .Ok thank you.
A reference is (usually) exactly the same as a pointer, from an implementation and performance point of view. They are, in that sense, pure syntactic sugar. The only difference is that in some cases a reference can be optimized away. I'm not saying they are a bad thing, they're good for what they are designed for. It's just incorrect to suggest that they offer a performance advantage over pointers. If you still disagree, consider this C++ and its assembly code (from g++ using -S flag): Code: #include <iostream> using namespace std; void f( int i, int& r, int* p ) { ++i; ++r; ++*p; } int main() { int i = 0, r = 1, p = 2; cout<< i <<' '<< r <<' '<< p <<endl; f( i, r, &p ); cout<< i <<' '<< r <<' '<< p <<endl; } I've condensed the assembly for brevity. ## comments are mine. Code: ... __Z1fiRiPi: ## f's mangled name: Z1(arbitrary) f(our name) iR(int&) iP(int*) i(int) pushl %ebp movl %esp, %ebp incl 8(%ebp) ## inc value at stack offset 8 (i) movl 12(%ebp), %eax ## load pointer at stack offset 12 (r) incl (%eax) ## inc indirect (dereference) movl 16(%ebp), %eax ## same as for r (p) incl (%eax) popl %ebp ret ... movl $0, -4(%ebp) ## Load the variables with 0, 1, and 2. movl $1, -8(%ebp) ## Note their constant addresses (stack offsets). movl $2, -12(%ebp) ## i is -4, r is -8, p is -12 (relative to ebp) ... leal -12(%ebp), %eax ## push p's address pushl %eax leal -8(%ebp), %eax ## push r's address (same as for p) pushl %eax pushl -4(%ebp) ## push i (value) call __Z1fiRiPi ## call f ...
You all are correct. One main Difference is that Extra memory is taken by Pointer( Size depends on machine architecture i.e. 32-bit machine will be 32 bit size of pointer) But in case of reference is Only Alias for that object. Some book written that reference is just like a constant pointer. But it's not correct. Just reference 's behabiour is like constant pointer.