C++ 基础知识点详解（初级）

void modifyByValue(int x) {
    x = 100; // 只修改副本，不影响原始变量
}

int main() {
    int a = 10;
    modifyByValue(a);
    // a 仍为 10
}

void modifyByReference(int& x) {
    x = 100; // 直接修改原始变量
}

int main() {
    int a = 10;
    modifyByReference(a);
    // a 变为 100
}

// 大对象只读：用 const 引用，零拷贝 + 保护原始值
void printVector(const std::vector<int>& vec) {
    for (int v : vec) {
        std::cout << v << " ";
    }
}

// C++ 继承与虚函数多态
class Animal {
public:
    virtual void speak() { std::cout << "..." << std::endl; }
};

class Dog : public Animal {
public:
    void speak() override { std::cout << "Woof!" << std::endl; }
};

// C++ 支持重载
void print(int x) { std::cout << x << std::endl; }
void print(double x) { std::cout << x << std::endl; }
void print(const std::string& x) { std::cout << x << std::endl; }

// C 语言必须用不同函数名：print_int(), print_double(), print_string()

// C++ 模板 —— 编译期泛型
template<typename T>
T max(T a, T b) {
    return a > b ? a : b;
}

// C 风格
int* p = (int*)malloc(sizeof(int) * 10);
free(p);

// C++ 风格
int* p = new int[10];
delete[] p;

// C++ 智能指针（推荐）
auto p = std::make_unique<int[]>(10); // 自动释放，无需手动 delete

void print(int x)    { std::cout << "int: " << x << std::endl; }
void print(double x) { std::cout << "double: " << x << std::endl; }
void print(int x, int y) { std::cout << x << ", " << y << std::endl; }

print(1);        // 调用 print(int)
print(3.14);     // 调用 print(double)
print(1, 2);     // 调用 print(int, int)

int  func(int x)  { return x; }
// double func(int x) { return x; }   ❌ 仅返回类型不同，无法重载

class Base {
public:
    virtual void func(int x) { /* ... */ }   // 基类虚函数
};

class Derived : public Base {
public:
    void func(int x) override { /* ... */ }  // ✅ 重写（override）：同名同参，覆盖基类虚函数
    void func(double x) { /* ... */ }        // ✅ 重载（overload）：同名不同参，新的函数
};

int a = 10;
std::cout << sizeof(a) << std::endl;       // 4（int 的大小）
std::cout << sizeof(int) << std::endl;      // 4（直接对类型求值）
std::cout << sizeof(double) << std::endl;   // 8
std::cout << sizeof(char) << std::endl;     // 1

// 数组：返回整个数组的字节数
char str[] = "hello";
std::cout << sizeof(str) << std::endl;      // 6（"hello" + '\0'）

// 指针：只返回指针本身的大小
char* ptr = "hello";
std::cout << sizeof(ptr) << std::endl;      // 8（64 位系统指针大小）
std::cout << sizeof(char*) << std::endl;    // 8

sizeof(a + b);   // 不会真正执行 a + b，只是计算结果的类型大小
sizeof(int());   // 不会调用构造函数

#include <cstring>

char str[] = "hello";
std::cout << strlen(str) << std::endl;      // 5（不包含 '\0'）

char str2[] = "hello\0world";
std::cout << strlen(str2) << std::endl;     // 5（遇到第一个 '\0' 就停止）
std::cout << sizeof(str2) << std::endl;     // 11（整个数组大小）

char str[] = "hello world";

std::cout << sizeof(str) << std::endl;   // 12（11 个字符 + '\0'）
std::cout << strlen(str) << std::endl;   // 11（不包含 '\0'）

char* ptr = "hello world";

std::cout << sizeof(ptr) << std::endl;   // 8（指针大小）
std::cout << strlen(ptr) << std::endl;   // 11（正常遍历到 '\0'）

std::cout << sizeof("hello world") << std::endl;  // 12（字符串字面量包含 '\0'）
std::cout << strlen("hello world") << std::endl;   // 11

// file1.cpp —— 定义全局变量
int globalVar = 100;

// file2.cpp —— 声明引用（不重新定义）
extern int globalVar;  // 告诉编译器 globalVar 在别处定义
void print() {
    std::cout << globalVar << std::endl;  // 可以正常使用
}

