I am trying to construct sophisticated object oriented libraries with many levels of inheritance, and the fact that I have to write out explicitly trivial constructors over and over again is driving me nuts.

In general I can't help but wonder, what is so bad about two stage construction. Here is my list of pros and cons:

Cons

1. Possible performance penalty, when default initialization steps are taken unneccessarily.
2. Classes which should not be default constructed will require checks requiring an initialization variable to make sure that they are initialized before used.

Pros

• Designs with deep inheritance trees can be expressed with significantly less code
• Wrapper classes (e.g. contract classes or veneers [see Matthew Wilson's book Imperfect C++ Chapter 21]) are much easier to implement, and become more viable
• There is no chance of programmer errors within multiple initialization lists (see Matthew Wilson's book Imperfect C++ section 2.3.2 on Member Ordering Dependencies)
• No chance of incorrect casts silently generated by the compiler
• Easier to trace, debug and understand code

The reason all of this has become such an issue for me is that I want to seperate the OOTL implementation of standard classes (like lists or arrays) into four levels: implementation, contract, extension, and final, where each one inherits from the previous.

• The implementation class represents a basic implementation of the core data type.
• the contract is a class which wraps (i.e. inherits from) the implementation and provides verification of the preconditions, postconditions and invariants
• The extension wraps the contract adding extra utility functions which can be trivially derived from the core implementation functions (e.g. syntactic sugar)
• The final version is a class which conditionally (depending on compile-time constants) creates a class for the user to use, which either applies the contract to the implementation or not

struct Base {
  Base(int x) : m(x) { }
  int m;
};

struct Derived : public Base {
};

Derived d(42); // does not compile