c++高频总结二

发表于 2025/01/09 更新于 2025/01/09

作者 匆匆那年 41 分钟阅读

多态和继承在什么情况下使用

多态和继承是面向对象编程中两个核心概念，它们的使用场景和目的不同，但经常结合在一起使用。以下是两者的用途及适用场景：

继承的使用场景

继承主要用于表示“is-a”关系，即子类是父类的一种。通过继承，可以实现代码复用，并在子类中扩展或重写父类的功能。

适用场景

代码复用：

如果多个类具有相同的属性和行为，可以将这些共性抽取到父类中，子类继承父类以避免重复代码。

例如：

  
class Animal {
public:
    void eat() { std::cout << "Eating...\n"; }
};
     
class Dog : public Animal {
public:
    void bark() { std::cout << "Barking...\n"; }
};

体现层次结构：
- 当需要表达自然的层次关系时，例如“猫是动物”、“狗是动物”，可以使用继承。
- 继承体现了类之间的从属关系，帮助程序更加贴近问题领域。

行为的扩展或重写：

如果需要在子类中添加新的功能，或者对父类的行为进行调整，可以通过继承实现。

例如：

  
class Animal {
public:
    virtual void makeSound() { std::cout << "Some generic sound\n"; }
};
     
class Dog : public Animal {
public:
    void makeSound() override { std::cout << "Woof\n"; }
};

多态的使用场景

多态的核心是通过动态绑定实现行为的灵活性。使用多态可以让程序在运行时根据具体对象的类型选择相应的方法，而无需修改调用代码。

适用场景

统一接口，灵活扩展：

当需要对不同类型的对象进行操作，而不关心其具体类型时，可以使用多态来提供统一的接口。

例如，使用基类指针或引用来调用派生类的重写方法：

  
class Animal {
public:
    virtual void makeSound() = 0; // 纯虚函数
};
     
class Dog : public Animal {
public:
    void makeSound() override { std::cout << "Woof\n"; }
};
     
class Cat : public Animal {
public:
    void makeSound() override { std::cout << "Meow\n"; }
};
     
void animalSound(Animal* animal) {
    animal->makeSound();
}
     
int main() {
    Dog dog;
    Cat cat;
    animalSound(&dog); // 输出：Woof
    animalSound(&cat); // 输出：Meow
}

运行时行为的改变：
- 如果程序需要在运行时根据对象的实际类型执行不同的逻辑，多态是最佳选择。
- 例如，处理形状（圆形、矩形、三角形）时，通过多态调用统一的draw()方法。
解耦代码：
- 多态可以降低代码的耦合度，使得程序更容易扩展。例如，新增一种类型的对象时，只需创建一个新类继承基类，而无需修改已有代码。

继承与多态结合的使用

在实际开发中，继承和多态经常结合使用。典型场景包括：

设计抽象接口：使用继承定义一个基类接口，通过多态实现具体的子类行为。
插件式设计：系统提供一个抽象接口，用户可以通过继承基类扩展功能，而无需修改系统代码。

示例：

  
class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing Circle\n"; }
};

class Rectangle : public Shape {
public:
    void draw() override { std::cout << "Drawing Rectangle\n"; }
};

void renderShape(Shape* shape) {
    shape->draw(); // 多态调用
}

避免滥用的场景

继承：
- 如果两个类之间不存在真正的“is-a”关系，避免使用继承，可以考虑组合（Composition）或接口（Interface）。
- 例如，Car和Driver之间不应该是继承关系，而应该通过成员变量表示“has-a”关系。
多态：
- 不需要动态行为时，避免使用多态（如不必要的虚函数）。
- 如果类的层次结构太复杂，可能需要重新设计，避免难以维护。

总结：

继承适用于代码复用和层次关系表达。
多态适用于行为的灵活性和解耦。
两者结合，可以实现扩展性强、维护性好的系统设计。

除了多态和继承还有什么面向对象方法

面向对象编程（OOP）不仅包括多态和继承，还涉及许多其他关键概念和方法，用于实现可扩展性、模块化和代码复用性。以下是一些主要的面向对象方法及其适用场景：

1. 封装（Encapsulation）

