c语言指针详解_C语言之精华——指针详解（下）

点击上方“C语言中文社区”，选择“设为星标★”

技术干货第一时间送达！

https://www.cnblogs.com/lulipro/p/7460206.html

C语言之精华——指针详解(上)

目录

• 数组和指针
• 函数和指针
• const 和 指针
• 深拷贝和浅拷贝
• 附加知识

数组和指针

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
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;
}

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#等 在语言层面封装了对指针的直接操作的编程语言中。引用是编程语言提供给程序员的抽象机制，而指针是操作系统提供给软件开发模型的抽象机制。

大端模式和小端模式

1. Little-Endian 就是数据的低字节排放在内存的低地址端，高字节排放在内存的高地址端。个人 PC 常用，Intel X86 处理器是小端模式。
2. B i g-Endian 就是数据的高字节排放在内存的低地址端，低字节排放在内存的高地址端。

采用大端方式 进行数据存放符合人类的正常思维，而采用小端方式进行数据存放利于计算机处理。有些机器同时支持大端和小端模式。

假如 short 类型占用 2 个字节，且存储的地址为 0x30。short a = 1;

如下图：

#include

//测试机器使用的是否为小端模式。是，则返回true，否则返回false
//这个方法判别的依据就是：C语言中一个对象的地址就是这个对象占用的字节中，地址值最小的那个字节的地址。
int isSmallIndain(void){
      unsigned short val = 0x0001;
      unsigned char* p = (unsigned char*)&val;  //C/C++：对于多字节数据，取地址是取的数据对象的第一个字节的地址，也就是数据的低地址

      return (*p == 0x01);
}

int main(void){

    if(isSmallIndain())
    {
        puts("小端");
    } else{
        puts("大端");
    }

    return 0;

}

第二种方法，使用 union 类型

#include


typedef union {
    unsigned short us;
    unsigned char  uc;
}Test_t;

int main(void){
    Test_t val;
    val.us = 0x0001;

    if(val.uc==0x01)
    {
        puts("小端");
    } else{
        puts("大端");
    }

    return 0;

}

#include


//打印出一个unsigned short int 类型的原始字节流
//这个例子中很明显看到，取到a的首地址后，我们循环递增了p，而非递减p，也从来不会看到有从首地址递减输出数据的字节的写法。
//这也就佐证了：在C语言中，对于一个多字节数据，它的地址就是它占用的所有字节中的地址值最小的那个字节的虚拟空间地址
//这也又说明了一个事实：C语言中，一个多字节数据类型的实例，占用的虚拟内存空间是连续的。
int main(void){
    size_t i;
    unsigned short int a = 0xA1FF;
    unsigned char*p = (unsigned char*)&a;

    for( i=0;i<sizeof(a);++i)
    {
        printf("%#x ",*p);   //小端平台输出：0xFF 0xA1
        p++;                 //大端平台输出：0xA1 0xFF

    }
    printf("\n\n");

    return 0;
}

喜欢就点个在看再走吧