Is there a performance/memory usage impact in non-polymorphic inheritance?

Question

I'm curious about the impact of inheritance in non-polymorphic classes. Specifically, I am writing two smart pointer classes, neither with virtual methods, and both for very unique purposes. Since the basic operator overloads and some standard functions are identical, and they only need one member variable, I figured I could use a base class to reuse code. Here's a simple mockup of what I mean:

The base class:

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

And then:

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

The question: Is there any overhead in memory or performance in deriving from a base class lacking any virtual methods? Since it's a smart pointer implementation, lean and mean is what I'm looking for.

My gut says no, there is no concern, but I'd like to be certain from wiser minds.

Answer 1

Performance impact

None. Without virtual (either virtual inheritance or virtual functions) you won't incur any runtime penalties for using a base class. The name resolution is performed entirely at compile time using the static types.

Memory impact

None. In the absence of virtual, there's no meaningful difference between a class that inherits and one that has the same fields directly as members. This all changes if you have multiple base classes or virtual (inheritance or functions).

Compilation impact

There may be some impact on the time taken to compile; the compiler will have to keep track of more names and template instantiations. This is sometimes a concern for large, template-heavy codebases.