封装是将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏对象的内部实现细节，仅通过公开的接口访问对象。

核心思想

隐藏实现细节：防止外部直接访问对象的内部状态，增强安全性和稳定性。
控制访问权限：通过public、protected、private等修饰符限制访问范围。

适用场景

当需要对数据进行访问保护时。
对于类的属性需要提供一致的访问接口。

示例

  
class Account {
private:
    double balance; // 私有数据成员

public:
    Account(double initialBalance) : balance(initialBalance) {}

    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) balance -= amount;
    }

    double getBalance() const {
        return balance;
    }
};

2. 组合（Composition）

组合是将对象作为类的成员变量，以实现“has-a”关系。与继承相比，组合更适合表达组件式关系。

核心思想

一个类可以包含其他类的对象，通过组合实现复杂对象的构建。
强调“有一个”而不是“是一个”。

适用场景

当类的行为可以通过包含的对象来实现。
当需要避免继承导致的高耦合时。

示例

  
class Engine {
public:
    void start() { std::cout << "Engine started\n"; }
};

class Car {
private:
    Engine engine; // 组合

public:
    void start() {
        engine.start(); // 使用组合对象的方法
        std::cout << "Car started\n";
    }
};

3. 抽象（Abstraction）

抽象是将复杂的系统隐藏在一个高层的简单接口之后，仅暴露关键功能，而隐藏实现细节。

核心思想

提供通用接口，屏蔽复杂性。
使用抽象类或接口定义行为，具体实现交由子类完成。

适用场景

当需要定义一组通用操作，而具体实现因对象而异时。
在大型系统中需要分离接口和实现。

示例

  
class Shape {
public:
    virtual void draw() = 0; // 抽象方法
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing Circle\n"; }
};

class Rectangle : public Shape {
public:
    void draw() override { std::cout << "Drawing Rectangle\n"; }
};

4. 接口（Interfaces）

接口是指定义一组方法的契约，不包含任何实现。C++中通过纯虚类实现接口。

核心思想

强制实现某些方法，定义行为的规范。
支持多重继承以实现多种行为。

适用场景

当类需要实现多个独立的功能时。
需要定义统一的行为规范，支持灵活扩展。

示例

  
class Printable {
public:
    virtual void print() const = 0; // 接口方法
};

class Document : public Printable {
public:
    void print() const override {
        std::cout << "Printing Document\n";
    }
};

5. 依赖注入（Dependency Injection）

依赖注入是一种设计模式，强调将类的依赖关系从内部创建转移到外部注入，从而减少耦合。

核心思想

类不自己创建依赖对象，而是通过构造函数或方法传递依赖。
提高代码的灵活性和可测试性。

适用场景

当类依赖于外部资源（例如数据库、服务）时。
需要替换依赖的实现（例如测试时使用模拟对象）。

示例

  
class Logger {
public:
    void log(const std::string& message) {
        std::cout << "Log: " << message << "\n";
    }
};

class Application {
private:
    Logger& logger; // 依赖注入

public:
    Application(Logger& loggerInstance) : logger(loggerInstance) {}

    void run() {
        logger.log("Application is running");
    }
};

int main() {
    Logger logger;
    Application app(logger); // 注入依赖
    app.run();
}

6. 消息传递（Message Passing）

对象通过方法调用互相通信，体现了对象之间的协作关系。

核心思想

对象通过发送消息（调用方法）请求其他对象的服务。
这种方法抽象了具体实现，专注于接口交互。

适用场景

当多个对象需要协作完成某一任务时。
需要降低模块间的耦合性。

7. 责任链模式（Chain of Responsibility）

通过对象链动态处理请求，每个对象可以处理请求或将其传递给下一个对象。

适用场景

请求的处理需要多个对象协作。
需要动态决定请求由哪个对象处理。

示例

  
class Handler {
public:
    virtual void handleRequest(int level) = 0;
};

class ConcreteHandler1 : public Handler {
public:
    void handleRequest(int level) override {
        if (level == 1)
            std::cout << "Handler1 processing request\n";
        else
            std::cout << "Handler1 passing request\n";
    }
};

8. 类的聚合（Aggregation）

