初级
1、指针的概念
在64位操作系统中,不管什么类型的指针都占8个字节
int a=1;
int* p=&a;//p就是一个整型的指针,保存了a的地址
2、指针和变量
int* p=&a;* p=100; // 等价于a=100p //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)); //32printf("%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])); //10f(a); //2return 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 1return 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 5int 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个字节