// ❌ 错误：多个文件定义同名全局变量 → 链接错误（重复定义）
// file1.cpp: int x = 1;
// file2.cpp: int x = 2;

// ✅ 正确：只在一个文件定义，其他文件 extern 声明
// file1.cpp: int x = 1;
// file2.cpp: extern int x;

// file1.cpp
void doSomething() { std::cout << "Hello" << std::endl; }

// file2.cpp
extern void doSomething();  // 声明
doSomething();              // 调用

C 编译:    add(int, int) →  _add
C++ 编译:  add(int, int) →  _Z3addii
C++ 编译:  add(int, char) →  _Z3addic   （重载，所以必须区分）

// math_lib.c（C 语言库）
int add(int a, int b) { return a + b; }

// main.cpp（C++ 程序）
extern "C" {
    int add(int a, int b);  // 按 C 规则链接，不做名称修饰
}

int main() {
    std::cout << add(1, 2) << std::endl;  // 可以正常调用 C 函数
}

extern "C" {
    #include "c_library.h"  // 整个头文件的函数都按 C 规则链接
}

#ifdef __cplusplus
extern "C" {
#endif

void my_c_function();
int another_c_function(int x);

#ifdef __cplusplus
}
#endif

int arr[5] = {1, 2, 3, 4, 5};
// 栈上分配 5 * sizeof(int) = 20 字节的连续空间
// arr 代表这块内存的起始地址

int* ptr;            // 栈上只分配 8 字节（存储地址），尚未指向有效内存
ptr = new int[5];    // 堆上分配 20 字节，ptr 指向堆内存首地址
// 或
ptr = (int*)malloc(5 * sizeof(int));

数组的内存布局：
  栈上: [1][2][3][4][5]   ← arr 指向这里，连续分配，大小固定

指针的内存布局：
  栈上: [ptr: 0x7fff...]  ← 指针变量本身只存地址
  堆上: [ ? ][ ? ][ ? ]   ← ptr 指向这里，动态分配，大小灵活

int arr[5];           // ✅ 大小固定为 5
int n = 10;
int arr2[n];          // ❌ C++ 中不允许变长数组（VLA，这是 C99 特性，非标准 C++）

// C++ 中动态大小只能用指针 + new
int* arr3 = new int[n];  // ✅ 堆上动态分配
delete[] arr3;            // 需要手动释放

int n;
std::cin >> n;       // 运行时确定大小
int* arr = new int[n];  // ✅ 根据运行时输入分配
delete[] arr;

int arr[5] = {1, 2, 3, 4, 5};
arr[0] = "hello";    // ❌ 编译错误：不能把字符串赋给 int 类型

int value = 42;
int* iptr = &value;
void* vptr = iptr;   // ✅ 任何类型指针都可以隐式转为 void*
char* cptr = (char*)iptr;  // ⚠️ 强制类型转换，类型不匹配，可能导致未定义行为

int arr[5] = {1, 2, 3, 4, 5};
// arr++;            ❌ 编译错误：数组名是常量指针，不能进行算术运算
// arr--;            ❌ 同上
// arr = other_arr;  ❌ 数组名不能被赋值
std::cout << arr[0] << std::endl;  // ✅ 但可以通过下标访问

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr;  // ptr 指向数组首元素
std::cout << *ptr << std::endl;   // 输出 1
ptr++;                              // ✅ 指针递增，指向下一个元素
std::cout << *ptr << std::endl;   // 输出 2
ptr += 2;                           // ✅ 跳过两个元素
std::cout << *ptr << std::endl;   // 输出 4

int arr[5] = {1, 2, 3, 4, 5};

// 在表达式中，数组名退化为指针
int* ptr = arr;     // ✅ arr 退化为 int*，指向 arr[0]
std::cout << *arr;  // ✅ arr 退化为 int*，解引用得到 arr[0] 即 1

int arr[5] = {1, 2, 3, 4, 5};

// 例外 1：sizeof 运算符
std::cout << sizeof(arr);     // 输出 20（整个数组的字节数），不是 8（指针大小）
std::cout << sizeof(*arr);    // 输出 4（单个元素的字节数）

// 例外 2：取地址运算符 &
std::cout << sizeof(&arr);    // 输出 8（指针大小，这里是指向整个数组的指针 int(*)[5]）

