OOP_review

引用

//给变量起别的名字
int a = 10 ;
int & b = a;
//数据类型&别名 = 原名;
//引用必须先初始化，一但初始化后，就不可以更改

//引用作传参
//作用：可以用形参改变实参
//可以用指针修改
//值传递
void exchange(int * a , int * b)
{
    int tmp;
    tmp = *a ;
    b* = tmp;
    a* = *b;
}
//引用传递
void swap(int & a , int & b)
{
    int tmp = a ;
    a = b;
    b = tmp;
    
}

//swap(a,b) -> 改变成功;

//引用作函数返回值
//不要返回局部变量的引用，函数调用可以作为左值的存在

int & test()
{
    static int a = 10;//全局区上的数据在程序结束后系统释放
    return a;
}


test() = 10086;//返回值2就改为10086

//引用的本质：内部实现就是一个指针常量

指针

const int * p = &a;//const 修饰的是指针 ，指针的指向可以修改，指针指向的值不可以修改
int * cosnt p = & a; // const 修饰的是常量 ， 指针的指向不可以修改 ， 指针的值可以修改

new操作符

//new返回的是该数据类型的指针
int * p = new int(num);//num是变量
delete p;
//new 开辟数组
int * array = new int[num];
delete[] array;

构造函数和析构函数

class t
{
    private:
		int a;
    public:
		t(int aa){a = aa};
    	~t(){}
};

 //拷贝构造
class pe
{
  private:
    int xxx;
  public:
    pe(const pe &p ) //const修饰避免拷贝对象被改变
    {
        xxx = p.xxx;
	}
};
//拷贝构造函数调用
//1.使用一个已经创建完毕的对象来初始化一个新对象
//2.值传递的方式给函数参数传值
//3.以值的方式返回局部对象

//类默认的三个函数 ： 1.默认构造函数（无参） 2.默认析构函数（无参） 3.默认拷贝构造函数
//若有有参构造则不提供无参构造，但提供拷贝构造
//若有拷贝构造，则无其他构造函数

//深拷贝 ： 简单的赋值拷贝操作
//浅拷贝 ： 在堆区重新申请空间进行拷贝操作（new）申请
pe(const pe & p)
{
    age = p.age;
    pointer = new int(*p.pointer);//(int * pointer;)
}
~pe()
{
    if(pointer != NULL)
    {
        delete pointer;
        pointer = NULL;
	}
}
//初始化列表
pe(int aa , int bb , int cc):a(aa),b(bb),c(cc){}

静态成员

//静态成员变量 ： 所有对象共享 ， 类内声明类外初始化
class p
{
    public:
    	static int a;//1.通过对象访问 2.通过类名访问
}
int p::a = 10086;//类外初始化

//静态成员函数 ： 只能访问静态成员变量

this指针

//this指针指向被调用的成员函数所属的对象
//用于解决名称冲突
//返回对象本身

继承

class pp : public Base
{
	public:
    int a;
};

//继承中private的内容子类都不可以访问
//public继承照搬除private的所有成员及其属性
//protected继承将所有非private成员变为protected成员
//继承中有同名的对象直接访问即可，访问父类成员需加作用域
//a -> 子类 Base::a -> 父类 函数同理

//多继承
class son : public base1 , public base2
{
    //引发同名成员用作用域访问
};

//菱形继承
//成员不明确可以用作用域区分
//继承加上virtual变成虚继承
 class sheep : virtual public animal
{
};
class tuo : virtual public animal
{
};
class sheep_tuo : public sheep , public tuo
{
};

多态

//虚函数可以重写父类函数
class animal
{
    virtual void speak(){}//虚函数
};
class cat : public animal
{
    void speak(){cout << "cat speak" << endl;}
};
void speak(animal & a)
{
    animal.speak();
}

运算符重载

//加号运算符重载
person operator+ (person & pp , person & p)
{
        person tmp;
        temp.a = pp.a + p.a;
        temp.b = pp.b + p.b;
        return tmp;
}//全局函数重载
class person
{
public:
    int a , int b;
    person operator+ (person & p)
    {
        person tmp;
        temp.a = this -> a + p.a;
        temp.b = this -> b + p.b;
        return tmp;
	}
};

//左移运算符重载 <<
ostream & operator<<(ostream & cout , p)
{
    cout << p.a << p.b;
    return cout;
}
class person
{
    friend ostream & operator<<(ostream & cout , p)
public:
    person(int aa , int bb )
    {
        a = aa , b = bb;
	}
private:
    int a , int b;
    //不利用成员函数重载<<运算符，因为无法实现cout在左侧
};
int main()
{
    int a , b;
    cin >> a >> b;
    person p(a,b);
    cout << p;
    return 0;
}

//递增运算符重载
class mint
{
  public:
    mint()
    {
        num = 0;
	}
    //前置递增
    mint &operator++()//为了一直对一个数据进行操作
    {
        num++;
        return *this;//将自身作返回
    }
    //后置递增
    mint operator++(int )//为了一直对一个数据进行操作
    {
      	//先记录结果
        mint tmp = *this;
        //后递增
        num++;
        //最后记录结果作返回
        return *this;
    }
   private:
    int num;
};

赋值运算符

class person
{ 
	public:
    person (int a)
    {
        age = new int(a);
    }
    int * age;
}