C++运算符重载

最新推荐文章于 2024-10-29 00:00:00 发布
转载 最新推荐文章于 2024-10-29 00:00:00 发布 · 453 阅读 · 0
文章标签：

#c++ #string #delete #class #c #扩展

本文详细介绍了C++中的运算符重载概念，包括其作用、规则及重载方法。探讨了运算符重载为成员函数和友元函数的区别，并通过实例展示了下标、增1减1及函数调用运算符的重载过程。
C++运算符重载<转>
2008-10-12 09:55

      所谓多态性是指发出同样的消息被不同类型的对象接收时导致完全不同的行为。这里所说的消息主要是指对类的成员函数的调用，而不同的行为是指不同的实现。利用多态性，用户只需发送一般形式的消息，而将所有的实现留给接收消息的对象。对象根据所接收到的消息而做出相应的动作(即操作)。

 

　　函数重载和运算符重载是简单一类多态性。

 

　　所谓函数重载简单地说就是赋给同一个函数名多个含义。具体地讲，C++中允许在相同的作用域内以相同的名字定义几个不同实现的函数，可以是成员函数，也可以是非成员函数。但是，定义这种重载函数时要求函数的参数或者至少有一个类型不同，或者个数不同。而对于返回值的类型没有要求，可以相同，也可以不同。那种参数个数和类型都相同，仅仅返回值不同的重载函数是非法的。因为编译程序在选择相同名字的重载函数时仅考虑函数表，这就是说要靠函数的参数表中，参数个数或参数类型的差异进行选择。 由此可以看出，重载函数的意义在于它可以用相同的名字访问一组相互关联的函数，由编译程序来进行选择，因而这将有助于解决程序复杂性问题。如：在定义类时，构造函数重载给初始化带来了多种方式，为用户提供更大的灵活性

 

   

     运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。运算符重载的实质就是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用的函数，这个过程是在编译过程中完成的。

 

 

一、运算符重载的作用

    运算符重载为类的用户提供了更直观的接口，使类类型的对象也可以像普通变量一样进行运算符的表达式运算。运算符重载允许C/C++的运算符在用户定义类型(类)上拥有一个用户定义的意义。

 

二、运算符重载的规则

（1）C++中的运算符除了少数几个以外，全部可以重载，而且只能重载已有的运算符。

可以重载的运算符有：

    算术运算符：+,-,*,/,%,++,--;

　　位操作运算符：&,|,~,^,＜＜,＞＞

　　逻辑运算符：!,&&,||;

　　比较运算符：＜,＞,＞=,＜=,==,!=;

　　赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;

　　其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*。

不能重载的运算符只有5个：

类属关系运算符“.”，成员指针运算符“*”，作用域分辨符“::”，sizeof运算符和三目运算符“?:”。

（2）重载之后运算符的优先级和结合性都不变。

（3）四个“不能改变”

    ·不能改变运算符操作数的个数；

　　·不能改变运算符原有的优先级；

　　·不能改变运算符原有的结合性；

　　·不能改变运算符原有的语法结构。

（4）至少要有一个操作对象是自定义类型。

（5）重载的运算符含义必须清楚，不能有二义性。

 

 

三、运算符重载的2种方法

（1）运算符重载为成员函数

（a）对于双目运算符op，如果要重载op为某类的成员函数，使之能够实现表达式 k op t，其中k为A类的对象，则应当把op重载为A类的成员函数，该函数只有一个形参，形参的类型是t所属的类型。经过这样重载之后，表达式 k op t 就相当于函数调用k.operator op( t )

（b）对于前置单目运算符U(如负号“-”)，若要重载U为类的成员函数，用来实现表达式

U oprd，其中oprd为A类的对象，则U应当重载为A类的成员函数，且该函数不带形参。经过重载之后，表达式U oprd 就相当于函数调用oprd.operator U()。

（b）后置运算符“++”和“--”，若要将它们重载为类的成员函数，用来实现表达式oprd++或oprd--，其中oprd为A类的对象，那么就应当重载这2个运算符为A类的成员函数，这时函数要带有一个整型（int）形参。重载之后，表达式 oprd ++ 和 oprd -- 就分别相当于函数调用oprd.operator ++(0) 和 oprd.operator --(0)。

 

（2）运算符重载为友元函数

（a）对于双目运算符op，如果它的一个操作数为类A的对象，就可以将op重载为A类的友元函数，该函数有两个形参，其中一个形参的类型是A类。经过这样的重载之后，表达式k op t就相当于函数调用operator op( k, t )

（b）对于前置单目运算符U(如负号“-”)，若要实现表达式 U oprd 其中oprd为A类的对象，则U可以重载为A类的友元函数，函数的形参为A类的对象oprd。经过重载之后，表达式

