Question

我可以这样做：

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使用基类，那么这种方法的最佳方式（快速运行速度）是什么？

Answer 1

您的代码存在多处问题。

您似乎将类型与实例（或类和对象）混合在一起。

此代码实际上应该按预期编译和工作。

#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);
}

Answer 2

T类型T.print();的类型无效C ++。相反，您有以下选择：

如果您使print成为静态方法，则可以执行以下操作：

void say()
{
     T::print();
}

如果print方法不需要任何状态，这可能是一条好路线。它只不过是一个直接（可能是内联的）函数调用。所以性能问题的范围不大。

否则您必须传递对象 ：

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

如何传递对象有一些选项。是否按上述值（假设T不是引用/指针类型）或通过引用。根据具体情况，这些可能会对性能产生影响，也可能没有影响。

或在say方法中创建实例：

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

对于简单的情况，这可能会优化为与静态print方法情况基本相同。虽然构建一个T当然对于不那么微不足道的案件来说可能是昂贵的。

Answer 3

首先你忘记了类声明后面的分号，不知何故你的main不返回整数。所以假设那里修复了那里只有少量的代码，这仍然是错误的，但是影响很大。你混淆了运行时间和编译时间。

 A a;
 B b;
 C<a> c;
 C<b> d;

您尝试使用非const实例作为模板参数，这没有任何意义。它将在运行时创建，但在编译时你不知道那些。模板参数不采用非const值，大多数情况下它只是采用类型，就像在代码中一样。 template<class T>或template<typename T>期待某种类型，而不是某种事物的实例。但是，您可以通过执行template<A myConstA>之类的操作来接收实例。无论如何你需要重写它，以便它接收类型，因为它在编译时是已知的。

A a;
B b;

//you can do C<decltype(a)>, too
C<A> c;
C<B> d;

你有这样的打印功能：

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

但是如果没有实例，你就无法调用非静态函数！因此，您有一些可能来解决这个问题。要么引用T类型的引用并从中调用，如下所示：

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

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

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

或将print和A的{{1}}函数设为静态！试试吧online！

顺便说一句，无论你做什么，如果你决定不使它成为静态的，那就把它变成B函数和const，因为它永远不会抛出，也不会对实例做任何改变。

我可以通过模板c ++将对象传递给类

3 个答案: