c++ - 在 union 中正确使用 std::reference_wrapper

Question

有人可以解释一下这个模式有什么问题吗？当我尝试编译它时，我得到以下每种类型的错误。

错误:“operator=”不匹配(操作数类型为“std::reference_wrapperstd::__cxx11::basic_string >”和“int”)string_reference = 属性；

struct PropertyPointer {
    int type;
    std::string name;
    union {
        std::reference_wrapper<int*> int_reference;
        std::reference_wrapper<double*> double_reference;
        std::reference_wrapper<float*> float_reference;
        std::reference_wrapper<std::string*> string_reference;
    };
    PropertyPointer(std::string name, auto&& property): name{name} {
        if(std::is_same<decltype(property), int*>::value) {
            type = 'i';
            int_reference = property;
        }
        else if(std::is_same<decltype(property), double*>::value) {
            type = 'd';
            double_reference = property;
        }
        else if(std::is_same<decltype(property), float*>::value) {
            type = 'f';
            float_reference = property;
        }
        else if(std::is_same<decltype(property), std::string*>::value) {
            type = 's';
            string_reference = property;
        }
    }
};

Answer 1

问题的答案

if 语句未标记为 constexpr

您的代码无法编译的原因是，即使 if 语句在编译时被评估为 false，那些 if 语句包含的分支也会被编译。

在您的示例中，您可以将那些 if 语句标记为 constexpr 以编译代码。但是，它(可能)不会像您预期的那样工作，因为 property 的类型将是您传递给构造函数的指针的右值。

这是我如何让它工作的一个例子(如果我正确理解你想做什么的话:

struct PropertyPointer {
    int type;
    std::string name;
    union {
        std::reference_wrapper<int*> int_reference;
        std::reference_wrapper<double*> double_reference;
        std::reference_wrapper<float*> float_reference;
        std::reference_wrapper<std::string*> string_reference;
    };
    PropertyPointer(std::string name, auto&& property): name{name} {
        using Type = ::std::remove_cvref_t<decltype(property)>;
        if constexpr (std::is_same<Type, int*>::value) {
            type = 'i';
            int_reference = property;
        } else if constexpr (std::is_same<Type, double*>::value) {
            type = 'd';
            double_reference = property;
        } else if constexpr (std::is_same<Type, float*>::value) {
            type = 'f';
            float_reference = property;
        } else if constexpr (std::is_same<Type, std::string*>::value) {
            type = 's';
            string_reference = property;
        }
    }
};

标准::变体

在我看来，您对 std::variant 并不熟悉。

The class template std::variant represents a type-safe union.

source

它的工作是用具有额外功能的类型安全类替换 union (这是一个 C 特性)。

这里是一个简单的例子，说明我将如何做到这一点:

class PropertyPointer {
public:
    PropertyPointer(
        auto&& property
    )
        : m_value{ &property }
    {
        // compare types if you want it to compile but have the object empty
    }

    template <
        typename T
    > [[ nodiscard ]] bool hasType() // true if the types matches the one inside (pointer or not)
    {
        using Type = ::std::remove_cvref_t<::std::remove_pointer_t<::std::remove_cvref_t<T>>>;
        return std::holds_alternative<Type*>(m_value);
    }

private:
    ::std::variant<int*, float*, double*, ::std::string*> m_value;
};

int main()
{
    PropertyPointer property{ ::std::string{ "yes" } };
    property.hasType<int>(); // false
    property.hasType<float>(); // false
    property.hasType<double>(); // false
    property.hasType<::std::string>(); // true
    property.hasType<const ::std::string>(); // true
    property.hasType<::std::string&>(); // true
    property.hasType<const ::std::string*>(); // true
    property.hasType<const ::std::string *const>(); // true
}

这个例子是为了向您展示您可以添加一些额外的功能，例如比较有无指针的相同行为。

这里的示例并不是要告诉您“它必须如何完成”，而是一个现代 c++ 功能如何让您的生活更轻松的示例。