访问类树层次结构中的对象时避免使用空指针

Question

我必须使用基于树的对象层次结构，我需要在其中访问包含应用程序所需数据的最深元素。我不确定前面的陈述是否最好地解释了问题本身，所以最好用一个例子来说明它。鉴于以下情况：

class A {
private:
    B* _b;
public:
    B* getB() {return _b;}
};

class B {
private:
    C* _c;
public:
    C* getC() {return _c;}
};

class C {
private:
    int _n;
public:
    int getN() {return _n;}
};

所需的操作是通过 A 访问 n。所以我会调用以下内容：

A foo;
foo.getB()->getC()->getN();

当路径的任何部分为空时，问题就出现了，我们最终会产生核心转储。在上述场景中，如果 B 为空，我们将进入核心转储场景。

因此，我就可以用来避免这种核心转储情况的任何策略或模式寻求帮助和建议。如果路径非常大，我最终会检查每个指针是否有效，并最终得到非常丑陋的代码，并且还有可能错过检查路径的一部分的风险。 注意：我无权更改类（A、B、C）的层次结构的实现，因为它们是生成的代码，我无权更改生成器。是我的首选解决方案，但不幸的是我不能。

Answer 1

为了避免出现空指针，您可能希望建立一个成员永远不会为空的类不变量。这可以通过以下步骤来实现：

1. 封装对成员的访问，这样类外的任何东西都不能设置该成员。您已经通过使用私有访问实现了这一点。只需确保将引用或指向成员的指针从成员函数传递/返回到外部即可。
2. 确保没有任何成员或朋友函数将成员设置为 null。
3. 还要确保成员始终被初始化。这是通过使用自定义构造函数来实现的。示例：

---

class A {
    B* b;
public:
    A(B* b) : b(b) {
        if (!b) {
            // unlike indirection through null pointer, an exception can
            // be caught and (potentially) handled gracefully at runtime
            throw std::runtime_error("Naughty!");
        }
    }

    // following prevents passing null literal at compile time
    A(std::nullptr_t) = delete; // nullptr
    A(int)            = delete; // 0

    // since it is never null, we can safely return a reference
    B& getB() {return *b;}
}

虽然引用具有永远不会为空的良好属性，但它们作为成员却很棘手，因为它们也不可赋值。作为构造函数的参数，它们很棘手，因为通常不习惯或不期望类对象保留对传递给构造函数的对象的引用。因此，我主张在这种情况下使用指针，即使不需要 null。

注意：我无权更改类（A、B、C）的层次结构的实现，因为它们是生成的代码，我无权更改生成器。

在这种情况下，您可以用更好的类来包装生成的类：

class AWrapper {
    A a;
    // custom implementation that encapsulates A
}

---

如果空指针是无法避免的有效值，那么这样的不变量当然是不可能的。在这种情况下，您必须在间接通过它之前检查指针是否为空：

if (B* b = foo.getB())
    if (C* c = b->getC())
        c->getN();

您可能会考虑的另一件事是是否所有这些指针都是必要的。如果这些类相互包含而不是间接地相互引用，也许会更简单。

Answer 2

你需要一路测试：

A foo;
B* BPrt = foo.getB();
if (BPrt)
{
    C* CPtr = BPrt->getC();
    if (CPtr)
    {
        int n = CPtr->getN();
        ...

Answer 3

这是我解决问题的方法：

#include <iostream>
using namespace std;

class C {
private:
    int _n;
public:
    int getN() {return _n;}
};

class B {
private:
    C* _c;
public:
    C* getC() {return _c;}
};


class A {
private:
    B* _b;
public:
    B* getB() {return _b;}
};

int main(void);
int main() {
    static B b;
    static C c;
    static A foo; 
    unsigned int n;
    B *bPtr; C *cPtr;

    /* --RECODE (CHAIN-CALL): foo.getB()->getC()->getN();-- */
    bPtr = (B *) (foo.getB());
    cPtr = (C *) (bPtr ? bPtr->getC() : 0);
    n    = (int) (cPtr ? cPtr->getN() : 0);
    /* --USE (CAST) and (TERNARY) instead of (CHAIN-CALL)-- */

    cout << n << endl;
    return n;
}

Answer 4

如果类不能更改，则可以通过模板进行检查：

template <typename T, typename A, typename ...Args>
auto recurse(T t, A a, Args... args)
{
    if (!t)
        throw std::exception{};
    auto next = (t->*a)();
    if constexpr (sizeof...(Args) > 0)
        return recurse(next, args...);
    else
        return next;
}

Then call as follows:

recurse(&foo, &A::getB, &B::getC, &C::getN);

Answer 5

问题不在于指针为null。这实际上很好，因为它大多在运行时崩溃。如果它不是 null 但之前已被释放/删除怎么办？使用可能会导致未定义的行为。

如果可以的话，更好的方法是使用引用：

class A
{
private:
  B& _b;
public:
  A(B& b): _b{b} {}
  B& getB ()
  {
    return _b;
  }
};

或者类似的东西。然后你至少没有任何悬空的东西（除非你也在某处使用指针）。

如果您必须使用指针，请使用其中一个智能指针 - 看看 std::unique_ptr 是否可以为您解决问题。如果不是，那么对于共享所有权使用std::shared_ptr 等等。还要确保初始化对象的方式不会导致那里出现默认的 null。

Answer 6

如果可能的话，你可以确保你的指针总是被初始化：

class C {
private:
    int _n = 0;
public:
    int getN() {return _n;}
};


class B {
private:
    static C default_c;
    C* _c = &default_c;
public:
    C& getC() {return *_c;}
};

C B::default_c; // An out-of-line static member definition is required.

class A {
private:
    static B default_b;
    B* _b = &default_b;
public:
    B& getB() {return *_b;}
};

B A::default_b; // An out-of-line static member definition is required.

int main() {
    A a;
    std::cout << a.getB().getC().getN() << '\n';
}

请注意，指针比引用更能成为成员，因为引用破坏了值语义并使您的类不可赋值。

Answer 7

您是否考虑过：

try {
foo.getB()->getC()->getN();
}
catch(...)
{
    //Here you know something is Null
}

在处理现有代码时，这似乎是最简单最安全的。