自动生成关联运算符

最新推荐文章于 2024-11-02 14:05:25 发布
最新推荐文章于 2024-11-02 14:05:25 发布
阅读量2.2k 收藏 1
点赞数
文章标签： integer less class 编译器 templates c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotony/article/details/79075
版权

自动生成关联运算符

自定义运算符是C++的一个特色。它可以使用很多操作变得直观，符合一般的思维方式：

例如，在大多数语言中，对于int这样的内建类型（primary type）变量a,b，一个运算过程可以写成：a + b / a – 300，这与数学运算表达式完全一样。但对于非内建类型，比如Complex就不一定了。比如在Java中，它只能写成a.add(b.div(a).sub(300))，这就很难看了。而C++中可以通过自定义运算符实现与int类似的运算表达式。

运算符的实现有一个重要的原则：不改变运算符的原意。不应该把“＋”号重载成减法运算，也不应把“&&”定义为乘方，虽然这些重定义在语法上合法。这一原则的一个引申概念就是有关联的运算符其间的关系不应变化。“＋＝”和“＋”就是一对关联运算，”<”,”>”,”<=”和”>=”也是一组相关联的运算。其关联关系是这样的：

a = a + b 等价于 a += b

有a < b，也应有 b > a, b>= a, a<=b

关联运算符应一起实现，为了保证其相关性不变，在一组关联运算符中只实现一个基本运算符，其它运算符都使用这个基本运算符实现。例如加法运算以+=为基本运算，而+调用+=运算符来实现。

class A

{

  A& operator+=(A const& a);

};

A operator+(A const& a, A const& b)

{

   A result = a;

   result += b;

   return result;

}

关系运算符更是有一套模式化的实现方法。如果A定义了“<“号，则在STL中为它定义了如下模板。

template <class _Tp>

inline bool _STLP_CALL operator>(const _Tp& __x, const _Tp& __y) {

  return __y < __x;

}

 

template <class _Tp>

inline bool _STLP_CALL operator<=(const _Tp& __x, const _Tp& __y) {

  return !(__y < __x);

}

 

template <class _Tp>

inline bool _STLP_CALL  operator>=(const _Tp& __x, const _Tp& __y) {

  return !(__x < __y);

}

它们被定义在std::rel_ops命名空间中，要使用它们，需要在类中声明using namespace std::rel_ops。

这可以算是最基本的一个关联运算符生成器了，可惜它太少了一点，也不够灵活。不过在boost库中这个强大的功能被补全了，这就是boost::operators。

operator主要通过继承和友元来为类型提供运算符定义。

用法1通过继承：

class A : boost:: less_than_comparable<A>

{

  friend bool operator<(A const&a, A const& b);

};

用法2通过模板友元：

class A

{

  friend bool operator<(A const&a, A const& b);

};

 

template boost:: less_than_comparable<A>; //显式实例化模板。

boost:: less_than_comparable模板类提供了以下一组友元：

friend bool operator>(const T& x, const T& y) { return y < x; }

    friend bool operator<=(const T& x, const T& y) { return !(y < x); }

    friend bool operator>=(const T& x, const T& y) { return !(x < y); }

它们都依赖于A定义的operator<运算符。

Boost不只提供只对于当前类型的运算符，还提供类型之间的运算符，如下代码。

用法1通过继承：

class A : boost:: less_than_comparable<A,B>

{

  friend bool operator<(A const&a,  B const& b);

friend bool operator>(A const&a,  B const& b);

};

用法2通过模板友元：

class A

{

  friend bool operator<(A const&a,  B const& b);

friend bool operator>(A const&a,  B const& b);

};

template boost:: less_than_comparable<A, B>; //显式实例化模板。

 

boost:: less_than_comparable<A,B>模板类提供了以下一组友元：

bool operator<=(const T&, const U&)

bool operator>=(const T&, const U&)

bool operator>(const U&, const T&)

bool operator<(const U&, const T&)

bool operator<=(const U&, const T&)

bool operator>=(const U&, const T&)

以下是一张boost提供的模板，模板提供的运算符和模板所依赖的运算符的对应表。

 

T: primary operand type U: alternate operand type t, t1: values of type T u: value of type U

模板

提供的操作符

所依赖的运算符

less_than_comparable<T>

less_than_comparable1<T>

bool operator>(const T&, const T&)
bool operator<=(const T&, const T&)
bool operator>=(const T&, const T&)

