我可以通过模板C++将一个对象传递给一个类吗？

我可以这样做吗：

class A
{
    public:
    void print()
    {
         std::cout<<"A"<<std::endl;
    }
};

class B
{
    public:
    void print()
    {
         std::cout<<"B"<<std::endl;
    }
};

template <class T>
class C 
{
     public:
     void say()
     {
          T.print();
     }
};

int main()
{
     A a;
     B b;
     C<a> c;
     c.say();
     C<b> d;
     d.say();

     return 0;
 }

如果我不想为a和B使用基类，那么最好的快速运行方式是什么？

其中t是类型t.print；是无效的C++。 相反，您有以下选项：

如果将“打印”设置为静态方法，则可以执行以下操作：

如果print方法不需要任何状态，那么这可能是一个好方法。它只不过是一个直接的、可能是内联的函数调用。因此，性能问题的范围不大

否则，您必须传递对象：

对于如何传递对象，有一些选项。假设T不是引用/指针类型或按引用。根据具体情况，这些可能对性能有影响，也可能没有影响

或者在say方法中创建一个实例：

对于简单的情况，这可能会优化，使其与静态打印方法的情况基本相同。当然，对于不太常见的情况，构造T可能会有潜在的成本。

其中T是T型打印；是无效的C++。 相反，您有以下选项：

如果将“打印”设置为静态方法，则可以执行以下操作：

如果print方法不需要任何状态，那么这可能是一个好方法。它只不过是一个直接的、可能是内联的函数调用。因此，性能问题的范围不大

否则，您必须传递对象：

对于如何传递对象，有一些选项。假设T不是引用/指针类型或按引用。根据具体情况，这些可能对性能有影响，也可能没有影响

或者在say方法中创建一个实例：

---

对于简单的情况，这可能会优化，使其与静态打印方法的情况基本相同。当然，对于不那么琐碎的情况，构造T可能会有潜在的成本。

您的代码存在多方面的问题

您似乎将类型与实例、类和对象混为一谈

这段代码实际上应该按照预期编译和工作

#include <iostream>

class A
{
    public:
    void print()
    {
         std::cout<<"A"<<std::endl;
     }
};

class B
{
    public:
    void print()
    {
         std::cout<<"B"<<std::endl;
     }
};

template <class T>
class C 
{
     public:
     void say(T obj)
     {
          obj.print();
          // If T::print() were static, you could call it like that instead.
     }
};

int main()
{
     A a;
     B b;
     C<A> c; // template for C demands a class, not an object!
             // in practice this would mean you write 'A' instead of 'a' here
     c.say(a);
     C<B> d; // same here
     d.say(b);
}

---

您的代码有多处错误

您似乎将类型与实例、类和对象混为一谈

这段代码实际上应该按照预期编译和工作

#include <iostream>

class A
{
    public:
    void print()
    {
         std::cout<<"A"<<std::endl;
     }
};

class B
{
    public:
    void print()
    {
         std::cout<<"B"<<std::endl;
     }
};

template <class T>
class C 
{
     public:
     void say(T obj)
     {
          obj.print();
          // If T::print() were static, you could call it like that instead.
     }
};

int main()
{
     A a;
     B b;
     C<A> c; // template for C demands a class, not an object!
             // in practice this would mean you write 'A' instead of 'a' here
     c.say(a);
     C<B> d; // same here
     d.say(b);
}

---

起初，您忘记了类声明后面的分号，而且main不返回整数。所以假设这是固定的，那里只有少量的代码，这仍然是错误的，但会产生巨大的影响。您混淆了运行时和编译时

但是如果没有实例，就不能调用非静态函数！因此，您有一些可能修复此问题。取一个T型引用并从中调用，如下所示：

void print(T& t)
{ t.print(); }

或者简单地说，如果可以，请执行以下操作：

void print()
{ T().print(); }

或者使A和B的打印功能都是静态的！ 试试看

---

顺便说一句，无论您做什么，如果您决定不将其设为静态，请将其设为const函数和noexcept，因为它从不抛出实例，也不会对实例进行任何更改。

开始时，您忘记了类声明后面的分号，而且main不会返回整数。所以假设这是固定的，那里只有少量的代码，这仍然是错误的，但会产生巨大的影响。您混淆了运行时和编译时

但是如果没有实例，就不能调用非静态函数！因此，您有一些可能修复此问题。取一个T型引用并从中调用，如下所示：

void print(T& t)
{ t.print(); }

或者简单地说，如果可以，请执行以下操作：

void print()
{ T().print(); }

或者使A和B的打印功能都是静态的！ 试试看

---

顺便说一下，无论您做什么，如果您决定不将其设为静态，请将其设为const函数和noexcept，因为它从不抛出实例，也不会对实例进行任何更改。

您必须使用T.print创建实例。你也可以只做C:：比如说一个模板函数，而不是整个类。入口点必须返回print，而且你忘记了类后面的分号。然而，您似乎混淆了编译时和运行时。您必须使用T.print来创建实例。你也可以只做C:：比如说一个模板函数，而不是整个类。入口点必须返回print，而且你忘记了类后面的分号。然而，您似乎混淆了编译时和运行时。

void print()
{ T.print(); }

void print(T& t)
{ t.print(); }

void print()
{ T().print(); }