Trivially copyable requirements and virtual functions

Question

According to cppreference, a trivially copyable class should:

(class) has no virtual member functions;
(class) has no virtual base classes;

I don't understand the reason behind these requirements.

I tried to figure it out myself by doing:

#include <iostream>

struct virt
{
    int q;
    void virtual virt_func()
    {
        q += 2;
        std::cout << "base implementation: object value " << q << std::endl;
    }
};

struct virt_1 : public virt
{
    float w;
    void virt_func() override
    {
        w += 2.3;
        std::cout << "child 1 implementation: object value " << w << std::endl;
    }
};

struct virt_2 : public virt_1
{
    double e;
    void virt_func() override
    {
        e += 9.3;
        std::cout << "child 2 implementation: object value " << e << std::endl;
    }
};

int main()
{
    virt_2 * t = new virt_2();
    t->virt_func();
    void * p = malloc(sizeof(virt_2));
    
    memmove(p, t, sizeof(virt_2));

    static_cast<virt_2 *>(p)->virt_func();

    std::cout <<"End of a file" << std::endl;
    return 0;
}

and it works as it should, by printing:

child 2 implementation: object value 9.3
child 2 implementation: object value 18.6
End of a file

So, why, is what is effectively is a, no vtable pointer requirement is there? I mean, it's a simple pointer that can (should) be copied without any problem at all, right?!

Answer 1

Your example doesn't illustrate the dangers.

Imagine this:

virt_1 *copy_v1(virt_1 *t)
{
    void * p = malloc(sizeof(virt_1));
    memmove(p, t, sizeof(virt_1));
    return (virt_1 *)p;
}

called like this:

int main()
{
    virt_2 * v2 = new virt_2();
    virt_1 * v1 = copy_v1(v2);
    v1->virt_func();
}

What you've done here is create an object with the virt_2 virtual table but the object itself is too short and doesn't actually contain the e member.

Invoking virt_func() on this borked object will result in the proverbial undefined behavior.

Answer 2

Think about what copying an object really means and what requirements are there for it to be safe.

One should be able to define the following method:

virt* copy_virt(virt* original)
{
    return new virt(*original);
}

And this method should be invocable with any valid pointer to an object of type virt.

How exactly is the used copy constructor defined? If virt is trivially copyable it should copy the exact underlying representation of original into the new instance. Including the vtable pointer.

Let's test this:

int main()
{
    virt_2 *k = new virt_2();
    k->q = 5;
    virt *c = copy_virt(k);
    c->virt_func();
}

Output:

base implementation: object value 7

The vtable pointer was not copied, therefore virt is not trivially copyable. Copying the underlying bytes does not have the same effect as invoking the copy constructor, because the copy constructor ensures there are no dangling pointers, like any copying should. (In this case the dangling pointer would come from invoking the wrong virtual function and trying to access w or e.)

You might try to argue that I copied an object of one type to another, but copy_virt takes a pointer and returns a pointer to the exact same type. C++ says it is not trivially copyable because you cannot ignore the possibility of original being an instance of a subclass.