C语言之指针变量

菜单导航

1、指针变量

2、指针和数组

3、常量指针和指向常量的指针

4、指针和字符串的关系

5、数组越界造成的访问不属于自己的内存空间现象

6、引用数据类型和基本数据类型，形参和实参

7、字符串和字符数组

8、字符串常用函数(长度、拷贝、追加、比较)

一、指针变量

/*
     1、定义
     普通变量: 数据类型 变量名称
     指针变量: 数据类型 * 变量名称;
     2、指针变量是什么类型,那么将来就只能保存什么类型变量的地址,
     例如 指针变量是int类型, 那么将来就只能保存int类型变量的地址
     3、* : 标示这是一个指针变量，代表访问指针变量指向的那一块存储空间
     4、指针变量只能存储地址
     */
    int num = ;
    char c = 'a';
    float f = .f;
    double d = 22.5;

    printf("num地址：%p, c地址：%p, f地址：%p, d地址：%p \n", &num, &c, &f, &d);
    printf("num字节: %zu， c字节：%zu, f字节：%zu, d字节：%zu \n", sizeof(num), sizeof(c), sizeof(f), sizeof(d));

    int *pNum = #
    char *pC = &c;
    float *pF = &f;
    double *pD = &d;
    printf("pNum地址：%p, pC地址：%p, pF地址：%p, pD地址：%p \n", &pNum, &pC, &pF, &pD);
    printf("pNum字节: %zu, pC字节：%zu, pF字节：%zu, pD字节：%zu \n", sizeof(pNum), sizeof(pC), sizeof(pF), sizeof(pD));

    printf("改之前的值-->num: %d, c: %c, f: %f, d: %lf \n", num, c, f, d);
    *pNum = ;
    *pC = 'c';
    *pF = 222.5f;
    *pD = ;
    printf("改之后的值-->num: %d, c: %c, f: %f, d: %lf \n", num, c, f, d);

    /** 打印日志 //2, 1, 0, f, e, d, c, b, a, 9, 8, 7
     num地址：0x7fff5fbff758, c地址：0x7fff5fbff757, f地址：0x7fff5fbff750, d地址：0x7fff5fbff748
     num字节: 4， c字节：1, f字节：4, d字节：8
     pNum地址：0x7fff5fbff740, pC地址：0x7fff5fbff738, pF地址：0x7fff5fbff730, pD地址：0x7fff5fbff728
     pNum字节: 8, pC字节：8, pF字节：8, pD字节：8
     改之前的值-->num: 10, c: a, f: 12.000000, d: 22.500000
     改之后的值-->num: 111, c: c, f: 222.500000, d: 333.000000
     */

指针变量的应用练习1：交换两个变量的值

#include <stdio.h>

/** 交换变量值：地址传递  */
void swop2(int *v1,int *v2)
{
    int temp = *v1;
    *v1 = *v2;
    *v2 = temp;
}

/** 交换变量值：值传递 */
void swop(int v1,int v2)
{
    int temp = v1;
    v1 = v2;
    v2 = temp;

}

int main()
{
    int a = , b = ; //定义两个int类型变量

    printf("交换前a: %i, b: %i \n", a, b);

    //要求交换变量a和b的值
    //第一种尝试：传入变量a和b的变量名，在函数内部交换两个变量的值
    swop(a, b);
    printf("。。。传入变量名调用函数交换变量值: \n");
    printf("交换后a: %d, b: %d \n", a, b);

    //第二种尝试: 传入变量a和b的地址，在函数内部交换两个变量的值
    swop2(&a, &b);
    printf("。。。传入变量地址调用函数交换变量值：\n");
    printf("交换后a: %d, b: %d\n", a, b);

    /** 打印结果：
     交换前a: 20, b: 30
     。。。传入变量名调用函数交换变量值:
     交换后a: 20, b: 30
     。。。传入变量地址调用函数交换变量值：
     交换后a: 30, b: 20
     */

    printf("\n");
    return ;
}

指针变量的应用练习2：一个函数传入3个变量，求返回三个变量的和和平均值

#include <stdio.h>

/** 传入3个int变量，求3个变量之和 与 平均值 */
int getSum(int v1, int v2, int v3, int *ave){
    int sum = v1 + v2 + v3;
    *ave = sum/;
    return sum;
}

int main()
{
    int v1 = , v2 = , v3 = ;
    int ave;  //存储平均值
    int sum = getSum(v1, v2, v3, &ave);
    printf("v1: %d, v2: %d, v3: %d, 和sum: %d, 平均值ave: %d \n", v1, v2, v3, sum ,ave);
    //打印结果： v1: 18, v2: 998, v3: 188, 和sum: 1204, 平均值ave: 401

    printf("\n");
    return ;
}

指针变量注意点：

