不再为指针发愁（强力推荐）

何为指针，指针就是一个地址，内存地址。int a=100; int *p=&a; p是一个指针，这个指针指向了一个整数a, p就是一个地址，里面存放着变量a

说得更形象一点吧，指针跟变量的关系就像是钥匙和抽屉的关系，抽屉(指针)是用来打开(指向)抽屉(变量)的。而抽屉里面的东西，就是*p,p所指向的变量的值。

01.#include<iostream>  
02.#include<string>  
03.using namespace std;  
04.int main(){  
05.    int chouti;//一个抽屉  
06.    chouti=10086;//抽屉里面放了一张电话卡  
07.    int *yaoshi=&chouti;//钥匙，并且说明了钥匙是对应哪个抽屉的  
08.      
09.    cout<<yaoshi<<endl;   //输出抽屉的地址  
10.    cout<<&chouti<<endl;  //输出抽屉的地址  
11.    cout<<*yaoshi<<endl;  //取出抽屉里面的电话卡  
12.    system("pause");  
13.    return 0;  
14.}  

有人老是混淆 char *,string等，下面简单解析一下，

大家都知道char是C/C++内置类型，而string是c++的一个类，两者是有区别的，一个是字符'用' '括着，一个是字符串，用" "括着。

特别注意，字符数组最后面一个元素是'\0',是用来判断结束的标志

这样子对指针是不是有那么点印象了，不用怕，跟着我的脚步，下面来到指针之初体验：

01.#include<iostream>  
02.#include<string>  
03.using namespace std;  
04.int main(){  
05.    char c='h';    //定义一个字符  
06.    char *p=&c;    //初始化指针  
07.    cout<<*p<<endl;//解析p  
08.  
09.    char *pp=new char;     //分配内存  
10.    *pp='e';         //给解析指针赋值的时候，一定要先new一个  
11.    cout<<*pp<<endl;  
12.  
13.    char *ppp="hello world"; //初始化一个指针  
14.    cout<<ppp<<endl;        //输出结果，有的人就奇怪了，为什么解析不用*的，因为ppp指向的是数组，ppp就一个数组，用数组即可  
15.      
16.    char cc[]="hello wrold"; //定义一个字符数组  
17.    char *pppp=cc;          //数组名就是数组的首地址  这个时候cc=&cc[0];  
18.    cout<<pppp<<endl;       //输出结果  
19.  
20.    string s="I love Cplusplus";  
21.    char *ppppp=&s[0];      //因为string是有字符构成的，但是string又不是char,所以首地址要这样赋值，不能char *ppppp=s;类型不匹配  
22.    cout<<ppppp<<endl;    //输出结果  
23.  
24.    system("pause");  
25.    return 0;  
26.}  
 

这样子，够清晰吗，一定得动手调试一下，看看内存地址，看看解析，方能理解其中的关系。

总结一下上面的代码，就一句话， type *指针是一个数组（自己酝酿一下）

接下来，我们来看看二维指针，乃至多维。

二维指针就跟二维数组一样，二维数组是一维数组的数组，那么相对应的，二维指针就是一维指针的指针，或者说是指向数组的指针。

初始化二维数组的时候，第二维是给定大小，因为要知道第二维，才能给数组分配内存。而初始化二维指针也是一样的道理：

int a[][3]={{1,2,3},{4,5,6}};这是正确的初始化数组的方式 那么a就代表着&a[0][0]

下面初始化二维指针 int (*p)[3]=a;这样就初始化了二维指针，(*p)[3]一定要这样写，不能漏掉括号，优先级问题，自己翻翻书，当然这不是唯一初始化二维（多维）数组的方式

看看代码的实现吧。

01.#include<iostream>  
02.#include<string>  
03.using namespace std;  
04.int main(){  
05.    int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};//初始化二维数组  
06.    int (*p)[4];                                   //指向数组的指针  
07.    for(p=a;p!=a+3;++p){                            //循环输出内容  
08.        for(int *q=*p;q!=*p+4;++q){                 //*p指向的是首行地址  
09.            cout<<*q<<"\t";                          //输出结果  
10.        }  
11.        cout<<endl;  
12.    }  
13.    system("pause");  
14.    return 0;  
15.}  

自个琢磨琢磨，要弄明白喔；

下面定能让你茅舍顿开：

01.#include<iostream>  
02.#include<string>  
03.using namespace std;  
04.int main(){  
05.    int a=10086;  
06.    int *p=&a;      //一维指针  
07.    int **pp=&p;     //二维指针是一维指针的指针，这下明白了吧，下面也一样的道理  
08.    int ***ppp=&pp;  
09.    int ****pppp=&ppp;  
10.    // ... 任意维都行  
11.    cout<<****pppp<<endl;  
12.    cout<<***ppp<<endl;  
13.    cout<<**pp<<endl;  
14.    cout<<*p<<endl;  
15.    system("pause");  
16.    return 0;  
17.}  

这回你没有白来吧，再用一个程序巩固一下吧：

01.#include<string>  
02.using namespace std;  
03.int main(){  
04.    char **mychr;  
05.    char chr[]={"I love cplusplus"};  
06.    char chrs[]={"I love cplusplus"};  
07.    char *p=chr;  
08.    mychr=&p;  
09.  
10.    if(strcmp(*mychr,chrs)==0)  
11.    {  
12.        cout<<"equal"<<endl;  
13.    }  
14.    else  
15.    {  
16.        cout<<"not equal"<<endl;  
17.    }  
18.      
19.    cout<<&chr[0]<<endl;  
20.    cout<<&p<<endl;  
21.    cout<<&(*mychr)<<endl;  
22.    cout<<**mychr<<endl;  
23.    system("pause");  
24.    return 0;  
25.}  

体会一下，输出的那些都是什么，代表什么含义。