非多态继承对性能/内存使用有影响吗？

Question

我很好奇非多态类中继承的影响。具体来说，我正在编写两个智能指针类，都没有虚拟方法，并且都用于非常独特的目的。由于基本的运算符重载和一些标准函数是相同的，并且它们只需要一个成员变量，我想我可以使用基类来重用代码。这是我的意思的一个简单的模型：

基类：

template <class T>
class Pointer_Impl
{
public:
    T & operator*() { return this->*m_pointer; }
    // etc.
protected:
    T *m_pointer;
    //protected to prevent instantiation without using = delete
    Pointer_Impl() {}
    Pointer_Impl(T *) {}
    //other constructors, assignment and move operators, destructor here
};

然后：

template <class T>
class PointerA : public Pointer_Impl<T>
{
public:
    PointerA() { m_pointer = nullptr; }
    PointerA(T * obj) { m_pointer = obj; }
    // other constructors, assignment and move operators, destructor, and any other class-specific functions here
};

问题：从缺少任何虚方法的基类派生是否存在内存或性能开销？因为它是一个智能指针实现，所以我想要的是精益求精。

我的直觉说不，不用担心，但我想从更聪明的头脑中确定。

Answer 1

没有任何形式的运行时性能损失（如果优化。显然调试版本可能会存储一些有关继承的数据）。

作为证据，观察以下程序的输出

程序1：

template <class T>
class PointerA
{
public:
    PointerA(T * obj) : m_pointer(obj) {}
    T & operator*() { return *this->m_pointer; }
    T *m_pointer;
};

程序2：

template <class T>
class Pointer_Impl
{
public:
    T & operator*() { return *this->m_pointer; }
protected:
    T *m_pointer;
    Pointer_Impl(T *) {}
};

template <class T>
class PointerA : public Pointer_Impl<T>
{
public:
    PointerA(T * obj) : Pointer_Impl<T>(obj) {}
};

常见的主要：

int main() {
    PointerA<int> p(new int);
    volatile int i = 42;
    *p = i;
    i = *p;
}

两者都产生相同的程序集：

main:
        subq    $24, %rsp
        movl    $4, %edi
        call    operator new(unsigned long)
        movl    $42, 12(%rsp)
        movl    12(%rsp), %eax
        movl    %eax, 12(%rsp)
        movl    $0, %eax
        addq    $24, %rsp
        ret

Answer 2

性能影响

没有。如果没有virtual（虚拟继承或虚拟函数），您不会因使用基类而招致任何运行时惩罚。名称解析完全在编译时使用静态类型执行。

内存影响

没有。在没有virtual 的情况下，继承的类与直接具有相同字段作为成员的类之间没有有意义的区别。如果您有多个基类或virtual（继承或函数），这一切都会改变。

编译影响

编译时间可能会有一些影响；编译器将不得不跟踪更多的名称和模板实例。这有时是大型、大量模板代码库的问题。

Answer 3

您的子类的构造函数表明该子类至少包含一个其他成员 m_object，但您没有显示。

在没有任何虚拟方法的情况下，在运行时，由超类和子类组成的对象与由单个类组成的具有典型 C++ 实现的对象之间没有区别。毕竟，创建子类最终会创建一个新类。因此，包含基类和子类的所有成员的单个类在运行时与单个类没有区别，只要所有类成员相同，按相同顺序排列，并且不涉及虚拟继承。

当然，编译器必须做更多的工作来跟踪超类和子类，所以编译器可能需要做一些额外的工作，跟踪两个单独的类，而不是之一。但除非代码库很大，否则我怀疑性能差异是否可以衡量。