17

我正在尝试在 C++ 中创建一个函数，我想知道我是否可以创建它以便它能够返回不同类型的向量。例如，根据不同的大小写，它返回向量字符串、int、double 或...任何东西。在 C++ 中可以吗？（我不想使用具有不同 arg(S) 和不同返回值的重载函数）我对 C++ 很陌生，我的问题可能看起来很愚蠢。

这是我的一段代码：

//这里的零表示相交

std::vector<??????> findZeros(const mesh::Region& s, char *model) const
{
//Point  
  if( model == "point" )
  {
    std::vector<Vertex> zeros;
    for(Region::pointIterator it = s.beginPoint(); itv != s.endPoint(); ++itv )
    {
      if( abs(Val(*it)) < 1.e-12 )      
      zeros.push_back(*it);
    }
    std::vector<point> zerosP(zeros.begin(), zeros.end());
    return zerosP;
  }
 //line
  else if (EntityS == "line")
  {
    std::vector<line> zerosE;
    std::vector<Point&> PointE;
    for(Region::lineIterator ite = s.beginLine(); ite != s.endLine(); ++ite )
    {
      Line ed = *ite;
        Point P0 = ed.point(0);
        Point P1 = e.point(1);
        if( ......... ) zerosE.push_back(ed);
        else if ( ....... )
        {
         PontE.push_back( P0, P1);
         zerosE.push_back(ed);
        }
      }

//这里我想返回“点”或“带有点的线”或在我们的表面上层。//我想在一个功能中完成所有事情！}

4

4 回答 4

24

模板

试试这个：

template <typename T>
std::vector<T> func( /* arguments */ )
{
    std::vector<T> v;
    // ... do some stuff to the vector ...
    return v;
}

您可以通过以下方式调用不同类型的此函数：

std::vector<int> func<int>( args );
std::vector<double> func<double>( args );

备择方案

如果您在编译时知道类型，这是一种方法。如果您在编译时不知道类型，而只在运行时知道，那么您有不同的选择：

  1. 使用unions. 如果您有非常简单的类似 C 结构的类型，在 C++ 标准中称为 POD（普通旧数据），我只能推荐这个。
  2. 使用某种类型的变体。例如，boost::variant来自 Boost 库或QVariantQt 库。它们是更通用类型上的一种安全联合。它们还允许在不同类型之间进行一些转换。例如，将某些内容设置为整数值将可以读取与浮点数相同的值。
  3. 使用boost::anywhich 可以包装任何类型但不允许它们之间的转换。
  4. 使用继承和多态。对于这种情况，您需要一个公共基类，例如Base. 然后，您最好使用std::shared_ptrs. 所以数组类型是std::vector<std::shared_ptr<Base>>. 在这种std::shared_ptr情况下，它比内置指针更好，因为它通过引用计数自动管理您的内存。
  5. 使用不关心类型和性能的动态语言。
于 2013-07-15T07:52:35.310 回答
8

C++17 更新

如果您在编译时知道类型，则可以使用此答案中所示的模板。

如果类型仅在运行时已知，则c++17可以boost::variant使用std::variant.

这是一个工作示例：

#include <iostream>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>

using variant_vector = std::variant<std::vector<int>, std::vector<std::string>>;

auto get_vector(int i)
{
    if (i < 0)
        return variant_vector(std::vector<int>(3, 1));
    else
        return variant_vector(std::vector<std::string>(3, "hello"));
}

int main()
{
    auto visit_vec = [](const auto& vec) {
        using vec_type = typename std::remove_reference_t<decltype(vec)>::value_type;
        if constexpr (std::is_same_v<vec_type, int>)
            std::cout << "vector of int:" << std::endl;
        else if constexpr (std::is_same_v<vec_type, std::string>)
            std::cout << "vector of string:" << std::endl;
        for (const auto& x : vec)
            std::cout << x << std::endl;
    };
    
    std::visit(visit_vec, get_vector(-1));
    std::visit(visit_vec, get_vector(1));

    return 0;
}

在 Coliru上现场观看。

在上面的代码中，该函数get_vector返回一个std::variant包含 astd::vector<int>或 a的对象std::vector<std::string>。使用 . 检查返回对象的内容std::visit。

于 2020-08-18T08:10:14.693 回答
4

这完全取决于您要完成的工作，但是如何做到这一点有多种可能性。以下是一些我想到的：

如果在函数内部确定了特定的返回类型列表之一：

由于您编辑了您的问题，这似乎是您想要的。您可以尝试boost::variant：

boost::variant<int, double, std::string> foo() {
    if (something) 
        //set type to int
    else if (something else)
        //set type to double
    else
        //set type to std::string
}

如果返回类型取决于模板参数：

您可以使用 SFINAE 来操作重载决议：

template<typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
std::vector<int> foo() {...}

template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
std::vector<std::string> foo() {...}

如果返回类型可以是任何东西：

Aboost::any会很好用：

boost::any foo() {...}

如果返回类型总是派生自特定类：

返回一个指向基类的智能指针：

std::unique_ptr<Base> foo() {
    if (something)
        return std::unique_ptr<Base>{new Derived1};
    if (something else) 
        return std::unique_ptr<Base>{new Derived2};
}
于 2013-07-15T08:03:41.547 回答
2

如果在调用函数之前知道要返回什么类型，则可以使用模板。但是你不能有一个函数，它在内部决定返回某种类型。

您可以做的是创建一个类，该类将作为返回数据的容器，用所需数据填充此类的对象，然后返回该对象。

typedef enum { VSTRING, VINT, V_WHATEVER ... } datatype;

class MyReturnClass {

    datatype d;

    // now either
    vector<string> * vs;
    vector<int> * vi;

    // or
    void * vector;      

 }

 MyReturnClass * thisIsTheFunction () {

       MyReturnClass * return_me = new MyReturnClass();

       return_me->datatype = VSTRING;
       return_me->vs = new Vector<String>;

       return return_me;

 }
于 2013-07-15T07:56:33.317 回答