Как объявить член в базовом классе шаблона, где тип зависит от производного класса?

Можно ли сделать тип члена напрямую зависимым от производного класса? Принимая во внимание тип результата функции-члена, объявленной с помощью auto (выведенный тип возвращаемого значения), это невозможно.

Таким образом, использование типа, как вы делаете в вашем решении, является лучшим и единственным решением.

Причина в том, что базовый класс должен быть полным типом при определении производного класса: компилятор должен сначала создать экземпляр и проанализировать определение базового класса, прежде чем анализировать определение производного класса, Стандарт C++ N4140 [derived.class]/2 (жирный шрифт мой):

Тип, обозначенный спецификатором базового типа, должен быть типом класса, который не является не полностью определенным классом;[...]

Как насчет такого:

template <typename T, typename TypeId> class Base 
{
private:
    TypeId id;
public:
    Base() { id = 123; }
    TypeId getId() {return id;}
};

class Derived : public Base<Derived, int> {};

Это немного упрощено, но вы платите за это определенную цену.

#include <any>

template <class T> class Base {
    std::any id; // expensive, but cannot have T::TypeId here
 public:
    Base() : id(123) {}
    auto getId() { 
         return std::any_cast<typename T::TypeId>(id); 
    } // T::TypeId is OK inside a member function
};

class Derived : public Base<Derived> {
public:
    using TypeId = int;
};

Почему бы не изменить иерархию классов?

template <class T>
class Base : T {
    using TypeId = typename T::TypeId;
    TypeId id;
 public:
    Base() { id = 123; }
    TypeId getId() { return id; }
};

struct BasicDerived {
    using TypeId = int;
};


using Derived = Base<BasicDerived>;

На самом деле, я подумал еще немного... это не так уж неприятно:
У вас может быть структура связывания, которую можно даже написать в виде макроса, объявленного непосредственно перед реальным классом.
Структура связывания определяет перечисление. и неполное определение типа для реального класса.
Шаблон определен до всего этого, но использует имя типа для отсрочки своей зависимости, но он создается реальным классом и зависит только от структуры привязки.

template <class ThatClassWrapper>
class MyBase
{
protected:
    typedef typename ThatClassWrapper::TypeId TypeId;
    typedef typename ThatClassWrapper::RealClass ThatClass;
    TypeId typeIdValue;
    TypeId  GetTypeId() {   return typeIdValue; }
    std::vector<ThatClass*> storage;
};

class SomeClass;
namespace TypeIdBinding
{
    struct SomeClass
    {
        enum TypeId
        {
            hello, world
        };
        typedef ::SomeClass RealClass;
    };
}
class SomeClass: public MyBase<TypeIdBinding::SomeClass>
{
public:
    bool CheckValue(TypeId id)
    {   return id == typeIdValue;   }
};

Обратите внимание, что реальный класс использует TypeId, как определено в базе шаблонов, и именованные члены не видны напрямую. Вы можете исправить это, если шаблон Base будет получен из структуры привязки (подтверждено, что он компилируется таким образом). хотя мне на самом деле нравится, что в С++ 11 вы можете экспортировать или typedef только имя типа перечисления из другого пространства имен и использовать это имя типа в качестве префикса для членов перечисления, помогая избежать загрязнения имен.

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

Не могли бы вы объявить фиктивный класс шаблона, который принимает Derived и TypeID? Хотя я не думаю, что это вам что-то даст.

Является ли TypeID: производным сопоставлением 1: 1? Не будет ли лучше представить это сопоставление 1: 1 с другим вспомогательным шаблоном для обратного поиска, полученного из TypeID? Обратите внимание, что для этого необходимо определить TypeID вне класса Derived.
Действительно ли TypeID нужно определять внутри класса? Может ли он использовать определение, переданное в Base, для поддержки существующего использования внутреннего typedef?

Можете ли вы включить двойное включение? Разделить или макросить ваше определение производного, чтобы typeid находился в определении базового класса, которое можно включить перед шаблоном? Этот DerivedBase может быть объявлен в пространстве имен и содержать ссылку typedef на полный класс Derived, чтобы Base мог найти его для ссылок.