C++ 基础常见面试题总结（上）

源代码(.cpp/.h) → 预处理(.i) → 编译(.s) → 汇编(.o) → 链接 → 可执行文件

# 可以用 g++ 分步查看：
g++ -E main.cpp -o main.i    # 预处理
g++ -S main.i -o main.s      # 编译
g++ -c main.s -o main.o      # 汇编
g++ main.o -o main            # 链接

// 1. 单行注释
int a = 10; // 行尾注释

/* 2. 多行注释（块注释） */
/*
 * 这是
 * 多行注释
 */

/**
 * 3. Doxygen 文档注释（用于生成 API 文档）
 * @brief 计算两数之和
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数之和
 */
int Add(int a, int b) { return a + b; }

// 声明（不分配内存）
extern int globalVar;           // 变量声明
void Foo(int x);                // 函数声明
class MyClass;                  // 前向声明

// 定义（分配内存 / 提供实现）
int globalVar = 42;             // 变量定义
void Foo(int x) { /*...*/ }    // 函数定义
class MyClass { /*...*/ };      // 类定义

struct A {
    int x;   // 默认 public
};

class B {
    int x;   // 默认 private
};

struct C : A {};  // 默认 public 继承
class D : A {};   // 默认 private 继承

int i = 5;
int a = i++;   // a = 5, i = 6（先取值，后自增）
int b = ++i;   // b = 7, i = 7（先自增，后取值）

// 对于自定义类型（如迭代器），前置更高效
for (auto it = vec.begin(); it != vec.end(); ++it) {  // 推荐 ++it
    // ...
}

// 基本类型（64 位系统常见值）
sizeof(char)        // 1
sizeof(short)       // 2
sizeof(int)         // 4
sizeof(long)        // 4 或 8（平台相关）
sizeof(long long)   // 8
sizeof(float)       // 4
sizeof(double)      // 8
sizeof(bool)        // 1
sizeof(void*)       // 8（64 位）/ 4（32 位）

// 数组
int arr[10];
sizeof(arr)         // 40（10 * 4）
sizeof(arr) / sizeof(arr[0])  // 10（元素个数）

// ⚠️ 数组退化为指针后
void Foo(int arr[]) {
    sizeof(arr);    // 8（指针大小，不是数组大小！）
}

// typedef（传统方式）
typedef int Int32;
typedef void (*FuncPtr)(int, int);   // 函数指针别名（语法复杂）
typedef std::vector<int> IntVec;

// using（C++11，推荐）
using Int32 = int;
using FuncPtr = void (*)(int, int);  // 更直观
using IntVec = std::vector<int>;

// using 可以用于模板别名，typedef 不行！
template <typename T>
using Vec = std::vector<T>;          // ✅ using 支持

Vec<int> v;                          // std::vector<int>

#define PI 3.14159          // 宏：无类型，全局替换
const double PI = 3.14159;  // 编译期常量，有类型
constexpr double PI = 3.14159;  // 编译期确定值，有类型

// 宏的陷阱
#define SQUARE(x) x * x
int a = SQUARE(3 + 1);     // 展开为 3 + 1 * 3 + 1 = 7（不是 16！）

// 正确做法
#define SQUARE(x) ((x) * (x))  // 加括号
// 更好的做法：使用 constexpr 函数
constexpr int Square(int x) { return x * x; }

char/short → int → unsigned int → long → unsigned long → long long → float → double → long double

int a = 3;
double b = 2.5;
auto c = a + b;   // a 隐式转为 double，c 是 double 类型

// ⚠️ 风险1：有符号和无符号混用
int x = -1;
unsigned int y = 1;
if (x < y) {
    // 这个分支不会执行！x 被转为 unsigned int，变成一个很大的正数
}

// ⚠️ 风险2：精度丢失
int big = 2000000000;
float f = big;   // float 精度不够，可能丢失数据

// ⚠️ 风险3：缩窄转换
double d = 3.14;
int i = d;       // 小数部分被截断，i = 3

double a = 0.1 + 0.2;
std::cout << (a == 0.3) << "\n";  // 输出 0（false！）
std::cout << std::setprecision(20) << a << "\n";  // 0.30000000000000004

// 方法1：使用 epsilon 比较
#include <cmath>
bool AlmostEqual(double a, double b, double epsilon = 1e-9) {
    return std::fabs(a - b) < epsilon;
}

// 方法2：整数运算（如金额用"分"而非"元"）
int price_cents = 199;  // 1.99 元

// 方法3：使用第三方高精度库（如 Boost.Multiprecision）

auto i = 42;              // int
auto d = 3.14;            // double
auto s = std::string("hello");  // std::string
auto p = std::make_unique<int>(10);  // std::unique_ptr<int>

// 与范围 for 循环配合
std::vector<int> vec = {1, 2, 3};
for (auto& v : vec) { v *= 2; }         // 引用，可修改
for (const auto& v : vec) { /*...*/ }   // 常量引用，不可修改（推荐）

// 函数返回类型推导（C++14）
auto Add(int a, int b) { return a + b; }

int x = 10;
decltype(x) y = 20;      // y 的类型是 int
decltype(x + 0.5) z;     // z 的类型是 double

// 与 auto 的区别
const int& rx = x;
auto a = rx;              // a 是 int（丢掉了 const 和 &）
decltype(rx) b = x;       // b 是 const int&（完整保留类型）

