C++:将基类型完美透明地包装到一个类中？-6ren

C++:将基类型完美透明地包装到一个类中？

转载作者：行者123 更新时间：2023-11-30 05:34:23

我正在尝试开发一个完美包装基类型的类，以便人们可以像平常一样使用它们，但也可以扩展它们/添加新功能(c++11/c++14/etc 都很好) .到目前为止我还没有成功。这是我遇到的一个例子(这里我只实现了加号运算符，但我最终会实现它们):

template <class T>
class N
{
public:
  N() {};
  N(int _var) : var(_var) {};

  template<typename U = T,
           typename Arg,
           typename Return = 
           typename std::conditional<std::is_same<typename std::remove_cv<U>::type, long double>::value || std::is_same<typename std::remove_cv<Arg>::type, long double>::value, long double, 
            typename std::conditional<std::is_same<typename std::remove_cv<U>::type, double>::value || std::is_same<typename std::remove_cv<Arg>::type, double>::value, double, 
             typename std::conditional<std::is_same<typename std::remove_cv<U>::type, float>::value || std::is_same<typename std::remove_cv<Arg>::type, float>::value, float, 
              typename std::conditional<std::is_same<typename std::remove_cv<U>::type, unsigned long long>::value || std::is_unsigned<Arg>::value, unsigned long long, 
               typename std::conditional<std::is_same<typename std::remove_cv<U>::type, long long>::value || std::is_same<typename std::remove_cv<Arg>::type, long long>::value || std::is_same<typename std::remove_cv<U>::type, unsigned long long>::value || std::is_same<typename std::remove_cv<Arg>::type, unsigned long long>::value, long long, 
                typename std::conditional<std::is_same<typename std::remove_cv<U>::type, unsigned long>::value || std::is_unsigned<Arg>::value, unsigned long, 
                 typename std::conditional<std::is_same<typename std::remove_cv<U>::type, long>::value || std::is_same<typename std::remove_cv<Arg>::type, long>::value || std::is_same<typename std::remove_cv<U>::type, unsigned long>::value || std::is_same<typename std::remove_cv<Arg>::type, unsigned long>::value, long, 
                  typename std::conditional<std::is_same<typename std::remove_cv<U>::type, unsigned int>::value || std::is_unsigned<Arg>::value, unsigned int, 
                   typename std::conditional<std::is_same<typename std::remove_cv<U>::type, int>::value || std::is_same<typename std::remove_cv<Arg>::type, int>::value || std::is_same<typename std::remove_cv<U>::type, unsigned int>::value || std::is_same<typename std::remove_cv<Arg>::type, unsigned int>::value, int, 
                    typename std::conditional<std::is_same<typename std::remove_cv<U>::type, unsigned short>::value || std::is_unsigned<Arg>::value, unsigned short, 
                     typename std::conditional<std::is_same<typename std::remove_cv<U>::type, short>::value || std::is_same<typename std::remove_cv<Arg>::type, short>::value || std::is_same<typename std::remove_cv<U>::type, unsigned short>::value || std::is_same<typename std::remove_cv<Arg>::type, unsigned short>::value, short, 
                      typename std::conditional<std::is_same<typename std::remove_cv<U>::type, unsigned char>::value || std::is_unsigned<Arg>::value, unsigned char, 
                       typename std::conditional<std::is_same<typename std::remove_cv<U>::type, char>::value || std::is_same<typename std::remove_cv<Arg>::type, char>::value || std::is_same<typename std::remove_cv<U>::type, unsigned char>::value || std::is_same<typename std::remove_cv<Arg>::type, unsigned char>::value, char, 
                        typename std::conditional<std::is_same<typename std::remove_cv<U>::type, bool>::value, bool, void
                                                 >::type 
                                                >::type 
                                               >::type 
                                              >::type 
                                             >::type 
                                            >::type 
                                           >::type 
                                          >::type 
                                         >::type 
                                        >::type 
                                       >::type 
                                      >::type 
                                     >::type 
                                    >::type 
          >
  N<Return> operator+(const N<Arg>& i) const
    { return var+i; };

//#define CONVERSION(x)   template<typename U = T, typename = typename std::enable_if< std::is_same<U, x>::value >::type> operator x() const { return var; };
#define CONVERSION(x)   operator x() const { return var; };
  CONVERSION(bool);
  CONVERSION(char);
  CONVERSION(unsigned char);
  CONVERSION(short);
  CONVERSION(unsigned short);
  CONVERSION(int);
  CONVERSION(unsigned int);
  CONVERSION(long);
  CONVERSION(unsigned long);
  CONVERSION(long long);
  CONVERSION(unsigned long long);
  CONVERSION(float);
  CONVERSION(double);
  CONVERSION(long double);

