c语言指针是什么，彻底搞懂C语言指针

关于【c语言指针是什么】，今天小编给您分享一下，如果对您有所帮助别忘了关注本站哦。

• 内容导航：
• 1、c语言指针是什么：彻底搞懂C语言指针
• 2、c语言指针是什么，c语言指针介绍

1、c语言指针是什么：彻底搞懂C语言指针

指针是C语言的难点，本篇文章总结一下各类指针的用法。

指针是个变量,它存储的是变量的地址，这个地址指向哪里，取决于指针的类型，指针类型包括以下几种:

基本类型指针

数组类型指针

函数类型指针

结构体类型指针

联合体类型指针

指针类型指针

无具体类型指针

下面阐述各个类型指针的使用方法。

一.基本类型指针

声明方式:

基本类型*p；

变量p是一个基本类型指针，p存储的是基本类型变量的地址,表示p指向了基本类型,基本类型包括char,short,int,float,long,double。

例如int*p，p就变成了一个整型指针，如下图

使用例子:

#include <stdio.h>void swap(int* a, int* b);int main(int args, char *argv[]) {int a = 10;int b = 20;int*pa = &a;//获取变量a的地址赋值给指针paint* pb = &b;printf("%i", *pa);//输出10*pa = *pa + 1;printf("%i", *pa);//输出11int* clonep = pa;printf("%i", *clonep);//输出11clonep = pb;printf("%i", *clonep);//输出20int c = *pa;printf("%i

从上面代码的例子，可以看出以下几点:

a.通过&运算符可以获取一个变量的地址,&运算符只能获取内存变量的地址，不能对常量或者寄存器变量进行&操作。

b.可以通过*p,获取指针p指向的变量的值。

c.函数调用时，会把传入的变量拷贝一份作为参数，这里的拷贝就是把变量的值拷贝了一份，自此后，参数就是一个新的变量，它与传入的变量的值相同，任何对参数值的修改，都不会影响到传入的变量。

指针也是变量，只不过指针的值是地址罢了，所以也可以把指针变量传入给函数作为参数（代码21行），函数调用时，会把传入的指标变量拷贝一份作为参数，这个参数就是一个新的指针变量，它与传入的指针变量指向了同一个地址，所以在函数内部可以对这个参数指针指向的变量进行操作，效果与传入的指针变量一样。

二.数组类型指针

一维数组类型指针的声明方式:

T（*p）[N]；

变量p是一个数组指针,p存储的是一维数组T[N]的地址，表示p指向了一维数组，一维数组的长度为N,一维数组每一项的数据类型为T，T可以是基本类型，指针,结构体，联合体。

例如int(*p)[2]表示p指向了一维整型数组，这个整型数组长度为2，如下图是一个二维数组a[3][2],这个二维数组由3个一维数组（每个一维数组有2个整型元素）组成。

一维数组指针

使用例子

#include <stdio.h>int main(int args, char *argv[]) {int a[3][2] = { {1,2},{3,4},{5,6} };int(*p)[2] = a;printf("%i

上面代码例子定义了一个二维数组a[3][2]

第4行代码:int(*p)[2] = a;a是二维数组的首地址，它是一个常量，所以可以直接赋值给p,a与一维数组a[0]的地址相同即a=&a[0],此时p存储的就是一维数组a[0]的地址，指向了一维数组a[0]。

第5行代码:**和++运算都属于一元运算符，它们的优先级相同，但运算方向是从右向左的，因此先执行p++,而p++的意思是先操作p变量，然后再将p变量+1，这里操作p变量的意思是先执行**p,为什么需要两个*才能获取到二维数组的元素值呢，原因如下：

**p是从右向左执行的，先执行右边的*，因此先执行*p，*p的意思获取p指向的变量，而p指向的是一维数组，所以*p的结果就是a[0],a[0]是个一维数组,所以**p=*(a[0]),C语言规定，对数组可以执行*操作时，会临时转化为一个指针，因此可以a[0]就临时变成了一个指针，再次对a[0]进行*操作后，就获取到了a[0]这个一维数组第一个元素的值即1。

第6行代码:第5行代码p++后，p指向了a[1]的地址，如下图

类似于第5行代码的执行方式,此时**p++后，获取的变量值为a[1]的第一个元素即3

第7行代码:第6行代码p++后，p指向了a[2]的地址，如下图

因此执行**p后获取了a[2]数组的第一个元素即5。

第8行代码:第8行代码p = &a[0];获取第一个一维数组的地址，赋值给变量p。

第9行代码:printf("%i", **++p);先对p变量+1，执行后，p指向了a[1]，然后再执行**就获取到了a[1]的第一个元素。

上述介绍的是一维数组指针，其实可以扩展到N维数组指针，声明方式如下:

T（*p）[N1][N2][N3]...[NN]；

p为指向一个N维数组，这个N维数组存储的数据类型为T。

