C++ 如何确定输入的类型

我通过未定义的类型得到了迭代器：

 for (typename Type::const_iterator hayStackIterator = hayHeap.begin(); hayStackIterator != hayHeap.end(); ++hayStackIterator) {
           //some inner logic
}

如果能知道我的

*hayStackIterator

是什么类型，能够根据这些信息修改内部逻辑，那就太好了。。。有没有一些简单的函数来制作这样的东西

if (*hayStackIterator.isInstanceOf(vector<string>){
//do something
} else if (*hayStackIterator.isInstanceOf(string){
//do something else
}

---

将内部逻辑放入函数中，并重载该函数：

void innerLogic(vector<string> const& vec) {
    //do something
}

void innerLogic(string const& str) {
    //do something else
}

void loop() {
    for (typename Type::const_iterator hayStackIterator = hayHeap.begin();
         hayStackIterator != hayHeap.end();
         ++hayStackIterator)
    {
        innerLogic(*hayStackIterator);
    }
}

void内部逻辑（向量常量和向量）{
//做点什么
}
无效内部逻辑（字符串常量和字符串）{
//做点别的
}
void循环（）{
for（typename Type:：const_iterator hayStackIterator=hayHeap.begin（）；
hayStackIterator！=hayHeap.end（）；
++（迭代器）
{
innerLogic（*hayStackIterator）；
}
}

将内部逻辑放入函数中，并重载该函数：

void innerLogic(vector<string> const& vec) {
    //do something
}

void innerLogic(string const& str) {
    //do something else
}

void loop() {
    for (typename Type::const_iterator hayStackIterator = hayHeap.begin();
         hayStackIterator != hayHeap.end();
         ++hayStackIterator)
    {
        innerLogic(*hayStackIterator);
    }
}

void内部逻辑（向量常量和向量）{
//做点什么
}
无效内部逻辑（字符串常量和字符串）{
//做点别的
}
void循环（）{
for（typename Type:：const_iterator hayStackIterator=hayHeap.begin（）；
hayStackIterator！=hayHeap.end（）；
++（迭代器）
{
innerLogic（*hayStackIterator）；
}
}

您可以使用STL容器中的

typedefs

来帮助您使用SFINAE

template<typename Type> 
function flunk(const Type& hayHeap) {

    typedef typename Type::value_type inner_type;   // STL container typedef
                     ^^^^^^^^^^^^^^^^
    // if Type = vector<string> -> inner_type = string
    // if Type = string         -> inner_type = char

    inner_type start = inner_type();  // initialize start to default.

    for (typename Type::const_iterator hayStackIterator = hayHeap.begin(); hayStackIterator != hayHeap.end(); ++hayStackIterator) {
               //some inner logic
    }

}

模板
函数不及格（常数类型和草堆）{
typedef typename Type:：value\u Type internal\u Type；//STL容器typedef
^^^^^^^^^^^^^^^^
//如果类型=向量->内部类型=字符串
//如果类型=字符串->内部类型=字符
internal_type start=internal_type（）；//将start初始化为默认值。
for（typename Type:：const_iterator hayStackIterator=hayseap.begin（）；hayStackIterator！=hayseap.end（）；++hayStackIterator）{
//一些内在逻辑
}
}

您可以使用STL容器中的

typedefs

来帮助您使用SFINAE

template<typename Type> 
function flunk(const Type& hayHeap) {

    typedef typename Type::value_type inner_type;   // STL container typedef
                     ^^^^^^^^^^^^^^^^
    // if Type = vector<string> -> inner_type = string
    // if Type = string         -> inner_type = char

    inner_type start = inner_type();  // initialize start to default.

    for (typename Type::const_iterator hayStackIterator = hayHeap.begin(); hayStackIterator != hayHeap.end(); ++hayStackIterator) {
               //some inner logic
    }

}

模板
函数不及格（常数类型和草堆）{
typedef typename Type:：value\u Type internal\u Type；//STL容器typedef
^^^^^^^^^^^^^^^^
//如果类型=向量->内部类型=字符串
//如果类型=字符串->内部类型=字符
internal_type start=internal_type（）；//将start初始化为默认值。
for（typename Type:：const_iterator hayStackIterator=hayseap.begin（）；hayStackIterator！=hayseap.end（）；++hayStackIterator）{
//一些内在逻辑
}
}
你有没有尝试过STD：：ISSY？我对C++是很新的，所以我不知道可能性，它提供……我会看这个：）你能做的完全取决于类型类的实现，而你完全没有告诉我们。例如，C++内置的运行时多态性调度（虚拟函数）、Boosi:：变体和Booo:：所有的方法都有不同的处理多种类型的方法。您尝试过STD：：ISSY？我对C++是全新的，所以我不知道可能性，它提供了…我来看看：）你能做什么完全取决于类型类的实现，你完全没有告诉我们关于它的任何事情。例如，C++内置的运行时多态分派（虚拟函数）、boost:：variant和boost:：any都有不同的处理多种类型的方法。由于这些必要的代码，有时我觉得C++1y必须引入可重载的本地函数。这应该做什么<代码>类型：：常量迭代器：：运算符*

必须有一个返回类型-它不会每次都返回不同的类型，您可以使用编译时多态性将这些类型分派给重载函数。我遗漏了什么吗？@TonyD：假设

类型

依赖于模板参数，因此在编译时可能会发生更改，这将导致与

运算符*

不同的返回类型，这将反过来分派到不同的

内部逻辑

重载，我必须承认，我很惊讶，这本书的作者会问这个问题。我遗漏了什么吗？在我最初阅读这个问题时，我认为迭代是在一组不同但未知的类型上进行的（例如，需要像C#Object/is实例这样的东西——比如强制所有东西都从空对象类派生，并使用RTTI/dynamic_cast测试运行时类型）。您的代码似乎假设该类型将是一组已知的类型之一。重读这个问题，谁知道呢，哈哈。谢谢你解释你从哪里来。干杯。由于这些必要的代码，有时我觉得C++1y必须引入可重载的局部函数。这应该做什么<代码>类型：：常量迭代器：：运算符*必须有一个返回类型-它不会每次都返回不同的类型，您可以使用编译时多态性将这些类型分派给重载函数。我遗漏了什么吗？@TonyD：假设

类型

依赖于模板参数，因此在编译时可能会发生更改，这将导致与

运算符*

不同的返回类型，这将反过来分派到不同的

内部逻辑

重载，我必须承认，我很惊讶，这本书的作者会问这个问题。我遗漏了什么吗？在我最初阅读这个问题时，我认为迭代是在一组不同但未知的类型上进行的（例如，需要像C#Object/is实例这样的东西——比如强制所有东西都从空对象类派生，并使用RTTI/dynamic_cast测试运行时类型）。您的代码似乎假设该类型将是一组已知的类型之一。重读这个问题，谁知道呢，哈哈。谢谢你解释你从哪里来。干杯