定义

  1.指针就是个变量，用来存放数组，地址唯一标识一块内存空间。

  2.指针的大小是固定的4/8个字节（32位平台、64位平台）。

  3.指针是有类型。指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

  4指针的运算

指针类型

    int* p; //整形指针 - 指向整形的指针
    char* pc; //字符指针 - 指向字符的指针
    void* pv; //无类型的指针 - 指向无类型的指针
    void* parr[5]; //指针数组 - 由指针构成的数组
    void (*parra)[5];//数组指针 - 指向数组的指针
    void (*parrf)(void,void);//函数指针 - 指向函数的指针

整形指针

        一个类型为“整形指针”的变量，存储了一个整形变量的地址。

	//int 类型指针步长为4
    char str[] = "123456789";
	int* pi = (int*)str;
	printf("%p,%p,%d", pi, pi + 1, (int)(pi + 1) - (int)pi);//输出，地址1，地址1+4，4

 字符型指针

          一个类型为“字符指针”的变量，存储了一个字符变量的地址。

	//char 类型指针步长为1
    char str[] = "123456789";
	char* pi = (char*)str;
	printf("%p,%p,%d", pi, pi + 1, (int)(pi + 1) - (int)pi);//输出，地址1，地址1+1，1

 构造体型指针

         一个类型为“构造体指针”的变量，存储了一个构造体变量的地址。

//本方式中struct存储占用16字符，所以起步长为16
//需要注意构造体的存储方式
typedef struct MyStruct
{
	int ccc;
	int ccc2;
	int ccc3;
	int ccc4;
} struct_new;
int main() {
	struct_new* p;
	char str[] = "123456789";
	p =(struct_new*)str;
	printf("%p,%p，%d",  p, p + 1,(int)(p+1)-(int)p);//地址1，地址1+16,16
}

struct 的 sizeof 并不总是等于每个成员的 sizeof 总和。这是因为编译器添加了填充padding bytes以避免对齐问题。仅当结构体的成员后面有占有更多内存的成员，或在结构末尾时才添加填充padding。不同的编译器可能有不同的对齐约束。

#include <stdio.h>
int main()
{
	struct A {

		// sizeof(int) = 4
		int x;
		// Padding of 4 bytes

		// sizeof(double) = 8
		double z;

		// sizeof(short int) = 2
		short int y;
		// Padding of 6 bytes
	};
	printf("Size of struct: %ld", sizeof(struct A));
	return 0;
}

 存储顺序不变，与最长的一位类型对齐，所以struct A的长度为24。

// C program to illustrate
// size of struct
#include <stdio.h>
int main()
{
	struct B {
		// sizeof(double) = 8
		double z;

		// sizeof(int) = 4
		int x;

		// sizeof(short int) = 2
		short int y;
		// Padding of 2 bytes
	};
	printf("Size of struct: %ld", sizeof(struct B));
	return 0;
}

 上一位的填充可以放下该位置，着将数据放置其中。

指针数组

        一个类型为“整形指针”的数组变量，存储了多个整数变量的地址。 

	int a[5] = { 1,2,3,4,5 };
	int* parr[5] = { &a[0],&a[1],&a[2],&a[3],&a[4] };
	printf("%d,%d,%d,%d,%d",*parr[0], *parr[1], *parr[2], *parr[3], *parr[4]);
    //输出1,2,3,4,5

 类型 指针[m]

 数组指针

一个类型为“数组指针”的变量，存储了一个“数组变量”的地址。 

	int a[5] = { 1,2,3,4,5 };
	int(*parr)[5] = a;
	printf("%d", *((int*)(parr+1)-1));
    //输出5

数组指针parr存储a数组的地址，因为parr是数组指针，所以parr+1增加5*4=20个字节，在被（int*）转化为整形指针后(int*)(parr+1)-1减少4个字节，最后指向a[5]的地址，输出5。

类型 指针[n]

数组指针数组

int main() {
	int a[5] = {1,2,3,4,5};
	int b[5] = {6,7,8,9,10};
	int(*parr[2])[5];
	parr[0] = &a;
	parr[1] = &b;
	//printf("%x,%x\n", &a,&b);
	printf("%d,%d", *((int*)parr[0]+3), *((int*)(parr[1]) + 0));
    //输出4,6
}

 一个parr[2]指针数组，指向的数组类型为int长度为5。

类型 (指针[m])[n]

函数指针

    int add(int a, int b) {
	    return a+b;
    }
    int main() {
	    int a = 1;
	    int b = 1;
    	int (*ptemp)(int, int) = add;
	    printf("%d", ptemp(a, b));
        //输出2
    }

对于函数指针int (*ptemp)(int,int)=temp;中int (*ptemp)(int,int)=temp;3个变量类型都是与temp保持对齐的。

 函数指针数组

int add(int a, int b) {
	return a+b;
}
int cut(int a, int b) {
	return a - b;
}
int main() {
	int a = 1;
	int b = 1;
	int (*ptemp[2])(int, int) = {add,cut};
	printf("%d,%d", ptemp[0](a, b),ptemp[1](a,b));
}

函数指针数组的定语是在int (*ptemp[2])(int, int)而不是int (*ptemp)(int, int)[2]。

函数类型 指针(参数1类型，参数2类型)。