区分typedef

Question

我正在为C库编写C ++抽象。 C库具有用于标识远程资源的ID的几种typedef：

typedef int color_id;
typedef int smell_id;
typedef int flavor_id;
// ...

color_id createColor( connection* );
void destroyColor( connection*, color_id );
// ...

所有这些typedef在编译器看来都是相同的类型。这对我来说是个问题，因为我想重载函数并专门化模板以提供一个不错的C ++友好API：

// can't do the following since `color_id`, `smell_id` and `int` are the same
std::ostream& operator<<( std::ostream&, color_id );
std::ostream& operator<<( std::ostream&, smell_id );
void destroy( connection*, color_id );
void destroy( connection*, smell_id );

// no static check can prevent the following
smell_id smell = createSmell( connection );
destroyColor( connection, smell ); // it's a smell, not a color!

• 我该如何区分这些ID，以利用类型安全性和重载/专业化功能和类？

---

由于我不知道其他任何方式，因此我一直在考虑为每种C类型创建不同的包装器类型。但是这条路似乎很崎......

1. 已经有很多代码专门用于原始类型（例如std::hash）。
   有没有办法告诉编译器类似“如果某项对int有专门化，但对于我的包装却没有，那么只需使用int专门化”？
   我是否应该为std::hash之类的东西写专业化课程？不在std中的类似模板结构如何处理（例如boost，Qt等中的东西）？

2. 我应该使用隐式还是显式构造函数和强制转换运算符？显式的当然更安全，但是与使用C API的现有代码和第三方库进行交互将使其非常乏味。

无论是谁，我都乐于接受任何提示！

Answer 1

一个包装器类将其全部统治

您最好的选择是创建一个包装器类，但是使用模板，我们可以编写一个包装器类模板，并将其分配给模板的不同实例，然后将其用于所有不同的ID。

template<class ID> 
struct ID_wrapper
{
    constexpr static auto name() -> decltype(ID::name()) {
        return ID::name(); 
    }
    int value;

    // Implicitly convertible to `int`, for C operability
    operator int() const {
        return value; 
    }  
};

重载std::hash（仅一次）

我们可以在ID类中保留我们想要的任何特征，但是我提供了name()作为示例。由于ID_Wrapper是作为模板编写的，因此专门用于std::hash和其他类只需要做一次：

template<class ID>
class std::hash<ID_wrapper<ID>> : public std::hash<int>
{
   public:
    // I prefer using Base to typing out the actual base
    using Base = std::hash<int>;

    // Provide argument_type and result_type
    using argument_type = int;
    using result_type = std::size_t; 

    // Use the base class's constructor and function call operator
    using Base::Base; 
    using Base::operator(); 
};

打印出具有其名称的ID

如果您愿意，我们也可以专门研究operator<<，但是ID_wrapper仍可以隐式转换为int：

template<class ID>
std::ostream& operator<<(std::ostream& stream, ID_Wrapper<ID> id) {
    stream << '(' << ID_Wrapper<ID>::name() << ": " << id.value << ')'; 
    return stream; 
}

有了这些，我们只需为每种ID类型编写一个traits类！

struct ColorIDTraits {
    constexpr static const char* name() {
        return "color_id";
    }
};

struct SmellIDTraits {
    constexpr static const char* name() {
        return "smell_id";
    }
};

struct FlavorIDTraits {
    constexpr static const char* name() {
        return "flavor_id";
    }
};

将它们包装在一起

然后我们可以typedef ID_wrapper：

using color_id = ID_wrapper<ColorIDTraits>;
using smell_id = ID_wrapper<SmellIDTraits>;
using flavor_id = ID_wrapper<FlavorIDTraits>;

Answer 2

使用@MooDuck所说的BOOST_STRONG_TYPEDEF。