指针与引用

目录

• （1）形参形式：int
• （2）形参形式：int*
• （3）形参形式：int&
• （4）形参形式：int*&
• （5）形参形式：int &*
• （6）形参形式：int**

来源

• 指针——指向某一块内存的变量，其本身存储的信息就是内存地址的首地址，其类型决定指向内存的大小。
• 变量——某一块内存地址数据值的名字。
• 引用——变量的别名。（依然可以代表变量本身。）

（1）形参形式：int

#include<iostream>                   
#include<cstdlib>                    
using namespace std;                 
                                     
void swap1(int a, int b){            
        int tmp;                     
        tmp = a;                     
        a = b;                       
        b = tmp;                     
}                                    
                                     
int main(){                          
        int a = 1;                   
        int b = 2;                   
        swap1(a, b);                 
        cout << "a = " << a << endl; 
        cout << "b = " << b << endl; 
        system("pause");             
        return 0;                    
}                                    

交换失败。这种交换知识交换了形参的参数，没有改变实参，因此无法达到交换值。（linux中不存在system函数）

（2）形参形式：int*

#include<iostream>                    
#include<cstdlib>                     
using namespace std;                  
                                      
void swap2(int* a, int* b){           
        int tmp;                      
        tmp = *a;                     
        *a = *b;                      
        *b = tmp;                     
}                                     
                                      
int main(){                           
        int a = 1;                    
        int b = 2;                    
        swap2(&a, &b);                
        cout << "a = " << a << endl;  
        cout << "b = " << b << endl;  
        system("pause");              
        return 0;                     
}                                     

交换成功。swap2函数传入的是实参的地址，因此可以直接操作实参的值。

（3）形参形式：int&

#include<iostream>
using namespace std;

void swap3(int& a, int& b){
        int tmp;
        tmp = a;
        a = b;
        b = tmp;
}

int main(){
        int a = 1;
        int b = 2;
        swap3(a, b);
        cout << "a = "<< a << endl;
        cout << "b = "<< b << endl;

        return 0;
}

交换成功。引用即别名，通过引用也可以直接访问到实参和控制实参。

（4）形参形式：int*&

#include<iostream>
using namespace std;

void swap4(int *&a, int *&b){
        int tmp = *a;
        *a = *b;
        *b = tmp;
}

int main(){
        int a = 1;
        int b = 2;

        int *aptr = &a;
        int *bptr = &b;
        int *&arptr = aptr;   // arptr是指针aptr的别名；
        int *&brptr = bptr;   // brptr是指针bptr的别名；
        swap4(arptr, brptr);

        cout << "a = " << a << endl;
        cout << "b = " << b << endl;

        return 0;
}

交换成功。对于int*& value这个声明，从最接近value的符号看起，是个&，说明value是一个引用；再看*，是一个指针的引用，即指针的别名；因此我们用*value就可以访问到实参的值了。所以，其交换函数的内部逻辑和int*是一样的；

（5）形参形式：int &*

void swap5(int &* a, int &* b)也可以交换成功，但是这是指针的引用，而指针是无法引用的，因此这种定义是错误的，不要用这个。对于int &* a这个声明，最接近a的的*表明a是一个指针，然后前面的&表明这是一个指针的引用。

（6）形参形式：int**

#include<iostream>
using namespace std;

void swap6(int **a, int **b){
        int tmp;
        tmp = **a;
        **a = **b;
        **b =tmp;
}

int main(){
        int a = 1;
        int b = 2;
        int *aPtr = &a;   //指向数据地址的指针
        int *bPtr = &b;   //指向数据地址的指针
        int **aaPtr = &aPtr;   //指向指针地址的指针
        int **bbPtr = &bPtr;   //指向指针地址的指针
        swap6(aaPtr, bbPtr);
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;

        return 0;
}

交换成功。int **value，最接近value的是*，说明value是一个指针，再看前一个*，说明是一个指向指针的指针；访问实参时只需要用**value即可，*是取值操作符，&是取址操作符。