C++中的指针和引用

一、* 和 & 的区别

*为指针运算符, 取地址上的内容;

&为取地址运算符, 取变量的地址。两个相反的方向。

int a;

*(&a)就是a

二、值传递、指针传递、引用传递的区别

1. 值传递：形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。

void swap(int a,int b){
     int temp;
     temp=a;
     a=b;
     b=temp;
     cout<<a<<' '<<b<<endl;
}

int main(){
     int x=1;
    int y=2;
    swap(x,y);
    cout<<x<<' '<<y<<endl;
    
    return 0;
}

用gdb调试后发现，x,y的地址分别是0xffbef938, 0xffbef934, 值分别是1，2。而形参a,b的地址分别是0xffbef918,0xffbef914, 虽然它们存储的值和x,y一样，都是1，2，但是这只是拷贝过来的。swap只交换了a,b，并不会改变x,y的值。输出为2，1；1，2

2. 指针传递：

void swap(int *a,int *b){
     int temp;
     temp=*a;
     *a=*b;
     *b=temp;
     cout<<*a<<' '<<*b<<endl;
}

int main(){

   int x=1;
    int y=2;
    swap(&x,&y);
    cout<<x<<' '<<endl;

}

输出结果是2，1；2，1。实参x,y, 形参a,b的地址同上，但是a,b的内容分别为0xffbef938 （x的地址）,0xffbef934（y的地址），*a也就是0xffbef938内存中存放的内容，即x的值1。简单地说，a是一个指向外部实参地址的指针，*a是指针的内容，如果改变了*a也必然导致外部实参的改变。

3. 引用传递：

void swap(int &a,int &b){
     int temp;
     temp=a;
     a=b;
     b=temp;
     cout<<a<<' '<<b<<endl;
}

int main(){
    
    int x=1;
    int y=2;
    swap(x,y);
    cout<<x<<' '<<endl;
    return 0;
}

输出是2，1；2，1。实参x,y的地址同上。然而与指针传递不同的是，形参a,b的地址也与x,y相同，即0xffbef938, 0xffbef934。这样一来，交换a,b就相当于交换x,y。

指针传递和引用传递一般适用于：函数内部修改参数并且希望改动影响调用者。对比值传递，指针/引用传递可以将改变由形参“传给”实参（实际上就是直接在实参的内存上修改，不像值传递将实参的值拷贝到另外的内存地址中才修改）。指针/引用传递的另外一种用法是：当一个函数实际需要返回多个值，而只能显式返回一个值时，可以将另外需要返回的变量以指针/引用传递给函数，这样在函数内部修改并且返回后，调用者可以拿到被修改过后的变量，也相当于一个隐式的返回值传递吧。

至于指针/引用传递的格式，可以参考以下的内容：

int x=1;
int *y=&x; //用于指针传递，y有自己独立的内存地址，存储的内容是x的地址，*y是x的值
int &z=x; //用于引用传递，可以理解为z就是x，x就是z，只不过名字不一样

例子：

int change1(char* name){
    name=”alter”;
    return 1;
}

int change2(char* &name){
    name=”alter”;
    return 1;
}

int main(){
    char* string=”original!”;
    change1(string);
    cout<<string<<’\n’;

    change2(string);
    cout<<string<<’\n’;

}

结果：original!;alter。change1是值传递，形参name有自己独立的内存地址，内容是拷贝string的内容（string的内容是”original”的地址），修改后name的内容变成了“alter”的地址。change2是引用传递，形参name的地址就是string的地址，或者说name就是string

三、指针详解

1、要理解C++指针，我认为一定要从C++中“变量”的存储实质开始

（1）内存地址与内存空间：

内存只不过是一个存放数据的空间，就好像我 的看电影时的电影院中的座位一样。每个座位都要编号，我们的内存要存放各种各样的数据，当然我们 要知道我们的这些数据存放在什么位置吧！所以内存也要象座位一样进行编号了，这就是我们所说的内 存编址。座位可以是按一个座位一个号码的从一号开始编号，内存则是按一个字节一个字节进行编址， 如上图所示。每个字节都有个编号，我们称之为内存地址。

图中可看出，i在内存起始地址为6上申请了 两个字节的空间（我这里假设了int的宽度为16位，不同系统中int的宽度是可能不一样的），并命名为 i. a在内存地址为8上申请了一字节的空间，并命名为a.这样我们就有两个不同类型的变量了。

（2）赋值给变量

i=30;
a='t';

