【漫漫转码路】Day 39 C++ day10

之前

变量型指针可以隐式转换成常量型指针
也就是说一般指针可以转换成const char *，但是const char *不能转换成一般指针

char *p = "abc"  // 会报错
char a[100] = "kkk"
const char *m = a;  // 这种是可以的

不涉及深拷贝的类不用写拷贝构造函数，系统会自动生成
运算符重载，入口参数一律认为是右值
做连等号的重载需要有返回值，不能用void

关于临时变量

临时变量通常被认为是不可修改的常量，也就是带const的，如果传给变量，会报错

v1.func(v1+v2);

这里，v1+v2会先产生一个临时变量=v1+v2，然后将值给到func()，临时变量在;结束的时候被销毁;
临时变量也会产生构造函数
如果编不过，可以加强制类型转换

func(& that)  // 这里that是个引用，所以不涉及到临时变量的创建和销毁

单例模型

构造函数和析构函数都在protected里面，外部无法调用，public只有一个静态指针返回到构造函数，也就是说，整个类里面，只有一个公有的静态方式获取到实例，这种模型称为单例模型
头文件

//例如
class studentceator
{
protected:
	studentceator();
	~studentceator();
public:
	static studentceator* getinstance();
};

函数体

//例如
#include"single_mod.h"
studentceator::studentceator()
{

}
studentceator::~studentceator()
{

}
studentceator* studentceator::getinstance()
{
	static studentceator* m_pinstance = nullptr;
	if (m_pinstance == nullptr)
	{
		m_pinstance = new studentceator();
	}
	return m_pinstance;
}

调用

//例如
#include"single_mod.h"
int main()
{
	studentceator* p = studentceator::getinstance();
}

继承

公有继承

默认公有继承，也就是public继承
B是A的子类，则默认B继承A所有public和protected接口，在A中是public则B中也是public，在A中是protected，则在B中也是protected
构造函数，先调基类A的构造函数，再调子类B的构造函数
析构函数，先调子类B的析构函数，再调基类A的析构函数

//例如
class A
{
public:
	A() { m_data = 0; cout << "A的构造函数"<<"\n"; };
	~A(){ cout << "A的析构函数" << "\n"; }
	void setdata(int b) { m_data = b; };
	int getdate() { return m_data; }
protected:
	int m_data;
};
class B : public A  // 公有继承
{
public:
	B() { cout << "B的构造函数" << "\n"; };
	~B() { cout << "B的析构函数" << "\n"; };
	int adddata(int a) { return m_data += a; };
protected:
};

int main()
{
	B b;
	b.adddata(5);
	b.adddata(3);
	cout << b.getdate() << "\n";
}

//显示
A的构造函数
B的构造函数
8
B的析构函数
A的析构函数

私有继承

基类A的public全都变成B的private
A的private在B中直接不可访问

//例如
class A
{
public:
	A() { m_data = 0; cout << "A的构造函数"<<"\n"; };
	~A(){ cout << "A的析构函数" << "\n"; }
	void setdata(int b) { m_data = b; };
	int getdate() { return m_data; }
protected:
	int m_data;
};
class B : private A  // 私有继承
{
public:
	B() { cout << "B的构造函数" << "\n"; };
	~B() { cout << "B的析构函数" << "\n"; };
	int adddata(int a) { setdata(getdate() + a); };
protected:

};

int main()
{
	B b;
	b.adddata(5);
	b.adddata(3);
	cout << b.getdate() << "\n";  //不可调用
}

保护继承

基类的public和protected成员：都以protected身份出现在派生类中；
基类的private成员：不可直接访问

私有继承应用

has-a逻辑
私有继承可以写成组合的方式

多重继承

//例如
class anmal
{
public:
	anmal() { cout << "这是anmal"<<"\n"; };
	~anmal(){  }
	void shout() { cout << "叫啥" << "\n"; };
protected:
};

class sheep : public anmal
{
public:
	sheep() { cout << "这是sheep" << "\n"; };
	~sheep() {  };
	void shout() { cout << "咩"<<"\n"; };
protected:

};

class camel : public anmal
{
public:
	camel() { cout << "这是camel" << "\n"; };
	~camel() {  };
	void shout() { cout << "哞" << "\n"; };
protected:

};

class yangtuo : public sheep, camel  // 菱形继承
{
public:
	yangtuo() { cout << "这是yangtuo" << "\n"; };
	~yangtuo() {  };
	void shout() { cout << "阿巴阿巴" << "\n"; };
	void shout2() { sheep::shout(); camel::shout(); };
protected:

};
int main()
{
	sheep sheep;
	sheep.shout();  //子类和基类有相同名称的方法，子类会重写基类的方法，
	yangtuo yt;
	yt.shout();
	yt.shout2();

对于菱形继承，会从左到右，先运行，左边基类的基类的构造函数，再运行左边基类的构造函数，然后是右边基类的基类的构造函数，和右边基类的构造函数
一个类继承多个类的时候，如果调用相同名称的函数，一定要写清调用哪个类中的函数否则会报错
菱形继承，多个类继承一个类的时候，从分开的时候，内存占用就彻底分开了

//显示
这是anmal
这是sheep
咩
这是anmal
这是sheep
这是anmal
这是camel
这是yangtuo
阿巴阿巴
咩
哞