двусмислен оператор [] в променлив шаблон

Преносим начин да правите каквото искате е приблизително:

template<class...Ts>
struct operator_index_inherit {};
template<class T0, class T1, class...Ts>
struct operator_index_inherit<T0, T1, Ts...>:
  T0, operator_index_inherit<T1, Ts...>
{
  using T0::operator[];
  using operator_index_inherit<T1, Ts...>::operator[];
};
template<class T0>
struct operator_index_inherit<T0>:
  T0
{
  using T0::operator[];
};

тогава:

template<class... Fields>
struct ctmap : operator_index_inherit<Field<Fields>...> {
  using base = operator_index_inherit<Field<Fields>...>;
  using base::operator[];
};

тук ние линейно наследяваме от всеки от типовете и using operator[] от нашите родители.

Ако можехме using Field<Fields>::operator[]...; нямаше да се налага да правим това.

Трябва да се внимава с конструкторите (които аз не взех), но може да не е необходимо да правите това.

пример на живо.

Това, което всъщност се обърка, зависи от детайлите на стандарта, в който не съм много сигурен. По принцип вие смесвате оператори, наследяване и претоварване по сложен начин. Дори ако вашият код е стандартно съвместим (което може или не може да бъде), той е съвместим по начин, по който някои компилатори умират.

Кодът е невалиден и gcc е правилен, за да го отхвърли (clang 3.6.0 обаче го приема - това е грешка). Правилата за търсене на оператор започват от [over.match.oper]:

[...] за двоичен оператор @ с ляв операнд от тип, чиято cv-неквалифицирана версия е T1 и десен операнд от тип, чиято cv-неквалифицирана версия е T2, три набора кандидат функции, обозначени като член кандидати, нечленуващи кандидати и вградени кандидати, се конструират както следва:
— Ако T1 е пълен тип клас или клас в момента като е дефиниран, наборът от кандидати за членове е резултат от квалифицираното търсене на T1::operator@ (13.3.1.1.1); в противен случай наборът от кандидати за членове е празен.

Правилата за търсене на име на член са (тъй като търсим ctmap<last_name,age>::operator[]), от [class.member.lookup]:

Наборът за справка за f в C, наречен S(f,C), [...] се изчислява, както следва:

Ако C съдържа декларация на името f, [...]

В противен случай (т.е. C не съдържа декларация на f или полученият набор от декларации е празен), S(f,C) първоначално е празен. Ако C има базови класове, изчислете набора за справка за f във всеки подобект Bi на пряк базов клас и обединете всеки такъв набор за справка S(f,B_i) на свой ред в S(f,C).

Следващите стъпки дефинират резултата от обединяването на справочния набор S(f,B_i) в междинния S(f,C):
— [...]
— В противен случай, ако наборите от декларации на S(f,B_i) и S(f,C) се различават, сливането е двусмислено: новото S(f,C) е набор за справка с невалиден набор от декларации и обединението на наборите от подобекти. При последващи сливания невалиден набор от декларации се счита за различен от всеки друг.
— [...]

По принцип - тук имаме два базови класа, и двата с operator[]. И двата комплекта декларации се различават - така че сливането е двусмислено. Начинът за разграничаване на двусмислието би бил да се въведат using-declarations, които въвеждат всички членски функции на базовия клас в производния клас, така че първоначалният набор за търсене да намира всичко.

За да съкратите примера си:

struct A { void foo(char) { } };
struct B { void foo(int ) { } };

struct C : A, B { };

struct D : A, B {
    using A::foo;
    using B::foo;
};

С тази йерархия

C c;
c.foo(4);  // error: ambiguous lookup set for foo()

D d;
d.foo('x') // OK: calls A::foo()