指针的学习和理解

初级

1、指针的概念

在64位操作系统中，不管什么类型的指针都占8个字节

int a=1;
int* p=&a;//p就是一个整型的指针，保存了a的地址

2、指针和变量

int* p=&a;
   * p=100; // 等价于a=100
     p //p=&a

*·有两种定义：

• 定义的时候（前面有类型），表示后面的变量是指针
• 使用的时候，表示取值（取指针指向的内存空间里的值）

intp1 和 charp2 字节大小一样，但步长不一样。p1+1指向下一个整型，跨4个字节；p2+1指向下一个char型，跨1个字节

并不是指针一定能保存地址，而是要保存相同类型的地址。

指针作为函数参数

比如本来传给函数是一个结构体参数，但结构体成员很多，占很多字节；如果传入结构体的地址，就只需要8个字节，很省空间。
如果要交换实参，一定要传入地址

指针的运算

inta,*pa=&a,*pb;
pb=pa; //pa、pb都指向a，pa就是变量，pb=pa就是正常的变量赋值，只不过这个变量值是a的地址

经典笔试题

int x=3,y=0,*px=&x;
y=*px+5; //y=8
y=++*px; //y=4,x=4
y=(*px)++ //y=4,x=5
y=*px++; //y=5,px变成了野指针，指向了后面4个字节。先赋值，然后指针指向地址+1
//区分*px++、++*px

练习实现字符串数组赋值

#include <stdio.h>
void mystrcp(char* dest,const char*src)
{
	while(*src != '\0')
	{
		*dest++ = *src++; //*dest=*src ,然后两个指针各自后移下个地址
	}
}
int main()
{
	char s1[32]="hello";
	char s2[32]={0};
	mystrcp(s2,s1);
	printf("%s\n",s2);
    return 0;
}

然后是这里的const

void f()
{
	int num;
	const int *p1=# //const 修饰*p1，即指针指向的值不可以变，但指针本身（即指向的地址）可变
	p1++;
	
	int *const p2=# //const 修饰p2，即指针不可以变，指针本身（即指向的地址）不可变，但指针指向的值可变
	(*p2)++;
	
	const int *const p3=#
}

空指针和野指针

#include <stdio.h>
#include <stdlib.h>  //malloc
int main()
{
	int*p; //野指针
	*p=100; //段错误，访问了不能访问的内存
	int*p=NULL;//指向地址为0的内存，空指针也不能用，只是我们知道
	//如何合法 使用内存
	//1、系统分配的内存
	int a;
	int *p1=&a;//a这4个字节可以使用
	//2、申请内存(堆内存)
	//申请的内存得知道地址，编译时申请
	char *str=(char *)malloc(32);//返回void* 万能指针类型，看如何使用
	free(str);//释放内存，如果不释放，内存泄漏。 str为要释放内存的地址
	str=NULL;//如果不变为空指针，就成为了野指针
	return 0;
}

练习

去掉字符串中的空格

#include <stdio.h>

void f(char* dest,const char*src)
{
	while(*src++!='\0')
	{
		if(*src!=' ')
		{
			*dest++=*src;
		}
	}
}

int main()
{
	char s1[32]="abcd eef ed";
	char s2[32]={0};
	f(s2,s1);
	printf("%s\n",s2);
	return 0;
}

不使用数组

#include <stdio.h>
#include <stdlib.h>

void delete_space(char*s)
{
	while(*s!='\0')
	{
		*s=*(s+1);
		s++;//s=s+1 地址移动
	}
}
int main()
{
	char *str=(char*)malloc(128);
	char ch;
	int i=0;
	while((ch=getchar())!='\n')
	{
		//str[i++]=ch; //等于数组了
		*(str + i++)=ch; //str+i，然后i=i+1，str没有变化
	}
	printf("%s\n",str);
	char*begin=str;
	while(*str!='\0')
	{
		if(*str==' ')
		{
			delete_space(str);
		}else
		{
			str++;
		}
	}
	printf("%s\n",begin);
	return 0;
}

当有一个字符数组 char str[N]; 或一个通过 malloc 分配的字符指针 char *str = (char *)malloc(N * sizeof(char)); 时，str 在表达式中可以被视为一个指向数组（或动态分配的内存块）首字符的指针。

3、指针和数组

数组名是常指针（地址常量），不可以修改。原先声明时是在栈里找到一块也用内存，现在往后挪，后面那个位置不一定可用。
p是一个指针，p++，也就是地址移动一次，原来指向h，现在指向e，指向下一个元素

int main()
{
	char str[32]="helloword";
	char*p="helloword";
	//str++ 报错
	p++;

	str[0]='x';
	//p[0]='x'; //字符串常量不能修改
	
	printf("%d\n",sizeof(str)); //32
	printf("%d\n",sizeof(p)); //8字节
	return 0;
}

弄明白指针和数组在内存里如何存储的

另外，数组名通过参数传到函数时，变成了指针

void f(int a[])
{
	printf("%d\n",sizeof(a)/sizeof(a[0])); // 8/4=2
}
int main()
{
	int a[10]={0};
	
	printf("%d\n",sizeof(a)/sizeof(a[0])); //10
	f(a); //2
	return 0;
}

练习

p1[0] , p2[0] , p3[0] 的值分别为多少？

