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

class MyInt {
public:
    MyInt(int v) : value(v) {}   // 单参数构造函数，可隐式转换
    int value;
};

void printMyInt(MyInt m) {
    std::cout << m.value << std::endl;
}

int main() {
    printMyInt(42);      // ❌ 隐式转换：42 被悄悄转成 MyInt(42)
                         // 这往往不是我们想要的，容易产生 bug
    MyInt m = 10;        // ❌ 隐式转换：int 转 MyInt
    MyInt m2 = m + 5;    // ❌ 隐式转换：m 先转 int 相加，再转回 MyInt
}

class MyInt {
public:
    explicit MyInt(int v) : value(v) {}
    int value;
};

void printMyInt(MyInt m) {
    std::cout << m.value << std::endl;
}

int main() {
    // printMyInt(42);     ❌ 编译错误：不能隐式转换
    printMyInt(MyInt(42));  // ✅ 必须显式构造

    // MyInt m = 10;       ❌ 编译错误
    MyInt m(10);            // ✅ 显式调用
}

class SmartPtr {
public:
    explicit operator bool() const { return ptr_ != nullptr; }
    // 避免在 if/bool 之外的隐式转换
};

SmartPtr p;
// bool b = p;    ❌ 禁止隐式转换
bool b = static_cast<bool>(p);  // ✅ 显式

class Base final {   // 此类不能被继承
public:
    void func() {}
};

// class Derived : public Base {};   ❌ 编译错误：Base 是 final

class Base {
public:
    virtual void foo() {}
    virtual void bar() final {}   // bar 不允许再被重写
};

class Derived : public Base {
public:
    void foo() override {}    // ✅ 可以重写
    // void bar() override {} ❌ 编译错误：bar 是 final，不能重写
};

struct S {
    char a;    // 1 字节
    int  b;    // 4 字节
    char c;    // 1 字节
};
// 直觉上大小是 6 字节，实际上 sizeof(S) = 12

偏移:  0    1    2    3    4    5    6    7    8    9    10   11
内容:  a   [pad][pad][pad]  b   (4字节)   c   [pad][pad][pad]
       └─char─┘  └─填充3字节─┘ └────int────┘ └─char─┘ └─填充3字节─┘

struct alignas(16) S {   // 强制结构体按 16 字节对齐
    int x;
};

#pragma pack(1)          // 取消填充，按 1 字节对齐（节省空间但降低性能）
struct Packed { char a; int b; };  // sizeof = 5
#pragma pack()

对齐（快）：一次读一个字         未对齐（慢）：跨两个字节，需两次读取
[  ][int][int][  ]              [ ][int|int][ ]
      └──一次读──┘                    └─两次读─┘

// 合理排列成员可以减少 padding
struct Bad  { char a; int b; char c; };   // sizeof = 12，浪费 6 字节
struct Good { int b; char a; char c; };   // sizeof = 8，只浪费 2 字节

// 基本类型转换
double d = 3.14;
int i = static_cast<int>(d);        // 3

// 类层次中向上转换（子类 → 基类，安全，无需强制转换其实也能隐式完成）
class Base {};
class Derived : public Base {};
Derived* d = new Derived;
Base* b = static_cast<Base*>(d);     // 向上转换，安全

// void* 转具体类型指针
void* vp = &i;
int* ip = static_cast<int*>(vp);

// 枚举与整型互转
enum Color { RED, GREEN };
int c = static_cast<int>(GREEN);

class Base { virtual void f() {} };  // 必须有虚函数，否则编译错误
class Derived : public Base {};

Base* b = new Derived;
Derived* d = dynamic_cast<Derived*>(b);   // ✅ 成功，b 实际指向 Derived
if (d != nullptr) {
    // 安全地当作 Derived 使用
}

Base* b2 = new Base;
Derived* d2 = dynamic_cast<Derived*>(b2); // ✅ 失败返回 nullptr，不会崩
if (d2 == nullptr) {
    // 转换失败，安全处理
}

const int x = 10;

// int* p = &x;                    ❌ 不能直接转
int* p = const_cast<int*>(&x);     // ✅ 移除 const
// *p = 20;                        ⚠️ 危险！修改原本是 const 的对象是未定义行为

