返回未知类型的函数

Question

class Test
{
public:

 SOMETHING DoIt(int a)
 {
  float FLOAT = 1.2;
  int INT = 2;
  char CHAR = 'a';

  switch(a)
  {
  case 1: return INT;
  case 2: return FLOAT;
  case 3: return CHAR;
  }
 }
};


int main(int argc, char* argv[])
{  
 Test obj;
 cout<<obj.DoIt(1);    
    return 0;
}

现在，使用 a = 1 意味着我需要返回一个整数等知识，Doit() 是否可以返回可变数据类型的变量？

本质上，我用什么替换 SOMETHING ？

PS：我正在尝试寻找一种替代方法来返回包含这些数据类型的结构/联合。

Answer 1

SOMETHING = void*

您必须转换返回的值，因此您必须知道返回的内容。

void* DoIt(int a)
    {
        float FLOAT = 1.2;
        int INT = 2;
        char CHAR = 'a';

        switch(a)
        {
        case 1: return ∫
        case 2: return &FLOAT;
        case 3: return &CHAR;
        }
    }

Answer 2

您可以使用 boost::any< /a> 或 boost::variant 做你想做的事。我推荐 boost::variant 因为您知道要返回的类型集合。

---

这是一个非常简单的示例，尽管您可以使用 variant 做更多事情。检查参考以获取更多示例:)

#include "boost/variant.hpp"
#include <iostream>

typedef boost::variant<char, int, double> myvariant;

myvariant fun(int value)
{
 if(value == 0)
 {
  return 1001;
 }
 else if(value  == 1)
 {
  return 3.2;
 }
  return 'V';
}

int main()
{
 myvariant v = fun(0);
 std::cout << v << std::endl;

 v = fun(1);
 std::cout << v << std::endl;

 v = fun(54151);
 std::cout << v << std::endl;
}

输出：

1001
3.2
V

我将使用 boost::variant 而不是 union 因为你不能在 中使用非 POD 类型联盟。另外，如果您不知道正在处理的类型，则 boost::any 非常有用。否则，我会使用 boost::variant 因为它更高效、更安全。

---

回答编辑后的问题：如果您不想随代码一起发布 Boost，请查看 bcp。来自同一链接的 bcp 描述：

bcp 实用程序是一个工具
提取Boost的子集，它是
对于想要的 Boost 作者很有用
单独分发他们的库
来自 Boost，以及 Boost 用户
想要分发 Boost 的子集
以及他们的应用程序。

bcp 还可以报告哪些部分
Boost 你的代码依赖于，并且
这些人使用什么许可证
依赖关系。

Answer 3

C++是强类型语言，没有未知类型的概念。您可以尝试使用 boost::any，它可以（某种程度上）指定任何类型。然而，我会质疑你的功能的设计。

Answer 4

如果您知道编译时的类型，则可以使用模板。如果类型取决于运行时，则不能选择使用模板。

class Test
{
  template<int> struct Int2Type {};
  template<>    struct Int2Type<1> { typedef int value_type; };
  template<>    struct Int2Type<2> { typedef float value_type; };
  template<>    struct Int2Type<3> { typedef char value_type; };

public:
  template<int x> typename Int2Type<x>::value_type DoIt() {}; // error if unknown type used
  template<> typename Int2Type<1>::value_type DoIt<1>() { return 2; };
  template<> typename Int2Type<2>::value_type DoIt<2>() { return 1.2f; };
  template<> typename Int2Type<3>::value_type DoIt<3>() { return 'a'; };
};

int main()
{
  Test obj;
  cout << obj.DoIt<2>(); 
  return 0;
}

Answer 5

编辑：使用 bcp 的 boost::any （感谢 AraK）似乎是迄今为止最好的解决方案，但是是否有可能（在某种程度上）证明这个问题不存在 ANSI C++ 解决方案？

您似乎对这里的术语有点困惑。

首先，我们将其称为 ISO C++，好吗？它于 1998 年由 ISO 标准化，从那时起，这就是人们在谈论“标准 C++”时所指的。
现在，“ANSI C++ 解决方案”是什么意思？

• 一个仅使用 ANSI（或 ISO）C++ 进行干净编译的解决方案？如果是这样，Boost是 ANSI C++ 解决方案
• 已经在 ANSI C++ 标准库中实现的解决方案吗？如果是这样，那么不，不存在这样的解决方案（并且没有“证据”，除了“通读语言标准，看看是否可以找到这样的类。如果不能，则它不存在”。
• 您可以仅使用 ANSI C++ 自己实现的解决方案然后答案是“是的，您可以从 Boost 复制源代码”，

我无法想象您会得到什么样的“证明” 。 C++ 是散文形式的文档，它不是一个数学方程，除非通过“去阅读标准”来证明。语言或标准库中的内容很容易 - 只需指出标准中的描述位置即可，但要证明不存在某些内容基本上是不可能的 - 除非枚举每个<。 /em> 标准的一句话，并记录它们都没有描述您正在寻找的内容，并且我怀疑您会找到愿意为您做的事情

无论如何，正确的标准 。 C++ 解决方案是使用Boost。
这不是一个重量级的解决方案。 Boost 非常轻量级，因为您可以准确包含您需要的位，而不依赖于库集合的其余部分。

