C语言面试题（自总结）

C 语言的编译过程

1. 预处理：hello.c -> hello.i 找到头文件、展开宏；
2. 编译：hello.i -> hello.S 将预处理后的代码转化为汇编码；
3. 汇编：hello.S -> hello.o 将汇编码进行汇编，生成机器码；
4. 链接：hello.o -> hello 将所有使用到的 .o 文件链接在一起，生成可执行文件；

C 程序运行时的内存区域构成

栈区：

• 存放局部变量、函数参数和返回地址等
• 栈区的大小通常是固定的，有操作系统或编译器设置

堆区：

• 动态分配内存区域，通过 malloc、calloc、realloc、和 free 等函数进行管理
• 堆内存有程序员手动管理，容易造成内存泄漏

文件映射区域：在某些实现中，如果请求的内存非常大，可能会使用内存映射（如 mmap）而不是传统的堆分配方式，这可以更有效地管理大块内存。

数据区：

• 存放全局变量和静态变量的初始值。
• 可以分为两个部分：
  • 初始化数据段：存储初始化的全局变量和静态变量。
  • 未初始化数据段 (BSS)：存储未初始化的全局变量和静态变量，通常会在程序加载时被清零。

代码（文本）段：

• 存放程序的机器指令
• 只读，防止程序修改自己的指令

头文件中双引号和尖括号的区别是什么？

• 双引号 #include "stdio.h" 
  • 搜索顺序：编译器首先会在当前源文件所在的目录下查找该头文件。如果找不到才去系统默认的头文件目录中查找。
  • 适用场景：用于包含用户自定义的头文件，如项目中的模块或库

• 尖括号 #include <stdio.h>
  • 搜索顺序：编译器直接在系统默认的头文件目录下查找该头文件，而不在当前目录中查找。
  • 适用场景：用于包含系统提供的标准库头文件，例如 stdio.h、stdlib.h 等。

C语言的数据类型

基本数据类型

• 整型（int）：用于表示整数。
  • short int（16 位）
  • int （32 位）
  • long int （32 位或 64 位，取决于平台）
  • long long int （64 位）
• 字符型（char）：用于表示单个字符（8 位）。
  • unsigned char：无符号字符，范围 0-255。
• 浮点型（float）：用于表示单精度浮点数（32 位）。
• 双精度浮点型（double）：用于表示双精度浮点数（64 位）。
• 长双精度浮点型（long double）：用于表示更高精度的浮点数（64 位或 80 位）。

构造数据类型

• 数组（array）：一组同类型元素的集合。int arr[10]; 定义一个包含 10 个整型元素的数组
• 结构体（struct）：用于组合不同类型的数据。

struct Person {
    char name[50];
    int age;
};

• 共同体（union）：与结构体类似，但在同一内存位置存储不同类型的数据。只会占用最大成员所需类型空间。

union Data {
    int intValue;
    float floatValue;
    char charValue;
};

• 枚举（enum）：用于定义一组命名的整型变量。在赋值的情况下，第一个枚举元素的默认值为 0，之后每一个元素的值为前一个元素的值加一。

enum Color { RED, GREEN, BLUE };

指针类型：用于存储其他变量的地址。

int *ptr; // ptr 是一个指向整型的指针

空类型：表示没有类型，常用于函数返回类型，表示该函数不返回任何值。用来定义指针时，该指针可以指向任意类型的数据。

void function() {
    // 不返回任何值
}

定义常量有什么方法，区别是什么？

使用 const 定义常量：const int OFF = 0; 或 int const OFF = 0;

使用 #define 定义常量：#define OFF 0

使用 enum 枚举类型：enum{ OFF = 0 };

区别：

• 类型检查：const 有类型，提供编译时的检查；#define 没有类型，可能导致错误而不易发现。
• 作用域：const 和 enum 可以有局部作用域；#define 是全局的，直到编译结束。
• 调试支持：使用 const 的常量可以在调试中查看其值；#define 在展开后无法跟踪。
• 适用场景：#define 常用于定义简单的常量，如数学常量、条件等；const 适合需要类型安全的常量；enum 用于常量的分组。

