《面向对象程序设计》

课程大作业

（ 2021 / 2022学年第二学期）. 1

第一章绪论. 1

1.1面向对象程序特点与目标. 1

1.2面向对象程序知识架构. 1

第二章面向对象程序设计关键. 2

2.1引用与重载. 2

2.1.1引用做函数参数. 2

2.1.2引用做函数返回值. 3

2.1.3引用的本质. 4

2.1.4常量引用. 5

2.1.5函数重载. 6

2.2封装. 8

2.2.1访问权限. 8

2.2.2成员属性私有化. 9

2.3对象特性. 11

2.3.1构造函数. 11

2.3.2析构函数. 12

2.3.3拷贝构造函数. 13

2.3.4静态成员. 16

2.4this指针. 18

2.5友元. 22

2.5.1全局函数做友元. 22

2.5.2友元类. 23

2.5.3成员函数做友元. 25

2.6继承. 27

2.6.1继承方式. 31

2.6.2同名成员处理. 35

2.6.3菱形继承. 37

2.7多态. 38

2.7.1多态基本语法. 38

2.7.2纯虚函数与抽象类. 40

2.7.3虚析构与纯虚析构. 41

2.8文件操作. 46

2.8.1文本文件. 46

2.8.2二进制文件. 49

第三章面向对象应用. 51

3.1矩阵类设计及应用. 51

3.2银行账号管理系统设计及应用. 55

结束语. 72

第一章绪论

1.1面向对象程序特点与目标

面向对象程序设计的主要特点为：抽象，封装，继承，多态。①抽象，也就是将具体的实例化特点抽样出共同的属性与功能，例如人类有共有的属性，比如：年龄，姓名，性别等。但是每个人却又彼此不同，每个人具有自己的属性与能力，每一个人都是整个人类的某一个对象②封装，将有关数据与操作封存在对象之中，形成一个独立的个体，避免与其他个体产生冲突，互相干扰。并且将一部分属性进行私有化，保障数据信息安全③继承，通过类似于父子的继承方式，精简代码，减少相应属性操作代码重复冗杂④多态，在继承的前提下，产生更多不同的其他派别，不同对象对于同一消息会产生不同的响应。

1.2面向对象程序知识架构

以对象为核心，通过设置对象的属性，并对其进行封装，改变对象的权限范围以及应用范围，解决现实的问题。通过多个类，使单个能够起到作用的子对象组合成符合多功能的统一对象组合，通过继承使单一子对象具有向下发展向外拓展的可持续发展可能性，多态则保证了向外拓展的多样性，也同时保证在程序运用使的普适性广泛性

第二章面向对象程序设计关键

2.1引用与重载

2.1.1引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：简化指针修改实参

函数参数主要有值传递，地址传递以及引用三种方式，值传递中形式参数的改变不会对实际参数产生影响，地址传递中通过取地址与指针的方式，实现了形式参数对实际参数的改变。而由于指针传递的方式较为难以理解，并且指针传递会开辟一块新的内存空间，所以我们采用引用的方式实现对实际参数的改变。

代码实现；

#include<iostream>
using namespace std;
//值传递,形式参数改变，实际参数不改变
void trans01(int a,int b)
{
int temp = a;
a = b;
b = temp;
}
//地址传递，实际参数改变
void trans02(int *a,int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
//引用，相当于取别名，a就是m，b就是n
void trans03(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int m, n;
m = 1;
n = 2;
trans01(m,n);
trans02(&m,&n);
trans03(m,n);
system("pause");
return 0;
}

可以明显的看出，引用实现实参改变的方法，函数主体与值传递相同，所以我们可以将引用理解为取别名，也就是给实参取一个小名，小名变化大名也变化。简化了函数形式参数的运用，提升了代码的易读程度，降低了编写难度。

2.1.2引用做函数返回值

作用：引用是可以作为函数的返回值存在的

注意：不要返回局部变量引用

用法：函数调用作为左值

用引用作为函数的返回值的最大好处是在内存中不产生返回值的副本，直接将变量返回给函数，避免临时变量的产生。当变量属于类的对象时，这样还可以避免调用拷贝构造函数在内存中创建临时对象的过程，提高了程序的时间和空间使用效率

代码实现：

#include<iostream>
using namespace std;
//局部变量不能作为函数的返回值
int& test01()
{
int a = 10;
//作为局部变量，储存在栈区，函数运行结束后即释放
return a;//返回局部变量引用
}
//引用函数可以作为左值
int& test02()
{
static int a = 20;
//作为静态局部变量，储存在全局区，在程序运行结束后自动释放
return a;//返回静态变量引用
}
int main()
{
int &ret=test01();
cout << ret << endl;//10
cout << ret << endl;//2033293704
//函数值第一次打印正确，第二次打印为乱码，是由于编辑器对返回值自动做了一次保存
//而第二次打印的时候就不会再次保存了
int& ret2 = test02();
cout << ret2 << endl;//20
cout << ret2 << endl;//20
test02() = 2000;
//如果函数作为左值，则必须返回引用
//函数可以作为左值，因为函数返回值与ret2是同一事物，即a与ret2为同一主体的不同名字
cout << ret2 << endl;//2000
cout << ret2 << endl;//2000
ret2 = 100;
cout << ret2 << endl;//100
cout << test02() << endl;//100
system("pause");
return 0;
}

2.1.3引用的本质

引用的本质就是一个指针常量，引用一旦初始化之后，就不可以发生改变。

表面上：Int &ref=a;

实际上：int * const ref =&a;

代码实现：

#include<iostream>
using namespace std;
void func(int &ref)
{
ref = 100;//ref为引用，转换为*ref=100
}
int main()
{
int a = 10000;
int& ref = a;
//编辑器发现引用，转换为int * const ref=&a;
//由于ref为有关键字const修饰，所以为固定对象不可修改
ref = 20;//*ref=20;
cout << "a=" << a << endl;//20
cout << "ref=" << ref << endl;//20
func(a);
cout << ref << endl;//100
system("pause");
return 0;
}

2.1.4常量引用

引用无法指向一个常量，必须指向一个栈区或者堆区的可变数据。引用本省需要一个合法的内存空间，因此例如：int &a=10;这样的代码是错误的

而Const int &a=10;是正确的

编译器会将其自动转换为

int temp=10;
Const int &a=temp;

函数中常常利用常量引用防止误操作修改实参，引用的使用常见，通常是用来就是形式参数

代码实现：

#include<iostream>
using namespace std;
void test01(int &ref)
{
ref = 1000;
cout << "ref="<<ref << endl;
}
void test02(const int& ref2)
//实现输出，避免变量改变导致打印值变化
{
//ref2 = 10;//这里会报错，因为ref有const修饰，不可修改
cout << "ref2=" << ref2 << endl;
}
int main()
{
int a = 10;
test01(a);//1000
test02(a);//1000
system("pause");
return 0;
}

2.1.5函数重载

函数默认参数：void func(int a,int b=10){}

函数的默认参数即是给形式参数一个初值，如果函数体中没有给该形式参数赋值，则使用函数定义中的默认参数，有赋值则采用赋值值。①如果某个位置参数有默认值，那么从这个位置往后，从左向右都必须有默认值②如果函数的声明有默认值，那么函数实现的时候就不能有默认参数。

函数占位参数：void func(int a,int){}

函数重载满足条件：①在同一个作用域下②函数名称相同③函数参数类型不同或者个数不同或者顺序不同

注意：函数的返回值不可以作为函数重载的条件

代码实现：

#include<iostream>
using namespace std;
void func()
{
cout << "func的调用" << endl;
}
void func(int a)
{
cout << "func(int a)的调用" << endl;
}
void func(double a)
{
cout << "func(double a)的调用" << endl;
}
void func(int a, int b)
{
cout << "func(int a,int b)的调用" << endl;
}
void func(double a, int b)
{
cout << "func(double a,int b)的调用" << endl;
}
int main()
{
func();
func(1);
func(1.0);
func(1, 1);
func(1.0, 1);
system("pause");
return 0;
}

函数重载的注意事项：

1）引用作为函数重载的条件

代码实现：

#include<iostream>
using namespace std;
//引用作为函数参数
void fun(int& a)
{
cout << "fun(int& a)的调用" << endl;
}
void fun(const int& a)
{
cout << "fun(const int& a)的调用" << endl;
}
int main()
{
int a = 10;
fun(a);
fun(10);
system("pause");
return 0;
}

2）函数重载碰到函数默认参数

要尽量减少函数重载与默认参数同时出现，避免出现同一个函数调用适用于多个函数的情况，避免产生生成错误，出现二义性导致崩溃

代码实现：

#include<iostream>
using namespace std;
//函数重载碰到默认参数
void func(int a)
{
cout << "func(int a)的调用" << endl;
}
void func(int a, int b = 10)
{
cout << "func(int a,int b=10)的调用" << endl;
}
int main()
{
int a = 10;
//func(a);
//同时满足上面两个函数，编译器无法判断，出现二义性
system("pause");
return 0;
}

2.2封装

2.2.1访问权限

将类内分为公共权限（public）、保护权限（protected）、私有权限（private）

公共权限：类内可以访问，类外也可以访问

保护权限：类内可以访问，类外不能访问

私有权限：类内可以访问，类外不能访问

代码实现：

#include<iostream>
using namespace std;
class human
{
public://公共权限
string h_name;
protected://保护权限
string h_car;
private:// 私有权限
int h_password;
public:
void func()
{
h_name = "张三";
h_car = "拖拉机";
h_password = "12345";
}
};
int main()
{
human s1;
s1.h_name = "李四";
//s1.h_car = "奔驰";//显示不可访问，因为car属于保护权限内容，在类外访问不到
//s1.h_passworld = "123";//同样显示不可访问，私有权限类外不可访问
system("pause");
return 0;
}

注意：class与struct的区别

Class中的默认权限是私有权限，而struct中的默认权限是公共权限

代码实现：

#include<iostream>
using namespace std;
//class默认权限是私有权限private
//struct默认权限是公共权限public
class f1
{
int m_a;//私有
};
struct f2
{
int m_a;//公共
};
int main()
{
f1 f1;
//f.m_a = 100;//报错不可访问，因为class默认为私有权限
f2 f2;
f2.m_a = 100;//默认权限为公共，所以可以访问
system("pause");
return 0;
}

2.2.2成员属性私有化

优点：①将所有成员属性设置为私有，可以自己控制读写权力②对于写权限，我们可以检测数据的有效性，可以在读写中设置if等选择语句进行判别

代码实现：

#include<iostream>
#include<string>
using namespace std;
class person
{
public://将成员属性私有化，需要在公共权限提供接口
//写姓名
void setname(string name)
{
m_name = name;
}
//读姓名
string getname()
{
return m_name;
}
int getage()
{
int m_age = 16;
return m_age;
}
void setlover(string lover)
{
m_lover = lover;
}
//输入财产
void setmoney(int money)
{
m_money = money;
}
//输出财产
int getmoney()
{
if (m_money < 0 ||m_money>1000)
{
cout << "财产不正常" << endl;
return 0;
}
return m_money;
}
private:
string m_name;//姓名可读可写
int m_age;//年龄只读
string m_lover;//爱人只写
int m_money;//财产可读可写
};
int main()
{
person d1;
d1.setname("张三");
//d1.m_name = "张三"; 不可以使用这条语句，因为m_name属于私有权限
cout << "姓名：" << d1.getname() << endl;
//d1.getage = 18;
//d1.getage("18");
//这两种都是不可以的，因为getage没有形参也就没有输入，不可以赋值
cout << "年龄：" << d1.getage() << endl;
d1.setlover("xx");
//cout << "爱人" << d1.setlover << endl;//报错因为函数无返回值
d1.setmoney(100);
cout << "财富：" << d1.getmoney() << endl;
system("pause");
return 0;
}

2.3对象特性

2.3.1构造函数

构造函数：主要作用在创建对象时，为对象赋初值

对象的初始化与清除也是十分重要的问题，在对象的开始默认使用构造函数，完成对对象的初始化工作，如果不主动提供构造函数，则编译器会自动强制使用编译器自带的构造函数，为空实现

注意：①构造函数没有返回值，也不写void②函数名称与类名相同③构造函数可以有参数，因此也可以函数重载④程序在调用时会自动调用构造函数，无需手动调用，且程序允许一次只会调用一次

代码实现：

#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "Person构造函数的调用" << endl;
}
}
void test01()
{
Person P;//在栈区上的数据，函数执行完毕后内存空间释放
}
int main()
{
test01();
system("pause");
return 0;//main函数运行完毕后也会执行析构函数，只是由于对话框关闭显示时间极短
}
*/

构造函数分为无参构造函数（默认构造函数）和有参构造函数

1）无参：Person()

调用无参构造：person p1

调用默认构造时不加（），否则编译器会认为是一个函数的声明

2）有参：person(int a)

调用有参构造：person p2（10）

2.3.2析构函数

析构函数：主要作用在销毁对象是，执行清理

对象的初始化与清除也是十分重要的问题，在对象的结束默认使用析构函数，完成对对象的清理工作，如果不主动提供析构函数，则编译器会自动强制使用编译器自带的析构函数，为空实现

注意：①析构函数没有返回值，也不写void②函数名称与类名相同，并在名称前面加~③析构函数不可以有参数，无法发生重载④程序在对象销毁之前会自动调用析构函数，无需手动调用，且程序结束一次只会调用一次

代码实现：

#include<iostream>
using namespace std;
class Person
{
public:
~Person()
{
cout << "~Person析构函数的调用" << endl;
}
};
void test01()
{
Person P;//在栈区上的数据，函数执行完毕后内存空间释放
}
int main()
{
test01();
system("pause");
return 0;//main函数运行完毕后也会执行析构函数，只是由于对话框关闭显示时间极短
}

2.3.3拷贝构造函数

用法：①使用一个已经创建完毕的对象来初始化一个新的对象②以值传递的方式给函数参数传值③以值方式返回局部对象

编辑器默认的拷贝构造函数是一个浅拷贝，直接进行值传递拷贝

代码实现：

#include<iostream>
using namespace std;
class person
{
public:
person()
{
cout << "person默认构造函数的调用" << endl;
}
~person()
{
cout << "person析构函数的调用" << endl;
}
person(int age)
{
cout << "有参构造函数的调用" << endl;
m_age = age;
}
person(const person& p)
{
cout << "拷贝构造函数的调用" << endl;
m_age = p.m_age;
}
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 dowork1()
{
person p1;
return p1;
//由于创建临时对象，此时p1已经消失，return的是p1的克隆体，person p接收的也是克隆体的数据
}
void test03()
{
person p = dowork1();//相当于person p=person(p1)
}
int main()
{
//test01();
//test02();
test03();
system("pause");
return 0;
}

运行结果：

深拷贝与浅拷贝

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

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

当我们对p2.m_height进行析构函数释放空间时，堆区内存以及被释放掉了，此时p1再次执行析构函数释放堆区内存，会导致同一块内存区域被连续释放两次，为非法操作。因此我们引入深拷贝，使p1，p2在堆区分别开辟一块空间，这样数据释放时就不会重复

编译器提供的浅拷贝（默认实现）：

person(const person& p)
{
cout << "person拷贝构造函数调用" << endl;
m_age = p.m_age;
m_height=p.m_height
}

自己实现深拷贝：

person(const person& p)
{
cout << "person拷贝构造函数调用" << endl;
m_age = p.m_age;
m_height = new int(*p.m_height);
}

代码实现：

//深拷贝
//深拷贝与浅拷贝的区别在于浅拷贝直接进行值复制传递，两次传递共用一个地址，所以在析构函数的释放过程中会重复释放堆区内存
//浅拷贝地址相同而深拷贝地址不同
#include<iostream>
using namespace std;
class person
{
public:
person(int age, int hight)
{
m_age = age;//全局区中的内存数据
m_hight = new int(hight);//在堆区开辟一个数据hight，并将这个hight的值赋值给m_hight，这里的m_hight为指针变量
cout << "person有参构造函数调用" << endl;
}
~person()
{
//析构代码通常将堆区开辟的数据进行释放
if (m_hight != NULL)
{
delete m_hight;
m_hight = NULL;//防止野指针出现
}
cout << "person析构函数调用" << endl;
}
person(const person& p)//构造函数重载，通过形式参数的改变，重新构造拷贝函数，其中的参数为地址且为常量
{
cout << "拷贝函数调用" << endl;
m_age = p.m_age;
m_hight = new int(*p.m_hight);//深拷贝，开辟一个堆区空间用于存放m_hight的地址，并用m_hight来接收
//m_hight=p.m_hight,这里是浅拷贝方法，直接值拷贝
}
int m_age;
int* m_hight;//由于接收的是堆区中存放的地址，所以为整型指针变量
};
void test01()
{
person p1(18, 170);
cout << "p1年龄为" << p1.m_age << "\t" << "p1身高为" << *p1.m_hight << endl;
person p2(p1);
cout << "p2年龄为" << p2.m_age << "\t" << "p2身高为" << *p2.m_hight << endl;
}
int main()
{
test01();
system("pause");
return 0;
}

2.3.4静态成员

静态成员变量：①所有对象共享一份数据②在编译阶段分配内存③类内声明类外初始化

静态成员函数：①所有对象共享同一个函数②静态成员函数只能访问静态成员变量

非静态成员变量必须要对象特定的类，假如同时有p1,p2，则无法确定非静态成员变量m_b是p1还是p2的

通过对象访问静态成员函数

通过类名访问静态成员函数

Person p；

P．func（）；

Person：：func（）

代码实现：

//类内的成员变量和成员函数分开储存
//只有非静态成员变量才属于类的对象上
#include<iostream>
using namespace std;
class person
{
public:
int m_A;//非静态成员变量,属于类的对象上
static int m_B;//静态成员变量，不属于类的对象上，不增加类的内存空间
void func1()//非静态成员函数，不属于类的对象上,不增加类的内存空间
{
}
static void func2()//静态成员函数，不属于类的对象上，不增加类的内存空间
{
}
};
int person::m_B = 200;
void test01()
{
person p1;
//空对象占用内存空间为 1
//c++编译器会给每个空对象也分配一个字节空间
//用于区分空对象占内存的位置，每个空对象也会有一个独一无二的内存地址
cout <<" sizeof p1 =" <<sizeof(p1)<< endl;
}
void test02()
{
person p2;
cout << "sizeof p2 =" << sizeof(p2) << endl;//4
}
class ani
{
public:
double m_M;
};
void test03()
{
ani a1;
cout << "sizeof a1 =" << sizeof(a1) << endl;//8,因为m_M为双精度型
}
int main()
{
test01();
test02();
test03();
system("pause");
return 0;
}

静态成员函数同样具有访问权限，private私有作用域下类外无法访问

2.4this指针

每一个非静态成员函数只会产生一份函数实例，也就是说多个同类型的对象会使用同一块代码。为了区分对象，引入this指针，指向被调用的成员函数所属的对象

P1	This指向p1
P2	This指向p2
P3	This指向p3

用途：①当形参与成员变量同名时，使用this指针来区分，this指向的为属性中定义的，未被指向的为形式参数

②在类的非静态成员函数中返回对象本身，用return *this

代码实现：

#include<iostream>
using namespace std;
class person
{
public:
person(int age)
{
age = age;
}
int age;
};
void test01()
{
person p1(18);
cout << "p1的年龄为:" << p1.age << endl;
//程序运行出错，显示乱码，形式参数与属性同名
}
class high
{
public:
high(int tall)
{
//this指针指向被调用的成员函数所属的对象
this->tall = tall;
}
high& addhigh01(high &h)
//当函数的返回值为void时，此函数不能被连续调用
//例如：h3.addhigh(h2).addhigh(h1)是错误的
{
this->tall += h.tall;
return *this;//用*this做函数的返回值
}
high addhigh02(high &h)
{
this->tall += h.tall;
return *this;
}
int tall;
};
void test02()
{
high h1(170);//h1调用有参构造函数，所以this指向h1
high h2(200);
cout << "h1的高度为:" << h1.tall << endl;//170
cout << "h2的高度为:" << h2.tall << endl;//200
}
void test03()
{
high h3(120);
high h4(150);
h4.addhigh01(h3);
cout << "h4的身高加上h3的身高后为：" << h4.tall << endl;
high h5(200);
h5.addhigh01(h4).addhigh01(h3);
//可以无限向后追加，是链式编程思想
cout << "采用addhigh01，返回值为high&的函数" << endl;
cout << "h5+(h4+h3)+h3后身高为：" << h5.tall << endl;
}
void test04()
{
high m1(50);
high m2(100);
m1.addhigh02(m2).addhigh02(m2);
cout << "m1.addhigh02(m2).addhigh02(m2);后m1身高为：" << m1.tall << endl;
//150，m1=50+100，后面的一个100加到m1'上使得m1’=150+100，m1’为m1的拷贝复制所得
//addhigh02的函数返回值是high，是值传递，为拷贝构造函数，每调用一次都会创造一个新的对象
high m3(50);
high m4(100);
m3.addhigh01(m4).addhigh01(m4);
cout << "m3.addhigh01(m4).addhigh01(m4)后m3身高为：" << m3.tall << endl;
//250,m3=50+100+100，从始至终都是一个对象m3
//addhigh01的函数返回值是high&，是引用的方式返回，不会创建新的对象
}
int main()
{
test01();//显示为乱码，因为三个age编辑器认为是同一个
test02();
test03();
test04();
system("pause");
return 0;
}

This为类自带指针，所以返回值类型为类名，返回对象本身用*this

返回值类型

Void

High

High&

只可调用一次，由于无返回值，所以不能连续调用

可以无限的向后叠加运算，但是返回值类型为值传递，每次向后运算都会增加一个新的对象

用引用的方式返回，返回为本体，之后不论进行多少次调用运算，仍然是对同一个进行运行，也就是对初始的类名运算

X1=1+1

X2=x1+1=2+1

X3=x2+1=3+1

X=1+1+1+1+…

空指针：

空指针：类型为void的指针，void*可以指向任意类型的对象

说明指针与地址值有关，只是不知道储存在这个地址上的对象的类型

支持：①与另一指针比较②向函数传递void*指针③函数返回void*指针④给另一个void*指针赋值

不支持：①解引用，无法获得指向对象的值②不能进行移位操作等指针运算

//空指针也可以调用成员函数
#include<iostream>
using namespace std;
//补充
//野指针：指向一个非法的或以及销毁的内存指针，指针变量没有被初始化，不知道指向地址为什么
//如果指针被free释放或者delete删除后，指针所指的内存被释放，没有改变指针的值，指针就落为野指针
//可以理解为亲戚搬家后还留着旧地址
class person
{
public:
person(int age)
{
m_age = age;
}
void showclassname()
{
cout << "this is person class" << endl;
}
void showpersonage()
{
cout << "age=" << this->m_age << endl;//this是类内默认的隐含操作
}
int m_age;
};
void test01()
{
person* p = NULL;//p是一个空指针，与野指针不同
//p->m_age = 18;
//代码崩溃，p是一个空指针，无法对p内的m_age赋值，因为指针内部为空，无属性
p->showclassname();
//p->showpersonage();
//代码崩溃，读取访问权限错误,this指向一个空指针，空的值并没有产生任何属性，所以无法访问m_age
}
int main()
{
test01();
system("pause");
return 0;
}

野指针并无赋值，空指针赋值为空，两者有本质上的区别

2.5友元

2.5.1全局函数做友元

友元，让一个函数或者类可以访问另一个类中的私有成员。关键字：friend

比如生活中的客厅允许所有的客人进入，而卧室是私有的，只有自己允许进入，但是也可以允许好朋友进入

注意：

（1）定义友元函数：在类中定义函数的声明，并在前加friend

（2）友元函数主要解决访问类中的私有成员变量的问题

（3）函数可以被定义为多个类的友元函数

（4）友元函数不属于任何类，不是类的成员函数

（5）友元函数不能被const修饰

（6）友元函数可以在类定义的任何地方声明，不受类访问限定符限制

代码实现：

//友元
//友元目的就是让一个函数或者类访问另一个类中的私有成员
//关键字friend
#include<iostream>
using namespace std;
class building
{
//通过友元关键字friend，允许homie访问类内私有权限
friend void homie(building* building);
public:
building()
{
m_sittingroom = "公共客厅";
m_bedroom = "私有卧室";
}
public:
string m_sittingroom;
private:
string m_bedroom;
};
void homie(building* building)//全局函数
{
cout << "homie全局函数正在访问" << building->m_sittingroom << endl;
//cout << "homie全局函数正在访问" << building->m_bedroom << endl;//单独使用会报错
cout << "homie全局函数正在访问" << building->m_bedroom << endl;
}
void test01()
{
building building1;
homie(&building1);
}
int main()
{
test01();
system("pause");
return 0;
}

2.5.2友元类

友元类，实际上就是把这个类定义为另一个类的友元（即A类是B类的友元，A可以访问B中的私有成员变量以及保护成员变量）

注意：

（1）友元关系不具有传递性
（2）友元关系不具备双向性（我是你的友元类，我可以访问你，但你不能访问我）
（3）若要相互访问对方类的成员，则要双方都要定义对方为自己的友元
（4）内部类就是外部类的友元类（内部类：如果一个类定义在另一个类的内部，这个内部类就叫做内部类）

代码实现：

#include<iostream>
using namespace std;
class building;
class homie
{
public:
homie();//创建构造函数homie，作用是
public:
void visit();//设置函数，访问building中的属性
building* m_building;//这里的building为指针变量
};
class building
{
friend class homie;
//使得homie类可以访问building中的私有成员
public:
building();
public:
string m_sittingroom;//公有客厅
private:
string m_bedroom;//私有卧室
};
//类外写成员函数
building::building()
{
m_sittingroom = "公有客厅";
m_bedroom = "私有卧室";
}
homie::homie()
{
m_building = new building;
//给指针变量赋初值，这个初值为building类型，存放在堆区
}
void homie::visit()
{
cout << "homie类正在访问" << m_building->m_sittingroom << endl;
cout << "homie类正在访问" << m_building->m_bedroom << endl;
}
void test01()
{
homie h1;
h1.visit();
}
int main()
{
test01();
system("pause");
return 0;
}

2.5.3成员函数做友元

注意：需要提前声明要使用的类；必须将先定义的类的成员函数作为后定义的类的友元函数，如果调换顺序会出现语法错误

代码实现：

#include<iostream>
using namespace std;
class Building;//前置声明
class homie
{
public:
homie();
~homie();
void visit_l();
void visit_b();
Building* building;
//指针使用原因：为了building能访问homie的成员函数
//所以需要先写homie，又因为homie需要访问building类，所以只能再前面加上类的声明
//前置声明由于没有实现，所以不能使用对象，只能使用指针
//可以理解为在building类的创建之前，创建了一个类名为building的变量，需要使用指针来指向
};
class Building
{
friend void homie::visit_l();
public:
Building();
public:
string m_livingroom;
private:
string m_bedroom;
};
Building::Building()//类外设置析构函数，初始化
{
m_livingroom = "客厅";
m_bedroom = "卧室";
}
homie::homie()
{
building = new Building;
//创建一个对象Builing在堆区，并且用指针builing维护
//在堆区开辟数据，需要程序员手动释放内存
}
homie::~homie()
{
delete building;
building = NULL;
}
void homie::visit_l()
{
cout << "visit_l正在访问" <<building->m_livingroom << endl;//正在访问building下的客厅
cout << "visit_l正在访问" << building->m_bedroom << endl;
//在Building前设置homie的成员函数visit_l为友元，所以可以访问私有权限下的m_bedroom
}
void homie::visit_b()
{
cout << "visit_b正在访问" << building->m_livingroom << endl;
//cout << "visit_b正在访问" << building->m_bedroom << endl;
//没有使成员函数visit_b做Building的友元，所以building无法访问visit_b函数
}
void test01()
{
homie h1;
h1.visit_l();
h1.visit_b();
}
int main()
{
test01();
system("pause");
return 0;
}

2.6继承

定义不同的类时，下级除了具有自己的特点，还具有上一级的共性，通过继承的技术减少代码重复

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

例如：class java : public normal

对于重复对象，初始基础做法：

#include<iostream>
using namespace std;
//以下三个类大部分成员函数相同，仅仅在top部分出现不同
//因此我们可以使用继承的方法，减少重复
class java
{
public:
void base()
{
cout << "代码程序基础" << endl;
}
void rise()
{
cout << "代码程序提高" << endl;
}
void top()
{
cout << "java语言关键" << endl;
}
};
class c
{
public:
void base()
{
cout << "代码程序基础" << endl;
}
void rise()
{
cout << "代码程序提高" << endl;
}
void top()
{
cout << "c语言关键" << endl;
}
};
class python
{
public:
void base()
{
cout << "代码程序基础" << endl;
}
void rise()
{
cout << "代码程序提高" << endl;
}
void top()
{
cout << "python语言关键" << endl;
}
};
void test01()
{
cout << "java" << endl;
java j1;
j1.base();
j1.rise();
j1.top();
cout << "\t" << endl;
cout << "c" << endl;
c c1;
c1.base();
c1.rise();
c1.top();
cout << "\t" << endl;
cout << "python" << endl;
python p1;
p1.base();
p1.rise();
p1.top();
}
int main()
{
test01();
system("pause");
return 0;
}

采用继承的方式，提取公因子，从而减少代码量，提高运行效率，子类也称为派生类，父类也称为基类。派生类包括两大成员：①从基类继承来的共性特点②自己的成员，体现个性特点

以下这段代码，子类为：java、c、python，父类为normal

代码实现：

#include<iostream>
using namespace std;
//公共类
class normal
{
public:
void base()
{
cout << "代码程序基础" << endl;
}
void rise()
{
cout << "代码程序提高" << endl;
}
};
//继承实现
class java : public normal
{
public:
void top()
{
cout << "java关键" << endl;
}
};
class c : public normal
{
public:
void top()
{
cout << "c关键" << endl;
}
};
class python : public normal
{
public:
void top()
{
cout << "python关键" << endl;
}
};
//公共类
class normal
{
public:
void base()
{
cout << "代码程序基础" << endl;
}
void rise()
{
cout << "代码程序提高" << endl;
}
};
void test01()
{
cout << "java" << endl;
java j1;
j1.base();
j1.rise();
j1.top();
cout << "\t" << endl;
cout << "c" << endl;
c c1;
c1.base();
c1.rise();
c1.top();
cout << "\t" << endl;
cout << "python" << endl;
python p1;
p1.base();
p1.rise();
p1.top();
}
int main()
{
test01();
system("pause");
return 0;
}

2.6.1继承方式

继承方式分为：公共继承，保护继承，私有继承。与类内的访问权限对应

不同继承方式会导致子类对于父类属性的访问权限变化如图所示

代码实现：

#include<iostream>
using namespace std;
//继承方式分为：公共继承，保护继承，私有继承，与类的访问权限一一对应
//不论是哪一种继承方式都无法访问私有继承
//任何一种都可以访问公共继承内容
class father
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
};
class son1 : public father
{
public:
void func1()
{
m_a = 100;//属于son1的公共权限
m_b = 100;//属于son1的保护权限
//m_c = 100;//属于私有权限，不可访问
}
};
class son2 : protected father
{
public:
void func2()
{
m_a = 50;//father公共权限->son2保护权限
m_b = 50;//father保护权限->son2保护权限
//m_c = 50;//不可访问，属于私有权限
}
};
class son3 : private father
{
public:
void func3()
{
m_a = 10;//属于son3的私有权限
m_b = 10;//属于son3的私有权限
//m_c = 10;//不可访问，属于私有权限
}
};
class grandson : public son1
{
public:
void fun()
{
m_a = 1;//son1公共权限->grandson公共权限
m_b = 1;//son1保护权限->grandson保护权限
}
};
int main()
{
son1 s1;
//cout << s1.m_a << endl;
//cout << s1.m_b << endl;//s1中的m_b为保护权限，无法访问
son2 s2;
//cout << s2.m_a << endl;
//cout << s2.m_b << endl;
//s2中m_a.m_b都是保护权限，无法访问
//同理在son3 s3 中两者都为私有权限，无法访问
system("pause");
return 0;
}