这两个语句是将30存入i变量的内存空间中，将‘t’字符存入a变量的内存空间中。

（3）变量的地址

cout<<&i;

&i是取i变量所在的地址,所以结果显示的不是i值30，而是显示i的内存地址编号6

2、指针

生活中处处都有指针。比如说你要 我借给你一本书，我到了你宿舍，但是你人不在宿舍，于是我把书放在你的2层3号的书架上，并写了一 张纸条放在你的桌上。纸条上写着：你要的书在第2层3号的书架上。当你回来时，看到这张纸条。你就 知道了我借与你的书放在哪了。你想想看，这张纸条的作用，纸条本身不是书，它上面也没有放着书。 那么你又如何知道书的位置呢？因为纸条上写着书的位置嘛！其实这张纸条就是一个指针了。它上面的 内容不是书本身，而是书的地址，你通过纸条这个指针找到了我借给你的本书。

short int * pi;

pi是一个指针，其实，指针也只过是一个变量而已。与上面说的变量并没有实质的区别。

由图示中可以看出，我们使用int * pi申明指针变量； 其实是在内存的某处 申明一个一定宽度的内存空间，并把它命名为pi.你能在图中看出pi与前面的i，a 变量没有本质。那么它又为什么会被称为指针？关键是我们要让 这个变量所存储的内容是什么，如何要让pi成为真正有意义上的指针。

pi=&i;

把i地址的编号赋值给pi，也就是你在pi上写上i的地址编号。

cout<<pi<<","<<*pi;

pi指向变量i的地址=6,*pi读地址的内容=30

例子：

char  a, *pa;
a=10;
pa=&a;
*pa=20;
cout<<a；//指针引用改变了a的值，所以=20

3、指针的指针（指向另一指针地址的指针）

（1）数组元素

int i,a[]={3,4,5,6,7,3,7,4,4,6};
for (i=0;i<=9;i++){
  //法一
  //cout<<a[i]<<" ";
  //法二
  cout<<*(a+i)<<" ";
}

上面展示了两种输出数组个元素的方式，也可以用指针的方式里表示：

int i,*pa,a[]={3,4,5,6,7,3,7,4,4,6};
pa =a;//请注意数组名a直接赋值给指针pa
for (i=0;i<=9;i++){
  //法一
  //cout<<pa[i]<<" ";
  //法二
  cout<<*(pa+i)<<" ";
}

看pa=a即数组名赋值给指针，以及通过数组名、指针对元素的访问形式看，它们并没有什么区别，从这里可以看出数组名其实也就是指针。那他们有何区别？

int i,*pa,a[]={3,4,5,6,7,3,7,4,4,6};
pa =a;
for (i=0;i<=9;i++){
  cout<<*pa<<" ";
  pa++ ;　 //注意这里，指针值被修改
}

可以看出，这段代码也是将数组各元素值输出。不过，把{}中的pa改成a试试。你会发现程序编译出错，不能成功。看来指针和数组名还是不同的。其实上面的指针是指针变量，而数组名只是一个指针常量。这个代码与上面的代码不同的是，指针pa在整个循环中，其值是不断递增的，即指针值被修改了 。数组名是指针常量，其值是不能修改的，因此不能类似这样操作：a++.前面pa[i]，*（pa+i ）处，指针pa的值是使终没有改变。所以变量指针pa与数组名a可以互换。

(2)申明指针常量

int i, a[]={3,4,5,6,7,3,7,4,4,6};
int * const pa=a;//注意const的位置：不是 const int * pa
for (i=0;i<=9;i++){
  cout<<*pa<<" ";
  pa++ ;　 //注意这里，指针值被修改
}

这时候的代码能成功编译吗？不能。因为pa指针被定义为常量指针了。这时与数组名a已经没有不同 。这更说明了数组名就是常量指针。但是，

int * const a={3，4，5，6，7，3，7，4，4，6};//不行
int a[]={3，4，5，6，7，3，7，4，4，6};//可以，所以初始化数组时必定要这样。

(3)const

int i=0；
i=20；//这里重新赋值了

用const声明一个变量（暂且称它变量），在申明时就赋一个初始值。之后我的程序在其它任何处都不会再去重新对它赋值。

const int ic =20;
ic=40; //这样是不可以的，编译时是无法通过，因为我们不能对 const 修饰的ic重新赋值的。

const修饰的ic 我们不称它为变量，而称符号常量，代表着20这个数。

const有两种格式，效果完全相同：

const int ic=20;//法一
int const ic=20;//法二