假设一个三维数组a[4][3][2],定义二维整型数组指针p,声明如下:

int (*p)[3][2];

p就是一个二维整型数组指针，p指向了二维数组,这个二维数组，有3行两列数据，每个存储单元存储的是整型数据，代码例子如下：

#include <stdio.h>int main(int args, char *argv[]) {int a[4][3][2] = { { {1,2},{3,4},{5,6}},{{7,8},{9,10},{11,12}},{{13,14},{15,16},{17,18} } , { {19,20},{21,22},{23,24}}};int(*p)[3][2] = a;printf("%i

好了，数组指针就介绍到这里了。

与数组指针比较类似的一个概念就是指针数组，指针数组是一个数组，数组的每个元素是个指针，这个指针可以是一个任何类型的指针，声明如下:

T *p[N];

p是个数组，这个数组长度为N,数组中的每个元素包含一个指向类型T的指针。

例如int *p[6],p是个数组，它的长度为6，每个数组存储的是整型指针，如下图

整型指针数据

T可以是基本类型，结构体类型，联合体类型,指针类型等。

代码例子

#include <stdio.h>int main(int args, char *argv[]) {int a = 1;int b = 2;int c = 3;int* pa = &a;int* pb = &b;int* parray[3] = {pa,pb,&c};printf("%i", *parray[0]);//输出1printf("%i", *parray[1]);//输出2printf("%i", *parray[2]);//输出3}

当然p也可以是N维数组，N维数组中存储的是指向T类型的指针，声明如下:

T *p[N1][N2][N3]....[NN];

现在来对比下：数组指针和指针数组的声明方式，看看有什么区别?

数组指针:T (*p)[N]

指针数组:T *p[N]

看起来声明方式比较类似，我们可以通过运算符优先级来分析上边的表达式，为什么是数组指针或者指针数组。

（），[]运算符的优先级大于*运算符，（），[]优先级相同，（），[]从左向右进行运算

先来看看T (*p)[N]

先执行(*p)，这个执行后，表示p是一个指针,然后这个指针指向哪里呢？紧接着执行[N],表示这个指针指向了一个一维数组，这个一维数组的长度为N,最后的T表示数组中每个元素的类型。

T *p[N]

没有了(),[N]的优先级比*高，所以先执行p[N],表示p是一个长度为N的数组,数组里元素的类型是什么呢?,然后执行*p,表示数组中元素存储的是指针，最后的T表示指针指向的类型为T。

因此通过优先级分析，即使以后忘了，也可以通过这种方式回忆起来。

三.函数类型指针

声明如下:

T (*p)(参数1,.....参数n)

p存储的函数的地址，指向了函数，函数的返回类型为T,参数列表为参数1~参数n。

例如一个例子int (*p)(int a, int b)，表示p是个函数指针，函数的返回类型为整型，参数列表为两个整型。

代码例子:

#include <stdio.h>int swap(int i, int j);int main(int args, char *argv[]) { int a = 1; int b = 2; int (*f)(int i, int j); f = swap; printf("%i", (*f)(a, b));//输出3 printf("%i", f(a, b));//输出3}int swap(int i, int j) { return i + j;}

T (*p)(参数1,.....参数n)中T可以为基本类型，指针，结构体,联合体。

函数指针作为指针，同样也可以作为函数的参数，例子如下

#include <stdio.h>int swap(int i, int j);void test(int i, int j, int (*f)(int i, int j));int main(int args, char *argv[]) { int a = 1; int b = 2; test(a, b, swap);}void test(int i, int j, int (*f)(int i, int j)) { printf("%i",(*f)(i,j));//输出3};int swap(int i, int j) { return i + j;}

第7行代码:swap是一个函数地址，是个常量，将这个函数地址传输给函数时，自动转化为函数指针。

好了，函数指针介绍到这里了。

有一个与函数指针容易混淆的概念就是返回指针的的函数,返回指针的函数的声明方式如下:

T *f(参数列表)

f是一个函数，它的返回类型为指向T的指针,T可以是基本类型，指针，结构体，联合体。

函数指针和返回函数的指针这两个概念容易混淆，不过可以根据运算符的优先级分析，快速得出一个表达式是函数指针还是返回函数的指针，如下所示

函数指针：T (*p)(参数列表n)

返回指针的函数: T *f(参数列表n)

先分析T (*p)(参数列表n),()的优先级比*高,（）从左向右开始运算，因此先运算(*p)，运算后，表明p就是一个指针，然而这个指针指向哪里呢？紧接着分析(参数列表n)，分析(参数列表n)后，表明指针指向了一个函数，这个函数的参数列表就是参数列表n,然后再分析这个函数的返回类型,发现函数的返回类型为T,因此p就是一个指向函数的指针，函数的参数列表为参数列表n,返回类型为T。

