Как вызвать конструктор не по умолчанию для каждого унаследованного типа из списка типов?

Я не мог устоять перед искушением посмотреть, как это можно сделать с помощью inherit_linearly. Получается не так уж и плохо, ИМХО:

template<class Base, class Self>
struct PolicyWrapper : Base, Self
{
    PolicyWrapper(const ExpensiveType& E)
        : Base(E), Self(E)
    {}
};

struct EmptyWrapper
{
    EmptyWrapper(const ExpensiveType& E)
    {}
};

template <typename PolicyTypeList = boost::mpl::vector<> >
class Host : 
    public inherit_linearly<
       PolicyTypeList, 
       PolicyWrapper<_1, _2>, 
       EmptyWrapper
    >::type
{

typedef typename inherit_linearly<
    PolicyTypeList, 
    PolicyWrapper<_1, _2>, 
    EmptyWrapper
>::type BaseType;

public:
    Host() : BaseType(m_expensiveType)
    {}

private:
    const ExpensiveType m_expensiveType;
};

Предупреждение: передача ссылки на неинициализированный член, как это делается в Host ctor, очень хрупкая. Если, например, кто-то пишет политику следующим образом:

struct BadPolicy
{
    BadPolicy(const ExpensiveType& E)
    : m_expensiveType(E)
    {}

    ExpensiveType m_expensiveType;
};

произойдут плохие вещи, так как копирующий элемент ExpensiveType будет вызываться с неинициализированным объектом.

Если вам нужна такая генерация, я могу только порекомендовать прочитать Современный дизайн C++. Существует целая глава, посвященная генерации иерархии из списка типов. Вы также можете найти его на веб-сайте Loki: Генераторы иерархии; хотя вам будет не хватать диаграмм и объяснений, а также самого процесса.

Для вашей конкретной проблемы это кажется довольно простым.

// Helper
struct nil
{
};

template < class Head, class Tail = nil>
struct SH: Head<Tail> /* for SimpleHierarchy */
{
  SH(const ExpensiveType& e): Head(e), SH<Tail>(e) {}
};

template<>
struct SH<nil,nil>
{
  SH(const ExpensiveType& e) {}
}:

// Policies
class A
{
public:
  A(const ExpensiveType& e) : T(e), m_e(e) {}

private:
  const ExpensiveType& m_e;
};

class B
{
public:
  B(const ExpensiveType& e) : T(e), m_e(e) {}

private:
  const ExpensiveType& m_e;
};

class C
{
public:
  C(const ExpensiveType& e) : T(e), m_e(e) {}

private:
  const ExpensiveType& m_e;
};

// Use
// nesting example
typedef SH<A, SH<B,C> > SimpleHierarchy;

// Your example, revisited
template <class A, class B>
class Host: SH<A,B>
{
public:
  Host(const ExpensiveType& e): SH<A,B>(e), m_e(e) {}

private:
  const ExpensiveType& m_e;
};

Конечно, это только набросок. Основная проблема здесь — расширяемость. Если вы прочитаете книгу Александреску, вы узнаете гораздо больше, а если у вас нет времени, взгляните на исходный код, это может оказаться именно тем, что вам нужно.

Есть способы сделать это прямо из mpl::vector, единственное, что нужно понимать, это то, что вы не можете сделать это с большим однослойным MI, но вы можете добавить много слоев.

Здесь я решил не усложнять уровень политик (они не шаблонизированы) и вместо этого полагаться на MI (двойной) на каждом уровне. Вы могли бы сделать это чисто линейным, но создание политик по шаблону означает, что вы не можете определить их в исходном файле.

Также обратите внимание, что этот подход может быть адаптирован для непосредственного использования mpl::vector, но это будет включать использование операций программирования меташаблонов: back, pop_back и empty, по крайней мере, которые могут больше запутать код, чем на самом деле помочь.

Как упоминалось в комментарии, вам нужно связать вызовы конструктора. Для этого каждый тип в цепочке производных должен знать, из какого типа он получен. Чтобы разрешить произвольные последовательности производных, нам нужно сделать эти типы шаблонами, чтобы их база могла быть любым типом.
Это позволяет нам ссылаться на базу и явно вызывать его конструкторы.

Я набросал базовый пример, но в итоге не использовал boost, потому что mpl::vector ожидает известные типы, и мне нужно было передать ему параметры шаблона шаблона. Вместо этого я использовал собственный список типов, который поддерживает параметры шаблона шаблона и неявно выводится.

struct expensive {};

// derivation list

struct nil {}; // list end
struct Noop {  // do nothing on end of derivation chain
    Noop(expensive& e) {}
};

template<template <typename T> class H, typename L>
struct DL {
    typedef L tail;
    typedef H<typename tail::head> head;
};

template<template <typename T> class H>
struct DL<H, nil> {
    typedef H<Noop> head;
};

// example types

template<class T>
struct A : T {
    A(expensive& e) : T(e) {}
};

template<class T>
struct B : T {
    B(expensive& e) : T(e) {}
};

// derivation chain usage example

typedef DL<A, DL<B, nil> > DerivationChain;

class User : DerivationChain::head
{
public:
    User(expensive& e) : DerivationChain::head(e) {}
};

int main(int argc, char** argv)
{
    expensive e;
    User u(e);
}

Создайте параметризованный конструктор и передайте ему параметры. Таким образом, вы можете достичь двух целей одновременно. 1) Перегрузка конструктора 2) Избегайте вызова конструктора по умолчанию.