void func(int arr[]) {
    std::cout << sizeof(arr);  // 输出 8（指针大小），不是 20！
    // 在函数参数中，int arr[] 等价于 int* arr，数组名已经退化为指针
}

int arr[10] = {0};
int* ptr = arr;

std::cout << sizeof(arr) << std::endl;   // 40（10 * sizeof(int)）
std::cout << sizeof(ptr) << std::endl;   // 8（指针大小，64 位系统）
std::cout << sizeof(*ptr) << std::endl;  // 4（int 大小）

// 替代固定大小数组 → std::array（栈上分配，编译期确定大小）
#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};
std::cout << arr.size();      // 5，有大小信息
std::cout << arr.at(10);      // 越界抛出异常，比 arr[10]（未定义行为）安全

// 替代动态数组 → std::vector（堆上分配，动态大小）
#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
vec.push_back(6);             // 动态扩容
std::cout << vec.size();      // 6，自动管理大小
// 自动内存管理，无需手动 new/delete

struct S {
    int x;      // 默认 public
};
S s;
s.x = 10;       // ✅ 可直接访问

class C {
    int x;      // 默认 private
};
C c;
// c.x = 10;    ❌ 编译错误，private 不能外部访问

struct Base { virtual void f() {} };   // struct 也能多态
class Derived : public Base { void f() override {} };

struct S {
    char a;   // 1 字节
    int  b;   // 4 字节
    char c;   // 1 字节
};
// sizeof(S) = 12（各成员独立 + padding）

union U {
    char a;   // 1 字节
    int  b;   // 4 字节
    char c;   // 1 字节
};
// sizeof(U) = 4（只取最大成员 int 的大小）

// 优化前：普通 struct，所有字段同时占内存
struct Message {
    int type;          // 1=整数 2=浮点 3=字符串指针
    int intValue;      // 占用
    double doubleValue;// 占用
    char* strValue;    // 占用
};
// sizeof(Message) 很大

// 优化后：union 让互斥字段共享内存
struct Message {
    int type;
    union {             // 三个 value 共享一块内存，节省空间
        int intValue;
        double doubleValue;
        char* strValue;
    } data;
};
// 只占 type + max(int, double, char*) 的大小

#include <variant>
std::variant<int, double, std::string> v;  // 类型安全，记住当前类型
v = 42;
int i = std::get<int>(v);   // 安全访问

#include <cstdlib>

// new：类型安全，自动算大小，自动调构造函数
int* p1 = new int(10);              // 分配 + 初始化为 10
MyClass* p2 = new MyClass();        // 自动调用构造函数

// malloc：返回 void*，手动算大小，不调构造函数
int* p3 = (int*)malloc(sizeof(int));  // 需强转 + 手动 sizeof
*p3 = 10;
MyClass* p4 = (MyClass*)malloc(sizeof(MyClass));  // 不调构造函数，成员未初始化！

// delete：自动调用析构函数
MyClass* p = new MyClass();
delete p;          // 先调 ~MyClass()，再释放内存

// free：不调析构函数，可能泄漏资源
MyClass* p2 = (MyClass*)malloc(sizeof(MyClass));
free(p2);          // 只释放内存，不调析构（若有资源会泄漏！）

// 数组
int* arr = new int[10];
delete[] arr;      // 必须用 delete[] 释放数组

new    = malloc + 构造函数
delete = 析构函数 + free

new/delete 是 C++ 对象生命周期管理的一部分，会调用构造/析构；
malloc/free 只是纯粹的内存分配/释放，不涉及对象语义。

class Person {
public:
    Person(int age) {
        this->age = age;   // this 指向当前正在构造的对象
    }
    int age;
};

class Person {
    int age;
public:
    void setAge(int age) {
        this->age = age;   // 左边是成员变量，右边是形参
    }
};

class Counter {
    int count = 0;
public:
    Counter& add(int n) {
        count += n;
        return *this;   // 返回当前对象
    }
};

Counter c;
c.add(1).add(2).add(3);   // 链式调用

void func() {
    // 实际上编译器会隐式加上 this->
    // this->member = ...;
}

#include <cstring>

char str[] = "hello world";

// 把 "hello" 向后移动 6 字节，但 src 和 dest 重叠了
memcpy(str + 6, str, 5);   // ❌ 未定义行为，结果可能错误
memmove(str + 6, str, 5);  // ✅ 正确处理重叠

