C++ 对待实例化模板 class 与非模板类型有什么不同吗？

Question

When using virtual functions it is often convenient to use a single class template for both the base class and all derived classes. My question is: are classes defined this way treated any differently by the C++ compiler from the same classes defined without templates?

Here is an example of some classes created using templates:

template <typename T=void> struct Adder;

template <> struct Adder <void>
{
    virtual double add(double a, double b)
    {
        return (a+b);
    }
};

template <typename T> struct Adder : Adder <void>
{
    virtual double add(double a, double b)
    {
        return ((T)a+(T)b);
    }
};

    
using AdderBase   = Adder <void>;
using AdderInt    = Adder <int>;
using AdderFloat  = Adder <float>;
using AdderDouble = Adder <double>;

int main(int argc, char* argv[])
{
    AdderBase* addI = new AdderInt;
    AdderBase* addF = new AdderFloat;
    AdderBase* addD = new AdderDouble;

    printf("addI = %18.1f\n", addI->add(11111111111111111.0, 1.0));
    printf("addF = %18.1f\n", addF->add(11111111111111111.0, 1.0));
    printf("addD = %18.1f\n", addD->add(11111111111111111.0, 1.0));
}

And here is an example of classes with the same functionality created without templates:

struct AdderBase
{
    virtual double add(double a, double b)
    {
        return (a+b);
    }
};

struct AdderInt : AdderBase
{
    virtual double add(double a, double b)
    {
        return ((int)a+(int)b);
    }
};

struct AdderFloat : AdderBase
{
    virtual double add(double a, double b)
    {
        return ((float)a+(float)b);
    }
};

struct AdderDouble : AdderBase
{
    virtual double add(double a, double b)
    {
        return ((double)a+(double)b);
    }
};

Does the compiler treat the classes AdderBase, AdderInt, AdderFloat or AdderDouble differently when they are defined in these two different ways?

An example of a difference might be a different order for overload resolution when the class is used as a parameter in an overloaded function.

Answer 1

The short answer is no.

In particular, I'd expect any reasonable compiler to generate identical code when you used either of your implementations of (say) AdderFloat . In fact, even well before the code generator starts looking at the code, both are doing to be reduced to identical intermediate representations.

There are cases where you can get different code from a template, but most often that's when you know there's a shortcut for some particular type, and write a specialization to let the compiler take advantage of that shortcut for that particular type.