学懂C++（五十）：深入详解 C++ 陷阱：对象切片（Object Slicing）

对象切片基本概念

什么是对象切片？

对象切片（Object Slicing）是 C++ 中的一个常见陷阱，发生在将派生类对象赋值给基类对象时。由于基类对象无法存储派生类特有的数据和行为，因此派生类对象的特有部分会被“切掉”，只保留基类部分。

为什么会发生对象切片？

        对象切片发生的原因在于 C++ 的赋值操作是基于值语义的。当你将一个派生类对象赋值给一个基类对象时，实际上是创建了一个新的基类对象，而这个新的基类对象只能包含基类的成员变量和方法。因此，派生类对象的特有部分（即派生类独有的数据和方法）就会被丢弃，这就是对象切片。

示例代码

让我们通过一个具体的例子来深入理解对象切片。

#include <iostream>

//基类
class Base {
public:
    Base(int a): a_(a) {}
    virtual void show() const {
        std::cout << "Base class, a: " << a_ << std::endl;
    }
private:
    int a_;
};

//派生类
class Derived : public Base {
public:
    Derived(int a, int b): Base(a), b_(b) {}
    virtual void show() const override {
        Base::show();
        std::cout << "Derived class, b: " << b_ << std::endl;
    }
private:
    int b_;
};

int main() {
    Derived d(5, 10);
    Base b = d; // 对象切片，b_ 被“切掉”
    b.show();   // 只调用 Base 类的 show()，不会显示 b_
    return 0;
}

 运行结果

Base class, a: 5

如上所示，派生类的 show() 方法没有被调用，派生类对象的成员变量 b_ 也没有被显示。这是因为 b 是 Base 类型的对象，无法存储 Derived 类型的特有部分。对象切片发生在将派生类对象 d 赋值给基类对象 b 时，导致派生类对象的特有数据 b_ 被丢弃。

如何避免对象切片？

有多种方法可以避免对象切片，以下是几种常见的方法。

1. 使用指针或引用

使用指针或引用可以避免对象切片，因为它们不会创建基类对象的副本。这种方法确保派生类的特有部分不会被“切掉”。

int main() {
    Derived d(5, 10);
    Base* pb = &d; // 使用指针
    pb->show();   // 调用 Derived 类的 show() 方法

    Base& rb = d; // 使用引用
    rb.show();    // 调用 Derived 类的 show() 方法
    return 0;
}

运行结果

Base class, a: 5
Derived class, b: 10
Base class, a: 5
Derived class, b: 10

在这段代码中，pb 和 rb 分别是指向 d 的指针和引用。通过它们调用 show() 方法时，会根据虚函数机制动态绑定到 Derived 类的 show() 方法。

2. 使用多态和虚函数

确保基类中的方法是虚函数，这样即使通过基类指针或引用调用方法，也能动态绑定到派生类的实现。注意：虚函数不能避免对象切片，只能保证在使用指针或引用时实现多态行为。

class Base {
public:
    Base(int a): a_(a) {}
    virtual void show() const {  // 使用 virtual 关键字
        std::cout << "Base class, a: " << a_ << std::endl;
    }
    virtual ~Base() {} // 确保基类有虚析构函数
private:
    int a_;
};

class Derived : public Base {
public:
    Derived(int a, int b): Base(a), b_(b) {}
    virtual void show() const override {
        Base::show();
        std::cout << "Derived class, b: " << b_ << std::endl;
    }
private:
    int b_;
};

int main() {
    Derived d(5, 10);
    Base b = d; // 对象切片仍然发生
    b.show();   // 只调用 Base 类的 show()，不会显示 b_

    Base* pb = &d; // 使用指针
    pb->show();   // 调用 Derived 类的 show() 方法

    Base& rb = d; // 使用引用
    rb.show();    // 调用 Derived 类的 show() 方法
    return 0;
}

 运行结果

Base class, a: 5
Base class, a: 5
Derived class, b: 10
Base class, a: 5
Derived class, b: 10

这里，第一行结果来自于对象切片操作，仅调用了 Base 类的 show() 方法，而没有显示派生类的特有数据 b_。后续使用指针或引用来调用 show() 方法时，动态多态性确保了调用 Derived 类的 show() 方法。

3. 使用智能指针

使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理动态分配的对象，可以有效避免对象切片，同时更好地管理内存。

#include <memory>
#include <iostream>

class Base {
public:
	Base(int a) : a_(a) {}
	virtual void show() const {
		std::cout << "Base class, a: " << a_ << std::endl;
	}
private:
	int a_;
};

class Derived : public Base {
public:
	Derived(int a, int b) : Base(a), b_(b) {}
	virtual void show() const override {
		Base::show();
		std::cout << "Derived class, b: " << b_ << std::endl;
	}
private:
	int b_;
};

int main() {
	std::unique_ptr<Base> pb = std::make_unique<Derived>(5, 10); // 使用智能指针管理动态分配的对象
	pb->show(); // 调用 Derived 类的 show() 方法

	std::shared_ptr<Base> spb = std::make_shared<Derived>(5, 10); // 使用智能指针
	spb->show(); // 调用 Derived 类的 show() 方法
	return 0;
}

运行结果

Base class, a: 5
Derived class, b: 10
Base class, a: 5
Derived class, b: 10

此例中，pb 和 spb 是指向 Derived 类型对象的智能指针，因此调用了 Derived 类的 show() 方法，避免了对象切片。

总结

        对象切片是 C++ 中一个常见而隐蔽的陷阱，发生在将派生类对象按值赋给基类对象时。由于基类对象无法存储派生类的特有部分，这些特有数据和行为将会被丢弃。要避免对象切片，可以使用指针或引用来管理对象，或者使用智能指针来处理动态分配的对象。此外，通过使用虚函数，可以确保基类指针或引用的多态性行为，但这并不能避免对象切片本身。

        理解和避免对象切片是编写高质量 C++ 代码的关键。掌握这些技术和概念不仅可以提高代码的健壮性，还能使程序更具有扩展性和维护性，避免由于对象切片带来的各种潜在问题。