// 使用场景：老式 C API 不带 const，需要适配
void legacy_api(char* str);        // 老接口没有 const
const char* modern = "hello";
legacy_api(const_cast<char*>(modern));  // 去掉 const 以适配老接口

// 整数与指针互转（底层编程、序列化）
int* p = new int(65);
uintptr_t addr = reinterpret_cast<uintptr_t>(p);  // 指针 → 整数
int* p2 = reinterpret_cast<int*>(addr);           // 整数 → 指针

// 不相关指针类型之间的转换
struct A { int x; };
struct B { int y; };
A* a = new A;
B* b = reinterpret_cast<B*>(a);   // 位模式不变，仅重解释（危险！）

首选最小权力的转换：
能用 static_cast → 不要用 reinterpret_cast
能不用强转 → 就不要强转（依赖隐式转换）

越往下越危险：
static_cast  <  dynamic_cast  <  const_cast  <  reinterpret_cast
（编译期）     （运行期+RTTI）   （去 const）     （位重解释）

// 函数重载：同一个名字，根据参数类型选择
void print(int x)    { std::cout << "int: " << x; }
void print(double x) { std::cout << "double: " << x; }

// 模板：根据类型实例化出不同版本
template<typename T>
T max(T a, T b) { return a > b ? a : b; }

class Animal {
public:
    virtual void speak() { std::cout << "Animal speaks" << std::endl; }
    virtual ~Animal() = default;   // 基类析构必须虚
};

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

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

int main() {
    std::unique_ptr<Animal> a1 = std::make_unique<Dog>();
    std::unique_ptr<Animal> a2 = std::make_unique<Cat>();

    a1->speak();   // 输出 "Woof!"（Dog 的版本）
    a2->speak();   // 输出 "Meow!"（Cat 的版本）
    // 同一个调用 speak()，根据实际对象类型执行不同实现 —— 这就是多态
}

// 值传递会切片，丢失多态
void call(Animal a) { a.speak(); }   // ❌ 永远调用基类版本
void call2(Animal& a) { a.speak(); } // ✅ 引用保持多态

Base 类的 vtable:                Derived 类的 vtable:
┌─────────────────┐              ┌─────────────────┐
│ Base::speak()   │              │ Derived::speak() │  ← 被重写，替换了
├─────────────────┤              ├─────────────────┤
│ Base::other()   │              │ Base::other()    │  ← 未重写，沿用基类
└─────────────────┘              └─────────────────┘

对象内存布局：
┌──────────────┐
│    vptr      │  → 指向 Derived 类的 vtable
├──────────────┤
│  成员变量...  │
└──────────────┘

Animal* a = new Dog();
a->speak();   // 运行期如何找到 Dog::speak？

class Base {
public:
    virtual void f() { std::cout << "Base::f" << std::endl; }
    virtual void g() { std::cout << "Base::g" << std::endl; }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void f() override { std::cout << "Derived::f" << std::endl; }  // 重写 f
    // g 未重写，沿用 Base::g
};

int main() {
    Base* b = new Derived();
    b->f();   // 运行期通过 vtable 找到 Derived::f
    b->g();   // 运行期找到 Base::g（Derived 未重写）

    // 含虚函数的类，对象大小会多一个 vptr
    std::cout << sizeof(Base);     // 8（vptr，64 位系统）
}

class Base {
public:
    virtual Base() {}   // ❌ 编译错误：构造函数不能是虚函数
};

class Base {
public:
    virtual ~Base() {}   // ✅ 析构函数可以且应该是虚函数
};

class Derived : public Base {
    int* data;
public:
    Derived() : data(new int[100]) {}
    ~Derived() { delete[] data; }   // 释放资源
};

Base* b = new Derived();
delete b;   // 如果 Base 析构不是虚，只调 Base::~Base，Derived 资源泄漏！

class Base {
public:
    virtual ~Base() = default;
    virtual std::unique_ptr<Base> clone() const = 0;   // 虚克隆
};

class Derived : public Base {
public:
    std::unique_ptr<Base> clone() const override {
        return std::make_unique<Derived>(*this);
    }
};