U oprd 就相当于函数调用operator U( oprd )

(c)对于后置运算符“++”和“--”，如果要实现表达式 oprd ++ 或 oprd --, 其中oprd为A类的对象，那么运算符就可以重载为A类的友元函数，这时函数的形参有两个，一个是A类的对象oprd，另一个是整型（int）形参。第二个参数是用于与前置运算符函数相区别的。重载之后，表达式oprd ++ 和 oprd -- 就分别相当于函数调用operator ++ (oprd, 0)

和operator -- (oprd, 0)。

 

 

（3）两种重载方法的比较

　　一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。

 

四、特殊运算符的重载

1).下标运算符重载

　　由于C语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用C++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。

　　下面先看看一个例子：

#include ＜iostream.h＞

class CharArray   //数组类

{

public:

CharArray(int l)

{

   Length = l;

   Buff = new char[Length];

}

~CharArray()
{
   delete Buff;
}

int GetLength()
{
   return Length;
}

char & operator [](int i);

private:

int Length;

char * Buff;

};

char & CharArray::operator [](int i)

{

static char ch = 0;

if(i＜Length && i＞=0)

{
   return Buff[i];
}

else

{

   cout＜＜"/nIndex out of range.";

   return ch;

}

}

void main()

{

int cnt;

CharArray string1(6);

char * string2 = "string";

for(cnt=0; cnt＜8; cnt++)
{

   string1[cnt] = string2[cnt];
}

cout＜＜"/n";

for(cnt=0; cnt＜8; cnt++)

{
   cout＜＜string1[cnt];
}

cout＜＜"/n";

cout＜＜string1.GetLength()＜＜endl;

}


　　该数组类的优点如下：

　　(1) 其大小不必是一个常量。

　　(2) 运行时动态指定大小可以不用运算符new和delete。

　　(3) 当使用该类数组作函数参数时，不必分别传递数组变量本身及其大小，因为该对象中已经保存大小。

 

在重载下标运算符函数时应该注意：

　　(1) 该函数只能带一个参数，不可带多个参数。

　　(2) 不得重载为友元函数，必须是非static类的成员函数。

 

2). 重载增1减1运算符

　　增1减1运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为双目运算符。表达式

　　obj++或obj--

　　被看作为：

　　obj++0或obj--0

下面举一例子说明重载增1减1运算符的应用。

#include ＜iostream.h＞

class counter
{
public:

   counter() { v=0; }

   counter operator ++();

   counter operator ++(int );

void print()
{
   cout << v << endl;
}

private:

   unsigned v;
};

counter counter::operator ++()
{
   v++;

   return *this;
}

counter counter::operator ++(int)
{
   counter t;

   t.v = v++;

   return t;
}

void main()
{
   counter c;

   for(int i=0; i<8; i++)
   {
      c++;
   }

   c.print();

   for(int i=0; i<8; i++)
   {
      ++c;
   }

   c.print();
}


　　3). 重载函数调用运算符

　　可以将函数调用运算符()看成是下标运算[]的扩展。函数调用运算符可以带0个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。

class F
{
public:

   double operator ()(double x, double y) const;
};

double F::operator ()(double x, double y) const
{
   return (x+5)*y;
}

void main()
{
   F f;

   cout<< f(1, 2) << endl;
}

 

 