int a[5]={1,2,3,4,5};
int *p1=(int*)(&a+1);
int *p2=(int*)((int)a+1);
int *p3=(int*)(a+1);

&a表示数组的地址 ，a 表示数组首元素的地址。虽然两者值相等，但含义完全不一样，&a+1表示到下一个数组的地址， a+1下一个元素

p1: &a+1，int*作了一个类型强制转换，原来是一整块的地址，现在变成了首地址，所以p1是一个野指针

p2: (int)a 强转为了一个整数，然后+1，最后(int*)转为地址，现在p2指向首元素的第2个字节。这种访问是错误，c语言里访问一个整数必须从这个整数的第一个字节地址访问。

p3：指向2

p1[0] p2[0] p3[0] 等价于*p1[0] *p2[0] *p3[0]
指针的数组下标访问：在C语言中，使用指针和数组下标是等价的。当你使用p[0]时，这实际上是在说“从指针p指向的位置开始，偏移0个元素的位置的值”。由于偏移是0，所以它直接指向p当前指向的元素。

#include <stdio.h>
int main()
{
	int a[]={1,2,3,6,7};
	int*p=a;
	printf("%d\n %d\n",p[3],*p);// 6 1
	return 0;
}

4、指针和字符串

比较直白简单的定义

char st[]="helloworld" //数组

char*s = "helloworld" //指针s指向了h的地址

复杂点的，指针数组

char* string[] = {"i love china","i am"};

c语言里，括号和中括号优先级高，因此string优先和 [ ] 结合，所以string是个数组，char*代表字符型指针，所以string是一个字符型指针数组，简称指针数组，每个元素是一个指针

int main()
{
	char* string[] = {"i love china","i am"};
	
	printf("%s\n",string); //不会输出，因为string不是一个字符串的地址,是一个地址的地址
	printf("%s\n",string[0]);
	return 0;
}

练习

编写C函数，将" i am from china hello" 倒置为 "hello china from am i " 将句子中的单词倒置，而不改变单词内部结构

#include <stdio.h>
#include <stdlib.h>

#define SIZE 5

int main()
{
	char* str[SIZE]={0};
	int i=0;
	for(;i<SIZE;i++)
	{
		str[i]=(char*)malloc(sizeof(char)*128);
		scanf("%s",str[i]);
	}
	char *t;
	for(i=0;i<SIZE/2;i++)
	{
		t=str[i];
		str[i]=str[SIZE-1-i];
		str[SIZE-1-i]=t;
	}
	for(i=0;i<SIZE;i++)
	{
		printf("%s ",str[i]);
		free(str[i]);
	}
	return 0;
}

假如不知道字符串长度

高级

5、指针 和 函数

函数指针：指向函数的指针
指针函数：返回值是指针的函数

a. 函数指针

在C语言中，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的首地址。把函数的这个首地址（函数入口地址）赋予一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量称为函数指针变量。

函数指针变量定义的一般形式为∶

类型说明符(*指针变量名));

例如︰

int(*pf)（);  //声明

表示pf是一个指向函数入口的指针变量，该函数的返回值（函数值）是整型。

#include <stdio.h>


void f1()
{
	printf("hello\n");
}
int add(int x,int y)
{
	return x+y;
}
typedef int(*T)(int,int); //申明一个新的类型T表示函数指针
int main()
{
	void(*p)();
	p=f1;
	p();
	
	int (*q)(int,int)=add;
	printf("%d\n",q(1,2));
	T qq=add;
	return 0;
}

b.指针函数

在C语言中允许一个函数的返回值是一个指针（地址），这种返回指针值的函数称为指针型函数，简称指针函数。
注意:不能返回局部变量的地址!!!(因为局部变量在函数结束后就被释放了，返回他的地址没有意义)

定义指针型函数的一般形式为∶

类型说明符 * 函数名(形参表){
	/*函数体*/
}

char *init()
{
	//char str[32]={0}; //栈内存不可以，结束后会被释放
	char *str = (char*)malloc(128) //堆内存可以
	return str;
}

其中函数名之前加了*号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。

区别  int （*p）() 和 int *p（）

c. 函数指针的应用：回调函数

把函数名作为另一个函数的参数
作用：修改函数的功能

d. 复杂类型声明

右左法则：先看变量右边，然后看左边
int*(*(*fp)(int))[10]; 
fp是指针，指向函数，函数有一个整型参数，返回值是指针，指向数组，数组有10个元素，每个元素是整型指针

int*(*(*array[5])())();
array是一个数组，有5个元素，类型是指针，指向函数，函数没有形参，函数的返回值是指针，指向函数没有参数，返回值是 int型的指针

6、指针和数组

指针数组：元素是指针的数组

类型说明符 *数组名 [数组长度]
int * pa[3]; pa是一个指针数组，三个元素，每个元素都是指向整型变量的指针

数组指针：指向数组的指针

int(*p)[5] // p+1加几个字节取决于p指向的对象，此时p+1 加20个字节
int *p[5]

a. 数组指针表示二维数组

二维数组：int a[3][4]

a[0]表示首行首元素地址， 4个字节 两者值相等，但是意义不同
a数组名表示首行地址 步长一行16字节
&a表示数组的地址 48个字节

7、指针的指针

编程练习