继承中的对象模型：继承中父类所有的属性都会被子类继承下去，只是父类的私有属性被编译器隐藏，无法访问，但是事实存在

代码实现：

#include<iostream>
using namespace std;
class father
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
};
class son : public father
{
public:
int m_d;
};
void test01()
{
son s1;
cout << sizeof(s1) << endl;
}
int main()
{
test01();//16
//说明子类完全继承父类中的属性
//只是父类中的私有属性被编译器隐藏，无法访问，但是他是存在的
system("pause");
return 0;
}

对于上面这串代码通过vs开发人员命令提示符，可以查看son子类的大小以及所含内容，说明其中是继承了父类的所有属性

具体操作：

Cl /d1 reportSingleClassLayout类名文件名（为报告单个类的布局）

父类与子类的构造与析构函数顺序；

父类构造->子类构造->子类析构->父类析构

2.6.2同名成员处理

当子类与父类出现同名成员时①访问子类同名成员，直接访问即可②访问父类中的同名成员，加作用域

代码实现：

//当子类与父类出现同名成员时
//①访问子类同名成员，直接访问即可
//②访问父类中的同名成员，加作用域
#include<iostream>
using namespace std;
class father
{
public:
father()
{
m_a = 100;
}
void func()
{
cout << "father-func" << endl;
}
void func(int a)
{
cout << "father-func(int a)" << endl;
}
int m_a;
};
class son : public father
{
public:
son()
{
m_a = 20;
}
void func()
{
cout << "son-func" << endl;
}
int m_a;
};
void test01()
{
//同名属性调用
son s1;
cout << s1.m_a << endl;
//直接访问，得子类中的属性
cout << s1.father::m_a << endl;
//通过子类对象，访问父类中的同名对象
s1.func();//son-func
s1.father::func();//father-func
//如果子类中有与父类同名的成员函数，子类会自动隐藏所有父类同名成员函数，包括函数的重载
s1.father::func(10);//father-func(int a)
}
int main()
{
test01();
system("pause");
return 0;
}

子类对象可以直接访问子类中的同名成员函数；子类对象加作用域可以访问父类中的同名函数；子类对象与父类对象拥有同名函数时，创建的子类对象会自动隐藏父类中的所有同名成员函数，加作用域后即可访问父类中的同名函数

同名静态成员函数与同名静态成员属性与非静态成员函数跟非静态成员属性处理方式相同

多继承语法：一个类继承多个类

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

2.6.3菱形继承

菱形继承，也叫做钻石继承：①两个派生类（子类）继承同一个基类②某个类同时继承两个派生类