class Base {
public:
    ~Base() { std::cout << "Base destroyed" << std::endl; }   // ❌ 非虚析构
};

class Derived : public Base {
    int* data;
public:
    Derived() : data(new int[1000]) {}
    ~Derived() { delete[] data; }   // 释放资源
};

Base* b = new Derived();
delete b;   // ❌ 只调 Base::~Base，不调 ~Derived → data 泄漏！
            // 这是未定义行为

class Base {
public:
    virtual ~Base() = default;   // ✅ 虚析构
};
// delete b 现在会依次调用 ~Derived → ~Base

class NonPolymorphic final {   // final 类不会被继承
    ~NonPolymorphic() = default;   // 不必虚
};

    A
   / \
  B   C
   \ /
    D

class A { public: int x = 1; };
class B : public A {};   // 普通继承
class C : public A {};   // 普通继承
class D : public B, public C {};

D d;
// d.x;              ❌ 二义性：B::x 还是 C::x？
d.B::x;              // 必须指定路径，且有两份 x
sizeof(D);           // 有两份 A 的成员，冗余

class A { public: int x = 1; };
class B : virtual public A {};   // 虚继承
class C : virtual public A {};   // 虚继承
class D : public B, public C {};

D d;
d.x = 100;          // ✅ 无二义性，只有一份 x
sizeof(D);          // 只有一份 A 的成员

class A {
public:
    A(int v) : x(v) {}
    int x;
};
class B : virtual public A {
public:
    B() : A(1) {}   // 这个 A(1) 会被忽略！虚基类由 D 初始化
};
class C : virtual public A {
public:
    C() : A(2) {}   // 这个 A(2) 也会被忽略
};
class D : public B, public C {
public:
    D() : A(3) {}   // 只有这里真正初始化 A，x = 3
};

class SelfDeleting {
public:
    void release() {
        delete this;   // 自毁：释放自己
    }
};

SelfDeleting* p = new SelfDeleting();
p->release();   // 对象在内部 delete 自己
// 之后不能再访问 p

void release() {
    delete this;
    // this->member = 0;   ❌ 未定义行为！this 已悬空
    // this->someFunc();   ❌ 未定义行为！
}

// 函数重载：编译器按参数类型静态决议到具体版本
void print(int x)    { std::cout << "int\n"; }
void print(double x) { std::cout << "double\n"; }

// 模板：按实参类型实例化出独立函数
template<typename T>
T max(T a, T b) { return a > b ? a : b; }

class Base {
public:
    virtual void f() { std::cout << "Base::f\n"; }
    virtual ~Base() = default;
};
class Derived : public Base {
public:
    void f() override { std::cout << "Derived::f\n"; }
};

Base* p = new Derived();
p->f();   // 运行期动态绑定到 Derived::f

// 用 unordered_map（平均 O(1)）替代 map（O(log n)）做查找
std::unordered_map<std::string, int> um;  // 哈希表
// 大数据量查找、去重优先哈希，需要有序遍历才用 map

// 缓存友好：连续内存访问比链表跳跃快
std::vector<int> v(1'000'000);   // 连续内存，CPU 预取友好
// std::list 遍历时指针跳跃，cache miss 多

// ❌ 值传递：每次调用都拷贝
void process(std::vector<int> v) { /* ... */ }

// ✅ 引用传递，避免拷贝
void process(const std::vector<int>& v) { /* ... */ }

// ✅ 移动语义：转移资源而非拷贝（右值）
std::vector<int> a = buildVector();
std::vector<int> b = std::move(a);   // O(1)，只转移内部指针

// ✅ 预留容量，避免反复扩容
std::vector<int> v;
v.reserve(1000);                     // 一次分配足额空间
for (int i = 0; i < 1000; ++i) v.push_back(i);

// ✅ emplace_back 原地构造，避免临时对象
v.emplace_back(42, 3.14);            // 直接构造，无需移动/拷贝

// constexpr：编译期求值
constexpr int fib(int n) { return n <= 1 ? n : fib(n - 1) + fib(n - 2); }
constexpr int result = fib(10);   // 编译期算好，运行期直接是常量