  T var;
};

int main(int, char**)
{
  N<short> n1;
  N<int> n2;
  int d = n1;
  n1 + n2;
  return 0;
}

因此，基本上如您所见，我正在为它阐明条件系列中类型之间最小无损转换的基本逻辑。但是运行这个得到:

test.cpp: In instantiation of ‘N<Return> N<T>::operator+(const N<Arg>&) const [with U = short int; Arg = int; Return = int; T = short int]’:
test.cpp:2542:8:   required from here
test.cpp:2507:17: error: ambiguous overload for ‘operator+’ (operand types are ‘const short int’ and ‘const N<int>’)
     { return var+i; };
                 ^
test.cpp:2507:17: note: candidate: operator+(int, int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, unsigned int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, long int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, long unsigned int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, long long int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, long long unsigned int) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, float) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, double) <built-in>
test.cpp:2507:17: note: candidate: operator+(int, long double) <built-in>

...因为转换运算符都可以被调用，所以编译器认为所有这些对于我明确说明的转换来说都是同样有效的选项。现在，如果我们切换到注释掉的转换宏，以便为每种类型只启用一个转换运算符，我们将得到:

test.cpp: In function ‘int main(int, char**)’:
test.cpp:2541:11: error: cannot convert ‘N<short int>’ to ‘int’ in initialization
   int d = n1;
           ^

...因为编译器拒绝转换为 short 然后将其转换为 int，所以它需要显式的直接转换运算符。

我知道我显然可以通过在 main 函数中使用显式强制转换来做到这一点。但这不是重点，重点是透明包装，一个行为就像基类型(不需要显式转换)的类。

就目前而言，这在 C++ 中实际上是不可能的吗？ :(

最佳答案

我想我明白了每个人!这不是最漂亮的代码，但它似乎可以工作。首先，我会注意到我将问题分解为两个变体:“StrongNumber”，它试图始终返回一个包装的数字类；和“WeakNumber”，它总是尝试返回一个基本类型。关键是 - 是什么让它变得丑陋 - 避免使用模板。模板只会导致编译器混淆。

template <class T>
class StrongNumber
{
public:
  StrongNumber() {};
  StrongNumber(const T& _var) : var(_var) {};
  StrongNumber(const StrongNumber<T>& i) : var(i.var) {};

  #define DECLARE_HELPER(x, y) \
  auto operator x (const StrongNumber<long double>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };  \
  auto operator x (const StrongNumber<double>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };   \
  auto operator x (const StrongNumber<float>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };    \
  auto operator x (const StrongNumber<unsigned long long>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };   \
  auto operator x (const StrongNumber<long long>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };    \
  auto operator x (const StrongNumber<unsigned long>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };\
  auto operator x (const StrongNumber<long>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };     \
  auto operator x (const StrongNumber<unsigned int>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); }; \
  auto operator x (const StrongNumber<int>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };      \
  auto operator x (const StrongNumber<unsigned short>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };   \
  auto operator x (const StrongNumber<short>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };    \
  auto operator x (const StrongNumber<unsigned char>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };\
  auto operator x (const StrongNumber<char>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };     \
  auto operator x (const StrongNumber<bool>& i) y { return StrongNumber<decltype(var x i.var)>(var x i.var); };     \
  auto operator x (const long double i) y { return StrongNumber<decltype(var x i)>(var x i); };         \
  auto operator x (const double i) y { return StrongNumber<decltype(var x i)>(var x i); };              \
  auto operator x (const float i) y { return StrongNumber<decltype(var x i)>(var x i); };               \
  auto operator x (const unsigned long long i) y { return StrongNumber<decltype(var x i)>(var x i); };      \
  auto operator x (const long long i) y { return StrongNumber<decltype(var x i)>(var x i); };           \
  auto operator x (const unsigned long i) y { return StrongNumber<decltype(var x i)>(var x i); };           \
  auto operator x (const long i) y { return StrongNumber<decltype(var x i)>(var x i); };                \
  auto operator x (const unsigned int i) y { return StrongNumber<decltype(var x i)>(var x i); };            \
  auto operator x (const int i) y { return StrongNumber<decltype(var x i)>(var x i); };             \
  auto operator x (const unsigned short i) y { return StrongNumber<decltype(var x i)>(var x i); };          \
  auto operator x (const short i) y { return StrongNumber<decltype(var x i)>(var x i); };               \
  auto operator x (const unsigned char i) y { return StrongNumber<decltype(var x i)>(var x i); };           \
  auto operator x (const char i) y { return StrongNumber<decltype(var x i)>(var x i); };                \
  auto operator x (const bool i) y { return StrongNumber<decltype(var x i)>(var x i); };

  #define DECLARE(x)       DECLARE_HELPER(x, )
  #define DECLARE_CONST(x) DECLARE_HELPER(x, const)
  #define DECLARE_UNARY(x) auto operator x () { return StrongNumber<decltype(x var)>(x var); };
  #define DECLARE_UNARY_CONST(x) auto operator x () const { return StrongNumber<decltype(x var)>(x var); };

  operator T() const { return var; };

  DECLARE_CONST(%);
  DECLARE_CONST(+);
  DECLARE_CONST(-);
  DECLARE_CONST(*);
  DECLARE_CONST(/);
  DECLARE_CONST(&);
  DECLARE_CONST(|);
  DECLARE_CONST(^);
  DECLARE_CONST(<<);
  DECLARE_CONST(>>);
  DECLARE(=);
  DECLARE(+=);
  DECLARE(-=);
  DECLARE(*=);
  DECLARE(/=);
  DECLARE(&=);
  DECLARE(|=);
  DECLARE(^=);
  DECLARE(<<=);
  DECLARE(>>=);
  DECLARE_CONST(==);
  DECLARE_CONST(!=);
  DECLARE_CONST(>);
  DECLARE_CONST(<);
  DECLARE_CONST(>=);
  DECLARE_CONST(<=);
  DECLARE_UNARY(++);
  DECLARE_UNARY(--);
  DECLARE_UNARY_CONST(+);
  DECLARE_UNARY_CONST(-);
  DECLARE_UNARY_CONST(~);
  DECLARE_UNARY_CONST(!);
  explicit operator std::string() const { return std::to_string(var); };
  static int size() { return sizeof(T); };

  T var;
};