t < t1.

less_than_comparable<T, U>
less_than_comparable2<T, U>

bool operator<=(const T&, const U&)
bool operator>=(const T&, const U&)
bool operator>(const U&, const T&)
bool operator<(const U&, const T&)
bool operator<=(const U&, const T&)
bool operator>=(const U&, const T&)

t < u. t > u.

equality_comparable<T>
equality_comparable1<T>

bool operator!=(const T&, const T&)

t == t1.

equality_comparable<T, U>
equality_comparable2<T, U>

bool operator==(const U&, const T&)
bool operator!=(const U&, const T&)
bool operator!=(const T&, const U&)

t == u.

addable<T>
addable1<T>

T operator+(const T&, const T&)

T temp(t); temp += t1.
返回值类型为T.

addable<T, U>
addable2<T, U>

T operator+(const T&, const U&)
T operator+(const U&, const T& )

T temp(t); temp += u.
返回值类型为T.

subtractable<T>
subtractable1<T>

T operator-(const T&, const T&)

T temp(t); temp -= t1.

subtractable<T, U>
subtractable2<T, U>

T operator-(const T&, const U&)

T temp(t); temp -= u.

subtractable2_left<T, U>

T operator-(const U&, const T&)

T temp(u); temp -= t.

multipliable<T>
multipliable1<T>

T operator*(const T&, const T&)

T temp(t); temp *= t1.

multipliable<T, U>
multipliable2<T, U>

T operator*(const T&, const U&)
T operator*(const U&, const T&)

T temp(t); temp *= u.

dividable<T>
dividable1<T>

T operator/(const T&, const T&)

T temp(t); temp /= t1.

dividable<T, U>
dividable2<T, U>

T operator/(const T&, const U&)

T temp(t); temp /= u.

dividable2_left<T, U>

T operator/(const U&, const T&)

T temp(u); temp /= t.

modable<T>
modable1<T>

T operator%(const T&, const T&)

T temp(t); temp %= t1.

modable<T, U>
modable2<T, U>

T operator%(const T&, const U&)

T temp(t); temp %= u.

modable2_left<T, U>

T operator%(const U&, const T&)

T temp(u); temp %= t.

orable<T>
orable1<T>

T operator|(const T&, const T&)

T temp(t); temp |= t1.

orable<T, U>
orable2<T, U>

T operator|(const T&, const U&)
T operator|(const U&, const T&)

T temp(t); temp |= u.

andable<T>
andable1<T>

T operator&(const T&, const T&)

T temp(t); temp &= t1.

andable<T, U>
andable2<T, U>

T operator&(const T&, const U&)
T operator&(const U&, const T&)

T temp(t); temp &= u.

xorable<T>
xorable1<T>

T operator^(const T&, const T&)

T temp(t); temp ^= t1.

xorable<T, U>
xorable2<T, U>

T operator^(const T&, const U&)
T operator^(const U&, const T&)

T temp(t); temp ^= u.

incrementable<T>

T operator++(T&, int)

T temp(t); ++t

decrementable<T>

T operator--(T&, int)

T temp(t); --t;

left_shiftable<T>
left_shiftable1<T>

T operator<<(const T&, const T&)

T temp(t); temp <<= t1.

left_shiftable<T, U>
left_shiftable2<T, U>

T operator<<(const T&, const U&)

T temp(t); temp <<= u.

right_shiftable<T>
right_shiftable1<T>

T operator>>(const T&, const T&)

T temp(t); temp >>= t1.

right_shiftable<T, U>
right_shiftable2<T, U>

T operator>>(const T&, const U&)

T temp(t); temp >>= u.

equivalent<T>
equivalent1<T>

bool operator==(const T&, const T&)

t < t1.

equivalent<T, U>
equivalent2<T, U>

bool operator==(const T&, const U&)

t < u. t > u.

partially_ordered<T>
partially_ordered1<T>

bool operator>(const T&, const T&)
bool operator<=(const T&, const T&)
bool operator>=(const T&, const T&)

t < t1. t == t1.

partially_ordered<T, U>
partially_ordered2<T, U>

bool operator<=(const T&, const U&)
bool operator>=(const T&, const U&)
bool operator>(const U&, const T&)
bool operator<(const U&, const T&)
bool operator<=(const U&, const T&)
bool operator>=(const U&, const T&)

t < u. t > u. t == u.

 

