【GL010】C++

1.C++中的const关键字有哪些用法？

• 1.修饰变量：表示变量的值不可修改。

• const int a = 10;

• 2.修饰指针：

• const int* p：        // 指针指向的内容不可修改。
  int* const p：        // 指针本身不可修改。
  const int* const p：  // 指针和指针指向的内容都不可修改。

• 3.修饰成员函数：表示该函数不会修改类的成员变量。

• void func() const;

• 4.修饰函数参数：表示函数内部不会修改该参数。

• void func(const int& x);

2.C++中的static关键字有哪些用法？

• 1.修饰局部变量：使局部变量的生命周期延长到整个程序运行期间，但作用域不变。

• void func() { static int count = 0; count++; }

• 2.修饰全局变量或函数：限制其作用域为当前文件。

• static int globalVar = 10;

• 3.修饰类的成员变量：使该成员变量属于类而不是类的实例，所有实例共享同一个静态成员变量。

• class A { public: static int count; };

• 4.修饰类的成员函数：静态成员函数不能访问类的非静态成员，只能访问静态成员。

• class A { public: static void func(); };

3. C++中的虚函数和纯虚函数有什么区别？ 

• 虚函数：在基类中使用virtual关键字声明的函数，派生类可以重写该函数。基类可以定义虚函数的实现。

• class Base { public: virtual void func() { cout << "Base" << endl; } };

• 纯虚函数：在基类中使用virtual关键字声明并且没有实现的函数，派生类必须重写该函数。含有纯虚函数的类称为抽象类，不能实例化。

• class Base { public: virtual void func() = 0; };

4. C++的多态形式

        多态（Polymorphism）定义：多态性是面向对象编程（OOP）中的一个核心概念，它允许不同类的对象通过相同的接口调用不同的方法。在C++中，多态性通常通过继承和虚函数来实现。

实现方式：

1.基于继承的多态（运行时多态）：通过基类指针或引用来调用派生类中的重写方法。

class Base {
public:
    virtual void show() {
        cout << "Base class show function" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class show function" << endl;
    }
};

int main() {
    Base* basePtr;
    Derived derivedObj;
    basePtr = &derivedObj;
    basePtr->show(); // 调用的是Derived类的show方法
    return 0;
}

2.基于函数重载和模板的多态（编译时多态）（虽然这不是传统意义上的多态，但在某些情况下可以模拟多态行为）

注意：多态性要求基类中的函数必须是虚函数（使用virtual关键字），且派生类中对该函数进行了重写（使用override关键字，C++11及以后）。

• 函数重载：允许在同一个作用域内定义多个同名函数，但这些函数的参数列表必须不同。

  void print(int i) {
      cout << "Integer: " << i << endl;
  }
  
  void print(double d) {
      cout << "Double: " << d << endl;
  }
  

• 模板：允许编写与类型无关的代码，编译器在编译时会自动根据实参类型生成相应的函数或类。

  template <typename T>
  void print(T t) {
      cout << t << endl;
  }

5. C++的重载（Overloading）

定义：函数重载是指在同一作用域内，可以声明多个具有相同名称但参数列表不同的函数。参数列表的不同可以是参数的类型、数量或顺序。

示例：

class MathUtils {
public:
    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;
    }
};

在这个例子中，MathUtils类有三个名为add的函数，但它们的参数列表不同，因此可以共存。

• 关于多态：

  • 虚函数表（vtable）是如何实现的？它是如何支持多态性的？
    • 答案：虚函数表是一个指向函数指针数组的指针，每个类都有一个自己的虚函数表。当通过基类指针或引用调用虚函数时，编译器会查找该指针所指向的虚函数表，并根据对象实际的类型找到正确的函数指针进行调用。
  • 虚析构函数的作用是什么？为什么需要它？
    • 答案：虚析构函数确保当通过基类指针删除派生类对象时，能够调用到派生类的析构函数，从而正确释放资源。如果没有虚析构函数，可能会导致资源泄漏或未定义行为。

• 关于重载：

  • 函数重载是如何实现的？编译器如何区分同名函数？
    • 答案：函数重载是通过函数名称修饰（name mangling）来实现的。编译器会根据函数的参数列表生成一个唯一的函数标识符，从而区分同名但参数不同的函数。
  • 构造函数可以被重载吗？如果可以，有什么注意事项？
    • 答案：是的，构造函数可以被重载。每个构造函数都必须有独特的参数列表。在重载构造函数时，需要确保每个构造函数都能正确地初始化对象的状态，并避免重复或冲突的代码。

6. 虚拟地址和物理地址 

（1）基本概念

• 地址空间：一个非负整数地址的有序集合，用于标识内存位置。

  • 虚拟地址空间 (Virtual Address Space)：由 CPU 生成的逻辑地址集合，大小为 N=2的n次方（如 32 位系统为 2的32次方=4GB）。
  • 物理地址空间 (Physical Address Space)：实际物理内存（RAM）的地址集合，大小为 MM 字节（如 8GB 物理内存对应 M=8×2的30次方字节）。

