《C++ Templates: The Complete Guide》第七章 模板和继承

在《C++ Templates: The Complete Guide》这本书中，继承和多态性是C++编程中的重要概念。下面是一个简单的例子来说明继承和多态性的用法：

#include <iostream>

// 基类 Shape
class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a Shape." << std::endl;
    }
};

// 派生类 Circle
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle." << std::endl;
    }
};

// 派生类 Rectangle
class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Rectangle." << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Rectangle();

    shape1->draw();  // 调用 Circle 类的 draw() 函数
    shape2->draw();  // 调用 Rectangle 类的 draw() 函数

    delete shape1;
    delete shape2;

    return 0;
}
           

在上面的例子中，我们定义了一个基类 Shape 和两个派生类 Circle 和 Rectangle。基类 Shape 中有一个虚函数 draw()，并且在派生类中进行了重写。

在 main() 函数中，我们创建了两个指向基类对象的指针 shape1 和 shape2，并分别使用 new 运算符将它们指向派生类的对象。

当我们调用 shape1->draw() 和 shape2->draw() 时，由于这两个指针是指向派生类对象的，所以会根据对象的实际类型来调用相应的 draw() 函数。这就是多态性的体现，即同一个函数在不同的对象上表现出不同的行为。

在上述例子中，shape1->draw() 调用了 Circle 类的 draw() 函数，输出了 "Drawing a Circle."；shape2->draw() 调用了 Rectangle 类的 draw() 函数，输出了 "Drawing a Rectangle."。

这个例子展示了继承和多态性在C++中的基本用法，通过继承可以创建派生类，并且通过虚函数的重写实现多态性，使得相同的函数调用可以表现出不同的行为。这在面向对象的程序设计中非常有用。

《C++ Templates: The Complete Guide》是一本关于C++模板的权威指南，提供了详细的介绍和示例。下面是关于基类模板和派生类模板的一些示例：

1. 基类模板（Base Class Templates）示例：

template <typename T>
class Base {
public:
    Base(T value) : data(value) {}
    void print() {
        std::cout << "Base: " << data << std::endl;
    }
private:
    T data;
};

// 使用基类模板创建对象
Base<int> baseInt(10);
baseInt.print();  // 输出：Base: 10

Base<std::string> baseString("Hello");
baseString.print();  // 输出：Base: Hello
           

在这个示例中，Base 是一个模板类，它有一个模板参数 T，表示基类的数据类型。我们可以使用不同的类型实例化 Base 类，并调用 print 函数来打印基类的数据。

1. 派生类模板（Derived Class Templates）示例：

template <typename T>
class Derived : public Base<T> {
public:
    Derived(T value) : Base<T>(value) {}
    void print() {
        std::cout << "Derived: " << this->data << std::endl;
    }
};

// 使用派生类模板创建对象
Derived<int> derivedInt(20);
derivedInt.print();  // 输出：Derived: 20

Derived<std::string> derivedString("World");
derivedString.print();  // 输出：Derived: World
           

在这个示例中，Derived 是一个派生类模板，它继承自 Base<T>。我们可以使用不同的类型实例化 Derived 类，并调用 print 函数来打印派生类的数据。注意，在派生类中，我们使用 this->data 来访问基类的数据。

这些示例展示了基类模板和派生类模板的基本用法，你可以根据自己的需要扩展和修改这些代码。请注意，这只是一个简单的示例，实际使用中可能涉及更多的模板特性和技巧。

《C++ Templates: The Complete Guide》是一本关于C++模板的权威指南，它详细介绍了模板的各个方面。在书中，作者讨论了模板类的继承关系，并给出了一些示例。

在C++中，模板类可以通过继承来扩展和特化。下面是一个简单的示例，展示了模板类的继承关系：

template <typename T>
class Base {
public:
    void foo() {
        std::cout << "Base foo" << std::endl;
    }
};

template <typename T>
class Derived : public Base<T> {
public:
    void bar() {
        std::cout << "Derived bar" << std::endl;
    }
};

int main() {
    Derived<int> d;
    d.foo(); // 调用Base类的foo函数
    d.bar(); // 调用Derived类的bar函数
    
    return 0;
}
           

在上面的示例中，Base是一个模板类，它有一个foo函数。Derived也是一个模板类，它通过继承Base类来扩展功能，并添加了一个bar函数。

在main函数中，我们创建了一个Derived<int>的对象d。我们可以调用d的foo函数和bar函数，分别会输出"Base foo"和"Derived bar"。

这个示例展示了模板类的继承关系，通过继承，派生类可以继承基类的成员函数和数据，并且可以添加自己的新成员函数和数据。这样可以在不改变基类的情况下，对模板类进行扩展和特化