类与类之间是弱关系，一个类可以引用另一个类，但生命周期相互独立。

适用场景

两个类需要协作，但不属于强耦合的“拥有”关系。

总结

除了多态和继承，面向对象编程还提供了多种方法和设计原则（如封装、组合、抽象、接口、依赖注入等）。这些方法可以根据具体需求灵活选择和组合，构建出具有高复用性和可维护性的程序。

C++内存分布。什么样的数据在栈区，什么样的在堆区

C++ 程序的内存主要分为以下几种区域，每个区域存储不同类型的数据：

1. 栈区（Stack Segment）

特点：
- 栈区的内存由编译器自动分配和释放。
- 存储在栈区的数据具有作用域，当超出作用域后，栈上的数据会被自动销毁。
- 栈区的内存管理效率高，但空间有限（通常几 MB 到几十 MB）。
存储内容：
1. 局部变量：
  - 函数内部声明的普通变量（不包括静态变量）。
  - 例如：
    1 2 3 void foo() { int x = 10; // x 存储在栈区 }
2. 函数参数：
  - 例如，按值传递的参数。
    1 void bar(int a) { /* a 存储在栈区 */ }
3. 返回地址：
  - 每次函数调用时，函数的返回地址和一些临时变量会保存在栈中。

2. 堆区（Heap Segment）

特点：
- 堆区的内存由程序员手动分配和释放（使用 new 和 delete 或 malloc 和 free）。
- 如果程序员未释放，可能导致内存泄漏。
- 堆的内存空间较大，但分配和释放需要更多时间。
存储内容：
1. 动态分配的对象或变量：
  - 使用 new分配的对象或变量。
    1 2 int* ptr = new int(10); // ptr 指向堆区 delete ptr; // 释放堆内存
2. 容器中的元素（可能存储在堆上）：
  - STL 容器（如 std::vector, std::map）的动态分配的元素通常存储在堆上。
    1 std::vector<int> v = {1, 2, 3}; // 元素动态存储在堆区

3. 数据区（静态区 / Global Segment）

特点：
- 数据区在程序加载时分配，并在程序结束时释放。
- 数据区内存分为以下两个子区域：
  1. 全局初始化区（DATA段）：存储已初始化的全局变量和静态变量。
  2. 全局未初始化区（BSS 段）：存储未初始化的全局变量和静态变量（初值为零）。

存储内容：

全局变量：

  
int globalVar = 10; // 存储在数据区（已初始化区）

静态变量：

  
void foo() {
    static int staticVar = 10; // 存储在数据区
}

字符串字面值：

字符串字面值存储在只读数据区。

  
const char* str = "Hello"; // "Hello" 存储在数据区

4. 代码区（Text Segment）

特点：
- 存储程序的机器指令。
- 通常是只读的，防止程序意外修改指令。

存储内容：

编译后的函数代码。

  
void foo() {
    // foo 的代码存储在代码区
}

内存分布总结

区域	存储内容	生命周期	示例
栈区	局部变量、函数参数、返回地址	函数作用域结束时销毁	`int x = 10;`
堆区	动态分配的对象或变量	显式释放或程序结束	`int* p = new int;`
数据区	全局变量、静态变量、字符串字面值	程序结束时销毁	`static int x = 10;`
代码区	编译后的机器指令	程序结束时销毁	`void foo() {}`

示例分析

  
#include <iostream>
#include <string>

int globalVar = 100;            // 数据区（已初始化区）

void func() {
    static int staticVar = 10;  // 数据区（已初始化区）
    int localVar = 20;          // 栈区
    int* heapVar = new int(30); // 堆区
    std::cout << "Static: " << staticVar << ", Local: " << localVar
              << ", Heap: " << *heapVar << std::endl;
    delete heapVar;             // 释放堆区内存
}

int main() {
    std::string str = "Hello";  // 栈区（str 对象），"Hello" 存储在数据区
    func();
    return 0;
}

内存分布：

globalVar：数据区。
staticVar：数据区（静态变量）。
localVar：栈区。
heapVar：堆区（指针本身在栈区，但指向的值在堆区）。
"Hello"：数据区。

注意事项

堆区管理：
- 堆内存必须显式释放，否则可能导致内存泄漏。
- 推荐使用智能指针（如 std::shared_ptr 或 std::unique_ptr）管理堆内存。
栈区限制：
- 栈区内存有限，递归过深或过大局部变量可能导致栈溢出。
数据区字符串只读：
- 修改字符串字面值会导致未定义行为：
  1 2 char* p = "Hello"; p[0] = 'h'; // 未定义行为

c/c++内存管理

C++ 的内存管理是程序开发的重要部分，合理地分配和释放内存可以提高程序性能并避免内存泄漏或崩溃问题。以下是 C++ 中常见的内存管理技术和原则。

C++ 的内存分类

1. 静态内存

分配方式：编译时确定，程序加载时分配。
释放方式：程序结束时自动释放。
存储内容：
- 全局变量
- 静态变量
- 字符串字面值

示例：

  
static int staticVar = 10; // 静态变量
const char* str = "Hello"; // 字符串字面值

2. 栈内存

分配方式：由编译器自动分配和释放。
释放方式：函数作用域结束时自动释放。
存储内容：
- 局部变量
- 函数参数

示例：

  
void foo() {
    int localVar = 10; // 栈内存
}

3. 堆内存

分配方式：由程序员手动分配（new/delete 或 malloc/free）。
释放方式：必须显式释放，否则会导致内存泄漏。
特点：
- 空间大但分配速度较慢。
- 动态分配更灵活。

示例：

  
int* p = new int(10); // 动态分配堆内存
delete p;             // 手动释放堆内存

C++ 动态内存管理

1. `new` 和 `delete`

new：在堆区分配内存。
delete：释放通过 new 分配的内存。

示例：基本类型

  
int* ptr = new int(42);  // 分配内存并初始化为 42
delete ptr;              // 释放内存

示例：数组

  
int* arr = new int[10];  // 分配一个大小为 10 的数组
delete[] arr;            // 释放数组内存

注意事项

delete 必须匹配 new，delete[] 必须匹配 new[]。
使用未释放的内存会导致内存泄漏。

2. `malloc` 和 `free`

malloc：从堆区分配指定大小的内存，不调用构造函数。
free：释放 malloc 分配的内存，不调用析构函数。

示例

  
int* ptr = (int*)malloc(sizeof(int)); // 分配 4 字节内存
*ptr = 42;                           // 使用内存
free(ptr);                           // 释放内存

与 `new/delete` 的区别

特性	new/delete	malloc/free
内存分配	自动计算大小	手动指定大小
构造/析构函数	调用构造和析构函数	不调用构造和析构函数
类型安全	返回正确类型的指针	返回 `void*`，需要显式转换

3. 智能指针

C++11 引入了智能指针，用于自动管理堆内存，避免手动调用 delete。

类型

std::unique_ptr：
- 独占所有权，无法共享。
- 内存会在离开作用域时自动释放。
1 std::unique_ptr<int> ptr = std::make_unique<int>(10);
std::shared_ptr：
- 共享所有权，多个智能指针可以共享同一块内存。
- 内存会在引用计数为零时自动释放。
1 2 std::shared_ptr<int> ptr1 = std::make_shared<int>(10); std::shared_ptr<int> ptr2 = ptr1; // 共享同一内存

std::weak_ptr：

弱引用，不增加引用计数。
通常用于解决循环引用问题。

  
std::shared_ptr<int> shared = std::make_shared<int>(10);
std::weak_ptr<int> weak = shared; // 弱引用

内存管理注意事项

1. 避免内存泄漏

问题：动态分配的内存未释放。
解决方法：
- 保证每个 new 有对应的 delete。
- 使用智能指针自动管理内存。

示例

  
void foo() {
    int* ptr = new int(10);
    // 如果忘记 delete ptr，会导致内存泄漏
}

2. 避免悬空指针

问题：释放内存后指针仍指向该内存。
解决方法：
- 释放内存后将指针置为 nullptr。

示例

  
int* ptr = new int(10);
delete ptr;
ptr = nullptr; // 避免悬空指针

3. 避免重复释放

问题：对同一内存块调用两次 delete 会导致未定义行为。
解决方法：
- 确保内存仅释放一次。
- 使用智能指针避免手动释放。

示例

  
int* ptr = new int(10);
delete ptr;
delete ptr; // 未定义行为

内存调试工具

Valgrind：检测内存泄漏和非法访问。
AddressSanitizer (ASan)：运行时内存错误检测工具。
工具链支持：大多数现代 IDE（如 Visual Studio）都内置了内存调试工具。

总结

静态内存和栈内存由编译器自动管理。
堆内存需要程序员手动分配和释放，或使用智能指针进行自动管理。
避免常见问题，如内存泄漏、悬空指针和重复释放。
利用现代 C++ 的智能指针和工具（如 std::unique_ptr 和 std::shared_ptr）简化内存管理，提高代码安全性和可维护性。

确实，RAII（Resource Acquisition Is Initialization）是 C++ 中内存管理的一种重要方式。它利用对象的构造函数和析构函数来管理资源，包括内存、文件句柄、线程锁等。

以下是对 RAII 的详细介绍：

RAII 的核心概念

资源获取即初始化：在对象的构造函数中分配资源（如内存、文件、锁等）。
资源释放由析构函数完成：当对象的生命周期结束时，析构函数会自动释放资源。

优点

自动化管理资源：
- 避免显式调用 delete 或 free，降低出错概率。
异常安全性：
- 即使在函数异常返回时，析构函数仍会自动释放资源，避免资源泄漏。
统一管理资源：
- 所有资源的生命周期都与对象绑定，易于维护和调试。

RAII 的典型用法

1. 使用智能指针管理动态内存

智能指针是 RAII 的典型实现，用于管理堆内存。

示例：`std::unique_ptr`

  
#include <memory>
#include <iostream>

void foo() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42); // 在构造函数中分配资源
    std::cout << *ptr << std::endl;                      // 自动管理内存
} // 作用域结束时，自动调用析构函数释放内存