骡是马与驴的杂交种，骡马驴都属于动物，但是骡又同时继承了属于马与骡的特性。马继承了动物的特性，驴继承了动物的特性，当骡使用数据时就会产生二义性。

当使用骡的动物属性时，同时具有马的动物属性与驴的动物属性，然而实际上只需要一份骡的动物属性即可

需要利用虚继承解决菱形继承的问题

虚继承关键字 virtual，将animal变成虚基类

此时m_age只有一份，ma与lv继承的属性为vbptr（虚基类指针virtual base pointer）指向vbtable（虚基类表），不会出现第二份数据

代码实现：

#include<iostream>
using namespace std;
//菱形继承概念：
//①两个派生类（子类）继承同一个基类
//②某个类同时继承两个派生类
class animal
{
public:
int m_age;
};
class ma :virtual public animal {};
class lv :virtual public animal {};
class luo:public ma,public lv
{
};
void test01()
{
luo l1;
l1.ma::m_age = 18;
l1.lv::m_age = 26;
cout << l1.ma::m_age << endl;
cout << l1.lv::m_age << endl;
//同时继承了两份数据
//然而luo l1只需要一份数据，导致资源浪费
//加上virtual之后，输出结果都为26
cout << l1.m_age << endl;
//加入虚基类之后就允许直接输出，不会出现二义性，因为为同一份数据
}
int main()
{
test01();
system("pause");
return 0;
}

2.7多态

2.7.1多态基本语法

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

多态分为两类：

静态多态：函数重载与运算符重载属于静态多态

动态多态：派生类和虚函数实现运行时多态

区别：

静态多态函数地址早绑定，编译阶段确定函数地址

动态多态的函数地址晚绑定，运行阶段确定函数地址

代码实现：

#include<iostream>
using namespace std;
class animal
{
public:
virtual void speak()
//加入virtual使其变成虚函数，再运行就会打印猫叫
{
cout << "动物说话" << endl;
}
};
class cat:public animal
{
public:
void speak()
{
cout << "猫叫" << endl;
}
};
//执行dospeak函数，地址早绑定，在编译阶段就确定了函数地址

void dospeak01(animal &animal) //animal &animal =cat

{
animal.speak();
//加入virtual之前不论传入任何类，都会走animal的路径，所以显示动物说话
//speak函数的地址在加入virtual之后无法立刻确认，受传入的不同类，决定不同的路径
}
void test01()
{
cat c1;
dospeak01(c1);
}
int main()
{
test01();//动物说话
system("pause");
return 0;
}

动态多态满足条件：①有继承关系②子类重写父类的虚函数

重写与函数重载不同，重写函数返回值相同，函数名相同，形参列表也相同。但是子类的虚函数可以省略virtual，但在父类中必须要写才能变成虚函数

Animal类内部结构：包含vfptr(虚函数指针)->vftable(虚函数表)

虚函数表的内部会记录一个虚函数的地址&animal::speak

Cat类内部结构:包含vfptr->vftable

虚函数表的内部会记录一个虚函数的地址&animal::speak，因为子类会继承父类中的所有内容

如果子类中重写了父类的虚函数，子类中的vftable(虚函数表)内部会替换成子类的虚函数地址，父类vftable中的内容不改变

当父类的指针或者引用指向子类对象时，就发生了多态//animal &animal =cat，父类的引用指向子类，此时成员函数speak就明确指向cat中的同名speak函数

2.7.2纯虚函数与抽象类

有时候父类中的虚函数的实现无意义，并不需要，这时候就用纯虚函数代替

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

当类中出现纯虚函数时，这个类就叫抽象类

抽象类特点：①无法实例化对象②子类必须重写抽象类中的纯虚函数，否则子类也为抽象类，无法实例化对象

代码实现：

#include<iostream>
using namespace std;
class father
{
public:
virtual void func() = 0;
};
class son:public father
{
public:
virtual void func()
{
cout << "func调用" << endl;
}
};
void test01()
{
//father f1;//抽象类无法实例化对象
son s1;
father* f1 = new son;
f1->func();
}
int main()
{
test01();
system("pause");
return 0;
}

2.7.3虚析构与纯虚析构

多态使用时，如果子类有属性开辟在堆区，那么父类指针释放时无法调用子类的析构函数

这时候将父类的析构函数改为虚析构或者纯虚析构

共性：①可以解决父类指针释放子类对象②都需要具体的函数实现

区别：如果是纯虚析构，那么类属于抽象类，无法实例化对象

问题：

#include<iostream>
using namespace std;
class father
{
public:
father()
{
cout << "father构造函数调用" << endl;
}
~father()
{
cout << "father析构函数调用" << endl;
}
virtual void func() = 0;//纯虚函数
};
class son :public father
{
public:
son(string name)
{
cout << "son构造函数调用" << endl;
m_name = new string(name);
}
~son()
{
if(m_name != NULL)
{
cout << "son析构函数调用" << endl;
delete m_name;
m_name = NULL;
}
}
void func()
{
cout << "son void func() 调用" << endl;
}
string* m_name;
};
void test01()
{
father* f1 = new son("tom");
//在堆区开辟一块son的内存，并用father类f1接收
f1->func();
delete f1;
}
int main()
{
test01();
system("pause");
return 0;
}

运行结果：

由此可见并没有执行子类的析构函数，并没有释放m_name在堆区的内存，导致内存泄漏

产生原因是由于用父类的指针接收father* f1 = new son("tom");

父类的指针在析构的时候，不会调用子类的析构函数，导致子类如果有堆区数据，无法释放，内存泄露

解决方法：父类的析构前加关键字virtual，使其变成虚析构函数，解决父类释放子类堆区对象不干净问题

代码实现：

#include<iostream>
using namespace std;
class father
{
public:
father()
{
cout << "father构造函数调用" << endl;
}
virtual~father()
{
cout << "father析构函数调用" << endl;
}
virtual void func() = 0;//纯虚函数
};
class son :public father
{
public:
son(string name)
{
cout << "son构造函数调用" << endl;
m_name = new string(name);
}
~son()
{
if(m_name != NULL)
{
cout << "son析构函数调用" << endl;
delete m_name;
m_name = NULL;
}
}
void func()
{
cout << "son void func() 调用" << endl;
}
string* m_name;
};
void test01()
{
father* f1 = new son("tom");
//在堆区开辟一块son的内存，并用father类f1接收
f1->func();
delete f1;
}
int main()
{
test01();
system("pause");
return 0;
}

纯虚析构：virtual ~animal()=0;

纯虚析构的直接调用会导致系统报错，因为此时只是一个函数声明，并没有析构函数的实现

纯虚析构既需要类内声明，也需要类外实现，有了纯虚析构后，所属类也变为抽象类，无法实例化对象

代码实现；

#include<iostream>
using namespace std;
class father
{
public:
father()
{
cout << "father构造函数调用" << endl;
}
//虚析构
//virtual~father()
//{
// cout << "father析构函数调用" << endl;
//}
//纯虚析构
virtual ~father() = 0;//此时为一个函数的声明，并无实现
virtual void func() = 0;//纯虚函数
};
//纯虚析构的外部函数实现
father:: ~father()
{
cout << "father的纯虚析构函数调用" << endl;
}
class son :public father
{
public:
son(string name)
{
cout << "son构造函数调用" << endl;
m_name = new string(name);
}
~son()
{
if(m_name != NULL)
{
cout << "son析构函数调用" << endl;
delete m_name;
m_name = NULL;
}
}
void func()
{
cout << "son void func() 调用" << endl;
}
string* m_name;
};
void test01()
{
father* f1 = new son("tom");
//在堆区开辟一块son的内存，并用father类f1接收
f1->func();
delete f1;
}
int main()
{
test01();
system("pause");
return 0;
}

2.8文件操作

2.8.1文本文件

文本文件操作需要头文件<fstream> ofstream写操作 ifstream读操作 fstream读写操作

文件打开方式：

打开方式	解释
Ios::in	读文件而打开
Ios::out	写文件而打开
Ios::ate	初始位置为文件尾部
Ios::app	追加方式写文件
Ios::trunc	如果文件存在，先删除再创建
Ios::binary	二进制方式

二进制方式读文件：int::binary | ios::in

（1）文本文件--写文件

流程：①包含头文件#include<fstream>②创建流对象 ofstream 文件名;③打开文件文件名.open(“文件路径”，打开方式)④写数据文件名<<“写入的数据”；⑤关闭文件文件名.close();

不会在编译器内打印，在未指定状态下，会自动在代码所在文件夹内输出

代码实现：

#include<iostream>
#include<fstream>
using namespace std;
void test01()
{
//创建流对象
ofstream a1;
//指定打开方式
a1.open("test.txt",ios::out );
//写内容
a1 << "姓名：阮晓野" << endl;
a1 << "年龄：18" << endl;
a1.close();
}
int main()
{
test01();
system("pause");
return 0;
}

