c语言学习笔记（9）——指针

指针是c语言的灵魂
-----------------------------------------------------------------------------
# include <stdio.h>


int main(){
int *p; //p是变量名，int *表示p变量存放的是int类型变量的地址，p是一个指针变量
int i = 3;

//p = i; 这样写是错误的
//p = 4; 这样写是错误的
p = &i; //将i变量的地址给p变量
//p保存了i的地址，因此p指向i,修改p的值不影响i的值，修改i的值也不影响p的值

return 0;
}
-----------------------------------------------------------------------------
# include <stdio.h>


int main(){
int *p; //不表示定义了一个名字叫做 *p的变量
//应该这样理解：p是变量名，p变量的数据类型是 int *类型
//int *类型实际就是存放int变量地址的类型


int i = 3;

p = &i;

printf("*P = %d\n", *p);
printf("i = %d\n", i);
return 0;
}
1.如果p是个指针变量，并且p存放了普通变量i的地址，则p指向了普通变量
2.*P 完全等同于 普通变量i (有i出现的地方都可以替换成*p)
------------------------------------------------------------------------------
指针和指针变量的区别：
1.指针就是地址，地址就是指针
地址就是内存单元的编号，所以指针就是内存单元的编号
2.指针变量存放地址的变量
指针变量是存放指针的变量，也就是说指针变量是存放内存单元编号的变量
3.指针和指针变量是两个不同的概念
但是要注意通常我们叙述时会把指针变量简称为指针，实际它们的含义不一样
一、指针的重要性
1.表示一些复杂的数据结构
2.快速的传递数据
3.使函数返回一个以上的值(函数只能返回一个值)
---------------------------------------------------------
# include <stdio.h>


int f(int a, int b);
void g(int * p ,int * q);


int main(void){

int a = 100;
int b = 200;

// a = f(a, b);
g(&a, &b);
printf("a = %d, b = %d\n", a, b);

return 0;
}
//只能修改一个值
int f(int a, int b){

return 1;
}
//这样被调函数可以修改主调函数一个以上的值
void g(int * p ,int * q){
*p = 1;
*q = 2;
}
---------------------------------------------------------
4.能直接访问硬件
5.能够方便的处理字符串
6.是理解面向对象语言中引用的基础
总结：指针是c语言的灵魂，是和其他语言的区别
二、指针的定义
地址
内存单元的编号，地址是从零开始的非负整数。
范围：
控制总线
CPU <----> 数据总线 <-----> 内存条
地址总线
控制线控制数据传输的方向
数据线是传输数据
地址线是确定是控制哪个内存单元

cup<-----> 数据总线 <-----> 内存条
一根线控制两个 0和1
两根线控制四个
n根线控制2的n次方个单元(字节)(每个单元是8位)

32位机 2x10^32
1G=2X10^30B(字节)
2x10^32 ~= 2X10^30*4 所以内存最大4G
4G [0——4G-1]
指针
指针就是地址，地址就是指针，指针变量就是存放内存单元编号的变量。
指针和指针变量是两个不同的概念
指针本质就是一个操作受限(不能运算，只是编号)的非负整数(地址)
三、指针的分类
1.基本类型指针
//就是上面的代码
--------------------------------------------------------------------------
指针常见错误1
# include <stdio.h>


int main(void){
int *p; //p指向一个垃圾值的地址，也就是一个垃圾地址
int i = 5;

*p = i; // 就是将i的值给了一个不知道的地址，这样写不对
printf("%d\n", *p);

return 0;
}
常见错误2
# include <stdio.h>


int main(void){
int i = 5;
int *p;
int *q;

p = &i
//*q = p; 语法编译出错
//*q = *p; error q指向一个垃圾地址
q = p; // error 可以读 q里面的垃圾地址，但是不能读*q的值,没有控制权限。
printf("%d\n", *q);

return 0;
}
--------------------------------------------------------------------------
/*
一个经典指针程序
*/
# include <stdio.h>


void huhuan(int i, int j);
void zhizhenhuhuan(int * a, int * b);
void huhuan3(int * a, int * b);


int main(void){
int a = 3;
int b = 5;

// huhuan(a, b);
// zhizhenhuhuan(&a, &b);
huhuan3(&a, &b);


printf("a = %d,b = %d\n", a, b);


return 0;
}


void huhuan(int a, int b){ //不能完成互换，a,b是形参，单独分配内存
int t;

t = a;
a = b;
b = t;
}


