Virtual Base Class, "Diamond" Inheritance

Hello,

I'm getting a little frustrated with constructor syntax when I use
virtual base classes.

Take the following code (classic diamond inheritance):

class BaseClass
{
    int base_value;
public:

    BaseClass(int bv) : base_value(0)
    {
        base_value = bv;
    }

    virtual ~BaseClass()
    {

    }

    int value() const
    {
        return base_value;
    }
};

class A : public virtual BaseClass
{
public:
    A() : BaseClass(1)
    {
    }

    virtual ~A()
    {

    }
};

class B : public virtual BaseClass
{
public:
    B() : BaseClass(2)
    {
    }

    virtual ~B()
    {

    }
};

class Diamond: public A, public B
{
public:
    Diamond(): BaseClass(3)
    {

    }

    virtual ~Diamond()
    {

    }
};

int main(int argc, char* argv[])
{
    Diamond d;

    printf("Hello World! %d\n", d.value());
    return 0;
}

This code won't compile without the calls to the BaseClass constructor
in A and B, even though they are never called. Why is that? I have
already told the compiler, "this class will be instantiated somewhere
else" (right?), why do I have to add completely meaningless code to
make the compiler happy?

What's more... if add this class:

class Diamond2 : public Diamond
{
public:
    Diamond2(): BaseClass(4)
    {

    }

    virtual ~Diamond2()
    {

    }
};

And change variable d to type Diamond2, it won't compile without the
constructor call to BaseClass. It seems to me that the call to
BaseClass should be satisfied by the call in the Diamond constructor.

I have two problems with this, (1) code is getting duplicated
unnecessarily, and (2) it undermines the programmer's ability to
design neatly encapsulated classes (for example, if the whole purpose
of class Diamond was to set the correct value in BaseClass).

Is there something I'm missing? I might be less frustrated if I had a
better understanding about what is going on. I don't see any
explanation in Stroustrup. Is there some kind of syntactic trick I can
use to duplicate less code?

Think of this way: "What does d.value() return?" could be an exam
question. This case is simple, but in "the real world" the code can
get complicated in a hurry, and I would rather not hurt myself trying
to read my own code!

Thanks for the hep!

Ryan

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]