记住一点，int 与const 哪个放前哪个放后都是一样的，下面这两者效果也完全相同

const int * pi;//法一
int const * pi;//法二

const int * pi是什么作用 （当然int const * pi也是一样的)

int i1=30;
int i2=40;
const int * pi=&i1;
pi=&i2;　　　 //4.注意这里，pi可以在任意时候重新赋值一个新内存地址
i2=80;　　　 //5.想想看：这里能用*pi=80;来代替吗？当然不能
cout<<*pi;　 //6. 输出是80

语义分析：可以看出，pi的值是可以被修改的。即它可以重新指向另一个地址的，但是，不能通过*pi来修改i2的值。首先const修饰的是整个*pi（注意，我 写的是*pi而不是pi）。所以*pi是常量，是不能被赋值的（虽然pi所指的i2是变量，不是常量）。其次，pi前并没有用const 修饰，所以pi是指针变量，能被赋值重新指向另一内存地址的。

再看int * const pi

int i1=30;
int i2=40;
int * const pi=&i1;
//pi=&i2;　　　 4.注意这里，pi不能再这样重新赋值了，即不能再指向另一个新地址。
　　 //所以我已经注释了它。
i1=80;　　　 //5.想想看：这里能用*pi=80;来代替吗？可以，这 里可以通过*pi修改i1的值。
　　　　 //请自行与前面一个例子比较。
cout<<*pi;　 //6.输出是80

语义分析：可以看出， pi值是不能重新赋值修改了。它只能永远指向初始化时的内存地址了。相反，这次你可以通过*pi来修改 i1的值了。首先，pi因为有了const 的修饰，所以只 是一个指针常量：也就是说pi值是不可修改的（即pi不可以重新指向i2这个变量了）（看第4行）。其次，整个*pi的前面没有const 的修饰。也就是说，*pi是变量而不是常量，所以我们可以通过 *pi来修改它所指内存i1的值（看5行的注释）

总结：
1) 如果const 修饰在*pi前则不能改的是*pi（即不能 类似这样：*pi=50；赋值）而不是指pi.
2) 如果const 是直接写在pi前则pi不能改（即不能类似 这样：pi=&i；赋值）。

补充三种情况。

情况一：int * pi指针指向const int i常量的情况

const int i1=40;
int *pi;
pi=&i1;　//这样不行，VC下是编译错。const int 类型的i1的地址是不能赋值给指向int 类型地址的指针pi的。否则pi岂不是能修改i1的值了吗！
pi=(int* ) &i1;　　//强制类型转换可是C++所支持的。ＶＣ下编译通过，但是仍不能通过*pi=80来修改i1的值。

情况二：const int * pi指针指向const int i1的 情况

const int i1=40;
const int * pi;
pi=&i1;//两个类型相同，可以这样赋值。很显然，i1的值无论是通过pi还是i1都不能修改的。

情况三：用const int * const pi申明 的指针

int i;
const int * const pi=&i;//不能通过pi修改i的值。因为不管是*pi还 是pi都是const的。

(4)指针的地址与指向另一指针地址的指针

#include <iostream>
using namespace std;

int main(){
	short int i;
	cout<<"i的地址="<<&i<<endl;  
	short int *pi;
	cout<<"pi的地址="<<&pi<<endl; 	
	cout<<"pi的内容="<<pi<<endl; 
	i=50;
	pi=&i;
	cout<<"赋值后的pi的地址="<<&pi<<endl; 
	cout<<"赋值后的pi的内容="<<pi<<endl; 
	*pi=5;
	short int ** ppi;
	cout<<"ppi的地址="<<&ppi<<endl; 
	cout<<"ppi的内容="<<ppi<<endl; 
	ppi=π
	cout<<"赋值后的ppi的地址="<<&ppi<<endl; 
	cout<<"赋值后的ppi的内容="<<ppi<<endl; 	
	cout<<endl;
	cout<<ppi<<","<<*ppi<<","<<**ppi<<endl;
	
	return 0;
} 

从图中看出，指针变量ppi的内容就是指针变量pi的起始地址。于是
ppi的值是多少呢？ ——0x22fd70
*ppi的值是多少呢？——0x22fd7e，即pi的值。
**ppi的值是多少 呢？——5，即i的值，也是*pi的值。

例子：

#include <iostream>
using namespace std;

int main(){
	short int i;
	cout<<"i的地址="<<&i<<endl;  
	short int *pi;
	cout<<"pi的地址="<<&pi<<endl; 	
	cout<<"pi的内容="<<pi<<endl; 
	i=50;
	pi=&i;
	cout<<"赋值后的pi的地址="<<&pi<<endl; 
	cout<<"赋值后的pi的内容="<<pi<<endl; 
	*pi=5;
	short int ** ppi;
	cout<<"ppi的地址="<<&ppi<<endl; 
	cout<<"ppi的内容="<<ppi<<endl; 
	ppi=π
	cout<<"赋值后的ppi的地址="<<&ppi<<endl; 
	cout<<"赋值后的ppi的内容="<<ppi<<endl; 	
	cout<<endl;
	cout<<ppi<<","<<*ppi<<","<<**ppi<<endl;
	
	return 0;
} 

例2：设计一个函数：void find1（char array[]， char search， char * pi）
要求：这个函数参数中的数组array是以0值为结束的字符串，要求在字符 串array中查找字符是参数search里的字符。如果找到，函数通过第三个参数（pa）返回值为array字符 串中第一个找到的字符的地址。如果没找到，则为pa为0。

#include <iostream>
using namespace std;
void find1(char array[], char search, char * pa){
  int i;
  for (i=0;*(array+i)!='\0';i++){
    if (*(array+i)==search){
      pa=array+i;
      break;
    }
  }
}

int main(){
	char str[]={"afsdfsdfdf"}; //待查找的字符串
	char a='d';
	char i='\0';
	char * p=&i; //如果查找到后指针p将指向字符串中查找到的第一个字符的地址。
	find1(str,a,p); 
	if(* p=='\0') cout<<"无"<<endl;//p==&i
	else  cout<<*p<<endl;
	
	return 0;
}

明明a值为'd'，而str字符串的第四个字符是'd',为何会查不到呢？整个调用如下：

array=str;
search=a;
pa=p;　　　 //请注意：以 上三句是调用时隐含的动作。
int i;
for (i=0;*(array+i)!='\0';i++){
  if (* (array+i)==search){
    pa=array+i
    break;
  }
}

参数pa与参数search的传递并没 有什么不同，都是值传递,所以对形参变量pa值的修改并不会改变实参变量p值，因此p的值并没有改变。

改正成指针传递如下：

#include <iostream>
using namespace std;

void  find1(char array[], char search, char ** pa){
	for(int i=0;*(array+i)!='\0';i++){
		if(*(array+i)==search){
			*pa=(array+i); 
			break;
		}
	} 
}

int main(){
	char str[]={"afsdfsdfdf"}; //待查找的字符串
	char a='d';
	char i='\0';
	char * p=&i; //如果查找到后指针p将指向字符串中查找到的第一个字符的地址。
	cout <<&p<<","<<p<<","<<*p<<endl;
	find1(str,a,&p); 
	cout <<&p<<","<<p<<","<<*p<<endl;
	if(* p=='\0') cout<<"无"<<endl;//p==&i
	else  cout<<*p<<endl;
	 
	return 0;
}

pa指向指针p的地址 ，对*pa的修改就是对p值的修改。

注意：（1）定义char类型字符串两种方式

char str[]={"afsdfsdfdf"};//法一
char * str="afsdfsdfdf";//法二

（2）第一行的两个空处，尽管都没有，但是两者是不一样的，第一个逗号后面是‘\0’的地址，即&i，第二个逗号后面是'\0'，即i

如果函数可以有返回值的话，可以采用以下做法也可以：

#include <iostream>
using namespace std;

char * find1(char array[], char search, char * pa){
	pa='\0';
	for(int i=0;*(array+i)!='\0';i++){
		if(*(array+i)==search){
			pa=(array+i); 
			break;
		}
	} 
	return pa;
}

int main(){
	char str[]={"afsdfsdfdf"}; //待 查找的字符串
	char a='d';
	char * p1,* p2;
	p2=find1(str,a,p1); //调用函数以实 现所要操作。
	if(p2=='\0') cout<<"无";
	else cout<<*p2; 
	
	return 0;
} 

（5）二维指针和二维数组的关系

int ** Ptr        <==>  int Ptr[ x ][ y ];
int *Ptr[ 5 ]     <==>  int Ptr[ 5 ][ x ];
int ( *Ptr )[ 5 ] <==>  int Ptr[ x ][ 5 ];

https://zhidao.baidu.com/question/499491916.html
http://www.cnblogs.com/poissonnotes/p/4371352.html
http://blog.chinaunix.net/uid-22889411-id-59688.html
http://blog.csdn.net/moxiaomomo/article/details/6296157