8、C++运算符重载
如是牛
12-11 1379
本章内容带领大家学习C++的运算符重载，了解C++运算符重载的应用场景和书写方式。
c++运算符重载之'+'（算术运算符重载）
qq_43941796的博客
07-10 1506
** c++运算符重载之’+’（算术运算符重载） ** 在我们学习了类之后，普通的运算符（像‘+’，‘-’）不能直接作用于对象，这时我们就需要定义运算符重载函数来支持对象之间的运算（具体什么样的运算由用户自己决定）。举一个例子就很好理解，比如我们平常的分数运算，两个分数相加，很显然‘+’是不支持分数相加的那么我们怎么来让他支持呢？ 首先我们要定义一个类来表示分数， class Fraction {...
C++面向对象学习之运算符重载（1）
菱形继承
12-12 478
#include <iostream> using namespace std; class Complex { public: Complex(){} Complex(double a, double b){real=a,imag=b;display();} Complex add(const Complex&a); Complex opera...
运算符重载
weixin_42380877的博客
07-18 204
双目运算符重载为成员函数：重载为类成员的运算符函数定义形式：函数类型 operator 运算符（形参）{ ........}参数个数 = 原操作数个数 - 1 （后置++， --除外）双目运算符重载规则：如果要重载B为类成员函数，使之能够实现表达式 oprd1 B oprd2， 其中oprd1 为A类对象，则B应被重载为A类的成员函数，形参类型应该是oprd2所属的类型经过重载后，表达式oprd1...
C++ 重载运算符 运算符重载函数作为类成员函数 重载运算符+
Z_Dream_ST的博客
09-20 3344
用运算符重载函数作为类成员函数的方法重载运算符+ 下面的例子来自于课本： #include using namespace std; class Complex { public: Complex() //无参构造函数 { real = 0; imag = 0; } Co
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
教你学C++运算符重载源码
最新发布
06-26
"教你学C++运算符重载源码"提供了一个实操平台，让学习者可以在动手实践的过程中加深对C++运算符重载的认识，并将这些知识应用到实际的编程问题中去。通过本项目，学习者不仅能够掌握运算符重载的技巧，还能增强使用...
操作符重载的两种形式
kisswawawa的专栏
06-02 1233
操作符重载的两种形式： 1、重载为类成员函数 2、重载为友元函数 一、运算符形式 1、声明形式 函数类型 operator 运算符（形参） { 。。。。。。。。 } 2、重载为类成员函数时 参数个数=原操作数个数-1（后置++、--除外） 3、重载为友元函数时 参数个数=原早作数个数，且至少应该有一个 自定义类型的形参。 4、双目运算符 B 1）如果要重载B的类成员函数
c++基础（1）
x844049168的博客
07-22 617
如果设计一个类时，没有显示声明定义构造函数、析构函数、复制构造函数、复制运算符、地址运算符，则编译器会自动生成。c++提供了构造函数来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同1、不需要用户来调用它也不能调用，而是建立对象时自动执行2、构造函数的名字必须与类同名，而不能用户任意命名，以便编译系统能识别它并把它作为构造函数处理3、没有返回值4、构造函数的功能是由用户定义的，用户根据初始化要求设计函数体和函数参数5、如果用户不设计，编译器自动生成一个public。......
c++ strlen(),GetLength(),sizeof()用法与区别
Txwtech
12-12 2901
int startstr_count=startStr.GetLength();//统计cstring类型的长度 int startstr_count1=strlen(mapname_aac);//统计char数组类型的长度 int startstr_count1=sizeof(startStr);//是用来计算变量或者对象、类型所占字节的多少 void CgetMapping...
C++——写一函数,求一个字符串的长度。在main函数中输人字符串,并输出其长度。用指针或引用方法处理。
2303_80770781的博客
10-29 356
int main()int len;cin>>str;return 0;int n=0;while(*p!='\0')n++;p++;return n;
【语言-C++】关于CString 函数GetLength()返回值等于0
少莫千华
10-26 7504
代码解读 CString 函数GetLength() int GetLength() const throw() { return( GetData()->nDataLength ); } CString的字符串长度是存在一个nDataLength（int型）的变量中，而nDataLength（int型）不是实时更新的，我们再看下面一个函数ReleaseBuffer
关于Cstring::GetLength()
少年乖
09-07 1万+
原文地址：http://www.cppblog.com/xunbu7/archive/2012/12/03/195930.html strText.GetLength();  返回的是字符个数(不包括结尾的空字符)，要视乎你编译是UNICODE还是MBCS(多字符集)。CString 本身就是TCHAR的封装，所以你定义了UNICODE那么他就占两个字节，否则就是一个字节。
C++中获取静态数组和动态数组的长度
热门推荐
酷小川的博客
10-17 3万+
1.对于字符串数组，可以用strlen( )函数来获取字符串数组的长度。    如：                 char a1[] = "fwegwe";         cout                  2.对于一般的数组，如：int a[ ] = { 40,45,438,12,46,899,450,321,210,785 ,10,57};    可以用size
C++学习笔记——C++ 拷贝构造函数（5）
Half-up的博客
11-18 223
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于： ~通过使用另一个同类型的对象来初始化新创建的对象。 ~复制对象把它作为参数传递给函数。 ~复制对象，并从函数返回这个对象。 如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。 拷贝构造函数的最常见形式如下： classname (const classname &obj) { // 构造函数的主体 } 在这里，obj 是一个对象引用，该对象是用于初
c＋＋运算符重载
03-25
<think>好的，我现在要帮用户介绍C++的运算符重载。首先，我需要回忆一下运算符重载的基本概念。运算符重载允许用户自定义类型使用C++内置的运算符，比如+、-、*等，使得代码更直观和易读。例如，可以让两个对象直接相加，而不必调用特定的函数。 接下来，我应该考虑用户可能的背景。用户可能是刚开始学习C++，或者已经有一定基础但想深入了解运算符重载。因此，解释需要清晰，从基础开始，逐步深入。可能需要先说明什么是运算符重载，为什么需要它，然后讲解如何实现，包括语法和注意事项。 然后，运算符重载的语法是关键部分。需要详细说明如何定义运算符重载函数，包括成员函数和非成员函数（友元函数）的区别。例如，重载+运算符时，成员函数通常只需要一个参数，因为左操作数是对象本身，而非成员函数需要两个参数。同时，要提到一些运算符必须作为成员函数重载，比如赋值运算符=。 例子是帮助理解的重要部分。我应该举一个简单的例子，比如为自定义的Vector类重载+运算符，这样用户可以看到具体的实现方式。同时，需要区分成员函数和非成员函数的例子，说明它们的不同应用场景。 注意事项和常见问题也不能遗漏。比如不能重载的运算符（如.、::、sizeof等），以及重载时保持运算符的原有语义，避免滥用导致代码难以理解。此外，还需要提到运算符的返回类型和参数类型的选择，比如是否返回引用或值，参数的const修饰等。 用户可能还会有疑问，比如运算符重载的使用场景，或者何时应该使用成员函数而非友元函数。因此，在解释过程中需要涵盖这些方面，可能的话，给出一些最佳实践的建议。 最后，总结运算符重载的优点和需要注意的地方，帮助用户全面理解。确保语言通俗易懂，避免过于专业的术语，必要时进行类比，让用户更容易接受。</think>### C++运算符重载详解 #### 1. 什么是运算符重载？ 运算符重载（Operator Overloading）是C++中的一种特性，允许开发者**为自定义类型（如类或结构体）重新定义运算符的行为**。通过重载运算符，可以让对象像内置类型（如`int`、`double`）一样使用`+`、`-`、`*`、`==`等运算符，提升代码可读性和简洁性。 --- #### 2. 如何实现运算符重载？ 运算符重载通过**成员函数**或**全局函数**实现，语法形式为： $$ \text{返回类型 operator 运算符(参数列表)} $$ ##### 示例1：成员函数重载`+` ```cpp class Vector { public: int x, y; // 成员函数重载 + Vector operator+(const Vector& other) { return {x + other.x, y + other.y}; } }; // 使用 Vector v1{1, 2}, v2{3, 4}; Vector v3 = v1 + v2; // 等价于 v1.operator+(v2) ``` ##### 示例2：全局函数重载`<<`（输出流） ```cpp class Student { public: string name; int age; }; // 全局函数重载 << ostream& operator<<(ostream& os, const Student& s) { os << "Name: " << s.name << ", Age: " << s.age; return os; } // 使用 Student s{"Alice", 20}; cout << s; // 输出: Name: Alice, Age: 20 ``` --- #### 3. 常见运算符重载规则 | 运算符类型 | 可重载性 | 示例 | |------------------|----------------|----------------------| | 算术运算符 | `+`, `-`, `*` | `a + b` | | 关系运算符 | `==`, `>`, `<` | `a == b` | | 赋值运算符 | `=`, `+=` | `a = b` | | 下标运算符 | `[]` | `a[0]` | | 函数调用运算符 | `()` | `a(1, 2)` | | **不可重载运算符** | `.`、`::`、`?:`、`sizeof` | 无法重载 | --- #### 4. 关键注意事项 1. **参数限制**： - 至少一个操作数是用户自定义类型（不能全为内置类型）。 - 不能修改运算符的优先级或结合性。 2. **成员函数 vs 全局函数**： - 赋值运算符（`=`）、下标运算符（`[]`）、函数调用运算符（`()`）**必须**作为成员函数重载。 - 输入输出运算符（`>>`、`<<`）通常作为全局函数。 3. **保持语义一致性**： - 例如重载`+`时，不应修改操作数本身，而应返回新对象。 --- #### 5. 完整示例：复数类重载 ```cpp class Complex { private: double real, imag; public: Complex(double r = 0, double i = 0) : real(r), imag(i) {} // 成员函数重载 + Complex operator+(const Complex& other) { return Complex(real + other.real, imag + other.imag); } // 全局友元函数重载 << friend ostream& operator<<(ostream& os, const Complex& c); }; ostream& operator<<(ostream& os, const Complex& c) { os << c.real << " + " << c.imag << "i"; return os; } // 使用 Complex c1(2, 3), c2(4, 5); Complex c3 = c1 + c2; cout << c3; // 输出: 6 + 8i ``` --- #### 6. 应用场景 - 数学计算（向量、矩阵、复数） - 字符串操作（`str1 + str2`） - 容器类（自定义数组、链表） --- #### 7. 总结 **优点**：提升代码直观性，使自定义类型操作更自然。 **注意**：避免过度使用或违反直觉的重载（例如用`+`实现减法）。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值