对于同一个类要实现多组运算符，operators采用链式继承的方式，例如如果需要同时定义小于和等于符号。可以这样定义：

class A : boost:: less_than_comparable<A,  equality_comparable<A> >

{

  friend bool operator<(A const&a, A const& b);

friend bool operator==(A const&a, A const& b);

};

如果是定义类型间的小于和等于，则是这样：

class A : boost:: less_than_comparable<A，B，equality_comparable<A，B> >

{

  friend bool operator<(A const&a,  B const& b);

friend bool operator>(A const&a,  B const& b);

friend bool operator==(A const&a,  B const& b);

};

boost预先定义了一些组合运算模板，也可以直接使用它们，例如上面的类也可以定义为：

class A : totally_ordered<T>

{

  friend bool operator<(A const&a, A const& b);

friend bool operator==(A const&a, A const& b);

};

以下是一个称为联合运算的组合运算模板的组成表：

Template

Component Operator Templates

totally_ordered<T>
totally_ordered1<T>

· less_than_comparable<T>

· equality_comparable<T>

totally_ordered<T, U>
totally_ordered2<T, U>

· less_than_comparable<T, U>

· equality_comparable<T, U>

additive<T>
additive1<T>

· addable<T>

· subtractable<T>

additive<T, U>
additive2<T, U>

· addable<T, U>

· subtractable<T, U>

multiplicative<T>
multiplicative1<T>

· multipliable<T>

· dividable<T>

multiplicative<T, U>
multiplicative2<T, U>

· multipliable<T, U>

· dividable<T, U>

integer_multiplicative<T>
integer_multiplicative1<T>

· multiplicative<T>

· modable<T>

integer_multiplicative<T, U>
integer_multiplicative2<T, U>

· multiplicative<T, U>

· modable<T, U>

arithmetic<T>
arithmetic1<T>

· additive<T>

· multiplicative<T>

arithmetic<T, U>
arithmetic2<T, U>

· additive<T, U>

· multiplicative<T, U>

integer_arithmetic<T>
integer_arithmetic1<T>

· additive<T>

· integer_multiplicative<T>

integer_arithmetic<T, U>
integer_arithmetic2<T, U>

· additive<T, U>

· integer_multiplicative<T, U>

bitwise<T>
bitwise1<T>

· xorable<T>

· andable<T>

· orable<T>

bitwise<T, U>
bitwise2<T, U>

· xorable<T, U>

· andable<T, U>

· orable<T, U>

unit_steppable<T>

· incrementable<T>

· decrementable<T>

shiftable<T>
shiftable1<T>

· left_shiftable<T>

· right_shiftable<T>

shiftable<T, U>
shiftable2<T, U>

· left_shiftable<T, U>

· right_shiftable<T, U>

ring_operators<T>
ring_operators1<T>

· additive<T>

· multipliable<T>

ring_operators<T, U>
ring_operators2<T, U>

· additive<T, U>

· subtractable2_left<T, U>

· multipliable<T, U>

ordered_ring_operators<T>
ordered_ring_operators1<T>

· ring_operators<T>

· totally_ordered<T>

ordered_ring_operators<T, U>
ordered_ring_operators2<T, U>

· ring_operators<T, U>

· totally_ordered<T, U>

field_operators<T>
field_operators1<T>

· ring_operators<T>

· dividable<T>

field_operators<T, U>
field_operators2<T, U>

· ring_operators<T, U>

· dividable<T, U>

· dividable2_left<T, U>

ordered_field_operators<T>
ordered_field_operators1<T>

· field_operators<T>

· totally_ordered<T>

ordered_field_operators<T, U>
ordered_field_operators2<T, U>

· field_operators<T, U>

· totally_ordered<T, U>

euclidian_ring_operators<T>
euclidian_ring_operators1<T>

· ring_operators<T>

· dividable<T>

· modable<T>

euclidian_ring_operators<T, U>
euclidian_ring_operators2<T, U>

· ring_operators<T, U>

· dividable<T, U>

· dividable2_left<T, U>

· modable<T, U>

· modable2_left<T, U>

ordered_euclidian_ring_operators<T>
ordered_euclidian_ring_operators1<T>

· euclidian_ring_operators<T>

· totally_ordered<T>

ordered_euclidian_ring_operators<T, U>
ordered_euclidian_ring_operators2<T, U>

· euclidian_ring_operators<T, U>