（2）文本文件—读文件

流程：①包含头文件#include<fstream>②创建流对象 ofstream 文件名;③打开文件文件名.open(“文件路径”，打开方式)④读数据四种方式读取⑤关闭文件文件名.close();

四种方式读取：

//第一种

char buf1[1024] = { 0 };

//初始化一个字符数组，并赋值全为0

while (b1 >> buf1)

//将文本文件中的所有读取到字符数组中

{

cout << buf1 << endl;

}

//第二种

char buf2[1024] = { 0 };

while(b1.getline(buf2,sizeof(buf2)))

//第一个参数为数据传入位置，第二个为读取的字节数

{

cout << buf2 << endl;

}

//第三种

string buf3;

while (getline(b1,buf3))

//全局函数getline需要加头文件string

{

cout << buf3 << endl;

}

//第四种

char c;

while ((c=b1.get())!=EOF)

//get函数每次只读取一个字符,效率低

//EOF end of file 文件尾

{

cout << c ;

}

代码实现：

#include<iostream>
#include<fstream>
#include<string>
using namespace std;
void test01()
{
fstream b1;
b1.open("test.txt", ios::in);
if (!b1.is_open())//判断是否打开成功
{
cout << "文件打开失败" << endl;
return;
}
//读取数据
第一种
//char buf1[1024] = { 0 };//初始化一个字符数组，并赋值全为0
//while (b1 >> buf1)
将文本文件中的所有读取到字符数组中
//{
// cout << buf1 << endl;
//}
第二种
//char buf2[1024] = { 0 };
//while (b1.getline(buf2,sizeof(buf2)))
第一个参数为数据传入位置，第二个为读取的字节数
//{
// cout << buf2 << endl;
//}
第三种
//string buf3;
//while (getline(b1,buf3))
全局函数getline需要加头文件string
//{
// cout << buf3 << endl;
//}
//第四种
char c;
while ((c=b1.get())!=EOF)
//get函数每次只读取一个字符,效率低
//EOF end of file 文件尾
{
cout << c ;
}
b1.close();
}
int main()
{
test01();
system("pause");
return 0;
}

2.8.2二进制文件

打开方式必须指定为ios::binary

(1)二进制方式写文件主要利用流对象调用成员函数write

代码实现：

#include<iostream>
#include<fstream>
using namespace std;
class person
{
public:
char m_name[64];
int m_age;
};
void test01()
{
ofstream o1;
o1.open("person.txt",ios::out|ios::binary);
person p1 = { "阮晓野",18 };
o1.write((const char *)&p1,sizeof(p1));
//取p1的地址，并且将person类强制转换为const char *
o1.close();
}
int main()
{
test01();
system("pause");
return 0;
}

只能显示姓名，年龄显示为乱码

（2）二进制方式读文件主要利用流对象调用成员函数read

代码实现：

#include<iostream>
#include<fstream>
using namespace std;
class person
{
public:
char m_name[64];
int m_age;
};
void test01()
{
person p1;
ifstream i1;
i1.open("person.txt", ios::in | ios::binary);
if (!i1.is_open())
{
cout << "文件打开失败" << endl;
return;
}
i1.read((char *)&p1,sizeof(p1));
cout << p1.m_name << p1.m_age << endl;
i1.close();
}
int main()
{
test01();
system("pause");
return 0;
}

第三章面向对象应用

3.1矩阵类设计及应用

矩阵类要求：设计一个矩阵类，要求能够根据用户需求构建row行、column列的矩阵，并灵活接受反馈矩阵元素信息（如：某行、某列、某行某列元素）。实现矩阵的相关运算，包括矩阵加（+）、矩阵乘（*）、矩阵输出（<<）、矩阵赋值（=）、获取矩阵指定位置元素值（[]）。

题目分析：需要在举证类内设置一个二阶数组p

数组运算需要重载运算符（+，*，=）

代码实现：

#include<iostream>
using namespace std;
class jvzheng
{
public:
jvzheng(int colnum,int rownum);
~jvzheng();
jvzheng& operator=(const jvzheng& m1);//实现矩阵的复制
jvzheng& operator+=(const jvzheng& m2);
jvzheng& operator*=(const jvzheng& m3);
friend istream& operator>>(istream &in ,jvzheng& m4);
jvzheng& operator=(double* a);//实现数组转化为矩阵
void show();//打印矩阵
void show(int r, int c);//打印指定位置元素值
private:
int m_row;//行数
int m_column;//列数
double **p;
void chushihua();//初始化一个矩阵
};
void jvzheng::chushihua()
{
//为数组中的每一个元素在堆区开辟一块内存
p = new double* [m_row];
for (int i = 0; i < m_row ; i++)
{
p[i] = new double [m_column];
}
}
//在构造函数中构建一个全0矩阵
jvzheng::jvzheng(int col,int row)
{
m_row = row;
m_column = col;
chushihua();
if (col< 0)
{
cout << "列数不能为0" << endl;
}
else if (row < 0)
{
cout << "行数不能为0" << endl;
}
else
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
p[i][j] = 0;
}
}
}
}
jvzheng::~jvzheng()
{
for (int i = 0; i < m_row; ++i)
{
delete[] p[i];//释放每一行内存
}
delete[] p;//释放所有内存
}
//实现矩阵的复制
jvzheng& jvzheng::operator=(const jvzheng &m1)
{
if (this == &m1)
{
return *this;
}
if (m_row != m1.m_row || m_column != m1.m_column)
{
for (int i = 0; i < m_row; i++)
{
delete[] p[i];//当出现不一样的时候，删除每一行数据释放空间
}
delete[] p;//释放数组p内存空间
m_row = m1.m_row;
m_column = m1.m_column;
chushihua();
}
for (int i = 0; i < m_row; i++)
{
for (int j = 0; j < m_column; j++)
{
p[i][j] = m1.p[i][j];
}
}
}
//赋值运算符重载
jvzheng& jvzheng::operator=(double* a)
{
for (int i = 0; i < m_row; i++)
{
for (int j = 0; j < m_column; j++)
{
p[i][j] = *(a + i * m_column + j);
}
}
return *this;
}
//加法运算符重构
jvzheng& jvzheng::operator+=(const jvzheng &m2)
{
for (int i = 0; i < m_row; i++)
{
for (int j = 0; j < m_column; j++)
{
p[i][j] += m2.p[i][j];
}
}
return *this;
}
//乘法运算符重构
jvzheng& jvzheng::operator*=(const jvzheng &m3)
{
jvzheng temp(m_row, m3.m_column);//设置一个中间变量用于矩阵乘法 p*m3=temp
for (int i = 0; i < m_row; i++)
{
for (int j = 0; j < m3.m_column; j++)
{
for (int k = 0; k < m_column; k++)
{
temp.p[i][j] = p[i][k] * m3.p[k][j];
}
}
}
*this = temp;
return *this;
}
//显示矩阵
void jvzheng::show()
{
cout << "矩阵行数为：" << m_row << endl;
cout << "矩阵列数为：" << m_column << endl;
cout << "矩阵为：" << endl;
for (int i = 0; i < m_row; i++)
{
for (int j = 0; j < m_column; j++)
{
cout<<p[i][j]<<" ";
}
cout << endl;
}
}
//实现矩阵的输入
istream& operator>>(istream& in,jvzheng& m4)
{
for (int i = 0; i < m4.m_row; i++)
{
for (int j = 0; j < m4.m_column; j++)
{
in >> m4.p[i][j];
}
}
return in;
}
void jvzheng::show(int r, int c)
{
cout << p[r][c] << endl;
}
int main()
{
jvzheng j1(3, 3);
cin >> j1 ;
cout << endl;
jvzheng j2(3, 4);
cin >> j2;
cout << endl;
j1.show();
j1.show(1, 2);
j1 *= j2;
j1.show();
system("pause");
return 0;
}

3.2银行账号管理系统设计及应用

银行账号管理系统要求：管理不同用户在银行的金融资产，每个用户可以拥有多种银行账户（如：定期储蓄、活期储蓄、信息卡、电子账户、贷款账户等）。账户包括账号、余额、利率等基本信息，用户可以进行账户信息查询、存款、取款、结算利息等操作。银行需统计所有账户的总金额、验证银行系统收支平衡，并能够及时预警反馈。设计Account抽象类作为所有银行账户顶层祖先，根据实际应用需求合理设置派生层次及相应子类。结合银行利息结算、用户贷款申请等实际应用需求，适当添加辅助类协同操作。合理定义虚基类、虚函数、纯虚函数、抽象类完成银行账号管理系统的稳定可靠运行。

首先一切的父类就是基础账号，在这个账号中可以实现活期储蓄与定期储蓄，通过成员函数实现账户信息查询，存款，取款，结算利息