//1、指针只能保存地址
    int num = ;

    //int *p = num;
    //printf("p: %i \n", *p); //这样运行会挂

    //2、同一个变量可以有多个指针指向它
    int *p = #
    int *p2 = #
    printf("num: %d, *p: %i, *p2: %d \n", num, *p, *p2);
    *p2 = ;
    printf("改后num: %d, *p: %i, *p2: %d \n", num, *p, *p2);
    /** 打印日志：
     num: 10, *p: 10, *p2: 10
     改后num: 88, *p: 88, *p2: 88
     */

    //3、指针的指向可以修改
    int num2 = ;
    p2 = &num2;
    *p2 = ;
    printf("num: %d, *p: %d, *p2: %d, num2: %d \n", num, *p, *p2, num2);
    //打印日志：num: 88, *p: 88, *p2: 99, num2: 99

    //4、不要访问野指针：野指针值没有赋值的指针
    int *p3 = NULL;
    //*p3 = 12; //这样运行会挂

// 5、指针变量和变量类型要一致，即int类型指针只能存储int类型的变量的地址
// 因为当我们利用指针去取值的时候,系统会自动根据指针的类型来确定应该取对少个字节的值.
    int intValue = ;
    char *p = &intValue;
    printf("*p: %i \n", *p);
    /**
     打印日志：*p: 6
     为什么？
     intValue = 518 的二进制为：
     0000 0000 0000 0000 0000 0010 0000 0110

     指针变量p是char类型，只会存储char类型的地址，即一个字节的地址，
     所以指针变量p只存储了intValue的最小字节地址，即0000 0110这个字节的地址，转成十进制为：6
     */

多级指针测试：

//一级指针
    char ch = 'a';
    char *p = &ch;

    *p = 'b';
    printf("c: %c, *p: %c \n", ch, *p);
    //打印日志：c: b, *p: b

    //二级指针
    char **p2 = &p; //指向指针的指针，也占用8个字节
    **p2 = 'd';
    printf("ch: %c, *p: %c, **p2: %c \n", ch, *p, **p2);
    //打印日志：ch: d, *p: d, **p2: d

    //三级指针
    char ***p3 = &p2;
    ***p3 = 'f';
    printf("ch: %c, *p: %c, **p2: %c, ***p3: %c \n", ch, *p, **p2, ***p3);
    //打印日志：ch: f, *p: f, **p2: f, ***p3: f
    printf("地址--》ch: %p, p: %p, p2: %p, p3: %p \n", p, p2, p3, &p3);
    //打印日志：地址--》ch: 0x7fff5fbff76b, p: 0x7fff5fbff760, p2: 0x7fff5fbff758, p3: 0x7fff5fbff750

二、指针和数组

//指针和数组
    int arr[] = {, , };
    int *pi = arr;
    //arr是数组名，也是数组地址，也是数组中第一个元素的地址
    printf("arr: %p, pi: %p, arr[0]: %p \n", arr, pi, &arr[]);
    //打印日志：arr: 0x7fff5fbff760, pi: 0x7fff5fbff760, arr[0]: 0x7fff5fbff760

    //pi + 1 : 表示地址+1，本质是地址+该数据类型的字节个数; pi相当于数组名
    printf("pi+1: %p, arr+1: %p \n", pi+, arr+);
    printf("*(pi+1): %i, *(arr+1): %i, pi[1]: %i, arr[1]: %i \n", *(pi+), *(arr+), pi[], arr[]);
    /** 打印日志：
     pi+1: 0x7fff5fbff764, arr+1: 0x7fff5fbff764
     *(pi+1): 18, *(arr+1): 18, pi[1]: 18, arr[1]: 18
     */

    //字符指针和字符数组
    char cArr[] = {'a', 'B', 'c', 'D', '\0'};
    char *pc = cArr;
    printf("cArr: %p, pc: %p, cArr[0]: %p \n", cArr, pc, &cArr[]);
    printf("pc+1: %p, cArr+1: %p \n", pc+, cArr+);
    printf("*(pc+1): %c, *(cArr+1): %c, pc[1]: %c, cArr[1]: %c \n", *(pc+), *(cArr+), pc[], cArr[]);
    *(pc+) = 'Z';
    printf("*(pc+1): %c, *(cArr+1): %c, pc[1]: %c, cArr[1]: %c \n", *(pc+), *(cArr+), pc[], cArr[]);
    /** 打印日志：
     cArr: 0x7fff5fbff743, pc: 0x7fff5fbff743, cArr[0]: 0x7fff5fbff743
     pc+1: 0x7fff5fbff744, cArr+1: 0x7fff5fbff744
     *(pc+1): B, *(cArr+1): B, pc[1]: B, cArr[1]: B
     *(pc+1): Z, *(cArr+1): Z, pc[1]: Z, cArr[1]: Z
     */