· totally_ordered<T, U>

与其它boost库一样,operators要求支持C++98标准的编译器，现在完全支持的编译器有VC7.1，GCC3.3，EGD 2.5以上。通过一定的方式支持GCC2.95和VC6 sp3以上。

  对于完全支持的编译器，推荐使用operatorable<T>和operatorable<T, U>模板。对于不完全支持的编译器，可以使用operatorable1<T>和operatorable2<T,U>这两个接口。

 

solotony
关注
【编译原理】实验三：使用 Lex 自动生成扫描程序
LJR的博客
12-29 1422
本次实验主要学习了Lex输入文件的格式，布局分为三部分，定义段、规则段和用户代码段，段间通过双百分号间隔开来，定义段完成了include头文件和变量、函数的声明等，规则段采用正则表达式的形式说明匹配规则，用户代码段实现了声明的函数，生成对应的.c代码。本次实验要求统计不同关键字、标识符、运算符的个数。填写id2keyword函数实现区别关键字与用户自定义的标识符，定义有关正整数和用户自定义标识符对应的正则表达式。因为在很早之前自学过正则表达式的相关知识，所以并没有被本次实验填写正则表达式的部分难住。
两种自动生成编码的方式
weixin_44548147的博客
07-18 1632
在我们做项目的过程中，我们会遇到新增某一张表的时候，它里面的某一个字段是通过自动生成出来的，我们可以通过数据库的条数来进行自增，也可以获取当前时间来进行拼接出我们需要的格式。 下面我来讲一下如何根据当前时间来进行生成编码。因为编码是自动生成的，所以是禁止输入的，我们要给input添加一个属性来进行禁用，下面请看Html代码： <input id="OpportunityNumber" n...
MySQL（4）运算符 | 关联查询详解
星海IT学习之路
07-10 697
目录 如果有收获！！！ 希望老铁们来个三连，点赞、收藏、转发 创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客
第四章运算符—关系运算符
weixin_62458944的博客
06-10 5593
关系运算符中“关系”二字的含义是指一个数据与另一个数据之间的关系，这种关系只有成立与不成立两种可能情况，可以用逻辑值来表示，逻辑上的 true 与 false 用数字 1 与 0 来表示。关系成立时表达式的结果为 true（或 1），否则表达式的结果为 false（或 0）。在本程序中，使用 input.nextInt() 接收用户从键盘输入的两个数，然后通过关系运算符来比较这两个数之间的大小。关系运算符的优先级为：>、=、
FPGA编程中常用的经典方法及技巧（图像处理-映射技术）
AccFPGA的博客
04-25 3315
流水线设计 基本概念 流水线处理源自现代工业生产装配线上的流水作业，是指将待处理的任务分解为相对独立的、可以顺序执行的而又相互关联的一个个子任务。流水线处理是高速设计中的一个常用设计手段，如果某个设计的处理流程分为若干步骤，并且整个数据处理是“单流向”的，即没有反馈或者迭代运算，前一个步骤的输出是下一个步骤的输入，那么可以考虑采用流水线设计方法来提高系统频率。流水线设计结构如图所示。 其...
关联分析——基本概念以及常用术语
jumdar的博客
01-07 2969
想必大家都听说过啤酒和尿布的故事，这种烂大街的例子很好的反映出关联分析的本质，这里简要提提这个所谓的啤酒和尿布。 有好事人儿发现周末的夜晚，家庭妇男为了和球赛度过一个美丽的夜晚，需要啤酒相伴，这个时候，一家之主兼政委主席——你的妻子却还需要照顾孩子，“想看球赛没问题，买啤酒顺便买尿布”。 对购物篮进行分析之后，惊喜的发现还真有这么回事儿。 这例子孰真孰假不得知，但起码它反映出了数据分析的价值...
关联规则(挖掘)，数据关联(融合)
热门推荐
pi9nc的专栏
07-02 2万+
3月9日07:49| 新浪博客| 来源：时空交互| 查看原文>       关联式规则 关联式规则(Association Rules, AR)，又称关联规则，是数据挖掘的一个重要课题，用于从大量数据中挖掘出有价值的数据项之间的相关关系。关联规则解决的常见问题如：“如果一个消费者购买了产品A，那么他有多大机会购买产品B?”以及“如果他购买了产品C和D，
如何实现代码自动生成？
淘系技术
07-06 4105
每年大促前一个月都是奋战与忙碌的时节，不仅业务上在不断迭代创新，技术上也在推陈出新，需求推动技术变革是一个正向演进的过程，但革新是需要成本的，每一次技术与标准的革新都带来一场翻天覆地的大...
软件过程与工具实验ActSmart加减法练习自动生成系统源代码+实验报告，增量模型应用+结对编程实践
07-11
软件过程与工具实验ActSmart加减法练习自动生成系统源代码+实验报告，增量模型应用+结对编程实践 软件系统功能结构设计方案：给出软件功能模块及模块间的关联关系。 前端界面: 包括生成界面create.jsp, 练习界面...
【Python自动化测试7】数据运算符知识讲解
萌笑天的博客
01-10 1880
  本文章主要讲解的是关于Python的运算符以及相关联自动化测试技术重点的扩展知识，也是运算符的专题讲解
