C语言的难点 指针

一.指针的重要性

1. 表示一些复杂的数据结构
2. 快速的传递数据,减少内存的耗用
3. 使函数返回一个以上的值
4. 能直接访问硬件
5. 能够方便的访问字符串
6. 是理解面向对象语言中引用的基础
   总结:指针是C语言的灵魂

二.指针的定义

地址 :

	内存单元的编号
		从零开始的非负整数
		范围:4G[0到4G-1]

指针:

指针就是地址，地址就是指针
 		指针变量就是存放内存单元编号的变量，或者说指针变量就是存放地址的变量
 		指针和指针变量是两个不同的概念
 			注意：通常我们叙述时会把指针变量简称为指针，实际它们的含义并不一样
 						指针的本质就是一个操作受限的非负整数
			

三.指针的分类

1. 基本类型指针

int	*p;//p是变量的名字,int *表示p变量存放的是int类型变量的地址
	  //int *p;不表示定义了一个名字叫*p的变量
	  //int *p应该这样理解:p是变量名,p变量的数据类型是int *类型
	  //所谓int *类型  实际就是存放int变量地址的类型
int i=3;
int j;
p=&i;//1.p保存了i的地址,因此p指向i
j=*p;//等价于j=i;
printf("i=%d,j=%d",i,j);
//2.p不是i，i也不是p，，更准确的说：修改p的值不影响i的值,修改i的值也不影响p的值

*p的说明

如果一个指针变量指向了某个普通变量,则:
				*指针变量  就完全等同于  普通变量
		例子:
					如果P是个指针变量,并且p存放了普通变量i的地址
					则p指向了普通变量i
					  *p就完全等同于   i
					  或者说;    //在所有出现*p的地方都可以替换成i
					  						//在所有出现i的地方都可以替换成*p
						*p最准确的解释是：*p表示的是以p的内容为地址的变量
	

如何通过被调函数修改主调函数普通变量的值

1.实参必须为该普通变量的地址
2.形参必须为指针变量。
3.在被调函数中通过
                   *形参名=.........
                              的方式就可以修改主调函数相关变量的值 

2.指针和数组

指针和一维数组

1.一维数组名

			一维地址名是个指针常量                        
	     	它存放是一维数组第一个元素的地址

2.下标和指针的关系

如果p是个指针变量，则 p[i]永远等价于*(p+i)
     确定一个一维数组需要几个参数〖如果一个函数要处理一个一维数组，则需要接收该数组的哪些信息〗
     					需要两个参数： 
	                           数组第一个元素的地址
	                           数组的长度
# include 
void f(int * pArr, int len)//int *pArr等同于int pArr[]
{
	int i;
	for (i=0; i<len; ++i)
		printf("%d  ",  pArr[i]);  //*(pArr+i) 等价于 pArr[i]  也等价于 b[i] 也等价于 *(b+i) 
	printf("\n");
}

int main(void)
{
	int b[6] = {-1,-2,-3,4,5,-6};
	f(b, 6);//b为int*类型等同于pArr   相当于 &b[0]
	return 0;
}

3.指针变量的运算

			指针变量不能相加  不能相乘    也不能相除
			如果两个指针变量指向的是同一块连续空间中的不同存储单元，
			则这两个指针变量才可以相减
# include 
int main(void)
{
	int i = 5;
	int j = 10;
	int * p = &i;
	int * q = &j;
	int a[5];
	p = &a[1];
	q = &a[4];
	printf("p和q所指向的单元相隔%d个单元\n", q-p);//p - q 没有实际意义  4
	return 0;
}

4.一个指针变量到底占几个字节〖非重点〗

预备知识：
		sizeof（数据类型）
			功能：返回值就是该数据类型所占的字节数
					 例子： sizeof(int) = 4        sizeof (char) =1    
					 		sizeof(double) =8

			sizeof（变量名） 
				 功能：返回值是该变量所占的字节数

假设p指向char类型变量（1个字节）	
			假设q指向int类型变量（4个字节）
			假设r指向double类型变量（8个字节）
	请问：p q r本身所占的字节数是否一样？
			答案：p q r本身所占的字节数是一样的
