特殊工具与技术

#include <new>
 
// operator new——只分配原始字节，不构造对象
void* raw = ::operator new(sizeof(std::string));
 
// placement new——在 raw 地址上构造一个 string
std::string* s = new (raw) std::string("hello");
 
// 用完：必须先析构再释放
s->~string();               // 显式调析构——释放 string 管理的堆内存::
operator delete(raw);     // 释放原始字节

#include <typeinfo>
 
Base* bp = new DerivedA();
if (typeid(*bp) == typeid(DerivedA))
    std::cout << "bp really points to DerivedA\n";
// typeid(*bp)——解引用查动态类型（需要虚函数）
// typeid(bp)——不查动态类型，只返回 Base*

Base* bp = new DerivedB();
 
// 指针版：失败返回 nullptr
auto* db = dynamic_cast<DerivedB*>(bp);
if (db) db->derivedOnlyMethod();  // 安全——转换成功才调用
 
// 引用版：失败抛 std::bad_cast
try {
    DerivedB& ref = dynamic_cast<DerivedB&>(*bp);
    ref.derivedOnlyMethod();
} catch (const std::bad_cast&) {
    // 转换失败——处理异常
}

// 传统 enum：成员暴露、可隐式转 int
enum TraditionalColor { Red, Green, Blue };
int c = Red;          // 编译通过——Red 隐式转 0
// enum 不加 class 直接在当前作用域创建 Red/Green/Blue——两个枚举有同名成员会撞
 
// enum class：限定作用域、不能隐式转换
enum class SafeColor { Red, Green, Blue };
auto sc = SafeColor::Red;          // "Red" 在 SafeColor 作用域内——不污染全局
int x = static_cast<int>(sc);      // 转整数必须显式写——不写就编译报错

enum class Permission : uint8_t { Read = 1, Write = 2, Exec = 4 };
// sizeof(Permission) == 1——省内存
// 前置声明：enum class Permission : uint8_t;——可在头文件中只声明不定义

union IntOrDouble {
    int i;
    double d;
};
// sizeof(IntOrDouble) == sizeof(double) == 8（兼容最大的成员）
// i 和 d 从同一个地址开始——写入 i 后再读 d 得到的是覆盖后的垃圾值
 
IntOrDouble u;
u.i = 42;      // 活跃成员是 i
u.d = 3.14;    // 活跃成员变成 d——i 的值被覆盖
// std::cout << u.i;  // 未定义行为！读的不是活跃成员

class Token {
    enum class Tag { INT, DOUBLE, STRING } tag;
    union {
        int i;
        double d;
        std::string s;  // C++11: union 可以有非平凡成员
    };
public:
    Token(int v) : tag(Tag::INT) { new (&i) int(v); }
    Token(const std::string& v) : tag(Tag::STRING) { new (&s) std::string(v); }
    ~Token() {
        if (tag == Tag::STRING) s.std::string::~string();  // 只析构 string
        // int 和 double 是 trivial 类型——无需析构
    }
    Token(const Token&) = delete;  // 简化为不可拷贝——实际产品需实现深拷贝
};

struct Widget {
    int value;
    void show() const { std::cout << value << '\n'; }
};
 
// 声明成员指针——不指定具体对象
int Widget::*pValue = &Widget::value;           // 数据成员指针
void (Widget::*pShow)() const = &Widget::show;   // 成员函数指针
 
Widget w{42};
w.*pValue = 100;      // 通过对象使用数据成员指针
(w.*pShow)();          // 通过对象调用成员函数——输出 100
 
Widget* pw = &w;
pw->*pValue = 200;    // 通过指针使用——->* 操作符
(pw->*pShow)();       // 输出 200

#include <map>
#include <string>
 
class Menu {
    using Action = void (Menu::*)();
    std::map<std::string, Action> actions;
public:
    void add(const std::string& name, Action act) { actions[name] = act; }
    void invoke(const std::string& name) {
        auto it = actions.find(name);
        if (it != actions.end()) (this->*(it->second))();
    }
    void save()  { std::cout << "save\n"; }
    void load()  { std::cout << "load\n"; }
};
// Menu m; m.add("save", &Menu::save); m.invoke("save");

class BinaryTree {
    struct Node {                    // 嵌套类——外部不可见
        int data;
        Node* left = nullptr;
        Node* right = nullptr;
        Node(int v) : data(v) {}
    };
    Node* root = nullptr;
public:
    void insert(int v) { /* 用 Node 构建树 */ }
    bool find(int v) const { /* 在树中查找 */ }
};
// 外部代码完全不知道 Node 的存在——只能通过 BinaryTree 的接口操作

int count_long_names(const std::vector<std::string> &names) {
    class LongerThan {
        std::size_t limit_;
    public:
        explicit LongerThan(std::size_t n) : limit_(n) {}
        bool operator()(const std::string &s) const {
            return s.size() > limit_;
        }
    } predicate(8);
    return std::count_if(names.begin(), names.end(), predicate);
}

struct DeviceFlags {
    unsigned ready : 1;
    unsigned mode  : 3;
    unsigned error : 1;
};
// sizeof、位的左右顺序和填充都不能据此跨平台推断

#include <string>
#include <new>      // placement new
#include <typeinfo>  // RTTI
#include <stdexcept>
 
class TaggedPointer {
    enum class Type { NONE, INT, DOUBLE, STRING } tag_ = Type::NONE;
    union Data {
        int i;
        double d;
        std::string s;
        // C++11: union 可以有非平凡成员——但要手动管理生命周期
        Data() {}   // union 含非平凡成员（string）时——必须自己声明构造/析构
        ~Data() {}  // 否则 union 的构造/析构被隐式删除，外层类无法编译
    } data_;

public:
    TaggedPointer(int v) : tag_(Type::INT)    { new (&data_.i) int(v); }
    TaggedPointer(double v) : tag_(Type::DOUBLE) { new (&data_.d) double(v); }
    TaggedPointer(const std::string& v) : tag_(Type::STRING) {
        new (&data_.s) std::string(v);  // placement new 构造 string
    }
 
    ~TaggedPointer() {
        if (tag_ == Type::STRING) data_.s.std::string::~string();
        // int 和 double 是 trivial 类型——不需要显式析构
    }

    const std::type_info& type() const {
        switch (tag_) {
            case Type::INT:    return typeid(data_.i);
            case Type::DOUBLE: return typeid(data_.d);
            case Type::STRING: return typeid(data_.s);
            default:           return typeid(void);
        }
    }
 
    int& get_int() {
        if (tag_ != Type::INT) throw std::bad_cast();
        return data_.i;
    }
    double& get_double() {
        if (tag_ != Type::DOUBLE) throw std::bad_cast();
        return data_.d;
    }
    std::string& get_string() {
        if (tag_ != Type::STRING) throw std::bad_cast();
        return data_.s;
    }
};

TaggedPointer tp(42);
std::cout << tp.type().name() << '\n';     // "int"（或编译器特定格式）
std::cout << tp.get_int() << '\n';         // 42——安全，tag 匹配
 
// 另建一个存 string 的对象——本类未实现拷贝/移动赋值，不能写 tp = ...
TaggedPointer tp2(std::string("hello"));   // 直接构造一个存 string 的对象
std::cout << tp2.get_string() << '\n';     // "hello"
// tp2.get_int();  // 抛出 bad_cast——tp2 当前存的是 string 不是 int