Excel数据整理与分析运算符共10页.pdf.zip
11-19
- PIVOT TABLE（数据透视表）：这是一种强大的数据分析工具，可对大量数据进行汇总、比较和分析，自动生成报表。 4. 数据分析工具： - 数据排序与筛选：除了基本的排序和筛选外，Excel还提供了高级筛选功能，可以...
SGI STL 源码解读之Allocator
行者无疆的专栏
10-08 3721
为了进一步了解Allocator的运作原理，我们以下面的使用作为例子，解读其实现细节。      std::allocatorint>MyAll;      MyAll.allocate(10);      以上代码调用SGI STL的allocator，分配10个int型的空间。下面的分析使用SGISTL源代码allocator.cpp，并加上我的理解注释，建议参考侯捷的书做了解。但我目前
Verilog HDL 使用笔记--连接运算符的使用
小李李的专栏
05-07 2713
连接运算符时硬件描述语言中一种比较特殊的运算符，它的作用是将两组或两组以上的信号用大括号括起来，拼接成一组新的信号。如： {a，b，d，3’b101} 如果a与d都是一位的信号，而b是四位的信号，则上例连接运算符操作后产生的信号有9位的位宽。 它等价于{a,b[3],b[2],b[1],b[0],d,1’b1,1’b0,1’b1}，注意上例中，常数表达式前面的位宽时不能缺省的，如3’b101中的1...
vue3+less使用主题定制（多主题定制）可切换主题
许粤军的博客
10-30 405
主要代码是最外层div上面绑定的class，下面的router-view你们项目是怎样的就是怎样的，不用和我的一样，然后再是下面的计算属性，引入vuex里面的主题变量。至此就可以了，其实思路很简单：就是在根目录上面绑定样式，通过切换这个样式来做到主题的切换，如果使用的主题量很大，是不是就得考虑性能问题了...1、在src目录下建一个styles文件夹，在syles文件夹下面新建两个less文件：theme.less和variables.less；2、使用vuex来管理，这边vuex怎么接入就不过多叙述，
less解决function中return写法在浏览器被识别成Object导致样式失败的问题
qq_42750608的博客
10-30 355
使用height: .pxToRem(40px);使用.px2rem(height, 40px);
leetcode713. Subarray Product Less Than K
weixin_44245188的博客
11-01 309
注意，对于某一个值，我们只关注以它为最右边元素的子数组。这样可以减少重复讨论的麻烦。思路：使用滑动窗口的思路，找取每一个符合条件的小窗，统计其内部子数组数量。
Xss_less靶场攻略(1-18)
saber的博客
10-30 457
介绍了XSS-LAB环境下的多个安全挑战（Level 1-18），每个挑战都涉及到如何在特定条件下实施跨站脚本攻击(XSS)。文档详细描述了各种攻击方法，包括但不限于利用特殊字符转义、img标签懒加载、a标签中的JavaScript执行、“”和“’”字符的使用技巧、以及针对不同HTML元素和属性的XSS注入策略。同时，还探讨了服务器端的防御措施，如使用htmlspecialchars函数进行转义，并尝试了多种编码和绕过技术来避开这些防御。
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
最新发布
weixin_43845922的博客
11-02 205
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
自动生成编译程序：LEX与YACC使用教程
LEX和YACC是用于自动生成 lexical analyzers (词法分析器)的工具，它们在编译器构造过程中扮演着关键角色，减少了手动编写词法规则的工作量。LEX，原名Flex，是Fast Lexical Analyzer Generator的缩写，它负责识别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值