由于C++的类没学好。这是在另一个班学习的笔记
一、面向对象的三大特征
封装、继承和多态
二、类之间的继承
【1】访问权限
public:类中、子类和类外都可以访问
private:类中可以访问，类外和子类中都不能访问
protected:类中和子类可以访问，类外不能访问
【2】继承
继承指的是，基于已有类，创建出新类的过程。
基类和派生类
父类和子类
【3】继承的作用
能提高代码的复用性，父类/基类中原有的内容，在子类/派生类中无需再定义，直接使用即可
继承是实现多态的前提
【4】继承的格式
已有class A，要创建一个class B继承自A
class B:权限 A ----->创建一个B类，用特定的权限继承方式继承自A
A类可以被称为父类、基类
B类可以被称为子类、派生类
class B:public A{} ---->B类公有继承A类
class B:private A{} ---->B类私有继承A类
class B:protected A{} ---->B类受保护的继承A类
三种继承权限
父类中访问权限
public|protected|private public|protected|private public|protected|private
继承方式
public private protected
子类中访问权限
public|protected|不能访问 private|private|不能访问 protected|protected|不能访问
【5】子类对父类中成员的继承
子类会继承父类中的所有成员，包括私有成员
类之间的继承关系，可以理解为是包含关系
子类中从父类继承的成员，先存放，放在首地址，父类的指针/引用可以指向子类的对象
父类的指针，可以访问的空间，只有父类本身的内容，子类的指针可以访问的空间包含父类继承的和子类拓展的
【6】子类中存在和父类同名成员时
通过子类对象默认访问的是，子类的成员
如果想要访问父类的成员，使用类名加上域标识符可以访问父类中的内容
或者也可以通过父类的指针指向子类对象，再来访问
三、继承中特殊的成员函数
这四个成员函数都不会被继承
【1】构造函数
父类中的构造函数不会被继承
实例化子类对象时，先调用父类中的构造函数，再调用子类中的构造函数
如果父类中只有有参构造，子类必须在构造函数的初始化列表中显性的调用父类的有参构造
【2】析构函数
父类中的析构函数不会被子类继承
先析构子类，再析构父类
有指针成员的情况：如果父类中有指针成员，需要在父类的析构函数中手动释放堆区的空间；如果子类中有指针成员，需要在子类的析构函数中手动释放堆区的空间
父类的析构函数，不需要再子类中手动调用，系统会自动调用析构函数
【3】拷贝构造函数
申请空间并初始化
如果父类中有指针成员，继承时会不会涉及到深浅拷贝问题？会
父类的拷贝构造不会被继承
如果父类中有指针成员，需要显性写出父类的深拷贝函数；如果指针成员在子类中九显性写出子类的深拷贝函数
子类的拷贝构造需要显性调用父类的拷贝构造，直接传子类的对象
【4】拷贝赋值函数
拷贝赋值函数也涉及到深浅拷贝问题
拷贝赋值函数也不会被继承
子类和父类有不同的拷贝赋值函数
如果父类中有指针成员，就显性写出父类的深拷贝赋值函数，如果子类中有指针成员，就显性写出子类的深拷贝赋值函数，如果显性写出了子类的深拷贝赋值，子类的拷贝赋值函数内一定要显性调用父类的拷贝赋值函数。
#include <iostream>
using namespace std;
class Person
{
private:
int *age;
string name;
public:
//无参构造
Person():age(new int){cout << "Per无参构造" << endl;}
//有参构造
Person(string name,int age):name(name),age(new int(age))
{cout << "Per的有参构造" << endl;}
//拷贝构造
Person(Person &other):age(new int(*(other.age)))
{
//*(this->age) = *(other.age);
this->name = other.name;
}
~Person()
{
cout << "释放了堆区的空间" << age << endl;
delete age;
cout << "Person的析构函数" << endl;
}
void show()
{
cout << "Per中age" << *age << endl;
}
void show_()
{
cout << age << endl;
}
//Person的深拷贝赋值
Person &operator=(const Person &other)
{
if(this!=&other)
{
this->name = other.name;
*(this->age) = *(other.age);
}
return *this;
}
};
//定义Stu类继承自Person
//类默认是私有继承，常用的继承方式是公有的
class Stu:public Person
{
public:
int score;
public:
Stu(){}
//子类的有参构造,在初始化列表中显性的调用父类的有参构造
Stu(string name,int age,int score):Person(name,age),score(score)
{cout << "Stu的有参构造" << endl;}
// void show()
// {
// //cout << name << endl;
// //cout << "Person的name" << Person::name << endl;
// //子类中不能访问父类继承下来的私有成员
// //cout << "Person中的name" << name << endl;
// //子类中可以访问从父类继承下来的受保护的成员
// //cout << "Person中的age" << age << endl;
// }
~Stu(){cout << "Stu的析构" << endl;}
//Person(Person &other)
Stu(Stu &other):Person(other) //对于Person的拷贝构造，传子类的对象，父类的引用可以引用子类的对象
{
this->score = other.score;
cout << "Stu的拷贝构造" << endl;
}
Stu &operator=(const Stu &other)
{
if(this!=&other)
{
//显性调用Person的拷贝赋值
Person::operator=(other);
cout << "Stu的拷贝赋值函数" << endl;
this->score = other.score;
}
return *this;
}
};
int main()
{
Stu s; //无参构造
s.show_();
Stu s1("zhangsan",20,100); //有参构造
cout << "s1" << "\t" ;
s1.show();
//拷贝构造
//Stu s2 = s1; //调用拷贝构造，需要开辟空间
s = s1;
cout << "s" << "\t" ;
s.show();
// cout << "s1的地址" << &s1 << endl; //a0
// s1.Person::show();
// Person *p = &s1;
// p->show(); //通过父类指针访问到的是父类中的show函数
// cout << "s1中首成员的地址" << &s1.score << endl;
return 0;
}
四、多重继承
一个子类由多个父类继承而来/一个派生类由多个基类派生出来
格式
class B:public A,private C
class 类名:继承权限1 类1,继承权限2 类2·····
{
//子类拓展的内容
};
如果多个基类(父类)中有同名成员，会发生歧义，通过类名加上域限定符访问指定的成员。
特殊的成员函数调用和使用的规律和普通继承时一致
多重继承时，构造函数的调用顺序，和继承的顺序有关，和初始化列表中的调用顺序无关。
#include <iostream>
using namespace std;
class Person
{
public:
string name;
int age;
Person(){cout << "p无参构造" << endl;}
Person(string name,int age):name(name),age(age)
{
cout << "P有参构造" << endl;
}
};
class Stu
{
public:
int age;
int score;
Stu(){cout << "Stu无参构造" << endl;}
Stu(int age,int score):age(age),score(score)
{cout << "Stu有参构造" << endl;}
};
//A类继承自Person类和Stu类
class A:public Person,public Stu
{
int high;
public:
A(){cout << "A无参构造" << endl;}
A(int h,string name,int age1,int age2,int score):Stu(age2,score),Person(name,age1),high(h)
{cout << "A有参构造" << endl;}
};
int main()
{
A a1; //Person的构造函数先被调用
cout << "a2****************************" << endl;
A a2(100,"zhangsan",78,90,23);
cout << a2.Stu::age << endl;
cout << a2.Person::age << endl;
return 0;
}
五、菱形继承(钻石继承)
公共基类的内容会在汇集子类中保留两份。
对于访问公共基类中成员时，会存在二义性的问题
如果多次继承大型的公共基类，会导致子类的内存过大。
【1】虚继承(virtual)
虚继承用于解决菱形继承存在的问题，通过菱形继承公共基类中的额内容只会在汇集子类中保存一份，不会造成子类的内存过大。
virtual关键字，只对关键字后面所跟的类起作用，表示虚继承virtual后面的类，两个中间基类都需要加virtual
如果使用虚继承，对于公共基类的构造函数，需要直接使用基类名来调用(因为不知道通过那一条中间路径继承的基类)
虽然，只保留了一份公共基类，但是仍然可以通过指定路径来访问基类中的成员
#include <iostream>
using namespace std;
class Person
{
public:
string name;
int age;
Person(){cout << "p无参构造" << endl;}
Person(string name,int age):name(name),age(age){}
};
//Stu虚继承Person
class Stu:virtual public Person
{
public:
int score;
Stu(){cout << "Stu无参构造" << endl;}
Stu(int score):score(score){}
};
//B虚继承Person
class B:virtual public Person
{
int bb;
public:
B(){}
B(int b):bb(b){}
};
class A:public B,public Stu
{
int high;
public:
A(){cout << "A无参构造" << endl;}
A(int h,int s,int b,int a,string name):high(h),Stu(s),B(b),Person(name,a)
{
}
};
int main()
{
//A a1; //Person的构造函数先被调用
A a1(100,78,9,18,"zhangsan");
cout << "a2****************************" << endl;
// cout << a1.B::age << endl; //指定访问从B路径继承下来的age
// cout << a1.Stu::age << endl; //指定访问从Stu路径继承下来的age
cout << a1.age << endl; //直接通过汇集子类来访问基类中的成员
return 0;
}
