有沒有一種簡單的方法來檢查 C++ 中的不安全表達式？

Question

我正在嘗試找到一種 [更好的] 方法來運行/檢查可能不安全的表達式或以更優雅的方式執行多個 null 檢查。

這是我想改進的代碼示例：

if (myObjectPointer &&
    myObjectPointer->getSubObject() &&
    myObjectPointer->getSubObject()->getSubSubObject() &&
    myObjectPointer->getSubObject()->getSubSubObject()->getTarget()) {

  // Use safely target
  ... *(myObjectPointer->getSubObject()->getSubSubObject()->getTarget()) ...
}

我試圖找到一種更優雅的方法來實現這一點（而不是上面冗長的 null 檢查）。 這是我的第一個想法：

template<typename T>
bool isSafe(T && function) {
   try {
       function(); 
       // Just running the func above, but we could e.g. think about returning the actual value instead of true/fase - not that important. 
       return true;
    }
    catch (...) {
       return false;
    }
}

...
// And use the above as follow :
if(isSafe([&](){ myObjectPointer->getSubObject()->getSubSubObject()->getTarget(); })) {
    // Use safely target
}
...

上面的問題是我們無法捕獲信號（Segmentation fault，...）。 而且我顯然不想處理程序中的所有信號，而只是在這個非常具體的檢查/評估 function 中。

我是不是以錯誤的方式解決問題？ 還有其他建議嗎？ 還是冗長的 if 是不可避免的？

提前謝謝了。

Answer 1

我在想這個，就像 Jarod42 說的，一定有一些可變參數模板的東西。 我在這方面不是最好的，但想出了這個：

#include <memory>
#include <functional>
#include <iostream>

template <typename T, typename MemFn, typename... Params> 
void safeExecute(T* ptr, MemFn memFn, Params&&... params) {
    if (ptr != nullptr)
        safeExecute(std::invoke(memFn, ptr), std::forward<Params>(params)...);
}

template <typename T, typename MemFn>
void safeExecute(T* ptr, MemFn memFn) {
    if (ptr != nullptr) std::invoke(memFn, ptr);
}


struct Target {
    void Bar() { std::cout << "tada!\n"; };
};


template<typename T>
class Object {
private:
    std::unique_ptr<T> ptr;
public:
    Object() : ptr(std::make_unique<T>()) {}

    T* Get() { return ptr.get(); }
};

using SubSubObject = Object<Target>;
using SubObject = Object<SubSubObject>;
using MyObject = Object<SubObject>;

int main() {
    auto myObjectPtr = std::make_unique<MyObject>();

    safeExecute(myObjectPtr.get(),
                &MyObject::Get,
                &SubObject::Get,
                &SubSubObject::Get,
                &Target::Bar);
}

---

編輯：我一直在嘗試使用更通用的返回類型，所以我嘗試了不調用成員 function 的選項，而是返回指向 object 的 std::optional 指針。 這導致我使用以下代碼：

#include <memory>
#include <functional>
#include <iostream>
#include <optional>

template <typename T, typename MemFn, typename... Params>
auto safeGetObject(T* ptr, MemFn memFn, Params&&... params)
    -> decltype(safeGetObject(std::invoke(memFn, std::declval<T>()), std::forward<Params>(params)...))
{
    if (ptr != nullptr) return safeGetObject(std::invoke(memFn, ptr), std::forward<Params>(params)...);
    return {};
}

template <typename T, typename MemFn>
auto safeGetObject(T* ptr, MemFn memFn) -> std::optional<decltype(std::invoke(memFn, std::declval<T>()))> {
    if (ptr != nullptr) return std::invoke(memFn, ptr);
    return {};
}

struct Target {
    int Bar(int a, int b) const noexcept {
        return a+b;
    };
};

template<typename T>
class Object {
private:
    std::unique_ptr<T> ptr;
public:
    Object() noexcept : ptr(std::make_unique<T>()) {}

    T* Get() const noexcept { return ptr.get(); }
};

using SubSubObject = Object<Target>;
using SubObject = Object<SubSubObject>;
using MyObject = Object<SubObject>;

int main() {
    auto myObjectPtr = std::make_unique<MyObject>();

    auto optionalTarget = safeGetObject(
        myObjectPtr.get(),
        &MyObject::Get,
        &SubObject::Get,
        &SubSubObject::Get);

    auto result = optionalTarget ? optionalTarget.value()->Bar(3, 4) : -1;
    std::cout << " result " << result << '\n';
}

Answer 2

拋開可能的設計問題，您可以使用std::optional的擴展版本。 由於並非所有接口都在您的控制之下，因此您必須將必要的函數包裝到自由函數中。 假設您可以更改myObjectPointer的 class MyClass ，但不能更改子對象的類。

class MyClass  {
public:
    optional<std::reference_wrapper<SubObjectClass>> getSubObject();
};

optional<std::reference_wrapper<SubSubObjectClass>> getSubSubObject(SubObjectClass& s) {
    SubSubObjectClass* ptr = s.getSubSubObject();

    if (ptr) {
        return std::ref(s.getSubSubObject());
    } else {
        return {};
    }
}

optional<std::reference_wrapper<Target>> getTarget(SubSubObjectCLass& s) {
    ...
}

你現在可以寫類似

optional<MyClass*>  myObjectPointer = ...;
myObjectPointer.and_then(MyClass::getSubObject)
               .and_then(getSubSubObject)
               .and_then(getTarget)
               .map( doSomethingWithTarget ):