void zhizhenhuhuan(int * a, int * b){ //不能完成互换，互换了指针的指向
int * t;


t = a;
a = b;
b = t;
}


void huhuan3(int * a, int * b){ //可以完成互换，传递的是地址，交换的是地址指向的值
int t;


t = *a;
*a = *b;
*b = t;
}
---------------------------------------------------------------------------
*的含义
1.乘法 c = a*b;
2.定义指针变量 int * p;
3.取值运算符 *p
---------------------------------------------------------------------------
2.指针和数组的关系
指针和一维数组
数组名
一维数组名是个指针常量
它存放的是数组第一个元素地址
----------------------------------------------------------------
int a[5];
int b[5];
a = b 是错误的 a,b都是常量
-----------------------------------------------------------------
# include <stdio.h>


int main(void){
int a[5];

printf("%#x\n", &a[0]);
printf("%#x\n", a);


return 0;
}
输出结果：0x12ff6c
0x12ff6c
----------------------------------------------------------------
下标和指针的关系
如果p是个指针变量，则
p[i]永远等价于 *(p+i)
确定一个一维数组需要两个参数
数组第一个元素的地址
数组的长度
-------------------------------------------------------------------------
//f函数可以输出任何一个一维数组的内容
# include <stdio.h>


void f(int * pArr, int len){
int i;
for (i=0; i<len; i++)
printf("%d ", *(pArr+i));
printf("\n");
}
int main(void){
int a[5] = {1, 2, 3, 4, 5};
int b[6] = {-1, -2, -3, 4, 5, -6};
int c[100] = {1, 99, 22, 33};

f(a, 5); //确定一个数组：数组首地址和长度
f(b, 6);
f(c, 100);

return 0;
}
-------------------------------------------------------------------------
# include <stdio.h>


void f(int * pArr, int len){
pArr[3] = 88; //pArr[3]等价于a[3]也等价于*(a+3)和*(pArr+3)
// *a==a[0]
}


int main(void){
int a[6] = {1, 2, 3, 4, 5, 6};

printf("%d\n", a[3]);
f(a, 6); // a和pArr都指向数组的第一个元素
printf("%d\n", *(a+3));

return 0;
}
-------------------------------------------------------------------------
指针变量的运算
指针变量不能相加，不能相乘，也不能相除(这些运算没有意义)
如果两个指针变量指向的是同一块连续空间中得不同的存储单元
则这两个指针才可以相减(这样减才有意义)
------------------------------------------------------------------------------
# include <stdio.h>


int main(void){
int i = 5;
int j = 10;
int * p = &i;
int * q = &j;
//此时p和q不能相减
int a[5];
p = &a[2];
q = &a[4];


printf("相减的结果为:%d\n", p-q);
//此时p和q可以相减，相减的值指p和q单元相隔的个数


return 0;
}
结果为：相减的结果为:-2
---------------------------------------------------------------------------------
一个指针变量到底占几个字节
预备知识：
sizeof(数据类型)；或者 sizeof(变量名);
返回该数据类型所占的字节数
例如： sizeof(int) = 4 sizeof(char) = 1
假设p指向的char类型变量(1个字节)
假设p指向的int类型变量(4个字节)
假设p指向的double类型变量(8个字节)
p q r 本身所占的字节数是否一样
---------------------------------------------------------------------------
# include <stdio.h>


