Что такое множественное повторное наследование?

Я добавляю к принятому ответу. В нем говорится, что производный класс не может получить доступ к прямому base класс, если производный класс также косвенно наследует base, Его решение делает base косвенный класс, обернув его шаблоном, аргумент второго типа которого tag, Это обеспечивает base является косвенным по отношению к производному классу при условии, что производный класс расширяет упакованную базу уникальным tag, В приведенном ниже примере будет использоваться не тип tag,

Если бы подобная алмазу проблема была обобщена, чтобы содержать больше поколений в форме:

• я^го класс наследует от base и (я — 1)^го,
• (я — 1)^го наследуется от base и (я — 2)^го,
• …, а также
• 2^й наследуется от base,

тогда это импровизированный контейнер, где каждый элемент хранится в каждом уникально помеченном base, В таком случае, tagИзготовление должно быть автоматизировано. Одним из способов является объединение всех производных классов с помощью нетипового шаблона. Свой нетипичный параметр N Можно указать количество рекурсивных итераций наследования. Делая tag это не типовой параметр, значение параметра, определяющего количество подклассов, может быть однозначно связано со значением одного тега для каждого типа подобъекта. Например, tag = 10 соответствует N = 10, который относится к 10-му поколению по иерархии:

// disambiguated_wrapper.h

struct int_wrapper {
int num;
};

template < typename base, unsigned int tag >
struct disambiguated_wrapper : base {
using base::base;
};

//impvised_container.h

#include "disambiguated_wrapper.h"
template <unsigned int N>
struct improvised_container :
protected disambiguated_wrapper<int_wrapper, N>,
protected improvised_container<N - 1> {

unsigned int size() const { return N; }

int& at(const unsigned int index) {
if (index >= N) throw "out of range";
else return (index == N - 1) ?
this->disambiguated_wrapper<int_wrapper, N>::num :
this->helper(index);
}
protected:
int& helper(const unsigned int index) {
return (index == N - 1) ?
this->disambiguated_wrapper<int_wrapper, N>::num :
this->improvised_container<N - 1>::helper(index);
}
};
#include "specializations.h"

// specializations.h

template <>
struct improvised_container<0> {
improvised_container() = delete;
}; // ^ prohibits 0-length container

template <>
struct improvised_container<1> :
protected disambiguated_wrapper<int_wrapper, 1> {

unsigned int size() const { return 1; }

int& at(const unsigned int index) {
if (index != 0) throw "out of range";
else return this->disambiguated_wrapper<int_wrapper, 1>::num;
}
protected:
int& helper(const unsigned int index) {
if (index != 0) throw "out of range";
else return this->disambiguated_wrapper<int_wrapper, 1>::num;
}
};

// main.cpp

#include "improvised_container.h"#include <iostream>
int main() {
improvised_container<10> my_container;
for (unsigned int i = 0; i < my_container.size(); ++i) {
my_container.at(i) = i;
std::cout << my_container.at(i) << ",";
}   // ^ Output: "0,1,2,3,4,5,6,7,8,9,"}

Элемент доступа at не может уменьшить index рекурсивно называть себя, потому что index не является константой времени компиляции. Но N является. Так, at звонки helper, который рекурсивно вызывает (i — 1)^го версия себя в (я — 1)^го подобъект, убывающий N пока это не будет равно index – 1при каждом вызове перемещение на одну область глубже и, наконец, возвращение элемента целевой области. Это проверяет против index – 1 и не indexпотому что 0^го improvised_container Ctor специализации deleteд. at компенсирует офф-по-одному.

improvised_container использования protected наследование, чтобы предотвратить доступ клиентского кода к at а также size методы его базовых подобъектов. Размер подобъекта меньше размера вложенного объекта.

Это работает в g ​​++ 4.8. Наследующий конструктор using base::base вызывает ошибки в VC12, но это может быть опущено, потому что тип элемента int,