template <class T>
class WeakNumber
{
public:
  WeakNumber() {};
  WeakNumber(const T& _var) : var(_var) {};
  WeakNumber(const WeakNumber<T>& i) : var(i.var) {};

  #undef DECLARE_HELPER
  #define DECLARE_HELPER(x, y) \
  auto operator x (const WeakNumber<long double>& i) y { return var x i.var; }; \
  auto operator x (const WeakNumber<double>& i) y { return var x i.var; };      \
  auto operator x (const WeakNumber<float>& i) y { return var x i.var; };       \
  auto operator x (const WeakNumber<unsigned long long>& i) y { return var x i.var; };  \
  auto operator x (const WeakNumber<long long>& i) y { return var x i.var; };   \
  auto operator x (const WeakNumber<unsigned long>& i) y { return var x i.var; };   \
  auto operator x (const WeakNumber<long>& i) y { return var x i.var; };        \
  auto operator x (const WeakNumber<unsigned int>& i) y { return var x i.var; };    \
  auto operator x (const WeakNumber<int>& i) y { return var x i.var; };     \
  auto operator x (const WeakNumber<unsigned short>& i) y { return var x i.var; };  \
  auto operator x (const WeakNumber<short>& i) y { return var x i.var; };       \
  auto operator x (const WeakNumber<unsigned char>& i) y { return var x i.var; };   \
  auto operator x (const WeakNumber<char>& i) y { return var x i.var; };        \
  auto operator x (const WeakNumber<bool>& i) y { return var x i.var; };        \
  auto operator x (const long double i) y { return var x i; };          \
  auto operator x (const double i) y { return var x i; };           \
  auto operator x (const float i) y { return var x i; };            \
  auto operator x (const unsigned long long i) y { return var x i; };       \
  auto operator x (const long long i) y { return var x i; };            \
  auto operator x (const unsigned long i) y { return var x i; };        \
  auto operator x (const long i) y { return var x i; };             \
  auto operator x (const unsigned int i) y { return var x i; };         \
  auto operator x (const int i) y { return var x i; };              \
  auto operator x (const unsigned short i) y { return var x i; };       \
  auto operator x (const short i) y { return var x i; };            \
  auto operator x (const unsigned char i) y { return var x i; };        \
  auto operator x (const char i) y { return var x i; };             \
  auto operator x (const bool i) y { return var x i; };