// final：让编译器对虚调用"去虚化"
class Base final { virtual void f(); };   // final 类可静态绑定

// inline 只是建议，现代编译器会自动内联；重点在 -O2 下让函数体可见

// 数据并行：多线程分摊任务（注意任务粒度与伪共享）
std::vector<std::thread> threads;
for (unsigned i = 0; i < std::thread::hardware_concurrency(); ++i) {
    threads.emplace_back([&, i] { computeChunk(i); });
}

// 减小锁粒度：缩小临界区、用读写锁、无锁原子
std::atomic<int> counter{0};   // 无锁递增，比 mutex 轻量
counter.fetch_add(1, std::memory_order_relaxed);

-O2 / -O3      开启常规/激进优化（内联、向量化、循环展开）
-march=native  针对本机 CPU 指令集（如 AVX2）生成代码
-flto          链接时优化（LTO），跨编译单元内联
-fprofile-generate / -fprofile-use  PGO 按真实运行热点优化

1. 先 profile（perf / gprof / VTune），定位热点，别盲目优化
2. 先算法复杂度，再内存拷贝，再局部细节
3. 每次改动后重新测量，验证收益
4. 过早优化是万恶之源 —— 先写对，再调快

1. 头文件用 Q_OBJECT 宏声明（还含 signals:/slots: 关键字）
2. moc 预处理：扫描头文件，生成 moc_xxx.cpp，内含元对象信息与信号实现
3. 运行时：每个含 Q_OBJECT 的类持有 QMetaObject，记录信号/槽的名字与索引
4. connect：把 信号索引 + 接收者 + 槽索引 登记到连接表
5. 发射信号：查连接表 → 按连接类型调用槽函数

#include <QObject>

class Sender : public QObject {
    Q_OBJECT
public:
    void doWork() {
        emit valueChanged(42);   // 发射信号，触发连接的槽
    }
signals:
    void valueChanged(int value);   // 信号只有声明
};

class Receiver : public QObject {
    Q_OBJECT
public slots:
    void onValueChanged(int value) {   // 槽是普通成员函数
        qDebug() << "received:" << value;
    }
};

// 连接
Sender sender;
Receiver receiver;
QObject::connect(&sender, &Sender::valueChanged,
                 &receiver, &Receiver::onValueChanged);   // 新式函数指针语法
sender.doWork();   // 输出 "received: 42"

class Shape {                      // 抽象基类，稳定的接口
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {      // Circle is-a Shape
public:
    explicit Circle(double r) : r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }
private:
    double r_;
};

// 多态使用：统一通过基类指针处理
void printArea(const Shape& s) { std::cout << s.area(); }

class Engine {
public:
    virtual void start() { std::cout << "engine start\n"; }
    virtual ~Engine() = default;
};

class Car {                        // Car has-a Engine
public:
    explicit Car(std::unique_ptr<Engine> e) : engine_(std::move(e)) {}
    void start() { engine_->start(); }   // 委托给组件，不继承
private:
    std::unique_ptr<Engine> engine_;     // 组合
};

// 运行期替换引擎实现
class ElectricEngine : public Engine {
public:
    void start() override { std::cout << "electric start\n"; }
};
Car car(std::make_unique<ElectricEngine>());

// ❌ 错误：为了复用 Engine::start 而继承，语义错乱（Car 不是 Engine）
class BadCar : public Engine { /* 破坏封装、耦合强 */ };

// ✅ 正确：组合，Car 持有 Engine 并委托
class Car {
    Engine engine_;
    void start() { engine_.start(); }
};

class Arena {
public:
    explicit Arena(size_t size) : data_(new char[size]), offset_(0), capacity_(size) {}
    ~Arena() { delete[] data_; }

    void* allocate(size_t n) {
        n = (n + 7) & ~size_t(7);      // 8 字节对齐
        if (offset_ + n > capacity_) throw std::bad_alloc();
        void* p = data_ + offset_;
        offset_ += n;
        return p;
    }

    void reset() { offset_ = 0; }       // 整体重置，O(1)

private:
    char* data_;
    size_t offset_;
    size_t capacity_;
};

