CPP-operator==, <overloading

C++ 中的运算符重载：==, !=, < 和相关实现
最新推荐文章于 2025-01-22 22:58:42 发布
原创 最新推荐文章于 2025-01-22 22:58:42 发布 · 969 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客探讨了在C++中如何利用已有的运算符重载来实现其他相关操作符。一旦定义了`operator==`，可以轻松实现`operator!=`，只需调用`operator==`并取反。同样，定义了`<`后，可以方便地定义`>`。标准库提供了一些模板帮助实现这些关系操作符。文章通过为数组类型定义`<`运算符为例，展示了如何实现这些操作，并提到了在成员函数中使用`this`指针的细节。然而，在尝试使用非常量成员函数（如lengthsquare()）时，由于`operator<`是常量成员函数，导致了编译错误。

如果已经定义了operator==,那么operator!=很容易实现，只要调用operator==,然后取反。

bool Array::operator!=(const Array& v) const
{
    return !((*this) == v);
}

这个函数的形式实际上和具体的类无关。即如果定义了operator==,那么总能根据这个模式定义operatot!=. 同样，如果定义了<, 则很容易能够定义>. 如果定义了==，则结合<和==,则能够定义<=和>=. 标准文件util包含了一系列预先定义的这些关系操作符的模式。使用时只需定义operator==， operator<，则自动有operator!=, operator>, operator<=.因此从不需要定义多余两个比较操作符。看以下例子：为array定义<.

bool operator< (const Array& v) const;

实现：

bool Array::operator< （const Array& v) const
{
    int n; //the length of the shortest of this object and v
    if(num <v.num)
    n = num;
    else
    n = v.num;
    for(int i=0;i<n;i++)
    if(p[i] <v.p[i])
    return true;
    else if(p[i]>v.p[i])
    return false;
    return num <v.num; //equal length
}

为了自动使用别的比较操作符。需要在类定义文件中包含以下信息：

#include〈utility>
using namespace std::rel_ops;

单操作符：operator-

Array operator- () const;

