Компиляция кода с ромбовидным наследованием

class A {
protected:
    int a;
public:
    A(int i) : a(i) {}
};
 
class B : public A {
public:
    B(int i) : A(i) {}
};
 
class C : public B, public A {
public:
    C(int i1, int i2) : B(i1), A(i2) {}
    void print() { std::cout << "B(" << B::a << "), A(" << A::a << ")"; }
};
 
int main()
{
    C cc(2, 1);
    cc.print();
}

class MemoryInfo {};
class HDDInfo: virtual public MemoryInfo {};
class RAMInfo: virtual public MemoryInfo {};
 
class ProcessorInfo{};
class CPUInfo: virtual public ProcessorInfo {};
class GPUInfo: virtual public ProcessorInfo {};
 
class VideoAdapterInfo: public GPUInfo, virtual public RAMInfo {};
 
class PCInfo: public HDDInfo, public RAMInfo, public CPUInfo, public VideoAdapterInfo {};

#include <iostream>
 
template<class T> struct ram 
{ 
    ram(const size_t v): memory(v){}
    size_t memory; 
};
 
struct video : ram<video> 
{
    video(const size_t v): ram<video>(v){}
};
 
struct cpu : ram<cpu> 
{
    cpu(const size_t v): ram<cpu>(v){}    
};
 
struct computer : video, cpu
{
    computer(const size_t memVideo, const size_t memCPU)
        : video(memVideo)
        , cpu(memCPU)
    {}
    
    void print() const 
    { 
        std::cout << "Video RAM .. " << video::memory << " Gb" << std::endl;
        std::cout << "CPU RAM .... " << cpu::memory   << " Gb" << std::endl;
        
        
    }
};
 
int main()
{
    computer pentium(16, 64);
    pentium.print();
}