c++操作符重载
今天我学习的是C++操作符重载。C++的操作符重载给C++带来很大的方便和灵活性。可以重载里面大部分操作符。这样在调用的时候就会相对的自然和简单。废话少说，直接奉上源代码(有部分相关的资料的注释都已经写在源代码上了):
//一位是学习代码，所以写的相对叫乱，如果是其他的就应该规范些 #include<stdio.h> #include <stdlib.h> //总结：重载操作符可以写成成员函数和友员函数。成员函数是类内部的 //函数，而友员函数是外部的函数，例如全局函数，甚至其他类里面的函数,我的习惯是 //写成成员函数，因为我觉得这样感觉要好一点，而且在成员函数中参数还可以少一个。 //哈哈，不过问题就是他不能重载左二元操作符(符号在他的左边)，也就是操作符是在他的左边，所以在 //重载一个整数和这个类相加的情况就只能写友员函数了。 //重载操作符的参数个数一定要跟默认参数个数的一样，除了()这样的可以自己定义以外， //例如operator+();这是错误的，还有operator(int a, int b,int c);这也是错误的 //我下面之所以只有一个，是因为他是成员函数。自己已经包括在里面了，而友员就必须两个都写。 //重载的返回类型没有规定，C++也不是用返回来判断是否重载的， //他是根据函数名和参数列表来判断的。成员函数加const也是重载的一种,但是如果其他都一样只有 //返回类型不一致，就认为是错误的重载。例如： //int operator+(int nAdd) const;和 //CBaseOperator operator+(const CBaseOperator& cAdd) const;就会认为是错误的重载 //而int operator+(int nAdd) const;和int operator+(int nAdd);就是正确的，他们是两个不同的函数 //在调用上，在未指明为const的类调用时，使用的是非const的函数。如果没有非const的函数， //他才会调用const的函数。而如果const的类去调用非const的函数，会直接报错。所以 //在写代码时，可以考虑是不是可能会修改成员，如果希望是不修改的，那么请用const，这样强制性的 //会提高你的编码能力的。（扯远了，呵呵。） //都说友员是一个强大的东东，可以访问内部的private函数和变量，但是，如果把拷贝构造函数和 //=重载为私有的话，他是不能访问的。。哈哈。设计语言的人真厉害。。 //百度百科找的资料: //什么时候定义类成员操作符重载，什么时候定义非类成员操作符重载？ //答：（1）如果一个重载操作符是类成员，那么只有当跟它一起使用的左操作数是该类对象时， //它才会被调用，如果该操作符的左操作数必须是其他类型，那么重载操作符必须是非类成员操作符重载。 //（2）C++要求，赋值（=），下标（[ ]），调用（()）和成员访问箭头（->）操作符必须被指定为类成员操作符，否则错误。 //http://www.examda.com/ncre2/cpp/fudao/20080312/092830274-2.html 网站的资料 //不能重载的操作符号： //. .* :: ?: new delete sizeof typeid static_cast dynamic_cast const_cast reintERPret_cast //可以重载的操作符: //operator new operator delete operator new[] operator delete[] // + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != // <= >= && || ++ -- , ->* -> () [] //貌似这里可以重载new //重载简单的+-*/%等 class CBaseOperator { public: int nData; //测试的变量 public: CBaseOperator(int nData = 0):nData(nData) { nData++; --nData; } CBaseOperator(const CBaseOperator& cBO) { nData = cBO.nData; } //重载=操作符，一般=操作符和拷贝构造函数是成对出现的。 const CBaseOperator& operator=(const CBaseOperator& cBO) { nData = cBO.nData; return *this; } public: //重载+操作符,简单的二元操作符重载是最常见也是比较简单的。基本思路都是这样，注意如果 //操作符出现在左边，则只能用友员了。这里了有几个返回类型是CBaseOperator，return //语句中却是两个int相加，这种情况是可以通过的，编译器会自动构建一个相应的对象返回， //前提是你的构造函数要有相应的参数，这里是int作为参数 int operator+(int nAdd) const { return nData + nAdd; } int operator+(int nAdd) { return nData + nAdd; } friend int operator+(int nAdd,const CBaseOperator& cAdd) { return nAdd + cAdd.nData; } CBaseOperator operator+(const CBaseOperator& cAdd) const { return nData + cAdd.nData; } //重载减法什么的也是一样。就不写了。哈哈 //比较操作符重载==,!=,>, >=, <, <=总结：这里都是配套的操作一般来说如果写一个 //都会重载其他几个，特别是==,!=。当然也有例外。哈哈。。 bool operator==(const CBaseOperator& cEqual) const { return nData == cEqual.nData; } bool operator == (int nEqual) const { return nData == nEqual; } friend bool operator ==(int nEqual, const CBaseOperator& cEqual) { return cEqual.nData == nEqual; } bool operator!=(const CBaseOperator& cEqual) const { return nData != cEqual.nData; } //其他的也就不写了，基本一样。哈哈 //重载++,--操作符,因为++,--有两种方式，一种是前增量(++XXX先改变自己，返回)， //一种是后增量（改变自己，返回改变前的状态) //因为重载是判断参数的，为了能区别前增量和后增量，C++的设计者做了这样的考虑。 //就是重载后增量的时候在参数列表中加一个int类型参数，这样就避免的重载的重复了。 //在调用上，如果都重载，那么用int参数的是后增量++,没有参数的是前增量++， //(注：我在这里说的是成员函数，当然友员的重载参数个数要多一个，以后的我可别说我无知啊。) //如果都重载，那么前增量和后增量都会调用相应的函数，如果只重载了后增量,那么前增量会失败 //如果只重载了前增量，就会无论是前增量和后增量都会调用这个函数。所以一般他们也是成对 //出现的，除非你懒，只写前增量，可惜如果人家要调用后增量呢？结果会错的哦。哈哈。 //重载后增量. CBaseOperator operator++(int) { CBaseOperator cTemp = *this; ++nData; return cTemp; } //重载前增量 CBaseOperator& operator++() { ++nData; return *this; } //重载--操作符是一样的，也不写了。 //重载[],()等操作符号,同样[]的参数个数是确定的。 //我之说以把他们写一起，是因为我错误的以为[]的参数个数是可以自己定义。错了错了。 //知错能改是好的，对了，()的参数个数是可以自己定义的。这个就给我们很大的发挥空间了。 //都忘了[],() = 等操作符必须是成员函数，上面有写。不能用友员和静态成员函数 //重载[] int operator[](int nIndex) const { return nIndex; } //重载() int operator()(int a) const { return a; } bool operator()(int a, int b) const { return a > b; } CBaseOperator operator()(int a, int b, int c) { return CBaseOperator(a+b+c+*this); } //重载*,->的操作符,*操作符就是相当于指针的*p;不过这里已经失去了原来的意义，他不是一个指针了。 //但如果是想通过他来得到一些东西，也是可以的，特别在迭代器中常用这种方法。->也是和*配对出现的。 //不过->操作符比较有意思，貌似和(*p).dddd真的差不多，所以返回的应该是一个结构的指针，我们这里 //就返回了本身，当然可以返回任何结构的指针的。（并不是只能返回本身）。 //重载*，这里参数个数是固定的，多写一个就成了乘法的操作了。哈哈 int operator*() const { return nData; } //重载-> CBaseOperator* operator->() { return this; } //其他的例如&& || 这样的操作符还是不重载的好。利用其原有的本性 //重载new delete,这里编译器做了一个限制，new必须返回void*类型， delete必须 //返回void类型。(上面说过函数重载是不检查返回类型的，和这里并没有冲突，他只是限定了返回 //类型，而不是只有返回类型不同的函数能重载，这个是编译器做的工作，一定上确保new能更好的工作吧) //还有就是他们的参数个数都是可以自定义的。new 和 new[] 是两个不同的操作符，所以还是要分别重载一下。 //delete 和 delete[] 也是两个不同的操作符。这里只重载了一个。 void* operator new(size_t size) { return malloc(size); } void* operator new[](size_t size) { return malloc(size); } void operator delete(void* P, unsigned int size) { size = 0; free(P); } }; int main() { const CBaseOperator cCo1(100); //判断+重载符 int nSum = cCo1 + 50; printf("%d\n", nSum); nSum = 50 + cCo1; printf("%d\n", nSum); //这里顺便检测一下拷贝构造函数 CBaseOperator co2(20); CBaseOperator co3 = co2 + cCo1; nSum = co3.nData; printf("%d\n", nSum); nSum = co3 + 60; printf("%d\n", nSum); //检测+，和=操作符 co3 = 10 + cCo1 + co2 + 20; nSum = co3.nData; printf("%d\n", nSum); //查看比较操作符 if (cCo1 == cCo1 && cCo1 == 100 && 100 == cCo1) { printf("True\n"); } co3 = co2; if (!(co3 != co2)) { printf("True\n"); } //增量操作符，cCo1是不能做这个操作的，因为他是常量 nSum = co2.nData; printf("%d\n", nSum); nSum = (co2++).nData; printf("%d\n", nSum); nSum = (++co2).nData; printf("%d\n", nSum); //测试[], nSum = cCo1[45]; printf("%d\n", nSum); //测试() nSum = cCo1(50); printf("%d\n", nSum); if (cCo1(45, 23)) { printf("True\n"); } co2 = co3(10,20,30); nSum = co2.nData; printf("%d\n", nSum); //测试*,这里co2并不是指针哦。只是重载了*的操作符 nSum = *co2; printf("%d\n", nSum); //测试->,这里也一样。 nSum = co2->nData; printf("%d\n", nSum); //测试new new[] delete, //这里没有测试输出。单步就知道了。 CBaseOperator* pCb1 = new CBaseOperator(); CBaseOperator* pCb2 = new CBaseOperator[10]; delete pCb1; delete pCb2; system("pause"); return 0; }
