【c++】运算符重载，继承

最新推荐文章于 2023-12-12 18:54:59 发布
最新推荐文章于 2023-12-12 18:54:59 发布
阅读量518 收藏 1
点赞数 2
分类专栏： 面向对象 C++ 文章标签： c++ python java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52765554/article/details/120695574
版权

写在开头
参考《黑马c++核心编程》

4.5 运算符重载

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

4.5.1 加号运算符重载

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	int m_A;
	int m_B;
public:
	Person() {};//无参默认构造
	Person(int a, int b)//有参构造
	{
		this->m_A = a;
		this->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;
	}
};
//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;
//}
Person operator+(const Person& p, const int val)
{
	Person temp;
	temp.m_A = p.m_A + val;
	temp.m_B = p.m_B + val;
	return temp;
}
void test()
{
	Person p1(10, 10);
	Person p2(20, 20);
	Person p3 = p1 + p2;//相当于p2.operator+(p1);
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
	Person p4 = p3 + 10;
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}
int main()
{
	test();
	return 0;
}

总结1：对于内置的数据类型表达式的运算符是不可能改变的

总结2：不要滥用运算符重载

4.5.2 左移运算符重载

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& cout, Person& p);
private:
	int m_A;
	int m_B;
public:
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现不了p<<cout我们想要的效果	
	//void operator << (Person& p) {}
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& cout, Person& p)
{
	cout << "a:" << p.m_A << "b:" << p.m_B;//无法直接访问，需要写友元函数

	return cout;
}
void test()
{
	Person p1(10,20);
	cout << p1 << "helloworld" << endl;
}
int main()
{
	test();
	return 0;
}

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

4.5.3 递增运算符重载

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

#include <bits/stdc++.h>
using namespace std;
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
private:
	int m_Num;
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++()//返回引用的目的是链式操作的影响
	{
		//先++
		m_Num++;
		//再返回
		return *this;//类的非静态成员函数返回对象本身用return *this
	}
	//后置++
	MyInteger operator++(int)
	{
		//先返回
		MyInteger temp = *this;//记录当前本身的值，然后让本身的值++，但是返回的是以前的
		m_Num++;
		return temp;
	}
};
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num << endl;
	return cout;
}
void test01()
{
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}
void test02()
{
	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}

总结：迁至递增返回引用，后置递增返回

4.5.4 赋值运算符重载

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

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

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	int* m_Age;//年龄指针
	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}
	Person& operator=(Person& p)
	{
		if (m_Age != NULL)//先初始化
		{
			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;
		}
	}
};
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();
	return 0;
}
4.4.5 关系运算符重载

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

#include <bits/stdc++.h>
using namespace std;
class Person
{
public:
	string m_Name;
	int m_Age;
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;
		return false;
	}
	bool operator!=(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
			return false;
		return true;
	}
};
void test01()
{
	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;
}
int main()
{
	test01();
	return 0;
}
4.5.6 函数调用运算符重载
  1. 函数调用运算符()也可以重载
  2. 由于重载后使用的方式非常想函数的调用，因此成为仿函数
  3. 仿函数没有固定的写法，非常灵活
#include <bits/stdc++.h>
using namespace std;
class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
};
void test01()
{
	//重载的()操作符 也成为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}
int main()
{
	test01();
	return 0;
}

4.6 继承

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

在定义一些类时，下级别的成员除了拥有上一级的共性，还有自己的特性，这个时候我们就可以考虑利用继承的技术，减少重复代码。

4.6.1 继承的基本语法

示例

#include <bits/stdc++.h>
using namespace std;
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java, Python, cpp...(公共分类列表)" << endl;
	}
};
//java页面
class Java :public BasePage
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};
void test01()
{
	cout << "Java下载视频页面如下:" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
}
int main()
{
	test01();
	return 0;
}

总结

继承的好处：可以减少重复的代码

class A:class B;

A类称为子类 或 派生类

B类称为父类 或 基类

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

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

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

4.6.2 继承方式

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

继承方式一共有三种

  1. 公共继承
  2. 保护继承
  3. 私有继承
#include <bits/stdc++.h>
using namespace std;
class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A;//可访问public权限
		m_B;//可访问protected权限
		//m_C;//私有权限不可访问
	}
};
void myClass()
{
	Son1 s1;
	s1.m_A;//其他类只能访问公共权限
	//s1.m_B;不可访问
	//s1.m_C;//不可访问
}
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A;//可访问protected权限
		m_B;//可访问protected权限
		//m_C;//私有权限不可访问
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A//不可访问,保护全新啊
}
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A;//可访问private权限
		m_B;//可访问private权限
		//m_C;//不可访问
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是似有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};
int main()
{
	myClass();
	myClass2();
}
4.6.3 继承中的对象模型

