前言
只是为方便学习,不做其他用途,原作者为黑马程序员
B站配套视频:
https://www.bilibili.com/video/BV1et411b73Z
一、友元
1.1 全局函数做友元
客厅就是Public,你的卧室就是Private
客厅所有人都可以进去,但是你的卧室只有和你亲密的人可以进。
在程序中,有些私有属性也想让类外特殊的一些函数或者类进行访问,就需要用到友元技术。
友元的目的就是让一个函数或者类 访问另一个类中的私有元素。
友元的关键字——friend
友元的三种实现 :
- 全局函数做友元
- 类做友元
- 成员函数做友元
全局函数做友元
#include<iostream>
#include<string>
using namespace std;
class Building
{
//goodgay全局函数是Building类的一个好朋友,可以访问你家的卧室(私有成员)
friend void 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 test()
{
Building building;
goodgay(&building);
}
int main(void)
{
test();
system("pause");
return 0;
}
类做友元
就是将此函数在类的最上面写一个声明,前面加一个friend。
#include<iostream>
#include<string>
using namespace std;
//类做友元
//在前面先声明一下
class Building;
class GoodGay
{
public:
GoodGay();
public:
void visit();//参观函数 访问Building中的属性
Building* building;
};
class Building
{
//GoodGay是Building类的好朋友,可以访问其私有属性
friend class GoodGay;
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//在类外写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
//创建一个Building对象
building = new Building;
}
void GoodGay::visit()
{
cout << "好基友正在访问你的" << building->m_SittingRoom << endl;
cout << "好基友正在访问你的" << building->m_BedRoom << endl;
}
void test()
{
GoodGay gy;
gy.visit();
}
int main(void)
{
test();
system("pause");
return 0;
}
成员函数做友元
告诉编译器 另一个类中的xx成员函数作为本类的好朋友,可以访问私有函数
#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay
{
public:
GoodGay();
void visit();//可以访问Building中私有成员
void visit1();//不可以访问Building中私有成员
Building* builidng;
};
class Building
{
//告诉编译器 GoodGay类中的visit成员函数作为本类的好朋友,可以访问私有函数
friend void GoodGay::visit();
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
builidng = new Building;
}
void GoodGay::visit()
{
cout << "visit正在访问" << builidng->m_SittingRoom << endl;
cout << "visit正在访问" << builidng->m_BedRoom << endl;
}
void GoodGay::visit1()
{
cout << "visit1正在访问" << builidng->m_SittingRoom << endl;
}
void test()
{
GoodGay gg;
gg.visit();
gg.visit1();
}
int main(void)
{
test();
system("pause");
return 0;
}
二、运算符重载
运算符重载的概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型。
2.1 加号运算符重载
作用:实现两个自定义数据类型相加的运算。
例如:两个整型相加编译器知道该怎么进行运算,如果是两个自定义出来的类型,两个Person想加,编译器就不知道该怎么运算了。
#include<iostream>
#include<string>
using namespace std;
//加号运算符重载
class Person
{
public:
//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;
}*/
int m_A;
int m_B;
};
//2.全局函数重载+
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 = p1 + p2;//可以简化成这种形式
//全局函数重载的本质调用
//Person p3 = operator+(p1,p2);
/*cout << p3.m_A << endl;
cout << p3.m_B << endl;*/
//运算符重载也可以发生函数重载
Person p3 = p1 + 10;
cout << p3.m_A << endl;
cout << p3.m_B << endl;
}
int main(void)
{
{
test01();
system("pause");
return 0;
}
总结:
- 对于内置的数据类型的表达式的运算符是不可能改变的
- 不要滥用运算符重载
2.2 左移运算符
作用:可以输出自定义的类型
#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;
}
//利用成员函数重载左移运算符p.operator<<(cout)简化版本p<<cout
//一般我们不会利用成员函数来重载<<运算符,以为无法实现cout在左边
/*void operator<<(ostream &cout,Person &p)
{
cout << p.m_A << endl;
cout << p.m_B << endl;
}*/
private:
int m_A;
int m_B;
};
//只能利用全局函数来重载左移运算符
//ostream : 输出流
ostream& operator<<(ostream& cout, Person& p)
//这样写的本质就是operator<<(cout,p)简化版本就是cout<<p;
{
cout << "m_A = " << p.m_A << endl;
cout << "m_B = " << p.m_B << endl;
return cout;
}
void test()
{
Person p(10, 10);
cout << p << "hello world" << endl;
}
int main(void)
{
test();
system("pause");
return 0;
}
2.3 递增运算符重载
作用:通过重载递增运算符,实现自己的整型数据。
#include<iostream>
using namespace std;
//重载递增运算符
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
MyInteger()
{
m_Num = 0;
}
//重载++运算符——前置
//返回引用是为了一直对一个数据进行递增操作
MyInteger& operator++()
{
++m_Num;
return *this;
}
//重载++运算符——后置
MyInteger operator++(int)//这个int在这里作为占位参数,用来区分前置递增和后置递增
{
MyInteger temp = *this;
m_Num++;
return temp;
//后置递增要返回值,因为如果返回引用,这里相当于返回的是一个局部对象的引用。
//局部对象在当前函数执行完毕之后就被释放掉了,还要返回引用就是非法操作。
}
private:
int m_Num;
};
//全局函数重载左移运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
cout << myint.m_Num << endl;
return cout;
}
void test()
{
MyInteger myint;
cout << "前置递增" << endl;
cout << ++(++myint);
cout << myint;
}
void test02()
{
MyInteger myint;
cout << "后置递增" << endl;
cout << (myint++)++ << endl;
cout << myint << endl;
}
int main(void)
{
test();
test02();
system("pause");
return 0;
}
2.4赋值运算符重载
C++编译器至少给一个类添加4个函数(前三个之前已经讲过了)
#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 test1()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1;
cout << *(p1.m_Age) << endl;
cout << *(p2.m_Age) << endl;
cout << *(p3.m_Age) << endl;
}
int main(void)
{
test1();
system("pause");
return 0;
}
2.5 关系运算符重载
作用:重载关系运算符,可以让两个自定义类型对象进行对比操作
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
//重载==
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;
}
}
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
string m_Name;
int m_Age;
};
void test()
{
Person p1("张三", 20);
Person p2("张三", 20);
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(void)
{
test();
system("pause");
return 0;
}
2.6 函数调用运算符重载
函数调用运算符 () 也可以重载
由于重载后使用的方式非常像函数的调用,因此称为仿函数
仿函数没有固定写法,非常灵活
#include<iostream>
#include<string>
using namespace std;
//函数调用运算符重载
class MyPrint
{
public:
//重载函数调用运算符
void operator()(string text)
{
cout << text << endl;
}
};
class MyAdd
{
public:
int operator()(int a, int b)
{
return a + b;
}
};
void test()
{
MyPrint myprint;
myprint("hello world");
MyAdd myadd;
cout << myadd(1, 2) << endl;
//匿名函数对象——特点:当前行被执行完立即释放
cout << MyAdd()(100, 100) << endl;
}
int main(void)
{
test();
system("pause");
return 0;
}
三、继承
继承是面向对象三大特性之一
有些类与类之间存在特殊的关系,例如下图中:
3.1 继承的基本语法
例如我们看到很多网站中,都有公共的头部,公共的底部,甚至公共的左侧列表,只有中心内容不同。
接下里我们分别利用普通写法和继承写法来实现网页中的内容,看一下继承存在的意义以及好处。
普通实现 :
#include<iostream>
#include<string>
using namespace std;
//普通实现页面
//java页面
class Java
{
public:
void header()
{
cout << "首页、登录注册" << endl;
}
void footer()
{
cout << "帮助中心、交流合作" << endl;
}
void left()
{
cout << "java、python、c++" << endl;
}
void contenet()
{
cout << "java学科视频" << endl;
}
};
class Python
{
public:
void header()
{
cout << "首页、登录注册" << endl;
}
void footer()
{
cout << "帮助中心、交流合作" << endl;
}
void left()
{
cout << "java、python、c++" << endl;
}
void contenet()
{
cout << "python学科视频" << endl;
}
};
class Cpp
{
public:
void header()
{
cout << "首页、登录注册" << endl;
}
void footer()
{
cout << "帮助中心、交流合作" << endl;
}
void left()
{
cout << "java、python、c++" << endl;
}
void contenet()
{
cout << "c++学科视频" << endl;
}
};
void test()
{
cout << "java" << endl;
Java java;
java.header();
java.footer();
java.left();
java.contenet();
cout << endl;
cout << "python" << endl;
Python python;
python.header();
python.footer();
python.left();
python.contenet();
cout << endl;
cout << "cpp" << endl;
Cpp cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.contenet();
}
int main(void)
{
test();
system("pause");
return 0;
}
继承实现 :
#include<iostream>
#include<string>
using namespace std;
//公共页面
class BasePage
{
public:
void header()
{
cout << "首页、登录注册" << endl;
}
void footer()
{
cout << "帮助中心、交流合作" << endl;
}
void left()
{
cout << "java、python、c++" << endl;
}
};
//普通实现页面
//java页面
class Java : public BasePage
{
public:
void contenet()
{
cout << "java学科视频" << endl;
}
};
class Python : public BasePage
{
public:
void contenet()
{
cout << "python学科视频" << endl;
}
};
class Cpp : public BasePage
{
public:
void contenet()
{
cout << "c++学科视频" << endl;
}
};
void test()
{
cout << "java" << endl;
Java java;
java.header();
java.footer();
java.left();
java.contenet();
cout << endl;
cout << "python" << endl;
Python python;
python.header();
python.footer();
python.left();
python.contenet();
cout << endl;
cout << "cpp" << endl;
Cpp cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.contenet();
}
int main(void)
{
test();
system("pause");
return 0;
}
3.2 继承方式
继承的语法——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 = 10;父类中的隐私权限成员,子类访问不到
}
};
void test01()
{
Son1 son1;
son1.m_A = 100;
//son1.m_B = 100;保护权限的内容到了类外就无法访问了
};
//保护继承
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2 :protected Base2
{
void func()
{
m_A = 100;//父类中公共权限的成员,因为是保护继承,到子类中变为保护权限
m_B = 100;//父类中保护权限的成员,保护继承后到了子类还是保护权限。
//m_C = 100;父类中的私有成员子类访问不到
}
};
void test02()
{
Son2 son2;
//保护权限类外访问不到,所以在son2中m_A也访问不到了
}
//私有继承
class Base3
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3 :private Base3
{
void func()
{
m_A = 100;//父类中公共成员,私有继承后,到了子类变为私有成员
m_B = 100;//父类中保护成员,私有继承后,到了子类变为私有成员
//m_C = 100;父类的私有权限成员仍然访问不到
}
};
void test03()
{
Son3 son3;
//私有成员类外访问不到
}
//验证Son3私有继承后成员是否变成了私有属性
class GrandSon3 :public Son3
{
void func()
{
//访问不到父类的私有成员
//到了Son3中m_A,m_B,m_C全是私有成员,子类无法访问
}
};
int main(void)
{
system("pause");
return 0;
}
3.3 继承中的对象模型
问题:从父类继承过来的对象,哪些属于子类对象?
- 父类中所有的非静态成员属性都会被子类继承下去。
- 父类中私有的成员属性是被编译器给隐藏了,因此访问不到,但是确实被继承下去了
#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;
};
//利用开发人员命令提示工具查看对象类型
//跳转盘符 C:
//跳转文件路径: cd 具体路径下
//查看命名
// cl /d1 reportSingleLayout类名 文件名
void test01()
{
//父类中所有的非静态成员属性都会被子类继承下去
//父类中私有的成员属性是被编译器给隐藏了,因此访问不到,但是确实被继承下去了
cout << "sizeof of son:" << sizeof(Son) << endl;//结果是16 = 12 + 4
}
int main(void)
{
test01();
system("pause");
return 0;
}
3.4 继承中构造和析构顺序
子类继承父类后,当创建子类时,也会调用父类的构造函数。
问题:父类和子类的构造函数和析构顺序怎么样的呢?
- 先构造父类,再构造子类
- 先析构子类,再析构父类
- 创建子类对象的同时也会创建一个父类对象。
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "父类的构造函数" << endl;
}
~Base()
{
cout << "父类的析构函数" << endl;
}
};
class Son :public Base
{
public:
Son()
{
cout << "子类的构造函数" << endl;
}
~Son()
{
cout << "子类的析构函数" << endl;
}
};
void test01()
{
Son son;
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结:继承中先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反。 |
3.5 继承同名成员处理方式
问题:当子类与父类出现同名的成员。如何通过子类对象,访问到子类或父类中同名的数据呢?
- 访问子类同名成员,直接访问即可
- 访问父类同名成员,需要加作用域
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "父类同名成员函数调用" << endl;
}
void func(int a)
{
cout << "父类同名重载成员函数调用" << endl;
}
int m_A;
};
class Son :public Base
{
public:
Son()
{
m_A = 200;
}
void func()
{
cout << "子类同名成员函数调用" << endl;
}
int m_A;
};
//同名成员属性处理方式
void test01()
{
Son son;
cout << son.m_A << endl;
//如果要通过子类对象访问到父类中的同名成员,需要加作用域。
cout << son.Base::m_A << endl;
}
//同名成员函数处理方式
void test02()
{
Son son1;
son1.func();//子
son1.Base::func();//父
//如果子类中出现和父类同名的成员函数
//子类的同名成员会隐藏掉父类中所有同名成员函数
//如果想要访问到父类中被隐藏的同名成员函数,需要加作用域
son1.Base::func(10);
}
int main(void)
{
test02();
system("pause");
return 0;
}
总结:
- 子类对象可以直接访问到子类中同名成员
- 子类对象加作用域可以访问到父类同名成员
- 当子类与父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,加作用域可以访问到父类同名函数。
3.6 继承同名静态成员处理方式
问题:继承中同名的静态成员在子类对象上是如何进行访问的呢?
静态成员和非静态成员出现同名,处理方式 一致。
- 访问子类同名成员,直接访问即可
- 访问父类同名成员,需要加作用域
#include<iostream>
using namespace std;
class Base
{
public:
static void func()
{
cout << "父类静态成员函数调用" << endl;
}
static void func(int a)
{
cout << "父类静态成员重载函数调用" << endl;
}
static int m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
static void func()
{
cout << "子类静态成员函数调用" << endl;
}
static int m_A;
};
int Son::m_A = 200;
//同名静态成员
void test()
{
//通过对象访问
Son son1;
cout << "通过对象访问" << endl;
cout << son1.m_A << endl;
cout << son1.Base::m_A << endl;
//通过类名访问
cout << "通过类名访问" << endl;
cout << Son::m_A << endl;
//第一个::代表通过类名方式访问,第二个::代表访问父类作用域下
cout << Son::Base::m_A << endl;
}
//同名静态函数
void test01()
{
//通过对象访问
Son son2;
cout << "通过对象访问" << endl;
son2.func();
son2.Base::func();
//通过类名访问
cout << "通过类名访问" << endl;
Son::func();
Son::Base::func();
//父类同名重载成员函数调用
//子类出现和父类同名的静态成员函数,也会隐藏掉父类中所有同名成员函数(重载)
//如果想访问父类中被隐藏的同名成员,需要加作用域
Son::Base::func(100);
}
int main(void)
{
test();
cout << "我是分割线------" << endl;
test01();
system("pause");
return 0;
}
3.7 多继承语法
C++允许一个类继承多个类
语法:
class 子类:继承方式 父类1,继承方式 父类2
多继承可能会引发父类中有同名成员出现,需要加作用域区分
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 Son :public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01()
{
Son son1;
cout << sizeof(son1) << endl;//16
cout << "第一个父类的m_A:" << son1.Base1::m_A << endl;
cout << "第二个父类的m_A:" << son1.Base2::m_A << endl;
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结:多继承中如果父类中出现了同名情况,子类使用时要加作用域。 |
3.8 菱形继承
菱形继承概念:
两个派生类继承同一个基类,又有某个类同时继承这两个派生类,这种继承称为菱形继承,或者钻石继承。
典型的菱形继承案例
菱形继承问题:
- 羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时,就会产生二义性。
- 草泥马继承动物的数据继承了两份,其实我们应该清楚,这份数据我们只需要一份就可以。
vbptr——虚基类
继承了两个指针,两个指针通过偏移量找到了唯一的数据。
#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 << endl;
cout << st.Tuo::m_Age << endl;
cout << st.m_Age << endl;
//这份数据我们知道,只有一份就可以了,菱形继承导致数据有两份,资源浪费
}
int main(void)
{
test01();
system("pause");
return 0;
}
四、多态
多态是C++面向对象三大特性之一
多态基本概念
多态分为两种:
- 静态多态:函数重载和运算符重载属于静态多态,复用函数名
- 动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态的区别:
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
4.1 多态的基本语法
#include<iostream>
using namespace std;
class Animal
{
public:
//加上virtual变成虚函数,实现地址晚绑定
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.子类重写父类的虚函数
*/
//重写要求:函数返回值类型 函数名 参数列表 完全相同
//动态多态的使用
/*
父类的指针或者引用 指向子类的对象//Animal &animal = cat;
*/
void doSpeak(Animal& animal)//Animal &animal = cat;
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结 :
多态满足条件
- 有继承关关系
- 子类重写父类中的虚函数
多态的使用条件
- 父类指针或引用指向子类对象
重写:函数返回值类型 函数名 参数列表 完全一致称为重写
4.1.2 多态的原理剖析
虚函数(表)指针:
vfptr
v - virtual
f - function
prt - pointer
Cat子类重写前:
重写后
4.2 多态案例–计算器类
案例描述 :
分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类。
多态的优点 :
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护
代码实现
普通实现 :
#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 test()
{
Calculator c;
c.m_Num1 = 10;
c.m_Num2 = 10;
cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
}
int main(void)
{
test();
system("pause");
return 0;
}
多态实现 :
#include<iostream>
#include<string>
using namespace std;
//利用多态实现计算器
//实现计算器抽象类
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;//父类指针指向子类对象
cout << "abc = " << abc << endl; //abc是指针地址 int *p = new int(10)
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 = " << abc << endl; //指针的类型没有变,但是指针的内存和数值都销毁了
cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
delete abc;
}
int main(void)
{
test();
system("pause");
return 0;
}
4.3 纯虚函数和抽象类
在多态中,通常父类汇中虚函数的实现是毫无意义的,主要都是调用子类重写的内容。
因此可以将虚函数改为纯虚函数。
纯虚函数语法 virtual 返回值类型 函数名 (参数列表) = 0;
当类中有了纯虚函数,这个类也称为抽象类。
抽象类特点:
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数,否则也属于抽象类
4.4 多态案例2——制作饮品
案例描述:制作饮品的大致流程为:煮水-冲泡-倒入杯中-加入辅料
利用多态技术实现本案例,提供抽象制作饮品基类,提供子类制作咖啡和茶水。
#include<iostream>
using namespace std;
//多态案例-制作饮品
class AbstractDrinking
{
public:
//煮水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void Pour() = 0;
//加入辅料
virtual void PutSomething() = 0;
//制作饮品
void makeDrink()
{
Boil();
Brew();
Pour();
PutSomething();
}
};
//制作咖啡
class Coffee :public AbstractDrinking
{
public:
//煮水
virtual void Boil()
{
cout << "把水煮开" << endl;
}
//冲泡
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
//倒入杯中
virtual void Pour()
{
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething()
{
cout << "加入糖和牛奶" << endl;
}
};
//制作茶水
class Tea :public AbstractDrinking
{
public:
//煮水
virtual void Boil()
{
cout << "把矿泉水煮开" << endl;
}
//冲泡
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
//倒入杯中
virtual void Pour()
{
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething()
{
cout << "加入柠檬" << endl;
}
};
//制作函数
void DoWork(AbstractDrinking* abs)//父类指针指向子类对象AbstractDrinking* abs = new Coffee;
{
abs->makeDrink();
delete abs;//手动释放
//堆区的数据被销毁了但是指针的类型没变
}
//制作
void test()
{
DoWork(new Coffee);
cout << "------我是分割线------" << endl;
DoWork(new Tea);
}
int main(void)
{
test();
system("pause");
return 0;
}
4.5 虚析构和纯虚析构
多态使用的时候,如果子类中有属性开辟到堆区,那么父类指针在释放的时无法调用到子类的析构代码
#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)
{
m_Name = new string(name);
}
virtual void speak()
{
cout << "Cat的构造函数调用" << endl;
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(void)
{
test01();
system("pause");
return 0;
}
总结:
- 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象问题
- 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构
- 拥有纯虚析构函数的类也属于抽象类
4.6 多态案例3-电脑组装
案例描述 :
电脑主要组成部件为CPU(用于计算),显卡(用于显示),内存条(用于存储),将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口,测试时组装三台不同的电脑进行工作.
#include<iostream>
using namespace std;
//抽象不同零件类
//抽象cpu
class CPU
{
public:
//抽象的计算函数
virtual void calculate() = 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;
m_vc = vc;
m_mem = mem;
}
//提供一个工作的函数
void work()
{
//让零件工作起来,调用他的接口
m_cpu->calculate();
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;//内存条零件指针
};
//具体的厂商
//Intel
class IntelCPU :public CPU
{
public:
virtual void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class IntelVideoCard :public VideoCard
{
public:
virtual void display()
{
cout << "Intel的显卡开始显示了" << endl;
}
};
class IntelMemory :public Memory
{
public:
virtual void storage()
{
cout << "Intel的内存条开始存储了" << endl;
}
};
//具体的厂商
//Lenovo
class LenovoCPU :public CPU
{
public:
virtual void calculate()
{
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()
{
//一台电脑零件
CPU* intelcpu = new IntelCPU;
VideoCard* videocard = new IntelVideoCard;
Memory* memory = new IntelMemory;
//创建第一台电脑
Computer* computer1 = new Computer(intelcpu, videocard, memory);
computer1->work();
delete computer1;
cout << "------我是分割线------" << endl;
//组装第二台电脑
Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
computer2->work();
delete computer2;
cout << "------我是分割线------" << endl;
//组装第三台电脑
Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
computer3->work();
delete computer3;
}
int main(void)
{
test01();
system("pause");
return 0;
}
五、文件操作
程序运行时,产生的数据都属于临时数据,程序一旦运行结束就会被释放。
通过文件可以将数据持久化。
C++中对文件进行操作需要包含头文件< Fstream>:
文件类型分为两种:
- 文本文件-文件以文本的ASCII码形式存储在计算机中
- 二进制文件-文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂他们
操作文件的三大类
- ofstream:写操作
- ifstream:读操作
- fstream:读写操作
5.1 文本文件
5.1.1 写文件
写文件的步骤
- 包含头文件——#include< fstream>
- 创建流对象——ofstream ofs;
- 打开文件——ofs.open(“文件路径”,打开方式)
- 写数据——ofs<<“写入的数据”;
- 关闭文件——ofs.close();
文件打开方式:
注意:文件打开方式可以配合使用,利用|操作符
例如:用二进制方式写文件
ios::binary | ios::out
#include<iostream>
#include<fstream>
using namespace std;
//文本文件写文件
void test01()
{
//1.包含头文件
//2.创建流对象
ofstream ofs;
//3.指定打开方式
ofs.open("test.txt", ios::out);//如果不指定文件路径,默认和你项目的文件路径一样
//4.写内容
ofs << "姓名:张三" << endl;
ofs << "性别:男" << endl;
ofs << "年龄:18" << endl;
//5.关闭文件
ofs.close();
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结:
- 文件操作必须包含头文件fstream
- 读文件可以利用ofstream,或者fstream类
- 打开文件时候需要指定操作文件的路径,以及打开方式
- 利用<<可以向文件中写数据
- 操作完毕,要关闭文件
5.1.2 读文件
读文件操作与写文件步骤相似,但是读取方式比较多
读文件操作步骤如下:
- 包含头文件——#include< fstream>
- 创建流对象——ifstream ifs;
- 打开文件并判断文件是否打开成功——ifs.open(“文件路径”,打开方式);
- 读数据——四种方式读取
- 关闭文件——ifs.close();
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
void test01()
{
//1.包含头文件
//2.创建流对象
ifstream ifs;
//3.打开文件,并且判断是否打开成功
ifs.open("test.txt", ios::in);
if (!ifs.is_open())
{
cout << "文件打开失败了" << endl;
return;
}
//4.读数据
//第一种
/*char buf[1024] = { 0 };
while (ifs>>buf)
{
cout << buf << endl;
}*/
//第二种
/*char buf[1024] = { 0 };
while (ifs.getline(buf,sizeof(buf)))
{
cout << buf << endl;
}*/
//第三种
/*string buf;
while (getline(ifs,buf))
{
cout << buf << endl;
}*/
//第四种-不推荐
char c;
while ((c = ifs.get()) != EOF)//EOF——end of file
{
cout << c;
}
ifs.close();
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结
- 读文件可以利用ifsteam,或者fstream类
- 利用is_open函数可以判断是否打开成功
- close关闭文件
5.2二进制文件
以二进制的方式对文件进行读写操作
打开方式主要为ios::binary
5.2.1 写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型:
ostream& wirte(const char* buffer,int len);
参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include<iostream>
#include<fstream>
using namespace std;
//二进制写文件
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test01()
{
//1.包含头文件
//2.创建头文件
ofstream ofs("person.txt", ios::out | ios::binary);
//3.打开文件
//ofs.open("person.txt",ios::out | ios::binary);
//4.写文件
Person p = { "张三",18 };
ofs.write((const char*)&p, sizeof(Person));
//5.关闭文件
ofs.close();
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结:
- 文件输出流对象,可以通过write函数,以二进制的方式写数据
5.2.2 读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型:
istream& read(char * buffer,int len);
参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include<iostream>
#include<fstream>
using namespace std;
//二进制读文件
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test01()
{
//1.包含头文件
//2.创建流对象
ifstream ifs;
//3.打开文件&判读文件是否打开成功
ifs.open("person.txt", ios::in | ios::binary);
if (!(ifs.is_open()))
{
cout << "打开失败" << endl;
return;
}
//4.读文件
Person p;
ifs.read((char*)&p, sizeof(Person));
cout << "姓名:" << p.m_Name << " " << "年龄:" << p.m_Age << endl;
//5.关闭文件
ifs.close();
}
int main(void)
{
test01();
system("pause");
return 0;
}
总结
:
:
二维数组定义的四种方式: |