二级指针各种说法(先转着好看看)

就是指向指针的指针,所谓指针就是一个整数,里面存着一个地址
比如
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);

NO.3 作者： jerry921

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

NO.4 作者： fei1703）

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

NO.5 作者： steedhorse

举两个小例子给你看吧。
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＋＋语言的精华，但理解指针还是应该从指针本身去理解，二级指针只是指针的一种，不应该在这里钻牛角尖，多级指针其实还是指针，只不过它指向的内容内容仍是指针而已。

NO.6 作者： fangrk

下面这个程序生成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;
}
}

NO.7 作者： Rain_Snow

下面这个例子可能对你有点帮助吧！动态分配二维数组：
#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()的参数！
你可以把一维指针当作一维数组，二维指针当作二维数组。不要考虑太多
的地址问题，那样只会更糟！

NO.8 作者： penghuai

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

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

NO.9 作者： jianxin0560

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