问题：从父类继承过来的成员，那些属于子类对象中？

示例：

#include <bits/stdc++.h>
using namespace std;
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;
}
int main()
{
	test01();
	return 0;
}
4.6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序谁先谁后？

示例：

#include <bits/stdc++.h>
using namespace std;
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 test01()
{
	//继承中 先调用父类的构造函数，再调哟个子类的构造函数，析构顺序与构造相反
	Son s;
}
int main()
{
	test01();
	return 0;
}

总结：继承中 先调用父类的构造函数，再调用子类的构造函数，析构顺序与构造相反

4.6.5 继承同类成员处理方式

问题：当子类与父类出现同名成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

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

示例

#include <bits/stdc++.h>
using namespace std;
class Base
{
public:
	int m_A;
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func()调用" << endl;
	}
	void func(int a)
	{
		cout << "Base - func(int a)调用" << endl;
	}
};
class Son :public Base
{
public:
	int  m_A;
	Son()
	{
		m_A = 200;
	}
	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son - func()的调用" << endl;
	}
};
void test01()
{
	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);
}
int main()
{
	test01();
	return 0;
}

总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
4.6.6 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

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

  1. 访问子类同名成员 直接访问即可
  2. 访问父类同名成员 需要加作用域
#include <bits/stdc++.h>
using namespace std;
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()
{
	//通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	cout << "Son 下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
	//通过类名访问
	cout << "通过类名访问" << endl;
	cout << "Son 下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
void test02()
{
	//通过对象访问
	cout << "通过对象访问：：" << endl;
	Son s;
	s.func();
	s.Base::func();
	cout << "通过类名访问:" << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员，需要加作用域访问
	Son::Base::func(100);
}
int main()
{
	test01();
	test02();
}
4.6.7 多继承语法

cpp允许一个类继承多个类

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

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

cpp实际开发中不建议使用多态

示例

#include <bits/stdc++.h>
using namespace std;
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}
	int m_A;
};
class Son :public Base2, public Base1
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}
int main()
{
	test01();
	return 0;
}
4.6.8 菱形继承

菱形继承概念:

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

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

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

典型的菱形继承案例

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
  2. 草泥马继承自动物的数据继承了两份，实则只需要一份就好

示例

#include <bits/stdc++.h>
using namespace std;
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 test01()
{
	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;
}//类似于数据共享