  #undef DECLARE
  #undef DECLARE_CONST
  #undef DECLARE_UNARY
  #undef DECLARE_UNARY_CONST
  #define DECLARE(x)       DECLARE_HELPER(x, )
  #define DECLARE_CONST(x) DECLARE_HELPER(x, const)
  #define DECLARE_UNARY(x) auto operator x () { return x var; };
  #define DECLARE_UNARY_CONST(x) auto operator x () const { return x var; };

  operator T() const { return var; };

  DECLARE_CONST(%);
  DECLARE_CONST(+);
  DECLARE_CONST(-);
  DECLARE_CONST(*);
  DECLARE_CONST(/);
  DECLARE_CONST(&);
  DECLARE_CONST(|);
  DECLARE_CONST(^);
  DECLARE_CONST(<<);
  DECLARE_CONST(>>);
  DECLARE(=);
  DECLARE(+=);
  DECLARE(-=);
  DECLARE(*=);
  DECLARE(/=);
  DECLARE(&=);
  DECLARE(|=);
  DECLARE(^=);
  DECLARE(<<=);
  DECLARE(>>=);
  DECLARE_CONST(==);
  DECLARE_CONST(!=);
  DECLARE_CONST(>);
  DECLARE_CONST(<);
  DECLARE_CONST(>=);
  DECLARE_CONST(<=);
  DECLARE_UNARY(++);
  DECLARE_UNARY(--);
  DECLARE_UNARY_CONST(+);
  DECLARE_UNARY_CONST(-);
  DECLARE_UNARY_CONST(~);
  DECLARE_UNARY_CONST(!);
  // A couple more just because they're useful
  explicit operator std::string() const { return std::to_string(var); }; 
  static int size() { return sizeof(T); };

  T var;
};

所以，我在这里写了一个测试函数:

template<class T1, class T2, class T3>
T3 foo()
{
  StrongNumber<T1> n1;
  StrongNumber<T2> n2;
  T3 d = n1;
  n1 + n2;
  n1 + 1;
  n1 + 1.0;
  d = d + n1;
  d += 1 + n1;
  d += 1.0 + n1;
  return d;
}

...然后反复称它为:

std::cout << foo<short, long long, int>() << std::endl;

...等等。我让它尝试了基本类型的每一种组合(我写了一个快速的 bash 脚本来打印它们)，但没有一个给出编译错误。

所以，我认为这已经解决了! :) 我发誓，我曾经编写过的 C++ 程序中有三分之一需要像这样的类，并且过去编写过一些不太令人满意的程序……所以这将得到很多用处!

关于C++:将基类型完美透明地包装到一个类中？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34242451/

