Dziedziczenie nazw alternatywnych do istniejących typów w klasach

Cześć,

#include <memory>


template<typename T>
class object
{
public:
  typedef T class_type;
};

class example : public object<example> {};
class upgraded_example : example, public object<upgraded_example> {};


int main(void)
{
  example::class_type a;
  upgraded_example::class_type b;

  return 0;
}

main.cpp: In function 'int main()':
main.cpp:18:3: error: reference to 'class_type' is ambiguous
upgraded_example::class_type b;
^
main.cpp:8:13: note: candidates are: typedef class upgraded_example object<upgraded_example>::class_type
typedef T class_type;
^
main.cpp:8:13: note: typedef class example object<example>::class_type
main.cpp:18:32: error: expected ';' before 'b'
upgraded_example::class_type b;
^

Jakieś pomysły, aby rozwiązać ten problem?

A teraz napisz po polsku o co ci chodzi. Dziedziczysz dwa razy z tej samej klasy to i masz problem z niejednoznacznością. W czym rzecz?

Zakładam, że chodzi o dziedziczenie z tej samej klasy, ale inna specjalizacja.
Zawrzyj ją w swojej klasie i po problemie.

Może ten komunikat czytelniejszy będzie:

C:\myprogs\nienazwany2\main.cpp:18: błąd:C2385: ambiguous access of 'class_type'
could be the 'class_type' in base 'object<example>'
or could be the 'class_type' in base 'object<upgraded_example>'

Poprzednicy napisali jak naprawić daną sytuację. Ja jedynie od siebie dodam, że jeśli to jakiś design programu, który ma być rozwijany to uważam, że tego typu wielodziedziczenie jeszcze w dodatku po szablonach jest zapowiedzą błędów w architekturze prowadzących do sado-masochistycznego siedzenia wieczorami nad kodem.

Problem w tym, że zawarcie tego w swojej klasie odpada - ta wartość musi być wyłącznie deklarowana w klasie potomnej (nazwanej 'object'). Inne pomysły, aby wskazać kompilatorowi, że chodzi mi o tą definicję z klasy 'object', a nie 'example'?

@Kamil___ to akurat nie jest żaden problem, od tego jest deklaracja using.

Czy możesz podać mi przykład zastosowania jej w tym przypadku? Bo ja osobiście nie widzę tego :(.

http://stackoverflow.com/a/6845874

Nawet dwa sposoby:
http://ideone.com/jx4yg3

Działa, dzięki.

#include <memory>
#include <string>
#include <iostream>
 
template<typename T>
class object
{
public:
  typedef std::shared_ptr<T> shared;
  
  template<typename ...Args>
  static shared create(Args... args) { return shared(new T(args...)); }
  
  template<typename Type>
  bool is_type() { return typeid(Type) == typeid(T); }
};
 
class example : public object<example> {};
class upgraded_example : example, public object<upgraded_example> 
{
public:
  using object<upgraded_example>::shared;
  using object<upgraded_example>::create;
  using object<upgraded_example>::is_type;
};
 
 
int main(void)
{
  example::shared object1 = example::create(); 
  std::cout << object1->is_type<example>() << std::endl;
  std::cout << object1->is_type<upgraded_example>() << std::endl;
  upgraded_example::shared object2 = upgraded_example::create();
  std::cout << object2->is_type<example>() << std::endl;
  std::cout << object2->is_type<upgraded_example>() << std::endl;
  return 0;
}