C语言进阶剖析 29 指针和数组分析(下)

  • 问题: 数组名可以当作常量指针使用,那么指针是否也可以当作数组名来使用呢

数组的访问方式

  • 以下标的形式访问数组中的元素
void code_1()
{
    int a[5] = {0};
    
    a[1] = 3;
    a[2] = 5;
}
  • 以指针的形式访问数组中的元素
void code_2()
{
    int a[5] = {0};
    
    *(a + 1) = 3;
    *(a + 2) = 5;
}

下标形式 VS 指针形式

  • 指针以固定增量在数组中移动,效率高于下标形式
  • 指针增量为 1 且硬件具有硬件增量模型时,效率更高
  • 下表形式与指针形式的专函
    a[n] <--> *(a + n) <--> *(n + a) <--> n[a]

注意:现代编译器生成代码的优化率已大大提高,固定增量时,下标形式的效率已经和指针相当;而且从可读性和代码维护性的角度来看,下标形式更优。

编程实验: 数组的访问方式

#include <stdio.h>

int main()
{
    int a[5] = {0};
    int* p  = a;
    int i = 0;
    
    for(i=0; i<5; i++)
    {
        p[i] = i + 1;
    }
    
    for(i=0; i<5; i++)
    {
        printf("a[%d] = %d\n", i, *(a + i));
    }
    
    printf("\n");
    
    for(i=0; i<5; i++)
    {
        i[a] = i + 11;
    }
    
    for(i=0; i<5; i++)
    {
        printf("p[%d] = %d\n", i, p[i]);
    }
    

    return 0;
}
输出:
a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5

p[0] = 11
p[1] = 12
p[2] = 13
p[3] = 14
p[4] = 15

编程实验: 数组和指针不同

test.c

#include <stdio.h>

int main()
{
    extern int* a;
    
    printf("&a = %p\n", &a);
    printf("a = %p\n", a);
    printf("*a = %d\n", *a);
}

ext.c

int a[] = {1, 2, 3, 4, 5};
输出:【编译无警告,无错误】
&a = 0x804a014
a = 0x1
段错误

分析:

  • 为什么编译没有警告,没有报错呢?
        ○ 编译器中,在编译阶段进行语法、语义检查,进行警告和错误提示。但是各个文件在编译阶段是互相独立的,文件之间没有关联。
        ○ 在 test.c 文件中, 编译器发现 extern int* a; 就会把 a 当作一个外部定义的 int*指针变量进行解析使用,不再做其它任何处理;
        ○ 在链接阶段,发现 a 符号确实是存在的,而连接器没有能力去检查 a 的属性,因此链接也无警告和错误提示,导致正常编译生成最终文件。

  • 运行过程中发生了什么呢?

  1. ext.c中,编译器发现 int a[] = {1, 2, 3, 4, 5}; 便会分配 20 字节空间,空间名为a,其中包含 5 个 int 类型元素,并进行初始化;
  2. test.c中, 编译器发现 extern int* a; 此后 a 在当前文件中就会被当作 int* 指针变量进行解析;
  3. &a 当前文件中,意图访问 int* 指针变量的地址,实质结果为访问数组a[5]的数组名a的地址,即访问数组首元素的地址&a[0],&a[0] 对数组操作是有效的,因此正常输出0x804a014;
  4. a 当前文件中,意图访问int* 指针变量存储的地址值,此时 a 地址为 0x804a014,实质结果为访问 0x804a014 处存储的数值, 即 数组a[5] 中 *a ==> a[0] ==> 0x01;
    5.*a 当前文件中,意图访问 int* 指针变量指向的地址处空间,a 存储的地址值为 0x01, 就会访问 0x01 地址处的内容,造成段错误。

a 与 &a 的区别

  • a 为首元素的地址
  • &a 为整个数组的地址
  • a 和 &a的区别在于指针运算
        ○ a + 1 ==> (unsigned int)a + sizeof(*a)
        ○ &a + 1 ==> (unsigned int)(&a) + sizeof(*&a) ==> (unsigned int)(&a) + sizeof(a)