Array Array::operator- () const
{
Array temp(*this); //creat a copy of this array object
for(int i=0;i

class Myclass{
public:
    bool operator== (const Myclass &vb) const {
            if(this->vx == vb.vx && this->vy == vb.vy && this->vz == vb.vz) return true;
            else return false;};
private:
    double  vx,vy,vz;
}

其实当在一个成员函数内部写一个成员名字时候(如vx)，编译器将解释为this->vx。因此以上语句其实不需要明确指出this->vx；故代码可以简化：

class Myclass{
public:
    bool operator== (const Myclass &vb) const {
        return(vx == vb.vx && vy == vb.vy && vz == vb.vz) };
private:
    double  vx,vy,vz;
}

接下来实现矢量大小比较（长度）

bool operator<  (const Vector3d &vb) const {return (this->lengthsquare() < vb.lengthsquare());};

inline double lengthsquare() {return(vx*vx + vy*vy + vz*vz);};

这几句总是给错误提示：
“the object has type qualifiers that are not compatible with the member function”，

因为operator< 声明为一个常函数，而函数lengthsquare()没有声明为常函数。

bool operator<  (const Vector3d &vb) const {return (this->lengthsquare() < vb.lengthsquare());};

inline double lengthsquare() const{return(vx*vx + vy*vy + vz*vz);};

其他comparison operator:

bool operator== (const Vector3d &vb) const {return(vx == vb.vx && vy == vb.vy && vz == vb.vz);}
        bool operator!= (const Vector3d &vb) const {return !(*this == vb);};
        bool operator<  (const Vector3d &vb) const {return (this->lengthsquare() < vb.lengthsquare());};
        bool operator>= (const Vector3d &vb) const {return !(*this < vb);};
        bool operator>  (const Vector3d &vb) const {return (*this >= vb) && (*this != vb);};
        bool operator<= (const Vector3d &vb) const {return !(*this > vb);};
语言/CPP {operator运算符重载}
qq_66485519的博客
08-12 202
1
cpp代码-重载操作符operator
07-16
cpp代码-重载操作符operator
CPP-operator= overloding
CCMPI的博客
12-14 691
c++很好的一个优点就是根据用户定义的类，操作符有不同的意义。这就叫operator overloading. 一般通过在类中提供一个特别的成员函数来实现。可以被overloading的操作符有以下几种：= (assignment operator) + - * (binary arithmetic operators) += -= *= (compound assignment operators
c++ 重载运算符
洛冰翼的专栏
06-12 397
#include using namespace std; class CTmp{ public: //friend const CTmp operator++(CTmp& tmp); //friend const CTmp operator++(CTmp& tmp, int); CTmp(int iflag=0):i(iflag) { } void print(
（转载）C++中的赋值运算符重载函数（operator=）
Carol_learning的博客
03-11 1727
本文主要介绍C++中的重载操作符（operator）的相关知识。 概述 1.1 what operator 是C++的一个关键字，它和运算符（如=）一起使用，表示一个运算符重载函数，在理解时可将operator和运算符（如operator=）视为一个函数名。 使用operator重载运算符，是C++扩展运算符功能的方法。使用operator扩展运算符功能的原因如下： 使重载后的运算符的使用方法...
一文说尽C++赋值运算符重载函数(operator=)
dizhen7495的博客
12-07 1607
写在前面： 关于C++的赋值运算符重载函数(operator=)，网络以及各种教材上都有很多介绍，但可惜的是，内容大多雷同且不全面。面对这一局面，在下在整合各种资源及融入个人理解的基础上，整理出一篇较为全面/详尽的文章，以飨读者。 正文： Ⅰ.举例 例1 #include<iostream> #include<string> usin...
C++中的赋值运算符重载函数（operator=）
TwcatL
08-25 626
本文主要介绍C++中的赋值运算符重载函数（operator=）的相关知识。 1. 概述 1.1 why 首先介绍为什么要对赋值运算符“=”进行重载。某些情况下，当我们编写一个类的时候,，并不需要为该类重载“=”运算符，因为编译系统为每个类提供了默认的赋值运算符“=”，使用这个默认的赋值运算符操作类对象时，该运算符会把这个类的所有数据成员都进行一次赋值操作。例如有如下类： class A{public: int a...
C++编程语言中赋值运算符重载函数（operator=）介绍_重载赋值操作符
2401_89609495的博客
01-22 689
/ 调用默认的赋值运算符重载函数。// 调用赋值运算符重载函数。// 赋值运算符重载函数。
CPP中操作符operator的俩种作用
oLingFengYu的专栏
02-27 1270
在CPP中，一个类的操作符有俩个作用。 第一是对这个类的对象进行操作，如比较，赋值，位移等； 第二是对这个类的对象进行隐式转换 一个例子的代码： #include &lt;iostream&gt; using namespace std; struct struct_a{ int ta; int tb; }; class A { public: A(int a)...
c语言operator,在c中重写operator <<
weixin_29801195的博客
05-20 384
我正在为我在C的学校做一个项目我有2节课：Employe和Teacher.源自Employe的老师,其职能已被覆盖.我们覆盖运算符对于Employe,是5,对于Teacher,是20.当我在main.cpp中创建教师时,我调用了operatorostream& operator<os << (pTeacher);return os;}但是,该函数使用“ osos <...
解析c++中的默认operator=操作的详解
01-01
在c++中，如果没有定义operator=操作，编译器会提供一个默认的operator=操作。由于operator=操作和拷贝构造函数的功能类似，都执行拷贝操作。因此，编译器也分提供无用的默认operator=操作和非无用的默认operator=操作。并且什么时候提供非无用的默认operator=操作和无用的等操作的情形也和拷贝构造函数类似。(详细分析过程请参考《基于c++中的默认拷贝函数的使用详解》) 对于一个类，编译器会提供非无用的operator=操作的情形： 1 该类是含有虚成员函数(继承自虚基类，或者继承的基类含有虚成员函数也属于这种情况) 2 该类继承的基类自定义了operator
C++ operator=
shuyan745294340的博客
01-09 401
C++ operator实现=重载
Cpp_操作符重载
Jerry的专栏
02-29 1333
一、双目操作符的重载1.计算类双目操作符 形如L#R的表达式会被编译器处理为形如L.operator#(R)的成员函数的调用，该函数的返回值即为表达式的值。 形如L#R的表达式也可以被编译器处理为形如::operator#(L,R)的全局函数的调用，该函数的返回值即为表达式的值。 2.赋值类双目操作符 表达式的值是一个左值，而且它就是左操作数本身。 左操作数不能是常量，右操作数可以是常量。
C++ operator= 注意事项
wuan584974722的专栏
12-21 1088
版权声明：本文为博主原创文章，未经博主允许不得转载。 下面先看一段代码： [cpp] view plain copy   #include    using namespace std;   class Point{   public:       Point(float x=0.0,float y=0.0):_x(x),_y(y){
C++那些细节--中operator=相关问题
热门推荐
puppet_master的专栏
07-23 1万+
C++中关于operator=的相关知识整理，涉及深拷贝浅拷贝，以及一些拷贝构造函数的知识
C++ 中的 “operator“（运算符）
ultramand的博客
10-18 1366
当谈到 C++ 中的 “operator”（运算符）时，通常指的是运算符重载（operator overloading）。运算符重载允许用户重新定义或扩展内置运算符的操作行为，使其适用于自定义的类型或类对象。这些示例说明了运算符重载的一些用法，通过重载运算符，可以使自定义类型的对象支持原生运算符，从而提供更直观和灵活的操作方式。但需要注意，运算符重载应该按照一定的规则和语义进行设计，以避免混淆和不当的使用。是要重载的运算符，可以是任何合法的 C++ 运算符。是运算符重载函数的返回类型，表示操作的结果类型。
C++ 函数对象operator()
转载和创作优秀的博客
02-13 1887
函数对象：定义了调用操作符（）的类对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子： [cpp]view plaincopy classA { public: intoperator()(intval) { returnval>0?val:-val; } }; 类A中定义了操作符 ( )，A对象调用...
C++ 类内重载输出运算符、类外重载输出运算符的区别；及其调用区别；operator＜＜
多丰富下自己呀
05-13 2713
目录前言一、类内与类外重载运算符1.类内重载与类外重载的区别2.类外重载为什么需要友元关于模板类3.类内重载与类外重载，调用的区别二、实例实现效果：参考 前言 最后的实例利用一个模板类来实现类内与类外重载输出运算符。 其他运算符的重载类似。 如果不需要模板，去掉模板即可。 一、类内与类外重载运算符 1.类内重载与类外重载的区别 1.1类外重载一般需要类内声明友元，详见2. 1.2类内实现，调用的时候需要用对象调用，参数列表只包含一个ostream类引用。 1.3类内，作为成员函数，所以没有友元声明一说。
operator* 和operator-＞ 操作符的重载在自定义智能指针class MyPtr中的应用
qq_52458749的博客
07-29 358
operator* 和operator-> 操作符的重载在自定义智能指针class MyPtr中的应用
// Fig. 11.9: String.h // String class definition with operator overloading. #ifndef STRING_H #define STRING_H #include <iostream> using namespace std; class String { friend ostream &operator<<( ostream &, const String & ); friend istream &operator>>( istream &, String & ); public: String( const char * = "" ); // conversion/default constructor String( const String & ); // copy constructor ~String(); // destructor const String &operator=( const String & ); // assignment operator const String &operator+=( const String & ); // concatenation operator bool operator!() const; // is String empty? bool operator==( const String & ) const; // test s1 == s2 bool operator<( const String & ) const; // test s1 < s2 // test s1 != s2 bool operator!=( const String &right ) const { return !( *this == right ); } // end function operator!= // test s1 > s2 bool operator>( const String &right ) const { return right < *this; } // end function operator> // test s1 <= s2 bool operator<=( const String &right ) const { return !( right < *this ); } // end function operator <= // test s1 >= s2 bool operator>=( const String &right ) const { return !( *this < right ); } // end function operator>= char &operator[]( int ); // subscript operator (modifiable lvalue) char operator[]( int ) const; // subscript operator (rvalue) String operator()( int, int = 0 ) const; // return a substring int getLength() const; // return string length private: int length; // string length (not counting null terminator) char *sPtr; // pointer to start of pointer-based string void setString( const char * ); // utility function }; // end class String #endif
最新发布
11-13
// Fig. 11.9: String.h // String class definition with operator overloading. --- ### 题目重述 请根据提供的 `String` 类定义，实现能够重载加号（`+`）运算符的功能，使得两个 `String` 对象可以进行拼接操作而不修改原对象，支持如下语句： ```cpp string1 = string2 + string3; ``` 同时，在已有类结构基础上补充必要的函数原型与实现思路。 --- ### 给出答案（答案为带注释的代码块） ```cpp // 在 String 类中添加 operator+ 的声明（建议放在 public 区域） const String operator+( const String & ) const; // 返回一个新的 String 对象，不改变原对象 // 实现示例（可在类外定义） const String String::operator+( const String &right ) const { // 创建新字符数组，长度为两字符串之和 + 1（含 '\0'） char *temp = new char[length + right.length + 1]; // 复制当前对象的字符串 strcpy( temp, sPtr ); // 拼接右侧字符串 strcat( temp, right.sPtr ); // 构造新的 String 对象并返回 String result( temp ); delete[] temp; // 避免内存泄漏（注意：此处 temp 内容已被复制） return result; } ``` > ⚠️ 注意：上面 `delete[] temp;` 是否保留取决于构造函数是否立即复制了数据。若 `String(const char*)` 构造函数会再次深拷贝 `temp` 中的内容，则此处可安全释放。 更稳妥写法（推荐）： ```cpp const String String::operator+( const String &right ) const { char *temp = new char[length + right.length + 1]; strcpy(temp, sPtr); strcat(temp, right.sPtr); String result(temp); // result 自己负责管理自己的内存 delete[] temp; // 可以删除，因为 result 已完成复制 return result; } ``` 或进一步优化使用 RAII： ```cpp const String String::operator+( const String &right ) const { size_t newLen = length + right.length; char *temp = new char[newLen + 1]; // 动态分配临时缓冲区 strcpy(temp, sPtr); strcpy(temp + length, right.sPtr); // 更高效代替 strcat temp[newLen] = '\0'; String result(temp); delete[] temp; return result; } ``` --- ### 代码解析 1. **函数签名**：`const String operator+( const String & ) const;` - 声明为 `const` 成员函数，保证当前对象不被修改。 - 返回值是 `String` 类型（非引用），因为结果是一个新对象。 - 参数以 `const &` 形式传入，避免复制开销。 2. **内存管理**： - 使用 `new[]` 分配足够空间用于存储拼接后的字符串。 - 调用 `strcpy` 和 `strcat`（或手动复制）完成拼接。 - 利用已有的构造函数 `String(const char*)` 将拼接好的 C 字符串封装成新 `String` 对象。 3. **返回机制**： - 返回的是局部对象的副本（通过拷贝构造函数），编译器通常会优化（RVO/NRVO）。 4. **安全性**： - 所有动态分配的中间内存都及时释放，防止内存泄漏。 --- ### 知识点（列出该代码中遇到的知识点） - **运算符重载**：允许自定义类的对象使用内置运算符（如 `+`），提升代码可读性。必须保持语义一致。 - **常量成员函数**：用 `const` 修饰成员函数，表明其不会修改调用对象的状态，适用于比较、访问、组合等场景。 - **深拷贝与资源管理**：当类管理动态资源（如 `char*`）时，需正确实现构造函数、析构函数和赋值操作，防止内存错误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值