c语言defaults

C 语言的默认行为主要可以分为以下几个大类：

1. 数据类型的默认规则
2. 函数参数的默认规则
3. 存储类的默认规则
4. 编译器的默认行为

数据类型的默认规则

这是最常见也最容易出错的默认行为,主要涉及 int 和 double。

a) int 的默认

如果一个变量的类型没有被明确指定,并且它的初始化值是一个整数，那么它默认会被推断为 int 类型。

示例代码：

// 以下两个变量的声明是等价的
my_var = 10; // 默认为 int 类型
int my_var = 10; // 明确指定为 int

重要场景： 在函数定义中，如果省略了返回类型，它默认是 int。

// 以下两个函数定义是等价的
add(int a, int b) {
    return a + b;
}
int add(int a, int b) {
    return a + b;
}

注意： 这个特性在 C99 标准中被废弃了，现代 C 编译器（如 GCC, Clang）会给出警告，要求必须指定返回类型。

b) double 的默认

如果一个浮点数常量（带小数点的数字）没有后缀，它默认会被推断为 double 类型。

示例代码：

// 以下两个变量的声明是等价的
pi = 3.14; // 默认为 double 类型
double pi = 3.14;
// 如果想指定为 float，需要使用 f 或 F 后缀
float small_pi = 3.14f; // 明确指定为 float

函数参数的默认规则

在 C 语言中，函数参数默认是“值传递”（Pass-by-Value），这意味着函数内部接收到的是原始参数的一个副本，对副本的修改不会影响到原始数据。

示例代码：

#include <stdio.h>
void modify_value(int x) {
    x = 100; // 修改的是副本 x
    printf("Inside function, x = %d\n", x);
}
int main() {
    int original_var = 10;
    printf("Before function call, original_var = %d\n", original_var);
    modify_value(original_var); // 传递 original_var 的值
    printf("After function call, original_var = %d\n", original_var);
    return 0;
}

输出：

Before function call, original_var = 10
Inside function, x = 100
After function call, original_var = 10

可以看到,original_var 在函数调用后没有改变，这是 C 语言函数调用的核心默认行为。

存储类的默认规则

存储类决定了变量的生命周期（何时创建和销毁）和作用域（在何处可见）。

a) auto 的默认

在所有函数内部（局部作用域）声明的变量，如果没有指定存储类，默认就是 auto（自动的）。auto 变量存储在栈上，当它所在的代码块（如函数或 块）执行完毕时，它就会被销毁。

示例代码：

#include <stdio.h>
void my_function() {
    // 以下两个声明是等价的
    int x = 10; // 默认是 auto
    auto int y = 20; // 显式声明为 auto
    printf("x = %d, y = %d\n", x, y);
} // x 和 y 在这里被销毁

注意： auto 关键字很少被显式使用，因为它是局部变量的默认行为。

b) 全局变量的默认

在所有函数外部声明的变量,称为全局变量，如果没有指定存储类，默认是 extern（外部的）。extern 变量存储在静态存储区，它的生命周期贯穿整个程序，作用域是整个文件（除非被 static 修饰）。

示例代码：

#include <stdio.h>
// file1.c
// 以下两个声明是等价的
int global_var = 1; // 默认是 extern
extern int another_global = 2;
void print_globals() {
    printf("global_var = %d\n", global_var);
}

编译器的默认行为

编译器在处理代码时,也有一系列默认行为。

a) 整数提升

当 char、short 或 enum 类型的整数参与运算时，它们会被默认提升为 int 或 unsigned int 类型（取决于 int 是否能表示该类型的所有值）。

示例代码：

#include <stdio.h>
int main() {
    char a = 10;
    char b = 20;
    char c = a + b; // 1. a 和 b 被提升为 int
                    // 2. 在 int 范围内进行 10 + 20 = 30
                    // 3. 结果 30 再被截断为 char 并存入 c
    printf("c = %d\n", c); // 输出 30
    return 0;
}

这个默认行为确保了小整数类型在运算时不会意外溢出,但有时也会导致意想不到的结果。

b) 结构体成员对齐

为了提高内存访问效率,编译器会默认对齐结构体的成员，这意味着结构体中成员的地址可能会被填充一些字节，以确保每个成员都从其“自然边界”开始。

示例代码 (32位系统):

struct my_struct {
    char c;     // 1 byte
    int i;      // 4 bytes
}; // 默认对齐下，sizeof(struct my_struct) 是 8，而不是 5
struct packed_struct {
    char c;
    int i;
} __attribute__((packed)); // 使用 __attribute__((packed)) 可以取消默认对齐
// sizeof(struct packed_struct) 是 5

默认行为： sizeof(struct my_struct) 通常是 8。 取消默认： 通过 #pragma pack 或编译器特定属性（如 __attribute__((packed))）可以覆盖这个默认行为。

总结表格

理解这些默认行为是编写健壮、高效 C 代码的基础，它们能帮助你预测代码的运行结果，并避免许多常见的陷阱。