运算符重载

一.基本运算符重载 1.不能重载的运算符：. :: ?: sizeof 2.返回值类型 operator+(){} 3.因为这个运算符重载是在类中，this指针要占一个参数 4."+"重载 int operator + ( ) { # include <iostream> using namespace std ; class student { int a ; public : student ( ) { a = 1 ; } int operator + ( const student & stu ) { return this - > a + stu . a ; } } ; int main ( ) { student stu1 , stu2 ; int c = stu1 + stu2 ; //stu1是调用者，stu2是传入者 cout << c << endl ; system ( "pause" ) ; return 0 ; } } 5."*"重载 功能是输出一句话 void operator * ( ) { cout << "你是猪吗" << endl ; } * stu1 ; 4.显示调用:int c=stu1.operator+(stu2); 二.前后++重载 1.前置++重载 student & operator ++ ( ) { this - > a ++ ;

常规 ： 通过调用方法实现，让 ‘+’实现两个对象（负数）相加 # include <iostream> class Complex { public : Complex ( ) ; Complex ( double r , double i ) ; Complex Complex_add ( Complex & d ) ; //普通的函数调用 //Complex operator+(Complex &d); //运算符重载 void print ( ) ; private : double real ; double imag ; } ; Complex : : Complex ( ) { real = 0 ; imag = 0 ; } Complex : : Complex ( double r , double i ) { real = r ; imag = i ; } Complex Complex : : Complex_add ( Complex & d ) { Complex c ; c . real = real + d . real ; c . imag = imag + d . imag ; return c ; } Complex Complex : : operator + ( Complex & d ) { Complex c ; c . real =

运算符重载基本概念 1）目的是拓展原C程序运算符的作用范围，使程序看起来更加简洁 2）本质是函数，可以称之为运算符函数 3）可以定义为普通函数，也可定义为成员函数 4）把含运算符的表达式转换成函数的调用 5）运算符操作数转换为函数的参数 6）运算符函数可以重载，调用时根据参数类型选择 例如： class complex { public : double real , imag ; complex ( double r = 0.0 , double i = 0.0 ) : real ( r ) , imag ( i ) { } complex operator - ( const complex & r ) ; } ; complex operator + ( const complex & c1 , const complex & c2 ) { return complex ( c1 . real + c2 . real , c1 . imag + c2 . imag ) ; } complex complex :: operator - ( const complex & r ) { return complex ( real - r . real , imag - r . imag ) ; } int main ( ) { complex a ( 4 , 4 ) , b (

P436 C++ Primer Plus(第六版） #define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; class Cp { public: 　　static int sta1, 　　sta2, 　　sta3, 　　sta4; 　　char *c; 　　int len; 　　Cp(const char* st = "no") 　　{ 　　　　sta1++; 　　　　cout << "默认构造= " << sta1 << "; 总构造= " << sta1 + sta2 << "; " << endl; 　　　　len = strlen(st); 　　　　c = new char[len + 1]; 　　　　strcpy(c, st); 　　} 　　Cp(const Cp& p) 　　{ 　　　　sta2++; 　　　　cout << "copy构造= " << sta2 << "; 总构造= " << sta1 + sta2 << "; " << endl; 　　　　len = p.len; 　　　　c = new char[len + 1]; 　　　　strcpy(c, p.c); 　　} 　　~Cp() 　　{ 　　　　sta3++; 　　　　cout << this->c << "'

一般的我们喜欢这样对对象赋值： Person p1;Person p2=p1; classT object(another_object), or A a(b); classT object = another object; class A { // … }; int main( ) { A x; A y(x); // … A z = x; z = y; } 这样的话，如果成员变量中有指针的话，就容易造成指针的二次删除。这样就需要我们显示的在类中实现 1、拷贝构造， 2、赋值运算符重载。 1）、判断是不是自赋值，2）、释放旧空间，3）、开辟新空间。4）、内容本身的 拷贝，5）、返回*this 3、析构函数（释放指针指向的空间）。 这三步使类实现深拷贝，从而避免浅拷贝的二次删除问题。俗称三大件。 class Vector { private: int *rep; int size; void clone(const Vector& a); void dispose( ); public: Vector(int s=0); // a default constructor initializing all members of rep to 0 if s is not 0. Vector( int*, int ); // a constructor creates a Vector

C++ Code 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

1、什么是运算符重载？ (1)运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的 数据类型 。 因为在实际中确实有这种需求，例如将两个类对象直接相加，直接比较两个类对象的大小.....等等，因为普通的运算符 不能完成这种功能，所以在适当的时候对运算符进行重载，能够给我们的编程带来很大的方便。 (2)运算符函数定义的一般格式： <返回类型说明符> operator<运算符符号>(<参数表>) { <函数体> } 2、运算符重载的分类：一元运算符重载、二元运算符重载 一元运算符表示的是这中运算符只需要一个数参与运算，而二元运算符表示这种运算符需要两个数参与运算；例如：两个是相加的 "+"运算，就是一个二元运算符，两个数相乘的 "*" 运算符也是一个二元运算符；而 "++" "--"，还有作为取反的负号运算符 "-" 等等都是一元运算符。 (1)一元运算符重载，本例子中使用 "-" 和 "++"运算符来演示一元运算符重载的使用，" ++"运算符的两种重载方式：前置++、后置++ 按照运算符重载的方式来说，一般分为友元函数重载和成员函数重载两种方式，下面分别用代码进行说明： 1 #include <iostream> 2 using namespace std; 3 4 class Coordinate{ // 定义一个坐标类 5 public: 6

一、加号+ 1.成员函数重载 2.友元函数重载 二、输出符号<< 三、索引符号 [ ] 四、补充说明 1.《二元运算符重载》课程评论： （一）为什么<<运算符的重载必须定义为友元 如果在类中定义非友元成员函数，默认第一个参数默认会传入this*指针，这时就无法实现cout在前<<对象在后的格式 因为二元运算符中的调用格式是 参数一 运算符 参数二 这也就是为什么 加号运算符可以使用非友元成员函数，因为参数一是一个this*指针，参数二是其它对象 假设定义为非友元成员函数，那么第一个参数系统默认为this*（且无法更改），第二个参数是cout 那么调用格式就变成了 coor << cout了，这就是不能定义为非友元成员函数的原因 （二） 这里对于输出运算符重载讲得一般，当时课程上学习的时候，这里返回值为out是有原因的。 cout<<coor1<<coor2<<endl; 上面这个例子中，第一次重载<<的时候cout作为第一个参数，coor作为第二个参数，返回出来out的引用，这个out引用的是"cout<<coor1"， 第二次重载的时候是将这个cout<<coor1整个作为out流对象，做成第一个参数。 2.《二元运算符重载》课程评论： 来吧！让我给您们解释一下为什么<<只能友元，而[]只能成员重载； 简而言之： <1> 对于友元重载没有this指针指向当前对象的

全局运算符重载要注意函数的声明 全局运算符重载中的等号是浅拷贝，并非深拷贝。 代码如下： # include <iostream> using namespace std ; class Person ; Person operator + ( const Person & p1 , const Person & p2 ) ; // 注意函数的声明 class Person { public : int m_A ; int m_B ; } ; void test01 ( ) { Person p1 ; p1 . m_A = 5 ; p1 . m_B = 3 ; Person p2 ; p2 . m_A = 2 ; p2 . m_B = 7 ; // 关于什么时候调用拷贝构造函数，什么调用等号的载载，可以参考其他资料 // 简单举例如下： // Person t = p1; // 调用拷贝构造函数，因为t还没有被被始化 // ---------- // Person t; // t = p1; // 调用等号的重载，因为t已经被构造，初始化 Person p3 = p1 + p2 ; // 此处使用的默认拷贝构造函数为浅拷贝 cout << "p3.m_A = " << p3 . m_A << endl ; cout << "p3.m_B = " << p3 . m_B <<

一、运算符重载 1.C++中可以重载的运算符：： 2.C++中不可以重载的运算符： 3.C++中只能进行类内重载的运算符： =、()、[]、-> 自增自减运算符(++、–)、输入输出(>>、<<)、四则运算符（+、-、 、/、+=、-=、 =、/=）和关系运算符（>、<、<=、>=、==、!=）都是数学运算符，它们在实际开发中非常常见，被重载的几率也很高。本文以复数类 CComplex 为例对它们进行类外重载，演示运算符重载的语法以及规范。代码如下所示： # include <iostream> using namespace std ; class CComplex { double m_fReal ; double m_fImag ; public : CComplex ( ) { m_fReal = m_fImag = 0 ; } CComplex ( double d1 , double d2 ) { this - > m_fReal = d1 ; this - > m_fImag = d2 ; } //声明友元函数 friend CComplex operator + ( const CComplex & c1 , const CComplex & c2 ) ; friend CComplex operator - ( const CComplex & c1 ,