转载 仅供学习参考

二级指针就是指向指针的指针,所谓指针就是一个整数,里面存着一个地址 
比如 
char c = a; //一个字符型变量 
char *p; //p是一个指向char类型的指针 
p=&c; //现在p里存的是c的地址 
char **q; //q是一个二级指针 
q=&p; //q里存的是p的地址(p如前所述是个整数,所以p占有内存的一块空 
//间,现在q就是指向这个空间的开始) 
printf("%p",q); //p的地址 
printf("%p",*q); //c的地址 
printf("%c",**q); //a 

int A[100]; //A是一个int *型的指针,指向一块内存的开始(当然课本上把这种 
//指向预先分配的空间的指针叫做数组) 
int B[100][100]; //B就是一个int **型的指针 

void F(int **p); 

你可以这样调用F 
F(B);

可以指向一个二维数组。比如 
int iarray[3][4]; 
int **p=iarray; 
可以如此传数组到一个函数。 

二级指针存放的是指向一级指针的地址 
int a=10; //定义一个整型变量，假如内存地址为50 
int *p;//定义一个指针变量。假如分配的地址为100； 
p=&a;//地址为100存放的值为50； 
int *pp//定义一个二级指针变量。假如分配的地址为500； 
pp=&p;//地址为500的存放的值为100

举两个小例子给你看吧。 
1。用二级指针动态申请二维数组。 
void main() 
{ 
int m , n , **p; 
scanf("%d%d" , &m , &n); 
p = (int **)malloc(m * sizeof(int *)) 
//C＋＋中建议使用：p = new int* [m]; 
for(i = 0 ; i < m ; i++) 
p[i] = (int *)malloc(n * sizeof(int)); 
//C＋＋：p[i] = new int[n]; 
} 
这样就实现了二维数组的动态申请，因为一般数组声明时，不允许下标是变量，所以如果想动态决定数组各维的大小，最好这样做。 

2。使用二级指针传递参数，可以在函数内部修改一级指针。 
或许，你已经很熟悉通过传递一级指针，可以在函数内部修改实参指针指向的内容：如： 
void f(char *p) 
{ 
p[2] = a;//由实参指向的函数外部的数组的内容就被改变了。 
…… 
} 
但是，如果我们想改变实参本身呢？也就是说，我们连指针值都要改变，如果使用： 
void f(char *p) 
{ 
p = (char *)malloc(10 * sizeof(char)) 
//或C＋＋中：p = new char[10]; 
…… 
} 
就不行了，因为在函数内部不能通过改变形参的值来改变实参。 
void f(char **p) 
{ 
*p = new char[10]; 
*p[2] = a; 
…… 
} 
可以这样说，传入一个N级指针，就可以修改N-1级指针，原因就是C的参数传递是值传递的，直接修改形参根本改变不了实参，但可以改变行参指针指向的内 容，而N级指针指向的内容就是一个N-1级指针，另外，你可能感觉这样使用似乎有问题，因为原先的内存空间没有释放，是的，这只是个为了说明问题的简化了 的例子，实际的应用场合要比这合适的多。 

最后，指针是C/C＋＋语言的精华，但理解指针还是应该从指针本身去理解，二级指针只是指针的一种，不应该在这里钻牛角尖，多级指针其实还是指针，只不过它指向的内容内容仍是指针而已。

下面这个程序生成PCB，并且按照CoursePriority排序： 
#include <iostream.h> 
struct PCB 
{ 
char CourseName[30]; 
int CoursePriority; 
int CourseCpuTime; 
int CourseStatus;//1:Ready 2:Running 3:Blocked 
struct PCB *next; 
}; 
PCB* createPCB(); 
PCB* insertPCB(PCB*&,PCB*);//指针的引用 
void display(PCB*); 
void distroy(PCB*); 

void main() 
{ cout<<"Creat Head PCB:"<<endl; 
PCB *head=createPCB(); 
PCB *temp; 
char ch; 
cout<<"Continue to create PCB?(y/n):"; 
cin>>ch; 
while(ch==y||ch==Y){ 
temp=createPCB(); 
insertPCB(head,temp); 
cout<<"Continue to create PCB?(y/n):"; 
cin>>ch; 
} 
display(head); 
distroy(head); 
} 

PCB* createPCB() 
{ PCB*t=new PCB; 
cout<<"Set CourseName:"; 
cin>>t->CourseName; 
cout<<"Set CoursePriority:"; 
cin>>t->CoursePriority; 
t->CourseCpuTime=0; 
t->CourseStatus=1; 
t->next=0; 
return t; 
} 
PCB* insertPCB(PCB* &head,PCB* newPCB) 
{ if(newPCB->CoursePriority<head->CoursePriority){ 
newPCB->next=head; 
head=newPCB;//改变了指针本身 
return head; 
} 
PCB*p1=head->next; 
PCB*p2=head; 
while(p1&&p1->CoursePriority<newPCB->CoursePriority){ 
p2=p1; 
p1=p1->next; 
} 
p2->next=newPCB; 
newPCB->next=p1; 
return head; 
} 
void display(PCB*head) 
{ int i=0; 
cout<<"Show sorted PCBs:"<<endl; 
while(head){ 
cout<<"No."<<++i<<": CourseName="<<head->CourseName; 
cout<<", CourePriority="<<head->CoursePriority<<endl; 
head=head->next; 
} 
} 
void distroy(PCB*head) 
{ PCB*t; 
while(head){ 
t=head->next; 
delete head; 
head=t; 
} 
} 

下面这个例子可能对你有点帮助吧！动态分配二维数组： 
#include"stdio.h" 
#include"mem.h" 
char **Foo(int InPut) 
{ 
char **OutPut; 
OutPut=(char **)malloc(InPut*sizeof(char)); 
return OutPut; 
} 
main() 
{ 
char **Array; 
int i,j; 
Array=Foo(16); 
for(i=0;i<4;i++) 
for(j=0;j<4;j++) 
Array[i][j]=i+j; 
for(i=0;i<4;i++) 
{ 
printf("\n"); 
for(j=0;j<4;j++) 
printf("%d",Array[i][j]); 
} 
free(Array); 
} 
其实，二维指针就是二维数组，当然，你可以自己指定Foo()的参数！ 
你可以把一维指针当作一维数组，二维指针当作二维数组。不要考虑太多 
的地址问题，那样只会更糟！

二级指针,即指向指针的指针 
.... 
char **p; 
char *name[]; 
.... 
*(p1++)指向各string 

那么int matrix[][]怎么用指向指针的指针来定义各单元

二级指针是指向指针的指针,储存的是指针的地址,一般用于指针数组,指针数组,数组指针中.