是否有安全的导航操作员C++?

Question

在现代C++中，有没有办法进行安全导航？

例如，而不是做...

if (p && p->q && p->q->r)
p->q->r->DoSomething();

。通过使用某种短路智能指针或利用运算符重载的某种其他类型的语法，或标准C++库或 Boost 中的某些内容，具有简洁的语法。

p?->q?->r?->DoSomething(); // C++ pseudo-code.

上下文尤其C++17。

Answer 1

你能做的最好的事情就是将所有成员访问折叠到一个函数中。这假设没有检查所有内容都是指针：

template <class C, class PM, class... PMs>
auto access(C* c, PM pm, PMs... pms) {
if constexpr(sizeof...(pms) == 0) {
return c ? std::invoke(pm, c) : nullptr;
} else {
return c ? access(std::invoke(pm, c), pms...) : nullptr;
}
}

这使您可以编写：

if (auto r = access(p, &P::q, &Q::r); r) {
r->doSomething();
}

没关系。或者，您可以对运算符重载进行一些疯狂处理，并生成类似以下内容的内容：

template <class T>
struct wrap {
wrap(T* t) : t(t) { }
T* t;
template <class PM>
auto operator->*(PM pm) {
return ::wrap{t ? std::invoke(pm, t) : nullptr};
}
explicit operator bool() const { return t; }
T* operator->() { return t; }
};

这使您可以编写：

if (auto r = wrap{p}->*&P::q->*&Q::r; r) {
r->doSomething();
}

那也没关系。不幸的是，没有像运算符->?或.?，所以我们不得不绕过边缘。

Answer 2

"带有一点样板...">

我们可以得到这个：

p >> q >> r >> doSomething();

这是样板...

#include <iostream>
struct R {
void doSomething()
{
std::cout << "somethingn";
}
};
struct Q {
R* r;
};
struct P {
Q* q;
};
struct get_r {};
constexpr auto r = get_r{};
struct get_q {};
constexpr auto q = get_q{};
struct do_something {
constexpr auto operator()() const {
return *this;
}
};
constexpr auto doSomething = do_something {};
auto operator >> (P* p, get_q) -> Q* {
if (p) return p->q;
else return nullptr;
}
auto operator >> (Q* q, get_r) -> R* {
if (q) return q->r;
else return nullptr;
}
auto operator >> (R* r, do_something)
{
if (r) r->doSomething();
}
void foo(P* p)
{
//if (p && p->q && p->q->r)
//    p->q->r->DoSomething();
p >> q >> r >> doSomething();
}

由此产生的程序集非常可以接受。到这一点的旅程可能不是...

foo(P*):
test    rdi, rdi
je      .L21
mov     rax, QWORD PTR [rdi]
test    rax, rax
je      .L21
cmp     QWORD PTR [rax], 0
je      .L21
mov     edx, 10
mov     esi, OFFSET FLAT:.LC0
mov     edi, OFFSET FLAT:std::cout
jmp     std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
.L21:
ret

Answer 3

虽然现在是 2022 年，但仍然没有语言级别的支持。 我可以弄清楚一个非常接近的模拟：

template <typename T, typename F>
auto operator->*(T&& t, F&& f) {
return f(std::forward<T>(t));
}
#define pcall(fn)                                                            
[&](auto&& __p) {                                                          
if constexpr (std::is_pointer_v<std::remove_reference_t<decltype(__p)>>) 
return __p ? __p->fn : decltype(__p->fn){};                            
else                                                                     
return __p ? __p.fn : decltype(__p.fn){};                              
}
struct A {
int v;
int foo(int a, int b) { return a + b + v; }
};
struct B {
A* getA() { return &a; }
A a{100};
};
struct C {
B* getB() { return &b; }
B b;
operator bool() { return true; }
};
int main(){
int v = 3;
C by_val;
int t1 = by_val->*pcall(getB())->*pcall(getA())->*pcall(foo(1, v));
C* by_ptr = &by_val;
int t2 = by_ptr->*pcall(getB())->*pcall(getA())->*pcall(foo(1, v));
}

https://godbolt.org/z/zPhzTTv9s