示例：`std::shared_ptr`

  
#include <memory>

void foo() {
    std::shared_ptr<int> shared1 = std::make_shared<int>(42);
    std::shared_ptr<int> shared2 = shared1; // 引用计数增加
    // 内存会在最后一个智能指针销毁时释放
}

2. 管理文件资源

RAII 可用于自动管理文件句柄，避免手动关闭文件。

示例

  
#include <fstream>
#include <iostream>

void writeToFile() {
    std::ofstream file("example.txt"); // 构造函数打开文件
    if (file.is_open()) {
        file << "Hello, RAII!" << std::endl;
    } // 作用域结束时，析构函数自动关闭文件
}

3. 管理互斥锁

RAII 常用于线程同步，确保在锁的作用域结束时自动释放锁。

示例：`std::lock_guard`

  
#include <mutex>
#include <iostream>

std::mutex mtx;

void safeFunction() {
    std::lock_guard<std::mutex> lock(mtx); // 自动加锁
    std::cout << "Thread-safe operation\n";
} // 作用域结束时，自动释放锁

4. 自定义 RAII 类

如果需要管理特定资源，可以自定义 RAII 类，将资源的获取和释放封装在构造函数和析构函数中。

示例：自定义内存管理类

  
#include <iostream>

class Resource {
private:
    int* data;

public:
    Resource(size_t size) {
        data = new int[size]; // 在构造函数中分配资源
        std::cout << "Resource acquired\n";
    }

