#1.头文件

#include<iostream>
#include<cstdlib>
#include <cstring>
#include <algorithm> //给sort函数做准备
#include <vector>
#include <new>
using namespace std;

#2.重载运算符

对于二元运算符重载

class number{
	public:
		number(int a,int b):real(a),image(b){}//初始化列表
		friend number operator+(const number&n1,const number&n2);//声明友元函数进而使其在括号内声明的新的对象在类外也能访问私有化对象
	private:
		int real;
		int image;
}; 
number operator+(const number&n1,const number&n2){
	return number(n1.real+n2.real,n1.image+n2.image);//优化过的输出方式，从ASCLL码上来看，大大减少了输出的反应时间
}

但是，此方法是当重载运算符的函数在类外声明的时候使用的（函数为自由函数，即在类和结构体之外的时候才使用），在类内声明的时候，有别的方法如下。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <iostream>
#include <vector>
#include <new>
#include<algorithm>
using namespace std;
#define PI 3.14
class number{
	public:
		number(int a,int b):real(a),image(b){}
	    number operator+(const number&n1){//当作为一个类内函数的时候，声明的过程中就会出现一个this指针，可以默认看成一个对象，所以就不用在括号内声明两个对象了
        //同时，因为指针的存在，且类里的指针只能用->来指向类里面的小变量
     	return number(this->real+n1.real,this->image+n1.image);
}
	private:
		int real;
		int image;
}; 
int main()
{
	
    return 0;

对于一元运算符重载

class clock{
	public:
    	clock& operator++();//&代表引用clock，加快运行效率，
        //但是使用有条件，其优点是省去了重新拷贝一个副本进行
        //运算的过程，坏处是有的重载函数返回的就是那个拷贝函
        //数，如果失去拷贝，直接返回引用的东西，就会出现指针
        //悬空。因为如clock，他会在return之后被销毁，等于我们返回的引用没了，所以没有意义。
        
        clock operator++(int);//此处括号内的int是用作伪参数，用于区分第三行与之很像的代码
}；
Clock& Clock::operator ++() 
{	Second++;
	if(Second>=60)
	{   Second=Second-60;
	     Minute++;
	     if(Minute>=60)
	     {    Minute=Minute-60;
	          Hour++;
	          Hour=Hour%24;
	     }
	}
    return *this;
}
Clock Clock::operator ++(int)	//这个时候不能用引用&，因为后置++是先不计算+的，不能返回一个引用值，因为他会在函数结束后消失，消失了就没意义了。
{	//注意形参表中的整型参数
    Clock old=*this;
    ++(*this);
    return old;
}

同时，对于类内的成员函数，即使他们在类之外，也能引用private类成员。

但是也不能忘记了在类外引用函数的前提条件。

如：

class circle{
	public:
    	double area();
    private:
    	int a,b;
        double h;
};
circle::area(){
	return a+b;//成立

#有关于class的相关知识


#友元函数





class student{
	public:
    	friend void hi();
    private:
		int a,b;
        int c;
};
void friend(){
	cout<<a;
    }//可以不用：：来引用函数了

得记着初始化，尤其是出现父类子类的时候。

class father{
	public:
    	father(int age):level(age){}
        
    private:
    	int level;
};
class son:private public{
	public:
    	son(int n):result(n),level(n){}//当父类的构造函数声明且在括号内需要写入东西时，必须要一起写在子类的构造函数的初始化列表里面；
    private:
    	int result;

#析构函数

class student{
	public:
    	student()；
        ~student();//析构函数会在程序结束时执行，作为摧毁他们的标志；
};