Answer 3

好的，我可能會刪除我之前的答案，因為我一直在重新考慮這一點，現在考慮使用 std::optional 和鏈接。 你的原創

myObjectPointer->getSubObject()->getSubSubObject()->getTarget()

不是真正可重現的，因為operator->()不能是 static。 但是我們可以使用另一個運算符，例如operator>>() 。 因此：

#include <memory>
#include <iostream>
#include <optional>
#include <functional>

struct Target {
    int Bar(int a, int b) const noexcept { return a+b; };
};

template<typename T>
class Object {
private:
    T* const ptr;
public:
    Object(T* ptr) noexcept : ptr(ptr) {}
    T* Get() const noexcept { return ptr; }
};

using SubSubObject = Object<Target>;
using SubObject = Object<SubSubObject>;
using MyObject = Object<SubObject>;

template <typename T>
auto makeOptional(T* ptr) -> std::optional< std::reference_wrapper<T>> {
    if (ptr) return std::ref(*ptr);
    return {};
}

template <typename T, typename MemFn>
auto operator>> (std::optional<std::reference_wrapper<T>> optObj, MemFn memFn)
-> std::optional< std::reference_wrapper<std::remove_pointer_t<decltype(std::invoke(memFn, std::declval<T>()))>>> {
    if (optObj) return makeOptional(std::invoke(memFn, *optObj));
    return {};
}


int main() {
    {
        //complete
        auto TargetPtr = std::make_unique<Target>();
        auto subSubObjectPtr = std::make_unique<SubSubObject>(TargetPtr.get());
        auto subObjectPtr = std::make_unique<SubObject>(subSubObjectPtr.get());
        auto myObjectPtr = std::make_unique<MyObject>(subObjectPtr.get());

        auto optionalMyObject = makeOptional(myObjectPtr.get());

        auto optionalTarget = optionalMyObject >> &MyObject::Get >> &SubObject::Get >> &SubSubObject::Get;

        auto result = (optionalTarget) ? optionalTarget->get().Bar(3, 4) : -1;

        std::cout << "result is " << result << '\n';
    }
    {
        // incomplete
        auto subObjectPtr = std::make_unique<SubObject>(nullptr);
        auto myObjectPtr = std::make_unique<MyObject>(subObjectPtr.get());

        auto optionalMyObject = makeOptional(myObjectPtr.get());

        auto optionalTarget = optionalMyObject >> &MyObject::Get >> &SubObject::Get >> &SubSubObject::Get;

        auto result = (optionalTarget) ? optionalTarget->get().Bar(3, 4) : -1;

        std::cout << "result is " << result << '\n';
    }
}

會工作......讓我知道這是否是你要找的。

---

編輯：我也試過把它放在包裝器 class

#include <memory>
#include <iostream>
#include <functional>
#include <optional>

struct Target {
    constexpr int Bar(int a, int b) const noexcept { return a + b; };
};

template<typename T>
class Object {
private:
    T* const ptr;
public:
    constexpr Object(T* const ptr) noexcept : ptr(ptr) {}
    constexpr T* Get() const noexcept { return ptr; }
};

using SubSubObject = Object<Target>;
using SubObject = Object<SubSubObject>;
using MyObject = Object<SubObject>;

template<typename T>
class ObjectWrapper {
private:
    std::optional<std::reference_wrapper<T>> optRefObj{};
public:
    constexpr ObjectWrapper(T* ptr) noexcept
        : optRefObj(ptr ? std::make_optional(std::ref(*ptr)) : std::nullopt)
    {}

    template<typename MemFn>
    constexpr auto operator>>(MemFn memFn) const noexcept {
        return ObjectWrapper<std::remove_pointer_t<decltype(std::invoke(memFn, std::declval<T>()))>>
            (optRefObj ? std::invoke(memFn, *optRefObj) : nullptr);
    }

    constexpr operator bool() const noexcept { return optRefObj.has_value(); }

    constexpr T* Get() noexcept { return optRefObj ? &optRefObj->get() : nullptr; }
};

int main() {
    {
        //complete
        auto const TargetPtr = std::make_unique<Target>();
        auto const subSubObjectPtr = std::make_unique<SubSubObject>(TargetPtr.get());
        auto const subObjectPtr = std::make_unique<SubObject>(subSubObjectPtr.get());
        auto const myObjectPtr = std::make_unique<MyObject>(subObjectPtr.get());

        auto const myObjWrp = ObjectWrapper(myObjectPtr.get());

        auto optionalTarget = myObjWrp >> &MyObject::Get >> &SubObject::Get >> &SubSubObject::Get;

        auto const result = optionalTarget ? optionalTarget.Get()->Bar(3, 4) : -1;

        std::cout << "result is " << result << '\n';
    }
    {
        // incomplete
        auto const subObjectPtr = std::make_unique<SubObject>(nullptr);
        auto const myObjectPtr = std::make_unique<MyObject>(subObjectPtr.get());

        auto const myObjWrp = ObjectWrapper(myObjectPtr.get());

        auto optionalTarget = myObjWrp >> &MyObject::Get >> &SubObject::Get >> &SubSubObject::Get;

        auto const result = optionalTarget ? optionalTarget.Get()->Bar(3, 4) : -1;

        std::cout << "result is " << result << '\n';
    }
}