# include 
int main(void)
{
	char ch = 'A';
	int i = 99;
	double x = 66.6;
	char * p = &ch;
	int * q = &i;
	double * r = &x;
	printf("%d %d %d\n", sizeof(p), sizeof(q), sizeof(r));//4 4 4
	return 0;
}

			总结：
				一个指针变量，无论它指向的变量占几个字节，该指针变量本身只占四个字节
				一个变量的地址是用该变量首字节的地址来表示 

指针和二维数组

3.指针和函数

4.指针和结构体

5.多级指针

示例:

int i=10;
int *p = &i; //p只能存放int类型変量的地址
int ** q = &p; //q是int **类型，所渭int **类型就是指q只能存放int *类型変量的地址,
int *** r = &q; //r是int ***类型，所渭int ***类型就是指r只能存放int **类型変量的地址,
//r = &p; //error 因カr是int ***类型，r只能存放int **类型変量的地址
printf("i = %d\n", *r); //输出結果是10只有***rオ表示的是i，*r或*r或****r代表的都不是i

四.专题

动态内存分配[重点难点]

传统数组的缺点:

1.数组长度必须事先制定，且只能是常整数，不能是变量

int a[5]; //0K
int len = 5; int a[1en]; //error

2.传统形式定义的数组，该数组的内存程序员无法手动释放

		在一个函数运行期间，系统为该函数中数组所分配的空间会一直存在，
		直到该函数运行完毕时，数组的空间才会被系统释放

3.数组的长度一旦定义，其长度就不能在更改

		数组的长度不能在函数运行的过程中动态的扩充或缩短

4.A函数定义的数组，在A函数运行期间可以被其它函数使用,但A函数运行完毕之后，A函数中的数组将无法在被其他函数使用

		传统方式定义的数组不能跨函数使用

为什么需要动态分配内存

				动态数组很好的解决了传统数组的这4个缺陷
				传统数组也叫静态数组

动态内存分配举例_动态数组的构造

假设动态构造一个int型一维数组[至少保证要看懂]

int*= (int *)malloc (int len)

1、 本语句分配了两块内存，一 块内存是动态分配的，
		总共len个字节，另-块是静态分配的，
		并且这块静态内存是p变量本身所占的内存，总共4个字节

1.malloc只有一个int型的形参，表示要求系统分配的字节数
2.malloc函数的功能是请求系统len个字节的内存空间，如果请求分配成功，
则返回第一个字节的地址，如果分配不成功，则返回NULL

malloc函数能且只能返回第一个字节的地址，所以我们需要把这个无任何实际意义的第一个字节的地址(俗称干地址)转化为一个有实际意义的地址，因此
malloc前面必须加(数据类型*) ,表示把这个无实际意义的第一个字节的地址,转化为相应类型的地址。

如
  int* p= (int *)malloc (50) ;
		表示将系统分配好的50个字节的第一个字节的地址转化为int *型的地址，
			更准确的说是把第一个字节的地址转化为四个字节的地址,
			这样p就指向了第一个的四个字节，p+1就指向了第2个的四个字节，
			p+i就指向了第1+1个的4个字节。p[0]就是第一个元素，p[i]就是第1+1个元素

  double *p= (double *)ma1loc (80) ;
		表示将系统分配好的80个字节的第一个字节的地址转化为double *型的地址，
			更准确的说是把第一个字节的地址转化为8个字节的地址，
			这样p就指向了第一个的8个字节，p+1就指向了第二个的8个字节,
			p+i就指向了第1+1个的8个字节。p[0]就是第一个元素，p[i]就是第1+1个元素

  free(p);
			表示把p所指向的内存给释放掉
			p本身的内存是静态的，不能由程序员手动释放，
			p本身的内存只能在p变量所在的函数运行终止时由系统自动释放

静态内存和动态内存的比较[重点]

静态内存是由系统自动分配，由系统自动释放
静态内存是在栈分配的

动态内存是由程序员手动分配，手动释放
动态内存是在堆分配的

跨函数使用内存的问题[重点]

静态内存不可以跨函数使用

		静态内存在函数执行期间可以被其它函数使用，
		静态内存在函数执行完毕之后就不能再被其他函数使用了

动态内存可以跨函数使用

动态内存在函数执行完毕之后仍然可以被其他函数使用