Question

我正在创建一个知识处理器＆＃34;它可以处理多种形式的数据。我计划支持的数据形式是文本，视觉和听觉。每个都可以分别通过TEXT，VISUAL和AUDIO表示。因此，每个＆＃34;知识＆＃34;或数据都在一个名为＆＃34; know_t＆＃34;的结构中表示。

#define VISUAL 0
#define AUDIO  1
#define TEXT   2

struct know_t {
    k_type_t type;
    text_k_t text_value;
    visual_k_t visual_value;
    audio_k_t audio_value;
};

k_type_t是int的类型定义。它用于存储＆＃34;类型＆＃34;的数据，可以在代码片段的开头用#define＆＃39; d宏表示。

说实话，我正在为处理器编写搜索算法。这些类型中的每一种，VISUAL，AUDIO和TEXT都可以用＆＃34;原型＆＃34;形成。例如，TEXT数据可以通过std :: string表示。这些原型形式的数据将用于搜索知识数据库。为了便于搜索，我创建了一个名为＆＃34; search_t＆＃34;代表搜索。

struct search_t {
    k_type_t type;
    visual_t visual_value;
    audio_t audio_value;
    std::string text_value;

    bool operator == (const struct __search_t &in);
};

现在这里的结构可能看起来与上面的结构几乎完全相同，但是它们非常不同。例如，虽然类型＆＃34; k_type_t＆＃34;包含字符串的数据，例如定义，std :: string是用于搜索的数据的一种形式。所有其他形式的数据也是如此。

我正在使用C ++的unordered_map来完成搜索。 ISO C ++标准规定，对于unordered_map，哈希函数和＆＃34; ==＆＃34;在这种情况下，密钥类型search_t需要operator。为此，我决定编写一个get_value函数，该函数返回搜索结构的原型值。问题是随着数据类型的变化，返回类型会发生变化。

到目前为止，我已经为==运算符编写了以下代码，但是我的编译器（带-std = c ++ 11的GCC 4.8.1）似乎并不喜欢它。

#define test(in) in.type == VISUAL ? in.visual_value : \
                 in.type == AUDIO  ? in.audio_value  : \
                 in.type == TEXT   ? in.text_value   : NULL

bool search_t::operator == (const struct search_t &in) {
    auto getval_search = [](const search_t &in) -> decltype(test(in)) {
        if (in.type == __VISUAL__)
            return in.visual_value;
        if (in.type == __AUDIO__)
            return in.audio_value;
        if (in.type == __TEXT__)
            return in.text_value;
    }

    bool equal = (bool)((this->type) == in.type);
    if (!equal)
        return false;

    search_t tmp = *this; // bugfix
    if (getval_search(tmp) == getval_search(in))
        return true;
}

有没有办法解决这个问题？

Answer 1

呀。解决它的简单方法是编写正常的==比较：

struct search_t { // because C++
    k_type_t type;
    visual_t visual_value;
    audio_t audio_value;
    std::string text_value;

    bool operator == (const search_t& in) const {
        return type == in.type && visual_value == in.visual_value
            && audio_value == in.audio_value && text_value == in.text_value;
    }
};

如果它真的只是基于类型，那么我想你可以这样做：

bool operator == (const search_t& in) const {
    if (type != in.type) return false;

    switch (type) {
    case __VISUAL__: return visual_value == in.visual_value;
    case __AUDIO__: return audio_value == in.audio_value;
    case __TEXT__: return text_value == in.text_value;
    default: return false; // or something
}

请注意，根据[global.names]：

，您的type是无效标识符

每个包含双下划线__的名称或以下划线后跟大写的名称开头信（2.12）保留给任何用途的实施。

最后，这可能不是一个很好的存储数据类型。考虑使用：

using search_t = boost::variant<visual_t, audio_t, std::string>;

基于输入参数的C ++返回类型推导

1 个答案: