C语言基础:c指针不可能这么简单
2019.7.19
@author: 灼华
@整理编辑
C与指针
闲谈函数
一段代码拽出来,完成特定的功能,处理一些数据。
文章目录
·指针(地址变量)
1.理论
指针是程序数据在内存中的地址,而指针变量是用来保存这些地址的变量
所有的变量 在内存中都有地址
在程序员眼中的内存应该是下面这样的。(假设使用的是32位系统平台,虚拟存储空间为4GB)
每一个字节都是固定的大小,由8个二进制位组成。最关键的是,每一个字节都有一个唯一的编号,编号从0开始,一直到最后一个字节。如上图中,这是一个4GB的虚拟存储器的模型,它一共有4x1024x1024x1024 个字节,那么它的虚拟地址范围就是 0 ~ 4x1024x1024x1024-1 。
由于内存中的每一个字节都有一个唯一的编号,因此,在程序中使用的变量,常量,甚至数函数等数据,当他们被载入到内存中后,都有自己唯一的一个编号,这个编号就是这个数据的地址。指针就是这样形成的。
#include <stdio.h>
int main(void)
{
char ch = 'a';
int num = 97;
printf("ch 的地址:%p\n",&ch); //ch 的地址:0028FF47
printf("num的地址:%p\n",&num); //num的地址:0028FF40
return 0;
}
定义指针
int a ; //int类型变量 a
int *a ; //int* 变量a
int arr[3]; //arr是包含3个int元素的数组
int (* arr )[3]; //arr是一个指向包含3个int元素的数组的指针变量
//-----------------各种类型的指针------------------------------
int* p_int; //指向int类型变量的指针
double* p_double; //指向idouble类型变量的指针
struct Student *p_struct; //结构体类型的指针
int(*p_func)(int,int); //指向返回类型为int,有2个int形参的函数的指针
int(*p_arr)[3]; //指向含有3个int元素的数组的指针
int** p_pointer; //指向 一个整形变量指针的指针
取地址
既然有了指针变量,那就得让他保存其它变量的地址,使用& 运算符取得一个变量的地址。
int add(int a , int b)
{
return a + b;
}
int main(void)
{
int num = 97;
float score = 10.00F;
int arr[3] = {1,2,3};
//-----------------------
int* p_num = #
float* p_score = &score;
int (*p_arr)[3] = &arr;
int (*fp_add)(int ,int ) = add; //p_add是指向函数add的函数指针
return 0;
}
特殊的情况,他们并不一定需要使用&取地址:
- 数组名的值就是这个数组的第一个元素的地址。
- 函数名的值就是这个函数的地址。
- 字符串字面值常量作为右值时,就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。
int add(int a , int b){
return a + b;
}
int main(void)
{
int arr[3] = {1,2,3};
//-----------------------
int* p_first = arr;
int (*fp_add)(int ,int ) = add;
const char* msg = "Hello world";
return 0;
}
解地址
我们需要一个数据的指针变量干什么?当然使用通过它来操作(读/写)它指向的数据啦。对一个指针解地址,就可以取到这个内存数据,解地址 的写法,就是在指针的前面加一个*号。
解指针的实质是:从指针指向的内存块中取出这个内存数据。
int main(void)
{
int age = 19;
int*p_age = &age;
*p_age = 20; //通过指针修改指向的内存数据
printf("age = %d\n",*p_age); //通过指针读取指向的内存数据
printf("age = %d\n",age);
return 0;
}
指针之间的赋值
指针赋值和int变量赋值一样,就是将地址的值拷贝给另外一个。指针之间的赋值是一种浅拷贝,是在多个编程单元之间共享内存数据的高效的方法。
int* p1 = & num;
int* p3 = p1;
//通过指针 p1 、 p3 都可以对内存数据 num 进行读写,如果2个函数分别使用了p1 和p3,那么这2个函数就共享了数据num。
空指针
指向空,或者说不指向任何东西。在C语言中,我们让指针变量赋值为NULL表示一个空指针,而C语言中,NULL实质是 ((void*)0) , 在C++中,NULL实质是0。
换种说法:任何程序数据都不会存储在地址为0的内存块中,它是被操作系统预留的内存块。
下面代码摘自 stddef.h
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
坏指针
指针变量的值是NULL,或者未知的地址值,或者是当前应用程序不可访问的地址值,这样的指针就是坏指针,不能对他们做解指针操作,否则程序会出现运行时错误,导致程序意外终止。
任何一个指针变量在做 解地址操作前,都必须保证它指向的是有效的,可用的内存块,否则就会出错。坏指针是造成C语言Bug的最频繁的原因之一。
下面的代码就是错误的示例。
void opp()
{
int*p = NULL;
*p = 10; //Oops! 不能对NULL解地址
}
void foo()
{
int*p;
*p = 10; //Oops! 不能对一个未知的地址解地址
}
void bar()
{
int*p = (int*)1000;
*p =10; //Oops! 不能对一个可能不属于本程序的内存的地址的指针解地址
}
指针的2个重要属性
指针也是一种数据,指针变量也是一种变量,因此指针 这种数据也符合前面 变量和内存 主题中的特性。 这里我只想强调2个属性: 指针的类型,指针的值。
int main(void)
{
int num = 97;
int *p1 = #
char* p2 = (char*)(&num);
printf("%d\n",*p1); //输出 97
putchar(*p2); //输出 a
return 0;
}
指针的值:很好理解,如上面的num 变量 ,其地址的值就是0028FF40 ,因此 p1的值就是0028FF40。数据的地址用于在内存中定位和标识这个数据,因为任何2个内存不重叠的不同数据的地址都是不同的。
指针的类型:指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。一般指针变量的类型要和它指向的数据的类型匹配。
由于num的地址是0028FF40,因此p1 和 p2的值都是0028FF40
*p1 : 将从地址0028FF40 开始解析,因为p1是int类型指针,int占4字节,因此向后连续取4个字节,并将这4个字节的二进制数据解析为一个整数 97。
*p2 : 将从地址0028FF40 开始解析,因为p2是char类型指针,char占1字节,因此向后连续取1个字节,并将这1个字节的二进制数据解析为一个字符,即’a’。
同样的地址,因为指针的类型不同,对它指向的内存的解释就不同,得到的就是不同的数据。
void*类型指针
由于void是空类型,因此void类型的指针只保存了指针的值,而丢失了类型信息,我们不知道他指向的数据是什么类型的,只指定这个数据在内存中的起始地址,如果想要完整的提取指向的数据,程序员就必须对这个指针做出正确的类型转换,然后再解指针。因为,编译器不允许直接对void类型的指针做解指针操作。
结构体和指针
结构体指针有特殊的语法: -> 符号
如果p是一个结构体指针,则可以使用 p ->【成员】 的方法访问结构体的成员。p->member 等价于 (*p).member。
typedef struct
{
char name[31];
int age;
float score;
}Student;
int main(void)
{
Student stu = {"Bob" , 19, 98.0};
Student*ps = &stu;
ps->age = 20;
ps->score = 99.0;
printf("name:%s age:%d\n",ps->name,ps->age);
return 0;
}
数组和指针
1、数组名作为右值的时候,就是第一个元素的地址。
int main(void)
{
int arr[3] = {1,2,3};
int*p_first = arr;
printf("%d\n",*p_first); //1
return 0;
}
2、指向数组元素的指针 支持 递增 递减 运算。(实质上所有指针都支持递增递减 运算 ,但只有在数组中使用才是有意义的)
int main(void)
{
int arr[3] = {1,2,3};
int*p = arr;
for(;p!=arr+3;p++){
printf("%d\n",*p);
}
return 0;
}
3、p= p+1 意思是,让p指向原来指向的内存块的下一个相邻的相同类型的内存块。
同一个数组中,元素的指针之间可以做减法运算,此时,指针之差等于下标之差。
4、p[n] == *(p+n)
p[n][m] == *( *(p+n)+ m )
5、当对数组名使用sizeof时,返回的是整个数组占用的内存字节数。当把数组名赋值给一个指针后,再对指针使用sizeof运算符,返回的是指针的大小。
这就是为什么我么将一个数组传递给一个函数时,需要另外用一个参数传递数组元素个数的原因了。
int main(void)
{
int arr[3] = {1,2,3};
int*p = arr;
printf("sizeof(arr)=%d\n",sizeof(arr)); //sizeof(arr)=12
printf("sizeof(p)=%d\n",sizeof(p)); //sizeof(p)=4
return 0;
}
函数和指针
函数的参数和指针
C语言中,实参传递给形参,是按值传递的,也就是说,函数中的形参是实参的拷贝份,形参和实参只是在值上面一样,而不是同一个内存数据对象。这就意味着:这种数据传递是单向的,即从调用者传递给被调函数,而被调函数无法修改传递的参数达到回传的效果。
void change(int a)
{
a++; //在函数中改变的只是这个函数的局部变量a,而随着函数执行结束,a被销毁。age还是原来的age,纹丝不动。
}
int main(void)
{
int age = 19;
change(age);
printf("age = %d\n",age); // age = 19
return 0;
}
有时候我们可以使用函数的返回值来回传数据,在简单的情况下是可以的,但是如果返回值有其它用途(例如返回函数的执行状态量),或者要回传的数据不止一个,返回值就解决不了了。
传递变量的指针可以轻松解决上述问题。
void change(int* pa)
{
(*pa)++; //因为传递的是age的地址,因此pa指向内存数据age。当在函数中对指针pa解地址时,
//会直接去内存中找到age这个数据,然后把它增1。
}
int main(void)
{
int age = 19;
change(&age);
printf("age = %d\n",age); // age = 20
return 0;
}
再来一个老生常谈的,用函数交换2个变量的值的例子:
#include<stdio.h>
void swap_bad(int a,int b);
void swap_ok(int*pa,int*pb);
int main()
{
int a = 5;
int b = 3;
swap_bad(a,b); //Can`t swap;
swap_ok(&a,&b); //OK
return 0;
}
//错误的写法
void swap_bad(int a,int b)
{
int t;
t=a;
a=b;
b=t;
}
//正确的写法:通过指针
void swap_ok(int*pa,int*pb)
{
int t;
t=*pa;
*pa=*pb;
*pb=t;
}
有的时候,我们通过指针传递数据给函数不是为了在函数中改变他指向的对象,相反,我们防止这个目标数据被改变。传递指针只是为了避免拷贝大型数据。
考虑一个结构体类型Student。我们通过show函数输出Student变量的数据。
typedef struct
{
char name[31];
int age;
float score;
}Student;
//打印Student变量信息
void show(const Student * ps)
{
printf("name:%s , age:%d , score:%.2f\n",ps->name,ps->age,ps->score);
}
我们只是在show函数中取读Student变量的信息,而不会去修改它,为了防止意外修改,我们使用了常量指针去约束。另外我们为什么要使用指针而不是直接传递Student变量呢?
从定义的结构看出,Student变量的大小至少是39个字节,那么通过函数直接传递变量,实参赋值数据给形参需要拷贝至少39个字节的数据,极不高效。而传递变量的指针却快很多,因为在同一个平台下,无论什么类型的指针大小都是固定的:X86指针4字节,X64指针8字节,远远比一个Student结构体变量小。
函数的指针
每一个函数本身也是一种程序数据,一个函数包含了多条执行语句,它被编译后,实质上是多条机器指令的合集。在程序载入到内存后,函数的机器指令存放在一个特定的逻辑区域:代码区。既然是存放在内存中,那么函数也是有自己的指针的。
C语言中,函数名作为右值时,就是这个函数的指针。
void echo(const char *msg)
{
printf("%s",msg);
}
int main(void)
{
void(*p)(const char*) = echo; //函数指针变量指向echo这个函数
p("Hello "); //通过函数的指针p调用函数,等价于echo("Hello ")
echo("World\n");
return 0;c
}
const 和 指针
const到底修饰谁?谁才是不变的?
下面是我总结的经验,分享一下。
如果const 后面是一个类型,则跳过最近的原子类型,修饰后面的数据。(原子类型是不可再分割的类型,如int, short , char,以及typedef包装后的类型)
如果const后面就是一个数据,则直接修饰这个数据。
int main()
{
int a = 1;
int const *p1 = &a; //const后面是*p1,实质是数据a,则修饰*p1,通过p1不能修改a的值
const int*p2 = &a; //const后面是int类型,则跳过int ,修饰*p2, 效果同上
int* const p3 = NULL; //const后面是数据p3。也就是指针p3本身是const .
const int* const p4 = &a; // 通过p4不能改变a 的值,同时p4本身也是 const
int const* const p5 = &a; //效果同上
return 0;
}
typedef int* pint_t; //将 int* 类型 包装为 pint_t,则pint_t 现在是一个完整的原子类型
int main()
{
int a = 1;
const pint_t p1 = &a; //同样,const跳过类型pint_t,修饰p1,指针p1本身是const
pint_t const p2 = &a; //const 直接修饰p,同上
return 0;
}
深拷贝和浅拷贝
如果2个程序单元(例如2个函数)是通过拷贝 他们所共享的数据的 指针来工作的,这就是浅拷贝,因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了,在每个单元中都有自己的一份,对目标数据的操作相互 不受影响,则叫做深拷贝。
附加知识
指针和引用这个2个名词的区别。他们本质上来说是同样的东西。指针常用在C语言中,而引用,则用于诸如Java,C#等 在语言层面封装了对指针的直接操作的编程语言中。
大端模式和小端模式
-
Little-Endian就是低字节排放在内存的低地址端,高字节排放在内存的高地址端。个人PC常用,Intel X86处理器是小端模式。
-
B i g-Endian就是高字节排放在内存的低地址端,低字节排放在内存的高地址端。
采用大端方式 进行数据存放符合人类的正常思维,而采用小端方式进行数据存放利于计算机处理。有些机器同时支持大端和小端模式。
假如 short类型占用2个字节,且存储的地址为0x30。
short a = 1;
如下图:
//测试机器使用的是否为小端模式。是,则返回true,否则返回false//这个方法判别的依据就是:C语言中一个对象的地址就是这个对象占用的字节中,地址值最小的那个字节的地址。
bool isSmallIndain()
{
unsigned int val = 'A';
unsigned char* p = (unsigned char*)&val; //C/C++:对于多字节数据,取地址是取的数据对象的第一个字节的地址,也就是数据的低地址
return *p == 'A';
}
*作为间接运算符
一级指针可以存放普通变量
二级指针可以存放一级指针地址
int i=9;
int *p;
p=&i;
*
一定跟着的是地址
i=1;
*(p)----->*(&i)----->*(01)=1//*(P+0)=1;
int j;
j=*p;//不能写成j=p,j=1
j=*(p)----->*(&i)----->*(01)=1//读取01地址的值
2.基本使用
1交换数字
#include "stdafx.h"
int funmax(int *i,int *j);
int _tmain(int argc, _TCHAR* argv[])
{
int a=1,b=0;
funmax(&a,&b);
return 0;
}
int funmax(int *i,int *j)
{
int t=*i;
*i=*j;
*j=t;
return 0;
}
/*void fun(int*i,int*j)
{
int t=*i;
*i=*j;
*j=t;
//return
}
//返回最大值 三步运算法
//i_return=(i>=j)?i:j;
int FUNction(int i, int j)
{
if(i>=j){
i_Return =i
}
else{
I_Return =j
}
}
#include "stdafx.h"
int funmax(int *i,int *j);
int _tmain(int argc, _TCHAR* argv[])
{
int a=1,b=0;
int *p;
int s=0;
p=&a;
*p=2;
b=*p*a;
s=(*p*a)**p*b*a;
return 0;
}
答案:64
2递增一个指针
#include "stdafx.h"
const int MAX = 3;
int _tmain(int argc, _TCHAR* argv[])
{
int var[] = {10, 100, 200};
int i, *ptr;
/* 指针中的数组地址 */
ptr = var;
for ( i = 0; i < MAX; i++)
{
printf("存储地址:var[%d] = %x\n", i, ptr );
printf("存储值:var[%d] = %d\n", i, *ptr );
/* 移动到下一个位置 */
ptr++;
}
return 0;
}
输出
存储地址:var[0] = 3cf9b4
存储值:var[0] = 10
存储地址:var[1] = 3cf9b8
存储值:var[1] = 100
存储地址:var[2] = 3cf9bc
存储值:var[2] = 200
3递减一个指针
#include "stdafx.h"
const int MAX = 3;
int _tmain(int argc, _TCHAR* argv[])
{
int var[] = {10, 100, 200};
int i, *ptr;
/* 指针中最后一个元素的地址 */
ptr = &var[MAX-1];
for ( i = MAX; i > 0; i--)
{
printf("存储地址:var[%d] = %x\n", i-1, ptr );
printf("存储值:var[%d] = %d\n", i-1, *ptr );
/* 移动到下一个位置 */
ptr--;
}
return 0;
}
输出
存储地址:var[2] = 2efde0
存储值:var[2] = 200
存储地址:var[1] = 2efddc
存储值:var[1] = 100
存储地址:var[0] = 2efdd8
存储值:var[0] = 10
3.小题
1.运用指针递减输出数字
a=[1,5,7,6,5]
倒序输出
#include "stdafx.h"
const int MAX = 4;
int _tmain(int argc, _TCHAR* argv[])
{
int var[] = {1,5,7,3};
int i, *ptr;
/* 指针中最后一个元素的地址 */
ptr = &var[MAX-1];
for ( i = MAX; i > 0; i--)
{
printf("a[%d] = %d\n", i-1, *ptr );
/* 移动到下一个位置 */
ptr--;
}
return 0;
}
/*输出
a[3] = 3
a[2] = 7
a[1] = 5
a[0] = 1
2.输出最大的数字(显示如下)
请输入三个数字:1 2 3 最大的数字是: 3
#include <stdio.h>
int max(int x, int y)
{
return x > y ? x : y;
}
int main(void)
{
/* p 是函数指针 */
int (* p)(int, int) = & max; // &可以省略
int a, b, c, d;
printf("请输入三个数字:");
scanf("%d %d %d", & a, & b, & c);
/* 与直接调用函数等价,d = max(max(a, b), c) */
d = p(p(a, b), c);
printf("最大的数字是: %d\n", d);
return 0;
}
3.指针类型加减实现地址的移动
#include "stdafx.h"
#include "stdio.h"
int _tmain(int argc, _TCHAR* argv[])
{
int a[5]={1,2,3,4,5};
int *ptr=(int*)(&a+1); //int* 强制转换为指针类型
printf("%d,%d",*(a+1),*(ptr-1));//&a 表示整个数组地址 a表示数组首地址(两个地址数值相同但定义不同),*(a+1)中的*是解引作用,即取出指针所指向的地址中存储的值
return 0;
}//因为&a取得是整个数组的地址,所以此处表示在整个数组的基础上加1,所以最后指向的是数a[4]后边的地址,与输出语句中的-1相结合恰好指向a[4]
//a+1只是由a[n]变为a[n+1]
结果:*(a+1)=2 *(ptr-1)=5
运算公式:p+n可以表示为(unsigned int)p+nsizeof(*p)
4.计算器
// 做一个指针和函数的简单计算器。
//
#include "stdafx.h"
double jia(float* a,float* b);
double jian(float* a,float* b);
double cheng(float* a,float* b);
double chu(float* a,float* b);
int _tmain(int argc, _TCHAR* argv[])
{
char c;
float a,b;
float result=0;
printf("*****计算器*****\n");
printf("请输入运算方式\n");
printf("***** + *****\n");
printf("***** - *****\n");
printf("***** * *****\n");
printf("***** / *****\n");
scanf_s("%c",&c,1);//%c,c,长度很多带“_s”后缀的函数是为了让原版函数更安全,传入一个和参数有关的大小值,避免引用到不存在的元素,有时黑客可以利用原版的不安全性黑掉系统。比如:char d[20];写成scanf_s("%s",d,20);才是正确的,有这个参数20使准确性提高。
printf("请输入2个数:\n");
scanf_s("%f %f",&a,&b);
switch(c)
{
case '+':result=jia(&a,&b);printf("%.2f",result);break;
case '-':result=jian(&a,&b);printf("%.2f",result);break;
case '*':result=cheng(&a,&b);printf("%.2f",result);break;
case '/':result=chu(&a,&b);printf("%.2f",result);break;
}
return 0;
}
double jia(float* a,float* b)
{
float sun=0;
sun=*a+*b;
return sun;
}
double jian(float* a,float* b)
{
float sun=0;
sun =*a-*b;
return sun;
}
double cheng(float* a,float* b)
{
float sun=0;
sun =*a**b;
return sun;
}
double chu(float* a,float* b)
{
float sun=0;
sun=*a/(*b);
return sun;
}
上一篇: linux fdisk mount
下一篇: LeetCode221-最大正方形