可以通过子类设置贷款类，贷款类中除了比父类多出贷款金额与贷款利率，利息的计算，其余基础属性完全相同，所以可以通过继承多态的方式，实现派生

代码实现：

#include<iostream>
#include<ctime>
#define interestRates 0.03//定期利率
#define demandRrates 0.00035//活期利率
#define loanInterest 0.0475//贷款利率
#define creditInterest 0.0055//信用卡利率
using namespace std;
//父类：银行账户类，抽象类
class Account
{
friend class fixedDeposit;
friend class currentDeposit;
public:
virtual void menu();//菜单栏
virtual bool set();//存款
virtual bool get();//取款
virtual void show();//显示账户信息
virtual void setcard(double money, string cardid);//初始化账户
virtual void setid();
virtual void clearingInterest();//利息结算
private:
string m_id;//账号
double m_money;//余额
};
//菜单栏实现
void Account::menu()
{
int choice = 0;
while (true)
{
system("cls");
cout << "····欢迎使用银行账号管理系统····" << endl;
cout << "····请输入功能前的数字·······" << endl;
cout << "····0.退出银行账号管理系统·····" << endl;
cout << "····1.创建个人银行账户·······" << endl;
cout << "····2.查看账户个人信息·······" << endl;
cout << "····3.查询结算利息·········" << endl;
cout << "····4.存款·············" << endl;
cout << "····5.取款·············" << endl;
cin >> choice;
switch (choice)
{
case 0:
{
cout << "已退出银行账号管理系统" << endl;
return;
}
case 1:
{
cout << "创建个人银行账户" << endl;
setid();
break;
}
case 2:
{
cout << "查看个人账户信息" << endl;
show();
break;
}
case 3:
{
cout << "查询结算利息" << endl;
clearingInterest();
break;
}
case 4:
{
cout << "存款" << endl;
set();
break;
}
case 5:
{
cout << "取款" << endl;
get();
break;
}
}
}
}
//实现账户初始化
void Account::setcard(double money, string cardid)
{
m_id = cardid;
m_money = money;
}
//账户设置
void Account::setid()
{
string a1;
cout << "请设置你的id账户：" << endl;
cin >> a1;
cout << "你的id账户为：" << a1 << endl;
m_id = a1;
}
void Account::show()
{
cout << "账户id为：" << m_id << endl;
cout << "账户余额为：" << m_money << endl;
system("pause");
system("cls");
}
//存款
bool Account::set()
{
double inmoney;
char a;
cout << "请输入你的存款金额：" << endl;
cin >> inmoney;
cout << "存款金额为：" << inmoney <<"(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "存款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
m_money = inmoney;
cout << "存款金额确认无误，存款成功" << endl;
}
system("pause");
system("cls");
return true;
}
//取款
bool Account::get()
{
double outmoney;
char a;
cout << "请输入你的取款金额：" << endl;
cin >> outmoney;
if (m_money < outmoney)
{
cout << "余额不足" << endl;
return false;
}
cout << "取款金额为：" << outmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "取款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
m_money -= outmoney;
cout << "存款==取款金额确认无误，取款成功" << endl;
}
system("pause");
system("cls");
return true;
}
//实现结算利息
void Account::clearingInterest()
{
double a;
cout << "当前余额为：" << m_money << endl;
cout << "定期利率为：" << interestRates << endl;
a = m_money * interestRates;
cout << "结算定期利息为：" << a << endl;
double b;
cout << "当前余额为：" << m_money << endl;
cout << "活期利率为：" << demandRrates << endl;
b = m_money * demandRrates;
cout << "结算活期利息为：" << b << endl;
system("pause");
system("cls");
}
//贷款账户
class loan :public Account
{
public:
virtual void menu();//菜单栏
virtual bool set();//存款
virtual bool get();//取款
virtual void show();//显示账户信息
virtual void setcard(double money, string cardid);//初始化账户
virtual void setid();
virtual void clearingInterest();//利息结算
virtual bool loanmoney();
private:
string m_id;//账号
double m_money;//余额
double m_loanmoney;
};
void loan::menu()
{
int choice = 0;
while (true)
{
system("cls");
cout << "····欢迎使用银行账号管理系统····" << endl;
cout << "····请输入功能前的数字·······" << endl;
cout << "····0.退出银行账号管理系统·····" << endl;
cout << "····1.创建个人银行账户·······" << endl;
cout << "····2.查看账户个人信息·······" << endl;
cout << "····3.查询结算利息·········" << endl;
cout << "····4.查询存款···········" << endl;
cout << "····5.查询取款···········" << endl;
cout << "····6.查询贷款···········" << endl;
cin >> choice;
switch (choice)
{
case 0:
{
cout << "已退出银行账号管理系统" << endl;
return;
}
case 1:
{
cout << "创建个人银行账户" << endl;
setid();
break;
}
case 2:
{
cout << "查看个人账户信息" << endl;
show();
break;
}
case 3:
{
cout << "查询结算利息" << endl;
clearingInterest();
break;
}
case 4:
{
cout << "查询存款" << endl;
set();
break;
}
case 5:
{
cout << "查询取款" << endl;
get();
break;
}
case 6:
{
cout << "查询贷款" << endl;
loanmoney();
break;
}
}
}
}
//实现账户初始化
void loan::setcard(double money, string cardid)
{
m_id = cardid;
m_money = money;
}
//账户设置
void loan::setid()
{
string a1;
cout << "请设置你的id账户：" << endl;
cin >> a1;
cout << "你的id账户为：" << a1 << endl;
m_id = a1;
system("pause");
system("cls");
}
void loan::show()
{
cout << "账户id为：" << m_id << endl;
cout << "账户余额为：" << m_money << endl;
cout << "贷款金额为：" << m_loanmoney << endl;
system("pause");
system("cls");
}
//存款
bool loan::set()
{
double inmoney;
char a;
cout << "请输入你的存款金额：" << endl;
cin >> inmoney;
cout << "存款金额为：" << inmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "存款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
m_money = inmoney;
cout << "存款金额确认无误，存款成功" << endl;
}
system("pause");
system("cls");
return true;
}
//取款
bool loan::get()
{
double outmoney;
char a;
cout << "请输入你的取款金额：" << endl;
cin >> outmoney;
if (m_money < outmoney)
{
cout << "余额不足" << endl;
system("pause");
system("cls");
return false;
}
else
{
cout << "取款金额为：" << outmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "取款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
m_money -= outmoney;
cout << "取款金额确认无误，取款成功" << endl;
system("pause");
system("cls");
return true;
}
}
}
//贷款
bool loan::loanmoney()
{
cout << "请输入贷款金额" << endl;
int loan_money;
cin >> loan_money;
char a;
cout << "贷款金额为：" << loan_money <<"(t or f)" << endl;
cin >> a;
if (a=='f'||a=='F')
{
cout << "贷款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
m_loanmoney = loan_money;
m_money += m_loanmoney;
cout << "账户余额合计为：" << m_money << endl;
}
system("pause");
system("cls");
return true;
}
//贷款利息结算
void loan::clearingInterest()
{
cout << "贷款利率为" << loanInterest << endl;
double a1;
a1 = m_loanmoney * loanInterest;
cout << "贷款利息为：" << a1 << endl;
system("pause");
system("cls");
}
//信用卡账号
class credit :public Account
{
public:
virtual void menu();//菜单栏
virtual bool set();//存款
virtual bool get();//取款
virtual void show();//显示账户信息
virtual void setcard(double money, string cardid);//初始化账户
virtual void setid();
virtual void clearingInterest();//利息结算
private:
string m_id;//账号
double m_money=0.0;//余额
double m_creditmoney=0.0;//信用透支金额
};
//菜单栏
void credit::menu()
{
int choice = 0;
while (true)
{
system("cls");
cout << "····欢迎使用银行账号管理系统····" << endl;
cout << "····请输入功能前的数字·······" << endl;
cout << "····0.退出银行账号管理系统·····" << endl;
cout << "····1.创建个人银行账户·······" << endl;
cout << "····2.查看账户个人信息·······" << endl;
cout << "····3.查询结算利息·········" << endl;
cout << "····4.查询存款···········" << endl;
cout << "····5.查询取款···········" << endl;
cin >> choice;
switch (choice)
{
case 0:
{
cout << "已退出银行账号管理系统" << endl;
return;
}
case 1:
{
cout << "创建个人银行账户" << endl;
setid();
break;
}
case 2:
{
cout << "查看个人账户信息" << endl;
show();
break;
}
case 3:
{
cout << "查询结算利息" << endl;
clearingInterest();
break;
}
case 4:
{
cout << "查询存款" << endl;
set();
break;
}
case 5:
{
cout << "查询取款" << endl;
get();
break;
}
}
}
}
//实现账户初始化
void credit::setcard(double money, string cardid)
{
m_id = cardid;
m_money = money;
}
//账户设置
void credit::setid()
{
string a1;
cout << "请设置你的id账户：" << endl;
cin >> a1;
cout << "你的id账户为：" << a1 << endl;
m_id = a1;
system("pause");
system("cls");
}
void credit::show()
{
cout << "账户id为：" << m_id << endl;
cout << "账户余额为：" << m_money << endl;
cout << "信用透支金额为：" << m_creditmoney << endl;
system("pause");
system("cls");
}
//存款
bool credit::set()
{
double inmoney;
char a;
cout << "请输入你的存款金额：" << endl;
cin >> inmoney;
cout << "存款金额为：" << inmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "存款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else
{
if (m_creditmoney != 0)
{
cout << "当前透支金额为：" << m_creditmoney << endl;
char ch;
cout << "是否优先还款（y or n）" << endl;
cin >> ch;
if (ch=='y'||ch=='Y')
{
cout << "优先还款" << endl;
m_money = inmoney - m_creditmoney;
system("pause");
system("cls");
return true;
}
else if(ch=='n'||ch=='N')
{
cout << "非优先还款" << endl;
m_money = inmoney;
cout << "当前存款金额为：" << m_money << endl;
system("pause");
system("cls");
return false;
}
}
else
{
cout << "无信用透支金额" << endl;
m_money = inmoney;
cout << "存款金额确认无误，存款成功" << endl;
system("pause");
system("cls");
return true;
}
}
}
//取款
bool credit::get()
{
double outmoney;
char a;
cout << "请输入你的取款金额：" << endl;
cin >> outmoney;
if (m_money < outmoney)
{
cout << "余额不足" << endl;
cout << "是否透支信用卡(y or n)" << endl;
char ch;
cin >> ch;
if (ch == 'n' || ch == 'N')
{
cout << "余额不足取款失败" << endl;
return false;
}
else if(ch=='y'||ch=='Y')
{
cout << "取款金额为：" << outmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "取款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else if (a == 't' || a == 'T')
{
m_creditmoney = outmoney;
cout << "取款金额确认无误，取款成功" << endl;
}
system("pause");
system("cls");
return true;
}
}
else
{
if (m_creditmoney != 0)
{
cout << "当前透支金额为：" << m_creditmoney << endl;
double a;
a = m_creditmoney * creditInterest;
cout << "透支金额利息结算为：" << a << endl;
m_money -= m_creditmoney * creditInterest;
cout << "当前余额为：" << m_money << endl;
cout << "取款金额为：" << outmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "取款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else if (a == 't' || a == 'T')
{
m_money -= outmoney;
cout << "取款金额确认无误，取款成功" << endl;
cout << "当前余额为：" << m_money << endl;
system("pause");
system("cls");
return true;
}
}
else
{
cout << "当前无透支金额" << endl;
cout << "取款金额为：" << outmoney << "(t or f)" << endl;
cin >> a;
if (a == 'f' || a == 'F')
{
cout << "取款金额确认有误" << endl;
system("pause");
system("cls");
return false;
}
else if (a == 't' || a == 'T')
{
m_creditmoney = outmoney;
cout << "取款金额确认无误，取款成功" << endl;
system("pause");
system("cls");
return true;
}
}
}
}
void credit::clearingInterest()
{
cout << "信用卡利息为：" << creditInterest << endl;
double a;
a = m_creditmoney * creditInterest;
cout << "信用透支金额为：" << m_creditmoney << endl;
cout << "透支金额利息结算为：" << a << endl;
system("pause");
system("cls");
}
void test01()
{
Account a1;
a1.menu();
}
void test02()
{
loan l1;
l1.menu();
}
void test03()
{
credit c1;
c1.menu();
}
int main()
{
//test01();
//test02();
test03();
system("pause");
return 0;
}