c - 完美/理想的哈希来隔离字谜
为了加速测试字谜字符串的快速输出行为，我 came up with基于质数的哈希方案——尽管它看起来像 I wasn't the first . 基本思想是将字母映射到素数，并计算这些素数的乘积。字母
swift - swift服务器中的同步或异步(完美)
我使用 Perfect Framework 创建了一个 Swift 3.0 服务器。一切都按预期进行得很好，但我正在尝试了解是否有更好的方法来做一些事情。来自 iOS 背景，我知道总是在不同的线程中
css - *完美*垂直图像对齐
我有一个固定大小的正方形 div，希望使用 CSS 在其中放置任意大小的图像，以便它在水平和垂直方向上都居中。横向很容易: .container { text-align: center } 对于垂直
十分钟配置“完美”终端
程序员离不开终端，配置一个好看又好用的终端，可以提高工作效率. 本篇文章记录了使用 Oh My Zsh + PowerLevel9k + zsh插件快速配置Ubuntu下默认终端的过程. 我们在
swift - 完美，快速，从处理程序中的请求获取服务器地址
在请求处理程序中，处理例如获取 https://example.com/collections/1或 POSThttp://0.0.0.0:8080/collections 如何获取服务器地址 htt
swift - 完美+SQLiteStORM，如何多次插入
我正在使用 perfect 和 SQLite司机和StORM作为连接器。我可以一一保存(创建)多行。为了使其更快，我想一次创建多行，我该怎么做？最佳答案从完美的 SQLite-StORM 和 Pe
vb.net - 在表单上居中(完美)动态创建的按钮？
这是我在这里的第一篇文章，所以我希望我提供所有正确的信息。我目前正在开发一个简单的菜单应用程序，它有一个按钮控制数组(使用 MSDN 建议的控制数组的变通方法)，我很难重新调整表单大小和将按钮居中。
Androidplot:将填充/边距设置为(完美)容纳轴标签
在 androidplot XYPlot 中，如果您有较大的值(许多数字)和/或较大的字体大小，则 Y 轴上的刻度标签会被剪裁。这个(以及 X 轴上的类似问题)之前已经在这些问题中讨论过: Range
c - 如何使用平方根优化c中的循环(完美、丰富、不足)
注意:我遗漏了不相关的代码所以我目前正在研究 CCC 1996 P1，这个问题的全部目的是能够计算一个整数输入是完美数、不足数还是充数。我上面列出的代码可以工作，但是我认为它太慢了。该代码会迭代每个
algorithm - 31 位双射(完美)哈希算法
我需要什么我需要一个产生双射输出的算法。我有一个 31 位输入，需要一个伪随机 31 位输出。我考虑过的 CRC 在其位宽内是双射的。我查看了 Google 并找到了多项式，但找不到表格或算法。
swift - 完美 swift : Can't compile PerfectCrypto
我在 Ubuntu 14.04.1、clang-3.8 上使用 PerfectSwift我使用的是 Perfect，一切正常，但现在，我不能再编译了(但它可以在我的 mac 上编译) 错误日志是 /h
C#中efcore-ShardingCore呈现“完美”分表
如果您对分表有以下痛点那么不妨试试我这边开源的框架sharding-core ，是否需要无感知使用分表组件，是否需要支持abp，是否需要支持自定义分表规则，是否需要支持自定义分表键，是否需要支持特定
probability - 完美 32 位 crc 的预期冲突
我正在尝试确定我的 crc 与“ 理想 ”32 位 crc 的比较。因此，我运行我的 crc 超过 100 万个完全随机的数据样本并收集了碰撞数量，我想将此数字与我可以从“ 理想 ”crc 中预期的
javascript - 完美 URL 检查 MOST URL 的正则表达式
我正在开发一个项目，需要验证我的 URL，并偶然发现了以下正则表达式模式； /(((http|ftp|https):\/{2})+(([0-9a-z_-]+\.)+(aero|asia|biz|cat
python - 一个*完美*的 Python 调试器应该具备哪些特性？
关闭。这个问题是opinion-based .它目前不接受答案。想要改进这个问题？更新问题，以便 editing this post 可以用事实和引用来回答它. 关闭 4 年前。 Improve
css - 屏幕分辨率。全屏 - 完美。普通屏幕 - 不完美
我正在创建一个需要居中于中间的圆形网站。背景由围绕中心图像的圆圈组成。每当我以全屏(F11 快捷键)查看我的网站时，无论我的屏幕分辨率如何，它都完美居中。如果我在没有全屏显示的情况下查看我的网站，我
html - 在开发人员工具中测试响应能力时，网站 react 完美，但不是以实际手机屏幕为中心？
所以我有一个网站，在开发人员工具中测试响应能力时看起来很棒，但在 iPhone 本身上实际测试时却没有居中并且看起来有些破烂。什么会导致这种情况，如果我无法使用 iPhone(在我的 android
java - 导入 -> 'cannot find symbol' |完全合格的名称 -> 完美
我有一个内部类，它扩展了 AbstractTableModel。 import javax.swing.table.AbstractTableModel; public class MyClass e
linux - 完美/快速编译在 OSX 中工作，在 Linux 中失败
所以我正在使用 Perfect 服务器开发一个将值返回给客户端的应用程序。目前，它需要从另一个 API 下载一些数据，对其进行处理，然后将其发送给客户端。然而，出于某种原因，它在 OSX 中编译良好
jquery - CSS 按钮在 Firefox 中工作(接近)完美，在 IE 和 Chrome 中崩溃和燃烧
我有一些 CSS 按钮。 “按钮”效果是通过在 anchor 标记中使用固定大小的元素来完成的，并且 css 规则以 a span:active 、 a span:hover 的形式显示按钮状态。

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

C++:将基类型完美透明地包装到一个类中？