std::map::size_type для std::map, у которого value_type является собственным size_type

То, что вы ищете, вообще говоря, невозможно.

Возможно (хотя и надуманно), что std::map<int, long>::size_type равно int, а std::map<int, int>::size_type равно long (и аналогично для других целочисленных типов), и в этом случае нет никакого способа удовлетворить std::map<int, T>::size_type как T.

И наоборот, может быть так, что std::map<int, T>::size_type определяется как T для всех T, и в этом случае не существует уникального T, удовлетворяющего вашему "требованию".

Как упоминалось в нескольких ответах (и вашей собственной справочной ссылке), на практике это вряд ли будет чем-то иным, кроме size_t.

size_t должно быть достаточно для такого случая.

Но если вы настаиваете, вы можете сделать так:

#include <type_traits>
#include <map>

template <class Key, class Value = size_t, size_t depth = 0, class = void>
struct GetSizeType {
    using type = typename GetSizeType<Key, typename std::map<Key, Value>::size_type, depth + 1>::type;
};

template <class Key, class Value, size_t depth>
struct GetSizeType<Key, Value, depth, std::enable_if_t<std::is_same_v<Value, typename std::map<Key, Value>::size_type>>> {
    using type = typename std::map<Key, Value>::size_type;
};

template <class Key, class Value>
struct GetSizeType<Key, Value, 100, void> {};

int main() {
    using X = GetSizeType<int>::type;

    return 0;
}

Он будет выполняться рекурсивно на GetSizeType, рекурсивный вызов остановится на

• достижение ограничения глубины рекурсивного вызова (в этом случае члена type не будет), или
• найти специализацию std::map, из которых mapped_type и size_type идентичны (член type псевдонимы size_type).

Отказ от ответственности: это решение довольно глупое. Мы просто собираемся решить уравнение, многократно (обычно один раз) пытаясь создать экземпляр std::map, пока не найдем тот, у которого есть запрошенный ключ и его собственный size_type в качестве значения.

template <class T>
struct identity {
    using type = T;
};

template <class K, class V = char>
struct auto_map {
    using map_type = std::map<K, V>;
    using type = typename std::conditional_t<
        std::is_same_v<
            typename map_type::mapped_type,
            typename map_type::size_type
        >,
        identity<map_type>,
        auto_map<K, typename map_type::size_type>
    >::type;
};

template <class K>
using auto_map_t = typename auto_map<K>::type;

Если метафункция не может найти такую ​​карту, она либо выдаст ошибку, потому что type в конечном итоге определена сама для себя, либо нарушит ограничение рекурсии.

Используйте 1_. Целое число без знака std::map::size_type не будет больше std::size_t и на практике будет того же типа.

Если вы хотите быть уверенным, заявите об этом:

static_assert(std::is_same_v<
    std::size_t,
    std::map<std::string, std::size_t>::size_type
>);

Все реализации C++ в дикой природе, которые я использовал, используют один и тот же тип размера для всех карт.

So;

using map_size_type = std::map<int, int>::size_type;
using my_map = std::map<std::string, map_size_type>;
static_assert(std::is_same<map_size_type, my_map::size_type);

это просто вызывает ошибку компиляции, если (разумное) предположение не выполняется.

Единственный способ разорвать круговую зависимость — использовать определенный тип. Я рекомендую вам просто сделать map_index std::size_t - C++ строго подразумевает, что std::size_t будет назначен на map::size_type.

Но вы уверены, что size_type из std::map зависит от типов ключ/значение?

Если да, то я не вижу способа получить его.

Но size_type не должен зависеть от типов ключ/значение и обычно равен std::size_t.

Я предлагаю

using Index0 = typename std::map<std::string, std::size_t>::size_type;

using mapIndex = typename std::map<std::string, Index0>::size_type;    

Вы можете проверить, что вы получили правильный тип с помощью

static_assert( std::is_same_v<Index0, mapIndex>, "no right type");