• 虚拟地址与物理地址的关系：

  • 每个存储单元（字节）在虚拟地址空间和物理地址空间中分别有一个地址。
  • 虚拟地址是程序直接使用的逻辑地址，物理地址是内存硬件实际访问的地址。

（2）虚拟内存的核心思想

        虚拟内存允许数据对象拥有多个独立的虚拟地址，这些地址来自不同的虚拟地址空间。例如：

• 不同进程的映射：同一物理内存页（如共享库）可被映射到不同进程的虚拟地址空间中。
• 同一进程的多重映射：同一虚拟地址在不同时刻可映射到不同物理地址（如动态内存分配）。

（3）地址转换机制

        虚拟地址到物理地址的转换由 MMU（内存管理单元） 完成，核心步骤如下：

1. 分页机制：

   • 内存被划分为固定大小的页（如 4KB）。
   • 虚拟地址和物理地址均按页对齐，页内偏移直接映射。

2. 页表映射：

   • 页表 (Page Table)：操作系统为每个进程维护的数据结构，记录虚拟页号到物理页帧号的映射。
   • 页表项 (PTE)：包含物理页帧号、权限位（读/写/执行）、有效位（是否在内存中）等。

3. 转换流程：

   • 虚拟地址拆分为 页号（高位） 和 页内偏移（低位）。
   • MMU 通过页号查询页表，获取物理页帧号。
   • 物理地址 = 物理页帧号 × 页大小 + 页内偏移。

示例：

• 虚拟地址 0x0804A000（页号 0x0804A，偏移 0x000）→ 物理页帧 0x12345 → 物理地址 0x12345000。

（4）虚拟内存的优势

1. 内存隔离：每个进程拥有独立虚拟地址空间，防止非法访问。
2. 内存扩展：通过磁盘交换（Swap）支持运行超过物理内存大小的程序。
3. 共享内存：不同进程的虚拟地址可映射到同一物理页（如动态库、进程间通信）。
4. 简化编程：程序无需关心物理内存分配细节（如碎片、地址冲突）。

关键问题与场景 

Q1：虚拟地址空间可以大于物理地址空间吗？

• 可以。例如，32 位系统虚拟地址空间为 4GB，物理内存可能仅 2GB，剩余部分通过磁盘交换模拟。

Q2：虚拟地址是否一定对应物理地址？

• 不一定。虚拟地址可能：
  • 未分配（如未使用的堆空间）。
  • 已分配但未加载到内存（触发缺页中断）。
  • 映射到文件（内存映射文件，mmap）。

Q3：如何实现多个虚拟地址映射到同一物理地址？

• 共享内存：多个进程的页表项指向同一物理页帧。
• 示例：动态库代码段在多个进程间共享，减少内存冗余。

7. Linux字符设备

1. 什么是字符设备？

• 定义：字符设备（Character Device）是以**字节流（Byte Stream）**形式进行数据读写的设备，数据按顺序访问，不支持随机寻址。
• 典型例子：键盘、鼠标、串口、终端（/dev/tty）、声卡等。
• 与块设备的区别：
  • 访问方式：字符设备按字节流操作，块设备按固定大小的数据块（如 512B）操作。
  • 缓存机制：块设备通常有内核缓存（Buffer Cache），而字符设备无缓存（直接读写硬件）。
  • 使用场景：字符设备用于实时性高或数据量小的设备，块设备用于存储设备（如硬盘）。

2. 字符设备驱动核心机制

(1) 设备号（Major & Minor Number）

• 主设备号（Major Number）：标识设备类型，同一类设备共享同一主设备号。
• 次设备号（Minor Number）：区分同一类型设备的不同实例（如多个串口）。
• 注册方法：

• // 静态分配（需确保未被占用）
  int register_chrdev_region(dev_t first, unsigned int count, const char *name);
  
  // 动态分配（推荐）
  int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);

(2) 设备文件

• 设备节点：用户通过文件（如 /dev/mydev）访问设备。
• 创建方式：
  • 手动创建：mknod /dev/mydev c 250 0（主设备号250，次设备号0）。
  • 自动创建：通过 udev 或 devtmpfs 根据 sysfs 信息自动生成。

(3) 驱动核心结构体：file_operations

• 作用：定义设备操作函数（如 open, read, write），用户调用系统调用时触发。
• 关键成员函数：

• struct file_operations {
      struct module *owner;
      int (*open)(struct inode *, struct file *);
      ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
      ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
      long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
      int (*release)(struct inode *, struct file *);
      // 其他函数：poll, mmap, fsync 等
  };

(4) 驱动注册流程

1. 分配设备号：alloc_chrdev_region。
2. 初始化 cdev：

   struct cdev my_cdev;
   cdev_init(&my_cdev, &my_fops); // 绑定 file_operations

3. 添加设备到内核：cdev_add(&my_cdev, dev, count)。
4. 创建设备节点（可选自动方式）：

   struct class *my_class = class_create(THIS_MODULE, "my_class");
   device_create(my_class, NULL, dev, NULL, "mydev");

(5) 相关问题：

Q1: 字符设备和块设备有什么区别？

