C语言的指针、数据、结构体关系总结

#指针的类型、指针所指向的类型

A. 指针存储的数值是内存的一个地址

B. 只要把指针声明语句中的指针名去掉，剩下的部分就是指针的类型

C. 只要把指针声明语句中的指针名和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型

 

例子

代码部分 指针类型 指针所指向的类型

int *ptr; int * int

char *ptr; char * char

int **ptr; int ** int *

int (*ptr)[3]; int (*)[3] int ()[3]

int *(*ptr)[4]; int *(*)[4] int *()[4]

 

#指针的值

A. 指针的值是指指针本身存储的数值，这个值会被编译器当做一个地址进行编译

B. 指针本身的大小是一个字长（32位机是4字节，64位机是8字节）

C. 指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度是sizeof(指针所指向的类型)的一片连续内存区域

   注1. 说一个指针的值是X，就是说该指针指向了以X为首地址的一片内存区域

   注2. 说一个指针指向了某块内存区域，相当于说该指针的值是这块内存区域的首地址

D. 指针所指向的内存区和指针所指向的类型是两个完全不同的概念

   注1. 指针光声明但不初始化时，它所指向的内存区域是不存在的

 

#指针运算

A. 指针可以加减一个整数，注意这种运算的意义和通常的数值加减运算的意义是完全不一样的

 

例子

代码部分 分析部分

int a[20]; 定义一个int类型的数组

int *ptr = a; 该指针的类型是int *，指向的类型是int，被初始化为a的首地址

ptr++; 把ptr的值加上sizeof(int)，也就是指向了第2个元素的地址，即&a[1]

 

例子

代码部分 分析部分

char a[20]; 定义一个char类型的数组

int *ptr = a; 该指针的类型是int *，指向的类型是int，被初始化为a的首地址

ptr += 4; 把ptr的值加上sizeof(int)，在32位机上就是加上了4个int类型的长度，即为4*4=16个字节

由于char类型的长度是1个字节，这样指针就指向了第17个元素的地址，即为&a[16]

#运算符&和*

A. & 取址符

B. * 取值符

 

例子

代码部分 分析部分

int a, b; 定义int类型的变量a、b

int *p, **ptr; 定义指向int类型的指针p、指针的指针ptr

p = &a; a是int类型，&a是取到a的地址，所以&a的类型是int *，赋值给同为int *类型的指针变量p

*p = 24;

ptr = &p; p是int *类型，&p取到的是的是p的地址，所以&p的类型是int **，赋值给同为int **类型的指针变量ptr

*ptr = &b; b是int类型，&b取到的是b的地址，所以&b的类型是int *，赋值给同为int *类型的指针变量*ptr

**ptr = 24; 

 

#指针表达式

A. 如果一个表达式的最后结果是一个指针，那么这个表达式就叫做指针表达式

 

例子

代码部分 分析部分

int a, b;

int array[10];

int *pa;

pa = &a a是int类型，&a是int *类型，所以&a是一个指针表达式

int **ptr = &pa; pa是int *类型，&pa是int **类型，所以&pa是一个指针表达式

*ptr = &b; b是int类型，&b是int *类型，所以&b是一个指针表达式

pa = array;

pa++; pa自增1，返回值同样是一个指针，是指针表达式

 

#指针和数组的关系

A. 数组的数组名可以看做是个指针（注意用词，“可以看做是”，只是作为右值自动转化为指针）

 

例子

代码部分 分析部分

int array[10] = {0,1,2,3,4,5,6,7,8,9}, value;

value = array[0]; 同value = *array

value = array[3]; 同value = *(array + 3)

value = array[4]; 同value = *(array + 4)

 

如该例，定义一个数组 TYPE array[n]，则数组名array有如下几层含义

1). 它代表整个数组，类型是TYPE[n]

2). 它是一个指针，类型是TYPE *，指向的类型是TYPE

3). 有单独的内存区，和数组第0号单元占据的内存区不同

4). 该指针相当于一个指针常量，不可以修改

 

#指针和结构体

A. 可以自定义一个指向结构体类型对象的指针

 

例子

代码部分 分析部分

struct MyStruct

{

int a, b, c;

};

 

struct MyStruct s = {2, 3, 4};

struct MyStruct *p = &s; 使用p->a, p->b, p->c来访问每个成员变量

int *ptr = (int *)&s; 使用*ptr, *(ptr + 1), *(ptr + 2)来访问每个成员变量

 

#指针和函数

A. 可以把一个指针声明为一个指向函数的指针

 

例子

#include <stdio.h>

void fun(char *s)

{

printf("hello, %s\n", s);

}

 

int main (int argc, const char * argv[]) {

    // insert code here...

void (*pfun)(char *) = fun;

pfun("john");

return 0;

}

 

#一些复杂声明的解释

int (* func)(int *p)

1. 先找到未定义的标识符，这里是func，func被一对括号所包围，且前面有个*号，说明func是一个指针

2. 后面有括号，说明(* func)是一个函数，而func是一个指向函数的指针

3. 这个函数的形参是int *

4. 整个函数的返回值是个int

5. 结论，这是一个返回值是int、形参为int *类型的一个指针函数

 

int (* func)(int *p, int(*f)(int *))

1. (* func)是一个函数

2. 这个函数有两个形参，类型分别是int *和int (*)(int *)，也就是一个返回值为int的指针函数

3. 整个函数的返回值是int

4. 结论，这是一个返回值是int、形参分别为int *和一个返回值为int的指针函数的一个指针函数

 

int (* func[5])(int *p)

1. (* func[5])是一个函数

2. func是一个有5个元素，每个元素都是一个函数指针

3. 这个函数有一个类型为int *的形参

4. 这是返回值是int、形参是int *类型的函数指针数组

 

int (* (* func)[5])(int *p)

1. func是一个指针数组

2. 这个指针数组的元素是指针

3. 总结，func是一个指向数组的指针，数组的元素是函数指针，这些指针指向具有int *形参，整个函数返回值为int