补充:a和*(&a)等价

#include <stdio.h>

int main()
{ 
   int a[] = {1, 2, 3, 4, 5};
   printf("&a = %p\n", &a);
   printf("a = %p\n", a);
//  printf("*(&a) = %d\n", *&a);//warning: format%d’ expects typeint, but argument 2 has typeint *’
   printf("*(&a) = %p\n", *&a);
   printf("*(&a[0]) = %d\n", *&a[0]);
   printf("*a = %d\n", *a);

/**********sizeof(a) (*&a) *a *********/
  printf("sizeof_*(&a) = %d; sizeof_(a) = %d; sizeof_(*a) = %d.\n", sizeof(*&a),sizeof(a),sizeof(*a));

   return 0;
}
结果:
&a = 0xbfcbc6fc
a = 0xbfcbc6fc
*(&a) = 0xbfcbc6fc
*(&a[0]) = 1
*a = 1
sizeof_*(&a) = 20; sizeof_(a) = 20; sizeof_(*a) = 4.


实例分析: 指针运算经典问题

#include <stdio.h>

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int* p1 = (int*)(&a + 1);
    int* p2 = (int*)((int)a + 1);
    int* p3 = (int*)(a + 1);
    
    printf("%d, %d, %d\n", p1[-1], p2[0], p3[1]);
    
    return 0;
}
输出:【linux 小端模式】
5, 33554432, 3


分析

  • p1[-1] :
        ○ p1 = (int*)(&a + 1) ==> p1 = (int*)(&a + sizeof(*&a)) ==> p1 = (int*)(&a + sizeof(a)) ==> p1 = (int*)(&a[0 + 5]) ==> p1 = (int*)(&a[5])
        ○ p1[-1] = a[5 - 1] = a[4] = 5

  • p3[1] :
        ○ p3 = (int*)(a + 1) ==> p3 = (int*)(&a[0 + 1]) ==> (int*)(&a[1])
        ○ p3[1] = a[1 + 1] = a[2] = 3



数组参数

  • 数组作为函数参数时,编译器将其编译成对应的指针
    void f(int a[]); <--> void f(int* a);
    void f(int a[5]); <--> void f(int* a);

结论: 一般情况下,当定义的函数中有数组参数时,需要定义另一个参数来标识数组的大小。

实例分析: 虚幻的数组参数

#include <stdio.h>

void func1(char a[5])
{
    printf("In func1: sizeof(a) = %d\n", sizeof(a));  // 请注意打印输出
    
    *a = 'a';
    
    a = NULL;      // 请注意打印输出
}

void func2(char b[])
{
    printf("In func1: sizeof(b) = %d\n", sizeof(b));  // 请注意打印输出
    
    *b = 'b';
    
    b = NULL;      // 请注意打印输出
}

int main()
{
    char array[10] = {0};
    
    func1(array);
    
    printf("array[0] = %c\n", array[0]);
    
    func2(array);
    
    printf("array[0] = %c\n", array[0]);

    return 0;
}
输出:【编译无警告,无错误】
In func1: sizeof(a) = 4
array[0] = a
In func1: sizeof(b) = 4
array[0] = b

小结

  • 数组名和指针仅一定情况下使用方式相同
        ○ 数组名的本质不是指针
        ○ 指针的本质不是数组
  • 数组名并不是数组的地址,而是数组首元素的地址
  • 函数的数组参数退化为指针
补充:以上实验在32位机器中运行。