// 常用场景：获取返回类型
template <typename T, typename U>
auto Add(T t, U u) -> decltype(t + u) {
    return t + u;
}

int g = 100;              // 全局变量

static int sg = 200;      // 静态全局变量（仅当前文件可见）

void Foo() {
    int local = 10;        // 局部变量，函数结束后销毁
    static int count = 0;  // 静态局部变量，只初始化一次
    ++count;
    std::cout << count << "\n";  // 每次调用递增
}

┌──────────────────┐ 高地址
│     内核空间       │
├──────────────────┤
│       栈 (Stack)  │ ↓ 向低地址增长
│                  │ 局部变量、函数参数、返回地址
├──────────────────┤
│       堆 (Heap)   │ ↑ 向高地址增长
│                  │ new/malloc 动态分配
├──────────────────┤
│   全局/静态数据区   │ 全局变量、静态变量
│  (.data / .bss)  │ .data: 已初始化  .bss: 未初始化
├──────────────────┤
│   常量区 (.rodata)│ 字符串字面量、const 全局变量
├──────────────────┤
│   代码区 (.text)  │ 编译后的机器指令
└──────────────────┘ 低地址

void Example() {
    int stackVar = 10;                   // 栈上分配
    int* heapVar = new int(20);          // 堆上分配
    auto smartPtr = std::make_unique<int>(30); // 堆上分配（智能指针管理）

    delete heapVar;                      // 必须手动释放
    // smartPtr 离开作用域自动释放
}

// file1.cpp
int globalVar = 42;           // 定义
void Foo() { /*...*/ }        // 定义

// file2.cpp
extern int globalVar;          // 声明（不分配内存）
extern void Foo();             // 声明（函数可省略 extern）

void Bar() {
    std::cout << globalVar;    // 使用 file1 中定义的变量
    Foo();
}

const int a = 10;           // ✅ 编译期确定
const int b = GetValue();   // ✅ 运行时确定也可以

constexpr int c = 10;       // ✅ 编译期确定
// constexpr int d = GetValue();  // ❌ 除非 GetValue 也是 constexpr

constexpr int Square(int x) { return x * x; }
constexpr int val = Square(5);   // 编译期计算，val = 25
int arr[Square(3)];              // ✅ 可以用于数组大小

void ByValue(int x)         { x = 100; }         // 不影响原值
void ByRef(int& x)          { x = 100; }         // 修改原值
void ByConstRef(const int& x) { /* 只读 */ }     // 不拷贝，不修改
void ByPtr(int* x)          { if (x) *x = 100; } // 需要判空

int a = 1;
ByValue(a);    // a 仍为 1
ByRef(a);      // a 变为 100
ByPtr(&a);     // a 变为 100

int Add(int a, int b)          { return a + b; }
double Add(double a, double b) { return a + b; }
int Add(int a, int b, int c)   { return a + b + c; }

Add(1, 2);       // 调用第一个
Add(1.0, 2.0);   // 调用第二个
Add(1, 2, 3);    // 调用第三个

// ❌ 错误：仅返回类型不同，不构成重载
int Foo(int x);
double Foo(int x);  // 编译错误

// ✅ const 重载（成员函数）
class MyClass {
    void Print() { std::cout << "non-const\n"; }
    void Print() const { std::cout << "const\n"; }  // ✅ 可以重载
};

// 默认参数从右往左
void Foo(int a, int b = 10, int c = 20);  // ✅
// void Foo(int a = 1, int b, int c);     // ❌ 错误

// 声明和定义分离时，默认参数只能在声明中写
// header.h
void Foo(int a, int b = 10);

// source.cpp
void Foo(int a, int b) {  // 这里不能再写默认值
    // ...
}

inline int Max(int a, int b) {
    return (a > b) ? a : b;
}

// 调用 Max(3, 5) 会被编译器替换为 (3 > 5) ? 3 : 5

// 函数指针
int Add(int a, int b) { return a + b; }
int (*funcPtr)(int, int) = Add;     // 传统语法
auto funcPtr2 = Add;                // 或用 auto
int result = funcPtr(3, 5);         // 调用

// std::function（C++11，更通用）
#include <functional>
std::function<int(int, int)> func;

func = Add;                                         // 普通函数
func = [](int a, int b) { return a + b; };          // Lambda
func = std::bind(Add, std::placeholders::_1, 10);   // 绑定参数

int r = func(3, 5);

// && 短路：左边为 false，不执行右边
if (ptr != nullptr && ptr->IsValid()) {
    // 如果 ptr 为空，不会执行 ptr->IsValid()，避免崩溃
}

// || 短路：左边为 true，不执行右边
if (IsDefault() || LoadConfig()) {
    // 如果 IsDefault() 为 true，不会执行 LoadConfig()
}

// 常见应用

// 1. 判断奇偶
bool isOdd = (n & 1);

// 2. 交换两个数
a ^= b; b ^= a; a ^= b;

// 3. 乘除 2 的幂
int x = n << 1;   // n * 2
int y = n >> 1;   // n / 2

// 4. 标志位操作
const int READ  = 1 << 0;  // 0001
const int WRITE = 1 << 1;  // 0010
const int EXEC  = 1 << 2;  // 0100

int perm = READ | WRITE;       // 设置权限
bool canRead = perm & READ;    // 检查权限
perm &= ~WRITE;                // 清除权限
perm ^= EXEC;                  // 切换权限