C/C++备忘录（七）：类与对象

已于 2022-02-14 19:44:53 修改
阅读量615 收藏
点赞数
分类专栏： # C/C++基础备忘 文章标签： c++ c语言 开发语言
于 2022-02-14 19:44:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51487301/article/details/122897217
版权

C++面向对象的三大特性为：封装、继承、多态
C++认为万物皆为对象，对象皆有属性和行为

一、封装

1. 封装的意义
  1. 将属性和行为作为一个整体，表现生活中的事物
  2. 将属性和行为加以权限控制
class Circle{
public:
	int m_r;
	double cal_long(){			//计算周长
		return 2 * m_r * 3.14;
	}
};
int main(){
	Circle c;
	c.m_r = 10;
	cout << c.cal_long() << endl;
}
2. 访问权限
public公共权限类内可以访问 类外可以访问子类可访问父类
protected保护权限类内可以访问 类外不可以访问子类可访问父类
private私有权限类内可以访问 类外不可以访问子类不可访问父类
3. struct 和 class区别

struct默认公共权限
class默认私有权限

4. 利用访问权限管理读写功能
//先将成员属性都设置为私有权限
class Person {
private:
	string m_Name;	 //姓名 可写可读 
	int m_Age; 		//年龄 只读 
	string m_Score; //成绩 只写
public:
	//姓名可读可写
	void setName(string name){
		m_Name = name;
	}
	string getName(){
		return m_Name;
	}

	//年龄只读 
	int getAge() {
		return m_Age;
	}

	//成绩设置为只写
	void setScore(int score) {
		m_Score = score;
	}
};
int main() {
	Person p;
	//设置姓名 
	p.setName("Aimer");
	cout << "姓名： " << p.getName() << endl;

	//设置年龄 
	p.getAge();

	//设置成绩 
	p.setScore(95);
}

二、对象的初始化和清理

1 构造函数和析构函数
  • 构造函数： 创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
  • 析构函数： 对象销毁前系统自动调用，执行一些清理工作。

注意：

  1. 对象的初始化和清理工作是编译器的强制要求，如果不提供构造和析构，编译器会自行提供
  2. 编译器提供的构造函数和析构函数是空实现

构造函数语法：类名(){}

  1. 构造函数，没有返回值也不写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数，因此可发生重载
  4. 程序在调用对象时候会自动调用构造，无须手动调用，且只会调用一次

析构函数语法： ~类名(){}

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同，在名称前加上符号 ~
  3. 析构函数不能有参数，因此不能发生重载
  4. 程序在对象销毁前会自动调用析构，无须手动调用，且只会调用一次
  5. 析构在当前函数块的所有语句执行完后才调用
class Person
{
public:
	//构造函数
	Person(){
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person(){
		cout << "Person的析构函数调用" << endl;
	}

};
void test01(){
	Person p;
}
int main() {
	test01();
}
2. 构造函数的分类及调用

两种分类方式：

  • 按参数：有参构造和无参构造（又称默认构造函数）

  • 按类型：普通构造和拷贝构造

class Person {
public:
   //无参（默认）构造函数
   Person() {
   	cout << "无参构造函数!" << endl;
   }
   //有参构造函数
   Person(int a) {
   	age = a;
   	cout << "有参构造函数!" << endl;
   }
   //拷贝构造函数
   Person(const Person& p) {
   	age = p.age;
   	cout << "拷贝构造函数!" << endl;
   }
   //析构函数
   ~Person() {
   	cout << "析构函数!" << endl;
   }
public:
   int age;
};

三种调用方式：

  • ​括号法
    注：调用无参构造函数不能加括号，因为编译器认为这是一个函数声明
//调用无参构造函数
void test01() {
	Person p; 
}
//调用有参的构造函数
void test02() {
	Person p1(10);
	//注：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();
}
  • 显示法​
Person p1 = Person(10); 
Person p2 = Person(p1);
Person(10);		//单独写就是匿名对象 当前行结束之后，立即析构
  • 隐式转换法
Person p1 = 10; // Person p1 = Person(10); 
Person p2 = p1; // Person p2 = Person(p1); 
//注：不能利用 拷贝构造函数 来 初始化匿名对象，编译器会认为是对象声明
//Person p1(p2);
}
3. 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值（值传递会自动调用拷贝构造函数）
  • 以值方式返回局部对象

