C语言指针(含例子)

一、指针函数当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。

格式：类型说明符 * 函数名(参数)当然了，由于返回的是一个地址，所以类型说明符一般都是int。

例如：int *GetDate();int * aaa(int,int);函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。

int * GetDate(int wk,int dy);main(){int wk,dy;do{printf(\"Enter week(1-5)day(1-7)\\n\");scanf(\"%d%d\",&wk,&dy);}while(wk<1||wk>5||dy<1||dy>7);printf(\"%d\\n\",*GetDate(wk,dy));}int * GetDate(int wk,int dy){static int calendar[5][7]={{1,2,3,4,5,6,7},{8,9,10,11,12,13,14},{15,16,17,18,19,20,21},{22,23,24,25,26,27,28},{29,30,31,-1}};return &calendar[wk-1][dy-1];}程序应该是很好理解的，子函数返回的是数组某元素的地址。

输出的是这个地址里的值。

二、函数指针指向函数的指针包含了函数的地址，可以通过它来调用函数。

声明格式如下：类型说明符 (*函数名)(参数)其实这里不能称为函数名，应该叫做指针的变量名。

这个特殊的指针指向一个返回整型值的函数。

指针的声明笔削和它指向函数的声明保持一致。

指针名和指针运算符外面的括号改变了默认的运算符优先级。

如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。

例如：void (*fptr)();把函数的地址赋值给函数指针，可以采用下面两种形式：fptr=&Function;fptr=Function;取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。

C语言指针数组介绍定义指针数组输入输出指针数组C语言中，指针数组是一种特殊的数组类型，其中数组的每个元素都是一个指针。

指针数组允许我们存储和操作一组指针，以及通过指针访问和操作内存中的数据。

本文将介绍指针数组的定义、输入输出和常见用途。

1.定义指针数组定义指针数组的语法如下：```数据类型*数组名[大小];```其中，`数据类型`是指针指向的数据类型，`数组名`是指针数组的名称，`大小`是指针数组的大小（即元素个数）。

举个例子，如果想定义一个包含5个整型指针的指针数组，可以这样做：```int *ptrArray[5];```这个定义表示`ptrArray`是一个包含5个整型指针的数组。

输入指针数组的常见方式是使用循环结构逐个为数组元素赋值，可以使用`scanf`函数进行输入。

```for (int i = 0; i < size; i++)scanf("%d", &ptrArray[i]);```输出指针数组的常见方式是使用循环结构逐个打印数组元素的值，可以使用`printf`函数进行输出。

```for (int i = 0; i < size; i++)printf("%d\n", *ptrArray[i]);```注意这里要使用`*`操作符来访问指针指向的值。

3.指针数组的常见用途指针数组在程序设计中具有广泛的应用。

下面是一些常见的用途：-字符串数组：可以通过定义一个指针数组来存储一组字符串，每个元素都是一个指向字符串的指针。

```char *stringArray[5] = {"Hello", "World", "C", "Language", "Pointer"};```-函数指针数组：可以使用指针数组来存储不同函数的指针，以便在运行时根据需要调用特定的函数。

c语言5层指针
在C语言中，你可以定义一个指向指针的指针，然后该指针可以指向其他指针，这样你可以得到一个五层的指针结构。

下面是一个简单的示例：
```c
#include<stdio.h>
int main(){
int a=5;
int*p=&a;//指向整数的指针
int**pp=&p;//指向指针的指针
int***ppp=&pp;//指向指向指针的指针的指针int****pppp=&ppp;//指向指向指向指针的指针的指针的指针
int*****ppppp=&pppp;//指向指向指向指向指针的指针的指针的指针的指针
printf("Value:%d\n",*****ppppp);//输出5
return0;
}
```
在这个例子中，我们首先定义了一个整数变量`a`，然后创建了一个指向`a`的指针`p`。

接着，我们创建了一个指向`p`的指针`pp`，然后是`ppp`、`pppp`和`ppppp`。

当我们解引
用五层指针`*****ppppp`时，我们得到的是原始的整数`a`的值，即5。

注意：使用过多的层数可能会导致代码难以理解和维护。

在编写代码时应尽可能减少使用多级指针。

以下是一个简单的 C 语言指针例题：
c复制代码
#include<stdio.h>
int main() {
int a = 10;
int *p = &a; // 定义一个指向整型变量 a 的指针 p
printf("a 的值为：%d\n", a);
printf("p 所指向的值为：%d\n", *p); // 通过指针访问变量的值
*p = 20; // 通过指针修改变量的值
printf("a 的新值为：%d\n", a);
return0;
}
在这个例子中，我们定义了一个整型变量 a，然后定义了一个指向整型变量 a 的指针 p，并将指
针 p 的初始值设置为变量 a 的地址。

接着，我们通过指针访问变量的值，并修改了变量的值。

最后，我们输出了变量 a的新值。

需要注意的是，在使用指针时需要特别小心，因为指针操作涉及到内存地址的操作，如果操作不当可能会导致程序崩溃或者出现其他不可预期的错误。

在C语言中，二级指针常常被用于处理字符串数组。

下面是一个例子，说明了如何使用二级指针来创建一个字符串数组，并填充它：#include <stdio.h>#include <stdlib.h>#include <string.h>int main() {// 定义一个二级指针，用于存储字符串数组（字符串指针的数组）char **array;int i, j;int size = 5; // 设定字符串数组的大小为5// 为二级指针分配内存，也就是为字符串指针的数组分配内存array = (char **)malloc(size * sizeof(char *));if (array == NULL) {printf("Memory allocation failed!");return 1;}// 为每个字符串分配内存for (i = 0; i < size; i++) {array[i] = (char *)malloc(50 * sizeof(char)); // 分配足够的空间来存储一个50字符的字符串if (array[i] == NULL) {printf("Memory allocation failed!");return 1;}}// 填充字符串数组for (i = 0; i < size; i++) {sprintf(array[i], "String #%d", i); // 使用sprintf函数将格式化的字符串写入到每个字符串中}// 打印字符串数组的内容for (i = 0; i < size; i++) {printf("%s", array[i]);}// 释放内存for (i = 0; i < size; i++) {free(array[i]); // 先释放每个字符串的内存，然后再释放整个二级指针的内存}free(array);return 0;}这个程序首先定义了一个二级指针array，然后为它分配了内存，接着为每个字符串分配了内存，然后填充了每个字符串，最后释放了分配的内存。

C语言指针用法详解C语言指针用法详解指针可以说是集C语言精华之所在，一个C语言达人怎么可以不会指针呢。

下面店铺给大家介绍C语言指针用法，欢迎阅读!C语言指针用法详解(1)关于指针与数组的存储a、指针和数组在内存中的存储形式数组p[N]创建时，对应着内存中一个数组空间的分配，其地址和容量在数组生命周期内一般不可改变。

数组名p本身是一个常量，即分配数组空间的地址值，这个值在编译时会替换成一个常数，在运行时没有任何内存空间来存储这个值，它和数组长度一起存在于代码中(应该是符号表中)，在链接时已经制定好了;而指针*p创建时，对应内存中这个指针变量的空间分配，至于这个空间内填什么值即这个指针变量的值是多少，要看它在程序中被如何初始化，这也决定了指针指向哪一块内存地址。

b、指针和数组的赋值与初始化根据上文，一般情况下，数组的地址不能修改，内容可以修改;而指针的内容可以修改，指针指向的内容也可以修改，但这之前要为指针初始化。

如：int p[5];p=p+1; 是不允许的而p[0]=1; 是可以的;//int *p;p=p+1; 是允许的p[0]=1; 是不允许的，因为指针没有初始化;//int i;int *p=&i;p[0]=1; 是允许的;对于字符指针还有比较特殊的情况。

如：char * p="abc";p[0]='d'; 是不允许的为什么初始化了的字符指针不能改变其指向的内容呢?这是因为p 指向的是“常量”字符串，字符串"abc"实际是存储在程序的静态存储区的，因此内容不能改变。

这里常量字符串的地址确定在先，将指针指向其在后。

而char p[]="abc";p[0]='d'; 是允许的这是因为，这个初始化实际上是把常量直接赋值给数组，即写到为数组分配的内存空间。

这里数组内存分配在先，赋值在后。

(2)关于一些表达式的含义char *p, **p, ***p;char p[],p[][],p[][][];char *p[],*p[][],**p[],**p[][],*(*p)[],(**p)[],(**p)[][];能清晰地知道以上表达式的含义吗?(知道的去死!)第一组：char *p, **p, ***p;分别为char指针;char*指针，即指向char*类型数据地址的指针;char**指针，即指向char**类型数据的指针;他们都是占4字节空间的指针。

c语言指针的用法c语言是一种高级编程语言，它可以直接操作内存中的数据。

指针是c语言中一种特殊的变量，它可以存储另一个变量的地址，也就是内存中的位置。

通过指针，我们可以间接地访问或修改内存中的数据，从而实现更高效和灵活的编程。

本文将介绍c语言指针的基本概念、定义和初始化、运算和应用，以及一些常见的错误和注意事项。

希望本文能够帮助你掌握c语言指针的用法，提高你的编程水平。

指针的基本概念指针是一种数据类型，它可以存储一个地址值，也就是内存中某个位置的编号。

每个变量在内存中都有一个唯一的地址，我们可以用指针来记录这个地址，然后通过这个地址来访问或修改变量的值。

例如，假设有一个整型变量a，它的值为10，它在内存中的地址为1000（为了简化，我们假设地址是十进制数）。

我们可以定义一个指向整型的指针p，并把a的地址赋给p，如下所示：int a =10; // 定义一个整型变量a，赋值为10int*p; // 定义一个指向整型的指针pp =&a; // 把a的地址赋给p这里，&a表示取a的地址，也就是1000。

p = &a表示把1000赋给p，也就是让p指向a。

从图中可以看出，p和a是两个不同的变量，它们占用不同的内存空间。

p存储了a的地址，也就是1000。

我们可以通过p 来间接地访问或修改a的值。

指针的定义和初始化指针是一种数据类型，它需要在使用前进行定义和初始化。

定义指针时，需要指定它所指向的变量的类型。

初始化指针时，需要给它赋一个有效的地址值。

定义指针的一般格式为：type *pointer_name;其中，type表示指针所指向的变量的类型，如int、char、float等；pointer_name表示指针的名称，如p、q、ptr等；*表示这是一个指针类型。

例如：int*p; // 定义一个指向整型的指针pchar*q; // 定义一个指向字符型的指针qfloat*ptr; // 定义一个指向浮点型的指针ptr注意，在定义多个指针时，每个指针前都要加*号，不能省略。

c语言数组指针用法举例C语言中，数组指针是指向数组的指针，也可以说是数组的地址。

它可以通过指针访问数组的元素，这样就可以在函数间传递数组，而不需要将整个数组作为参数传递。

以下是一些C语言数组指针的用法举例：1. 声明数组指针变量：可以通过声明一个指针变量来指向一个数组。

例如：int arr[5] = {1,2,3,4,5};int *p = arr;2. 通过数组指针访问数组元素：可以通过指针访问数组元素。

例如：int arr[5] = {1,2,3,4,5};int *p = arr;printf('%d', *(p+2)); // 输出33. 传递数组指针作为函数参数：可以将数组指针作为函数参数传递，从而在函数中对数组进行操作。

例如：void printArray(int *p, int size) {for(int i=0; i<size; i++) {printf('%d ', *(p+i));}}int arr[5] = {1,2,3,4,5};printArray(arr, 5); // 输出1 2 3 4 54. 动态分配内存并创建数组指针：可以使用malloc函数动态分配内存，并创建指向该内存的数组指针。

例如：int *arr;arr = (int*)malloc(5*sizeof(int));arr[0] = 1;arr[1] = 2;arr[2] = 3;arr[3] = 4;arr[4] = 5;5. 释放动态分配的内存：使用free函数可以释放使用malloc 分配的内存。

例如：int *arr;arr = (int*)malloc(5*sizeof(int));// do something with arrfree(arr);这些都是C语言数组指针的常见用法，掌握这些用法可以更加灵活地处理数组和指针的关系，进而提高程序的效率和可维护性。

c语言中的指针是什么很多学习C语言的新手来说，指针无疑是一个难点。

但是，我觉得指针也是C语言特别重要的一个特性。

那么下面一起来看看店铺为大家精心推荐的c语言中的指针是什么，希望能够对您有所帮助。

为什么说指针是 C 语言的精髓?“指”是什么意思?其实完全可以理解为指示的意思。

比如，有一个物体，我们称之为A。

正是这个物体，有了这么个称谓，我们才能够进行脱离这个物体的实体而进行一系列的交流。

将一个物体的指示，是对这个物体的抽象。

有了这种抽象能力，才有所谓的智慧和文明。

所以这就是“指示”这种抽象方法的威力。

退化到C语言的指针，指针是一段数据/指令(在冯诺易曼体系中，二者是相通，在同一空间中的)的指示。

这是指示，也就是这段数据/指令的起始位置。

但是数据/代码是需要一个解释的方法的。

比如0x0001，可以作为一个整数，也可以作为作为一串指令，也可以作为一串字符，总之怎样解释都可以。

而C语言，在编译阶段，确定了这段数据/指令的“解释方法”。

例如，整型指针，表示的就是可以从这个指针p指向的位置开始解释，解释为一个整数。

一个函数指针，表示的就是可以从这个指针p指向的位置开始解释，解释为一段指令，对应的输入和输出以及返回值按照函数指针的类型，符合相应的要求。

综上，C语言的精髓是指针，但指针不仅仅是C语言的精髓，它是抽象的精髓。

各个语言中都有类似的东西，例如函数，例如引用。

(引用和指针的区别，我的理解，不可以进行+/-偏移操作的指针，就是引用。

随意偏移，很容易使得目标位置不符合其相应的意义，从而造成解释失败，进而崩溃。

而增加了偏移功能的指针，好处是方便表述一堆具有相同类型的数据/指令，数组之类的就是这样的实例。

) 同样的void类型的指针，也是C语言的特色。

void型的指针，就是去掉了指定类型的指针，从而使得可以以任意解释方式，解释指针，这就带来了如上的潜在问题。

但是也可以说，这个C语言的特有威力(我一般都把C语言的威力理解为这个)。

指向结构体的指针在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。

创建结构体指针是极常见的。

下面是一个例子：r是一个指向结构体的指针。

请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。

而malloc语句会从堆上分配45字节的内存。

*r是一个结构体，像任何其他Rec类型的结构体一样。

下面的代码显示了这个指针变量的典型用法：您可以像对待一个普通结构体变量那样对待*r，但在遇到C的操作符优先级问题时要小心。

如果去掉*r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。

使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：r->这种写法和(*r).是完全等效的，但是省去了两个字符。

指向数组的指针还可以创建指向数组的指针，如下所示：或：可见要创建指向整数数组的指针，只需创建一个普通的整数指针即可。

调用malloc分配合适的数组空间，然后将指针指向数组的第一个元素。

访问数组元素既可以用普通的数组下标也可以用指针运算。

C将两种方法视为是等效的。

指向数组的指针这一技巧尤其适用于字符串。

您可以为某个特定大小的字符串分配刚好合适的内存。

指针数组有时声明一个指针数组可以节省大量内存，或者使得某些内存消耗较大的问题得以解决。

下面例子中的代码，声明了一个由10个结构体指针组成的数组，而不是一个结构体数组。

否则这个结构体数组将占用243 *10=2,430字节的内存。

使用指针数组可以最大限度减小内存消耗，直到用malloc语句为记录实际分配内存空间。

作为此过程的演示，下面的代码只为一个记录分配空间，保存某个值后又将空间释放：包含指针的结构体结构体可以包含指针，如下所示：typedef struct{char name[21];char city[21];char phone[21];char *comment;} Addr;Addr s;char comm[100];gets(, 20);gets(s.city, 20);gets(s.phone, 20);gets(comm, 100);ment=(char *)malloc(sizeof(char[strlen(comm)+1])); strcpy(ment, comm);typedef struct{char s1[81];char s2[81];char s3[81];} Rec;Rec *a[10];a[0]=(Rec *)malloc(sizeof(Rec));strcpy(a[0]->s1, "hello");free(a[0]);int *p;int i;p=(int *)malloc(sizeof(int[10]));for (i=0; i<10; i++)*(p+i)=0;free(p);int *p;int i;p=(int *)malloc(sizeof(int[10]));for (i=0; i<10; i++)p[i]=0;free(p);strcpy(r->name, "Leigh");strcpy((*r).name, "Leigh");strcpy((*r).city, "Raleigh");strcpy((*r).state, "NC");printf("%sn", (*r).city);free(r);typedef struct{char name[21];char city[21];char state[3];} Rec;typedef Rec *RecPointer;RecPointer r;r=(RecPointer)malloc(sizeof(Rec));　结构体指针变量的概念 当一个指针变量用来指向一个结构体变量时，称之为结构体指针变量。

c语⾔中，指针加1的情况.指针变量详细介绍指针是⼀个特殊的变量，它⾥⾯存储的数值被解释成为内存⾥的⼀个地址。

要搞清⼀个指针需要搞清指针的四⽅⾯的内容：1. 指针的类型，2. 指针所指向的类型，3. 指针的值或者叫指针所指向的内存区，4. 还有指针本⾝所占据的内存区。

让我们分别说明。

先声明⼏个指针放着做例⼦： 例⼀： (1)int *ptr; (2)char *ptr; (3)int **ptr; (4)int(*ptr)[3]; (5)int*(*ptr)[4];指针的类型 从语法的⾓度看，你只要把指针声明语句⾥的指针名字去掉，剩下的部分就是这个指针的类型。

这是指针本⾝所具有的类型。

让我们看看例⼀中各个指针的类型： (1)int*ptr;//指针的类型是int* (2)char*ptr;//指针的类型是char* (3)int**ptr;//指针的类型是int** (4)int(*ptr)[3];//指针的类型是int(*)[3] (5)int*(*ptr)[4];//指针的类型是int*(*)[4] 怎么样？找出指针的类型的⽅法是不是很简单？指针所指向的类型 当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那⽚内存区⾥的内容当做什么来看待。

从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。

例如： (1)int*ptr;//指针所指向的类型是int (2)char*ptr;//指针所指向的的类型是char (3)int**ptr;//指针所指向的的类型是int* (4)int(*ptr)[3];//指针所指向的的类型是int()[3] (5)int*(*ptr)[4];//指针所指向的的类型是int*()[4] 在指针的算术运算中，指针所指向的类型有很⼤的作⽤。

指针的类型(即指针本⾝的类型)和指针所指向的类型是两个概念。

c语言结构体指针定义摘要：一、结构体指针的定义1.结构体简介2.结构体指针的定义方法3.结构体指针的作用二、结构体指针的引用1.通过结构体指针访问结构体成员2.通过结构体指针操作结构体三、结构体指针的应用1.链表的操作2.文件的操作正文：一、结构体指针的定义C 语言中，结构体是一种复合数据类型，可以包含多个不同类型的成员。

而结构体指针，则是指向结构体的指针变量。

它用于存放结构体的内存地址。

定义结构体指针的方法与普通指针相似，只是在定义时需要加上结构体类型名。

例如，定义一个结构体类型`students`，包含姓名、年龄和分数三个成员：```ctypedef struct {char name[20];int age;float score;} students;```定义一个结构体指针变量`p`，指向`students`类型的结构体：```cstudents *p;```结构体指针的作用是方便我们通过指针访问和操作结构体的成员。

二、结构体指针的引用结构体指针的引用，就是通过结构体指针访问和操作结构体的成员。

1.通过结构体指针访问结构体成员使用结构体指针访问结构体成员的方法与普通指针相似，也是通过指针运算符`*`和点运算符`.`。

例如，访问上面定义的结构体`students`中的姓名成员：```c(*p).name = "张三";```2.通过结构体指针操作结构体结构体指针还可以用于操作结构体，如添加、删除和修改结构体成员等。

例如，给结构体添加一个年龄成员：```cp->age = 18;```三、结构体指针的应用结构体指针在实际应用中有很多用途，如操作链表、文件等。

1.链表的操作链表是一种动态数据结构，通过指针实现节点的连接。

结构体指针可以用于表示链表的节点，从而方便地操作链表。

例如，定义一个链表节点结构体：```ctypedef struct node {students data;struct node *next;} node;```使用结构体指针操作链表节点的示例：```code *head = NULL;ode *tail = NULL;// 添加节点ode *new_node = (node *)malloc(sizeof(node));ew_node-> = "张三";ew_node->data.age = 18;ew_node->data.score = 90;ew_node->next = NULL;if (head == NULL) {head = new_node;tail = new_node;} else {tail->next = new_node;tail = new_node;}// 删除节点ode *delete_node = head;while (delete_node != NULL && delete_node-> != "张三") {delete_node = delete_node->next;}if (delete_node != NULL) {node *temp = delete_node->next;free(delete_node);if (temp == NULL) {head = NULL;tail = NULL;} else {head = temp;}}// 遍历链表ode *cur_node = head;while (cur_node != NULL) {printf("姓名：%s 年龄：%d 分数：%f", cur_node->, cur_node->data.age,cur_node->data.score);cur_node = cur_node->next;}```2.文件的操作结构体指针还可以用于操作文件，如读取、写入文件等。