C++ C++；：有没有办法从实例化模板中提取类型？ //对STL容器执行操作的类模板 模板 结构foo{ T包含元素（）的容器{ T-con； elee； con.推回（+++e）； 返回con； }
如您所见，将元素的类型放入templates的参数中是非常愚蠢的，因为它已经包含在容器的类型中 那么，从T中得到元素的类型有什么魔力吗 大量Thx:-）标准库中的每个“容器”都试图遵守。这个概念要求，给定一个容器C++ C++；：有没有办法从实例化模板中提取类型？ //对STL容器执行操作的类模板 模板 结构foo{ T包含元素（）的容器{ T-con； elee； con.推回（+++e）； 返回con； },c++,templates,C++,Templates,如您所见，将元素的类型放入templates的参数中是非常愚蠢的，因为它已经包含在容器的类型中 那么，从T中得到元素的类型有什么魔力吗 大量Thx:-）标准库中的每个“容器”都试图遵守。这个概念要求，给定一个容器T： T:：value\u type是容器元素的类型 T:：reference是容器元素的引用类型 T:：const_reference是容器元素的常量引用类型 在特定示例中，可以通过以下方式提取元素类型： //a class template to do something to ST
TT:：value\u typeT:：referenceT:：const_reference//a class template to do something to STL container
template<typename T/*should be a STL container*/,typename Ele/*the type of element*/>
struct foo{
T a_container_with_an_element(){
T con;
Ele e;
con.push_back(++++e);
return con;
}
模板
结构foo{
容器a_容器_与_元素（）{
集装箱集装箱；
typename容器：：值\类型e；
con.推回（+++e）；
返回con；
}
template<typename Container>
struct foo {
Container a_container_with_an_element(){
Container con;
typename Container::value_type e;
con.push_back(++++e);
return con;
}
如果
Tpush_back（）X::value_type
X::reference
X::const_reference
X::iterator
X::const_iterator
X::difference_type
X::size_type
template
结构foo
{
类型DEF Con Con Con Con Con_类型；
类型定义元素值\u类型；
容器\键入带有元素（）的容器\类型
{
集装箱式集装箱；
e型值；
con.push_back（e）；//或先修改e，但不修改++++e
返回con；
}
};
template< template<typename, typename> class Con,
typename Ele, typename Alloc = std::allocator<Ele> >
struct foo
{
typedef Con<Ele, Alloc> container_type;
typedef Ele value_type;
container_type a_container_with_an_element()
{
container_type con;
value_type e;
con.push_back( e ); // or modify e first but not ++++e
return con;
}
};
foomyfoo；
std:：vector myvec=myfoo.a_容器_与_an_元素（）；
foo< std::vector, int > myfoo;
std::vector<int> myvec = myfoo.a_container_with_an_element();
模板
结构foo
{
typedef typename Con:：value\u type value\u type；
将容器与元素（）合并
{
康康；
e型值；
con.push_back（e）；//或先修改e，但不修改++++e
返回con；
}
};
template< typename Con >
struct foo
{
typedef typename Con::value_type value_type;
Con a_container_with_an_element()
{
Con con;
value_type e;
con.push_back( e ); // or modify e first but not ++++e
return con;
}
};
foomyfoo；
std:：vector myvec=myfoo.a_容器_与_an_元素（）；
请注意，在本例中，您还可以执行
foo:：Eletypedeftypenamefoo foo<std::vector<int> > myfoo;
std::vector<int> myvec = myfoo.a_container_with_an_element();
模板
结构MyFirstElement；
模板
结构MyFirstElement{
使用类型=T_类型；
};
//单元测试
使用MustBeInt=typename MyFirstElement:：Type；
使用mustAlley=typename MyFirstElement:：Type；
静态断言（std:：is_same:：value，“”）；
静态断言（std:：is_same:：value，“”）；
//即使它不是STL容器，也可以这样做
模板
结构MyCrazyContainer{}；
静态断言（std:：is_same:：value，“”）；
正如Jarod42所指出的，这只适用于“常规”模板，即仅将类型作为参数。例如，std:：array之所以这样做是因为它有一个int作为第二个参数。这取决于您想如何使用它。例如，您可以使用
typeid（…）typeid（…）.name（）typedef typename T:：value\u type type+++estdElestd:：arraystd:：remove_reference:：type foo<std::vector<int> > myfoo;
std::vector<int> myvec = myfoo.a_container_with_an_element();
template<typename T>
struct MyFirstElement;
template<template<typename...> class T_Container, typename T_Type, typename... Ts>
struct MyFirstElement<T_Container<T_Type,Ts...>>{
using Type = T_Type;
};
//unit test
using MustBeInt = typename MyFirstElement<std::vector<int>>::Type;
using MustBeLong = typename MyFirstElement<std::map<long,float>>::Type;
static_assert(std::is_same<MustBeInt,int>::value,"");
static_assert(std::is_same<MustBeLong,long>::value,"");
//this works too even though its not an STL container
template<typename T, typename U, typename Z>
struct MyCrazyContainer{};
static_assert(std::is_same<typename MyFirstElement<MyCrazyContainer<bool,long,float>>::Type,bool>::value,"");