根据您的描述（面向广泛用户群的轻型应用程序），没有理由不使用 Boost。它可以简化您的代码并减少因尝试重新发明轮子而导致的错误数量。分发编译后的可执行文件时，成本为零。与 Boost 的大部分内容一样，Boost.Any 库仅包含头文件，并且只需编译到可执行文件中即可。无需分发单独的库。

尝试重新发明轮子不会有任何收获。您的可执行文件不会更小或更高效，但它会出现更多错误。

我敢打赌，您自制的解决方案将不是是 ANSI C++。它将依赖于某种形式的未定义行为。如果您想要 ANSI-C++ 解决方案，那么最好的选择是 Boost。

Answer 6

使用 boost::any：

boost::any DoIt(int a)
{
    float FLOAT = 1.2;
    int INT = 2;
    char CHAR = 'a';

    switch(a)
    {
    case 1: return boost::any(INT);
    case 2: return boost::any( FLOAT);
    case 3: return boost::any( CHAR);
    }
}

Answer 7

实现这样的事情的通常方法是 C，它并不总是在 C++ 中工作，而是使用联合和类型字段：

enum SomeType { INT, FLOAT, CHAR };
struct Something
{
    SomeType type;
    union
    {
        int i;
        float f;
        char c;
    };
};

Something DoIt(int a)
{
    Something s;
    switch (a)
    {
      case 1:
        s.type = INT;
        s.i = 2;
        break;
      case 2:
        s.type = FLOAT;
        s.f = 1.2;
        break;
      case 3:
        s.type = CHAR;
        s.c = 'a';
        break;
      default:
        // ???
    }
    return s;
}

当可能的值类型之一是具有非 - 的类时，这在 C++ 中不起作用。简单的构造函数，因为并不总是清楚应该调用哪个构造函数。 Boost.Variant 使用了更复杂的版本为 C++ 中的任何值类型提供这种构造的方法。

Answer 8

您可以使用包含指向您想要返回的值的 void* 以及指示要返回的对象的大小的 size_t 的结构。像这样的事情：

struct Something {
    void *value;
    size_t size;
};

记住void*应该指向驻留在堆上的值（即使用new或malloc动态分配）并且调用者应该负责释放分配的对象。

话虽如此，我认为总体来说这是一个坏主意。

编辑：您可能还需要考虑包含一个标志，指示上述结构中返回的内容，以便调用者可以理解它，除非调用者知道期望的类型。

Answer 9

你可以使用联合：

typedef union {
  int i;
  float f;
  char c;
} retType;

retType DoIt(int a){
  retType ret;

  float FLOAT = 1.2;
  int INT = 2;
  char CHAR = 'a';

  switch(a)
  {
    case 1: ret.i = INT; break;
    case 2: ret.f = FLOAT; break;
    case 3: ret.c = CHAR; break;
  }
  return ret;
}

Answer 10

Adobe Source Libraries 还具有 adobe::any_regular_t，它允许您可以存储任何类型，只要它符合 常规 概念即可。您可以像使用 boost::any 一样包装返回值。 （链接页面上还有关于 adobe::any_regular_t 与 boost::any 有何不同的文档 - 当然，您选择的类型应该取决于你的代码。）

Answer 11

您可以通过引用传递，并进行类型保存并检查它是否同时工作，也不会涉及任何额外的库（您的 ansi C++ 解决方案）：

bool DoIt (int i, int & r1)
{
  if (i==1) {r1 = 5; return true}
  return false;
}

bool DoIt (int i, double & r2)
{
  if (i==2) {r2 = 1.2; return true}
  return false;
}

...

我发现这个解决方案在设计方面通常更干净。不幸的是，函数签名不允许多种类型作为返回类型，但这样您就可以传递任何内容。

Answer 12

从 C++17 开始，有 std::any< /a> 和 std::variant，这意味着您不需要第三方库。根据@Arak 的回答，代码将进行如下修改。

#include <variant>
#include <any>
#include <iostream>

typedef std::variant<char, int, double> myvariant;

myvariant fun(int value)
{
   if(value == 0)
   {
      return 1001;
   }
   else if(value  == 1)
   {
      return 3.2;
   }
   return 'V';
}

int main()
{
   myvariant v = fun(0);
   std::cout << v << std::endl;

   v = fun(1);
   std::cout << v << std::endl;

   v = fun(54151);
   std::cout << v << std::endl;
}

Answer 13

如果用户知道放入的内容，您可以使用模板来解决此问题。如果没有，我想不出任何解决办法。

Answer 14

我认为问题出在这个功能设计上。你尝试过超载吗？

class Test
{

public:

int DoIt(int a) {

  int INT = 2;
   return INT;

} 

float DoIt(float a) {

float FLOAT = 1.2; 
return FLOAT;

} 

char DoIt(char a) {

char CHAR = 'a'; 
return CHAR;

} 

};


int main(int argc, char* argv[])
{       
    Test obj;

//....

switch(a)
case 1: 
    cout<< obj.DoIt(1);    
break;

case 2:
cout<< obj.DoIt(1.01);   
break;

case 3:
cout<< obj.DoIt("1");   
break;

    return 0;
}

在 DoIt 函数内部，您可以放置​​更多代码并让它们调用其他函数以避免重复代码。