Is there a safe navigation operator for C++?

by

The best you can do is collapse all the member accesses into one function. This assumes without checking that everything is a pointer:

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;
    }
}

Which lets you write:

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

That’s ok. Alternatively, you could go a little wild with operator overloading and produce something like:

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; }
};

which lets you write:

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

That’s also ok. There’s unfortunately no ->? or .? like operator, so we kind of have to work around the edges.

More Related Contents:

  1. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  2. What are Aggregates and PODs and how/why are they special?
  3. reinterpret_cast creating a trivially default-constructible object
  4. Deprecated header replacement
  5. Advantages of auto in template parameters in C++17
  6. What are template deduction guides and when should we use them?
  7. experimental::filesystem linker error
  8. Difference between “if constexpr()” Vs “if()”
  9. Strongly typed using and typedef
  10. Is a pointer with the right address and type still always a valid pointer since C++17?
  11. How is P0522R0 breaking code?
  12. Lambda implicit capture fails with variable declared from structured binding
  13. Simplest way to determine return type of function
  14. “If constexpr” in C++17 does not work in a non-templated function
  15. Link errors using members in C++17
  16. polymorphic_allocator: when and why should I use it?
  17. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  18. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  19. Compile-time or runtime detection within a constexpr function
  20. Are C++17 Parallel Algorithms implemented already?
  21. Partial class template argument deduction in C++17
  22. How to enable C++17 support in VSCode C++ Extension
  23. How do you implement Coroutines in C++
  24. Why isn’t RVO applied to base class subobject initialization?
  25. Using std::string_view with api that expects null-terminated string
  26. Convert std::variant to another std::variant with super-set of types
  27. What are the differences between std::variant and boost::variant?
  28. Directly write into char* buffer of std::string
  29. ‘std::filesystem’ has not been declared after including
  30. Undefined reference error with new filesystem library and clang++7

Leave a Comment