为“ type”做一个共同的功能和“类型”的向量使用C＆＃x2B;＆＃x2B;

Question

我正在编写功能，并遇到了这种情况：

void doSomeThing(std::vector<someType> vec)
{
  for(element : vec)
  {
    // do Something different if it is in vector
  }
}

void doSomeThing(someType element)
{
  // do Something else if it was not a vector
}

我需要像上面所述的那样分开。我想知道是否有一种方法使用模板来推断这种类型并进行相应的处理？

Answer 1

好吧，是的，这是可能的。

例如，您可以做；

template<class someType>
void doSomeThing( const someType &obj )
{
      // do something assuming someType is not a vector of something
}

template<class someType>
void doSomeThing( const std::vector<someType> &obj )
{
      // do something different if a vector<someType> is passed
}

int main()
{
    int x = 24;
    std::vector<int> a{1,2,3};     // assuming C++11 and later

    doSomeThing(x);     //  will call a specialisation of the first form above
    doSomething(a);     //  will call a specialisation of the second form above
}

就个人而言，我会做一些不同的事情 - 而不是为矢量超载，而是对一对迭代器过载。例如，假设dosomething（）是打印到std :: cout的功能

template<class someType>
void doSomeThing( const someType &obj )
{
      std::cout << obj;
}

template<class Iter>
void doSomeThing( Iter begin, Iter end)
{
    while(begin != end)
    {
       std::cout << *begin << ' ';
       ++begin;
    }
    std::cout << '\n';
}

，它将与任何标准容器中的迭代器一起使用（例如std ::的特殊性， vector，std :: list）或其他任何可以提供有效迭代器的东西。

int main()
{
    int x = 24;
    std::vector<int> a{1,2,3};     // assuming C++11 and later
    std::list<double> b {42.0, 45.0};


    doSomeThing(x);     
    doSomething(std::begin(a), std::end(a));
    doSomething(std::begin(b), std::end(b));
}

Answer 2

只需更改，您就可以这样做

#include <iostream>
#include <vector>

template <typename T>
void doSomeThing(std::vector<T> vec)
{
  for (element : vec)
  {
    // do Something different if it is in vector
  }
}

template <typename T>
void doSomeThing(T element)
{
  // do Something else if it was not a vector
}

Answer 3

例如，您可以

template <class T>
void doSomeThing( const std::vector<T> &vec )
{
    for ( const auto &element : vec )
    {
        std::cout << element << ' ';
    }
    std::cout << '\n';
}

template <class T>
void doSomeThing( const T &obj )
{
    for ( const auto &element : obj )
    {
        std::cout << element << ' ';
    }
    std::cout << '\n';
}

在此处写一个演示程序。

#include <iostream>
#include <vector>
#include <type_traits>

template <class T>
void doSomeThing( const std::vector<T> &vec )
{
    std::cout << std::boolalpha
        << std::is_same_v<std::decay_t<decltype( vec )>, std::vector<T>>
        << '\n';

    for ( const auto &element : vec )
    {
        std::cout << element << ' ';
    }
    std::cout << '\n';
}

template <class T>
void doSomeThing( const T &obj )
{
    std::cout << std::boolalpha
        << std::is_same_v<std::decay_t<decltype( obj )>, std::vector<T>>
        << '\n';
    for ( const auto &element : obj )
    {
        std::cout << element << ' ';
    }
    std::cout << '\n';
}

int main() 
{
    std::vector<int> v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    doSomeThing( v );

    int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    
    doSomeThing( a );
}

程序输出是

true
0 1 2 3 4 5 6 7 8 9 
false
0 1 2 3 4 5 6 7 8 9