[c++] Operator overloading

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

---

==

Ref: C++ 关系运算符重载

声明关键字 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();
  person p2();
  if(p1==p2) cout<<”the age is equal!”< return ;
}

>>,  <<,  +,  +=

包括：(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 = ;
    this->b = ;
}

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{, };
    Test t2{, };

    /*
     * 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{}, SmallInt{}, SmallInt{}};

    sort(vec.begin(), vec.end());
    copy(vec.begin(), vec.end(), std::ostream_iterator<SmallInt>(std::cout, " "));

    return ;
}

加法运算符重载 de 返回值

函数直接返回类，以为着什么？

会直接调用拷贝构造函数，然后默认实施的是：逐位拷贝语义．

Ref: C++进阶系列：拷贝构造函数与NRV优化

Ref: 关于NRV优化［例子非常不粗］

请问从a, b传入函数开始，一共创建了多少个对象？

Vector a, b;
Vector c = add(a, b);

操作符重载 与 友元函数

C++操作符重载形式——成员函数or友元函数

一般来说，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 = ;
    Sum_t s(&total);　　// <-- 这个是构造参数

    int arr[] = {, , , , , }; 

    std::for_each(arr, arr+, 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 = ; 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{};
//    s[12] = 2;    // 这算是两个operator，因为是有赋值运算，必须返回&类型．
    cout << s[] << 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 = ;
         minutes = ;
      }
      Time(int h, int m){
         hours = h;
         minutes = m;
      }
      // 显示时间的方法
      void displayTime()
      {
         cout << "H: " << hours << " M:" << minutes <<endl;
      }
      // 重载前缀递增运算符（ ++x ）
      Time operator ++ ()
      {
         ++minutes;          // 对象加 1
         if(minutes >= )
         {
            ++hours;
            minutes -= ;
         }
         return Time(hours, minutes);
      }
      // 重载后缀递增运算符（ x++ ）
      Time operator ++ (int)
      {
         // 保存原始值
         Time T(hours, minutes);
         // 对象加 1
         ++minutes;
         if(minutes >= )
         {
            ++hours;
            minutes -= ;
         }
         // 返回旧的原始值
         return T;
      }
};

-------------------------------------------------------------
int main()
{
   Time T1(, ), T2(,);

   ++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 ;
}

指针相关的，比较复杂，但不经常用到的运算符重载．

指针运算符 -> , *

/* 感觉用处不是很大 */

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 = ;
int Obj::j = ;

// 为上面的类实现一个容器
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 = ;
   }
   // 返回值表示列表结束
   bool operator++() // 前缀版本
   {
     if(index >= oc.a.size() - ) return false;
     if(oc.a[++index] == ) return false;
     return true;
   }
   bool operator++(int) // 后缀版本
   {
      return operator++();
   }
   // 重载运算符 ->
   Obj* operator->() const
   {
     if(!oc.a[index])
     {
        cout << "Zero value";
        return (Obj*);
     }
     return oc.a[index];
   }
};

int main() {
   const int sz = ;
   Obj o[sz];
   ObjContainer oc;
   for(int i = ; i < sz; i++)
   {
       oc.add(&o[i]);
   }
   SmartPointer sp(oc); // 创建一个迭代器
   do {
      sp->f(); // 智能指针调用
      sp->g();
   } while(sp++);
   return ;
}

类成员访问运算符（ -> ）可以被重载，但它较为麻烦。它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符，返回类型必须是指针或者是类的对象。

运算符 -> 通常与指针引用运算符 * 结合使用，用于实现"智能指针"的功能。这些指针是行为与正常指针相似的对象，唯一不同的是，当您通过指针访问对象时，它们会执行其他的任务。比如，当指针销毁时，或者当指针指向另一个对象时，会自动删除对象。

-> 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.