    ~Resource() {
        delete[] data; // 在析构函数中释放资源
        std::cout << "Resource released\n";
    }
};

void useResource() {
    Resource res(100); // 自动管理资源
    // 使用资源
} // 作用域结束时，自动释放资源

示例：文件 RAII 类

  
#include <iostream>
#include <fstream>

class File {
private:
    std::ofstream file;

public:
    File(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }

    ~File() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed\n";
        }
    }

    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
};

void writeToFile() {
    File file("example.txt");
    file.write("Hello, RAII!\n");
} // 作用域结束时，自动关闭文件

5. 管理动态库句柄

RAII 也可以用于管理操作系统资源，比如动态库句柄。

示例：动态库 RAII 类

  
#include <iostream>
#include <stdexcept>
#include <dlfcn.h>

class DynamicLibrary {
private:
    void* handle;

public:
    DynamicLibrary(const char* libraryPath) {
        handle = dlopen(libraryPath, RTLD_LAZY);
        if (!handle) {
            throw std::runtime_error("Failed to load library");
        }
    }

    ~DynamicLibrary() {
        if (handle) {
            dlclose(handle);
        }
    }

    template <typename T>
    T getFunction(const char* funcName) {
        return reinterpret_cast<T>(dlsym(handle, funcName));
    }
};