三、常量指针和指向常量的指针

先来看几个变量，各自说说他们的区别和时什么类型的变量：

const  int   a1;   //常量a1
int  const  a2;    //常量a2, 这种写法和常量a1的写法是等效的关系

const  int  *a3;     //指向整型常量的指针： 所指向的目标为常量（不能间接修改指向变量的值，可以从新赋值新地址）
int  *  const   a4;  //a4和a3 不同，a4是常量指针，指向整型的常量指针，即指针是常量
//（可以间接修改指向变量的值，但是不可重新赋值新变量地址）

const  int  *  const  a5;  //a5是指向整型常量的常量指针（既不能间接修改变量的值，也不可重新赋值新变量地址）

总结：1、const关键字写在数据类型的前面和后面是等效关系；

　　2、指向常量的指针：不能间接修改所指向变量的值，但是可以给指针重新赋值新地址

　　3、常量指针：可以间接修改指向变量的值，但是不能重新赋值新变量地址

　　4、指向常量的常量指针：有2个const修改，既不能间接修改变量的值，也不可重新赋值新变量地址

验证示例代码：

//1、指针变量，指针变量可间接修改值，指针变量也可重新赋值新变量地址
    int a = , a2 = ;
    int *ap = &a;
    *ap = ;

    printf("测试1：a=%d, a地址：%x, *ap=%d, ap地址：%x, ap保存的地址：%x \n", a, &a, *ap, &ap, ap);
    printf("变量a占用字节个数：%lu, 变量ap占用字节个数：%lu \n", sizeof(a), sizeof(ap));
    //测试1：a=12, a地址：5fbff65c, *ap=12, ap地址：5fbff650, ap保存的地址：5fbff65c
    //变量a占用字节个数：4, 变量ap占用字节个数：8
    //验证一个问题：a占用的字节地址为5fbff65f-5fbff65c, ap占用的字节地址为：5fbff657-5fbff650
    *ap = ;
    printf("测试2：a=%d, a地址：%x, *ap=%d, ap地址：%x, ap保存的地址：%x \n", a, &a, *ap, &ap, ap);
    //测试2：a=13, a地址：5fbff65c, *ap=13, ap地址：5fbff650, ap保存的地址：5fbff65c

    ap = &a2;
    printf("*ap=%d, a2=%d, &a2=%x, ap=%x \n", *ap, a2, &a2, ap);
    //*ap=22, a2=22, &a2=5fbff658, ap=5fbff658  //说明指针变量可以重新指向其他变量

    //2、测试指向整型常量的指针
    int c = , c2 = ;
    int const *cp = &c;  //指向整型常量的指针
    printf("c1: c=%d, *cp=%d, &c=%x, cp=%x \n", c, *cp, &c, cp);
    //c1: c=19, *cp=19, &c=5fbff63c, cp=5fbff63c
//    *cp = 20; //报错：Read-only variable is not assignable
    //指向整形常量的指针，不能间接修改变量的值，因为指向整型常量
    c = ;  //但是原变量自己可以直接修改自己的值
    printf("c2: c=%d, *cp=%d, &c=%x, cp=%x \n", c, *cp, &c, cp);
    //c2: c=20, *cp=20, &c=5fbff63c, cp=5fbff63c
    cp = &c2;
    printf("c3: c2=%d, *cp=%d, &c2 = %x, cp=%x \n", c2, *cp, &c2, cp);
    //c3: c2=29, *cp=29, &c2 = 5fbff638, cp=5fbff638

    //3、测试指向整型的常量指针
    int d = , d2 = ;
    int* const dp = &d;
    printf("d1: d=%d, *dp=%d, &d=%x, dp=%x \n", d, *dp, &d, dp);
    //d1: d=31, *dp=31, &d=5fbff63c, dp=5fbff63c
    *dp = ;
    printf("d2: d=%d, *dp=%d, &d=%x, dp=%x \n", d, *dp, &d, dp);
    //d2: d=3, *dp=3, &d=5fbff63c, dp=5fbff63c

//    dp = &d2; //报错：Cannot assign to variable 'dp' with const-qualified type 'int *const'
    //指向整型的常量指针，不能再重新赋值其他变量地址。但是可以间接修改当前指向的变量的值

    //4、测试指向整型常量的常量指针：既不能间接修改变量的值，也不能重新赋值新的变量地址
    int e = , e2 = ;
    int const * const ep = &e;