volatile作用和用法

volatile意思是“易变的”，解释为“直接存取原始内存地址”比较合适。

volatile 关键字在多线程编程中非常重要，主要用于确保变量的可见性和防止指令重排序；一个线程对 volatile 变量的修改会立即对其他线程可见；volatile 提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，告诉编译器对该变量不做优化，直接从变量内存地址中读取数据，从而可以提供对特殊地址的稳定访问。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

volatile int running = 1;

void* run(void* arg){
    while(running){
        printf("thread is running...");
        delay(100);
    }
    printf("thread stopped");
    return NULL;
}
int main(){
    pthread_t th;
    pthread_create(&th, NULL, run, NULL);
    // 让主线程运行一段时间
    delay(1000);
    // 修改 volatile 变量
    running = 0;
    pthread_join(th, NULL);
    return 0;
}

static 关键字的作用

static 主要用来修饰局部变量、全局变量、函数。

• 静态局部变量：作用域限于其定义的函数内部；在程序运行的整个期间保持其值，而不是在函数调用结束时被销毁。

#include <stdio.h>

void function() {
    static int count = 0; // 静态局部变量
    count++;
    printf("Count: %d\n", count);
}

int main() {
    function(); // 输出 Count: 1
    function(); // 输出 Count: 2
    function(); // 输出 Count: 3
    return 0;
}

• 静态全局变量：作用域限制在定义它的文件内，其他文件无法访问；在程序运行期间一直存在。

// file1.c
static int globalVar = 10; // 静态全局变量
void display() {
    printf("Global Variable: %d\n", globalVar);
}

// file2.c
// extern int globalVar; // 不能访问，因为 globalVar 是静态的

• 静态函数：只能在定义它的文件内部使用，外部文件无法调用该函数；用于限制函数可见性，避免命名冲突。

// file1.c
static void helperFunction() {
    printf("This is a static function.\n");
}

void publicFunction() {
    helperFunction(); // 可以调用
}

// file2.c
// void publicFunction(); // 可调用，但不能调用 helperFunction

extern 关键字的作用

        extern 用于声明一个变量或函数的存在，而不定义它。通常使用在跨文件共享的变量和函数。使用 extern 声明不会分配内存，只是告诉编译器该变量或函数在其他地方定义。

• 声明全局变量：在一个文件中声明，另一个文件中定义的全局变量。可以在多个文件共享同一变量。

//----------------------------------  file1 ---------------------------------
int globalVar = 10; // 定义全局变量

void display() {
    printf("Global Variable: %d\n", globalVar);
}
//----------------------------------  file2 ---------------------------------
extern int globalVar; // 声明全局变量

void print() {
    printf("Global Variable in file2: %d\n", globalVar);
}

• 声明函数：声明在其他文件中定义的函数（在 C 中函数默认是 extern 的，因此可以省略 extern）。

//----------------------------------  file1 ---------------------------------
void function() {
    printf("Hello from function!\n");
}
//----------------------------------  file2 ---------------------------------
extern void function(); // 声明函数

int main() {
    function(); // 调用在 file1.c 中定义的函数
    return 0;
}

关键字sizeof与strlen

sizeof

• 计算的是数据类型或变量所占的字节数。
• 可以作用于任何数据类型，包括基本数据类型、结构体、数组、指针等。
• 在编译时就会计算出结果，不会增加程序运行时的开销

#include <stdio.h>

int main() {
    int a;
    double b;
    char str[20];

    printf("Size of int: %zu bytes\n", sizeof(a));        // 输出 int 的大小
    printf("Size of double: %zu bytes\n", sizeof(b));     // 输出 double 的大小
    printf("Size of array: %zu bytes\n", sizeof(str));    // 输出数组的大小

    return 0;
}

strlen

• 计算的时字符串的字符数量（不包含结尾的'\0'）
• 只能用于字符串
• 在程序运行时计算出结果，需要遍历整个字符串导致增加运行开销。

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, World!";
    
    printf("Length of the string: %zu\n", strlen(str));  // 输出字符串的长度

    return 0;
}