1. Reference base
A reference is a different name for an object, usually in the form of "&d" to define the reference type, where D is the declared variable name:
int ival = 1024;
int &refval = ival;
References must be initialized, references are not objects, just another name for an existing object. After a reference is defined, all operations on it are performed on the object to which it is bound:
Refval = 2;
int II = Refval;
The reference itself is not an object, so the reference cannot be defined
This article address: http://wuyudong.com/2016/11/10/2971.html, reprint please indicate the source.
2, reference to the pointer
Because the reference itself is not an object, naturally there is no pointer to the reference, but the pointer is an object, all references that can define the pointer:
int i = 1;
int *p;
int *&r = p; R is a reference to the pointer p
r = &i; R references a pointer, which is P pointing i
*r = 0; Solution Reference R Get I
3, the const reference
You can bind a reference to a const object as a reference to a constant, and a reference to a constant cannot be used to modify the object to which it is bound:
const int CI = 1024;
const int &R1 = CI;
R1 = 42; ERROR:R1 is a reference to a constant
int &r2 = CI; Error: Attempting to have a very reference to a constant object
An arbitrary expression is allowed as an initial value when initializing a constant reference, provided that the result of the expression can be converted to a reference type, especially for a constant reference to a bound object, a literal, or even a general expression:
int i = 42;
const int &R1 = i;
const int &R2 = 42;
const int &R3 = r1 * 2;
int &R4 = r1 * 2; ERROR:R4 is a normal, extraordinary amount of reference
4. function Pass Reference parameter
Allows a function to change the value of one or more arguments by reference parameters
void Reset (int &i)
{
i = 0;
}
int j = 23;
Reset (j);
cout<< "J =" <<j<<endl; j = 0
Tip 1: Use references to avoid copying
Copying large class-type objects or container objects is inefficient, and even some class types (including IO types) do not support copying at all, and can be accessed by reference parameters, for example:
BOOL Isshorter (const string &S1, const string &s2)
{
String object may be very long, select reference
Return S1.size () < S2.size ();
}
Tip 2: Use reference parameters to return additional information
If there are times when a function needs to return more than one value, the reference parameter provides the possibility for that requirement.
For example: Implement a function that returns the first occurrence of a specified character in a string object and returns the total number of occurrences of that character
String::size_type Find_char (const string &s, char C, String::size_type &occurs)
{
Auto ret = S.size ();
Occurs = 0;
For (Decltype (ret) i = 0; I!= s.size (); i++) {
if (s[i] = = c) {
if (ret = = S.size ()) {
ret = i;
}
occurs++;
}
}
return ret;
}
Auto index = Find_char (s, c, occurs)
5, array reference parameters
C + + allows a variable to be defined as a reference to an array, so that the parameter can be a reference to the arrays, at which point the reference parameter is bound to the corresponding argument, which is bound to the array:
void print (int (&array) [10])
{
for (auto Elem:array)
cout<<elem<<endl;
}
int k[10] = {0,1,2,3,4,5,6,7,8,9};
Print (k);
6, function return reference
If the function returns a reference, the reference is only an alias for the object it refers to, for example:
Const string &shorterstring (const string &S1, const string &s2)
{
Return s1.size () <= s2.size ()? S1:S2;
}
Where the formal parameter and the return result are references to a const string so that the string object is not actually copied whether the call function or the result is returned.
Calling a function that returns a reference gets the left value, and the other return type gets the right value, so that we can assign a value to the result of the function that the return type is a very important reference:
Char &get_val (string &s, String::size_type i)
{
return s[i];
}
Int main ()
{
string s ("a bug!");
cout<<s<<endl; /output: A bug
get_val (s, 0) = ' a ';
& nbsp; cout<<s<<endl; Output: A bug
System ("PAUSE");
return 0;
}
This article summarizes the various usages that are referenced in C + +, and then supplements it later.