// memmove 的"安全"策略：根据重叠方向选择拷贝顺序
// 如果 dest < src（目标在前），从前往后拷贝
// 如果 dest > src（目标在后），从后往前拷贝

#include <cstring>

// strcpy：拷贝字符串，遇 \0 停止，会带上 \0
char src[] = "hello";
char dest[10];
strcpy(dest, src);       // dest = "hello\0"

// memcpy：按字节拷贝，需要指定长度
char src2[] = "hello";
char dest2[10];
memcpy(dest2, src2, 5);  // 只拷贝 5 字节，不含 \0
// dest2 是 "hello" 但没结束符，需要自己处理
memcpy(dest2, src2, 6);  // 拷贝 6 字节含 \0，等价 strcpy

// strcpy 的安全隐患：源字符串太长会溢出
char small[3];
char* long_str = "this is a very long string";
// strcpy(small, long_str);   ❌ 缓冲区溢出！

// 现代替代
std::string s = "hello";   // 自动管理内存，安全

void func() {
    int a = 10;        // 栈上分配
    int arr[100];      // 栈上分配连续空间
    // 函数返回时自动释放，无需手动管理
}

int* p = new int;          // 堆上分配
int* arr = new int[100];   // 堆上分配数组
// ... 使用 ...
delete p;                  // 手动释放
delete[] arr;

// 1. 局部大数组 —— 超出栈容量（默认约 8MB）
void func() {
    int big[10 * 1024 * 1024];   // 约 40MB，远超默认栈大小 → 栈溢出
}

// 2. 无限递归 —— 每次调用都压栈，最终耗尽
void recurse() {
    recurse();   // 没有终止条件，栈帧无限增长 → 栈溢出
}

// 3. 深递归 —— 递归层数过深
int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);   // 层数深时也可能栈溢出
}

// 大数组放堆上
std::vector<int> big(10 * 1024 * 1024);   // 堆上分配，不受栈大小限制

void func(int x)     { std::cout << "int" << std::endl; }
void func(char* p)   { std::cout << "pointer" << std::endl; }

func(NULL);    // 可能调用 func(int)，而不是 func(char*)，不符合预期
func(nullptr); // 明确调用 func(char*)，类型安全

// nullptr 有专属类型 std::nullptr_t，能隐式转换为任意指针类型
int* p1 = nullptr;          // ✅
char* p2 = nullptr;         // ✅
std::nullptr_t n = nullptr; // 专属类型

// NULL 是整数 0，模板推导时会被当作 int
template<typename T>
void f(T t) { /* ... */ }
f(NULL);     // T 推导为 int
f(nullptr);  // T 推导为 std::nullptr_t

#include <a.h>   →  ① 系统 include 目录（如 /usr/include）→ ② 编译器 -I 指定的目录
#include "a.h"   →  ① 当前源文件所在目录 → ② 系统 include 目录 → ③ 编译器 -I 指定的目录

#include <iostream>    // 标准库头文件，用尖括号
#include <vector>      // 系统目录查找
#include "my_header.h" // 项目自定义头文件，用双引号（先查当前目录）

// main.cpp
#include "util.cpp"   // ❌ 把整个源文件展开进来，重复定义

// util.cpp
int add(int a, int b) { return a + b; }

编译命令：g++ main.cpp util.cpp -o app
结果：add 函数被定义两次 → 链接错误（multiple definition）

// util.h —— 只放声明
int add(int a, int b);

// util.cpp —— 放定义
#include "util.h"
int add(int a, int b) { return a + b; }

// main.cpp —— 包含头文件
#include "util.h"
int main() {
    return add(1, 2);
}

// 两个库都定义了 print，直接放全局会冲突
namespace LibA {
    void print() { std::cout << "A" << std::endl; }
}
namespace LibB {
    void print() { std::cout << "B" << std::endl; }
}

LibA::print();   // ✅ 通过命名空间限定，互不冲突
LibB::print();

namespace MySpace {
    int value = 10;
    void func() { /* ... */ }
    class MyClass { /* ... */ };
}

using std::cout;      // 只引入 cout
cout << "hi";         // 可直接用

namespace A { namespace B { int x = 1; } }
namespace AB = A::B;      // 别名
std::cout << AB::x << std::endl;