int main() 
{
	test01();

	system("pause");

	return 0;
}
leimingzeOuO
关注
专栏目录
C++运算符重载和继承
01-17
在C++编程中，运算符重载和继承是两个核心概念，它们极大地扩展了语言的能力，使得代码更加灵活且易于理解。本章我们将深入探讨这两个主题，并通过实际代码示例来阐述它们的工作原理。 首先，让我们关注“运算符...
C++运算符重载及组合与继承
m0_59949484的博客
08-14 153
C++准许以运算符命名函数！！！运算符重载是指在编程语言中，通过定义类的成员函数或全局函数来改变原有运算符的行为。通过运算符重载，可以使得用户自定义的类对象能够像基本类型一样进行运算操作。运算符重载的概念包括以下几个方面：对于类对象，可以通过成员函数或全局函数重载运算符。例如，可以定义一个类的成员函数来重载"+"运算符，使得两个对象相加时能够按照自定义的方式进行运算。运算符重载可以改变运算符的操作数数量。例如，可以定义一个全局函数来重载"-"运算符，使得它可以接受一个参数或两个参数进行运算。
6、运算符重载、继承(C++核心语法)
伍粟的博客
04-14 421
1 关系运算符重载 1.1 对于自定义数据类型，编译器不知道如果进行比较 1.2 重载 == ！=号 1.3 bool operator==( Person & p) 1.4 bool operator!=(Person & p) #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; class Person { public: Person(string name, int a
C++:运算符重载及继承
最新发布
lmf1751014911的博客
12-12 899
前面学到了函数的重载，现在又新出现一个叫运算符重载的东西，还有C++三大特性之一的继承又是如何实现，起什么作用的呢？本文介绍了运算符重载的相关概念及代码呈现，如有不足，还望指出。
DAY5, C++（重载运算符问题，类的继承问题）
weixin_46260677的博客
07-20 336
C++（重载运算符问题，类的继承问题） 完善my_string类，将能够重载的运算符，全部进行重载; 将继承过程中特殊成员函数相关代码;
C++ 学习日记-算符重载、继承
KLh
07-11 392
一、大于运算符重载 #include <iostream> using namespace std; class Student { public: Student(string n, int i, float s) { this->id = i; this->name = n; this->scored = s; } bool operator>(Student &s)
opreator-override.zip_override+c++_运算符重载
09-24
"opreator-override.zip_override+c++_运算符重载"这个压缩包文件，显然包含了关于C++运算符重载的详细信息，特别是如何通过`override`关键字来更精确地控制重载。 首先，运算符重载并不是创建新的运算符，而是给已...
继承与派生 运算符重载
05-15
继承与派生运算符重载 继承是面向对象编程（Object-Oriented Programming）中的一种机制，它允许一个类继承另一个类的成员变量和成员函数。继承的主要目的是实现代码的重用和提高编程效率。在C++中，继承是通过...
C++运算符重载教学和编程中易被忽视的问题
10-27
### C++运算符重载教学和编程中易被忽视的问题 #### 1. 二元运算符重载为类成员函数时易忽视的问题及解决方法 以复数类为例，在实现复数相加的过程中，很容易忽略一个重要的设计原则：**当一个二元运算符（如加法...
运算符重载与多态练习（面向对象程序设计C++）
07-01
【运算符重载】在C++中，运算符...总结起来，这个实验旨在让学生掌握C++中的运算符重载、虚函数和多态、继承与派生等面向对象编程概念，并通过实际操作加深理解。同时，还涉及到了链表数据结构的创建和对象的动态管理。
运算符重载及组合与继承
qq_52479948的博客
01-17 791
运算符重载及组合与继承
c++(继承)
weixin_67993841的博客
04-21 1286
c++继承的问题
C++ 重载运算符 继承 多态 （超详细）
日拱一卒,功不唐捐
06-22 4312
（一）重载运算符： （1）声明与定义格式 一般是类内声明，类外定义，虽然可以在类内定义，但 写前面堆一堆不好看！！！ 类内声明： class Demo { 返回值类型 operator 运算符（形参表）； } 类外定义： 返回类型 Demo（类名）：：operator运算符（形参表） { 函数体 } (2）双目运算符重载为成员函数 当重载运算符为双目运算符时，形参表中只有一个参数...
公有继承，私有继承，保护继承的区别
dwj6336736的博客
08-29 650
一个子类继承父类时，可按照public、private和protected方式继承父类，每种继承方式的区别如下：1) public继承方式基类中所有public成员在派生类中为public属性； 基类中所有protected成员在派生类中为protected属性； 基类中所有private成员在派生类中不可访问。2) protected继承方式基类中的所有public成员在派生类中为protec
C++运算符、继承
zillll的博客
04-19 336
一、C++运算符重载“==” ①不允许用户自定义新的运算符，只能对已有的运算符进行重载 ②重载运算符不能改变运算符操作数的个数 ③不能改变运算符的优先级 ④不能改变运算符的结合性 ⑤不能有默认的参数 #include<iostream> using namespace std; class CStudent { private: string pname; int page; public: CStudent(string name,int age)
继承中的运算符重载：输入输出的传奇
weixin_47354208的博客
12-05 413
他人实验题目 子类继承父类，运算符的重载能继承吗？ **通过实验，结论：**不能继承也不需要继承。 方法分别在子类和父类中声明友函数，在类外分别定义运算符重载。 例 class Point { friend istream&operator >>(istream&in,Point &point_a); friend ostream&operator<<(ostream &out,Point &point_a); }; is
重载关系运算符 继承包括一部分！
lth158的博客
07-23 193
C++是面向对象的语言，只能在全局函数，或者是类里面写执行代码，这些函数和类里面，都属于非全局；·2）继承的私有属性是外部不能访问的，但是继承的成员函数可能要用到，所以私有属性一定要继承。定义classA（子类）继承方式B（父类）类与类之间的特别的关系，把代码中重复表达的函数信息用公共的方式进行表达。函数外只能定义全局变量或者对象，而不能执行语句及调用函数！·由于重载后使用的方式非常像函数的调用，称为仿函数。·1）//利用开发人员命令提示工具查看对象模型。......
C++ 运算符重载（课堂笔记）
weixin_60895836的博客
06-08 793
在一学期的吹水过后，开始复习吧
C++运算符重载与转换函数的继承
"转换函数可以被继承-C++ 运算符重载" 在C++编程中，运算符重载是一项重要的特性，它允许我们为自定义类型赋予与内置类型相似的行为。当我们定义了一个类，有时需要让这个类的对象能够像内置类型一样进行运算，比如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leimingzeOuO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值