6

是否可以从函数返回一个空对？意思是，遵循函数原型的规则，但对中没有任何元素（例如NULL）。了解一对只是存在，所以我不知道这在概念上是否可行。如果有意义的话，我需要返回一个 NULL 或空的对。

例如，

pair<int, int> MyClass::someFunction()
{

   // do something that means we need to return an empty pair
   return NULL; // <--- this does not work obviously
}

不幸的是，提升对我来说是不可能的。

4

5 回答 5

6

一般来说，空对甚至没有意义。毕竟pair，根据定义，a 是一个包含两个对象的容器。

但是，您可以使用Boost.Optional制作类似空对的东西。然后，您可以使用 aboost::optional<std::pair<...>>为您提供返回一对或空状态的选项，或者使用std::pair<boost::optional<...>, boost::optional<...>>一个对象可以为空的对。

于 2012-08-03T18:51:47.967 回答
3

通过考虑 C++ 编译器在这种情况下生成代码的方式，可以很容易地解释您的问题的答案。

std::pair<int, int>是按值返回的。

由于MyClass::someFunction()是按值返回对象，因此事件顺序如下：

  • 调用函数在堆栈上为一个std::pair<int, int>
  • 被MyClass::someFunction()称为
  • return 语句的右侧是对先前在堆栈中保留的位置的赋值。有一个std::pair<int, int>正在发生的隐含结构。

因此返回 NULL 指针是不可能的。

于 2012-08-03T19:24:40.850 回答
3

您可以返回指针...或使用boost::optional<T>. 可选的会更好...

boost::optional<std::pair<int, int> > MyClass::someFunction()
{
    return boost::optional<std::pair<int, int> >();
}

void f(const MyClass& f)
{
    boost::optional<std::pair<int, int> > ret = f.someFunction();
    if (!ret) // empty
    {
        ...
    }
}
于 2012-08-03T18:51:10.293 回答
2

创建自己的“可选对”（类似于boost::optional<std::pair<…&gt;>，但界面不同）并不需要太多，例如：

template <typename T1, typename T2> struct OptPair : std::pair<T1, T2>
{
  typedef std::pair<T1, T2> base_t;
  bool contains;
  OptPair() : contains(true) {}
  explicit OptPair(bool x) : contains(x) {}
  OptPair(const T1& x, const T2& y) : base_t(x, y), contains(true) {}
  template <class U, class V>
  OptPair(const std::pair<U,V> &p) : base_t(p), contains(true) {}
  template <class U, class V> OptPair(const OptPair<U,V> &p) : base_t(p), contains(p.contains) {}
  // No need to define operator=, as the default will construct an OptPair<T1, T2>
  // if necessary, then copy members into *this.
};

template <typename T1, typename T2>
OptPair<T1, T2> makeOptPair() { return OptPair<T1, T2>(); }

template <typename T1, typename T2>
OptPair<T1, T2> makeOptPair(const T1 &x, const T2 &y) {
  OptPair<T1, T2> p(true);
  p.first = x;
  p.second = y;
  return p;
}

template <typename OS, typename T1, typename T2>
OS &operator<<(OS &os, const OptPair<T1, T2>& p) {
  os << "<OptPair: ";
  if (p.contains) os << p.first << ", " << p.second;
  else os << "empty";
  os << ">";
  return os;
}

然后您可以像 std::pair 一样使用它（甚至可以将它与 std::pair 互换使用，来回分配值），但增加了将“空”值传回的能力，如下所示：

OptPair<int, int> someFunction()
{
   ...
   return OptPair<int, int>(false); 
}

您必须确保在使用之前检查结果，如下所示：

void doStuffWithPair(std::pair<int, int>);
void doStuffWithEmpty();
...
OptPair<int, int> ret = someFunction();
if (ret.contains) doStuffWithPair(ret);
else doStuffWithEmpty();
于 2012-08-03T19:17:30.173 回答
1

根据定义，一对有 2 个元素。它不可能没有。

你需要类似的东西boost::optional<std::pair<T1,T2>>。然后，您可以选择是否拥有一对。您可以在此处找到 boost::optional 的文档。

于 2012-08-03T18:49:01.257 回答