// c_lib.h —— C 库头文件
#ifdef __cplusplus
extern "C" {
#endif

int add(int a, int b);
void say_hello();

#ifdef __cplusplus
}
#endif

# 1. 用 C 编译器编译 C 源码为目标文件
gcc -c c_lib.c -o c_lib.o

# 2. 用 C++ 编译器编译 C++ 源码，并链接 C 目标文件
g++ main.cpp c_lib.o -o app

// main.cpp
#include "c_lib.h"
int main() {
    return add(1, 2);   // 直接调用 C 函数
}

int a = 10;
int* p = &a;     // 指针：存 a 的地址
int& r = a;      // 引用：a 的别名

*p = 20;         // 通过指针修改，需要解引用
r = 30;          // 通过引用修改，无需解引用

p = nullptr;     // ✅ 指针可为空、可改指向
// r = b;        // ❌ 引用一旦绑定，不能再绑定其他对象

int& r;          // ❌ 编译错误：引用必须初始化
int* p;          // ⚠️ 指针可不初始化，但会成野指针（危险）

void swap(int& x, int& y) {   // 引用传参，直接修改实参
    int t = x; x = y; y = t;
}

class MyClass {
public:
    int* data;
    MyClass()  { data = new int[100]; }   // 构造：申请资源
    ~MyClass() { delete[] data; }          // 析构：释放资源
};

MyClass* p = new MyClass();   // 分配内存 + 调构造函数
delete p;                     // 调析构函数 + 释放内存
// 若漏掉 delete，析构不执行，data 指向的内存泄漏

int* a = new int;        // new 配 delete
delete a;

int* b = new int[10];    // new[] 必须配 delete[]
delete[] b;
// delete b;  ❌ 错误：数组不用 delete[] 是未定义行为

int* c = (int*)malloc(sizeof(int));
// delete c;  ❌ 错误：malloc 分配的内存不能用 delete 释放
free(c);                  // ✅ malloc 配 free

#include <iostream>

int main() {
    // 1. 指针数组：数组里存了 5 个 int* 指针
    int a = 1, b = 2, c = 3, d = 4, e = 5;
    int* ptrArr[5] = { &a, &b, &c, &d, &e };   // 元素是指针
    for (int i = 0; i < 5; ++i) {
        std::cout << *ptrArr[i] << " ";        // 先取下标拿到指针，再解引用
    }
    // 输出：1 2 3 4 5

    // 2. 数组指针：一个指针指向整个数组
    int arr[5] = { 1, 2, 3, 4, 5 };
    int (*p)[5] = &arr;   // p 指向 arr 这个「长度为 5 的 int 数组」

    std::cout << (*p)[0] << std::endl;   // 先解引用拿到数组，再下标访问 → 1
    std::cout << (*p)[3] << std::endl;   // → 4
    return 0;
}

#include <iostream>

void print2D(int (*matrix)[3], int rows) {   // 数组指针：指向「每行 3 个 int」
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    int grid[2][3] = { {1, 2, 3}, {4, 5, 6} };

    // 数组名 grid 退化为指向「int[3]」的数组指针，正好匹配参数
    print2D(grid, 2);

    // 指针数组：每行长度可以不同（锯齿数组）
    int r0[] = { 1, 2, 3 };
    int r1[] = { 4, 5 };
    int* jagged[2] = { r0, r1 };   // 两行长度不同，指针数组天然支持
    return 0;
}

#include <iostream>

struct Flags {
    unsigned int read  : 1;   // 占 1 位
    unsigned int write : 1;   // 占 1 位
    unsigned int exec  : 1;   // 占 1 位
    unsigned int mode  : 2;   // 占 2 位，可表示 0~3
};
// 四个字段共占 5 位，实际按 unsigned int 对齐，sizeof(Flags) 通常为 4

#include <iostream>

// 典型：权限标志位
struct Perm {
    unsigned int read  : 1;
    unsigned int write : 1;
    unsigned int exec  : 1;
};

int main() {
    Perm p{};
    p.read = 1;
    p.exec = 1;
    std::cout << "read=" << p.read
              << ", write=" << p.write
              << ", exec=" << p.exec << std::endl;   // 1, 0, 1
    return 0;
}

// ❌ 不能取地址
struct F { unsigned int a : 1; };
F f{};
// auto* p = &f.a;   // 编译错误：不能对位域取地址