如何实现一个空对象？

Question

详情

我在此处 (https://softwareengineering.stackexchange.com/questions/152094/null-pointers-vs-null-object-pattern) 和此处 (http://en.wikipedia.org/wiki/Null_Object_pattern#C.2B.2B) 找到了有关 空对象模式 的一些信息。

但是，C++ 实现并没有说明我的用例。

我还看到了 Nullable Type (http://en.wikipedia.org/wiki/Nullable_type) 的相关链接。

用例

我有一个不属于层次结构的对象，通常不会在堆上分配。此外，没有一个方便的值可以用作标记来指示 null。希望下面的代码可以清楚地说明用例。

class ContrivedType
{
public:
    ContrivedType() :
        mValue(0)
    {
        // Do nothing
    }

    bool operator==(const ContrivedType& other) const
    {
        return mValue == other.mValue;
    }

    void setValue(std::uint16_t value)
    {
        mValue = value;
    }

private:
    // All values in the range [0, 65535] are valid for use
    std::uint16_t mValue;
};

class Foo
{
public:
    const ContrivedType getValue() const
    {
        return mValue;
    }

    void setValue(const ContrivedType &value)
    {
        mValue = value;
    }

private:
    ContrivedType mValue;
};

int main()
{
    Foo f;

    if (f.getValue() == ContrivedType())
    {
        // Ambiguous case
        // -    Was this value explicitly set to be the same value
        //      as when it's default constructed
        // OR
        // -    Was the value never set
    }

    return 0;
}

可能的解决方案 1

强制需要区分默认状态和未设置的ContrivedType用户使用指针并动态分配ContrivedType。也许是这样的？

class Foo
{
public:
    Foo() :
        mValue(nullptr)
    {
        // Do nothing
    }

    const ContrivedType* getValue() const
    {
        return mValue.get();
    }

    void setValue(const ContrivedType &value)
    {
        if (!mValue)
        {
            mValue.reset(new ContrivedType(value));
        }
        else
        {
            *mValue = value;
        }
    }

private:
    std::unique_ptr<ContrivedType> mValue;
};

现在很清楚ContrivedType 是否已设置。

可能的解决方案 2

更新ContrivedType的实现以支持null的概念。

class ContrivedType
{
public:
    ContrivedType() :
        mState(nullptr)
    {
        // Do nothing
    }

    explicit ContrivedType(std::uint16_t value) :
        mState(&mStorage)
    {
        mStorage.mValue = value;
    }

    bool isNull() const
    {
        return mState == nullptr;
    }

    bool operator==(const ContrivedType& other) const
    {
        if (!isNull())
        {
            return mStorage.mValue == other.mStorage.mValue;
        }
        else
        {
            return other.isNull();
        }
    }

    void setValue(std::uint16_t value)
    {
        mStorage.mValue = value;

        if (!mState)
        {
            mState = &mStorage;
        }
    }

private:
    struct State
    {
        // All values in the range [0, 65535] are valid for use
        std::uint16_t mValue;
    };

    State mStorage;

    // This will point to the storage when a value actually set
    State* mState;
};

问题

这个概念是否有既定的模式或习语？如果没有，有什么实施建议吗？

基本原理

在实际代码中，有一个或多个成员的类在某些情况下是可选的。这些类正在使用支持缺失字段（即可选字段）的协议通过套接字进行序列化。序列化可以跳过 optional 字段，而不是浪费字节序列化未明确设置的默认构造对象。例如，updateFoo(const Foo&) 函数。如果仅更新现有Foo 实例的子集，则只需序列化这些字段。

编辑

看起来std::experimental::optional（@myaut 提请我注意）是我想要使用的，但我无权访问它。

现在我需要使用适用于 Visual Studio 2013（2015 可能还可以）和 g++ 4.8 的解决方案。

Answer 1

来自this question（想点赞；）：

std::experimental::optional 源自 Boost.Optional 库，此实现在 Visual C++ 12.0 中运行良好（尽管它与 a little 不同）。参考单头实现，基于N3793提案论文，可以在here找到。

Visual Studio 附带的受支持的 C++11/14/1z 核心和库功能的最新列表可从 Visual C++ Team blog，尤其是 this post 中找到。一组来自微软的标准库实现（和一些扩展）的头文件可以查看here。

我最近尝到了它的滋味，花了一些精力来构建它，我设法使用它并且对它很满意。希望对您有所帮助。