//
// vbase.cpp -- Breaking virtual inheritance chains
//

#include <cstdio>

/*
 * Desired inheritance hierarchy:
 *
 *     A       A
 *    / \     / \
 *   /   \   /   \
 *  B1   B2 B1   B2
 *   \   /   \   /
 *    \ /     \ /
 *     C1     C2
 *      \     /
 *       \   /
 *        \ /
 *         D
 *
 */

//
// Assume this is code we can't modify.
//

class A {
protected:
        int v;

        A(int x) : v(x) {}
};

class B1 : public virtual A {
protected:
        B1(int x) : A(x) {}
};

class B2 : public virtual A {
protected:
        B2(int x) : A(x) {}
};

class C1 : public B1, public B2 {
protected:
        C1(int x) : A(x), B1(x), B2(x) {}
};

class C2 : public B1, public B2 {
protected:
        C2(int x) : A(x), B1(x), B2(x) {}
};


//
// Solution
//


//
// If we just inherited C1 and C2 they'd use the same instance of A. Instead
// declare them as member variables.
//

class D {
        friend void print(const D&);

        //
        // Wrap C1 and C2 and declare this class a `friend' to access their
        // protected members.
        //
        // Friend declarations of D have to be repeated as needed.
        //

        class C1 : public ::C1 {
                friend class D;
                friend void print(const D&);

                C1(int x) : A(x), ::C1(x) {}
        };

        class C2 : public ::C2 {
                friend class D;
                friend void print(const D&);

                C2(int x) : A(x), ::C2(x) {}
        };

        // Qualifier is unnecessary but helpful.
        D::C1 c1;
        D::C2 c2;

public:
        D(int x, int y) : c1(x), c2(y) {}

        void pow2()
        {
                c1.v *= c1.v;
                c2.v *= c2.v;
        }
};

void print(const D& d)
{
        std::printf("c1.v=%d, c2.v=%d\n", d.c1.v, d.c2.v);
}

int main()
{
        D d(2, 3);
        d.pow2();
        print(d); // Outputs "c1.v=4, c2.v=9"
}

matti fucked around with this message at 19:25 on Aug 31, 2020

// bool test_safe_range(long value);
// bool test_safe_range(long long value); [C++11]
//
// Return whether `value' is in the range where any arithmetic operator is
// guaranteed to not cause overflow on any target platform.
//
// FIXME: I actually have the feeling this isn't safe as a predicate for
// using an operator (the conditional block asserts that this always returns
// true). Bignum algorithms may be required. See regehr.org.

inline bool test_safe_range(long value)
{
        return value <= SAFE_LONG_MAXIMUM && value >= SAFE_LONG_MINIMUM;
}

matti fucked around with this message at 15:56 on Sep 17, 2020

matti fucked around with this message at 05:04 on Jan 28, 2021

matti fucked around with this message at 22:21 on Sep 29, 2021

matti fucked around with this message at 17:24 on Sep 30, 2021

matti fucked around with this message at 05:54 on Oct 1, 2021