我经常遇到这样的情况(在我的 C++/C++11 代码中)，我的类型基本上表现得像内置类型(或“基本简单”类型，如 std::string ), 但这是有意义的 超出 32 位数字或一堆字符。 我没有在互联网上找到任何有用的东西，因为我真的不知道要搜索什么术语...

例子:

• 我曾经在一个系统上工作，其中的项目由 ID 标识。这些 ID 是 std::string(一开始可能不是最好的主意，但那是另一回事)。真正糟糕的是，这些 ID 作为 std::string 或 const char* 通过系统传递。所以很难(不可能)说出 搜索类型时使用了代码库 ID。变量名称是 ID(ID, id, Id) 或 key 或只是 i 或 name 或其他任何形式的所有变体。所以你也不能按名字搜索。所以我更愿意将这些变量作为 id_t 类型传递。
• 网络端口:它们是uint16_t。但我想将它们作为 network_port_t 传递。

我通常使用 typedef 来使事情变得更好。但是这种方法有多个问题:

• 您不必使用 typedef。您仍然可以通过“原始”类型传递变量(例如 std::string 而不是 id_t)。
• 如果原始类型是模板，您就完成了前向声明 typedef(例如使用 shared_ptr)。
• “转发声明”typedef 是一个维护问题。如果原始类型发生变化，您需要更改所有地方的内容。

我在网络端口示例中尝试的另一件事是编写一个带有 operator uint16_t 的瘦包装类。这解决了前向声明的问题。但后来我跑了 陷入一些在内部使用 printf 的日志记录宏的陷阱。 printfs 仍然有效(好吧，已编译)，但没有打印端口号，而是(我认为)对象的地址。

我想像重量或长度这样的尺寸 Boost.Units 可能值得一看(即使它看起来有点“重”)。但对于上面的两个例子，它不适合。

实现我想要的目标的最佳实践是什么(使用 Boost 是一种选择)？

简而言之: 我想要实现的是将“具有更高含义的类型”作为自己的类型传递，而不是作为普通的原始/低级/非抽象类型传递。 (有点)像拥有用户定义的类型。最好不要为每个类型编写一个具有基本相同实现的完整类的巨大开销，而只能做内置函数已经可以做的事情。

最佳答案

1。强类型定义

您可以使用 BOOST_STRONG_TYPEDEF 来获得一些便利。

它确实使用了宏，我认为您可以进行异构比较(例如 id == "123")。

有两个版本，一定要从 Boost Utility 拿一个。

2。 flavor 字符串<>

对于字符串，您可以使用 flavor 字符串(发明人:R.Martinho Fernandes)来欺骗系统。

这利用了这样一个事实，即您实际上可以改变 std::basic_string 上的特征。 ，并创建实际上不同的标记别名:

#include <string>
#include <iostream>

namespace dessert {
    template <typename Tag>
    struct not_quite_the_same_traits : std::char_traits<char> {};
    template <typename Tag>
    using strong_string_alias = std::basic_string<char, not_quite_the_same_traits<Tag>>;

    using vanilla_string = std::string;
    using strawberry_string = strong_string_alias<struct strawberry>;
    using caramel_string = strong_string_alias<struct caramel>;
    using chocolate_string = strong_string_alias<struct chocolate>;

    template <typename T>
    struct special;

    template <typename T>
    using special_string = strong_string_alias<special<T>>;

    std::ostream& operator<<(std::ostream& os, vanilla_string const& s) {
        return os << "vanilla: " << s.data();
    }
    std::ostream& operator<<(std::ostream& os, strawberry_string const& s) {
        return os << "strawberry: " << s.data();
    }
    std::ostream& operator<<(std::ostream& os, caramel_string const& s) {
        return os << "caramel: " << s.data();
    }
    std::ostream& operator<<(std::ostream& os, chocolate_string const& s) {
        return os << "chocolate: " << s.data();
    }

    template <typename T>
    std::ostream& operator<<(std::ostream& os, special_string<T> const& s) {
        return os << "special: " << s.data();
    }
}

int main() {
    dessert::vanilla_string vanilla = "foo";
    dessert::strawberry_string strawberry = "foo";
    dessert::caramel_string caramel = "foo";
    dessert::chocolate_string chocolate = "foo";

    std::cout << vanilla << '\n';
    std::cout << strawberry << '\n';
    std::cout << caramel << '\n';
    std::cout << chocolate << '\n';

    dessert::special_string<struct nuts> nuts = "foo";
    std::cout << nuts << '\n';
}

关于c++ - 具有更高含义的简单类型 (C++11)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26038401/