void useLibrary() {
    DynamicLibrary lib("./my_library.so");
    auto func = lib.getFunction<void(*)()>("my_function");
    func(); // 调用动态库函数
} // 作用域结束时，自动释放句柄

RAII 的注意事项

资源必须与对象生命周期绑定：
- RAII 对象的生命周期应与资源使用周期一致。
禁止显式释放资源：
- 使用 RAII 时，资源的释放应仅由析构函数完成，避免重复释放。
配合智能指针：
- 尽量使用标准库提供的 RAII 工具（如智能指针、锁管理类）来避免手动管理。

RAII 的优点总结

异常安全：即使在异常情况下，资源也能正确释放。
可维护性强：资源管理代码集中在构造和析构函数中，逻辑清晰。
高效率：避免手动释放资源，减少出错概率。
广泛适用：RAII 可管理任何需要显式获取和释放的资源（如内存、文件、锁、动态库等）。

RAII 是 C++ 的核心内存管理策略之一，也是现代 C++ 编程的基本原则之一。它结合构造函数和析构函数的特性，提供了安全、高效的资源管理机制，极大地减少了资源泄漏和管理复杂性的问题。

C++从源程序到可执行程序的过程

C++ 从源程序到可执行程序的过程包括几个关键步骤：预处理、编译、汇编、链接。以下是这些步骤的详细解释：

1. 源程序的书写

源程序是程序员编写的 .cpp 文件（可能还包括 .h 头文件）。这些文件用人类可读的 C++ 语言编写。

示例源程序文件

main.cpp

：

  
#include <iostream>
void hello() {
    std::cout << "Hello, World!" << std::endl;
}
  
int main() {
    hello();
    return 0;
}

2. 预处理（Preprocessing）

预处理是将源代码中的预处理指令（如 #include 和 #define）展开，生成扩展的源代码。

预处理器：处理以 # 开头的指令，例如：
- 替换宏定义（#define）。
- 将 #include 替换为对应头文件的内容。
- 删除注释。
- 条件编译（#ifdef，#ifndef）。
预处理后的代码保存在临时文件中（通常以 .i 为扩展名），可通过编译器选项查看（如 g++ -E）。

示例：预处理后的代码

对于以下代码：

  
#include <iostream>
#define GREETING "Hello, World!"
int main() {
    std::cout << GREETING << std::endl;
    return 0;
}

预处理后可能变为：

  
// 内容来自 <iostream>
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

3. 编译（Compilation）

编译是将扩展后的源代码转换为汇编代码。这一步是 C++ 编译器的核心工作。

编译器：将高级语言代码转化为目标平台的汇编代码（通常以 .s 为扩展名）。
优化：编译器可以对代码进行优化，例如移除冗余代码、内联函数调用等。

示例：汇编代码

.section    .rodata
.LC0:
    .string "Hello, World!"
.text
.globl main
main:
    pushq   %rbp
    movq    %rsp, %rbp
    leaq    .LC0(%rip), %rdi
    call    puts
    movl    $0, %eax
    popq    %rbp
    ret

4. 汇编（Assembly）

汇编器将汇编代码转换为机器代码（目标代码），生成 .o 或 .obj 文件。

目标代码：目标文件是二进制格式，包含函数和变量的机器指令，但这些指令无法直接执行，因为它们尚未链接到其他库或代码。

示例：目标文件

目标文件是二进制数据，人类难以直接阅读。例如：

0000000000000000 <main>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   bf 00 00 00 00          mov    $0x0,%edi
   9:   e8 00 00 00 00          callq  0xe

5. 链接（Linking）

链接是将目标文件与所需的库和其他模块合并，生成可执行文件。

