C++对象切片：机制、应用场景与规避策略

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

class Derived : public Base {
public:
    int derived_data;
    void func() override { cout << "Derived" << endl; }
};

Derived d;
Base b = d;  // 切片发生：derived_data丢失，vptr重新绑定到Base的vtable

Derived对象内存布局：
[Base子对象][derived_data]
  ↓ 切片复制 ↑
Base对象内存布局：
[Base子对象]

class ConfigBase {
public:
    virtual std::string serialize() const = 0;
    virtual ~ConfigBase() = default;
    
    // 显式切片接口：获取基类值语义副本
    ConfigBase getBaseCopy() const {
        return *this;  //  intentional slicing
    }
};

class AdvancedConfig : public ConfigBase {
    std::unordered_map<std::string, std::string> extended_params;
public:
    std::string serialize() const override {
        // 复杂序列化逻辑
        return "advanced_config";
    }
};

void processConfig(ConfigBase config) {
    // 确定性地使用基类接口，不依赖多态
    auto serialized = config.serialize();  // 总是调用Base::serialize()
}

class DataPacket {
public:
    virtual std::vector<uint8_t> getCanonicalForm() const {
        return normalizeData(raw_data);
    }
protected:
    std::vector<uint8_t> raw_data;
};

class EncryptedPacket : public DataPacket {
    EncryptionMetadata meta;
public:
    std::vector<uint8_t> getCanonicalForm() const override {
        auto decrypted = decrypt(raw_data, meta);
        return normalizeData(decrypted);
    }
};

// 数据规范化管道：显式切片去除加密相关数据
std::vector<DataPacket> createNormalizedPipeline(
    const std::vector<DataPacket*>& packets) {
    
    std::vector<DataPacket> result;
    for (auto packet : packets) {
        result.push_back(*packet);  //  intentional slicing
    }
    return result;  // 所有包都转换为标准格式
}

class ResourceHandle {
public:
    virtual void release() { /* 基础资源释放 */ }
};

class ExtendedResourceHandle : public ResourceHandle {
    std::shared_ptr<AuxiliaryResource> aux_resource;
public:
    void release() override {
        ResourceHandle::release();
        aux_resource.reset();
    }
};

// 显式切片确保只释放基础资源
void safeReleaseBaseOnly(ResourceHandle handle) {
    handle.release();  // 只调用Base::release()
    // aux_resource不会被影响
}

template<typename T>
struct BaseTypeExtractor {
    using type = typename std::remove_reference<
                 typename std::remove_cv<T>::type>::type;
    
    static type extract(const T& obj) {
        return obj;  //  intentional slicing for type extraction
    }
};

// 使用示例
ExtendedResourceHandle ext_handle;
auto base_traits = BaseTypeExtractor<ExtendedResourceHandle>::extract(ext_handle);

std::vector<Base> objects;
objects.push_back(Derived());  // 切片发生
objects[0].func();  // 调用Base::func()，而不是Derived::func()

class ResourceOwner {
public:
    std::unique_ptr<Resource> resource;
    ~ResourceOwner() { /* 可能重复释放资源 */ }
};

class DerivedOwner : public ResourceOwner {
    std::unique_ptr<AnotherResource> another;
};

DerivedOwner derived;
ResourceOwner base = derived;  // 切片：another丢失，可能资源泄漏

std::vector<std::unique_ptr<Base>> polymorphic_objects;
polymorphic_objects.push_back(std::make_unique<Derived>());
polymorphic_objects[0]->func();  // 正确调用Derived::func()

using PolymorphicVariant = std::variant<Base, Derived, AnotherDerived>;

std::vector<PolymorphicVariant> objects;
objects.emplace_back(Derived{});

std::visit([](auto&& obj) {
    obj.func();  // 保持正确的多态行为
}, objects[0]);

class Cloneable {
public:
    virtual std::unique_ptr<Cloneable> clone() const = 0;
    virtual ~Cloneable() = default;
};

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

template<typename Derived>
class BaseCRTP {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class DerivedCRTP : public BaseCRTP<DerivedCRTP> {
public:
    void implementation() { /* 具体实现 */ }
};