This article is reproduced from http://www.cnblogs.com/tracylee/archive/2012/12/04/2801519.html
The difference between a reference and a pointer in C + +
The difference between pointers to different types is that the pointer type knows what the compiler interprets in memory content and size in a particular address (the address the pointer points to), whereas the void* pointer represents only one memory address, and the compiler cannot pass the pointer to the object's type and size, so you want to pass void* The pointer manipulation object must be type-converted.
★ Same point: 1. Is the concept of an address; the pointer points to a piece of memory whose contents are the address of the referred memory; the reference is the alias of a block of memory.
★ Difference:1. The pointer is an entity, and the reference is only an individual name; 2. The reference does not need to be dereferenced (*) and the pointer needs to be dereferenced; 3. A reference can only be initialized once at the time of definition, is immutable, the pointer is variable, and the reference "mindedness" ^_^ 4. The reference does not have a const, the pointer has a const,const pointer immutable; 5. The reference cannot be null, the pointer can be empty, and 6. "sizeof Reference" gets the size of the variable (object) pointed to, and the "sizeof pointer" gets the size of the pointer itself (the address of the variable or object to which it is pointing); typeID (t) = = typeid (t&) constant true, sizeof (t) = = Sizeo F (t&) is true, but when the reference is the name of a class member, it takes up as much space as a pointer by 4 bytes (no standard rule is found). 7. The pointer and the reference self-increment (+ +) operation has different meanings;
★ Contact 1. References are implemented within the language using pointers (how do I do that?) ）。 2. For general applications, the reference is interpreted as a pointer and does not make a serious semantic error. A reference is a pointer to a restricted operation (allow only the content operation). references are concepts in C + +, and beginners tend to confuse references with pointers. In the program, N is a reference to M (reference), and M is the quoted (referent). int m; int &n = m; n equals m alias (nickname), and any action on N is an operation on M. For example, someone named Wang Xiaomao, whose nickname is "Sanmao". Say "Sanmao" how how, in fact is to Wang Xiao judge. So n is neither a copy of M nor a pointer to M, in fact N is M itself. Some of the rules for references are as follows: (1) references are created and must be initialized (pointers can be initialized at any time). (2) cannot have a null reference, the reference must be associated with a valid storage unit (the pointer can be null). (3) Once a reference is initialized, the referenced relationship cannot be changed (the pointer can change the object at any time). In the following sample program, K is initialized as a reference to I. The statement k = J cannot modify k to be a reference to J, just change the value of K to 6. Since k is a reference to I, the value of I also becomes 6. int i = 5; int j = 6; & nbsp int &k = i; k = j;//k and I are all changed to 6; The above program looks like it is playing a word game and does not reflect the value of the quote. The primary function of a reference is the parameter and return value of the passed function. In the C + + language, the parameters and return values of a function are passed in three ways: value passing, pointer passing, and reference passing. 1) The following is a sample program for "Value passing". Since x in the FUNC1 function body is a copy of the external variable n, changing the value of x does not affect n, so the value of n is still 0.
void Func1 (int x)
{
x = x + 10;
}
int n = 0;
FUNC1 (n);
cout << "n =" << n << endl;//n = 0 |
2) The following is a sample program for "pointer passing". Since x in the FUNC2 function body is a pointer to an external variable n, changing the contents of the pointer will cause the value of N to change, so the value of n becomes 10.
void Func2 (int *x)
{
(* x) = (* x) + 10;
}
& #8943;
int n = 0;
FUNC2 (&n);
cout << "n =" << n << Endl; n = 10 |
3) The following is a sample program for "Reference passing". Since x in the FUNC3 function body is a reference to an external variable n, x and n are the same thing, changing x equals changing n, so the value of n becomes 10.
void Func3 (int &x)
{
x = x + ten;
}
& #8943;
int n = 0;
Func3 (n);
cout << n = "<< n << Endl; n = ten |
Comparing the three sample programs above, you will find that the property of "reference passing" is like "pointer passing", while writing is like "value passing". In fact, "reference" can Do Anything "pointer" also can do, why also "reference" this thing? The answer is "do the right thing with the proper tools." Pointers can manipulate how things are in memory without restraint, although pointers are powerful, but very dangerous. Like a knife, it can be used to cut trees, cut paper, manicure, Barber and so on, who dares to use this? If you really just need to borrow an "alias" for an object, use "reference" instead of "pointer" to avoid an unexpected occurrence. For example, someone needs a proof that the seal on the document would have been stamped on it, and if the key to the official seal is given to him, then he has acquired the right not to. —————————— excerpt from "High quality C + + programming" pointers and references, in more effective C + + clauses, I'll give you a transfer. clause One: The difference between a pointer and a reference pointers and references look completely different (pointers with the operator ' * ' and '-A, reference using operator '). '), but they seem to have the same function. Pointers and references let you refer to other objects indirectly. How do you decide when to use a pointer and when to use a reference? First, realize that you cannot use a reference to a null value under any circumstances. A reference must always point to some object. So if you use a variable and point it to an object, but that variable may not point to any object at some point, you should declare the variable as a pointer, because you can assign a null value to the variable. Conversely, if the variable is definitely pointing to an object, such as your design does not allow the variable to be empty, then you can declare the variable as a reference. "But wait a minute," you asked suspiciously, "what will happen to this code?" " char *pc = 0; //set pointer to null value char& rc = *pc;//reference to null value This is very harmful, No doubt. The result will be indeterminate (the compiler can produce some output, causing everything toLikely to happen), avoid people who write such code unless they agree to correct the error. If you are concerned that such code will appear in your software, then you'd better avoid using references altogether, or let better programmers do it. We will later ignore the possibility of a reference pointing to a null value. Because the reference will definitely point to an object, in C + +, the reference should be initialized.
| string& RS;//error, reference must be initialized String S ("Xyzzy"); string& rs = s;//correct, RS pointing s Pointers do not have such a limitation. string *ps;//uninitialized pointer Legal, but dangerous. |
The fact that there are no references to null values means that using the referenced code is more efficient than using pointers. Because you do not need to test its legitimacy before using a reference.
void printdouble (const double& RD)
{
cout << Rd; You do not need to test Rd, it
}//must point to a double value
Instead, the pointer should always be tested to prevent it from being empty:
void printdouble (const double *PD)
{
if (PD){//check if NULL
cout << *PD;
}
} |
Another important difference between pointers and references is that pointers can be re-assigned to point to another different object. But the reference always points to the object that was specified at initialization and cannot be changed later.
String S1 ("Nancy");
String S2 ("Clancy");
string& rs = s1; RS reference S1
String *ps = &s1; PS Pointing S1
rs = s2; RS still cites S1,
But the value of S1 is now
"Clancy"
PS = &s2; PS now points to S2;
S1 hasn't changed. |
In general, you should use pointers when you consider the possibility of not pointing to any object (in which case you can set the pointer to null), and you need to be able to point to different objects at different times (in which case you can change the pointer's direction). If you always point to an object and do not change the point once it points to an object, then you should use a reference. Another case is that when you reload an operator, you should use a reference. The most common example is the operator []. The typical use of this operator is to return a target object, which can be assigned a value.
Vector<int> V (10); Set up the shaping vector (vector), the size of 10;
A vector is a template in the standard C library (see clause 35)
V[5] = 10; The target object that is assigned is the value returned by the operator []
If the operator [] returns a pointer, then the latter statement has to be written like this:
*V[5] = 10; |
But that would make v look like a vector pointer. So you would choose to have the operator return a reference. (There is an interesting exception to this, see clause 30) You should not use pointers when you know that you must point to an object and do not want to change its point, or if you overload the operator and are misunderstood to prevent unnecessary semantics. And in other cases, you should use pointers to assume that you have
void func (int* p, int&r);
int a = 1;
int b = 1;
Func (&A,B); |
The value of the pointer itself (address value) is done with pass by value, you can change the address value, but this does not change the value of the variable pointed to by the pointer, p = someotherpointer;//a is still 1 but can use a pointer to change the value of the variable pointed to by the pointer, *p = 123131;//A now is 123131 but the reference itself is carried out by the pass by reference, changing its value to change the value of the reference corresponding to the variable r = 1231;//b now is 1231 as far as possible to make Use pointers when using references. When you do not need to "re-point", the reference generally takes precedence over the pointer being selected. This usually means that referencing a public interface for a class is more useful. The typical scenario where a reference occurs is the surface of the object, and the pointer is used inside the object. The exception above is when a function's argument or return value requires a "critical" reference. It is usually better to return/get a pointer and use a NULL pointer to accomplish this particular mission. (a reference should always be an alias for an object, not a NULL pointer that is dereferenced). Note: Traditional C programmers sometimes do not like references because they do not provide clear citation semantics at the caller's code. However, when you have some C + + experience, you will soon realize that this is a form of information hiding, which is beneficial rather than harmful. As is the case, the programmer should write code for the problem to be solved, not the machine itself.
[Reprint]c++ in the difference between the reference and the pointer (detailed introduction)