示例：

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20); 		//调用有参构造函数，创建一个p1对象
	Person p2(p1); 		//调用拷贝构造函数，创建一个p2对象
	Person p1 = p2; 	//拷贝构造 效果等同于Person p1 = Person(p2); 
	//Person p3;
	//p3 = p1; //不是调用拷贝构造函数，是赋值操作
}

//2. 值传递的方式给函数参数传值
void doWork(Person p1) {}	//相当于Person p1 = p;
void test() {
	Person p; 	//无参构造函数
    			//这里调用拷贝函数，创建一个新的p对象赋予dowork()函数
	doWork(p);
}

//3. 以值方式返回局部对象
Person doWork(){
	Person p1;					//同样是调用拷贝函数，传回的p1是新复制的一份，与当前dowork()中的p1不同
	cout << (int *)&p1 << endl;
	return p1;
}
void test(){
	Person p2 = doWork();
	cout << (int *)&p2 << endl;
}
4. 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则：

  • 如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不再提供其他构造函数

5. 深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

示例：

class Person {
public:
	//无参（默认）构造函数
	Person() {
	}
	//有参构造函数
	Person(int age ,int height) {
		m_age = age;
		m_height = new int(height);
	}
	//拷贝构造函数  
	Person(const Person& p) {
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);	//*p.m_height是解引用得到p.m_height指向的值再new
	}

	//析构函数
	~Person() {
		if (m_height != NULL){
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;	//用*是因为要把数据创建在堆区，new int得用int*去接收
};

void test()
{
	Person p1(18, 180);
	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

浅拷贝
在这里插入图片描述

深拷贝
在这里插入图片描述

6. 初始化列表

作用： C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）... {}

示例：

class Person {
public:
	//初始化列表方式初始化
	Person(int a, int b, int c):m_A(a), m_B(b), m_C(c) {}
private:
	int m_A;
	int m_B;
	int m_C;
};
int main() {
	Person p(1, 2, 3);
}
7. 类对象作为类成员
  • 当类中成员是其他类对象时，我们称该成员为 对象成员
  • 构造的顺序是 ：先调用对象成员的构造，再调用本类构造
  • 析构的顺序是：先本类后对象
class Phone{
public:
	Phone(string name){
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}
	~Phone(){
		cout << "Phone析构" << endl;
	}
	string m_PhoneName;
};

class Person{
public:
	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName){
		cout << "Person构造" << endl;
	}
	~Person(){
		cout << "Person析构" << endl;
	}
	void playGame(){
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}
	string m_Name;
	Phone m_Phone;	//对象成员
};

void test(){
	Person p("张三" , "苹果X");
	p.playGame();
}
int main() {
	test01();
}
8. 静态成员

静态成员： 在成员变量和成员函数前加上关键字static

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

示例1 ： 静态成员变量

class Person{
public:
	static int m_A; 	//静态成员变量
private:
	static int m_B; 	//静态成员变量也有访问权限
};

int Person::m_A = 10;	//一定要加int
int Person::m_B = 10;	//访问不到但可以赋值

void test()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;
	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

示例2： 静态成员函数

class Person{
public:
	static void func(){
		cout << "func调用" << endl;
		m_A = 100;
		//m_B = 100; //错误，不可以访问非静态成员变量
	}
	static int m_A; //静态成员变量
	int m_B; 
private:
	//静态成员函数也有访问权限
	static void func2(){
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;
void test(){
	//静态成员变量两种访问方式
	//1、通过对象
	Person p1;
	p1.func();
	//2、通过类名
	Person::func();
	//Person::func2(); //私有权限访问不到
}

三、C++对象模型和this指针

1. 成员变量和成员函数分开存储
  • 在C++中，类内的成员变量和成员函数分开存储
  • 只有非静态成员变量才属于类的对象上
  • c++中空对象也会占一字节空间，用于识别在内存中的位置
class Person {
public:
	Person() {
		mA = 0;
	}
	//非静态成员变量占对象空间
	int mA;
	
	//静态成员变量不占对象空间
	static int mB; 
	//函数不占对象空间，所有函数共享一个函数实例
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数不占对象空间
	static void sfunc() {
	}
};
int main() {
	cout << sizeof(Person) << endl;
}

四、友元

加上 friend 关键字可以访问私有权限

  • 全局函数：friend void xxx;
  • 类：friend class xxx;
  • 成员函数：friend void aaa::xxx; //aaa是作用域
1. 全局函数做友元
class Building{
	//告诉编译器 goodFriend全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodFriend(Building * building);
public:
	Building(){
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom; //卧室
};
void goodFriend(Building * building){
	cout << "好朋友正在访问： " << building->m_SittingRoom << endl;
	cout << "好朋友正在访问： " << building->m_BedRoom << endl;
}
void test(){
	Building b;
	goodFriend(&b);
}
2. 类做友元
class Building;		//声明不用打大括号
class goodFriend{
public:
	goodFriend();
	void visit();
private:
	Building *building;
};

class Building{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodFriend;
public:
	Building();
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};
Building::Building(){				//类外的构造函数
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodFriend::goodFriend(){
	building = new Building;	//goodFriend中的building(指针类型)指向堆区中的一个新的内存空间
}
void goodFriend::visit(){
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友正在访问" << building->m_BedRoom << endl;
}
void test(){
	goodFriend g;
	g.visit();
}
3. 成员函数做友元
class Building;
class goodFriend{
public:
	goodFriend();
	void visit1(); 	//只让visit函数作为Building的好朋友，可访问Building中私有内容
	void visit2(); 
private:
	Building *building;
};
class Building
{
	//告诉编译器  goodFriend类中的visit成员函数 是Building好朋友，可以访问私有内容
	friend void goodFriend::visit();

public:
	Building();
public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

Building::Building(){
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodFriend(){
	building = new Building;
}
void goodFriend::visit1(){
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友正在访问" << building->m_BedRoom << endl;
}
void goodFriend::visit2(){
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	//cout << "好朋友正在访问" << building->m_BedRoom << endl;
}
void test(){
	goodFriend  g;
	g.visit();
}
2. this指针概念
  • this指针指向被调用的成员函数所属的对象
  • this指针是隐含每一个非静态成员函数内的一种指针
  • this指针不需要定义，直接使用即可

this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可使用return *this
class Person{
public:
	Person(int age){
		//1、当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}
	Person& PersonAddPerson(Person p){
		this->age += p.age;
		//返回对象本身
		return *this;	//this解引用就是返回Person对象本身，注意要用& 引用接收
						//如果不用引用接收，就会一直复制一份新的Person对象，最后只会实现一次+=p.age的效果
	}
	int age;
};
void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);	//连续调用
	cout << "p2.age = " << p2.age << endl;
}
3. 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针，如果用到this指针，需要加以判断保证代码的健壮性

示例：

//空指针访问成员函数
class Person {
public:
	void ShowClassName() {
		cout << "我是Person类!" << endl;
	}
	void ShowPerson() {
		if (this == NULL) {		//加以判断是否为空，保证代码的健壮性
			return;
		}
		cout << mAge << endl;
	}
public:
	int mAge;
};
void test(){
	Person * p = NULL;
	p->ShowClassName(); //空指针，可以调用成员函数
	p->ShowPerson();  	//但如果成员函数中用到了this指针，就不可以调用成员函数
}
4. const修饰成员函数

常函数：

  • 成员函数后加const后我们称为这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数

示例：

//const Person person 常对象
//void func() const   常函数
class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}
	//this指针的本质是一个指针常量，指针的指向不可修改，故 this = NULL 是错误语法
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void func01() const {	//即const Type* const pointer;
		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}
	void func02() {
		this->mA = 10000;
	}
public:
	int m_A;
	mutable int m_B; //可修改
};
//const修饰对象  常对象
void test() {
	const Person person; 		//常量对象  
	
	//person.mA = 100; 	常对象不能修改成员变量的值，但可访问
	cout << person.m_A << endl;
	
	person.m_B = 100; 	//常对象可以修改mutable修饰成员变量

	//常对象访问成员函数
	person.func01(); 	
	//person.func02(); 常对象不能访问非常函数	
}

五、运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

1. 加号运算符重载

作用： 实现两个自定义数据类型相加的运算

  1. 成员函数实现
//成员函数实现 + 号运算符重载
class Person {
public:
	Person(){};
	Person(int a, int b) : m_A(a), m_B(b){};
	Person operator+(const Person& p) {		//
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}
	int m_A;
	int m_B;
};
  1. 全局函数实现
//全局函数实现 + 号运算符重载
Person operator+(const Person& p1, const Person& p2) {
   Person temp(0, 0);
   temp.m_A = p1.m_A + p2.m_A;
   temp.m_B = p1.m_B + p2.m_B;
   return temp;
}
  1. 运算符重载，可发生函数重载
//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}
  1. 调用
void test() {
	Person p1(10, 10);
	Person p2(20, 20);
	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	Person p4 = p3 + 10;  //相当于 operator+(p3,10)
}

注：对于内置的数据类型的表达式的运算符不可能改变（1+1不可能等于3）

2. 左移运算符重载

作用： 可以输出自定义数据类型

class Person {
	friend ostream& operator<<(ostream& out, Person& p);	//因为数据私有化所以要加友元
public:
	Person (){}
	Person(int a, int b):m_A(a),m_B(b){}

	//成员函数 实现不了  p << cout    
	//void operator<<(cout){}	    实现的是p << cout
	//void operator<<(Person& p){}	实现的是p<<p
private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个（标准输出流对象）
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;		//返回cout对象才能继续调用 <<
}
void test() {
	Person p1(10, 20);
	cout << p1 << "hello world" << endl; //链式编程
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

3. 递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

由于前置后置本身的特性，前置可在一行语句中连续递增并输出结构，但后置连续递增不可在递增的同时返回递增的结果。故前置返回引用，后置返回值。

class MyInteger {
	friend ostream& operator<<(ostream& out, MyInteger myint);
public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++() {		//写引用是为了一直对一个数进行++，实现++（++myint）
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++
	MyInteger operator++(int) {		//int表占位参数，可用于区分前置后置递增
		//先（记录结果）返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;			//temp是局部对象，不能返回引用
	}
private:
	int m_Num;
};

ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}

//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02() {
	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

总结： 前置递增返回引用，后置递增返回值

4. 赋值运算符重载

c++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

示例：

class Person
{
public:

	Person(int age){
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p){
		if (m_Age != NULL){			//清除当前m_Age
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}

	~Person()
	{
		if (m_Age != NULL){
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;
};

void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //赋值操作

	cout << "p1的年龄为：" << *p1.m_Age << endl;

	cout << "p2的年龄为：" << *p2.m_Age << endl;

	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;
}
5. 关系运算符重载

作用： 重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

class Person
{
public:
	Person(string name, int age){
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person & p){
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age){
			return true;
		}
		else{
			return false;
		}
	}

	bool operator!=(Person & p){
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age){
			return false;
		}
		else{
			return true;
		}
	}

	string m_Name;
	int m_Age;
};

void test(){
	Person a("孙悟空", 18);
	Person b("孙悟空", 18);

	if (a == b){
		cout << "a和b相等" << endl;
	}
	else{
		cout << "a和b不相等" << endl;
	}
	if (a != b){
		cout << "a和b不相等" << endl;
	}
	else{
		cout << "a和b相等" << endl;
	}
}
6. 函数调用运算符重载
  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活

示例：

class MyPrint{
public:
	void operator()(string text){
		cout << text << endl;
	}

};
void test01(){
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}

class MyAdd{
public:
	int operator()(int v1, int v2){
		return v1 + v2;
	}
};

void test02(){
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

六、继承

继承是面向对象三大特性之一

1. 继承的基本语法
  • 继承的好处： 可以减少重复的代码
    -class A : public B;
  • A 类称为子类 或 派生类
  • B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

//公共页面
class BasePage{
public:
	void header(){
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
};

//Java页面
class Java : public BasePage{
public:
	void content(){
		cout << "JAVA学科视频" << endl;
	}
};
void test(){
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();		//继承而来的函数
	ja.content();		//子类自身的函数
}
2. 继承方式

继承的语法：class 子类 : 继承方式 父类

继承方式一共有三种：

继承方式权限
公共继承权限不变
保护继承除父类私有权限属性，其他属性均变为子类的保护属性
私有继承除父类私有权限属性，其他属性均变为子类的私有属性

无论以何种方式继承，子类均访问不到父类的私有权限的属性

3. 继承中的对象模型

父类的私有成员只是被隐藏了，但子类仍会继承下去

示例：

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; 		//私有成员只是被隐藏了，但仍会继承下去
};

//公共继承
class Son :public Base
{
public:
	int m_D;
};

void test01(){
	cout << "sizeof Son = " << sizeof(Son) << endl;
}
4. 继承中构造和析构顺序
  • 子类继承父类后，当创建子类对象，也会调用父类的构造函数
  • 继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

示例：

class Base {
public:
	Base(){
		cout << "Base构造函数!" << endl;
	}
	~Base(){
		cout << "Base析构函数!" << endl;
	}
};
class Son : public Base{
public:
	Son(){
		cout << "Son构造函数!" << endl;
	}
	~Son(){
		cout << "Son析构函数!" << endl;
	}

};
void test(){
	//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
	Son s;
}
5. 继承同名成员处理方式
  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
s.func();
s.Base::func();
s.Base::func(10);

示例：

class Base {
public:
	Base(){
		m_A = 100;
	}

	void func(){
		cout << "Base - func()调用" << endl;
	}

	void func(int a){
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};
class Son : public Base {
public:
	Son(){
		m_A = 200;
	}

	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func(){
		cout << "Son - func()调用" << endl;
	}
public:
	int m_A;
};
void test(){
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;

	s.func();
	s.Base::func();
	s.Base::func(10);

}
6. 继承同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

示例：

class Base {
public:
	static void func(){
		cout << "Base - static void func()" << endl;
	}
	static void func(int a){
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func(){
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01(){
	//通过对象访问
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02(){
	//通过对象访问
	Son s;
	s.func();
	s.Base::func();

	//通过类名访问
	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}
7. 多继承语法

C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

示例：

class Base1 {
public:
	Base1(){
		m_A = 100;
	}
public:
	int m_A;
};

class Base2 {
public:
	Base2(){
		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
public:
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
	Son(){
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};

//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test(){
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

8. 菱形继承

菱形继承概念：

​ 两个派生类继承同一个基类

​ 又有某个类同时继承自两个派生类

​ 这种继承被称为菱形继承，或者钻石继承

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当羊驼使用数据时，就会产生二义性。

  2. 羊驼继承自动物的数据继承了两份，导致资源浪费以及毫无意义
    利用虚继承 virtual 可以解决这些问题

示例：

class Animal{
public:
	int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test(){
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
	//三份m_Age实际上都指向同一份数据
}

七、多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

  • 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别

  1. 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  2. 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

多态满足条件

  1. 有继承关系

  2. 子类重写父类中的虚函数

多态使用： 父类指针或引用指向子类对象

重写： 函数返回值类型，函数名 和 参数列表 完全一致称为重写

示例：

class Animal{
public:
	//如果函数地址在编译阶段就能确定，那么静态联编
	//如果函数地址在运行阶段才能确定，就是动态联编
	//函数前面加上virtual关键字，变成虚函数，令编译器在编译时不能确定函数地址
	virtual void speak(){
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal{
public:
	void speak(){
		cout << "小猫在说话" << endl;
	}
};
void DoSpeak(Animal & animal){
	animal.speak();
}
//
void test(){
	Cat cat;
	DoSpeak(cat);
}
2. 多态案例一-计算器类

案例描述：

分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护

示例：

//多态实现
//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator
{
public :

	virtual int getResult(){
		return 0;
	}
	int m_Num1;
	int m_Num2;
};

//加法计算器
class AddCalculator :public AbstractCalculator
{
public:
	int getResult(){
		return m_Num1 + m_Num2;
	}
};

//减法计算器
class SubCalculator :public AbstractCalculator
{
public:
	int getResult(){
		return m_Num1 - m_Num2;
	}
};

//乘法计算器
class MulCalculator :public AbstractCalculator
{
public:
	int getResult(){
		return m_Num1 * m_Num2;
	}
};


void test()
{
	//创建加法计算器
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  //用完了记得销毁

	//创建减法计算器
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  

	//创建乘法计算器
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}

总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

3. 纯虚函数和抽象类

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数

当类中有了纯虚函数，这个类也称为 抽象类

抽象类特点：

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

class Base
{
public:
	//纯虚函数
	//类中只要有一个纯虚函数就称为抽象类
	//抽象类无法实例化对象
	//子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;	//virtual xxx() = 0就是纯虚函数
};

class Son :public Base
{
public:
	virtual void func() {
		cout << "func调用" << endl;
	};
};
void test(){
	Base * base = NULL;
	//base = new Base; // 错误，抽象类无法实例化对象
	base = new Son;
	base->func();
	delete base;//记得销毁
}

函数调用

void doWork(Calculate* cal){	//相当于Calculate* cal = new addCal;
	cal->calcul();
}
void test(){
	doWork(new addCal);
}
5. 虚析构和纯虚析构

  1. 多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码，造成子类数据释放不干净，内存泄漏

  2. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

  3. ​如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

  4. ​拥有纯虚析构函数的类也属于抽象类

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

示例：

class Animal {
public:
	Animal(){
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	//析构函数加上virtual关键字，变成虚析构函数
	//virtual ~Animal()
	//{
	//	cout << "Animal虚析构函数调用！" << endl;
	//}


	virtual ~Animal() = 0;
};

Animal::~Animal()	//纯虚析构类外实现。一定要实现是因为该类也有可能要清楚的堆区数据
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;
};

void test()
{
	Animal *animal = new Cat("Tom");
	animal->Speak();
	delete animal;
}
做一只猫
关注
专栏目录
实验二：Java面向对象编程练习
weixin_59117711的博客
04-27 1639
实验目的： 1．理解 Java 语言是如何体现面向对象编程基本思想； 2．掌握Java编程技巧，提高解决问题的能力。 实验内容： 实验1：输出圆的信息 设计一个圆类(Circle)，将圆的位置(圆心坐标和半径)作为属性（提供任意圆的设置），并能计算圆的面积。 Circle类必须满足以下要求: (1) 圆类Circle 的属性有： point_x : int型，代表圆心横坐标。 point_y : int型， 代表圆心纵坐标。 radius: double型, 代表...
C#通过PInvoke调用c++函数的备忘录的实例详解
01-01
目前知道的情况被调用的C/C++函数只能是全局函数 不能调用类中的成员方法 被调用的C函数必须使用extern “C“包含，保证采用的导出函数名生成规则和.NET一致 函数调用约定通常使用WINAPI也就是__stdcall，.net默认也...
Java面向对象编程
九二六四的博客
06-17 487
如果说C语言程序设计很有意思的话，那该怎么去形容Java才最贴切呢。从现在起，开始深入研究Java面向对象编程——OOP（终于开始学Java了）。 最基本——创建一个类（class） 一个class类中需要描述出类的属性和方法，比如说现在有一个问题的对象是一只猫，我们需要把它的种类、名字、体重描述出来，同时它可以吃饭、睡觉、玩耍。这时候，我们就需要创建一个Cat类。这里只是简单描述，所以把属性和方...
编程学习码kdkak
qq_38512857的博客
09-12 227
/** *将dom转化为文本 */ functionnodeToString(node){ //createElement()返回一个Element对象 vartmpNode=document.createElement("div"); //appendChild()参数Node对象返回Node对象Element方法 //cloneNode()参数布尔类型返回Node对象Element方法 tmpNode.appendChild(node...
面向对象
jinmengyao的博客
03-16 137
一、面向对象与面向过程 （一）面向对象是相对面向过程而言的，面向对象和面向过程都是一种思想，面向对象是基于面向过程的。 （二）面向过程：强调的是功能行为 面向对象：将功能封装进对象，强调具备了功能的对象。 （三） 举例：操作冰箱 面向过程：定义打开冰箱、存储进冰箱、关闭冰箱这三个动作，操作每一个冰箱都要进行这三个动作（强调操作冰箱的过程，我是操作者的角色） 面向对象：创建一个冰箱，把打开冰箱、存储...
Java | 小练手：Cat类
黄佳俊的博客
09-24 2063
一、任务要求 1. 该类必须包含String属性来存宠物的名字。 2. 定义一个构造器，它使用String参数指定猫的名字；该构造器必须调用超类构造器来指明所有的猫都是四条腿。 3. 另定义一个无参的构造器。该构造器调用前一个构造器（用this关键字）并传递一个空字符串作为参数 4. 实现Pet接口方法。 5. 实现eat方法。 二、代码示例 public class Cat extends Animal implements Pet{ protected String name; public
C/C++设计模式详解：面向对象与模式实践
这些模式关注于如何将类和对象组合成更大的结构，使得它们能够协同工作，同时也解决了类与类之间的兼容性问题。 3. 行为型模式：如模板模式、观察者模式、迭代器模式、责任链模式、命令模式、策略模式、访问者模式...
C/C++设计模式实战：面向对象与模式解析
19. **备忘录模式** - 在不破坏封装的前提下，捕获一个对象的内部状态并在该对象之外保存这个状态，以便以后恢复。 20. **解析器模式** - 定义一个语法表达式的解析规则。 **C++语言设计模式** C++作为一门支持面向...
23种设计模式(C++)_设计模式c++_c/C++_frogvwe_C++设计模式_
09-30
- 备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后恢复对象的状态。 - 观察者模式：定义对象之间的一对多依赖关系，当一个对象的状态改变时，所有依赖于它的...
Java基础语法（八）——面向对象
rain67的博客
04-07 1609
千呼万唤始出来，Java的这篇面向对象介绍终于出炉…
设计模式之备忘录模式
我的博客
01-14 346
模式定义 ​ 所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。 ​ 备忘录模式将要保存的细节给封装在备忘录中，就是那天要改变保存的细节也不会影响到客户端。 模式结构 ​ 下图是备忘录模式的UML结构图： ​ 备忘录模式主要包含入下几个角色： ​ Originator: 原发器。负责创建一个备忘录...
面向对象基础8
dfgh11123的专栏
09-17 518
按要求编写Java应用程序。 （1）建立一个名叫Cat的类： 属性：姓名、毛色、年龄 行为：显示姓名、喊叫 （2）编写主类： 创建一个对象猫，姓名为“妮妮”，毛色为“灰色”，年龄为2岁，在屏幕上输 出该对象的毛色和年龄，让该对象调用显示姓名和喊叫两个方法。 转载于:https://www.cnblogs.com/Levi1995/p/5879257.html...
设计一个学生类 Student 包含姓名、成绩两个属性。定义一个无参的构造方法和一个接收两个参数的构造方法。
热门推荐
烟敛寒林的博客
12-08 6万+
请按照以下要求设计一个学生类 Student，并进行测试。 要求如下： Student 类中包含姓名、成绩两个属性 分别给这两个属性定义两个方法，一个方法用于设置值，另一个方法用于获取值. Student 类中定义一个无参的构造方法和一个接收两个参数的构造方法，两个参数分别为姓名和 成绩属性赋值 在测试类中创建两个 Student 对象，一个使用无参的构造方法，然后调用方法给姓名和...
java 程序设计题库
cat marshal的博客
06-18 3万+
答题要求：单选题，每题只有一个正确答案，选择正确给分，不正确不给分。 1、 下面（ A ）数据类型可用于main()方法中传递的参数 A、String B、Integer C、Boolean D、Variant 2、以下的选项中能正确表示Java语言中的一个整型常量的是（ B ） A、12． B、-20 C、1,000 D、4 5 6 3、下列的变量定义...
Java 设计一个Dog类，有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出Dog信息。编写应用程序使用Dog类。
weixin_42895133的博客
08-19 3万+
“` class Dog{ private String name,color; private int age; public Dog(String name,String color,int age){ this.name=name; this.color=color; this.age=age; ...
面试题笔试-带答案-1
dan_dan的博客
01-18 4万+
一. 选择题（234） 1.下面中哪两个可以在 A 的子类中使用：（ ） class A { protected int method1 (int a, int b) { return 0; } } A. public int method 1 (int a, int b) { return 0; } B. private int method1 (int a, int b) { return 0; } C. private int method1 (int a, long b) { return 0; }
C++学习系列（二）—— 核心编程（面向对象）
BISyus的博客
11-13 371
本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 代码仓库：https://github.com/Kerry-yu/Cpp_Learn 1. 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期.
【C++】类和对象-对象特性
debug...
07-04 917
C++类对象特性
按要求编写Java应用程序。 （1）建立一个名叫Cat的类： 属性：姓名、毛色、年龄 行为：显示姓名、喊叫 （2）编写主类： 创建一个对象猫，姓名为“妮妮”，毛色为“灰色”，年龄为2岁，在屏幕上输 出...
weixin_30664051的博客
09-17 4076
package com.homework.zw;//类Cat部分public class Cat { String name="妮妮"; String skin="灰色"; int age =2; void outputname() { System.out.println("这只猫咪的名字叫："+name); } void outputha...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值