C++ 学习笔记-10

在C++里面几乎可以重载所有的运算符
.  .*  ::  ?:
sizeof  typeid 
static_cast  dynamic_cast  const_cast  reinterpret_cast
这些运算符不能重载

只有已经存在的运算符可以重载，不能自己创造
重载的运算符不能改变其原来的操作数
不能改变它的优先级

运算符重载为成员函数参数表可以少一个，因为有一个隐藏的参数
重载为非成员函数，参数个数与操作数相同

x+y => x.operator+(y)
运算符左边的表达式叫做 receiver, 它决定用哪个 + 

重载运算符的建议：
    1: 单目的 应该 做成成员的
    2: = () -> ->* 一定要做成成员的
    3: 所有的二元运算符都做成非成员的

传进去的参数必须是引用，而且如果运算会改变算子就不能是const
assignment operator (重载赋值运算符)
如果没有自己重载的 = 
那么系统生成的是一个成员级别的赋值，这一点跟拷贝构造是一样的
如果要写一个自己的重载 = ，那么这个函数必须是成员函数
如果类里面有指针，动态内存分配的需要自己写一个重载的 =   没有，就可以不写
防止系统做的错误行为，可以将 assignment operator 声明为private, 但这样写代价很大，因为这个类的对象是不能被赋值的

在构造函数加上 explicit 关键字，就意味着是显示的构造，不能做自动类型转换

尽量少用自动帮你做的事情(构造，类型转换...)

learning record code:

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

class Integer{
    private:
        int i;
    public:
        Integer(int n = 0) : i(n) {}
        const Integer operator+(const Integer &n) const
        {
            return Integer(i + n.i);        // 返回的是一个对象，且不可修改
        }
        friend const Integer operator + (const Integer &lhs, const Integer &rhs);
        operator double() const;        
};
Integer::operator double() const    // 专用的类型转换函数，将Integer的对象转换成double类型
{
    return (double) i;
}

const Integer operator + (const Integer &lhs, const Integer &rhs)
{
    return Integer(lhs.i + rhs.i);
}


class Cargo{
    private:
        char *p;
    public:
        Cargo & operator = ( const Cargo & rhs )
        {
            if(this != &rhs)    // 一定要有这个判断
            {
                // perform assignment
                delete p;       // 如果没有之前的if判断，这里就会出错
                p = new char[strlen(rhs.p) + 1];
                strcpy(p, rhs.p);
            }
            cout << "inside Cargo::operator=" << endl;
            return *this;
        }
};

class Truck{
    Cargo b;
};

class PathName{
    private:
        string name;
    public:
        explicit PathName(const string &);      // 显式的构造函数，不能做自动类型转换
        ~PathName();
};

// class Orange;
// class Apple{
//         int k;
//     public:
//         operator Orange() const;
// };
// Apple::operator Orange() const
// {
// }

// class Orange{
//     int j;
//     public:
//         explicit Orange(Apple);     // 显式构造函数，不能做隐式的类型转换
// };
// Orange::Orange(Apple)
// {
// }

// void f(Orange)
// {

// }

int main()
{
    Truck a, b;
    a = b;



    return 0;
}