Constructors and virtual inheritance...

If we have a situation where a base class A has only a non-default
constructor, two classes B and C derived by virtual inheritance has
abstract methods, and a class D inheriting from both B and C. It
seems that the constructor of B and C must be defined and call
A::A(args), even though neither B nor C will ever be the class to
actually make the call to A::A, since that will always be done by the
most derived class (in this case D). Is this really so? If so, it
seems like a bit of an annoyance, because either I'd have to put in a
bogus value in the initializer lists of B and C's call to A::A (which
makes the code less obvious), or I would have to create non-defautl
constructors for both B and C that would pass on its arguments to A::A,
however this would mean D had to make three explicit constructor calls
from its constructor with the same parameter, but with only one call
actually making the difference.

Since both B and C are abstract in the case above, I don't see why I
have to define constructors that initialize A, but both GCC and MSVC++
7.1 seems to think that this is what I should do.

What is the recommended way of handling this?

I post an example below that illustrates what I mean if the text above
did not quite clarify it:
------------------------------------------------
#include <string>
#include <iostream>

class Node
{
public:
    Node(const std::string &id) : mId(id)
    {
        std::cout << "Node with id " << id << " created\n";
    }

private:
    std::string mId;
};

class DependerNode : public virtual Node
{
public:
    DependerNode(const std::string &id) : Node(id + " depender") {}
    void foo() { }
    virtual void bar() = 0;
};

class DependeeNode : public virtual Node
{
public:
    DependeeNode(const std::string &id) : Node(id + " dependee") {}
    void foo2() {}
    virtual void bar2() = 0;
};

class ExpressionNode : public DependerNode, public DependeeNode
{
public:
    ExpressionNode(const std::string &id) : Node(id), DependerNode(id),
DependeeNode(id)
    {
    }
    void bar() {}
    void bar2() {}
};

int main(void)
{
    ExpressionNode e("expr");
    return 0;
}
---------------------------------------------

This code compiles, but the initializer-list of
ExpressionNode::ExpressionNode is not very nice, and it would be
especially annoying if Node needed more arguments and so on.

Any suggestions as to how to solve this would be appreciated.

Sincerely, Peter

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