c++类和对象
c++面向对象的三大特性:
封装
继承
多态
c++认为万事万物皆为对象,对象上有其属性和行为
例如:
人作为对象,属性有姓名 年龄 身高 体重 行为有走 跑 跳
车也可以作为对象,属性有轮胎 方向盘 转向灯 行为有导航 空调 音乐等
具有相同性质的对象,我们将其抽象为类,人属于人类,车属于车类
封装
封装的意义
封装是c++面向对象的三大特性之一
意义:
- 将属性和行为作为一个整体,表现生活中的事物
- 将属性和行为加以权限控制
意义一:
将属性和行为作为一个整体,表现生活中的事物
语法:
class 类名{
访问权限:属性/行为
};
实例1:
设计一个圆类,求圆的周长
#include<iostream>
using namespace std;
#define PI 3.14
//设计一个圆类,求圆的周长
//周长的公式:2 * PI * 半径;
//class代表设计一个类,类名后面紧跟着就是类的名称
class Circle{
//访问权限
public://公共权限
//属性
int m_r;//半径
//行为
double calculateZC() {//获取圆的周长
return 2 * PI * m_r;
}
};
int main() {
//通过圆类创建具体的圆(对象)
//实例化(通过一个类创建一个对象的过程)
Circle cl;
//给圆对象的属性进行赋值
cl.m_r = 10;//半径为10
cout << "圆的周长为" << cl.calculateZC() << endl;//2 * PI * 10
system("pause");
return 0;
}
圆的周长为62.8
请按任意键继续. . .
实例2:
设计一个学生类,属性有姓名和学号可以为姓名和学号进行赋值,可以显示
学生的姓名和学号
#include<iostream>
#include<string>
using namespace std;
/*
设计一个学生类,属性有姓名和学号可以为姓名和学号进行赋值,可以显示学生的姓名和学号
*/
//设计学生类
class Student {
public://公共权限
//类中的属性和行为我们统一称为成员
//属性中有成员属性 成员变量
//行为中有成员函数 成员方法
//属性
string m_Name;//姓名
int m_Id;//学号
//行为
void showStudent() {//显示学生的姓名和学号
cout << "姓名:" << m_Name << " 学号:" << m_Id << endl;
}
//给姓名赋值
void setName(string name) {
m_Name = name;
}
void setId(int id) {
m_Id = id;
}
};
int main() {
//创建具体的学生(实例化)
Student s1;
//给s1进行赋值操作
s1.m_Name = "张三";//等价于s1.setName("张三")
s1.m_Id = 1;//等价于s1.setId(1);
//显示学生的信息
s1.showStudent();
Student s2;
s2.m_Name = "李四";
s2.m_Id = 2;
s2.showStudent();
system("pause");
return 0;
}
姓名:张三 学号:1
姓名:李四 学号:2
请按任意键继续. . .
意义二:
- 类在设计的时候,可以把属性和行为放在不同的权限下,加以控制
- 访问权限有三种:
public 公共权限
protected保护权限
private 私有权限
- 实例:
#include<iostream>
#include<string>
using namespace std;
//访问权限有三种:
/*
1.公共权限public 成员 类内和类外都可以访问
2.保护权限protected 成员 类内可以访问类外不可以访问 可以访问保护内容
3.私有权限private 成员 类内可以访问类外不可以访问 不可以访问私有内容
*/
class Person {
public://公共权限
string m_Name;//姓名
protected://保护权限
string m_Car;//车
private://私有权限
int m_password;//银行卡密码
public://公共权限
void func() {
m_Name = "张三";
m_Car = "雪佛兰";
m_password = 12345;
}
};
int main() {
Person p1;
p1.m_Name = "李四";
//p1.m_Car = "奔驰";//保护权限内容,在类外访问不到
//p1.password = 123455689;//私有权限,在类外访问不到
//p1.func();
system("pause");
return 0;
}
struct和class区别
在c++中struct和class唯一的区别就在于默认的访问权限不同
- 区别:
struct默认权限是公共
class默认权限是私有
- 实例:
#include<iostream>
using namespace std;
//struct和class的区别
//class默认权限是私有private
class C1 {
int m_A;//默认权限是私有权限
};
//struct默认权限是公共public
struct C2 {
int m_A;//默认权限是公共权限
};
int main() {
C1 c1;
//c1.m_A = 100;//class默认权限是私有权限,类外不可以访问
C2 c2;
c2.m_A = 100;//在struct默认权限是公共权限 ,因此可以访问
system("pause");
return 0;
}
成员属性设置为私有
- 优点:
将所有的成员属性设置为私有,可以自己控制读写权限
#include<iostream>
#include<string>
using namespace std;
//成员属性设置为私有
//优点:
//1、自己控制读写的权限
class Person {
public:
//写姓名--设置姓名
void setName(string name) {
m_Name = name;
}
//读姓名
string getName() {
return m_Name;
}
//获取年龄--只读
int getAge() {
m_Age = 0;//初始化为0岁
return m_Age;
}
//设置情人--只写
void setLover(string lover) {
m_Lover = lover;
}
private:
//姓名 可读可写
string m_Name;
//年龄 只读
int m_Age;
//情人 只写
string m_Lover;
};
int main() {
Person p;
p.setName("张三");
cout << "姓名为:" << p.getName() << endl;
//p.getAge = 19;
//p.setAge(19)
cout << "年龄为:" << p.getAge() << endl;
//设置情人为xxxx
p.setLover("xxxx");
//cout << "情人为:" << p.setLover() << endl;//只写权限不可以访问
system("pause");
return 0;
}
姓名为:张三
年龄为:0
请按任意键继续. . .
对于写权限,我们可以检测数据的有效性
#include<iostream>
#include<string>
using namespace std;
//成员属性设置为私有
//优点:
//对于写权限,我们可以检测数据的有效性
class Person {
public:
//写姓名--设置姓名
void setName(string name) {
m_Name = name;
}
//读姓名
string getName() {
return m_Name;
}
//获取年龄--可读可写 如果想修改(年龄的范围必须是0到100之间)
int getAge() {
//m_Age = 0;//初始化为0岁
return m_Age;
}
//设置年龄
void setAge(int age) {
if (age < 0 || age >100) {
m_Age = 0;
cout << "您这个年龄有误" << endl;
return;
}
m_Age = age;
}
//设置情人--只写
void setLover(string lover) {
m_Lover = lover;
}
private:
//姓名 可读可写
string m_Name;
//年龄 只读
int m_Age;
//情人 只写
string m_Lover;
};
int main() {
Person p;
p.setName("张三");
cout << "姓名为:" << p.getName() << endl;
//p.getAge = 19;
//p.setAge(19)
p.setAge(10);
cout << "年龄为:" << p.getAge() << endl;
//设置情人为xxxx
p.setLover("xxxx");
//cout << "情人为:" << p.setLover() << endl;//只写权限不可以访问
system("pause");
return 0;
}
姓名为:张三
您这个年龄有误
年龄为:0
请按任意键继续. . .
姓名为:张三
年龄为:10
请按任意键继续. . .
案例一:
设计立方体类
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等
#include<iostream>
using namespace std;
//立方体类设计流程:
//1.创建立方体类
//2.设计属性
//3.设计行为 获取立方体面积和体积
//4.分别利用全局函数和成员函数 判断两个立方体是否相等
//1.创建立方体类
class Cube {
public:
//设置长
void setL(int l) {
m_L = l;
}
//获取长
int getL() {
return m_L;
}
//设置宽
void setW(int w) {
m_W = w;
}
//获取宽
int getW() {
return m_W;
}
//设置高
void setH(int h) {
m_H = h;
}
//获取高
int getH() {
return m_H;
}
//获取立方体的面积
int calculateS() {
return 2 * (m_L * m_W + m_L * m_H + m_W * m_H);
}
int calculateV() {
return m_L * m_W * m_H;
}
//利用成员函数判断 两个函数是否相等
bool isSameByClass(Cube &c) {
if (m_L == c.getL() && m_W == c.getW() && m_H == c.getH()) {
return true;
}
else {
return false;
}
}
private:
int m_L;//长
int m_W;//宽
int m_H;//高
};
//利用全局函数判断 两个立方体是否相等
bool isSame(Cube &c1,Cube &c2) {
if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH()){
return true;
}
else {
return false;
}
}
int main() {
//创建立方体对象
Cube c1;
c1.setL(10);
c1.setW(10);
c1.setH(10);
cout << "c1的面积为:" << c1.calculateS() << endl;//面积600
cout << "c1的体积为:" << c1.calculateV() << endl;//体积1000
//创建第二个立方体对象
Cube c2;
c2.setL(10);
c2.setW(10);
c2.setH(10);
//利用全局函数判断
bool ret = isSame(c1, c2);
if (ret) {
cout << "全局函数判断:c1和c2相等的" << endl;
}
else {
cout << "全局函数判断:c1和c2是不相等的" << endl;
}
//利用成员函数判断
ret = c1.isSameByClass(c2);
if (ret) {
cout << "成员函数判断:c1和c2相等的" << endl;
}
else {
cout << "成员函数判断:c1和c2是不相等的" << endl;
}
system("pause");
return 0;
}
c1的面积为:600
c1的体积为:1000
全局函数判断:c1和c2相等的
成员函数判断:c1和c2相等的
请按任意键继续. . .
案例二:
点和圆的关系
设计一个圆形类和一个点类,计算点和圆的关系
-
分析
-
实例:
写法一:
#include<iostream>
using namespace std;
//点和圆的关系
//点类
class Point {
public:
//设置x
void setX(int x) {
m_X = x;
}
//获取x
int getX() {
return m_X;
}
//设置y
void setY(int y) {
m_Y = y;
}
//获取y
int getY() {
return m_Y;
}
private:
int m_X;
int m_Y;
};
//圆类
class Circle {
public:
//设置半径
void setR(int r) {
m_R = r;
}
//获取半径
int getR() {
return m_R;
}
//设置圆心
void setCenter(Point center) {
m_Center = center;
}
//获取圆心
Point getCenter() {
return m_Center;
}
private:
int m_R;//半径
//在类中可以让另一个类 作为本类中的成员
Point m_Center;//圆心
};
//判断点和圆的关系的函数
void isInCircle(Circle& c, Point& p) {
//计算两点之间距离的平方
int distance = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) + (c.getCenter().getY() - p.getX()) * (c.getCenter().getY() - p.getX());
//计算半径的平方
int rDistance = c.getR() * c.getR();
if (distance == rDistance) {
cout << "点在圆上" << endl;
}
else if(distance > rDistance){
cout << "点在园外" << endl;
}
else {
cout << "点在园内" << endl;
}
}
int main() {
//创建一个圆
Circle c;
c.setR(10);
Point center;
center.setX(10);
center.setY(0);
c.setCenter(center);
//创建一个点
Point p;
p.setX(10);
p.setY(10);
//判断点和圆的关系
isInCircle(c, p);
system("pause");
return 0;
}
点在圆上
请按任意键继续. . .
写法二–分文件编写:
#pragma once//防止头文件重复包含
#include<iostream>
using namespace std;
//点类
class Point {
public:
//设置x
void setX(int x);
//获取x
int getX();
//设置y
void setY(int y);
//获取y
int getY();
private:
int m_X;
int m_Y;
};
point.cpp
#include "point.h"
//设置x
void Point::setX(int x) {
m_X = x;
}
//获取x
int Point::getX() {
return m_X;
}
//设置y
void Point::setY(int y) {
m_Y = y;
}
//获取y
int Point::getY() {
return m_Y;
}
circle.h
#pragma once
#include<iostream>
#include "point.h"
using namespace std;
class Circle {
public:
//设置半径
void setR(int r);
//获取半径
int getR();
//设置圆心
void setCenter(Point center);
//获取圆心
Point getCenter();
private:
int m_R;//半径
//在类中可以让另一个类 作为本类中的成员
Point m_Center;//圆心
};
circle.cpp
#include "circle.h"
//设置半径
void Circle::setR(int r) {
m_R = r;
}
//获取半径
int Circle::getR() {
return m_R;
}
//设置圆心
void Circle::setCenter(Point center) {
m_Center = center;
}
//获取圆心
Point Circle::getCenter() {
return m_Center;
}
main.cpp
#include<iostream>
#include "point.h"
#include "circle.h"
using namespace std;
//判断点和圆的关系的函数
void isInCircle(Circle& c, Point& p) {
//计算两点之间距离的平方
int distance = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) + (c.getCenter().getY() - p.getX()) * (c.getCenter().getY() - p.getX());
//计算半径的平方
int rDistance = c.getR() * c.getR();
if (distance == rDistance) {
cout << "点在圆上" << endl;
}
else if(distance > rDistance){
cout << "点在园外" << endl;
}
else {
cout << "点在园内" << endl;
}
}
int main() {
//创建一个圆
Circle c;
c.setR(10);
Point center;
center.setX(10);
center.setY(0);
c.setCenter(center);
//创建一个点
Point p;
p.setX(10);
p.setY(10);
//判断点和圆的关系
isInCircle(c, p);
system("pause");
return 0;
}
点在圆上
请按任意键继续. . .
对象
对象的特性
对象的初始化和清理
生活中我们买的电子设备都有基本出厂设置,在某一天不用的时候也会删除一些自己的信息数据保证数据安全
c++中的面向对象来源于生活,每一个对象都有初始设置以及对象销毁前的数据清理的设置
构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态,对齐使用的后果是未知的
同样的使用完一个对象或者变量,没有及时的清理,也会造成一定的安全问题
c++利用构造函数和析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情,因此如果我们不提供构造和析构,编译器会提供编译器提供的构造函数和析构函数是空实现
构造函数:主要作用在创建对象是为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用
析构函数:主要作用在对象销毁前系统自动调用,执行一些清理工作
构造函数语法
类名(){
}
构造函数,没有返回值也不写void
函数名称与类名相同
构造函数可以有参数,因此可以发生重载
程序在调用对象的时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数语法
~类名(){
}
析构函数,没有返回值也不写void
函数名称与类名相同,在名称的前面加上符号~
析构函数不可以有参数,因此不可以发生重载
程序在对象销毁前自动调用析构,无须手动调用,而且只会调用一次
#include<iostream>
using namespace std;
//对象的初始化和清理
/*
1.构造函数 进行初始化的操作
2.析构函数 进行清理的操作
*/
class Person {
//构造函数 进行初始化的操作
/*
构造函数,没有返回值也不写void
函数名称与类名相同
构造函数可以有参数,因此可以发生重载
程序在调用对象的时候会自动调用构造,无须手动调用,而且只会调用一次
*/
/*
类名(){
}
*/
public:
Person() {
cout << "Person 构造函数的调用" << endl;
}
//2.析构函数 进行清理的操作
/*
析构函数,没有返回值也不写void
函数名称与类名相同,在名称的前面加上符号~
析构函数不可以有参数,因此不可以发生重载
程序在对象销毁前自动调用析构,无须手动调用,而且只会调用一次
*/
/*
~类名(){
}
*/
~Person() {
cout << "~Person 析构函数调用" << endl;
}
};
//构造哈析构都是必须有的实现,如果我们不提供,编译器会自动提供一个空实现的构造和析构
void test01() {
Person p;//在栈上的数据,test01执行完毕后,释放这个对象
}
int main() {
test01();
Person p;
system("pause");
return 0;
}
Person 构造函数的调用
~Person 析构函数调用
Person 构造函数的调用
请按任意键继续. .
构造函数的分类及调用
- 两种分类方式:
按参数分类:有参构造和无参构造
按类型分类:普通构造和拷贝构造
- 三种调用方式:
括号法
显示法
隐式转换法
#include<iostream>
using namespace std;
//1.构造函数的分类及调用
/*
按参数分类:有参构造和无参构造
按类型分类:普通构造和拷贝构造
*/
class Person {
public:
//无参构造函数--(默认构造)
Person() {
cout << "Person无参构造函数的调用" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "Person有参构造函数的调用" << endl;
}
//拷贝构造函数
Person(const Person &p) {
//将传入的人身上的所有的属性,拷贝我身上
cout << "Person拷贝构造函数的调用" << endl;
age = p.age;
}
~Person() {
cout << "~Person析构函数的调用" << endl;
}
int age;
};
//调用
void test01() {
//1.括号法
Person p1;//默认构造函数调用
Person p2(10);//有参构造函数调用
Person p3(p2);//拷贝构造函数
cout << "p2的年龄" << p2.age << endl;
cout << "p3的年龄" << p3.age << endl;
//注意事项:
/*
调用默认构造函数的时候,不要加()
Person p1();这一行代码,编译器会认为是一个函数的声明,不会认为在创建对象
void func();
*/
//2.显示法
Person p1;
Person p2 = Person(10);//有参构造
Person p3 = Person(p2);//拷贝构造
//注意事项:
/*
注意事项一:
Person(10);匿名对象 特点:当前行执行结束后,系统会立即回收掉匿名的对象
cout << "aaaaa" << endl;
注意事项二:
Person(p3);不要利用拷贝构造函数 初始化匿名对象,编译器会认为Person (p3) == Person p3;对象的声明
*/
//3.隐式转换法
Person p4 = 10;//相当于Person p4= Person(10);有参构造调用
Person p5 = p4;//拷贝构造Person p5 = Person(p4);
}
int main() {
test01();
system("pause");
return 0;
}
拷贝构造函数调用时机
- c++中拷贝构造函数调用的时机通常有三种情况:
使用一个已经创建完毕的对象来初始化一个新的对象
值传递的方式给函数参数传值
以值的方式返回局部对象
#include<iostream>
using namespace std;
//拷贝构造函数调用时机
/*
1.使用一个已经创建完毕的对象来初始化一个新的对象
2,值传递的方式给函数参数传值
3.值方式返回局部对象
*/
class Person {
public:
Person(){
cout << "Person默认构造函数调用" << endl;
}
Person(int age) {
cout << "Person有参构造函数调用" << endl;
m_Age = age;
}
Person(const Person& p) {
cout << "Person拷贝构造函数调用" << endl;
m_Age = p.m_Age;
}
~Person() {
cout << "Person析构函数调用" << endl;
}
int m_Age;
};
//1.使用一个已经创建完毕的对象来初始化一个新的对象
void test01() {
Person p1(20);
Person p2(p1);
cout << "p2的年龄" << p2.m_Age << endl;
}
//2,值传递的方式给函数参数传值
void doWork(Person p) {
}
void test02() {
Person p;
doWork(p);
}
//3.值方式返回局部对象
Person doWork2() {
Person p1;
cout << (int*)&p1 << endl;
return p1;
}
void test03() {
Person p = doWork2();
cout << (int*)&p << endl;
}
int main() {
test01();
test02();
test03();
system("pause");
return 0;
}
Person有参构造函数调用
Person拷贝构造函数调用
p2的年龄20
Person析构函数调用
Person析构函数调用
Person默认构造函数调用
Person拷贝构造函数调用
Person析构函数调用
Person析构函数调用
Person默认构造函数调用
000000D1FDF5FAB4
Person拷贝构造函数调用
Person析构函数调用
000000D1FDF5FBF4
Person析构函数调用
请按任意键继续. . .
构造函数调用规则
- 默认情况下,c++编译器至少给一个类添加3个函数
默认构造函数(无参,函数体为空)
默认析构函数(无参,函数体为空)
默认拷贝构造函数,对属性进行拷贝
- 构造函数调用规则如下:
如果用户定义有参构造函数,c++不在提供默认无参构造,但是会提供默认拷贝构造
如果用户定义拷贝构造含税,c++不会再提供其他构造函数
#include<iostream>
using namespace std;
//构造函数的调用规则
/*
1.创建一个类,c++编译器会给每一个类都会添加至少三个函数
默认构造函数(无参,函数体为空)
默认析构函数(无参,函数体为空)
默认拷贝构造函数,对属性进行拷贝
*/
//2.如果我们写了有参构造函数,编译器就不会在提供默认构造,依然提供拷贝构造函数
//3.如果我们写了拷贝构造函数,编译器就不会提供其他的构造函数
class Person {
public:
Person() {
cout << "Person默认构造函数调用" << endl;
}
Person(int age) {
cout << "Person有参构造函数调用" << endl;
m_Age = age;
}
Person(const Person& p) {
cout << "Person拷贝构造函数调用" << endl;
m_Age = p.m_Age;
}
~Person() {
cout << "Person析构函数调用" << endl;
}
int m_Age;
};
void test01() {
Person p;
p.m_Age = 10;
Person p2(p);
cout << "p2的年龄" << p2.m_Age << endl;
}
void test02() {
Person p(19);
Person p2(p);
cout << "p2的年龄" << p2.m_Age << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
Person默认构造函数调用
Person拷贝构造函数调用
p2的年龄10
Person析构函数调用
Person析构函数调用
Person有参构造函数调用
Person拷贝构造函数调用
p2的年龄19
Person析构函数调用
Person析构函数调用
请按任意键继续. .
深拷贝和浅拷贝
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区中重新申请空间,进行拷贝工作
浅拷贝的问题要用深拷贝来解决。
#include<iostream>
using namespace std;
//深拷贝和浅拷贝
class Person {
public:
Person() {
cout << "Person默认构造函数调用" << endl;
}
Person(int age,int height) {
m_Age = age;
m_Height = new int(height);
cout << "Person有参构造函数调用" << endl;
}
//自己实现一个拷贝构造函数解决浅拷贝的问题
Person(const Person& p) {
cout << "Person拷贝构造函数调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height;编译器默认实现就是这行代码
//深浅拷贝操作
m_Height = new int(*p.m_Height);
}
~Person() {
//析构代码,将堆区开辟的数据做释放操作
if (m_Height != NULL) {
delete m_Height;
m_Height = NULL;
}
cout << "Person析构函数调用" << endl;
}
int m_Age;//年龄
int* m_Height;//身高
};
void test01() {
Person p1(18,190);
cout << "p1的年龄为" << p1.m_Age <<" 身高为"<<*p1.m_Height<< endl;
Person p2(p1);
cout << "p2的年龄为" << p2.m_Age <<" 身高为"<<*p2.m_Height<< endl;
}
int main() {
test01();
system("pause");
return 0;
}
Person有参构造函数调用
p1的年龄为18 身高为190
Person拷贝构造函数调用
p2的年龄为18 身高为190
Person析构函数调用
Person析构函数调用
请按任意键继续. . .
总结:如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题
初始化列表
作用:c++提供了初始化列表语法,用来初始化属性
语法:
构造函数():属性1(值1),属性2(值2),......
{
}
#include<iostream>
using namespace std;
//初始化列表
class Person {
public:
传统初始化操作
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表初始化属性
Person(int a,int b,int c) :m_A(a),m_B(b),m_C(c)
{
}
void PrintPerson() {
cout << "m_A = " << m_A << endl;
cout << "m_B = " << m_B << endl;
cout << "m_C = " << m_C << endl;
}
private:
int m_A;
int m_B;
int m_C;
};
int main() {
Person p(1, 2, 3);
p.PrintPerson();
system("pause");
return 0;
}
m_A = 1
m_B = 2
m_C = 3
请按任意键继续. .
类对象作为类成员
c++类中的成员可以是另一个类中的对象,我们称该成员为对象成员
例如:
class A{
};
class B{
A a;
};
B类中有对象A作为成员,A为对象成员
那么当创建B对象是,A与B的构造和析构的顺序是怎样的呢?
#include<iostream>
#include<string>
using namespace std;
//类对象作为类成员
class Phone {
//手机类
public:
Phone(string pName) {
cout << "Phone的构造函数调用" << endl;
m_PName = pName;
}
~Phone() {
cout << "~Phone的析构函数调用" << endl;
}
//手机品牌名称
string m_PName;
};
class Person {
//人类
public:
//Phone m_Phone = pName 隐式转换法
Person(string name, string pName) :m_Name(name),m_Phone(pName)
{
cout << "Person的构造函数调用" << endl;
}
~Person() {
cout << "~Person的析构函数调用" << endl;
}
//姓名
string m_Name;
//手机
Phone m_Phone;
};
//当其他类对象作为本类的成员时,构造时候先构造类的对象,再构造自身。析构的顺序与构造相反
void test01() {
Person p("张三", "苹果MAX");
cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}
int main() {
test01();
system("pause");
return 0;
}
Phone的构造函数调用
Person的构造函数调用
张三拿着苹果MAX
~Person的析构函数调用
~Phone的析构函数调用
请按任意键继续. . .
静态成员
静态成员就是在成员变量和成员函数的前面加上关键字static,称为静态成员
静态成员分为:
- 静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明,类外初始化
- 静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
#include<iostream>
using namespace std;
//静态成员函数
//所有的对像共享同一个函数
//静态成员函数只能访问静态成员变量
class Person {
public:
static void func() {
m_A = 100;//静态成员函数可以访问静态成员变量
//m_B = 200;//静态成员函数不可以访问非静态成员变量,因为无法区分到底是哪一个对象的m_B;
cout << "static void func调用\n";
}
static int m_A;//静态成员函数
int m_B;//非静态成员变量
private:
static void func2() {
cout << "static void func2的调用\n";
}
};
int Person::m_A = 0;//静态成员变量
//两种访问方式
void test01() {
//1.通过对象进行访问
Person p;
p.func();
//2.通过类名进行访问
Person::func();
//Person::func2();类外访问不到私有的静态成员函数
}
int main() {
test01();
system("pause");
return 0;
}
static void func调用
static void func调用
请按任意键继续. . .
c++对象模型和this指针
成员变量和成员函数分开存储
在c++中,类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象
#include<iostream>
using namespace std;
//成员变量和成员函数是分开存储的
class Person {
int m_A;//非静态成员变量属于类的对象上
static int m_B;//静态成员变量不属于类的对象上
void func() {//非静态成员函数不属于类的对象上
}
static void func2() {//静态成员函数不属于类的对象上
}
};
int Person::m_B = 0;
void test01() {
Person p1;
//空对象占用的内存空间为:1
//解释:c++编译器会给每一个空对象也分配一个字节的空间,是为了区分空对象占用内存的位置
//每一个空对象也应该有一个独一无二的内存地址
cout << "size of p1 = " << sizeof(p1) << endl;
}
void test02() {
Person p2;
cout << "size of p2 = " << sizeof(p2) << endl;
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
this指针
c++中的成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例,就是说多个同类型的对象会共用一块代码
那么这一块代码是如何区分那个对象调用自己呢?
c++通过提供特殊的对象指针,this指针,解决上述问题。
this指针指向的被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义,直接使用即可
- this指针的用途:
当形参和成员变量同名是,可以用this指针来进行区分
在类的非静态成员函数中返回对象本身,可以使用return *this
#include<iostream>
using namespace std;
class Person {
public:
Person(int age) {
//1.解决名称冲突
this -> age = age;//this指针指向的是被调用的函数所属的对象
}
Person& PersonAddAge(Person& p) {
this->age += p.age;
//this指向的p2的指针,而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
void test01() {
Person p3(18);
cout << "p3的年龄为" << p3.age << endl;
}
void test02() {
Person p1(10);
Person p2(19);
//链式编程思想
//如果是引用的方式,则会返回p2,如果是值的方式,则会返回一个新的对象
p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
cout << "p2的年龄为" << p2.age << endl;//29
}
int main() {
test01();
test02();
system("pause");
return 0;
}
p3的年龄为18
p2的年龄为59
请按任意键继续. . .
空指针访问成员函数
c++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针,如果用到this指针,需要加以判断保证代码的健壮性
#include<iostream>
using namespace std;
//空指针调用成员函数
class Person {
public:
void showClassName() {
cout << "this is Person class\n";
}
void showPersonAge() {
//报错原因是因为传入的指针是为NULL
if (this == NULL) {
return;
}
cout << "age = " << this->m_Age << endl;
}
int m_Age;
};
void test01() {
Person* p = NULL;
p->showClassName();
p->showPersonAge();
}
int main() {
test01();
system("pause");
return 0;
}
this is Person class
请按任意键继续. . .
const修饰成员函数
- 常函数
成员函数后假const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后,在常函数中依然可以修改
- 常对象
声明对象前加const称该对象为常对象
常对象只能调用常函数
#include<iostream>
using namespace std;
//常函数
class Person {
public:
//this指针的本质是一个指针常量 指针的指向是不可以修改的
//const Person * const this;
//在成员函数后面加const,修饰的是this指向,让指针指向的值也不可以修改
void showPerson() const{
this->m_B = 100;
//this->m_A = 100;
//本身可以修改值,如果不想让它进行修改可以在()后加const关键字
//this = NULL;//this指针不可以修改指针的指向
}
void func() {
m_A = 100;
}
int m_A;
mutable int m_B;//特殊变量,即使在常函数中也可以修改这个值,加关键字mutable
};
void test01() {
Person p;
p.showPerson();
}
//常对象
void test02() {
const Person p;//在对象前加const,变为常对象
//p.m_A = 100;
p.m_B = 100;//m_B是特殊值,在常对象下也可以修改
//常对象只能调用常函数
p.showPerson();
//p.func();常对象不可以调用普通的成员函数,因为普通的成员函数可以修改属性
}
int main() {
test01();
system("pause");
return 0;
}
友元
生活中家里有客厅(public)有卧室(private),客厅所有往来的客人都可以进去,但是卧室是私有的,只有自己可以进去,但是可以允许你的闺蜜好友进去。
在程序中,有一些私有的属性也想让类外特殊的一些函数或者类进行访问,就用到了友元的技术。
- 友元的目的
就是让一个函数或者类访问另一个类中私有成员。 - 友元的关键字
friend - 友元的三种实现方式:
全局函数做友元
类做友元
成员函数做友元
全局函数做友元
#include<iostream>
#include<string>
using namespace std;
class Building {
//建筑物类
friend void goodGay(Building* building);//goodGay全局函数是Building好朋友,可以访问Building中的私有成员
public:
Building() {
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//全局函数
void goodGay(Building *building) {
cout << "好基友的全局函数正在访问" << building->m_SittingRoom << endl;
cout << "好基友的全局函数正在访问" << building->m_BedRoom << endl;
}
void test01() {
Building building;
goodGay(&building);
}
int main() {
test01();
system("pause");
return 0;
}
好基友的全局函数正在访问客厅
好基友的全局函数正在访问卧室
请按任意键继续. . .
类做友元–友元类
#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay {
public:
GoodGay();
void visit();//参观函数访问Building中的属性
Building* building;
};
class Building {
friend class GoodGay;//GoodGay类是本类的好朋友,可以访问本类中的私有成员
public:
string m_SittingRoom;
Building();
private:
string m_BedRoom;
};
//类外写成员函数
Building::Building() {
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay() {
//创建建筑物对象
building = new Building;
}
void GoodGay::visit() {
cout << "好基友类正在访问" << building->m_SittingRoom << endl;
cout << "好基友类正在访问" << building->m_BedRoom << endl;
}
void test01() {
GoodGay gg;
gg.visit();
}
int main() {
test01();
system("pause");
return 0;
}
好基友类正在访问客厅
好基友类正在访问卧室
请按任意键继续. . .
成员函数做友元
#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay {
public:
GoodGay();
void visit();//让visit函数可以访问Building中私有成员
void visit2();//让visit函数不可以访问Building中私有成员
Building* building;
};
class Building {
friend void GoodGay::visit();//告诉编译器GoodGay类下的visit成员函数作为本类的好朋友,可以访问私有成员
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//类外实现成员函数
Building::Building() {
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay() {
building = new Building;
}
void GoodGay::visit() {
cout << "visit正在访问" << building->m_SittingRoom << endl;
cout << "visit正在访问" << building->m_BedRoom << endl;
}
void GoodGay::visit2() {
cout << "visit2正在访问" << building->m_SittingRoom << endl;
//cout << "visit2正在访问" << building->m_BedRoom << endl;
}
void test01() {
GoodGay gg;
gg.visit();
gg.visit2();
}
int main() {
test01();
system("pause");
return 0;
}
visit正在访问客厅
visit正在访问卧室
visit2正在访问客厅
请按任意键继续. .
运算符重载
- 概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
加号运算符重载
- 作用:实现两个自定义数据类型相加的运算
#include<iostream>
using namespace std;
class Person {
//1.通过成员函数重载加号
Person operator+(Person& p) {
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
public:
int m_A;
int m_B;
};
//通过全局函数重载加号
Person operator+(Person& p1, Person& p2) {
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//函数重载的版本
Person operator+(Person& p1, int num) {
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01() {
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
成员函数重载本质调用
//Person p3 = p1.operator+(p2);
全局函数重载本质调用
//Person p3 = operator+(p1, p2);
Person p3 = p1 + p2;
//运算符重载也可以发生函数重载
Person p4 = p1 + 10;//Person + int
cout << "p3.m_A = " << p3.m_A << " p3.m_B = " << p3.m_B << endl;
cout << "p4.m_A = " << p4.m_A << " p4.m_B = " << p4.m_B << endl;
}
int main() {
test01();
system("pause");
return 0;
}
左移运算符重载
- 作用可以输出自定义数据类型
#include<iostream>
using namespace std;
//左移运算符
class Person {
friend ostream& operator<<(ostream& cout, Person& p);
public:
Person(int a, int b) {
m_A = a;
m_B = b;
}
private:
//利用成员函数重载左移运算符 p.operator<<(cout)简化为p<<cout
//不会利用成员函数重载左移运算符,因为无法实现cout在左侧
//void operator<<(cout) {
//
//}
int m_A;
int m_B;
};
//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout,Person &p) {//本质operator<<(cout,p)简化为cout<<p;
cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
return cout;
}
void test01() {
Person p(10,10);
//p.m_A = 10;
//p.m_B = 10;
cout << p<< endl;
}
int main() {
test01();
system("pause");
return 0;
}
m_A = 10 m_B = 10
请按任意键继续. . .
递增运算符重载
- 作用:通过重载递增运算符,实现自己的整型数据
#include<iostream>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger {
friend ostream& operator<<(ostream& cout, MyInteger);
public:
MyInteger() {
m_Num = 0;
}
//重载前置++运算符 返回引用是为了一直对一个数据进行递增操作
MyInteger& operator++() {
//先进行++运算
m_Num++;
//再将自身做返回
return *this;
}
//重载后置++运算符
MyInteger operator++(int) {//void operator++(int)中int代表占位参数用于区分前置和后置递增
//先记录当时的结果
MyInteger temp = *this;
//后进行递增操作
m_Num++;
//最后将记录结果做返回
return temp;
}
private:
int m_Num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, MyInteger myint) {
cout << myint.m_Num;
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();
//int a = 0;
//cout << ++(++a) << endl;
//cout << a << endl;
test02();
system("pause");
return 0;
}
2
2
0
1
请按任意键继续. . .
- 总结:前置递增返回的是引用,后置递增返回的是值
赋值运算符重载
- 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;
};
void test01() {
Person p1(19);
Person p2(20);
Person p3(50);
Person p4(60);
Person p5(70);
cout << "赋值前p1的年龄" << *p1.m_Age << endl;
cout << "赋值前p2的年龄" << *p2.m_Age << endl;
p2 = p1;//赋值操作
cout << endl;
cout << "赋值后p1的年龄" << *p1.m_Age << endl;
cout << "赋值后p2的年龄" << *p2.m_Age << endl;
cout << endl;
cout << "连续赋值前p3的年龄" << *p3.m_Age << endl;
cout << "连续赋值前p4的年龄" << *p4.m_Age << endl;
cout << "连续赋值前p5的年龄" << *p5.m_Age << endl;
p5 = p4 = p3;//连续赋值操作
cout << endl;
cout << "连续赋值后p3的年龄" << *p3.m_Age << endl;
cout << "连续赋值后p4的年龄" << *p4.m_Age << endl;
cout << "连续赋值后p5的年龄" << *p5.m_Age << endl;
}
int main() {
test01();
int a = 10;
int b = 40;
int c = 30;
c = b = a;
cout << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
system("pause");
return 0;
}
赋值前p1的年龄19
赋值前p2的年龄20
赋值后p1的年龄19
赋值后p2的年龄19
连续赋值前p3的年龄50
连续赋值前p4的年龄60
连续赋值前p5的年龄70
连续赋值后p3的年龄50
连续赋值后p4的年龄50
连续赋值后p5的年龄50
a = 10
b = 10
c = 10
请按任意键继续. . .
关系运算符重载
- 作用:重载关系运算符,可以 让两个自定义类型对象进行对比操作
#include<iostream>
#include<string>
using namespace std;
//重载关系运算符
class Person {
public:
Person(string name, int age) {
m_Name = name;
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;
}
string m_Name;
int m_Age;
};
void test01() {
Person p1("Tom", 18);
Person p2("Tom", 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;
}
}
int main() {
test01();
system("pause");
return 0;
}
p1和p2是相等的
p1和p2是相等的
请按任意键继续. . .
函数调用运算符重载
- 函数调用运算符()也可以重载
- 由于重载后使用的方式非常像函数的调用,因此称为仿函数
- 仿函数没有固定的写法,非常灵活
#include<iostream>
#include<string>
using namespace std;
//函数调用运算符重载
class MyPrint {
public:
//重载函数调用运算符
void operator()(string test) {
cout << test << endl;
}
};
void Myprint02(string test) {
cout << test << endl;
}
void test01() {
MyPrint myprint;
myprint("hello world");//由于使用起来非常类似于函数调用,因此被称为仿函数
//MyPrint02("hello world");
}
//仿函数非常灵活,没有固定的写法
//加法类
class MyAdd {
public:
int operator()(int num1,int num2) {
return num1 + num2;
}
};
void test02() {
MyAdd myadd;
int ret = myadd(100, 100);
cout << "ret = " << ret << endl;
//匿名函数对象
cout << MyAdd()(100, 100) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
hello world
ret = 200
200
请按任意键继续. .
继承
继承是面向对象的三大特性之一
有些类与类之间存在特殊的关系,例如:
我们发现,定义这些类时,下级别的成员拥有上一级的共性,还有自己的特性
这个时候就可以考虑用继承的技术,减少重复的代码
基本语法:
class 子类 :继承方式 父类 {
};
#include<iostream>
using namespace std;
//普通实现页面
//Java页面
//class Java {
//public:
// void header() {
// cout << "首页、公开课、登录、注册....(公共头部)" << endl;
// }
// void footer() {
// cout << "帮助中心、交流合作、站内地图....(公共底部)" << endl;
// }
// void left() {
// cout << "java,python,c++,.....(公共分类列表)" << endl;
// }
// void content() {
// cout << "java学科视频" << endl;
// }
//};
Python页面
//class Python{
//public:
// void header() {
// cout << "首页、公开课、登录、注册....(公共头部)" << endl;
// }
// void footer() {
// cout << "帮助中心、交流合作、站内地图....(公共底部)" << endl;
// }
// void left() {
// cout << "java,python,c++,.....(公共分类列表)" << endl;
// }
// void content() {
// cout << "Python学科视频" << endl;
// }
//}
C页面
//class CPP{
//public:
// void header() {
// cout << "首页、公开课、登录、注册....(公共头部)" << endl;
// }
// void footer() {
// cout << "帮助中心、交流合作、站内地图....(公共底部)" << endl;
// }
// void left() {
// cout << "java,python,c++,.....(公共分类列表)" << endl;
// }
// void content() {
// cout << "C学科视频" << endl;
// }
//};
//继承实现页面
class BasePage {
//公共页面类
public:
void header() {
cout << "首页、公开课、登录、注册....(公共头部)" << endl;
}
void footer() {
cout << "帮助中心、交流合作、站内地图....(公共底部)" << endl;
}
void left() {
cout << "java,python,c++,.....(公共分类列表)" << endl;
}
};
//继承的好处:减少重复的代码
//语法:
//class 子类 :继承方式 父类 {
//
//};
//子类也成为派生类
//父类也称为基类
///java页面
class Java :public BasePage {
public:
void content() {
cout << "java学科视频" << endl;
}
};
//python页面
class python :public BasePage {
public:
void content() {
cout << "python学科视频" << endl;
}
};
//c++页面
class CPP :public BasePage {
public:
void content() {
cout << "c++学科视频" << endl;
}
};
void test01() {
cout << "Java下载视频页面如下" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "---------------------" << endl;
cout << "python下载视频页面如下" << endl;
python py;
py.header();
py.footer();
py.left();
py.content();
cout << "-----------------------" << endl;
cout << "C下载视频页面如下" << endl;
CPP c;
c.header();
c.footer();
c.left();
c.content();
}
int main() {
test01();
system("pause");
return 0;
}
继承方式:
继承方式一共有三种:
公共继承
保护继承
私有继承
#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 = 10;//父类中的保护权限成员到子类依然是保护权限
//m_C = 10;父类中的私有权限成员子类访问不到
}
};
//公共继承
void test01() {
Son1 s1;
s1.m_A = 100;
//s1.m_B = 100;到Son1中m_B是保护权限类外访问不到
}
//保护继承
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 = 1200;//父类中保护成员,到子类中变为保护权限
//m_C = 1299;//父类中的私有成员子类访问不到
}
};
void test02() {
Son2 s2;
//s2.m_A = 1000;在Son2中m_A变为保护权限,因此类外访问不到
//s2.m_B = 1000;在Son2中m_B是保护权限,不可以访问
}
//私有继承
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 = 100;//父类中的保护成员到子类中变为私有成员
//m_C = 190;父类中的私有成员,子类访问不到
}
};
class GrandSon3 :public Son3 {
public:
void func() {
//m_A = 1000;到Son3中,m_A变为私有,即使是儿子也访问不到
//m_B = 1278;到Son3中,m_B变为私有,即使是儿子也访问不到
}
};
void test03() {
Son3 s3;
//s3.m_A = 1900;到Son3中变为私有成员类外访问不到
//s3.m_B = 1233;到Son3中变为私有成员类外访问不到
}
int main() {
test01();
test02();
test03();
system("pause");
return 0;
}
继承中的对象模型
从父类继承过来的成员哪些属于子类对象中?
//利用开发人员命令提示工具查看对象的模型:
/*
跳转盘符
跳转文件路径 cd 具体路径如下
查看命令
c1 /d1 reportSingleClassLayout类名 "文件名"
*/
#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;
};
//利用开发人员命令提示工具查看对象的模型:
/*
跳转盘符
跳转文件路径 cd 具体路径如下
查看命令
c1 /d1 reportSingleClassLayout类名 "文件名"
*/
void test01() {
//16
//父类中所有的非静态成员属性都会被子类继承下去
//父类中私有的成员属性是被编译器给隐藏了,因此是访问不到的,但是确实是被继承下去了
cout << "side of Son" << sizeof(Son) << endl;
}
int main() {
test01();
system("pause");
return 0;
}
side of Son16
请按任意键继续. . .
继承中构造和析构的顺序
子类继承父类后,当创建子类对象也会调用父类的构造函数
问题:父类和子类的构造和析构顺序谁先谁后
#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;
}
};
void test01() {
Base b;
cout << "----------" << endl;
//继承中的构造和析构的顺序如下:
//先构造父类,再构造子类,析构的顺序与构造的顺序相反
Son s;
}
int main() {
test01();
system("pause");
return 0;
}
Base构造函数
----------
Base构造函数
Son构造函数
~Son析构函数
~Base析构函数
~Base析构函数
请按任意键继续. . .
同名成员处理
当子类与父类出现同名的成员时,如何通过子类对象,访问到子类或父类中同名的数据呢?
访问子类同名成员直接访问即可
访问父类同名成员需要添加作用域
#include<iostream>
using namespace std;
//继承中同名的成员处理
class Base {
public:
Base() {
m_A = 100;
}
void func() {
cout << "Base::func()调用" << endl;
}
void func(int a) {
cout << "Base::func(int a)调用" << endl;
}
int m_A;
};
class Son :public Base {
public:
Son() {
m_A = 10000;
}
void func() {
cout << "Son::func()调用" << endl;
}
int m_A;
};
//同名成员处理
void test01() {
Son s;
cout << "Son中m_A = " << s.m_A << endl;
//如果通过子类对象访问到父类中同名成员需要添加作用域
cout << "Base中m_A = " << s.Base::m_A << endl;
}
//同名函数处理
void test02() {
Son s;
s.func();//直接调用,调用的是子类中同名的成员
//如何调用到父类中同名的成员函数?
s.Base::func();
//s.func(1000);//如果子类中出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有的同名成员函数
//如果想访问到父类中被隐藏的同名成员函数,需要添加一个作用域
s.Base::func(100);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
Son中m_A = 10000
Base中m_A = 100
Son::func()调用
Base::func()调用
Base::func(int a)调用
请按任意键继续. . .
同名静态成员处理
静态成员和非静态成员出现同名,处理方式一致
访问子类同名成员 直接访问即可
访问父类同名成员 需要添加作用域
#include<iostream>
using namespace std;
//继承中同名静态成员处理方式
class Base {
public:
static int m_A;
static void func() {
cout << "Base::static void func()的调用" << endl;
}
static void func(int a) {
cout << "Base::static void func(int a)的调用" << 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 = 2000;
//同名静态成员属性
void test01() {
//通过对象访问数据
cout << "通过对象访问数据\n";
Son s1;
cout << "Son中m_A = " << s1.m_A << endl;
cout << "Base中m_A = " << s1.Base::m_A << endl;
//通过类名访问数据
cout << "通过类名访问数据\n";
cout << "Son中的m_A = " << Son::m_A << endl;
cout << "Base中的m_A = " << Son::Base::m_A << endl;//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
}
//同名静态成员函数
void test02() {
//1.通过对象访问
cout << "通过对象访问\n";
Son s;
s.func();
s.Base::func();
//2.通过类名访问
cout << "通过类名访问\n";
Son::func();
Son::Base::func();
//子类出现和父类同名的静态成员函数,也会隐藏父类中所有同名成员函数
//如果想访问父类中被隐藏同名成员,需要添加作用域
Son::Base::func(100);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
通过对象访问数据
Son中m_A = 2000
Base中m_A = 100
通过类名访问数据
Son中的m_A = 2000
Base中的m_A = 100
通过对象访问
Son::static void func()的调用
Base::static void func()的调用
通过类名访问
Son::static void func()的调用
Base::static void func()的调用
Base::static void func(int a)的调用
请按任意键继续. . .
多继承语法
c++允许一个类继承多个类
- 语法:
class 子类:继承方式 父类, 继承方式 父类.....{
};
多继承可能会引发父类中有同名的成员出现,需要加作用域区分
c++实际开发中不建议使用多继承
#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;
};
//子类 需要继承Base1和Base2
//多继承语法:
/*
class 子类:继承方式 父类, 继承方式 父类.....{
};
*/
class Son :public Base1, public Base2 {
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 << "Base1 m_A = " << s.Base1::m_A << endl;
cout << "Base2 m_A = " << s.Base2::m_A << endl;
}
int main() {
test01();
system("pause");
return 0;
}
sizeof Son = 16
Base1 m_A = 100
Base2 m_A = 200
请按任意键继续. . .
菱形继承问题和解决方法
菱形继承的概念:
两个派生类继承同一个类
又有某个类同时继承着两个派生类
这种继承被称为菱形继承或者钻石继承
#include<iostream>
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 = 18;
st.Tuo::m_Age = 28;
//当菱形继承,两个父类拥有相同的数据,需要加以作用域区分
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;
}
st.Sheep::m_Age = 28
st.Tuo::m_Age = 28
st.m_Age = 28
请按任意键继续. . .
多态
多态的基本概念
- 多态是c++面向对象的三大特性之一
- 多态分为两类
静态多态: 函数重载和运算符重载属于静态多态,复用函数名
动态多态:派生类和虚函数实现运行时多态
- 静态多态和动态多态的区别
静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址
#include<iostream>
using namespace std;
//多态
class Animal {
public:
//动物类
//虚函数
virtual void speak() {
cout << "动物在说话" << endl;
}
};
//猫类
class Cat :public Animal {
public:
void speak() {
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal {
public:
//重写:函数的返回值类型 函数名 参数列表完全相同
void speak() {
cout << "小狗在说话" << endl;
}
};
//执行说话的函数,地址早绑定 在编译阶段确定了函数的地址
//如果想执行让猫说话,这个函数的地址就不可以提前绑定,需要在运行的时候再进行绑定
//动态多态的满足条件
/*
1.有继承关系
2.子类要重写父类中的虚函数
*/
//动态多态的使用:父类的指针或者引用指向子类的对象
void doSpeak(Animal& animal) {//Animal& animal = cat
animal.speak();
}
void test01() {
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main() {
test01();
system("pause");
return 0;
}
小猫在说话
小狗在说话
请按任意键继续. .
多态的原理刨析
#include<iostream>
using namespace std;
//多态
class Animal {
public:
//动物类
//虚函数
virtual void speak() {
cout << "动物在说话" << endl;
}
};
//猫类
class Cat :public Animal {
public:
void speak() {
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal {
public:
//重写:函数的返回值类型 函数名 参数列表完全相同
void speak() {
cout << "小狗在说话" << endl;
}
};
//执行说话的函数,地址早绑定 在编译阶段确定了函数的地址
//如果想执行让猫说话,这个函数的地址就不可以提前绑定,需要在运行的时候再进行绑定
//动态多态的满足条件
/*
1.有继承关系
2.子类要重写父类中的虚函数
*/
//动态多态的使用:父类的指针或者引用指向子类的对象
void doSpeak(Animal& animal) {//Animal& animal = cat
animal.speak();
}
void test01() {
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
void test02() {
cout << "sizeof Animal = " << sizeof(Animal) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
小猫在说话
小狗在说话
sizeof Animal = 8
请按任意键继续. . .
案例1:计算机类
- 描述:分别利用普通的写法和多态技术,设计实现两个操作数进行运算的计算机类
- 多态优点:
代码组织结构清晰
可读性强
利于前期和后期的扩展和保护
#include<iostream>
#include<string>
using namespace std;
//分别利用普通写法和多态技术实现计算器
//普通写法
class Calculator {
public:
int getResult(string oper) {
if (oper == "+") {
return m_Num1 + m_Num2;
}
else if (oper == "-") {
return m_Num1 - m_Num2;
}
else if (oper == "*") {
return m_Num1 * m_Num2;
}
//如果想扩展新的功能,需要修改源码,在真实的开发中提倡开闭原则
//开闭原则:对扩展中进行开放,对修改进行关闭
}
int m_Num1;
int m_Num2;
};
//普通写法的测试案例
void test01() {
//创建计算器的对象
Calculator c;
c.m_Num1 = 10;
c.m_Num2 = 10;
cout << "普通写法测试案例" << endl;
cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;
cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;
cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}
//利用多态实现计算器
//实现计算器的抽象类
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 test02() {
//多态使用条件:父类的指针或者引用指向子类的对象
cout << "----------------\n";
cout << "多态技术写法测试案例" << endl;
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;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
普通写法测试案例
10 + 10 = 20
10 - 10 = 0
10 * 10 = 100
----------------
多态技术写法测试案例
10 + 10 = 20
10 - 10 = 0
10 * 10 = 100
请按任意键继续. . .
纯虚函数和抽象类
在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数。
- 纯虚函数的语法:
virtual 返回值类型 函数名(参数列表) = 0;
当类中有了纯虚函数,这个类也称为抽象类
- 抽象类特点:
无法实例化对象
子类必须重写抽象类中的纯虚函数,否则也属于抽象类
#include<iostream>
using namespace std;
//纯虚函数和抽象类
class Base {
public:
//纯虚函数
//只要有一个纯虚函数,这个类称为抽象类
//抽象类的特点:
/*
1.无法实例化对象
2.子类必须重写抽象类中的纯虚函数,否则也属于抽象类
*/
virtual void func() = 0;
};
class Son :public Base {
public:
virtual void func() {
cout << "func函数的调用" << endl;
}
};
void test01() {
//Base b;1.无法实例化对象
//new Base;1.无法实例化对象
Son s; //2.子类必须重写抽象类中的纯虚函数,否则无法实例化对象
Base* base = new Son;
base->func();
}
int main() {
test01();
system("pause");
return 0;
}
func函数的调用
请按任意键继续. . .
案例2:制作饮品
利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶叶
#include<iostream>
using namespace std;
//多态案例2 制作饮品
class AbstractDrinking {
public:
//煮水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加入辅料
virtual void PutSomething() = 0;
void makeDrink() {
Boil();
Brew();
PourInCup();
PutSomething();
}
};
class Coffee :public AbstractDrinking {
public:
//煮水
virtual void Boil() {
cout << "煮水" << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡咖啡" << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething() {
cout << "加入糖和牛奶" << endl;
}
};
//制作茶叶
class Tea :public AbstractDrinking {
public:
//煮水
virtual void Boil() {
cout << "煮水" << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡茶叶" << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething() {
cout << "加入柠檬" << endl;
}
};
//制作函数
void doWork(AbstractDrinking * abs) {
abs->makeDrink();
delete abs;//手动释放
}
void test01() {
//制作咖啡
doWork(new Coffee);
cout << "------------\n";
//制作茶叶
doWork(new Tea);
}
int main() {
test01();
system("pause");
return 0;
}
煮水
冲泡咖啡
倒入杯中
加入糖和牛奶
------------
煮水
冲泡茶叶
倒入杯中
加入柠檬
请按任意键继续. . .
虚析构和纯虚析构
- 多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码
- 解决方式:将父类中的析构函数改为虚析构或者纯虚析构
- 虚析构和纯虚析构的共性:
可以解决父类指针释放子类对象
都需要有具体的函数实现
- 虚析构和纯虚析构的区别
如果是纯虚析构,该类属于抽象类,无法实例化对象
- 虚析构语法:
virtual ~类名(){
}
- 纯虚析构语法
virtual ~类名() = 0;
类名::~类名(){
}
#include<iostream>
#include<string>
using namespace std;
//虚析构和纯虚析构
class Animal {
public:
Animal() {
cout << "Animal构造函数调用" << endl;
}
//利用虚析构可以解决父类指针释放子类对象时不干净的问题
virtual ~Animal() {
cout << "Animal的析构函数调用" << endl;
}
//纯虚析构----需要声明也需要实现
//有了纯虚析构之后,这个类也属于抽象类,无法实例化对象
//virtual ~Animal() = 0;
//纯虚函数
virtual void speak() = 0;
};
/*
Animal:: ~Animal() {
cout << "Animal的纯虚析构函数调用" << endl;
}
*/
class Cat :public Animal {
public:
Cat(string name) {
cout << "Cat的构造函数调用" << endl;
new string(name);
}
virtual void speak() {
cout <<*m_Name <<"小猫在说话" << endl;
}
~Cat() {
if (m_Name != NULL) {
cout << "Cat析构函数调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
string *m_Name;
};
void test01() {
Animal* animal = new Cat("Tom");
animal->speak();
//父类指针在析构时候不会调用子类中析构函数,导致子类如果有堆区属性,出现内存泄漏
delete animal;
}
int main() {
test01();
system("pause");
return 0;
}
案例三:电脑组装
电脑组成部件有CPU 显卡 内存条
将每一个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Inter厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数,并且调用每一个零件工作的接口
测试时组装2台不同的电脑进行工作
#include<iostream>
using namespace std;
//抽象不同的零件类
//抽象CPU类
class CPU {
public:
//抽象计算函数
virtual void caculate() = 0;
};
//抽象显卡类
class VideoCard{
public:
//抽象显示函数
virtual void display() = 0;
};
//抽象内存条类
class Memory {
public:
//抽象存储函数
virtual void storage() = 0;
};
class Computer {
public:
Computer(CPU * cpu,VideoCard * vc,Memory * mem) {
m_cpu = cpu;//CPU的零件指针
m_vc = vc;//显卡的零件指针
m_mem = mem;//内存条的零件指针
}
void work() {
//让零件工作起来
m_cpu->caculate();
m_vc->display();
m_mem->storage();
}
//提供析构函数 释放3个电脑的零件
~Computer() {
//cpu释放
if (m_cpu != NULL) {
delete m_cpu;
m_cpu = NULL;
}
//显卡释放
if (m_vc != NULL) {
delete m_vc;
m_vc = NULL;
}
//内存条释放
if (m_mem != NULL) {
delete m_mem;
m_mem = NULL;
}
}
private:
CPU* m_cpu;//CPU的零件指针
VideoCard* m_vc;//显卡的零件指针
Memory* m_mem;//内存条的零件指针
};
//具体厂商
//Inter厂商
class InterCPU :public CPU {
public:
virtual void caculate() {
cout << "Inter的CPU开始计算了" << endl;
}
};
class InterVideoCard :public VideoCard {
public:
virtual void display() {
cout << "Inter的显卡开始显示了" << endl;
}
};
class InterMemory :public Memory {
public:
virtual void storage(){
cout << "Inter的内存条开始存储了" << endl;
}
};
//Lenovo厂商
class LenovoCPU :public CPU {
public:
virtual void caculate() {
cout << "Lenovo的CPU开始计算了" << endl;
}
};
class LenovoVideoCard :public VideoCard {
public:
virtual void display() {
cout << "Lenovo的显卡开始显示了" << endl;
}
};
class LenovoMemory :public Memory {
public:
virtual void storage() {
cout << "Lenovo的内存条开始存储了" << endl;
}
};
void test01() {
//第一台电脑零件
cout << "第一台电脑开始工作\n";
CPU* interCpu = new InterCPU;
VideoCard* interCard = new InterVideoCard;
Memory* interMem = new InterMemory;
//创建第一台电脑
Computer* computer1 = new Computer(interCpu,interCard,interMem);
computer1->work();
delete computer1;
cout << "------------------------\n";
//第二台电脑零件
cout << "第二台电脑开始工作\n";
CPU* lenovoCpu = new LenovoCPU;
VideoCard* lenovoCard = new LenovoVideoCard;
Memory* lenovoMem = new LenovoMemory;
//创建第二台电脑
Computer* computer2 = new Computer(lenovoCpu, lenovoCard, lenovoMem);
computer2->work();
delete computer2;
}
int main() {
test01();
system("pause");
return 0;
}
第一台电脑开始工作
Inter的CPU开始计算了
Inter的显卡开始显示了
Inter的内存条开始存储了
------------------------
第二台电脑开始工作
Lenovo的CPU开始计算了
Lenovo的显卡开始显示了
Lenovo的内存条开始存储了
请按任意键继续. . .
下节:c++文件操作