再来分析T *f(参数列表n),()的优先级比*高,因此先运算f(参数列表n),表明f是一个函数，这个函数的参数列表为参数列表n,那么这个函数的返回类型什么呢?,紧接着分析*,表明返回的类型为一个指针,这个指针指向哪里呢?再分析T，这个指针指向T,因此f是一个函数，参数列表为参数列表n,返回值为指向T类型的指针。

四.结构体类型指针

声明方式如下:

struct结构体类型{

.............

}*p;

例如结构体声明如下

struct point {

int x=10;

int y=20;

} ;

那么结构体类型指针声明如下

struct point *p;p就是一个指向结构体类型point的指针。

例子如下

#include <stdio.h>struct point {int x;int y;};int main(int args, char *argv[]) { struct point p;p.x = 10;p.y = 20;struct point* pp = &p;printf("%i

上述代码中->是C语言提供的结构体指针访问成员的快捷方式。

结构体类型指针，也可以作为函数参数和返回值

#include <stdio.h>#include <stdlib.h>struct point {int x;int y;};struct point* copy(struct point* p);int main(int args, char *argv[]) { struct point p;p.x = 10;p.y = 20;struct point *copyp = copy(&p);copyp->x = 30;copyp->y = 40;printf("%i", copyp->x);//30printf("%i", copyp->y);//40printf("%i", p.x);//10printf("%i", p.y);//20}struct point *copy(struct point *p) {struct point* clone = malloc(sizeof(struct point));clone->x = p->x;clone->y = p->y;return clone;}

第22行代码:通过malloc分配一个结构体point,point占用的空间在编译时已经能够确定，因此通过malloc创建一个结构体指针是很常见的一种方式。

五.联合体类型指针

联合体类型指针的申明方式如下:

union 联合体类型 {

.........

} *p;

下边为例子

#include <stdio.h>#include <stdlib.h>union tag* copy(union tag* p);union tag {int itag;float ftag;};int main(int args, char *argv[]) {union tag t;t.itag = 2;union tag* p = &t;printf("%i", p->itag);union tag *copyp = copy(p);//2printf("%f", copyp->ftag);//12.200000}union tag*copy(union tag*p) {union tag* clone = malloc(sizeof(union tag));clone->ftag = p->itag + 10.2f;return clone;}

第16行代码：联合体也可以作为函数的参数，也可以作为函数的返回值。

六.指针类型指针

指针类型指针就是指向指针的指针。

声明格式如下:

T **p;

T类型可以是基本类型,结构体，联合体,指针。

例如char **p表示p指针指向字符指针,如下图

如上图所示p是个指针，它存储的指向char类型指针m的地址，m为一个指向字符的指针。

例子如下

#include <stdio.h>#include <stdlib.h>void print(char* chars[]);int main(int args, char *argv[]) {char* pc1 = "hello,world";char* pc2 = "how old are you";char** p1 = &pc1;char* pca[2] = { pc1,pc2 };//pca是个数组，存储两个char*printf("%s", *p1);//hello,worldprintf("%s", pca[0]);//hello,worldprintf("%s", pca[1]);//how old are youprintf("%s", *pca);////hello,worldprint(pca);}void print(char* chars[]) {printf("%s", *chars++);//hello,worldprintf("%s", *chars);//how old are you}

第8行代码:pca是一个数组，这个数组有2个元素，存储的指向char类型的指针。

第13行代码:pca是一个常量，C语言规定，一个数组传递给函数作为参数时，会自动转化为一个指针。

第16行代码:chars变成一个指针，这个指针指向了指针数组的首地址,如下图

七.无具体类型指针

声明格式如下:

void *

表明该指针不能确定指向哪里，因此可以将任何指针赋值给该类型的指针。

代码如下:

#include <stdio.h>int main(int args, char *argv[]) {char* pc = "hello,world";void* pcvoid = pc;printf("%s", (char*)pcvoid);//输出hello,world}

番外篇

对指针可以增加限制符const

const T *const D

第一个const表示指针指向的内容不可以变，第二个const表示指针不能修改即指针变量的地址不能修改。

2、c语言指针是什么，c语言指针介绍

c语言指针其实是一个整形变量,与其它数据不同的是,它的作用是用来存储其它变量的地址指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元，下面我们就来说一说关于c语言指针是什么?我们一起去了解并探讨一下这个问题吧!

c语言指针是什么

c语言指针其实是一个整形变量,与其它数据不同的是,它的作用是用来存储其它变量的地址。指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。

因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

再打个比方:有个人让你去麦当劳帮我买个雪糕,那么麦当劳是这个变量a，但是那个人现在把麦当劳所在的地址写在纸上给你,那么这张纸就可以看做一个指向麦当劳的指针。

本文关键词：x在c语言中等于什么7,!，c语言指针是什么数据类型，c语言指针是什么意思，c语言指针到底是什么，c语言指针是什么PPT。这就是关于《c语言指针是什么，彻底搞懂C语言指针》的所有内容，希望对您能有所帮助！