The difference between a pointer and a reference

The difference between a pointer and a reference

(1) The reference always points to an object, and there is no so-called null reference. All when it is possible to point to an object, you must use a pointer if you do not point to the object.

Because C + + requires reference to always point to an object, reference requires an initial value.

String & rs = string1;

Because there is no so-called null reference, you do not need to test it for values before you use it. The use of pointers requires testing their validity.

(2) The pointer can be re-assigned and reference always points to the original or ground object.

(3) Where reference must be used. Operator[] operator because it is very special to return something that [can be used as a assignment assignment object], it is necessary to return a reference to the operator.

(4) In fact, reference is used very often in the parameters of the function.

void get*** (const int& a)//This uses a reference to ensure that the referenced value is not modified

{

} References and pointers

★ Same point:
1. Is the concept of the address;
The pointer points to a piece of memory whose contents are the address of the referred memory, and 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 dereference (*), the pointer needs to be dereferenced;
3. References can only be initialized once at the time of definition, and then immutable; pointers are variable;
Reference "mindedness" ^_^
4. Reference does not have a const, pointer has const,const pointer is immutable;
5. The reference cannot be null, the pointer can be empty;
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 is true, sizeof (t) = = sizeof (t&) constant is true,
But when a reference is a member, it occupies the same space as the pointer (no standard rule is found).
7. The pointer and the reference self-increment (+ +) operation has different meanings;

★ Contact
1. References are implemented using pointers within the language (how to implement them). ）。
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 one of M's
A reference (reference), M is the quoted (referent).
int m;
int &n = m;
N is equivalent to an M alias (nickname), and any action on N is an operation on M. For example, someone named * *,
His nickname is "Sanmao". Say "Sanmao" how how, in fact is to * * judge. So n neither
is a copy of M, nor is it a pointer to M, in fact N is M itself.
Some of the rules cited are as follows:
(1) The reference is created and must be initialized (the pointer 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 does not modify K to be the lead of J
Only 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;
int &k = i;
K = J; The values of k and I all become 6;
The above program looks like you're playing a word game and doesn't reflect the value of the quote. The main function of the reference is to pass
The arguments and return values of the recursive 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.
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
The following is a sample program for "pointer passing". Because x in the FUNC2 function body is the reference to an external variable n
Needle, 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
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 is the same thing, changing x equals changing n, so the value of n becomes 10.
void Func3 (int &x)
{
x = x + 10;
}
& #8943;
int n = 0;
FUNC3 (n);
cout << "n =" << n << Endl; n = 10
In contrast to the above three sample programs, it is found that "reference passing" is of the nature of "pointer passing", and that the writing method is like
"Value passing". In fact, anything that "references" can do "pointers" can also be done, why "reference"
This thing.
The answer is "do the right thing with the proper tools."
Pointers can manipulate things 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 it.
If you really only need to borrow the "alias" of an object, then use "reference" instead of "pointer",
To avoid accidents. For example, someone needs a proof that the seal on the document would have been stamped on it, such as
If you give him the key to the official seal, he will gain the right not to have it.
－－－－－－－－－－
Excerpt from "High quality C + + programming"
Pointers and references, in more effective C + + clauses I'll give you a turn around.
Article one: The difference between a pointer and a reference
Pointers and references look completely different (pointers use the operator ' * ' and '-a ', referencing the operator '. ') ), but they seem to have the same functionality. 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 would happen to such a code?" ”
char *pc = 0; Set the pointer to a null value
char& rc = *pc; To point a reference to a null value
This is very harmful, no doubt about it. The result will be indeterminate (the compiler can produce some output, causing anything to happen) and should avoid the person who writes the 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; Right, RS pointing to 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 for 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. In other cases, you should use pointers
Suppose you have
void func (int* p, int&r);
int a = 1;
int b = 1;
Func (&AMP;A,B);
The value of the pointer itself (the 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 you can use the pointer to change the value of the variable pointed to by the pointer,
*p = 123131; A now is 123131
However, the reference itself is carried out by the pass by reference, changing its value to change the value of the variable that the reference corresponds to.
R = 1231; b now is 1231


Ext.: Lijian