template<typename T>
class ObjectPool {
public:
    explicit ObjectPool(size_t n) {
        for (size_t i = 0; i < n; ++i) free_.push(new T());   // 预分配
    }
    ~ObjectPool() { while (!free_.empty()) { delete free_.top(); free_.pop(); } }

    T* acquire() {
        if (free_.empty()) return new T();
        T* p = free_.top(); free_.pop();
        return p;
    }
    void release(T* p) { free_.push(p); }   // 归还，不析构，下次复用

private:
    std::stack<T*> free_;
};

class FixedBlockPool {
    struct Block { Block* next; };      // 空闲链表节点（复用块本身内存）
public:
    FixedBlockPool(size_t blockSize, size_t count) {
        pool_ = static_cast<Block*>(::operator new(blockSize * count));
        Block* p = pool_;
        for (size_t i = 0; i < count - 1; ++i) {   // 串成空闲链表
            p->next = reinterpret_cast<Block*>(reinterpret_cast<char*>(p) + blockSize);
            p = p->next;
        }
        p->next = nullptr;
        free_ = pool_;
    }
    ~FixedBlockPool() { ::operator delete(pool_); }

    void* allocate() {
        if (!free_) return nullptr;
        Block* p = free_;
        free_ = free_->next;
        return p;
    }
    void deallocate(void* p) {
        Block* b = static_cast<Block*>(p);
        b->next = free_;
        free_ = b;
    }

private:
    Block* pool_;
    Block* free_;
};

class Empty {};

Empty a, b;
&a != &b;            // 标准要求：两个对象地址必须不同
sizeof(Empty) == 1;  // 占 1 字节，保证每个对象有唯一地址

class Empty {};
class WithEmpty : public Empty { int x; };   // EBO：sizeof == 4，Empty 不额外占位
class HasMember  { Empty e; int x; };        // sizeof == 8（Empty 占 1 + 对齐到 4）

class A { public: int a; };                 // 4 字节
class B : virtual public A { public: int b; };
class C : virtual public A { public: int c; };
class D : public B, public C { public: int d; };

┌─────────────────────┐
│  B 部分：vbptr_B    │ → 指向虚基类表，记录 A 相对 B 的偏移
│           b         │
├─────────────────────┤
│  C 部分：vbptr_C    │ → 记录 A 相对 C 的偏移
│           c         │
├─────────────────────┤
│  D 部分：d          │
├─────────────────────┤
│  虚基类 A：a        │ ← 只有一份，放在对象末尾
└─────────────────────┘

class Shape {                          // 抽象产品
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};
class Circle : public Shape {
public:
    void draw() const override { std::cout << "circle\n"; }
};
class Square : public Shape {
public:
    void draw() const override { std::cout << "square\n"; }
};

class ShapeFactory {                   // 工厂
public:
    static std::unique_ptr<Shape> create(const std::string& type) {
        if (type == "circle") return std::make_unique<Circle>();
        if (type == "square") return std::make_unique<Square>();
        return nullptr;
    }
};

auto s = ShapeFactory::create("circle");   // 调用方只依赖 Shape 接口
s->draw();

class SortStrategy {                   // 策略接口
public:
    virtual void sort(std::vector<int>& v) const = 0;
    virtual ~SortStrategy() = default;
};
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& v) const override { /* 快排 */ }
};
class MergeSort : public SortStrategy {
public:
    void sort(std::vector<int>& v) const override { /* 归并 */ }
};

class Sorter {                         // 上下文：组合一个策略
    std::unique_ptr<SortStrategy> strategy_;
public:
    explicit Sorter(std::unique_ptr<SortStrategy> s) : strategy_(std::move(s)) {}
    void setStrategy(std::unique_ptr<SortStrategy> s) { strategy_ = std::move(s); }
    void sort(std::vector<int>& v) const { strategy_->sort(v); }
};

class Observer {                       // 抽象观察者
public:
    virtual void update(int state) = 0;
    virtual ~Observer() = default;
};
class Subject {                        // 主题
    std::vector<Observer*> observers_;
    int state_ = 0;
public:
    void attach(Observer* o) { observers_.push_back(o); }
    void setState(int s) {
        state_ = s;
        notify();                      // 状态变化 → 通知所有观察者
    }
    void notify() {
        for (auto* o : observers_) o->update(state_);
    }
};

