围绕基本类型的 C++ 类包装器

Question

我见过/使用过的许多库都有 typedef 来提供可移植的、固定大小的变量，例如 int8、uint8、int16、uint16 等，无论平台如何，它们都是正确的大小(c++11 自己用 header stdint.h)

最近在我编写的小型库中使用了二进制文件 i/o 之后，我可以看到以这种方式使用 typedef 以确保代码可移植的好处。

但是，如果我不厌其烦地输入“namespace::uint32”而不是使用内置的基本类型，我也可以尽可能地使用替换。因此我正在考虑使用类而不是简单的 typedef。

这些包装类将实现所有普通运算符，因此可以与基本类型互换使用。

例如:

int x = 0;
//do stuff

可以变成

class intWrapper {
//whatever
};

intWrapper = 0;
//do stuff

无需修改“//do stuff”中的任何代码

我之所以考虑这种方法而不仅仅是 typedefs，是因为我已经有了对基本类型进行操作的函数，例如

std::string numberToString(double toConvert);

std::string numberToHexString(double toConvert);

int intToXSignificantPlaces(const int& number, 
                               unsigned char numberOfSignificantPlaces);

bool numbersAreApproximatelyEqual(float tollerance);
//etc....

从语法上讲，执行以下操作会更好(也更 oop):

intWrapper.toString();
intWrapper.toHexString();
//etc

此外，它还允许我实现 bigint 类(int128 等)，并让那些和较小的类(基于基本类型)使用相同的接口(interface)。

最后，每个包装器都可以有一个自身的静态实例，称为 max 和 min，因此 int32::max 和 int32::min 的漂亮语法将成为可能。

但是，在执行此操作之前，我想解决一些问题(因为它主要是语法糖，并且这些类型将被广泛使用，任何额外的开销都可能对性能产生重大影响)。

1) 仅在 int a + int b 上使用 someClass.operator+()、someClass.operator-() 等时是否有任何额外的函数调用开销？如果是这样，内联 operator+() 会消除所有这些开销吗？

2) 所有外部函数都需要原始类型，例如 glVertex3f(float, float, float) 不能简单地传递 3 个 floatWrapper 对象，有没有办法自动让编译器将 floatWrapper 转换为 float？如果是，是否会影响性能？

3) 是否有任何额外的内存开销？我理解(？)具有继承的类具有某种虚拟表指针，因此使用的内存略多(或者仅用于虚拟函数？)，但假设这些包装类不是从/不是子类继承的，则不存在'使用类而不是基本类型没有任何额外的内存使用，是吗？

4) 这可能会导致任何其他问题/性能影响吗？

Answer 1

1) Is there any additional function calling overhead when using someClass.operator+()

不会，如果函数体很小并且在函数头，它会被内联，没有开销

2) Is there a way to automatically make the compiler cast the floatWrapper to a float?

struct floatWrapper {
    floatWrapper(float); //implicit conversion from float
    operator float(); //implicit conversion to float.  
};

同样，如果函数体很小并且在函数头中，它将被内联，并且没有开销

3) Is there any additional memory overhead?

如果没有虚函数则不会。如果一个类声明或继承了任何虚函数，则该类称为多态。如果类不是多态的，则对象不需要包含指向虚函数表的指针。此外，不允许将对非多态类的指针/引用沿继承层次向下执行动态转换为对派生类的指针/引用，因此对象不需要具有某种类型信息。

4) Are there any other problems / performance impacts this could cause?

性能？没有。

此外，确保实现不将 lhs 修改为自由函数的二元运算符，并重载它们以支持 floatWrapper 和 float 的所有相关排列。

struct floatWrapper {
    explicit floatWrapper(float);
    operator float(); //implicit conversion to float.  
    floatWrapper operator-=(float);
};
floatWrapper operator-(floatWrapper lhs, floatWrapper rhs) 
{return lhs-=rhs;}
floatWrapper operator-(float lhs, floatWrapper rhs) 
{return floatWrapper(lhs)-=rhs;}
floatWrapper operator-(floatWrapper lhs, float rhs) 
{return lhs-=rhs;}

Here's my attempt at such a thing .请注意，对于 float/double/long double，您需要一个略有不同的版本。