Introduction
一、函数重载
关于重载 Overloading，最基本的是根据以下两个特性：
－ 基于参数
－ 基于const
其实，函数重载也没啥多余值得说的东西。
二、自定义操作规则
c++的操蛋属性：自己为一档，空一档，其他随意。
UB_stack a; UB_stack b = a; // copy
auto c = a; auto d {a}; // (or auto d = {a}), deduced type is std::initializer_list
这是一个抓狂的问题，详见：http://scottmeyers.blogspot.com.au/2014/03/if-braced-initializers-have-no-type-why.html
Goto: C++11:std::initializer_list
大神的无奈
今日一乐：为何感觉到了Scott对chinese edition是黑白版本的好奇和无奈。
三、可重载 or 不可重载
Goto: C++ 重载运算符和重载函数
下面是：可重载的运算符列表
| 双目算术运算符 | + (加)，-(减)，*(乘)，/(除)，% (取模) |
| 关系运算符 | ==(等于)，!= (不等于)，< (小于)，> (大于>，<=(小于等于)，>=(大于等于) |
| 逻辑运算符 | ||(逻辑或)，&&(逻辑与)，!(逻辑非) |
| 单目运算符 | + (正)，-(负)，*(指针)，&(取地址) |
| 自增自减运算符 | ++(自增)，--(自减) |
| 位运算符 | | (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移) |
| 赋值运算符 | =, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>= |
| 空间申请与释放 | new, delete, new[ ] , delete[] |
| 其他运算符 | ()(函数调用)，->(成员访问)，,(逗号)，[](下标) |
下面是：不可重载的运算符列表
| 成员访问运算符 | . |
| 成员指针访问运算符 | .*, ->* |
| 域运算符 | :: |
| 长度运算符 | sizeof |
| 条件运算符 | ? |
| 预处理符号 | # |
Overloaded Operator
==
声明关键字 operator，以及紧跟其后的一个c++预定义的操作符，举例如下：
// 申明关键字
class person{ private: int age; public: person(int a){ this->age=a; }
inline bool operator == (const person &ps) const; };
// 实现方式如下 inline bool person::operator == (const person &ps) const { if (this->age==ps.age) // 这里的this看上去是“符号”左边的类 return true; return false; }
int main() { person p1(10); person p2(20); if(p1==p2) cout<<”the age is equal!”< return 0; }
>>, <<, +, +=
包括：(1) 输入输出；(2) 自增自减；(3) 运算．
#include <iostream> #include <vector> #include <algorithm> #include <iterator> #include <UB_stack.h> using namespace std; class Test { public: Test(int x, int y):a{x},b{y}{} // The output operator must be defined as a friend function // and is usually a non-member function. // The input operator is similar.
friend ostream& operator << (ostream&, const Test &); friend istream& operator >> (istream&, Test&); friend Test operator +(const Test&, const Test&);// Usually implemented as a member function.
Test& operator += (const Test &); int returnA(void); void init(void); private: int a; int b; }; /******************************************************************************/
void Test::init(void) { this->a = 1; this->b = 1; } int Test::returnA(void) { return (this->a); } ostream& operator << (ostream &os, const Test &t) { os << t.a << " " << t.b << endl; } istream& operator >> (istream &is, Test &t) { is >> t.a >> t.b; } Test& Test::operator += (const Test &t) { this->a += t.a; this->b += t.b; return *this; } Test operator + (const Test &t1, const Test &t2) { Test ret = t1; ret += t2; return ret; } /******************************************************************************/
class SmallInt {
public: friend ostream& operator << (ostream &os, const SmallInt &s); friend bool operator < (const SmallInt&, const SmallInt&); SmallInt(int v): value_{v} {}
private: int value_; };
// friend function. bool operator < (const SmallInt &rhs,const SmallInt &lhs) { return rhs.value_ <= lhs.value_; }
// friend function std::ostream& operator<<(std::ostream &os, const SmallInt &s) { os << s.value_; return os; } /******************************************************************************/
int main() { cout << "Hello World!" << endl; Test t1{1, 2}; Test t2{10, 20}; /* * I/O Operators */ cout << t1 << t2; cin >> t2; cout << t1 << t2; t1.init(); t2.init(); /* * Compound Assignment Operators */ t2 += t1; cout << t2; /* * Arithmetic Operators */ cout << t1+t2; /* * Relational Operators * ... */
/* * Using the STL Sort and Copy Algorithms */ vector<SmallInt> vec{SmallInt{3}, SmallInt{1}, SmallInt{2}}; sort(vec.begin(), vec.end()); copy(vec.begin(), vec.end(), std::ostream_iterator<SmallInt>(std::cout, " ")); return 0; }
加法运算符重载 de 返回值
函数直接返回类，以为着什么？
会直接调用拷贝构造函数，然后默认实施的是：逐位拷贝语义．
Ref: C++进阶系列：拷贝构造函数与NRV优化
Ref: 关于NRV优化［例子非常不粗］
请问从a, b传入函数开始，一共创建了多少个对象？
Vector a, b;
Vector c = add(a, b);
操作符重载 与 友元函数
一般来说，C++运算符重载可采用成员函数和友元函数，二者都可以访问类的私有成员，那么该采用哪一种呢？
（1）当重载为成员函数时，会隐含一个this指针；当重载为友元函数时，不存在隐含的this指针，需要在参数列表中显示地添加操作数。
上述的代码中，因为用了fridend函数，因此没有用this，所以一元运算符重载 "用到了两个参数"．
（2）当重载为成员函数时，只允许右参数的隐式转换；当重载为友元函数时，能够接受左参数和右参数的隐式转换。
如果采用成员函数形式CString::operator+(const CString& rhs)，则只能接受CString+char；
如果执行char+CString则会编译出错。
简单类型可以＂隐式转换＂为复杂类型．
class CString { public: CString(char* str); private: char* m_pStr; };
一般而言，对于双目运算符，最好将其重载为友元函数；而对于单目运算符，则最好重载为成员函数。
但是也存在例外情况。有些双目运算符是不能重载为友元函数的，比如 赋值运算符=、函数调用运算符()、下标运算符[]、指针运算符-> 等，因为这些运算符在语义上与this都有太多的关联。
比如=表示“将自身赋值为…”，[]表示“自己的第几个元素”，如果将其重载为友元函数，则会出现语义上的不一致。
赋值运算符 =
实际操作当中，调用的是：拷贝构造函数。
返回void，只是”赋值“的简单版本：https://www.runoob.com/cplusplus/assignment-operators-overloading.html
函数调用运算符 ()
也叫做：functor
#include <stdio.h> #include <string.h> #include <thread> #include <functional> #include <iostream> #include <stdio.h> #include <algorithm> using namespace std; struct Sum_t { Sum_t(int * t):total(t) {}; int * total; void operator () (int element) { *total+=element; } }; int main() { int total = 0; Sum_t s(&total); // <-- 这个是构造参数 int arr[] = {0, 1, 2, 3, 4, 5}; std::for_each(arr, arr+6, s); // <-- 类作为函数来使用 cout << total << endl; }
下标运算符 []
假设 X 是某一个类的对象，类中定义了重载“[ ]”的 operator[ ] 函数，则表达式：
X[Y]; 可被解释为： X.operator[](Y);
定义实例：
class SafeArray {
public: SafeArray(int s); SafeArray(const int v[], int s); ~SafeArray() {delete[] values;} int& operator [] (int i); int operator [] (int i) const; private: int size; int *values; };
// 构造函数的实现 SafeArray::SafeArray(int s) : size{s}, values{new int[size]} {} SafeArray::SafeArray(const int v[], int s) : size{s} { values = new int[size]; for (int i = 0; i < size; i++) { values[i] = v[i]; } }
// 符号重载的实现 int& SafeArray::operator [](int index) { assert((index >= 0) && (index < size)); return values[index]; } int SafeArray::operator [](int index) const { // 常函数不能修改 函数内的成员，不能用于右赋值． assert((index >= 0) && (index < size)); return values[index]; }
使用样例：
SafeArray s{10}; // s[12] = 2; // 这算是两个operator，因为是有赋值运算，必须返回&类型．
cout << s[2] << endl;
自增自减符 ++, --
后缀法加了一个参数，有点意思。
From: https://www.runoob.com/cplusplus/increment-decrement-operators-overloading.html
#include <iostream>
using namespace std; class Time { private: int hours; // 0 到 23
int minutes; // 0 到 59
public: // 所需的构造函数
Time(){ hours = 0; minutes = 0; } Time(int h, int m){ hours = h; minutes = m; }
// 显示时间的方法
void displayTime() { cout << "H: " << hours << " M:" << minutes <<endl; }
// 重载前缀递增运算符（ ++x ）
Time operator ++ () { ++minutes; // 对象加 1
if(minutes >= 60) { ++hours; minutes -= 60; } return Time(hours, minutes); }
// 重载后缀递增运算符（ x++ ）
Time operator ++ (int) { // 保存原始值
Time T(hours, minutes); // 对象加 1
++minutes; if(minutes >= 60) { ++hours; minutes -= 60; } // 返回旧的原始值
return T; } };
-------------------------------------------------------------
int main() { Time T1(11, 59), T2(10,40); ++T1; // T1 加 1
T1.displayTime(); // 显示 T1
++T1; // T1 再加 1
T1.displayTime(); // 显示 T1
T2++; // T2 加 1
T2.displayTime(); // 显示 T2
T2++; // T2 再加 1
T2.displayTime(); // 显示 T2
return 0; }
指针相关的，比较复杂，但不经常用到的运算符重载．
指针运算符 -> , *
/* 感觉用处不是很大 */
Ref: C++ 类成员访问运算符 -> 重载
#include <iostream> #include <vector> using namespace std; // 假设一个实际的类 class Obj { static int i, j; public: void f() const { cout << i++ << endl; } void g() const { cout << j++ << endl; } }; // 静态成员定义 int Obj::i = 10; int Obj::j = 12; // 为上面的类实现一个容器 class ObjContainer { vector<Obj*> a; public: void add(Obj* obj) { a.push_back(obj); // 调用向量的标准方法 } friend class SmartPointer; }; // 实现智能指针，用于访问类 Obj 的成员 class SmartPointer { ObjContainer oc; int index; public: SmartPointer(ObjContainer& objc) { oc = objc; index = 0; } // 返回值表示列表结束 bool operator++() // 前缀版本 { if(index >= oc.a.size() - 1) return false; if(oc.a[++index] == 0) return false; return true; } bool operator++(int) // 后缀版本 { return operator++(); } // 重载运算符 -> Obj* operator->() const { if(!oc.a[index]) { cout << "Zero value"; return (Obj*)0; } return oc.a[index]; } }; int main() { const int sz = 10; Obj o[sz]; ObjContainer oc; for(int i = 0; i < sz; i++) { oc.add(&o[i]); } SmartPointer sp(oc); // 创建一个迭代器 do { sp->f(); // 智能指针调用 sp->g(); } while(sp++); return 0; }
类成员访问运算符（ -> ）可以被重载，但它较为麻烦。它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符，返回类型必须是指针或者是类的对象。
运算符 -> 通常与指针引用运算符 * 结合使用，用于实现"智能指针"的功能。这些指针是行为与正常指针相似的对象，唯一不同的是，当您通过指针访问对象时，它们会执行其他的任务。比如，当指针销毁时，或者当指针指向另一个对象时，会自动删除对象。
-> must be a member function and * is usually a member.
(Here 简介)
貌似不错的智能指针的博文：http://www.cnblogs.com/lanxuezaipiao/p/4132096.html
The Basic Idea Behind All Smart Pointers
类型转换操作符
Type Conversion Operators
Conversion operators must be defined as member functions. They
do not take any parameters, nor do they specify a return type.
Typically conversions don’t modify the object and are declared
const.
如果去掉explicit（显式的），则User code中的line 2即可成立。
explicit： 声明为explicit的构造函数，不能在隐式转换中使用。
End.