C++中定义了一个模板类A，之后在模板类B中使用A的例子

假设模板类A的定义如下：

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

模板类B中使用模板类A的例子如下：

template <typename T>
class B {
private:
    A<T> a; // 在B中定义一个A类对象
public:
    void print(T value) {
        std::cout << "B: " << value << std::endl;

        // 调用A类对象a中的print方法
        a.print(value);
    }
};

可以看出，模板类B中定义了一个A类对象a，并在其成员函数print中调用了a的print方法。在使用模板类B时，需要指定T的类型，例如：

B<int> b;
b.print(123);

在这个例子中，我们使用了int类型来实例化B类和A类。

相关问题

C++的模板 类 使用例子

当定义一个模板类时，我们可以使用不同的数据类型来实例化该模板类。以下是一个使用C++模板类的示例：

#include <iostream>

// 定义一个模板类
template <typename T>
class TemplateClass {
public:
    TemplateClass(T value) : data(value) {}

    void print() {
        std::cout << "Value: " << data << std::endl;
    }

private:
    T data;
};

int main() {
    // 实例化模板类，分别使用不同的数据类型
    TemplateClass<int> obj1(10);
    TemplateClass<double> obj2(3.14);
    TemplateClass<std::string> obj3("Hello");

    // 调用模板类的成员函数
    obj1.print();
    obj2.print();
    obj3.print();

    return 0;
}

在上面的示例中，我们定义了一个模板类`TemplateClass`，它包含一个成员变量`data`和一个成员函数`print()`。我们可以使用不同的数据类型来实例化该模板类。

在`main()`函数中，我们分别实例化了`TemplateClass`为`TemplateClass<int>`、`TemplateClass<double>`和`TemplateClass<std::string>`，并分别传递不同类型的值作为构造函数的参数。

然后，我们通过调用`print()`函数来打印每个实例化对象的值。

输出结果将是：

Value: 10
Value: 3.14
Value: Hello

这个例子展示了如何使用模板类来处理不同类型的数据，并且在每个实例化对象中保留了相应的数据类型。

C++中模板嵌套定义的例子

以下是一个简单的模板嵌套定义的示例：

template <typename T>
class Outer {
public:
    template <typename U>
    class Inner {
    public:
        void display(T t, U u) {
            std::cout << "Outer type: " << typeid(t).name() << std::endl;
            std::cout << "Inner type: " << typeid(u).name() << std::endl;
        }
    };
};

int main() {
    Outer<int>::Inner<double> obj;
    obj.display(10, 3.14);
    return 0;
}

在这个例子中，`Outer` 类中定义了一个嵌套的 `Inner` 类。`Inner` 类可以使用 `T` 和 `U` 两个模板参数，其中 `T` 是 `Outer` 类的模板参数，而 `U` 是 `Inner` 类自己的模板参数。在 `display` 函数中，我们可以访问 `T` 和 `U` 参数，并将它们打印出来。在 `main` 函数中，我们实例化了 `Outer<int>::Inner<double>` 类型的对象，并调用了它的 `display` 函数。