当前位置：首页 > news >正文

C++ 编程技巧之StrongType(1)

news 2025/7/19 0:57:16

最近看到一个NamedType的开源库，被里面的Strong Type这个概念和里面的模版实现给秀了一脸，特此总结学习一下

GitHub - joboccara/NamedType: Implementation of strong types in C++

C++本身是一种强类型语言，类型包括int、double等这些build in类型以及class类型，强类型的意思是所有变量的类型在编译阶段应该都是确定的。上面提到的Strong Type并不是这个意思，在C++中，Strong Type（强类型）是一种编程技巧，是对C++的类型进行加强的意思。

它用于定义一种类型安全的机制，使得编译器能够区分语义相似但实际意义不同的类型，从而避免因类型混淆导致的潜在错误。这种技术常见于处理需要区分类似数据的场景，比如标识符、单位、或封装基本数据类型以增强可读性和安全性。Strong Type在某种程度上和C++的自定义字面量有点相似，本文也对他们进行一些对比。

强类型的基本思想

强类型通常是通过封装一个原始类型（如 int, double 等）实现的，我们可以先看如下示例来感受一下用法

通过简单封装赋予语义

struct Meters {
double value;
};struct Seconds {
double value;
};Meters operator+(Meters lhs, Meters rhs) {return Meters{lhs.value + rhs.value};
}// 用法
Meters distance1{5.0};
Meters distance2{10.0};
Meters total = distance1 + distance2; // OK
// Seconds time = distance1; // 编译错误，类型不兼容

通过模板实现通用强类型

template <typename Tag, typename T>
class StrongType {
public:
explicit StrongType(T value) : value_(value) {}
T get() const { return value_; }private:
T value_;
};// 标识语义的标签
struct UserIdTag {};
struct ProductIdTag {};using UserId = StrongType<UserIdTag, int>;
using ProductId = StrongType<ProductIdTag, int>;UserId uid(42);
ProductId pid(101);// pid = uid; // 编译错误，类型不兼容

强类型与操作符重载

如果需要增强强类型的可用性，可以为其定义操作符：

template <typename Tag, typename T>
class StrongType {
public:
explicit StrongType(T value) : value_(value) {}
T get() const { return value_; }// 支持操作符重载
StrongType operator+(const StrongType& other) const {return StrongType(value_ + other.value_);
}private:
T value_;
};struct DistanceTag {};
using Distance = StrongType<DistanceTag, double>;// 用法
Distance d1(5.0), d2(10.0);
Distance total = d1 + d2; // OK

应用场景

标识符区分：避免混淆例如用户 ID 和产品 ID 等数据。
物理量单位：避免直接使用 double 等基础类型混淆不同单位的数值（如米和秒）。
类型安全接口：增强类型安全，避免误用相似类型的数据。
业务逻辑抽象：为关键业务对象创建显式的类型，增强代码可读性和可维护性。

Strong Type 和 C++字面量

上面Strong Type的思想其实和C++字面量有异曲同工之妙，我们不妨也来总结一下C+++自定义字面量的知识。

用户自定义字面量是 C++ 提供的扩展功能，通过为特定的字面量（如整型、浮点型、字符串等）自定义行为，可以实现特定语义，例如单位转换、数据封装等。自定义字面量通常使用 operator"" 实现。

基本语法

用户自定义字面量是通过重载 operator"" 实现的，后面可以接字面量标识符。根据传入的参数类型，用户自定义字面量分为以下几种形式：

参数类型	示例	常用场景
`const char*`	`"example"_id`	处理字符串类型
`unsigned long long`	`42_kg`	处理整型字面量
`long double`	`3.14_m`	处理浮点型字面量
`char`	`'c'_symbol`	处理字符字面量
`const char*, size_t`	`"hello"_custom`	处理字符串并获得长度

自定义字面量实现

以下是针对不同类型的自定义字面量的实现方式：

整型字面量

#include <iostream>// 自定义字面量，用于单位转换
constexpr unsigned long long operator"" _kg(unsigned long long value) {return value * 1000; // 转换为克
}int main() {auto weight = 5_kg; // 表示 5 公斤std::cout << "Weight in grams: " << weight << " g\n"; // 输出 5000 greturn 0;
}

浮点型字面量

#include <iostream>// 自定义字面量，用于单位转换
constexpr long double operator"" _m(long double value) {return value * 100; // 转换为厘米
}int main() {auto length = 2.5_m; // 表示 2.5 米std::cout << "Length in cm: " << length << " cm\n"; // 输出 250 cmreturn 0;
}

字符串字面量

#include <iostream>
#include <string>// 自定义字面量，处理字符串
std::string operator"" _hello(const char* str, size_t) {return std::string("Hello, ") + str;
}int main() {auto greeting = "World"_hello; // 添加 "Hello, "std::cout << greeting << std::endl; // 输出 "Hello, World"return 0;
}

字符串和长度字面量

C++20 前，可以通过传递字符串和长度参数实现更灵活的功能：

#include <iostream>// 自定义字面量，打印字符串和长度
void operator"" _log(const char* str, size_t len) {std::cout << "String: " << str << ", Length: " << len << std::endl;
}int main() {"Hello World"_log; // 输出 String: Hello World, Length: 11return 0;
}

C++自定义字面量也可以给变量赋予直接的语义信息，但是功能比较单一，而Strong Type通过类的封装，可以实现更复杂的功能。

Strong Type 和 C++字面量结合

#include <iostream>// 定义强类型 Distance
struct Distance {explicit Distance(double meters) : meters_(meters) {}double getMeters() const { return meters_; }
private:double meters_;
};// 自定义字面量
constexpr Distance operator"" _km(long double value) {return Distance(static_cast<double>(value * 1000.0));
}int main() {Distance d = 1.5_km; // 使用字面量创建强类型对象std::cout << "Distance: " << d.getMeters() << " meters" << std::endl; // 输出 1500 metersreturn 0;
}