// widget.h —— 对外只暴露接口，不含任何实现细节
#include <memory>

class Widget {
public:
    Widget();
    ~Widget();                       // 析构必须在 .cpp 中定义（Impl 不完整类型）
    Widget(Widget&&) noexcept;       // 移动需要完整类型
    Widget& operator=(Widget&&) noexcept;

    void doSomething();
    int getValue() const;

private:
    struct Impl;                     // 只前置声明，不暴露定义
    std::unique_ptr<Impl> pImpl_;    // 指向实现的指针
};

// widget.cpp —— 实现细节全部藏在这里
#include "widget.h"
#include <string>
#include <vector>

struct Widget::Impl {                // 真正的成员都在这里
    std::string name;
    std::vector<int> data;
    void doSomething() { /* ... */ }
};

Widget::Widget() : pImpl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;         // 必须在此定义：Impl 完整类型可见
void Widget::doSomething() { pImpl_->doSomething(); }
int Widget::getValue() const { return static_cast<int>(pImpl_->data.size()); }

// 如需拷贝，需在 .cpp 手写深拷贝
Widget::Widget(const Widget& other)
    : pImpl_(std::make_unique<Impl>(*other.pImpl_)) {}

# 编译与运行
g++ -fsanitize=address -g -O1 test.cpp -o test
./test    # 泄漏/越界时打印详细报告与调用栈

# 无需重编译，直接对现有二进制运行
valgrind --leak-check=full --track-origins=yes ./test

// 优化前：普通循环
void add(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; ++i) c[i] = a[i] + b[i];
}
// 编译：-O3 -march=native，循环会被自动向量化（一次处理 4/8 个 float）

#include <immintrin.h>

// SSE：一次加 4 个 float
void add4_sse(float* a, float* b, float* c) {
    __m128 va = _mm_loadu_ps(a);         // 载入 4 个 float
    __m128 vb = _mm_loadu_ps(b);
    __m128 vc = _mm_add_ps(va, vb);      // 一次算 4 个加法
    _mm_storeu_ps(c, vc);                // 存回
}

// AVX：一次加 8 个 float
void add8_avx(float* a, float* b, float* c) {
    __m256 va = _mm256_loadu_ps(a);
    __m256 vb = _mm256_loadu_ps(b);
    __m256 vc = _mm256_add_ps(va, vb);
    _mm256_storeu_ps(c, vc);
}

#include <Eigen/Dense>
// Eigen 内部自动使用 SSE/AVX，写普通表达式即可
Eigen::Vector4f a, b, c;
c = a + b;   // 底层自动向量化

// 有序数据：分支预测几乎全中，快
for (int i = 0; i < n; ++i)
    if (data[i] > threshold) sum += data[i];

// 无序数据：预测随机命中约 50%，频繁冲刷流水线，慢数倍
for (int i = 0; i < n; ++i)
    if (shuffled[i] > threshold) sum += shuffled[i];

#define likely(x)   __builtin_expect(!!(x), 1)   // 大概率成立
#define unlikely(x) __builtin_expect(!!(x), 0)   // 小概率成立

if (unlikely(error)) {        // 告诉编译器 error 很少发生
    handleError();            // 冷路径放到远处，提升热路径局部性
}
if (likely(normal_case)) {
    fastPath();
}

// 有分支
int x = (cond) ? a : b;

// 无分支：位运算/算术替代，避免预测失败
int x = b ^ ((a ^ b) & -cond);        // cond 为 0/1 时选择 a/b

// 依赖链长：每个加法等上一个结果
int sum = 0;
for (int i = 0; i < n; ++i) sum += a[i];

// 多累加器：4 条独立依赖链并行，隐藏延迟
int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
for (int i = 0; i < n; i += 4) {
    s0 += a[i]; s1 += a[i+1]; s2 += a[i+2]; s3 += a[i+3];
}
int sum = (s0 + s1) + (s2 + s3);