结束语

在写这份大作业的同时，我回顾了之前的所学内容，在原有理解的基础上，有了新的感悟与体验，对于程序本身的运行逻辑有了更深的感悟。

在学习面向对象程序设计的过程中，充分使用了c语言的基础，并且在此基础上扩展了类的用法，通过对类属性的抽象，实现父类子类的继承关系以及向下发展的多态多样化。在面对更加具体的要求时，可以实现具体的实例化，解决实际问题。同时通过面向对象程序设计的继承与多态特点，可以简明的实现类似功能，以及功能的差异化。虚基类，纯虚基类更是在细化的基础上，很大程度的减少了内存空间的占用，避免了无用操作导致程序运行时间变成的问题。在类的学习过程中，我认为类与结构体的学习过程十分相似，都有统一的格式要求，并且在内部有一定的特定功能，与结构体不同的是，类在实现功能与属性定义的同时，还可以对访问权限进行限制，不仅提高了代码的可读性，更方便了程序运行与定义。

通过析构函数构造函数拷贝构造函数，方便了数据在堆区的开辟与释放，同时实现了深层拷贝，避免了浅拷贝所带来的内存重复释放问题

最后学习了类文件操作，打开了对新世界的大门，知道了二进制文件与文本文件的区别，以及如何编写，进行文件操作，丰富了编程的手段与形式，扩展了输出表达的方式。

在面向对象程序设计的学习过程中，十分感谢刘宁老师的答疑解惑，解决了很多我不能理解的问题，从而让我对面向对象程序设计的研究学习更加深入。

《面向对象程序设计》相关推荐

ComeFuture英伽学院——2020年全国大学生英语竞赛【C类初赛真题解析】(持续更新)
视频:ComeFuture英伽学院--2019年全国大学生英语竞赛[C类初赛真题解析]大小作文--详细解析课件:[课件]2019年大学生英语竞赛C类初赛.pdf 视频:2020年全国大学生英语竞赛 ...
ComeFuture英伽学院——2019年全国大学生英语竞赛【C类初赛真题解析】大小作文——详细解析
视频:ComeFuture英伽学院--2019年全国大学生英语竞赛[C类初赛真题解析]大小作文--详细解析课件:[课件]2019年大学生英语竞赛C类初赛.pdf 视频:2020年全国大学生英语竞赛 ...
信息学奥赛真题解析（玩具谜题）
玩具谜题(2016年信息学奥赛提高组真题) 题目描述小南有一套可爱的玩具小人, 它们各有不同的职业.有一天, 这些玩具小人把小南的眼镜藏了起来.小南发现玩具小人们围成了一个圈,它们有的面朝圈内,有的 ...
信息学奥赛之初赛第1轮讲解（01-08课）
信息学奥赛之初赛讲解 01 计算机概述系统基本结构信息学奥赛之初赛讲解 01 计算机概述系统基本结构_哔哩哔哩_bilibili 信息学奥赛之初赛讲解 02 软件系统计算机语言进制转换信息 ...
信息学奥赛一本通习题答案（五）
最近在给小学生做C++的入门培训,用的教程是信息学奥赛一本通,刷题网址 http://ybt.ssoier.cn:8088/index.php 现将部分习题的答案放在博客上,希望能给其他有需要的人带来 ...
信息学奥赛一本通习题答案（三）
最近在给小学生做C++的入门培训,用的教程是信息学奥赛一本通,刷题网址 http://ybt.ssoier.cn:8088/index.php 现将部分习题的答案放在博客上,希望能给其他有需要的人带来 ...
信息学奥赛一本通提高篇第六部分数学基础相关的真题
第1章快速幂 1875:[13NOIP提高组]转圈游戏信息学奥赛一本通(C++版)在线评测系统第2 章素数第 3 章约数第 4 章同余问题第 5 章矩阵乘法第 6 章 ...
信息学奥赛一本通题目代码（非题库）
为了完善自己学c++,很多人都去读相关文献,就比如<信息学奥赛一本通>,可又对题目无从下手,从今天开始,我将把书上的题目一一的解析下来,可以做参考,如果有错,可以告诉我,将在下次解析里重 ...
信息学奥赛一本通（C++版）刷题记录
总目录详见:https://blog.csdn.net/mrcrack/article/details/86501716 信息学奥赛一本通(C++版) 刷题记录 http://ybt.ssoier. ...
最近公共祖先三种算法详解 + 模板题建议新手收藏例题：信息学奥赛一本通祖孙询问距离
首先什么是最近公共祖先?? 如图:红色节点的祖先为红色的1, 2, 3. 绿色节点的祖先为绿色的1, 2, 3, 4. 他们的最近公共祖先即他们最先相交的地方,如在上图中黄色的点就是他们的最近公共祖先 ...

《面向对象程序设计》

第一章 绪论

第二章 面向对象程序设计关键

2.3.2析构函数

2.7多态

第三章面向对象应用

结束语

《面向对象程序设计》相关推荐

最新文章

热门文章

第一章绪论

第二章面向对象程序设计关键