• 回答要点：
  • 字符设备按字节流访问，块设备按数据块访问。
  • 字符设备无内核缓存，块设备有缓存机制。
  • 典型应用场景：字符设备用于交互式设备（如串口），块设备用于存储（如硬盘）。

Q2: 如何注册一个字符设备驱动？

• 回答示例：
  1. 使用 alloc_chrdev_region 动态分配设备号。
  2. 定义并填充 file_operations 结构体。
  3. 初始化 cdev 并通过 cdev_add 注册到内核。
  4. 使用 class_create 和 device_create 自动生成设备节点。

Q3: file_operations 中的 read 和 write 函数如何实现？

• 回答示例：
  • read：从设备读取数据到用户空间缓冲区，使用 copy_to_user。

  • static ssize_t my_read(struct file *filp, char __user *buf, size_t len, loff_t *off) {
        char kernel_buf[256];
        // 从硬件读取数据到 kernel_buf
        copy_to_user(buf, kernel_buf, min(len, sizeof(kernel_buf)));
        return len;
    }

  • write：从用户空间缓冲区写入设备，使用 copy_from_user。

  • static ssize_t my_write(struct file *filp, const char __user *buf, size_t len, loff_t *off) {
        char kernel_buf[256];
        copy_from_user(kernel_buf, buf, min(len, sizeof(kernel_buf)));
        // 将 kernel_buf 写入硬件
        return len;
    }

Q4: 用户程序如何与字符设备交互？

• 回答要点：
  • 用户程序通过系统调用（如 open, read, write, ioctl）操作设备文件。
  • 示例代码：

  • int fd = open("/dev/mydev", O_RDWR);
    read(fd, buf, sizeof(buf));
    write(fd, buf, sizeof(buf));
    ioctl(fd, MY_CMD, arg);
    close(fd);

8. 进程，线程，协程区别，进程间通信、怎样做同步、信号量和锁

（1）基本概念对比

 （2）进程间通信（IPC）方式

【GL011】操作系统-CSDN博客文章浏览阅读975次，点赞21次，收藏19次。本篇文章是关于操作系统的知识混淆点，建议经常食用！https://blog.csdn.net/qq_68192341/article/details/144378829?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522efe8ef7a25b42058cc3baedf821c4263%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=efe8ef7a25b42058cc3baedf821c4263&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-144378829-null-null.nonecase&utm_term=%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1&spm=1018.2226.3001.4450

9. C++设计模式

1. 单例模式（Singleton）

• 作用：确保一个类只有一个实例，并提供全局访问点。
• 场景：配置管理、日志系统、数据库连接池。
• 实现（C++11 线程安全）：

• class Singleton {
  public:
      static Singleton& getInstance() {
          static Singleton instance; // C++11 保证线程安全
          return instance;
      }
      void doSomething() { /* ... */ }
  private:
      Singleton() = default; // 私有构造函数
      Singleton(const Singleton&) = delete; // 禁止拷贝
      Singleton& operator=(const Singleton&) = delete; // 禁止赋值
  };

• 2. 工厂模式（Factory Method）

• 作用：将对象创建延迟到子类，通过接口统一创建过程。
• 场景：跨平台 UI 组件、数据库驱动。
• 示例：

• class Product {
  public:
      virtual void use() = 0;
  };
  class ConcreteProduct : public Product {
      void use() override { std::cout << "Using product\n"; }
  };
  class Factory {
  public:
      virtual Product* createProduct() = 0;
  };
  class ConcreteFactory : public Factory {
      Product* createProduct() override { return new ConcreteProduct(); }
  };

3. 抽象工厂模式（Abstract Factory）

• 作用：创建一组相关或依赖对象的家族，无需指定具体类。
• 场景：跨主题 GUI 库（如不同风格的按钮和文本框）。
• 示例：

• class Button { /* ... */ };
  class WinButton : public Button { /* ... */ };
  class MacButton : public Button { /* ... */ };
  
  class GUIFactory {
  public:
      virtual Button* createButton() = 0;
  };
  class WinFactory : public GUIFactory {
      Button* createButton() override { return new WinButton(); }
  };
  class MacFactory : public GUIFactory {
      Button* createButton() override { return new MacButton(); }
  };

  4. 建造者模式（Builder）

• 作用：分步骤构造复杂对象，分离构建与表示。
• 场景：构造 HTTP 请求、游戏角色生成。
• 示例：

• class Car {
      std::string engine, wheels;
  public:
      void setEngine(const std::string& e) { engine = e; }
      void setWheels(const std::string& w) { wheels = w; }
  };
  
  class CarBuilder {
  public:
      virtual void buildEngine() = 0;
      virtual void buildWheels() = 0;
      virtual Car getResult() = 0;
  };
  class SportsCarBuilder : public CarBuilder {
      Car car;
      void buildEngine() override { car.setEngine("V8"); }
      void buildWheels() override { car.setWheels("Racing"); }
      Car getResult() override { return car; }
  };

................................很多................................

10. 观察者模式如何用C++实现

观察者模式（Observer）

• 作用：定义对象间的一对多依赖，当对象状态变化时自动通知依赖项。
• 场景：事件处理系统、MVC 模型更新。