int main(void){
char ch = 'A';
int i = 90;
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
内存中一个字节为一个单元，所以double中有8个编号，
只用首字节的编号代表该变量的内存编号，用该变量类型
指明下面连续单元的个数
如： int * p; int i = 5； p = &i;
p------>地址1101011(i的首地址)
int-------表示有四个字节
----------------------------------------------------------------------------
指针和二维数组
3.指针和函数的关系

4.指针和结构体的关系

5.多级指针
----------------------------------------------------------------------------------
# include <stdio.h>


int main(void){
int i = 10;
int * p = &i;
int ** q = &p;
int *** r = &q;

printf("i = %d\n", ***r);


return 0;
}
结果： i = 10
-----------------------------------------------------------------------------------
专题：
动态内存分配
传统数组的缺点
1.数组的长度必须事先制定，且只能是常整数，不能是变量
例如： int len = 5; int a[len]; //error
2.传统形式定义的数组，该数组的内存程序员无法手动释放
------------------------------------------------------------------------------
# include <stdio.h>


void f(void){
int a[5] = {1, 2, 3, 4, 5};
//这二十个字节的存储空间程序员无法手动编程释放它
//只能在本函数运行完毕时由系统自动释放
}


int main(void){
return 0;
}
------------------------------------------------------------------------------
3.数组的长度不能再函数运行的过程中动态的扩充或缩小
4.A函数定义的数组，在A函数运行期间可以被其它函数使用，
但A函数运行完毕之后，A函数中的数组将无法在被其它函数使用
静态数组不能跨函数使用
-------------------------------------------------------------------------
# include <stdio.h>
void g(int *pArr, int len){
pArr[2] = 88;
}
void f(void){
int a[5] = {1, 2, 3, 4, 5}; //f运行期间g();函数可以使用
g(a, 5); //当f运行完毕数组a空间被释放
printf("%d\n", a[2]);
}


int main(void){
return 0;
}
--------------------------------------------------------------------------
为什么需要动态分配
动态数组很好的解决了传统数组的上面四个缺陷
动态内存分配的举例——动态数组的构造
----------------------------------------------------------------------------
/*
2012年2月5日15:00:25
malloc 是 memory(内存) allocate(分配)的缩写
*/
# include <stdio.h.
# include <malloc.h> //头文件


int main(void){
int i = 5; //静态分配了四个字节
int * p = (int *)malloc(4); //把返回的地址强制转换为整形变量的地址
/*
1.要使用malloc函数，必须添加malloc.h这个头文件
2.malloc函数只有一个形参，并且是整型
3.4表示请求系统为本程序分配4个字节
4.malloc函数只能返回第一个字节的地址
5.上面一行代码分配了8个字节，p变量占4个字节，p所指向的内存也占4个字节
6.p本身所占的内存是静态分配的，p所指向的内存是动态分配的
*/
*p = 5; //*p代表整形变量，只不过*p这个整形变量的内存分配方式和i分配不同
free(p); //表示把p所指向的内存给释放掉
printf("同志们好！\n");

return 0;
}
----------------------------------------------------------------------------
# include <stdio.h>
# include <malloc.h>


void f(int * q){
*q = 200;
free(q); //把q指向的内存释放掉 和 free(p)等价
}
int main(void){
int * p = (int *)malloc(sizeof(int));
*p = 10;

printf("%d\n", *p); //10
f(p); //通过f()修改p指向内存的值
printf("%d\n", *p); //p指向的内存已经释放，所以会出错

return 0;
}
----------------------------------------------------------------------------
/*
2012年2月5日15:37:36
动态一维数组示例
*/
# include <stdio.h>
# include <malloc.h>


int main(void){
int a[5]; //包含20字节
int i;
int len;
int *pArr;

printf("请输入你要存放的元素个数：");
scanf("%d", &len);
pArr = (int *)malloc(4*len); //pArr指向前4个字节 类似于 int pArr[len];
// pArr+1 就指向第5到第8个字节
//动态的构造了一个int类型的一维数组，数组名 pArr
for (i=0; i<len; i++) //对一维数组进行赋值
scanf("%d", &pArr[i]);

printf("一维数组的内容是:\n");
for(i=0; i<len; i++)
printf("%d\n", pArr[i]);

return 0;
}
输出结果：
请输入你要存放的元素个数：5
1 2 3 4 5
一维数组的内容是:
1
2
3
4
5
----------------------------------------------------------------------------
静态内存和动态内存的比较
静态内存是由系统自动分配，由系统自动释放
静态内存是在栈中分配的
动态内存是由程序员手动分配，手动释放
动态内存是在堆分配的
跨函数使用内存的问题
----------------------------------------------------------------------------
# include <stdio.h>


void f(int ** q){
int i = 5;
//*q 等价于p q 和**q都不等价于p
*q = &i;
}
int main(void){
int * p;

f(&p); //访问完后释放内存
printf("%d\n", *p); //本语句语法没有问题， 但逻辑上有问题
//访问了不该访问的内存，f()函数结束后i的空间已经被释放
//静态变量，不能跨函数使用，当函数结束后变量不能被访问

return 0;
}
------------------------------------------------------------------------------
# include <stdio.h>
# include <malloc.h>


void f(int **q){
*q = (int*)malloc(sizeof(int)); //动态分配内存
//等价于 p = (int *)malloc(sizeof(int));
**q = 5;
}


int main(void){
int * p;
f(&p);
printf("%d\n", *p); //f()结束后，p指向的动态内存没有释放

return 0;
}
----------------------------------------------------------------------------------