C++重学 运算符重载

运算符重载

[] () = -> * 只能通过成员函数重载
<< >> 只能通过全局函数重载
不要重载&& || ，失去短路规则
成员函数实现重载

全局函数实现

输入/输出运算符重载

     friend ostream &operator<<( ostream &output, 
                                       const Distance &D )
      { 
         output << "F : " << D.feet << " I : " << D.inches;
         return output;            
      }
 
      friend istream &operator>>( istream  &input, Distance &D )
      { 
         input >> D.feet >> D.inches;
         return input;            
      }

++ 和 – 运算符重载
注意：重载函数的返回值，引用和非引用的区别

1. 重载前缀递增运算符（ ++ ）：
   如果是非引用，那么假如++（++Time), 实际上的Time只回增加一次
   引用：第一次++后还是返回他自己
2. 重载后缀递增运算符（ ++ ）
   返回临时变量T的引用可能会出现问题。

  // 重载前缀递增运算符（ ++ ）
      Time& operator++ ()  
      {
         ++minutes;          // 对象加 1
         if(minutes >= 60)  
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // 重载后缀递增运算符（ ++ ）
      // int 在 括号内是为了向编译器说明这是一个后缀形式，而不是表示整数。
      Time operator++( int )         
      {
         // 保存原始值
         Time T(hours, minutes);
         // 对象加 1
         ++minutes;                    
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // 返回旧的原始值
         return T; 
      }

指针运算符重载（智能指针）
用来托管自定义类型的对象， 让对象进行自动释放

#include<iostream>
class Person {
	int age;
public:
	Person(int age) :age(age) {}
	void showAge() {
		std::cout << age;
	}
	~Person() {
		std::cout << "Person xigou";
	}
};

class SmartPointer {
	Person *person;
public:
	SmartPointer(Person *person) {
		this->person = person;
	}
	// 重载->  让这个智能指针和Person* p1一样可以去使用成员函数
	Person* operator->() {
		return person;
	}
	// 重载*
	Person& operator*() {
		return *person;
	}
	~SmartPointer() {
		// 智能指针在释放时，会自动释放托管的自定义对象
		std::cout << "zhineng zhizhen";
		if (person != NULL) {
			delete(person);
			person = NULL;
		}
	}
};

int main()
{
	Person* p1 = new Person(10);
	SmartPointer s(p1);
	s->showAge(); // s->->showAge(); 编译器自动优化了
	(*s).showAge();
}

赋值运算符重载
一个类会创建默认 构造，析构，拷贝构造，operator=
如果不重写operator= / 拷贝构造，可能会出现深拷贝浅拷贝的问题

p3 = p2 = p1;

[]重载
返回引用才能做左值

 int& operator[](int i)
      {
          if( i > SIZE )
          {
              cout << "索引超过最大值" <<endl; 
              // 返回第一个元素
              return arr[0];
          }
          return arr[i];
      }

（）重载
仿函数

class Person {
	...
	void operator()() {

	}
};

	Person p2(2);
	p2(); // 仿函数

MyAdd() 匿名对象

不要重载&& ||
会失去短路特性