c++ - 如何避免对具有组合关系的对象进行空检查

Question

首先，我可能会以错误的方式写下英语，因为它不是母语。对此感到抱歉。

无论如何，现在我面临着多次检查 null 的问题，因为我愿意处理的对象有很多对象作为它的成员。让我举个例子。

// def:
class A {
public:
    B* getB() { return _b; }
    D* getD() { return _d; }

private:
    B* _b;  
};

class B {
public:
    C* getC() { return _c; } // Train Wreck. but it's needed on my frw...
   ...
};

// usg:
void foo(A* got)
{
    if(!got)
         return;
    B* b = got->getB();
    if(!b)
         return;
    C* c = b->getC();
    if(!c)
         return;
    // do something...
}

如您所见，每次尝试访问成员数据时都会有 3 行。当然，我可以放一个宏来减少这些行。

#define WRD_GET_3(expr, res, ret) \
        _TGet<decltype(expr)>::set(expr);\
        WRD_IS_NULL_3(_TGet<decltype(expr)>::get(), res, ret)
#define WRD_GET_2(expr, ret) WRD_GET_3(expr, WRD_SPACE, ret)
#define WRD_GET_1(expr)  WRD_GET_2(expr, WRD_SPACE)
#define WRD_GET(...)     WRD_OVERLOAD(WRD_GET, __VA_ARGS__)

#define WRD_IS_NULL_3(VALUE, RES, RET)  \
    if((VALUE).isNull()) {              \
        RES.warn(#VALUE);               \
        return RET;                     \
    }

template <typename T>
class _TGet {
public:
    static T& set(T& expr) { return *store() = &expr, get(); }
    static T& get() { return **store(); }
    static T** store() {
        static T* inner = 0;
        return &inner;
    }
};


void foo(A* got)
{
    if(!got) return;
    B* b = WRD_GET(got->getB())
    C* c = WRD_GET(b->getC())
    if(!c) return;

    // do something...
}

但是，它仍然需要放置单行来访问子对象。有没有办法像下面那样做？

void foo(A* got)
{
    C* c = got->getB()->getC();
    // if got or got->getB() is nullptr, c will got assigned to nullptr.
    // without exception.

    // do something...
}

听说过 trainwreck anipatt。但想坚持当前的类(class)设计。

提前致谢。

C.F，我认为第一个 sol 是在每个 getter 方法上放置“if stmt”。

B* A::getB() {
    if(!this) return nullptr;
}

它适用于大多数用法，但不适用于虚拟方法。 (当然是因为vtable)。

编辑:抱歉为它留下消息来晚了。即使我改用 ref ，仍然有时间检查我持有的指针。我之前有过异常(exception)的想法，但担心它对我正在做的事情来说太昂贵了。最好使用 nullobject 或我的宏来解决。

感谢您的所有回复。

编辑2:出于某种原因，我回到了这个任务中，并通过重用上面编写的 WRD_GET 宏为我想做的事情制作了一个宏。

#define _PUT(exp) _TGet<TypeTrait<decltype(exp)>::Org>::set(exp)
#define _GET(exp) _TGet<TypeTrait<decltype(exp)>::Org>::get()
#define _NULR(exp) nulr<TypeTrait<decltype(exp)>::Org>()
#define WRD_GET_1(e1) _PUT(e1)
#define WRD_GET_2(e1, e2) WRD_GET_1(e1).isNull() ? _NULR(e1.e2) : _PUT(e1.e2)
#define WRD_GET_3(e1, e2, e3) _PUT(e1).isNull() ? _NULR(e1.e2.e3) : (_PUT(e1.e2).isNull() ? _NULR(e1.e2.e3) : _PUT(e1.e2.e3))
#define WRD_GET_4(e1, e2, e3, e4) _PUT(e1).isNull() ? _NULR(e1.e2.e3.e4) : (_PUT(e1.e2).isNull() ? _NULR(e1.e2.e3.e4) : (_PUT(e1.e2.e3).isNull() ? _NULR(e1.e2.e3.e4) : _PUT(e1.e2.e3.e4)))
#define WRD_GET(...)            WRD_OVERLOAD(WRD_GET, __VA_ARGS__)
// yes... it's looks dumb.

用法

// as-is:
A* a = getA();
if(!a) return;
B* b = a.getB();
if(!b) return;
C* c = b.getC();
if(!c) return;

// to-be:
C* c = WRD_GET(getA(), getB(), getC()); // when I can recognize those commas into dots, It's pretty intuitive to me.

WRD_GET 已经设计用于避免双重调用问题。这一次，新的 WRD_GET 宏被扩展为通过获取对您提供的空传播页面的提示来接受不止 1 次访问。谢谢。

无论如何，即使它可以避免双重调用，它仍然需要放置和调用额外的 g/setter 并且它可能会稍微损失性能。并且代码可以通过类似 FOR 宏来改进。但是，嗯，它在我的环境中很有效。

Answer 1

实际上，this 指针不能为 null(如果在指定 this 时引用已经存在，它将是一个引用)，所以您的 if 检查是徒劳的:

B* A::getB()
{
    if(!this) return nullptr;
}

因为访问没有真实对象的非静态成员函数是未定义的行为:

A* a = nullptr;
a->getB();     // UB/illegal, whether you have the check inside getB or not!!!

如果您想避免检查空指针，请使用引用:

foo(A& a)
{
   B& b = a.getB();
}

与

B& A::getB() { return *_b; }
// but you need to guarantee that _b is never a null pointer!
// or you make, if it is never changed anyway, _b a reference as well

如果你不能保证 _b 存在，你也可以抛出:

B& A::getB()
{
    if(_b)
        return *_b;
    throw std::runtime_error("illegal state");
}

这样，如果函数返回，您就可以保证获得有效的引用。但是，这种方法会强制您在其他某个时间点捕获异常:

B* b = a.getB(); // assuming a being a reference already...
if(b)
{
    // use b
}
else
{
    // handle b not existing
}

对比

try
{
    B& b = a.getB();
    // use b
}
catch(std::runtime_error const&)
{
    // handle b not existing
}

当然，您不需要将 try/catch 放在每个访问器周围，但可以将它放在更大的 block 周围:

try
{
    B& b = a.getB();
    C& c = b.getC();
    D& d = c.getD();
    // use d

    // even this is valid:
    D& dd = a.getB().getC().getD();
    // as the exception will prevent the next function calls in the chain
}
catch(std::runtime_error const&)
{
}

您甚至可以让异常传播得更远，然后才捕获它(在 `foo 之外)。

至少，您应该在 main 中捕获它以确保调用堆栈上对象的析构函数(从而使 RAII 工作)。

请注意，随着 foo 签名的改变，您可能需要检查 foo 外部的指针:

A a;
foo(a); // fine; especially: no check that is not needed

A* p = ...;
if(p)        // needed unless that you are 100% sure that the pointer is valid
    foo(*p);

不过，在某些系统上，异常处理可能很昂贵。如果 A 无法提供 B 对象是一种相当正常/常见的情况，您可能更愿意继续显式检查指针。