当指针大小占用 8 字节时(64位机器), 使用 (unsigned int) 强制类型转换将发生数据截断,导致得到不正常的结果。
已标记关键词 清除标记
简介: C语言是编程语言中的一朵奇葩,虽已垂垂老矣,但却屹立不倒,诞生了数十年,仍然是最流行的编程语言之一。C语言看似简单,却不易吃透,想要运用好,更是需要积淀。本书是一本修炼C程序设计能力的进阶之作,它没有系统地去讲解C语言的语法和编程方法,而是只对C语言中不容易被初学者理解的重点、难点和疑点进行了细致而深入的解读,揭露了C语言中那些鲜为普通开发者所知的秘密,旨在让读者真正掌握C语言,从而编写出更高质量的C程序代码。 全书一共11章:第1章重点阐述了C语言中不易被理解的多个核心概念,很多初学者在理解这些概念时都会存在误区;第2~8章对预处理、选择结构和循环结构的程序设计、数组指针、数据结构、函数和文件等知识点的核心问题和注意事项进行了讲解;第9章介绍了调试和异常处理的方法及注意事项;第10章对C语言中的若干容易让开发者误解误用的陷阱知识点进行了剖析;第11章则对所有程序员必须掌握的几种算法进行了详细的讲解;附录经验性地总结了如何养成良好的编码习惯,这对所有开发者都尤为重要。 本书主要内容:  堆和栈、全局变量和局部变量、生存期和作用域、内部函数和外部函数、指针变量、指针数组数组指针指针函数和函数指针、传址和传值、递归和嵌套、结构体和共用体、枚举、位域等较难理解的核心概念的阐述和对比;  预处理中的疑难知识点,包括文件的包含方式、宏定义及其常见错误解析、条件编译指令和#pragma指令的使用等;  if、switch等选择结构语句的使用注意事项和易错点解析;  for、while、do while等循环结构语句的使用注意事项和易错点解析;  循环结构中break、continue、goto、return、exit的区别;  一维数组、二维数组、多维数组、字符数组、动态数组的定义和引用,以及操作数组时的各种常见错误解析;  不同类型的指针之间的区别,以及指针的一般用法和注意事项;  指针与地址、数组、字符串、函数之间的关系,以及指针指针之间的关系;  枚举类型的使用及注意事项,结构体变量和共用体变量的初始化方法及引用;  传统链表的实现方法和注意事项,以及对传统链表实现方法的颠覆;  与函数参数、变参函数、函数调用、函数指针相关的一些难理解和容易被理解错的知识点解析;  文件和指针的使用原则、技巧和注意事项;  函数调用和异常处理的注意事项和最佳实践;  与strlen、sizeof、const、volatile、void、void*、#define、typedef、realloc、malloc、calloc等相关的一些陷阱知识点的解析;  时间复杂度、冒泡排序法、选择排序法、快速排序法、归并排序法、顺序排序法、二分查找等常用算法的详细讲解;  良好的编码习惯和编程风格。
相关推荐
透析C语言中的核心概念、重要知识点、不易理解的知识点,以及容易被错误理解的知识点,是修炼C程序设计能力的必读之作。 C语言是编程语言中的一朵奇葩,虽已垂垂老矣,但却屹立不倒,诞生了数十年,仍然是最流行的编程语言之一。C语言看似简单,却不易吃透,想要运用好,更是需要积淀。本书是一本修炼C程序设计能力的进阶之作,它没有系统地去讲解C语言的语法和编程方法,而是只对C语言中不容易被初学者理解的重点、难点和疑点进行了细致而深入的解读,揭露了C语言中那些鲜为普通开发者所知的秘密,旨在让读者真正掌握C语言,从而编写出更高质量的C程序代码。 《C语言进阶:重点、难点与疑点解析》一共11章:第1章重点阐述了C语言中不易被理解的多个核心概念,很多初学者在理解这些概念时都会存在误区;第2~8章对预处理、选择结构和循环结构的程序设计、数组指针、数据结构、函数和文件等知识点的核心问题和注意事项进行了讲解;第9章介绍了调试和异常处理的方法及注意事项;第10章对C语言中的若干容易让开发者误解误用的陷阱知识点进行了剖析;第11章则对所有程序员必须掌握的几种算法进行了详细的讲解;附录经验性地总结了如何养成良好的编码习惯,这对所有开发者都尤为重要。 目录 《C语言进阶:重点、难点与疑点解析》 前言 第1章 必须厘清的核心概念/1 1.1 堆栈/2 1.2 全局变量和局部变量/5 1.3 生存期和作用域/7 1.3.1 生存期/7 1.3.2 作用域/10 1.4 内部函数和外部函数/11 1.5 指针变量/14 1.6 指针数组数组指针/17 1.7 指针函数和函数指针/20 1.8 传值和传址/22 1.9 递归和嵌套/25 1.10 结构体/29 1.11 共用体/32 1.12 枚举/37 1.13 位域/39 第2章 预处理/47 2.1 文件的包含方式/48 2.2 宏定义/50 2.2.1 简单宏替换/50 2.2.2 带参数的宏替换/52 2.2.3 嵌套宏替换/56 2.3 宏定义常见错误解析/56 2.3.1 不带参数的宏/56 2.3.2 带参数的宏/59 2.4 条件编译指令的使用/62 2.5 #pragma指令的使用/65 第3章 选择结构和循环结构的程序设计/69 3.1 if语句及其易错点解析/70 3.2 条件表达式的使用/76 3.3 switch语句的使用及注意事项/78 3.4 goto语句的使用及注意事项/85 3.5 for语句的使用及注意事项/87 3.6 while循环与do while循环的使用及区别/92 3.7 循环结构中break、continue、goto、return和exit的区别/98 第4章 数组/103 4.1 一维数组的定义及引用/104 4.2 二维数组的定义及引用/110 4.3 多维数组的定义及引用/117 4.4 字符数组的定义及引用/119 4.5 数组作为函数参数的易错点解析/124 4.6 动态数组的创建及引用/130 第5章 指针/139 5.1 不同类型指针之间的区别和联系 /140 5.2 指针的一般性用法及注意事项/144 5.3 指针与地址之间的关系/148 5.4 指针数组之间的关系/153 5.5 指针与字符串之间的关系/161 5.6 指针与函数之间的关系/163 5.7 指针指针之间的关系/169 第6章 数据结构/172 6.1 枚举类型的使用及注意事项/173 6.2 结构体变量的初始化方法及引用/177 6.2.1 结构体的初始化/177 6.2.2 结构体的引用/180 6.3 结构体字节对齐详解/184 6.4 共用体变量的初始化方法及成员的引用/193 6.5 传统链表的实现方法及注意事项/196 6.6 颠覆传统链表的实现方法/214 6.6.1 头结点的创建/214 6.6.2 结点的添加/215 6.6.3 结点的删除/217 6.6.4 结点位置的调整/219 6.6.5 检测链表是否为空/221 6.6.6 链表的合成/222 6.6.7 宿主结构指针/225 6.6.8 链表的遍历/225 第7章 函数/230 7.1 函数参数/231 7.2 变参函数的实现方法/235 7.3 函数指针的使用方法/241 7.4 函数之间的调用关系/245 7.5 函数的调用方式及返回值/251 第8章 文件/255 8.1 文件及文件指针/256 8.2 EOF和FEOF的区别/259 8.3 读写函数的选用原则/264 8.4 位置指针对文件的定位/270 8.5 文件中的出错检测/275 第9章 调试和异常处理/279 9.1 assert宏的使用及注意事项/280 9.2 如何设计一种灵活的断言/283 9.3 如何实现异常处理/287 9.4 如何处理段错误/293 第10章 陷阱知识点解剖/299 10.1 strlen和sizeof的区别/300 10.2 const修饰符/301 10.3 volatile修饰符/305 10.4 void和void*的区别/311 10.5 #define和typedef的本质区别/314 10.6 条件语句的选用/317 10.7 函数realloc、malloc和calloc的区别/319 10.8 函数和宏/322 10.9 运算符==、=和!=的区别/323 10.10 类型转换/324 第11章 必须掌握的常用算法/326 11.1 时间复杂度/327 11.2 冒泡法排序/329 11.3 选择法排序/332 11.4 快速排序/334 11.5 归并排序/337 11.6 顺序查找/340 11.7 二分查找/341 附录 如何养成良好的编程习惯/344
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页