C语言指针知识点总结

Int f(int i,int j)

★指针的重要性

{

表示一些复杂的数据结构

return 100;

快速传递数据

// return 88;error *p=1;

使函数返回一个以上的值

}

能直接访问硬件

Int main (void)

能方便处理字符串

{

是理解面向对象语言中引用的基础

Int a=3,b=5;

总结：指针是C语言的灵魂

Int a=3,b=5;

★指针的定义 ☆地址

内存单元的编号 从零开始的非负整数 范围：4G ☆指针

1.指针就是地址，地址就是指针 2.指针变量是存放地址的变量 3.指针和指针变量是两个不同的概念

4.叙述时通常把指针变量简称为指针，实际它们含义不一样 5.指针的本质就是一个操作受限的非负整数 ★指针的分类

☆基本类型指针（重要） #include int main(void)

{

Int main(void) } *q=2; {

针

# include Void g(int*p,int*q)

{

int *p; //p是变量的名字，int*表示p变量存放的是int类型变量的地址 Int*p;不表示定义了一个名字叫做*p的变量

Int*p;应该理解为：p是变量名，p变量的数据类型是int*类型 所谓int*类型，实际就是存放int变量地址的类型 int i=3; char ch=’A’ p=&i; //OK

1.p保存了i的地址，因此p指向i

2.p不是i，i也不是p，修改p的值不影响i的值，修改i的值也不影响p的值 3.如果一个指针变量指向了某个普通变量，则*指针变量 完全等同于 普通变量 例：若p指向i，则*p=i (*p和i 可互相替换) p=&ch;//error

//p=i; //error,因为类型不一致，p只能存放int类型变量的地址，不能存放int类型变量 //P=55;//error,原因同上 return 0； }

△附注： ?*的含义： 1.乘法 2.定义指针变量

Int*p; //定义了一个名字叫做p的变量，int*表示p只能存放int变量的地址 3.指针运算符

该运算符放在已经定义好的指针变量的前面 如果p是一个已经定义好的指针变量

则*p表示以p的内容为地址的变量 ?如何通过被调函数修改主调函数普通变量的值 1.实参必须为该普通变量的地址 &... 2.形参必须为指针变量 *...

3.在被调函数中通过 *形参名=...... 的方式就可以修改主调函数相关变量的值 例子： 经典指针程序：互换数值

#include #include

形参和实参是不同的变量，修改形参不会改变实参 void huhuan（int a, int b） void huhuan2（int *p, int *q） ?指针常见错误 { int t; t=a; a=b; b=t; return; }

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

{

#include Int main(void) { Int i=5; Int*p; Int*q; P=&i;

int *t;//如果要互换p和q的值， 则t必须是int*，不能是int t=p; p=q; q=t; return;

{

int t;//如果要互换*p和*q的值， 则t必须是int，不能是int* t=*p;//p是int*，*p是int *p=*q; *q=t; return; }

int main(void) {

#include

void huhuan3（int *p, int*q） //形参的名字是p和q，接收实参数据的是p和q，而不是*p和*q

}

//*q=p;//error语法编译会出错 int main(void)

//*q=*p;//error

{

P=q;//q是垃圾值，q赋给p，p也是垃圾值 int a=3;

printf(“%d\\n”,*q); //13行

int b=5; huhuan(a,b);

/*q的空间是属于本程序的，所以本程序可以读写q的内容，

int a=3;

但是如果q内部是垃圾值，则本程序不能读写*q的内容

int b=5; 因为此时*q所代表的内存单元的控制限权并没有分配给本程序 所以本程序运行到13行时就会立即出错*/ return 0;

}

☆指针和数组

△指针和一维数组 ?一维数组名

一维数组名是个指针常量

它存放的是一维数组第一个元素的地址 ?下标和指针的关系

如果p是个指针变量，则p[i]永远等价于*(p+i) ?确定一个一维数组需要几个参数

（如果一个函数要处理一个一维数组，则需要接收该数组的哪些信息） 需要两个参数：

数组第一个元素的地址 数组的长度

# include

int main(void)

#include

1 2 3 4 5 -1 -2 -3 4 5 -6

# include

//f函数可以输出任何一个一维数{ 组的内容 void f(int * pArr,int len) # include

{ pArr[3]=88; void f(int * pArr, int len) ?指针变量的运算 //10行

Void f(int*pArr,int len)

int a[5]={1,2,3,4,5}; 1 99 22 33 0 0 0 0 0 0 0 0 { pArr[2]=10; int b[6]={-1,-2,-3,4,5,-6};

0 0 0 0 0 0 0 0 0 0 0 0 0 0

Void OutArr(int*pArr,int len) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 } { 指针变量不能相加，不能相乘，不能相除 //pArr[2]==*( pArr+2)==*(a+2)==a[2]

int c[100]={1,99,22,33}; 0 0 0 0 0 0 0 0 0 0 0 0 0 0

{

0 0 0 0 0 0 0 0 0 0 0 0 0 0 int main(void) int i ； 可以相减（仅当两个指针变量指向的是同一块连续空间中的不同存储空间） }

f(a,5);//a是int*

Int i; 0 0 0 0 0 0 0 0 0 0 0 0 0 0 { for(i=0,i #include f(b,6); For(i=0;iint a[6]={1,2,3,4,5,6} printf( “%d”,*(pArr+i) )?一个指针变量到底占几个字节 { Int main(void)Int main(void)

Printf(“%d\\n”,pArr[i]);

pArr[i] b[i] printf(“%d\\n”,a[3]); //*(pArr+i) 等价于 预备知识： *(b+i) //17{ int i=5; int a[6]={1,2,3,4,5,6} { int i=5; 行

}

f(a,6); sizeof（数据类型）

Int j=10; printf(“%d\\n”,a[2]); Int j=10;

Int main(void)

printf(“%d\\n”,a[3]); 功能：返回值就是该数据类型所占的字节数

Int*p=&i; Int*p=&i; f(a,5);

{ //19 行 若写为 &a[3] 则输出结果为例子：sizeof（int的地址）=4 sizeof（char）=1 sizeof（double）=8 a[3] Int*q=&j; printf(“%d\\n”,a[2]); OutArr(a,5);

Int a[5]; //a=&a[2];//error 因为a是常量

Return 0; }

p=&a[1];

sizeof（变量名）

功能：返回值是该变量所占的字节数 假设p指向char类型变量（1个字节） 假设q指向int类型变量（4个字节） 假设 r指向double类型变量（8个字节）

#include

4 4 4

Press any key to continue

△指针和二维数组

Int main(void) ☆指针和函数 ☆指针和结构体 ☆多级指针 专题：

{ char ch=’A’; Int i=99; Double x=66.6 Char * p=&ch;

动态内存分配（重难点）

Int *q=&i; 传统数组的缺点：

1.数组长度必须事先制定，且只能是常整数，不能是变量。 例子：int a[5]; //OK

Int len=5; int a[len];//error Int a[5.6];//error

2.传统形式定义的数组，该数组的内存程序员无法手动释放 为什么需要动态分布内存

动态内存分配举例-动态数组的构造 静态内存和动态内存的比较 跨函数使用内存的问题