//    *ep = 48; //报错：Read-only vaiable is not assignable
//    ep = &e2;//报错：Cannot assign to variable 'ep' with const-qualified type 'int *const'

    //5、指向常量的指针变量
    int const b = ; //
    //    b = 30;  //编译报错：Cannot assign to variable 'b' with const-qualified type 'const int'
    int *bp = &b;
    printf("b=%d, b地址: %x, bp保存的地址：%x, *bp: %d \n", b, &b, bp, *bp);
    //b=50, b地址: 5fbff64c, bp保存的地址：5fbff64c, *bp: 50

    *bp = ;
    printf("修改后b=%d, b地址: %x, bp保存的地址：%x, *bp: %d \n", b, &b, bp, *bp);
    //修改后b=50, b地址: 5fbff64c, bp保存的地址：5fbff64c, *bp: 88
    /*
     这个地方有点奇怪，b是常量，指针变量bp指向b, 间接通过指针bp修改变量的值，
     但是最后打印结果是：*bp的值变了，b的值没有变（b是常量，指针变量bp指向b), 而且bp保存的地址和b的地址还是保持一样
     这究竟是为啥？怎么理解 ？
     变量被const修饰时，就复制了其值出来放到常量表中（由系统维护）
     但是每次取常量时，它是从常量表找到以前的值，而不是再次读内存。
     而指针变量bp可以修改指向地址里面的值。
     不知这样理解是否正确？
     */

四、指针和字符串的关系，变量内存栈区和常量区区别

测试字符数组，指向字符数组的指针，和指向字符串的指针的区别；

字符数组和指针存储的字符串在内存中的存储位置：即栈区存储和常量区存储的区别

 //1、字符数组
    char cs[] = "test";
    printf("%s, 第一个字符：%c, 地址：%p, %p, %p\n", cs, cs[], cs, &cs[], &cs[]);
    cs[] = 'A';
    printf("修改后的字符数组：%s, 第一个字符：%c, 地址：%p, %p, %p\n", cs, cs[], cs, &cs[], &cs[]);
    /*
     test, 第一个字符：t, 地址：0x7fff5fbff63b, 0x7fff5fbff63c, 0x7fff5fbff63d
     修改后的字符数组：Aest, 第一个字符：A, 地址：0x7fff5fbff63b, 0x7fff5fbff63c, 0x7fff5fbff63d
     */

    //2、指向字符串的指针
    char *cp = cs;
//    printf("%s", *cp);  //这样写会挂掉，因为*cp取出的数组中第一个字符
    printf("%s, %c, %c, %c, %c\n", cp, *cp, *(cp+), *(cp+), *(cp+));
    printf("%p, %p, %p\n", cp, cp+, cp+);
    /*
     Aest, A, A, e, s
     0x7fff5fbff63b, 0x7fff5fbff63c, 0x7fff5fbff63d

     解释： cp表示数组名，取出字符数组所有字符；*cp == *(cp+0) 表示取出数组中第一个字符的值，后面以此类推；
     cp表示字符数组中第一个字符的地址， cp+1表示第二个字符的地址， 后面以此类推
     cp格式化时用%s表示取出整个字符数组的所有字符，用%p表示取出字符数组的最低位地址（即第一个字符的地址）
     */
    //修改字符数组的值
    *cp = 'B';
    *(cp+) = 'C';
    *(cp + ) = 'd';
    printf("通过指针修改字符数组的值：%s, %c\n", cp, *(cp+));

    //直接字符指针指向常量字符串
    char *cp2 = "daxia";
    printf("cp2: %s, %p, %c, %p, %c, %p\n", cp2, cp2, *(cp2+), cp2+, *(cp2+), cp2+);
    //cp2: daxia, 0x100001aab, a, 0x100001aac, x, 0x100001aad
//    *(cp2 + 1) = 'G';  //野指针错误：因为常量字符串不允许修改

    //测试字符数组的存储区和常量字符串的存储地方
    char cs1[] = "hello";
    char cs2[] = "hello";
    char *p1 = "hello";
    char *p2 = "hello";
    printf("cs1: %p, cs2: %p, p1: %p, p2: %p\n", cs1, cs2, p1, p2);
    //cs1: 0x7fff5fbff61a, cs2: 0x7fff5fbff614, p1: 0x100001a9e, p2: 0x100001a9e
    //为什么？说明：字符数组存在内存中的栈区，常量字符串存在内存中的常量区
    /*
     如果通过数组来保存字符串，那么字符串变量可以修改，存在内存栈中，当作用域结束时自动释放该变量；
     如果通过指针来保存字符串，那么字符串是一个常量不能修改，保存在内存常量区，不会被释放，多个相同的值对应的地址相同；
     */

五、数组越界造成的访问不属于自己的内存空间

六、引用数据类型和基本数据类型，形参和实参

七、字符串和字符数组

八、字符串常用函数(长度、拷贝、追加、比较)

demo地址：https://github.com/xiaotanit/Tan_TestIOS/tree/master/Tan_LocationMove