C/C++教程
C++ 学习日记-算符重载、继承
本文主要是介绍C++ 学习日记-算符重载、继承，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
一、大于运算符重载
#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)
{
if (this->scored > s.scored)
{
return true;
}
else
{
return false;
}
}
private:
string name;
int id;
float scored;
};
int main()
{
Student s1("bb", 10, 99);
Student s2("cb", 0, 59);
if (s1 > s2)
{
cout << "bb六" << endl;
}
else
{
cout << "cb六" << endl;
}
return 0;
}
二、关系运算符重载
#include <iostream>
using namespace std;
class Person
{
public:
Person(string name, int age)
{
this->m_name = name;
this->m_age = age;
}
int m_age;
string m_name;
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;
}
}
};
int main()
{
Person p1("qq", 18);
Person p2("qq", 18);
if (p1 == p2)
{
cout << "p1=p2" << endl;
}
else
{
cout << "p1!=p2" << endl;
}
if (p1 != p2)
{
cout << "p1!=p2" << endl;
}
else
{
cout << "p1=p2" << endl;
}
return 0;
}
三、赋值运算符重载
C++会至少给一个类添加4个函数：
1默认构造函数、
2.默认析构函数、
3.默认拷贝构造函数（对属性进行一个值拷，浅拷贝）
4.赋值运算符重载函数operator(对属性进行值拷贝、浅拷贝)，
#include <iostream>
using namespace std;
class Person{
public:
Person(int age)
{
m_Age = new int(age);
}
~Person()
{
if(m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//由于系统提供=重载函数是有问题的，所以我们自己再重载一次。
Person& operator=(Person &p)
{
//m_Age = p.m_Age; //编译器默认做的就是这句话。(浅拷贝)
if(m_Age != NULL) //自己提供深拷贝。
{
delete m_Age;
m_Age = NULL;
}
m_Age = new int(*p.m_Age);
return *this;
}
int *m_Age;
};
int main()
{
/*
Person p1("张三",18);
cout << "p1的姓名:" << p1.m_Name << " 年龄:" << p1.m_Age << endl;
Person p2 = p1;
cout << "p2的姓名:" << p2.m_Name << " 年龄:" << p2.m_Age << endl;
*/
Person p3(18);
Person p4(20); //有参构造函数 //Person p4 = p3; //拷贝构造函数(默认就是浅拷贝)，我不调用重载函数
Person p5(30);
p5 = p4 = p3; //如果有连等的操作，以引用的方式来将对象返回。
cout << "p3的年龄:" << *p3.m_Age << endl;
cout << "p4的年龄:" << *p4.m_Age << endl;
cout << "p5的年龄:" << *p5.m_Age << endl;
return 0;
}
结论：
1.只要有属性开辟到堆区，那么使用对象给另一个对象赋值时，必须自己重新写operate这个重载函数来投共深拷贝
四、函数调用运算符重载
1.函数运算符（）也是可以重载的
2、由于重载以后使用方法非常像函数的调用，因此称为仿函数
3.仿函数没有固定的写法，非常的灵活
#include <iostream>
using namespace std;
//函数调用运算符重载。
//设计打印类。
class Myprint{
public:
//重载函数调用运算符
void operator()(string text)
{
cout << text << endl;
}
};
//设计加法类
class Myadd{
public:
int operator()(int num1,int num2)
{
return num1 + num2;
}
};
void myint02(string text)
{
cout << text << endl;
}
int main()
{
//Myprint myint;
//m.operator()("helloworld");
//myint("helloworld"); //由于重载之后使用方式非常像函数的调用，因此称为仿函数。
//myint02("helloworld");
Myadd ma;
//int ret = ma.operator()(10,20);
//int ret = ma(10,20);
//cout << "ret = " << ret << endl; //30
cout << ma(10,20) << endl; //30
cout << Myadd()(10,20) << endl; //30
//Myadd() -> 无名函数对象 Myadd()(10,20);
//ma -> 有名函数对象 ma(10,20);
return 0;
}
五、继承
继承是面向对象三大特性之一。
有一些类与类之间存在一些特殊的关系，
例如： 有一个动物类，猫与狗都是属于动物，都有动物的共性，也有自己的个性。
我们发现，定义这些类的时候，下级的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复的代码。
六、继承
案例：例如我们考到很多网页，都是由公共的头部、公共的底部，只有中心的内容不一样
子类也称为派生类，父类也称为基类
//继承语法：
//class 子类：继承方式 父类
//继承的好处：
//减少重复的代码
#include <iostream>
using namespace std;
//继承写法 -- 共性
class BasePage
{
public:
void head()
{
cout << "网址、书签、搜索栏、菜单栏、" << endl;
}
void right()
{
cout << "专题推荐" << endl;
}
void footer()
{
cout << "评论区、发帖子" << endl;
}
};
//继承语法：
//class 子类：继承方式 父类
class Page_one : public BasePage
{
public:
void content()
{
cout << "向袁隆平学习" << endl;
}
};
class Page_two : public BasePage
{
public:
void content()
{
cout << "从不哪一个红薯" << endl;
}
};
class Page_three : public BasePage
{
public:
void content()
{
cout << "马拉松遇难" << endl;
}
};
int main()
{
cout << "第一个网页内容图下" << endl;
Page_one po;
po.head();
po.right();
po.content();
po.footer();
cout << "第二个网页内容图下" << endl;
Page_two pt;
pt.head();
pt.right();
pt.content();
pt.footer();
cout << "第三个网页内容图下" << endl;
Page_three ps;
ps.head();
ps.right();
ps.content();
ps.footer();
return 0;
}
七、继承方式
继承语法：
class 子类：继承方式 父类
继承方式：
①公共继承
②保护继承
③私有继承
、
#include <iostream>
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 = 10; //公共属性 -> 公共属性(类内可以访问公共属性)
m_B = 20; //保护属性 -> 保护属性(类内可以访问保护属性)
//m_C = 30; //私有属性 -> 不可以访问
}
};
//保护继承
class Base2{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2:protected Base2{ //保护继承
public:
void func()
{
m_A = 100; //公共属性 -> 保护属性(类内可以访问保护属性)
m_B = 200; //保护属性 -> 保护属性(类内可以访问保护属性)
//m_C = 300; //私有属性 -> 不可以访问
}
};
class GrandSon2:public Son2{
public:
void func()
{
m_A = 50; //保护属性 -> 保护属性(类内可以访问保护属性)
m_B = 50; //保护属性 -> 保护属性(类内可以访问保护属性)
}
};
//私有继承
class Base3{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3:private Base3{
public:
void func()
{
m_A = 100; //公共属性 -> 私有属性(类内可以访问)
m_B = 200; //保护属性 -> 私有属性(类内可以访问)
//m_C = 300; //私有属性 -> 不可以访问。
}
};
class GrandSon3:public Son3{
public:
void func()
{
//m_A = 100; //私有属性 -> 不可以访问
//m_B = 100; //私有属性 -> 不可以访问
}
};
int main()
{
Son1 s1;
s1.m_A = 100; //公共属性 -> 公共属性(类外可以访问公共属性)
//s1.m_B = 200; //保护属性 -> 保护属性(类外不可以访问保护属性)
//s1.m_C = 300; //私有属性 -> 不可以访问
Son2 s2;
//s2.m_A = 100; //公共属性 -> 保护属性(类外不可以访问保护属性)
//s2.m_B = 200; //保护属性 -> 保护属性(类外不可以访问保护属性)
//s2.m_C = 300; //私有属性 -> 不可以访问
Son3 s3;
//s3.m_A = 100; //公共属性 -> 私有属性(类外不可以访问)
//s3.m_B = 200; //保护属性 -> 私有属性(类外不可以访问)
//s3.m_C = 300; //私有属性 -> 不可以访问。
return 0;
}
八、继承中的对称模型
问题：从父类中继承过来的成员，那些是属于子类对象上的？
#include <iostream>
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;
};
int main()
{
//1.计算父类对象的大小
cout << "sizeof(Base)" << sizeof(Base) << endl;
//父类中所有的非静态成员属性都会被子类继承下来。
//父类的私有成员属性是被编译器隐藏了，因此访问不到，但它确实是继承下来了
cout << "sizeof(son)" << sizeof(son) << endl;
return 0;
}
结论；
//父类中所有的非静态成员属性都会被子类继承下来。
//父类的私有成员属性是被编译器隐藏了，因此访问不到，但它确实是继承下来了
九、继承构造函数与析构的顺序？
子类继承父类以后。当创建子类对象时，
父亲先构造，子类再构造，析构则是相反
继承中构造与析构的顺序
#include <iostream>
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;
}
};
int main()
{
Base b;
Son s;
return 0;
}
十、继承中同名成员的处理方式
问题：当子类中与父类出现同名的成员，如何通过子类对象访问子类或者是父类中同名的数据
#include <iostream>
using namespace std;
//继承中同名成员处理方式
//1）访问子类同名成员，直接访问就可以了。
//2）访问父类同名成员，需要加作用域。
//设计父类
class Base{
public:
Base()
{
m_A = 10; //非静态成员属性
}
void func() //非静态成员函数
{
cout << "Base - func函数调用" << endl;
}
int m_A;
};
class Son:public Base{
public:
Son()
{
m_A = 20;
}
void func() //非静态成员函数
{
cout << "Son - func函数调用" << endl;
}
int m_A; //非静态成员属性
};
int main()
{
//1. 同名成员属性处理方式。
//Son s; //实例化子类的对象，就会先调用父类的构造函数，再调用子类的构造函数。
//cout << "Son下的m_A = " << s.m_A << endl; //子类对象访问子类成员，直接访问就可以了。
//cout << "Base下的m_A = " << s.Base::m_A << endl; //子类对象访问父类成员，需要加作用域。
//2. 同名成员函数处理。
Son s;
s.func(); //直接调用，则调用的是子类中同名成员。
s.Base::func(); //加作用域，则访问的是父类的函数。
return 0;
}
结论：
//访问子类同名成员，直接访问就可以了，
//访问父类同名成员，需要加作用域
十一、继承中同名的静态成员的处理方式。
问题：继承中同名的静态成员在子类中是如何访问的
静态成员与非静态成员出现同名情况。处理方式以一致
1)访问子类中静态成员，直接访问即可、
2）访问父类中静态成员函数，前面添加作用域
#include <iostream>
using namespace std;
class Base
{
public:
static int m_a;
static void func()
{
cout << "base - static void func()" << endl;
}
};
int Base::m_a = 100;
class Son : public Base
{
public:
static int m_a;
static void func()
{
cout << "son - static void func()" << endl;
}
};
int Son::m_a = 200;
int main()
{
//计算子类对象的大小
cout << sizeof(Son) << endl;
//通过对象访问
Son s;
cout << s.m_a << endl;
cout << s.Base::m_a << endl;
//通过类名访问
cout << Base::m_a << endl;
cout << Son::m_a << endl;
//通过对象访问
s.func();
s.Base::func();
//通过类名访问
Son::func();
Base::func();
Son::Base::func();
return 0;
}
十二、多继承的语法（不推荐使用，可能会很麻烦，和别人合作不方便）
C++中允许一个类继承多个类
语法： class 子类：继承方式 父类1，继承方式 父类二…………
多继承可能会引起父类中同名成员出现，需要加作用域加以区分
#include <iostream>
using namespace std;
class Base1
{
public:
Base1()
{
m_a = 100;
}
int m_a;
};
class Base2
{
public:
Base2()
{
m_a = 200;
}
int m_a;
};
//class 子类：继承方式 父类1，继承方式 父类二…………
class Son : public Base1, public Base2
{
public:
Son()
{
m_c = 300;
m_d = 400;
}
int m_c;
int m_d;
};
int main()
{
cout << sizeof(Son) << endl;
//当名字不同时访问如下
Son s;
cout << s.Base1::m_a << endl;
cout << s.Base2::m_a << endl;
cout << s.m_c << endl;
cout << s.m_d << endl;
return 0;
}
这篇关于C++ 学习日记-算符重载、继承的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
增量更新怎么做？-icode9专业技术文章分享11-23
-
压缩包加密方案有哪些？-icode9专业技术文章分享11-23
-
用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享11-23
-
webman可以同步自己的仓库吗？-icode9专业技术文章分享11-23
-
在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享11-23
-
如何重置new Swiper?-icode9专业技术文章分享11-23
-
oss直传有什么好处？-icode9专业技术文章分享11-23
-
如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享11-23
-
怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享11-23
-
怎么实现ansible playbook 备份代码中命名包含时间戳功能？-icode9专业技术文章分享11-22
-
ansible 的archive 参数是什么意思？-icode9专业技术文章分享11-22
-
ansible 中怎么只用archive 排除某个目录？-icode9专业技术文章分享11-22
-
exclude_path参数是什么作用？-icode9专业技术文章分享11-22
-
微信开放平台第三方平台什么时候调用数据预拉取和数据周期性更新接口？-icode9专业技术文章分享11-22
-
uniapp 实现聊天消息会话的列表功能怎么实现？-icode9专业技术文章分享11-22
栏目导航