静态链接：
- 将库的代码直接嵌入可执行文件中。
- 优点：可执行文件独立运行。
- 缺点：可执行文件较大。
动态链接：
- 仅在运行时加载动态库。
- 优点：可执行文件较小，多个程序可以共享动态库。
- 缺点：依赖运行环境中的库。
链接器主要负责：
- 符号解析：找到目标文件和库中定义的函数或变量。
- 重定位：调整函数和变量的内存地址。

示例

编译时动态链接标准库：
1 g++ main.cpp -o main
编译时静态链接：
1 g++ main.cpp -static -o main

6. 可执行文件

经过链接后，生成可执行文件（如 Linux 下的 ELF 文件，Windows 下的 PE 文件）。可执行文件包含：

机器代码。
静态链接的库代码（如果有）。
程序入口地址（如 _start 或 main）。

运行可执行文件时，操作系统会将其加载到内存中，并开始执行。

总结：C++ 编译过程的完整流程

步骤概览

预处理：展开 #include 和 #define，生成扩展代码（.i 文件）。
编译：将扩展代码转换为汇编代码（.s 文件）。
汇编：将汇编代码转换为目标代码（.o 或 .obj 文件）。
链接：将目标文件和库链接为可执行文件（如 main 或 main.exe）。

图示

源代码（.cpp）
   ↓ 预处理器
扩展代码（.i）
   ↓ 编译器
汇编代码（.s）
   ↓ 汇编器
目标文件（.o）
   ↓ 链接器
可执行文件（如 a.out / main.exe）

工具和选项

查看各阶段结果：
- 仅预处理：g++ -E main.cpp -o main.i
- 仅编译：g++ -S main.cpp -o main.s
- 仅汇编：g++ -c main.cpp -o main.o
- 完整编译：g++ main.cpp -o main
调试信息：
- 添加调试信息：g++ -g main.cpp -o main
优化：
- 代码优化：g++ -O2 main.cpp -o main
链接动态库：
- 链接动态库：g++ main.cpp -l<library_name>

通过这些步骤，C++ 程序从人类可读的源代码变为计算机可执行的二进制文件。

C++, C++面经

C++ 面经

本文由作者按照 CC BY 4.0 进行授权

多态和继承在什么情况下使用

继承的使用场景

适用场景

多态的使用场景

适用场景

继承与多态结合的使用

示例：

避免滥用的场景

除了多态和继承还有什么面向对象方法

1. 封装（Encapsulation）

核心思想

适用场景

示例

2. 组合（Composition）

核心思想

适用场景

示例

3. 抽象（Abstraction）

核心思想

适用场景

示例

4. 接口（Interfaces）

核心思想

适用场景

示例

5. 依赖注入（Dependency Injection）

核心思想

适用场景

示例

6. 消息传递（Message Passing）

核心思想

适用场景

7. 责任链模式（Chain of Responsibility）

适用场景

示例

8. 类的聚合（Aggregation）

适用场景

总结

C++内存分布。什么样的数据在栈区，什么样的在堆区

1. 栈区（Stack Segment）

2. 堆区（Heap Segment）

3. 数据区（静态区 / Global Segment）

4. 代码区（Text Segment）

内存分布总结

示例分析

注意事项

c/c++内存管理

C++ 的内存分类

1. 静态内存

2. 栈内存

3. 堆内存

C++ 动态内存管理

1. new 和 delete

示例：基本类型

示例：数组

注意事项

2. malloc 和 free

示例

与 new/delete 的区别

3. 智能指针

类型

内存管理注意事项

1. 避免内存泄漏

示例

2. 避免悬空指针

示例

3. 避免重复释放

示例

内存调试工具

总结

RAII 的核心概念

优点

RAII 的典型用法

1. 使用智能指针管理动态内存

示例：std::unique_ptr

示例：std::shared_ptr

2. 管理文件资源

示例

3. 管理互斥锁

示例：std::lock_guard

1. `new` 和 `delete`

2. `malloc` 和 `free`

与 `new/delete` 的区别

示例：`std::unique_ptr`

示例：`std::shared_ptr`

示例：`std::lock_guard`