6

有没有人在 C++ 中实现了一个空传播运算符，类似于函数式语言中使用的那个？我正在考虑一些巧妙的模板解决方案，可能类似于 operator-> 的传播行为。

假设我们有一个来自图表的对象链，例如foo->bar->baz（对不起，得墨忒耳定律）。假设其中任何一个都可以为空，并且应该在取消引用之前进行测试。然后代码突然变得复杂得多：

if( !foo )
  return nullptr;
if( !foo->bar )
  return nullptr;
return foo->bar->baz;

我想用某种紧凑的语法“分解”空检查，如下所示：

foo?->bar?->baz   // imaginary null-propagation syntax

现在，当然它不必看起来像那样，只要几乎一样紧凑。我想需要的是 C++ 中的 monad，启用空测试和“延续”。最好避免使用宏和 lambda，但这可能是不可能的。this我可以想象在每一步都重载 operator->() 并在为 null 时短路。

但这是非常侵入性的。理想的解决方案是将链中的每个对象包装起来。

4

3 回答 3

10

在您设计的这个阶段，这可能是一个彻底的背离，但也许可以考虑使用Null Object Pattern。那么你根本不需要任何空检查。

于 2013-05-01T00:09:06.777 回答
1

tldr; 我严重怀疑 C++ 能否做到这一点。

不幸的是，我不相信它可以完成（没有预处理器）。我的代码总是看起来像

type function(type parent) {
    if (parent==nullptr || parent->child==nullptr)
        return null;
    //do stuff with parent->child->grandchild
}

事实上，你提到“在每一步重载 operator->() 并在它为空时短路。”，但我认为即使是这样也做不到（没有预处理器）。如果它被重载，你可以operator->()返回 null，但如果this是，null那么调用operator->()已经是未定义的行为。即使不是，它也可能已经返回null。你可以让它抛出一个异常，但我认为这条路径比我上面提到的代码要复杂得多。

使用预处理器，可能会有一些东西，但我的第一个想法是丑陋和危险的

#define MAYBENULL1(X, Y) (X?(X->Y,nullptr)
#define MAYBENULL2(X, Y, Z) (X&&X->Y?X->Y->Z,nullptr)
#define MAYBENULL3(X, Y, Z, W) (X&&X->Y&&X->Y->Z?X->Y->Z->W,nullptr)

type function(type parent) {return MAYBENULL2(parent, child, grandchild);}

但你知道有人会搞砸的。

parent* get_next_parent();
type function() {return MAYBENULL1(get_next_parent(), child);}
于 2013-05-01T00:06:29.333 回答
1

C# 中有两种类型的空值传播。第一个是如您所描述的，如果foo为空，则返回空，但如果foo不为空，则返回foo->bar。

这在 C++ 中已经不那么复杂或难以阅读了。

return (foo) ? (foo->bar) ? foo->bar->baz : nullptr : nullptr;

看起来你不能制作一个宏来允许像我上面那样嵌套内联条件。

#define Maybe(X, Y) (X)?X->Y:nullptr
// Attempted nested usage:
return Maybe(foo, Maybe(foo->bar, baz));
//     ^ VS2015 complains here saying "Expected a member name".

但是考虑到宏是多么冗长，即使它有效，我也看不出它比最初使用的内联条件有多么优越。

然而，有一个模板解决方案甚至可以解决 Mooing Duck 在他的回答中指出的“双重呼叫”问题。

template<typename T_Return, typename T_X, T_Return* T_X::*Y>
T_Return* Maybe(T_X* pX)
{
    return (pX) ? pX->*Y : nullptr;
}

//Usage:
// Type is required, so assume the struct Foo contains a Bar* and Bar contains a Baz*.
return Maybe<Baz, Bar, &Bar::baz>(Maybe<Bar, Foo, &Foo::bar(foo));

当然，虽然这符合要求，但它是荒谬和迟钝的。

然而，值得注意的是，还有第二种类型的 Null Propagation 用于调用方法，这意味着它不需要“else”情况。它相当于：

// C# code here.
if(foo != null) { foo.Bar(); }

在 C# 中，您可以：

foo?.Bar()

这是一个更容易尝试使用宏进行复制的功能，并且它更“适合”普通语法。

// C++ Null Propagation
#define Maybe(X) if (auto tempX = (X)) tempX

//Usage
Maybe(GetFoo())->Bar();

//Or for setting a variable:
Maybe(GetFoo()->bar = new Bar();

它之所以有效，是因为它没有使用 ?: 速记，而是使用普通的内联 if 语句。

请记住，这仅具有调用方法或设置成员的目的。

但是，如果您真的很坚持，您可以执行以下操作：

#define ReturnMaybe(X, Y) auto tempX = X; \
if (tempX != nullptr) \
{ \
    return tempX->Y; \
} \
else \
{ \
    return nullptr; \
} \

可以内联到：

#define ReturnMaybe(X, Y) auto tempX = X; if(tempX) { return tempX->Y; }else{return nullptr;}

// Usage
Bar* GetBar()
{
    ReturnMaybe(GetFoo(), bar)
}

但这不能被链接起来，并且考虑到几乎所有可能性的冗长（可能除了方法调用 null 传播），您不会完全解决上述任何解决方案的任何问题。

编辑 - 使模板化的答案稍微好一些。

编辑 2 - 正在与同事讨论这个问题，并提出了一些其他选择：

#define Maybe(X) (X==nullptr) ? nullptr : X

用法：

return Maybe(foo)->bar;

有趣的是，这也适用于调用方法的情况。

Maybe(foo)->Bar();

因为它扩展的内容是有效的（尽管很奇怪）

(foo == nullptr) ? nullptr : foo->Bar();

但是，因为您不能在 ?: 简写中放置变量声明，所以您无法防止

return Maybe(get_next_parent())->child;

就像 Mooing Duck 描述的那样，需要自己创建一个临时的。

于 2016-11-28T15:12:34.820 回答