C++详解

C++详解


文章目录

  • C++详解
    • [1 内存分区模型](#1 内存分区模型)
      • [1.1 程序运行前](#1.1 程序运行前)
      • [1.2 程序运行后](#1.2 程序运行后)
      • [1.3 new操作符](#1.3 new操作符)
    • [2 引用](#2 引用)
      • [2.1 引用的基本使用](#2.1 引用的基本使用)
      • [2.2 引用注意事项](#2.2 引用注意事项)
      • [2.3 引用做函数参数](#2.3 引用做函数参数)
      • [2.4 引用做函数返回值](#2.4 引用做函数返回值)
      • [2.5 引用的本质](#2.5 引用的本质)
      • [2.6 常量引用](#2.6 常量引用)
    • [3 函数提高](#3 函数提高)
      • [3.1 函数默认参数](#3.1 函数默认参数)
      • [3.2 函数占位参数](#3.2 函数占位参数)
      • [3.3 函数重载](#3.3 函数重载)
        • [3.3.1 函数重载概述](#3.3.1 函数重载概述)
        • [3.3.2 函数重载注意事项](#3.3.2 函数重载注意事项)
    • [4 类和对象](#4 类和对象)
      • [4.1 封装](#4.1 封装)
        • [4.1.1 封装的意义](#4.1.1 封装的意义)
        • [4.1.2 struct和class区别](#4.1.2 struct和class区别)
        • [4.1.3 成员属性设置为私有](#4.1.3 成员属性设置为私有)
      • [4.2 对象的初始化和清理](#4.2 对象的初始化和清理)
        • [4.2.1 构造函数和析构函数](#4.2.1 构造函数和析构函数)
        • [4.2.2 构造函数的分类及调用](#4.2.2 构造函数的分类及调用)
        • [4.2.3 拷贝构造函数调用时机](#4.2.3 拷贝构造函数调用时机)
        • [4.2.4 构造函数调用规则](#4.2.4 构造函数调用规则)
        • [4.2.5 深拷贝与浅拷贝](#4.2.5 深拷贝与浅拷贝)
        • [4.2.6 初始化列表](#4.2.6 初始化列表)
        • [4.2.7 类对象作为类成员](#4.2.7 类对象作为类成员)
        • [4.2.8 静态成员](#4.2.8 静态成员)
      • [4.3 C++对象模型和this指针](#4.3 C++对象模型和this指针)
        • [4.3.1 成员变量和成员函数分开存储](#4.3.1 成员变量和成员函数分开存储)
        • [4.3.2 this指针概念](#4.3.2 this指针概念)
        • [4.3.3 空指针访问成员函数](#4.3.3 空指针访问成员函数)
        • [4.3.4 const修饰成员函数](#4.3.4 const修饰成员函数)
        • [4.3.5 GradeBook类](#4.3.5 GradeBook类)
      • [4.4 友元](#4.4 友元)
        • [4.4.1 全局函数做友元](#4.4.1 全局函数做友元)
        • [4.4.2 类做友元](#4.4.2 类做友元)
        • [4.4.3 成员函数做友元](#4.4.3 成员函数做友元)
        • [4.4.4 Date类作为person类的友元](#4.4.4 Date类作为person类的友元)
      • [4.5 运算符重载](#4.5 运算符重载)
        • [4.5.1 加号运算符重载](#4.5.1 加号运算符重载)
        • [4.5.2 左移运算符重载](#4.5.2 左移运算符重载)
        • [4.5.3 递增运算符重载](#4.5.3 递增运算符重载)
        • [4.5.4 赋值运算符重载](#4.5.4 赋值运算符重载)
        • [4.5.5 关系运算符重载](#4.5.5 关系运算符重载)
        • [4.5.6 函数调用运算符重载](#4.5.6 函数调用运算符重载)
        • [4.5.7 重载+, - ,*, /, >>,<<运算符](#4.5.7 重载+, - ,*, /, >>,<<运算符)
      • [4.6 继承](#4.6 继承)
        • [4.6.1 继承的基本语法](#4.6.1 继承的基本语法)
        • [4.6.2 继承方式](#4.6.2 继承方式)
        • [4.6.3 继承中的对象模型](#4.6.3 继承中的对象模型)
        • [4.6.4 继承中构造和析构顺序](#4.6.4 继承中构造和析构顺序)
        • [4.6.5 继承同名成员处理方式](#4.6.5 继承同名成员处理方式)
        • [4.6.6 继承同名静态成员处理方式](#4.6.6 继承同名静态成员处理方式)
        • [4.6.7 多继承语法](#4.6.7 多继承语法)
        • [4.6.8 菱形继承](#4.6.8 菱形继承)
      • [4.7 多态](#4.7 多态)
        • [4.7.1 多态的基本介绍](#4.7.1 多态的基本介绍)
        • [4.7.2 纯虚函数和抽象类](#4.7.2 纯虚函数和抽象类)
        • [4.7.3 虚析构和纯虚析构](#4.7.3 虚析构和纯虚析构)
        • [4.7.4 多态案例一-计算器类](#4.7.4 多态案例一-计算器类)
        • [4.7.5 多态案例二-制作饮品](#4.7.5 多态案例二-制作饮品)
        • [4.7.6 多态案例三-电脑组装](#4.7.6 多态案例三-电脑组装)
        • [4.7.7 继承与多态案例](#4.7.7 继承与多态案例)
    • [5 文件操作](#5 文件操作)

1 内存分区模型

C++程序在执行时,将内存大方向划分为4个区域

  • 代码区:存放函数体的二进制代码,由操作系统进行管理的。
  • 全局区:存放全局变量和静态变量以及常量。
  • 栈区:由编译器自动分配释放, 存放函数的参数值,局部变量等。
  • 堆区:由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收。

内存四区意义:

​ 不同区域存放的数据,赋予不同的生命周期, 给我们更大的灵活编程。

1.1 程序运行前


​ 在程序编译后,生成了exe可执行程序,未执行该程序前分为两个区域。

代码区:

  • 存放 CPU 执行的机器指令。

  • 代码区是共享的,共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可。

  • 代码区是只读的,使其只读的原因是防止程序意外地修改了它的指令。

全局区:

  • 全局变量和静态变量存放在此。

  • 全局区还包含了常量区, 字符串常量和其他常量也存放在此。

  • 该区域的数据在程序结束后由操作系统释放。

例1.1.1

c++ 复制代码
#include <iostream>
#include <cstdint> // 为了使用 uintptr_t

using namespace std;

// 全局变量
int g_a = 10;
int g_b = 10;

// 全局常量
const int c_g_a = 10;
const int c_g_b = 10;

int main()
{
    // 局部变量
    int a = 10;
    int b = 10;

    // 打印地址
    cout << "局部变量a地址为: " << (void*)&a << endl;
    cout << "局部变量b地址为: " << (void*)&b << endl;

    cout << "全局变量g_a地址为: " << (void*)&g_a << endl;
    cout << "全局变量g_b地址为: " << (void*)&g_b << endl;

    // 静态变量
    static int s_a = 10;
    static int s_b = 10;

    cout << "静态变量s_a地址为: " << (void*)&s_a << endl;
    cout << "静态变量s_b地址为: " << (void*)&s_b << endl;

    cout << "字符串常量\"hello world\"地址为: " << (void*)"hello world" << endl;
    cout << "字符串常量\"hello world1\"地址为: " << (void*)"hello world1" << endl;

    cout << "全局常量c_g_a地址为: " << (void*)&c_g_a << endl;
    cout << "全局常量c_g_b地址为: " << (void*)&c_g_b << endl;

    const int c_l_a = 10;
    const int c_l_b = 10;
    cout << "局部常量c_l_a地址为: " << (void*)&c_l_a << endl;
    cout << "局部常量c_l_b地址为: " << (void*)&c_l_b << endl;

    return 0;
}

​ 结果如下:

C++ 复制代码
局部变量a地址为: 0x61fe1c
局部变量b地址为: 0x61fe18
全局变量g_a地址为: 0x403010
全局变量g_b地址为: 0x403014
静态变量s_a地址为: 0x403018
静态变量s_b地址为: 0x40301c
字符串常量"hello world"地址为: 0x4040a9
字符串常量"hello world1"地址为: 0x4040da
全局常量c_g_a地址为: 0x404004
全局常量c_g_b地址为: 0x404008
局部常量c_l_a地址为: 0x61fe14
局部常量c_l_b地址为: 0x61fe10

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

​ 总结:

  • C++中在程序运行前分为全局区和代码区。
  • 代码区特点是共享和只读。
  • 全局区中存放全局变量、静态变量、常量。
  • 常量区中存放 const修饰的全局常量 和 字符串常量。

1.2 程序运行后


栈区:

  • 由编译器自动分配释放, 存放函数的参数值,局部变量等。

  • 注意事项:不要返回局部变量的地址,栈区开辟的数据由编译器自动释放。

例1.2.1

C++ 复制代码
#include <iostream>

using namespace std;

int * func()
{
	int a = 10;
	return &a;
}

int main()
{

	int *p = func();

	cout << *p << endl;
	cout << *p << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
10
10

Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.

堆区:

  • 由程序员分配释放,若程序员不释放,程序结束时由操作系统回收。

  • 在C++中主要利用new在堆区开辟内存。

例1.2.2

C++ 复制代码
#include <iostream>

using namespace std;

int* func()
{
	int* a = new int(10);
	return a;
}

int main()
{

	int *p = func();

	cout << *p << endl;
	cout << *p << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
10
10

Process returned 0 (0x0)   execution time : 0.043 s
Press any key to continue.

总结:

  • 堆区数据由程序员管理开辟和释放。

  • 堆区数据利用new关键字进行开辟内存。

1.3 new操作符


​ C++中利用new操作符在堆区开辟数据。

​ 堆区开辟的数据,由程序员手动开辟,手动释放,释放利用操作符 delete

​ 语法: new 数据类型

​ 利用new创建的数据,会返回该数据对应的类型的指针。

例1.3.1

C++ 复制代码
#include <iostream>

using namespace std;

int* func()
{
	int* a = new int(10);
	return a;
}

int main()
{

	int *p = func();

	cout << *p << endl;
	cout << *p << endl;

	//利用delete释放堆区数据
	delete p;

	//cout << *p << endl; //报错,释放的空间不可访问

	return 0;
}

​ 结果如下:

C++ 复制代码
10
10

Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.

例1.3.2

C++ 复制代码
#include <iostream>

using namespace std;

//堆区开辟数组
int main()
{

	int* arr = new int[10];

	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;
	}

	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}

	//释放数组 delete 后加 []
	delete[] arr;

	return 0;
}

​ 结果如下:

C++ 复制代码
100
101
102
103
104
105
106
107
108
109

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

2 引用

2.1 引用的基本使用


作用: 给变量起别名

语法: 数据类型 &别名 = 原名

例2.1.1

C++ 复制代码
#include <iostream>

using namespace std;

int main()
{

	int a = 10;
	int &b = a;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	b = 100;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
a = 10
b = 10
a = 100
b = 100

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

2.2 引用注意事项


  • 引用必须初始化。
  • 引用在初始化后,不可以改变。

例2.2.1

C++ 复制代码
#include <iostream>

using namespace std;

int main()
{

	int a = 10;
	int b = 20;

	//int &c; //错误,引用必须初始化

	int &c = a; //一旦初始化后,就不可以更改
	c = b; //这是赋值操作,不是更改引用

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
a = 20
b = 20
c = 20

Process returned 0 (0x0)   execution time : 0.026 s
Press any key to continue.

2.3 引用做函数参数


作用: 函数传参时,可以利用引用的技术让形参修饰实参。

优点: 可以简化指针修改实参。

例2.3.1

C++ 复制代码
#include <iostream>

using namespace std;

//1. 值传递
void mySwap01(int a, int b) 
{
	int temp = a;
	a = b;
	b = temp;
}

//2. 地址传递
void mySwap02(int* a, int* b) 
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//3. 引用传递
void mySwap03(int& a, int& b) 
{
	int temp = a;
	a = b;
	b = temp;
}

int main() 
{
	int a = 10;
	int b = 20;

	mySwap01(a, b);
	cout << "a:" << a << " b:" << b << endl;

	mySwap02(&a, &b);
	cout << "a:" << a << " b:" << b << endl;

	mySwap03(a, b);
	cout << "a:" << a << " b:" << b << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
a:10 b:20
a:20 b:10
a:10 b:20

Process returned 0 (0x0)   execution time : 0.039 s
Press any key to continue.

总结:

  • 通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单。

2.4 引用做函数返回值


​ 作用:引用是可以作为函数的返回值存在的。

​ 注意:不要返回局部变量引用。

​ 用法:函数调用作为左值。

例2.4.1

C++ 复制代码
#include <iostream>

using namespace std;

//返回局部变量引用
int& test01()
{
	int a = 10; //局部变量
	return a;
}

//返回静态变量引用
int& test02()
{
	static int a = 20; // 静态变量,存放在全局区,全局区上的数据在程序结束后系统释放
	return a;
}

int main()
{
	//不能返回局部变量的引用
	//int& ref1 = test01();
	//cout << "ref1 = " << ref1 << endl; // 程序崩溃

	//如果函数做左值,那么必须返回引用
	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;

	test02() = 1000; // 如果函数的返回值是引用,这个函数调用可以作为左值。

	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
ref2 = 20
ref2 = 20
ref2 = 1000
ref2 = 1000

Process returned 0 (0x0)   execution time : 0.038 s
Press any key to continue.

2.5 引用的本质


​ 本质:引用的本质在c++内部实现是一个指针常量。

例2.5.1

C++ 复制代码
#include <iostream>

using namespace std;

//发现是引用,转换为 int* const ref = &a;
void func(int& ref)
{
	ref = 100; // ref是引用,转换为*ref = 100
}
int main()
{
	int a = 10;

    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改,也说明为什么引用不可更改
	int& ref = a;
	ref = 20; //内部发现ref是引用,自动帮我们转换为: *ref = 20;

	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;

	func(a);

	return 0;
}

​ 结果如下:

C++ 复制代码
a:20
ref:20

Process returned 0 (0x0)   execution time : 0.034 s
Press any key to continue.

结论:

  • C++推荐用引用技术,因为语法方便,引用本质是指针常量,但是所有的指针操作编译器都帮我们做了。

2.6 常量引用


作用: 常量引用主要用来修饰形参,防止误操作。

​ 在函数形参列表中,可以加const修饰形参,防止形参改变实参。

例2.6.1

C++ 复制代码
#include <iostream>

using namespace std;

//引用使用的场景,通常用来修饰形参
void showValue(const int& v)
{
	//v += 10;
	cout << v << endl;
}

int main()
{

	//int& ref = 10;  引用本身需要一个合法的内存空间,因此这行错误
	//加入const就可以了,编译器优化代码,int temp = 10; const int& ref = temp;
	const int& ref = 10;

	//ref = 100;  //加入const后不可以修改变量
	cout << ref << endl;

	//函数中利用常量引用防止误操作修改实参
	int a = 10;
	showValue(a);

	return 0;
}

​ 结果如下:

C++ 复制代码
10
10

Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.

3 函数提高


3.1 函数默认参数


​ 在C++中,函数的形参列表中的形参是可以有默认值的。

​ 语法: 返回值类型 函数名 (参数= 默认值){}

例3.1.1

C++ 复制代码
#include <iostream>

using namespace std;

int func(int a, int b = 10, int c = 10)
{
	return a + b + c;
}

//1. 如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值
//2. 如果函数声明有默认值,函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);

int func2(int a, int b)
{
	return a + b;
}

int main()
{

	cout << "ret = " << func(20, 20) << endl;
	cout << "ret = " << func(100) << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
ret = 50
ret = 120

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

3.2 函数占位参数


​ C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置。

语法: 返回值类型 函数名 (数据类型){}

例3.2.2

C++ 复制代码
#include <iostream>

using namespace std;

//函数占位参数 ,占位参数也可以有默认参数
void func(int a, int)
{
	cout << "this is func" << endl;
}

int main()
{

	func(10,10); //占位参数必须填补

	return 0;
}

​ 结果如下:

C++ 复制代码
this is func

Process returned 0 (0x0)   execution time : 0.009 s
Press any key to continue.

3.3 函数重载


3.3.1 函数重载概述

作用: 函数名可以相同,提高复用性。

函数重载满足条件:

  • 同一个作用域下。
  • 函数名称相同。
  • 函数参数类型不同 或者 个数不同 或者 顺序不同。

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

例3.3.1

C++ 复制代码
#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 ,double b)
{
	cout << "func (int a ,double b) 的调用!" << endl;
}
void func(double a ,int b)
{
	cout << "func (double a ,int b)的调用!" << endl;
}

//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
//	cout << "func (double a ,int b)的调用!" << endl;
//}


int main()
{
	func();
	func(10);
	func(3.14);
	func(10,3.14);
	func(3.14 , 10);

	return 0;
}

​ 结果如下:

C++ 复制代码
func 的调用!
func (int a) 的调用!
func (double a)的调用!
func (int a ,double b) 的调用!
func (double a ,int b)的调用!

Process returned 0 (0x0)   execution time : 0.037 s
Press any key to continue.
3.3.2 函数重载注意事项

  • 引用作为重载条件。
  • 函数重载碰到函数默认参数。

例3.3.2

C++ 复制代码
#include <iostream>

using namespace std;

//函数重载注意事项
//1、引用作为重载条件

void func(int &a)
{
	cout << "func (int &a) 调用 " << endl;
}

void func(const int &a)
{
	cout << "func (const int &a) 调用 " << endl;
}


//2、函数重载碰到函数默认参数

void func2(int a, int b = 10)
{
	cout << "func2(int a, int b = 10) 调用" << endl;
}

void func2(int a)
{
	cout << "func2(int a) 调用" << endl;
}

int main()
{

	int a = 10;
	func(a); //调用无const
	func(10);//调用有const

	//func2(10); //碰到默认参数产生歧义,需要避免

	return 0;
}

​ 结果如下:

c++ 复制代码
func (int &a) 调用
func (const int &a) 调用

Process returned 0 (0x0)   execution time : 0.006 s
Press any key to continue.

4 类和对象


​ C++面向对象的三大特性为:封装、继承、多态

​ C++认为万事万物都皆为对象,对象上有其属性和行为

例如:

  • 人可以作为对象,属性有姓名、年龄、身高、体重...,行为有走、跑、跳、吃饭、唱歌...

  • 车也可以作为对象,属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...

  • 具有相同性质的对象,我们可以抽象称为类,人属于人类,车属于车类

4.1 封装


4.1.1 封装的意义

​ 封装是C++面向对象三大特性之一

语法: class 类名{ 访问权限: 属性 / 行为 };

封装的意义

  • 在设计类的时候,属性和行为写在一起,表现事物。

  • 类在设计时,可以把属性和行为放在不同的权限下,加以控制

    访问权限有三种:

    1. public 公共权限
    2. protected 保护权限
    3. private 私有权限

例4.1.1.1 设计一个圆类,求圆的周长。

C++ 复制代码
#include <iostream>

using namespace std;

//圆周率
const double PI = 3.14;

//1、封装的意义
//将属性和行为作为一个整体,用来表现生活中的事物

//封装一个圆类,求圆的周长
//class代表设计一个类,后面跟着的是类名
class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main()
{

	//通过圆类,创建圆的对象
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作

	//2 * pi * 10 = = 62.8
	cout << "圆的周长为: " << c1.calculateZC() << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
圆的周长为: 62.8

Process returned 0 (0x0)   execution time : 0.008 s
Press any key to continue.

例4.1.1.2 设计一个学生类,属性有姓名和学号,可以给姓名和学号赋值,可以显示学生的姓名和学号。

C++ 复制代码
#include <iostream>

using namespace std;

//学生类
class Student
{
public:
	void setName(string name)
	{
		m_name = name;
	}
	void setID(int id)
	{
		m_id = id;
	}

	void showStudent()
	{
		cout << "name:" << m_name << '\n' << "ID:" << m_id << endl;
	}
public:
	string m_name;
	int m_id;
};

int main()
{
	Student stu;
	stu.setName("小杜");
	stu.setID(10086);
	stu.showStudent();

	return 0;
}

​ 结果如下:

C++ 复制代码
name:小杜
ID:10086

Process returned 0 (0x0)   execution time : 0.009 s
Press any key to continue.

例4.1.1.3

C++ 复制代码
#include <iostream>

using namespace std;

// 三种权限
// 公共权限  public     类内可以访问  类外可以访问
// 保护权限  protected  类内可以访问  类外不可以访问
// 私有权限  private    类内可以访问  类外不可以访问

class Person
{
public:
	string m_Name; // 姓名  公共权限
    void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}

protected:
	string m_Car; // 汽车  保护权限

private:
	int m_Password; // 银行卡密码  私有权限

};

int main()
{
	Person p;

	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	return 0;
}

​ 结果如下:

C++ 复制代码
Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.
4.1.2 struct和class区别

​ 在C++中 struct和class唯一的区别 就在于 默认的访问权限不同

区别

  • struct 默认权限为公共
  • class 默认权限为私有

例4.1.2

C++ 复制代码
#include <iostream>

using namespace std;

class C1
{
	int  m_A; //默认是私有权限
};

struct C2
{
	int m_A;  //默认是公共权限
};

int main()
{

	//C1 c1;
	//c1.m_A = 10; //错误,访问权限是私有

	C2 c2;
	c2.m_A = 10; //正确,访问权限是公共

	return 0;
}

​ 结果如下:

C++ 复制代码
Process returned 0 (0x0)   execution time : 0.010 s
Press any key to continue.
4.1.3 成员属性设置为私有

优点

  • 将所有成员属性设置为私有,可以自己控制读写权限。
  • 对于写权限,我们可以检测数据的有效性。

例4.1.3

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	//姓名设置可读可写
	void setName(string name)
	{
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}

	//获取年龄
	int getAge()
	{
		return m_Age;
	}

	//设置年龄
	void setAge(int age)
	{
		if (age < 0 || age > 150)
        {
			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.setAge(50);
	cout << "年龄: " << p.getAge() << endl;

	//情人设置
	p.setLover("苍井");
	//cout << "情人: " << p.m_Lover << endl;  //只写属性,不可以读取

	return 0;
}

​ 结果如下:

C++ 复制代码
姓名: 张三
年龄: 50

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

4.2 对象的初始化和清理


  • 生活中我们买的电子产品都基本会有出厂设置,在某一天我们不用时候也会删除一些自己信息数据保证安全。
  • C++中的面向对象来源于生活,每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。
4.2.1 构造函数和析构函数

​ 对象的初始化和清理也是两个非常重要的安全问题

  • 一个对象或者变量没有初始状态,对其使用后果是未知。

  • 同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题。

​ c++利用了构造函数析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。

​ 对象的初始化和清理工作是编译器强制要我们做的事情,因此如果我们不提供构造和析构,编译器会提供

编译器提供的构造函数和析构函数是空实现。

  • 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
  • 析构函数 :主要作用在于对象销毁前系统自动调用,执行一些清理工作。

构造函数语法: 类名(){}

  1. 构造函数,没有返回值也不写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数,因此可以发生重载
  4. 程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次

析构函数语法: ~类名(){}

  1. 析构函数,没有返回值也不写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数,因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次

例4.2.1

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

void test01()
{
	Person p;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
Person的构造函数调用
Person的析构函数调用

Process returned 0 (0x0)   execution time : 0.012 s
Press any key to continue.
4.2.2 构造函数的分类及调用

​ 两种分类方式:

  • 按参数分为: 有参构造和无参构造

  • 按类型分为: 普通构造和拷贝构造

​ 三种调用方式:

  • 括号法

  • 显示法

  • 隐式转换法

例4.2.2

C++ 复制代码
#include <iostream>

using namespace std;

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person
{
public:
	//无参(默认)构造函数
	Person()
	{
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a)
	{
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01()
{
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02()
{

	//2.1  括号法,常用
	Person p1(10);
	//注意1:调用无参构造函数不能加括号,如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10);
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后,马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10);
	Person p5 = p4; // Person p5 = Person(p4);

	//注意2:不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main()
{

	test01();
	//test02();

	return 0;
}

​ 结果如下:

C++ 复制代码
无参构造函数!
析构函数!

Process returned 0 (0x0)   execution time : 0.015 s
Press any key to continue.
4.2.3 拷贝构造函数调用时机

​ C++中拷贝构造函数调用时机通常有三种情况

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

例4.2.3

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	Person()
    {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age)
	{
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p)
	{
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person()
	{
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数,赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}

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();

	return 0;
}

​ 结果如下:

C++ 复制代码
无参构造函数!
0x61fddc
0x61fddc
析构函数!

Process returned 0 (0x0)   execution time : 0.014 s
Press any key to continue.
4.2.4 构造函数调用规则

​ 默认情况下,c++编译器至少给一个类添加3个函数

1.默认构造函数(无参,函数体为空)

2.默认析构函数(无参,函数体为空)

3.默认拷贝构造函数,对属性进行值拷贝

​ 构造函数调用规则如下:

  • 如果用户定义有参构造函数,c++不在提供默认无参构造,但是会提供默认拷贝构造。

  • 如果用户定义拷贝构造函数,c++不会再提供其他构造函数。

例4.2.4

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	//无参(默认)构造函数
	Person()
	{
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a)
    {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

void test01()
{
	Person p1(18);
	//如果不写拷贝构造,编译器会自动添加拷贝构造,并且做浅拷贝操作
	Person p2(p1);

	cout << "p2的年龄为:" << p2.age << endl;
}

void test02()
{
	//如果用户提供有参构造,编译器不会提供默认构造,会提供拷贝构造
	Person p1; //此时如果用户自己没有提供默认构造,会出错
	Person p2(10); //用户提供的有参
	Person p3(p2); //此时如果用户没有提供拷贝构造,编译器会提供

	//如果用户提供拷贝构造,编译器不会提供其他构造函数
	Person p4; //此时如果用户自己没有提供默认构造,会出错
	Person p5(10); //此时如果用户自己没有提供有参,会出错
	Person p6(p5); //用户自己提供拷贝构造
}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

c++ 复制代码
有参构造函数!
拷贝构造函数!
p2的年龄为:18
析构函数!
析构函数!

Process returned 0 (0x0)   execution time : 0.038 s
Press any key to continue.
4.2.5 深拷贝与浅拷贝

  • 浅拷贝:简单的赋值拷贝操作。

  • 深拷贝:在堆区重新申请空间,进行拷贝操作。

例4.2.5

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	//无参(默认)构造函数
	Person()
	{
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height)
	{
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);

	}
	//拷贝构造函数
	Person(const Person& p)
	{
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存,会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
	}

	//析构函数
	~Person()
	{
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄:" << p1.m_age << " 身高:" << *p1.m_height << endl;

	cout << "p2的年龄:" << p2.m_age << " 身高:" << *p2.m_height << endl;
}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
有参构造函数!
拷贝构造函数!
p1的年龄:18 身高:180
p2的年龄:18 身高:180
析构函数!
析构函数!

Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.
4.2.6 初始化列表

作用:

  • C++提供了初始化列表语法,用来初始化属性。

语法: 构造函数():属性1(值1),属性2(值2)... {}

例4.2.6

C++ 复制代码
#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 << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main()
{
	Person p(1, 2, 3);
	p.PrintPerson();

	return 0;
}

​ 结果如下:

C++ 复制代码
mA:1
mB:2
mC:3

Process returned 0 (0x0)   execution time : 0.036 s
Press any key to continue.
4.2.7 类对象作为类成员

​ C++类中的成员可以是另一个类的对象,我们称该成员为 对象成员。

例4.2.7.1

C++ 复制代码
class A {}
class B
{
    A a;
}

​ B类中有对象A作为成员,A为对象成员。

​ 那么当创建B对象时,A与B的构造和析构的顺序是谁先谁后?

例4.2.7.2

C++ 复制代码
#include <iostream>

using namespace std;

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时,我们称该成员为 对象成员
	//构造的顺序是 :先调用对象成员的构造,再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
Phone构造
Person构造
张三 使用苹果X 牌手机!
Person析构
Phone析构

Process returned 0 (0x0)   execution time : 0.009 s
Press any key to continue.
4.2.8 静态成员

​ 静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员。

​ 静态成员分为:

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明,类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

例4.2.8.1

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	static int m_A; //静态成员变量

	//静态成员变量特点:
	//1 在编译阶段分配内存
	//2 类内声明,类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};

int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;

	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
p1.m_A = 100
p1.m_A = 200
p2.m_A = 200
m_A = 200

Process returned 0 (0x0)   execution time : 0.009 s
Press any key to continue.

4.2.9 GradeBook 类

​ 题目如下:

​ 上机实验一,参考上课范例,完成 GradeBook 类(class)设计。将类定义(class definition)写在 GradeBook.h 中。 将成员函数(member function)写在 GradeBook.cpp 中。编程一个主程序(main)创建两个 GradeBook 对象,测试类的所有成员函数。

GradeBook

c++ 复制代码
-courseName: string //at most 25 characters
-studentCount : int //number of student
-grade: double[] //double array to hold student grades
+setCourseName(name:string)
+setStudentCount(id : int)
+getCourseName():string
+getStudentCount():int
+print() //to display information of GradeBook object

程序接口示范

​ 上机实验一

​ 编程设计者 王小明 221040700101

​ 请输入课程名称:Object Oriented Programming

​ 请输入学生人数: 120

​ 利用 getCourseName 以及 getStudentCount 显示第一个对象的信息:

​ 课程名称:Object Oriented Programming

​ 学生人数: 120

​ 请输入课程名称:Linear Algebra

​ 请输入学生人数: 125

​ 利用 print 显示第二个对象的信息:

​ 课程名称:Linear Algebra

​ 学生人数: 125

​ 解答如下:

​ main.cpp

c++ 复制代码
#include <iostream>
#include "Person.h"
using namespace std;

int main()
{
    Person myPerson;
    // Person myPerson("S.M.Wang", 070145, "莲花路200号");

    cout << "请输入姓名:" ;
    string name;
    cin >> name;

    cout << "请输入ID:" ;
    int id;
    cin >> id;

    cout << "请输入住址:" ;
    string address;
    cin >> address;

    myPerson.setName(name);
    myPerson.setID(id);
    myPerson.setAddress(address);

    myPerson.print();
    return 0;
}

​ Person.h

c++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
    Person();
    Person(string name, int id, string address);
    ~Person();

    void setPerson(string name, int id, string address);
    void setName(string name);
    void setID(int id);
    void setAddress(string address);

    string getName();
    int getID();
    string getAddress();

    void print(); // outPutResult
private:
    string Name;
    int ID;
    string Address;
};

​ Person.cpp

c++ 复制代码
#include "Person.h"

using namespace std;

Person::Person()
{
    Name = "S.M.Wang";
    ID = 070145;
    Address = "莲花路200号";
}

Person::Person(string name, int id, string address)
{
    setPerson(name, id, address);
}

Person::~Person()
{
    cout << "object Destructor is called" << endl;
}


void Person::setPerson(string name, int id, string address)
{
    Name = name;
    ID = id;
    Address = address;
}


void Person::setName(string name)
{
    Name = name;
}

void Person::setID(int id)
{
    ID = id;
}

void Person::setAddress(string address)
{
    Address = address;
}

string Person::getName()
{
    return Name;
}

int Person::getID()
{
    return ID;
}

string Person::getAddress()
{
    return Address;
}

void Person::print()
{
    cout << "姓名:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "住址:" << getAddress() << endl;
}

​ 结果如下:

c++ 复制代码
请输入姓名:王小明
请输入ID:22104070
请输入住址:莲花路200号
姓名:王小明
ID:22104070
住址:莲花路200号
object Destructor is called

Process returned 0 (0x0)   execution time : 15.911 s
Press any key to continue.

4.3 C++对象模型和this指针


4.3.1 成员变量和成员函数分开存储

  • 在C++中,类内的成员变量和成员函数分开存储。

  • 只有非静态成员变量才属于类的对象上。

例4.3.1

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	Person()
	{
		mA = 0;
	}
	//非静态成员变量占对象空间
	int mA;
	//静态成员变量不占对象空间
	static int mB;
	//函数也不占对象空间,所有函数共享一个函数实例
	void func()
	{
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间
	static void sfunc()
	{

	}
};

int main()
{

	cout << sizeof(Person) << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
4

Process returned 0 (0x0)   execution time : 0.013 s
Press any key to continue.
4.3.2 this指针概念

​ c++通过提供特殊的对象指针,this指针,解决区分对象调用自己的问题。this指针指向被调用的成员函数所属的对象

​ 指针是隐含每一个非静态成员函数内的一种指针。

​ this指针不需要定义,直接使用即可。

​ this指针的用途:

  • 当形参和成员变量同名时,可用this指针来区分。
  • 在类的非静态成员函数中返回对象本身,可使用return *this。

例4.3.2

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:

	Person(int age)
	{
		//1、当形参和成员变量同名时,可用this指针来区分
		this->age = age;
	}

	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		//返回对象本身
		return *this;
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
p1.age = 10
p2.age = 40

Process returned 0 (0x0)   execution time : 0.026 s
Press any key to continue.
4.3.3 空指针访问成员函数

  • C++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针。

  • 如果用到this指针,需要加以判断保证代码的健壮性。

例4.3.3

C++ 复制代码
#include <iostream>

using namespace std;

//空指针访问成员函数
class Person
{
public:
	void ShowClassName()
	{
		cout << "我是Person类!" << endl;
	}

	void ShowPerson()
	{
		if (this == NULL)
        {
			return;
		}
		cout << mAge << endl;
	}

public:
	int mAge;
};

void test01()
{
	Person * p = NULL;
	p->ShowClassName(); //空指针,可以调用成员函数
	p->ShowPerson();  //但是如果成员函数中用到了this指针,就不可以了
}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
我是Person类!

Process returned 0 (0x0)   execution time : 0.003 s
Press any key to continue.
4.3.4 const修饰成员函数

常函数:

  • 成员函数后加const后我们称为这个函数为常函数
  • 常函数内不可以修改成员属性。
  • 成员属性声明时加关键字mutable后,在常函数中依然可以修改。

常对象:

  • 声明对象前加const称该对象为常对象。
  • 常对象只能调用常函数。

例4.3.4

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	Person()
	{
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是一个指针常量,指针的指向不可修改
	//如果想让指针指向的值也不可以修改,需要声明常函数
	void ShowPerson() const
	{
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数,表示指针指向的内存空间的数据不能修改,除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const
	{
		//mA = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可变的
};


//const修饰对象  常对象
void test01()
{

	const Person person; //常量对象
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

	//常对象访问成员函数
	person.MyFunc(); //常对象不能调用const的函数

}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
0

Process returned 0 (0x0)   execution time : 0.008 s
Press any key to continue.
4.3.5 GradeBook类

​ 题目如下:

​ 上机实验一,参考上课范例,完成 GradeBook 类(class)设计。

​ 将类定义(class definition)写在 GradeBook.h 中。 将成员函数(member function)写在 GradeBook.cpp 中。编程一个主程序(main)创建两个 GradeBook 对象,测试类的所有成员函数。

GradeBook

C++ 复制代码
-courseName: string //at most 25 characters
-studentCount : int //number of student
-grade: double[] //double array to hold student grades
+setCourseName(name:string)
+setStudentCount(id : int)
+getCourseName():string
+getStudentCount():int
+print() //to display information of GradeBook object

​ 程序接口示范

​ 编程设计者 王小明 221040700101

​ 请输入课程名称:Object Oriented Programming

​ 请输入学生人数: 120

​ 利用 getCourseName 以及 getStudentCount 显示第一个对象的信息:

​ 课程名称:Object Oriented Programming

​ 学生人数: 120

​ 请输入课程名称:Linear Algebra

​ 请输入学生人数: 125

​ 利用 print 显示第二个对象的信息:

​ 课程名称:Linear Algebra

​ 学生人数: 125

​ 解答如下:

​ main.cpp

C++ 复制代码
#include <iostream>
#include "Person.h"
using namespace std;

int main()
{
    Person myPerson;
    // Person myPerson("S.M.Wang", 070145, "莲花路200号");

    cout << "请输入姓名:" ;
    string name;
    cin >> name;

    cout << "请输入ID:" ;
    int id;
    cin >> id;

    cout << "请输入住址:" ;
    string address;
    cin >> address;

    myPerson.setName(name);
    myPerson.setID(id);
    myPerson.setAddress(address);

    myPerson.print();
    return 0;
}

Person.h

C++ 复制代码
#include <iostream>
 
using namespace std;
 
class Person
{
public:
    Person();
    Person(string name, int id, string address);
    ~Person();
 
    void setPerson(string name, int id, string address);
    void setName(string name);
    void setID(int id);
    void setAddress(string address);
 
    string getName();
    int getID();
    string getAddress();
 
    void print(); // outPutResult
private:
    string Name;
    int ID;
    string Address;
};

Person.cpp

C++ 复制代码
#include "Person.h"
 
using namespace std;
 
Person::Person()
{
    Name = "S.M.Wang";
    ID = 070145;
    Address = "莲花路200号";
}
 
Person::Person(string name, int id, string address)
{
    setPerson(name, id, address);
}
 
Person::~Person()
{
    cout << "object Destructor is called" << endl;
}
 
 
void Person::setPerson(string name, int id, string address)
{
    Name = name;
    ID = id;
    Address = address;
}
 
 
void Person::setName(string name)
{
    Name = name;
}
 
void Person::setID(int id)
{
    ID = id;
}
 
void Person::setAddress(string address)
{
    Address = address;
}
 
string Person::getName()
{
    return Name;
}
 
int Person::getID()
{
    return ID;
}
 
string Person::getAddress()
{
    return Address;
}
 
void Person::print()
{
    cout << "姓名:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "住址:" << getAddress() << endl;
}

结果如下:

C++ 复制代码
请输入姓名:S.M.Wang
请输入ID:070145
请输入住址:莲花路200号
姓名:S.M.Wang
ID:70145
住址:莲花路200号
object Destructor is called

Process returned 0 (0x0)   execution time : 27.263 s
Press any key to continue.

4.4 友元


​ 生活中你的家有客厅(Public),有你的卧室(Private)。

​ 客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去。

​ 但是呢,你也可以允许你的好闺蜜好基友进去。

​ 在程序里,有些私有属性 也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术。

​ 友元的目的就是让一个函数或者类 访问另一个类中私有成员。

​ 友元的关键字为 friend

​ 友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元
4.4.1 全局函数做友元

例4.4.1

C++ 复制代码
#include <iostream>

using namespace std;

class Building
{
	//告诉编译器 goodGay全局函数 是 Building类的好朋友,可以访问类中的私有内容
	friend void goodGay(Building * building);

public:

	Building()
	{
		this->m_SittingRoom = "客厅";
		this->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 b;
	goodGay(&b);
}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
好基友正在访问: 客厅
好基友正在访问: 卧室

Process returned 0 (0x0)   execution time : 0.032 s
Press any key to continue.
4.4.2 类做友元

例4.4.2

C++ 复制代码
#include <iostream>

using namespace std;

class Building;

class goodGay
{
public:

	goodGay();
	void visit();

private:
	Building *building;
};


class Building
{
	//告诉编译器 goodGay类是Building类的好朋友,可以访问到Building类中私有内容
	friend class goodGay;

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->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();

	return 0;
}

​ 结果如下:

C++ 复制代码
好基友正在访问客厅
好基友正在访问卧室

Process returned 0 (0x0)   execution time : 0.009 s
Press any key to continue.
4.4.3 成员函数做友元

例4.4.3

C++ 复制代码
#include <iostream>

using namespace std;

class Building;

class goodGay
{
public:

	goodGay();
	void visit(); //只让visit函数作为Building的好朋友,可以发访问Building中私有内容
	void visit2();

private:
	Building *building;
};


class Building
{
	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友,可以访问私有内容
	friend void goodGay::visit();

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	cout << "好基友正在访问" << building->m_BedRoom << endl;
}

void goodGay::visit2()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	//cout << "好基友正在访问" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay  gg;
	gg.visit();

}

int main()
{
	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
好基友正在访问客厅
好基友正在访问卧室

Process returned 0 (0x0)   execution time : 0.013 s
Press any key to continue.
4.4.4 Date类作为person类的友元

​ 题目如下:

​ 上机实验三,沿用上机实验二的Person类,设计一个Date类,并在Person中增加Date的对象Birthday(has a)。将类定义(class definition)写在 Person.h 及 Date.h 中。 将成员函数(member function)写在 person.cpp 及 Date.cpp中。

​ 编程一個主程式(main) 在主程序中建构两个 Person 对象,一个用全预设值,另一个给定所有的参数。 测试所有的功能,打印(print())对象的内容。

Date

c++ 复制代码
<<constructor>>+Date(y : int = 0, m : int = 0,d : int = 0)
<<destructor>>+~Date()
+setYear(y : int) : void
+setMonth(m : int) : void
+setDay(d : int) : void
+getYear() : int
+getMonth() : int
+getDay() : int
+print() : void
-Year : int
-Month : int
-Day : int

Person

c++ 复制代码
-Name : string
-ID : int
-Address : string
-Birthday: Date
<<constructor>> +Person(name : string = "", id : int =
0, address : string = "", Date = Date())
<<desctructor>> +~Person()
+setName(name : string)
+getName() : string
+setID(id : int)
+getID() : int
+setAddress(address : string)
+getAddress() : string
+setBirthday(d : Date)
+getBirthday() : Date
+print() : void

​ 解答如下:

​ main.cpp

c++ 复制代码
#include <iostream>
#include "Person.h"
using namespace std;

int main()
{
    Person myPerson;
    // Person myPerson("S.M.Wang", 070145, "莲花路200号");

    cout << "请输入姓名:" ;
    string name;
    cin >> name;

    cout << "请输入ID:" ;
    int id;
    cin >> id;

    cout << "请输入住址:" ;
    string address;
    cin >> address;

    Date myDate;

    cout << "请输入生日年:" ;
    int year;
    cin >> year;

    cout << "请输入生日月:" ;
    int month;
    cin >> month;

    cout << "请输入生日天:" ;
    int day;
    cin >> day;

    myPerson.setName(name);
    myPerson.setID(id);
    myPerson.setAddress(address);

    myDate.setYear(year);
    myDate.setMonth(month);
    myDate.setDay(day);

    myPerson.setBirthday(myDate); // 调用的形参为类

    myPerson.print();
    return 0;
}

​ Person.h

c++ 复制代码
#include <iostream>
#include "Date.h"
using namespace std;

class Person
{
public:
    Person();
    Person(string name, int id, string address);
    ~Person();

    void setPerson(string name, int id, string address);
    void setName(string name);
    void setID(int id);
    void setAddress(string address);
    void setBirthday(Date d);

    string getName();
    int getID();
    string getAddress();
    Date getBirthday();

    void print(); // outPutResult
private:
    string Name;
    int ID;
    string Address;
    Date Birthday;
};

​ Date.h

c++ 复制代码
#include <iostream>

using namespace std;


class Date
{
    friend class Person;
public:
    Date();
    Date(int y, int m, int d);
    ~Date();

    void setYear(int y);
    void setMonth(int m);
    void setDay(int d);

    int getYear();
    int getMonth();
    int getDay();

    void print();
private:
    int Year;
    int Month;
    int Day;

};

​ Person.cpp

c++ 复制代码
#include "Person.h"
#include <iostream>
using namespace std;

Person::Person()
{
    Name = "S.M.Wang";
    ID = 070145;
    Address = "莲花路200号";
}

Person::Person(string name, int id, string address)
{
    setPerson(name, id, address);
}

Person::~Person()
{
    //cout << "object Destructor is called" << endl;
}


void Person::setPerson(string name, int id, string address)
{
    Name = name;
    ID = id;
    Address = address;
}


void Person::setName(string name)
{
    Name = name;
}

void Person::setID(int id)
{
    ID = id;
}

void Person::setAddress(string address)
{
    Address = address;
}

string Person::getName()
{
    return Name;
}

int Person::getID()
{
    return ID;
}

string Person::getAddress()
{
    return Address;
}


void Person::setBirthday(Date d) // 调用的形参是类
{
    Birthday = d;
}

Date Person::getBirthday() // 返回的是类
{
    return Birthday;
}

void Person::print()
{
    cout << "Name:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "Address:" << getAddress() << endl;
    
    cout << "Birthday:" << getBirthday().getYear(); // getBirthday()返回的是类,再调用类中的子函数满足cout的返回值。
    cout << " " << getBirthday().getMonth();
    cout << " " << getBirthday().getDay() << endl;
}

​ Date.cpp

c++ 复制代码
#include "Date.h"
#include <iostream>
using namespace std;

Date::Date()
{
    Year = 0;
    Month = 0;
    Day = 0;
}

Date::Date(int year, int month, int day)
{
    setYear(year);
    setMonth(month);
    setDay(day);
}

Date::~Date()
{
    //cout << "object Destructor is called" << endl;
}


void Date::setYear(int year)
{
    Year = year;
}

void Date::setMonth(int month)
{
    Month = month;
}

void Date::setDay(int day)
{
    Day = day;
}

int Date::getYear()
{
    return Year;
}

int Date::getMonth()
{
    return Month;
}

int Date::getDay()
{
    return Day;
}

void Date::print()
{
    cout << "Year :" << getYear() << endl;
    cout << "Month :" << getMonth() << endl;
    cout << "Day :" << getDay() << endl;
}

​ 结果如下:

c++ 复制代码
请输入姓名:S.M.Wang
请输入ID:070145
请输入住址:莲花路200号
请输入生日年:2000
请输入生日月:1
请输入生日天:1
Name:S.M.Wang
ID:70145
Address:莲花路200号
Birthday:2000 1 1

Process returned 0 (0x0)   execution time : 49.737 s
Press any key to continue.

4.5 运算符重载


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

4.5.1 加号运算符重载

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

例4.5.1

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) 
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) 
//{
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() 
{

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() 
{
	test();

	return 0;
}

​ 结果如下:

C++ 复制代码
mA:30 mB:30
mA:40 mB:40

Process returned 0 (0x0)   execution time : 0.179 s
Press any key to continue.
  • 对于内置的数据类型的表达式的的运算符是不可能改变的。

  • 不要滥用运算符重载。

4.5.2 左移运算符重载

​ 作用:重载左移运算符配合友元可以实现输出自定义数据类型。

例4.5.2

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了  p << cout 不是我们想要的效果
	//void operator<<(Person& p)
	//{
	//
	//}

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p)
{
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test()
{

	Person p1(10, 20);

	cout << p1 << '\n' << "hello world" << endl; //链式编程
}

int main()
{
	test();

	return 0;
}

​ 结果如下:

C++ 复制代码
a:10 b:20
hello world

Process returned 0 (0x0)   execution time : 0.007 s
Press any key to continue.
4.5.3 递增运算符重载

作用

  • 通过重载递增运算符,实现自己的整型数据。
  • 前置递增返回引用,后置递增返回值。

例4.5.3

C++ 复制代码
#include <iostream>

using namespace std;

class MyInteger
{

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger()
	{
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++()
	{
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++
	MyInteger operator++(int)
	{
		//先返回
		MyInteger temp = *this; //记录当前本身的值,然后让本身的值加1,但是返回的是以前的值,达到先返回后++;
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};


ostream& operator<<(ostream& out, MyInteger myint)
{
	out << myint.m_Num;
	return out;
}


//前置++ 先++ 再返回
void test01()
{
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02()
{

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main()
{

	test01();
	test02();

	return 0;
}

​ 结果如下:

C++ 复制代码
1
1
0
1

Process returned 0 (0x0)   execution time : 0.007 s
Press any key to continue.
4.5.4 赋值运算符重载

​ c++编译器至少给一个类添加4个函数

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

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

例4.5.4

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //赋值操作

	cout << "p1的年龄为:" << *p1.m_Age << endl;

	cout << "p2的年龄为:" << *p2.m_Age << endl;

	cout << "p3的年龄为:" << *p3.m_Age << endl;
}

int main()
{

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	return 0;
}

​ 结果如下:

C++ 复制代码
p1的年龄为:18
p2的年龄为:18
p3的年龄为:18

Process returned 0 (0x0)   execution time : 0.109 s
Press any key to continue.
4.5.5 关系运算符重载

作用: 重载关系运算符,可以让两个自定义类型对象进行对比操作。

例4.5.5

C++ 复制代码
#include <iostream>

using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		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;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	//int a = 0;
	//int b = 0;

	Person a("孙悟空", 18);
	Person b("孙悟空", 20);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	/*if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}*/
}


int main()
{

	test01();

	return 0;
}

例4.5.5

C++ 复制代码
a和b不相等

Process returned 0 (0x0)   execution time : 0.060 s
Press any key to continue.
4.5.6 函数调用运算符重载

  • 函数调用运算符 () 也可以重载。
  • 由于重载后使用的方式非常像函数的调用,因此称为仿函数。
  • 仿函数没有固定写法,非常灵活。

例4.5.6

C++ 复制代码
#include <iostream>

using namespace std;

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};

void test01()
{
	//重载的()操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main()
{
	test01();
	test02();

	return 0;
}

​ 结果如下:

C++ 复制代码
hello world
ret = 20
MyAdd()(100,100) = 200

Process returned 0 (0x0)   execution time : 0.052 s
Press any key to continue.
4.5.7 重载+, - ,*, /, >>,<<运算符

​ 题目如下:

​ 上机实验四设计一个 Complex 类,并在 Complex 中重载+, - ,*, /, >>以及<<等运算符。

  1. 建构数个 Complex 物件,测试对象的所有成员函数(member functions)。
  2. 建构数个 Complex 物件的指针(pointer),以指针测试物件的所有成员函数(member functions)。

Complex

c++ 复制代码
-Real : double
-Imaginary : double
<<constructor>> +Complex(real : double = 0.0,
imaginary : double = 0.0)
<<desctructor>> +~Complex()
+setReal(real : double)
+getReal() : double
+setImaginary(imaginary : double)
+getImaginary() : double
+operator+(c: Complex) : Complex &
+operator-(c: Complex) : Complex &
+operator*(c: Complex) : Complex &
+operator/(c: Complex) : Complex &
<<friend>>+operator>>(input : istream&, c :
&Complex) : istream&
<<friend>>+operator<<(output : ostream&, c :
Complex) : ostream&

​ 解答如下:

​ main.cpp

c++ 复制代码
#include <iostream>
#include "Complex.h"
using namespace std;

int main()
{
    Complex c1(3.0, 4.0);
    Complex c2(4.0, 5.0);
    Complex c3;
    Complex c4;
    Complex c5;
    Complex c6;

    c3 = c1 + c2;
    c4 = c1 - c2;
    c5 = c1 * c2;
    c6 = c1 / c2;

    cout << "c1 = " << c1 << endl;
    cout << "c2 = " << c2 << endl;
    cout << "c1 + c2 = " << c3 << endl;
    cout << "c1 - c2 = " << c4 << endl;
    cout << "c1 * c2 = " << c5 << endl;
    cout << "c1 / c2 = " << c6 << endl;

    Complex *ptr1;
    Complex *ptr2;
    Complex *ptr3;
    Complex *ptr4;
    Complex *ptr5;
    Complex *ptr6;

    ptr1 = new Complex(7.0, 8.0);
    ptr2 = new Complex(6.0, 5.0);
    ptr3 = new Complex();
    ptr4 = new Complex();
    ptr5 = new Complex();
    ptr6 = new Complex();

    *ptr3 = *ptr1 + *ptr2;
    *ptr4 = *ptr1 - *ptr2;
    *ptr5 = *ptr1 * *ptr2;
    *ptr6 = *ptr1 / *ptr2;

    cout << "*ptr1 = " << *ptr1 << endl;
    cout << "*ptr2 = " << *ptr2 << endl;
    cout << "*ptr1 + *ptr2 = " << *ptr3 << endl;
    cout << "*ptr1 - *ptr2 = " << *ptr4 << endl;
    cout << "*ptr1 * *ptr2 = " << *ptr5 << endl;
    cout << "*ptr1 / *ptr2 = " << *ptr6 << endl;

    delete ptr3;
    delete ptr4;
    delete ptr5;
    delete ptr6;

    return 0;
}

​ Complex.h

c++ 复制代码
#ifndef COMPLEX_H
#define COMPLEX_H

#include <iostream>

using namespace std;

class Complex
{
public:
    Complex();
    Complex(double real, double imaginary); // default constructor
    ~Complex();

    void setReal(double real);
    void setImaginary(double imaginary);

    double getReal();
    double getImaginary();

    Complex operator+(const Complex& c); // 重载
    Complex operator-(const Complex& c); //
    Complex operator*(const Complex& c); //
    Complex operator/(const Complex& c); //

    friend istream& operator>>(istream& input, Complex& a);
    friend ostream& operator<<(ostream& output, Complex& a);

    void print(); // in real + i imaginary
private:
    double Real;
    double Imaginary;
};
#endif // COMPLEX_H

​ Complex.cpp

c++ 复制代码
#include "Complex.h"

using namespace std;

Complex::Complex()
{
    Real = 0.0;
    Imaginary = 0.0;
}

Complex::Complex(double real, double imaginary)
{
    setReal(real);
    setImaginary(imaginary);
}

Complex::~Complex()
{
    //cout << "object Destructor is called" << endl;
}

void Complex::setReal(double real)
{
    Real = real;
}

void Complex::setImaginary(double imaginary)
{
    Imaginary = imaginary;
}

double Complex::getReal()
{
    return Real;
}

double Complex::getImaginary()
{
    return Imaginary;
}

Complex Complex::operator+(const Complex& c)
{
    return Complex(getReal() + c.Real, getImaginary() + c.Imaginary);
}

Complex Complex::operator-(const Complex& c)
{
    return Complex(getReal() - c.Real, getImaginary() - c.Imaginary);
}

Complex Complex::operator*(const Complex& c)
{
    return Complex(getReal() * c.Real - getImaginary() * c.Imaginary, getReal() * c.Imaginary + getImaginary() * c.Real);
}

Complex Complex::operator/(const Complex& c)
{
    double denominator = c.Real * c.Real + c.Imaginary * c.Imaginary;
    double a = getReal() * c.Real + getImaginary() * c.Imaginary;
    double b = getImaginary() * c.Real - getReal() * c.Imaginary;
    return Complex(a / denominator, b / denominator);
}

// 重载输入运算符
istream& operator>>(istream& input, Complex& c)
{
    input >> c.Real >> c.Imaginary;
    return input;
}

// 重载输出运算符
ostream& operator<<(ostream& output, Complex& c)
{
    output << c.getReal() << "+" << c.getImaginary() << "i";
    return output;
}

void Complex::print()
{
    cout << "Real is " << getReal() << endl;
    cout << "Imaginary is " << getImaginary() << endl;
    cout << endl;
}

​ 结果如下:

c++ 复制代码
c1 = 3+4i
c2 = 4+5i
c1 + c2 = 7+9i
c1 - c2 = -1+-1i
c1 * c2 = -8+31i
c1 / c2 = 0.780488+0.0243902i
*ptr1 = 7+8i
*ptr2 = 6+5i
*ptr1 + *ptr2 = 13+13i
*ptr1 - *ptr2 = 1+3i
*ptr1 * *ptr2 = 2+83i
*ptr1 / *ptr2 = 1.34426+0.213115i

Process returned 0 (0x0)   execution time : 0.070 s
Press any key to continue.

4.6 继承


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

​ 我们发现,定义这些类时,下级别的成员除了拥有上一级的共性,还有自己的特性。

​ 这个时候我们就可以考虑利用继承的技术,减少重复代码。

4.6.1 继承的基本语法

C++ 复制代码
class 子类 : 继承方式 父类
{
    ...
}

​ 继承的好处

​ 1.可以减少重复的代码。

​ 2.在父类中体现共性,在子类中体现特性。

例4.6.1.1 普通实现

C++ 复制代码
#include <iostream>

using namespace std;

class Java
{
public:
    void header()
    {
        cout << "首页,公开课,登录,注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心,交流合作,站内地图...(公共底部)" << '\n' << endl;
    }
    void left()
    {
        cout << "Java, Python, C++, ...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << '\n' << "Java学习资料" << '\n' << endl;
    }
};

class CPP
{
public:
    void header()
    {
        cout << "首页,公开课,登录,注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心,交流合作,站内地图...(公共底部)" << '\n' << endl;
    }
    void left()
    {
        cout << "Java, Python, C++, ...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << '\n' << "C++学习资料" << '\n' << endl;
    }
};

class Python
{
public:
    void header()
    {
        cout << "首页,公开课,登录,注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心,交流合作,站内地图...(公共底部)" << '\n' << endl;
    }
    void left()
    {
        cout << "Java, Python, C++, ...(公共分类列表)" << endl;
    }
    void content()
    {
        cout << '\n' << "Python学习资料" << '\n' << endl;
    }
};

void test01()
{
    Java ja;
    ja.header();
    ja.left();
    ja.content();
    ja.footer();
}

void test02()
{
    Python py;
    py.header();
    py.left();
    py.content();
    py.footer();
}

void test03()
{
    CPP cpp;
    cpp.header();
    cpp.left();
    cpp.content();
    cpp.footer();
}

int main()
{
    test01();
    test02();
    test03();
    return 0;
}

例4.6.1.2 继承实现

C++ 复制代码
#include <iostream>

using namespace std;

class BasePage
{
public:
    void header()
    {
        cout << "首页,公开课,登录,注册...(公共头部)" << endl;
    }
    void footer()
    {
        cout << "帮助中心,交流合作,站内地图...(公共底部)" << '\n' << endl;
    }
    void left()
    {
        cout << "Java, Python, C++, ...(公共分类列表)" << endl;
    }
};

class Java : public BasePage
{
public:
    void content()
    {
        cout << '\n' << "Java学习资料" << '\n' << endl;
    }
};

class CPP : public BasePage
{
public:
    void content()
    {
        cout << '\n' << "C++学习资料" << '\n' << endl;
    }
};

class Python : public BasePage
{
public:
    void content()
    {
        cout << '\n' << "Python学习资料" << '\n' << endl;
    }
};

void test01()
{
    Java ja;
    ja.header();
    ja.left();
    ja.content();
    ja.footer();
}

void test02()
{
    Python py;
    py.header();
    py.left();
    py.content();
    py.footer();
}

void test03()
{
    CPP cpp;
    cpp.header();
    cpp.left();
    cpp.content();
    cpp.footer();
}

int main()
{
    test01();
    test02();
    test03();
    return 0;
}

​ 结果如下:

C++ 复制代码
首页,公开课,登录,注册...(公共头部)
Java, Python, C++, ...(公共分类列表)

Java学习资料

帮助中心,交流合作,站内地图...(公共底部)

首页,公开课,登录,注册...(公共头部)
Java, Python, C++, ...(公共分类列表)

Python学习资料

帮助中心,交流合作,站内地图...(公共底部)

首页,公开课,登录,注册...(公共头部)
Java, Python, C++, ...(公共分类列表)

C++学习资料

帮助中心,交流合作,站内地图...(公共底部)


Process returned 0 (0x0)   execution time : 0.201 s
Press any key to continue.
4.6.2 继承方式

  • 公共继承
  • 保护继承
  • 私有继承

其都不能访问父类中 private 的信息。

例4.6.2

C++ 复制代码
#include <iostream>

using namespace std;

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

//公共继承
class Son1 :public Base
{
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 Son2 :protected Base
{
public:
    void func()
    {
        m_A = 10; // 父类中的公共权限成员 到子类中变为保护权限
        m_B = 10; // 父类中的保护权限成员 到子类中仍然是保护权限
        //m_C = 10; // 父类中的私有权限成员 子类访问不到
    }
};

void test02()
{
    Son2 s2;
    //s2.m_A = 100; // 在Son2中 m_A变为保护权限,因此访问不到。
}

//私有继承
class Son3 :private Base
{
public:
    void func()
    {
        m_A = 10; // 父类中的公共权限成员 到子类中变为私有权限
        m_B = 10; // 父类中的保护权限成员 到子类中变为私有权限
        //m_C = 10; // 父类中的私有权限成员 子类访问不到
    }
};

void test03()
{
    Son3 s3;
    //s3.m_A = 100; // 在Son3中 m_A变为私有权限,因此访问不到。
}

int main()
{
    test01();
    test02();
    test03();
    return 0;
}
4.6.3 继承中的对象模型

​ 父类中私有成员也是被子类继承下去了,只是由编译器给隐藏后访问不到。

例4.6.3

C++ 复制代码
#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;
};

void test01()
{
	cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
sizeof Son = 16

Process returned 0 (0x0)   execution time : 0.092 s
Press any key to continue.
4.6.4 继承中构造和析构顺序

​ 继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反。

例4.6.4

C++ 复制代码
#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()
{
	//继承中 先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反
	Son s;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
Base构造函数!
Son构造函数!
Son析构函数!
Base析构函数!

Process returned 0 (0x0)   execution time : 0.084 s
Press any key to continue.
4.6.5 继承同名成员处理方式

  • 子类对象可以直接访问到子类中同名成员。
  • 子类对象加作用域可以访问到父类同名成员。
  • 当子类与父类拥有同名的成员函数,子类会隐藏父类中同名成员函数,加作用域可以访问到父类中同名函数。

例4.6.5.1 如果子类和父类成员同名,直接调用会调用到子类的数据。

C++ 复制代码
#include <iostream>

using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }
    int m_A;
};

void test01()
{
    Son s;
    cout << "m_A = " << s.m_A << endl;
}

int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
m_A = 200

Process returned 0 (0x0)   execution time : 0.061 s
Press any key to continue.

例4.6.5.2 如果子类和父类成员同名,前面加作用域( :: )调用会调用到父类的数据。

c++ 复制代码
#include <iostream>

using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }
    int m_A;
};

void test01()
{
    Son s;
    cout << "Son 下的 m_A = " << s.m_A << endl;
    cout << "Base 下的 m_A = " << s.Base::m_A << endl;
}

int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
Son 下的 m_A = 200
Base 下的 m_A = 100

Process returned 0 (0x0)   execution time : 0.081 s
Press any key to continue.
4.6.6 继承同名静态成员处理方式

  • 访问子类同名成员 直接访问即可。
  • 访问父类同名成员 需要加作用域。

例4.6.6

C++ 复制代码
#include <iostream>

using namespace std;

class Base
{
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base
{
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问: " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问: " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问: " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通过类名访问: " << endl;
	Son::func();
	Son::Base::func();
	//出现同名,子类会隐藏掉父类中所有同名成员函数,需要加作作用域访问
	Son::Base::func(100);
}

int main()
{
	//test01();
	test02();

	return 0;
}

​ 结果如下:

C++ 复制代码
通过对象访问:
Son - static void func()
Base - static void func()
通过类名访问:
Son - static void func()
Base - static void func()
Base - static void func(int a)

Process returned 0 (0x0)   execution time : 0.109 s
Press any key to continue.
4.6.7 多继承语法

​ C++允许一个类继承多个类。

​ 语法如下:

C++ 复制代码
class 子类 : 继承方式 父类1, 继承方式 父类2, ...
{
    ...
}

例4.6.7

C++ 复制代码
#include <iostream>

using namespace std;

class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_B = 200;
    }
    int m_B;
};

// 子类 继承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 s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_B << endl;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
sizeof Son = 16
100
200

Process returned 0 (0x0)   execution time : 0.039 s
Press any key to continue.
4.6.8 菱形继承

菱形继承概念:

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

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

菱形继承问题:

  1. 羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时,就会产生二义性。

  2. 草泥马继承自动物的数据继承了两份,其实我们应该清楚,这份数据我们只需要一份就可以。

解决方法:

  • 虚继承

例4.6.8

C++ 复制代码
#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 = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
st.Sheep::m_Age = 200
st.Tuo::m_Age = 200
st.m_Age = 200

Process returned 0 (0x0)   execution time : 0.129 s
Press any key to continue.

4.7 多态


4.7.1 多态的基本介绍

1.多态的基本语法

C++ 重写:virtual 函数值返回类型 函数名 参数列表

2.多态满足条件

  • 有继承关系
  • 子类重写父类中的虚函数

3.多态使用条件

  • 父类指针或引用指向子类对象

4.多态的优点

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展以及维护

例4.7.1 class animal

C++ 复制代码
#include <iostream>

using namespace std;

// 多态

// 动物类
class Animal
{
public:
    // 虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

// 猫类
class Cat :public Animal
{
public:
    // 重写 函数返回值类型 函数名 参数列表 完全相同
    virtual void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

// 狗类
class Dog :public Animal
{
public:
    // 重写 函数返回值类型 函数名 参数列表 完全相同
    virtual void speak()
    {
        cout << "小狗在说话" << endl;
    }
};

// 执行说话的函数
// 地址早已绑定 在编译阶段确定函数地址
// 如果想执行让猫说话,那么这个函数不能提前绑定,要在运行阶段进行绑定,地址晚绑定
void doSpeak(Animal &animal) // Animal & animal == cat;
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
    Dog dog;
    doSpeak(dog);
}
int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
小猫在说话
小狗在说话

Process returned 0 (0x0)   execution time : 0.085 s
Press any key to continue.
4.7.2 纯虚函数和抽象类

​ 在多态中,通常父类中的虚函数的实现是没有意义的,主要是调用子类重写的内容,因此可以将虚函数改为纯虚函数。

​ 纯虚函数的语法:

virtual 返回值类型 函数名 (形参列表) = 0;

​ 当类中有了纯虚函数,这个类也称为抽象类。

​ 抽象类的特点

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数,否则也属于抽象类

例4.7.2

C++ 复制代码
#include <iostream>

using namespace std;

// 纯虚函数和抽象类
class Base
{
public:
    // 纯虚函数
    // 只要有一个纯虚函数,这个类称为抽象类
    // 抽象类的特点:
    // 1.无法实例化对象
    // 2.抽象类的子类 必须重写父类中的纯虚函数,否则也属于抽象类
    virtual void func() = 0;

};

class Son :public Base
{
public:
    virtual void func()
    {
        cout << "output the son result" << endl;
    }
};

void test01()
{
    // Base b; // 抽象类无法实例化对象
    // new Base; // 抽象类无法实例化对象
    Son s; // 子类必须重写父类中的纯虚函数,否则无法实现实例化对象。

    Base * base = new Son;
    base->func();
}

int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
output the son result

Process returned 0 (0x0)   execution time : 0.083 s
Press any key to continue.
4.7.3 虚析构和纯虚析构

​ 多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放的时候无法调用到子类的析构代码。

​ 解决方式:将父类中的析构函数改为虚析构 或者纯虚析构

​ 虚析构和纯虚析构的共性:

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

​ 纯虚析构和虚析构的区别:

如果是是纯虚析构函数,该类属于抽象类,无法实例化对象。

​ 虚析构语法:

c++ virtual ~类名() { ... }

​ 纯虚析构的语法:

C++ virtual ~类名() = 0;
类名::类名() { ... }

例4.7.3.1 调用虚析构函数

C++ 复制代码
#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;
        m_Name = 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();
    return 0;
}

​ 结果如下:

C++ 复制代码
Animal的构造函数调用
Cat的构造函数调用
Tom小猫在说话
Cat的虚析构函数调用
Animal的虚析构函数调用

Process returned 0 (0x0)   execution time : 0.113 s
Press any key to continue.

例4.7.3.2 调用纯虚析构函数

C++ 复制代码
#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;
        m_Name = 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();
    return 0;
}

​ 结果如下:

C++ 复制代码
Animal的构造函数调用
Cat的构造函数调用
Tom小猫在说话
Cat的虚析构函数调用
Animal的纯虚析构函数调用

Process returned 0 (0x0)   execution time : 0.029 s
Press any key to continue.
4.7.4 多态案例一-计算器类

例4.7.4 class calculator

C++ 复制代码
#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;
        }
        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 << 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;
    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 Add :public AbstractCalculator
{
    virtual int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

// 减法计算器类
class Sub :public AbstractCalculator
{
    virtual int getResult()
    {
        return m_Num1 - m_Num2;
    }
};

// 乘法计算器类
class Mul :public AbstractCalculator
{
    virtual int getResult()
    {
        return m_Num1 * m_Num2;
    }
};

// 除法计算器类
class Div :public AbstractCalculator
{
    virtual int getResult()
    {
        return m_Num1 / m_Num2;
    }
};

void test02()
{
    // 多态使用条件
    // 父类指针或者引用指向子类对象

    // 加法运算
    AbstractCalculator * abc = new Add;
    abc->m_Num1 = 20;
    abc->m_Num2 = 20;

    cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;

    delete abc;

    // 减法运算
    abc = new Sub;
    abc->m_Num1 = 20;
    abc->m_Num2 = 20;

    cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;

    delete abc;

    // 乘法运算
    abc = new Mul;
    abc->m_Num1 = 20;
    abc->m_Num2 = 20;

    cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;

    delete abc;

    // 除法运算
    abc = new Div;
    abc->m_Num1 = 20;
    abc->m_Num2 = 20;

    cout << abc->m_Num1 << " / " << abc->m_Num2 << " = " << abc->getResult() << endl;

    delete abc;

}

int main()
{
    cout << "test01" << endl;
    test01();

    cout << endl;

    cout << "test02" << endl;
    test02();

    return 0;
}

​ 结果如下:

C++ 复制代码
test01
10 + 10 = 20
10 - 10 = 0
10 * 10 = 100
10 / 10 = 1

test02
20 + 20 = 40
20 - 20 = 0
20 * 20 = 400
20 / 20 = 1

Process returned 0 (0x0)   execution time : 0.028 s
Press any key to continue.
4.7.5 多态案例二-制作饮品

例4.7.5 make drinking

C++ 复制代码
#include <iostream>

using namespace std;

// make drinking
class BaseDrinking
{
public:
    virtual ~BaseDrinking()
    {
        // 基类析构函数实现
    }

    // 煮水
    virtual void Boil() = 0;
    // 冲泡
    virtual void Brew() = 0;
    // 倒入杯中
    virtual void PourInCup() = 0;
    // 加入辅料
    virtual void AddSomethings() = 0;

    // 制作饮品
    void MakeDrink()
    {
        Boil();
        Brew();
        PourInCup();
        AddSomethings();
    }
};

// 制作咖啡
class Coffee :public BaseDrinking
{
public:
    // 煮水
    virtual void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }
    // 冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }
    // 倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入咖啡杯中" << endl;
    }
    // 加入辅料
    virtual void AddSomethings()
    {
        cout << "加入糖和牛奶" << endl;
    }
};

// 制作茶
class Tea :public BaseDrinking
{
public:
    // 煮水
    virtual void Boil()
    {
        cout << "煮娃哈哈" << endl;
    }
    // 冲泡
    virtual void Brew()
    {
        cout << "冲泡茶" << endl;
    }
    // 倒入杯中
    virtual void PourInCup()
    {
        cout << "倒入茶杯中" << endl;
    }
    // 加入辅料
    virtual void AddSomethings()
    {
        cout << "加入柠檬" << endl;
    }
};

// 制作函数
void doWork(BaseDrinking * base)
{
    base->MakeDrink();
    delete base; // 释放
}

void test01()
{
    // 制作咖啡
    doWork(new Coffee);

    cout << "---------------------" << endl;

    // 制作茶
    doWork(new Tea);

}
int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
煮农夫山泉
冲泡咖啡
倒入咖啡杯中
加入糖和牛奶
---------------------
煮娃哈哈
冲泡茶
倒入茶杯中
加入柠檬

Process returned 0 (0x0)   execution time : 0.078 s
Press any key to continue.
4.7.6 多态案例三-电脑组装

例4.7.6 assembly computer

C++ 复制代码
#include <iostream>

using namespace std;

// 组装电脑

// 抽象不同的零件类

// 抽象CPU类
class CPU
{
public:
    virtual ~CPU()
    {

    }
    // 抽象的计算函数
    virtual void calculate() = 0;
};

// 抽象显卡类
class VideoCard
{
public:
    virtual ~VideoCard()
    {

    }
    // 抽象的显示函数
    virtual void display() = 0;
};

// 抽象内存条类
class Memory
{
public:
    virtual ~Memory()
    {

    }
    // 抽象的存储函数
    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个电脑零件
    virtual ~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;
    }
};


// AMD厂商
class AMDCPU :public CPU
{
public:
    virtual void calculate()
    {
        cout << "AMD的CPU开始计算了" << endl;
    }
};

class AMDVideoCard :public VideoCard
{
public:
    virtual void display()
    {
        cout << "AMD的显卡开始显示了" << endl;
    }
};

class AMDMemory :public Memory
{
public:
    virtual void storage()
    {
        cout << "AMD的内存条开始存储了" << endl;
    }
};

void test01()
{
    // 第一台电脑零件
    CPU * intelcpu = new IntelCPU;
    VideoCard * intelCard = new IntelVideoCard;
    Memory * intelMem = new IntelMemory;

    cout << "第一台电脑开始工作:" << endl;
    // 创建第一台电脑
    Computer * Computer1 = new Computer(intelcpu, intelCard, intelMem);
    Computer1->work();
    delete Computer1;

    cout << "----------------------" << endl;
    cout << "第二台电脑开始工作:" << endl;
    // 第二台电脑组装
    Computer * Computer2 = new Computer(new AMDCPU, new AMDVideoCard, new AMDMemory);
    Computer2->work();
    delete Computer2;

}
int main()
{
    test01();
    return 0;
}

​ 结果如下:

C++ 复制代码
第一台电脑开始工作:
Intel的CPU开始计算了
Intel的显卡开始显示了
Intel的内存条开始存储了
----------------------
第二台电脑开始工作:
AMD的CPU开始计算了
AMD的显卡开始显示了
AMD的内存条开始存储了

Process returned 0 (0x0)   execution time : 0.072 s
Press any key to continue.
4.7.7 继承与多态案例

​ 题目如下:

​ 上机实验五 继承與多态,请沿用实验三的实验结果, 以公开(public)继承 Person 类产生一个 Student 类(class)。

以及 Teacher 类。注意: Person 类的 print()成员已经设为虚函数(virtual function)。

​ 将类定义(class definition)写在 Person.h, Date.h, Student.h 及 Teacher.h 中。 将成员函数的定义(member function definition)写在person.cpp, Date.cpp, Student.cpp 及Teacher.cpp 中。在主程序中实例化二个 Person对象,二个 Student 对象,一个 Teacher 对象。并在主程序中定义一个 Person 的指针数组,将数组中的指针分别指向上述五个对象。 利用 for 及指针数组调用数组指针指向的每个对象的 print 成员函数顺序打印对象的内容。

Person

c++ 复制代码
-Name : string
-ID : int
-Address : string
-Birthday: Date
<<constructor>> +Person(name : string = "", id : int = 0,
address : string = "", Date = Date())
<<desctructor>> +~Person()
+setName(name : string)
+getName() : string
+setID(id : int)
+getID() : int
+setAddress(address : string)
+getAddress() : string
+setBirthday(d : Date)
+getBirthday() : Date
+virtual print() : void

Date

c++ 复制代码
<<constructor>>+Date(y : int = 0,
m : int = 0, d : int = 0)
<<destructor>>+~Date()
+setYear(y : int) : void
+setMonth(m : int) : void
+setDay(d : int) : void
+getYear() : int
+getMonth() : int
+getDay() : int
+print() : void
-Year : int
-Month : int
-Day : int
Student
-Department:string
-studentID:int
<<constructor>> +Student (name:string="",
id:int=0, address:string="", Date=Date(),
Dep:string="", sID:int=0)
<<destructor>> +~Student()
+setDepartment(Dep:string):void
+setStudentID(sID:int):void
+getDepartment():string
+getStudentID():int
+print():void

Teacher

c++ 复制代码
-Department:string
-Salary:double
<<constructor>> +Teacher(name:string,
id:int=0, address:string="", Date=Date(),
Dep:string="",sal:double=0.0)
<<destructor>> +~Teacher()
+setDepartment(Dep:string):void
+setSalary(sal:duble):void
+getDepartment():string
+getSalary():double
+print():void

​ 解答如下:

​ main.cpp

c++ 复制代码
#include <iostream>
#include "Person.h"

#include "Student.h"

#include "Teacher.h"
using namespace std;

int main()
{
    Person p1("Alice", 1, "123 Street");
    Person p2("Bob", 2, "456 Avenue");

    Student s1("Charlie", 3, "789 Boulevard", Date(2000, 3, 1), "Math", 1001);
    Student s2("David", 4, "101 Lane", Date(2001, 7, 22), "Physics", 1002);

    Teacher t1("Eve", 5, "202 Road", Date(1975, 1, 1), "Biology", 50000);

    Person* people[] = {&p1, &p2, &s1, &s2, &t1}; // 容器

    for (const auto& person : people) // output
    {
        person->print();
    }

    return 0;
}

​ Person.h

c++ 复制代码
#ifndef PERSON_H

#define PERSON_H
#include <iostream>
#include "Date.h"
using namespace std;

class Person
{
public:
    Person();
    Person(string name, int id, string address);
    ~Person();

    void setPerson(string name, int id, string address);
    void setName(string name);
    void setID(int id);
    void setAddress(string address);
    void setBirthday(Date d);

    string getName();
    int getID();
    string getAddress();
    Date getBirthday();

    virtual void print(); // outPutResult
private:
    string Name;
    int ID;
    string Address;
    Date Birthday;
};
#endif // PERSON_H

​ Student.h

c++ 复制代码
#ifndef STUDENT_H

#define STUDENT_H
#include <iostream>
#include "Person.h"
#include "Date.h"
using namespace std;

class Student :public Person
{
public:
    Student();
    Student(string name, int id, string address, Date date, string department, int studentID);
    ~Student();

    void setDepartment(string department);
    void setStudentID(int studentID);

    string getDepartment();
    int getStudentID();

    virtual void print(); // outPutResult
private:
    string Department;
    int StudentID;
};
#endif // STUDENT_H

​ Teacher.h

c++ 复制代码
#ifndef TEACHER_H

#define TEACHER_H
#include "Person.h"
#include "Date.h"
using namespace std;

class Teacher :public Person
{
public:
    Teacher();
    Teacher(string name, int id, string address, Date date, string department, double salary);
    ~Teacher();

    void setDepartment(string department);
    void setSalary(double salary);

    string getDepartment();
    double getSalary();

    virtual void print(); // outPutResult
private:
    string Department;
    double Salary;
};
#endif // TEACHER_H

​ Person.cpp

c++ 复制代码
#include "Person.h"
#include <iostream>
using namespace std;

Person::Person()
{
    Name = "S.M.Wang";
    ID = 070145;
    Address = "莲花路200号";
}

Person::Person(string name, int id, string address)
{
    setPerson(name, id, address);
}

Person::~Person()
{
    //cout << "object Destructor is called" << endl;
}


void Person::setPerson(string name, int id, string address)
{
    Name = name;
    ID = id;
    Address = address;
}


void Person::setName(string name)
{
    Name = name;
}

void Person::setID(int id)
{
    ID = id;
}

void Person::setAddress(string address)
{
    Address = address;
}

string Person::getName()
{
    return Name;
}

int Person::getID()
{
    return ID;
}

string Person::getAddress()
{
    return Address;
}


void Person::setBirthday(Date d) // 调用的形参是类
{
    Birthday = d;
}

Date Person::getBirthday() // 返回的是类
{
    return Birthday;
}

void Person::print()
{
    cout << "Name:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "Address:" << getAddress() << endl;

    cout << "Birthday:" << getBirthday().getYear(); // getBirthday()返回的是类,再调用类中的子函数满足cout的返回值。
    cout << " " << getBirthday().getMonth();
    cout << " " << getBirthday().getDay() << endl;
    cout << endl;
}

​ Student.cpp

c++ 复制代码
#include "Student.h"
#include <iostream>
using namespace std;

Student::Student()
{

}

Student::Student(string name, int id, string address, Date date, string department, int studentID)
{
    setPerson(name, id, address);
    setBirthday(date);
    setDepartment(department);
    setStudentID(studentID);
}

Student::~Student()
{
    //cout << "object Destructor is called" << endl;
}

void Student::setDepartment(string department)
{
    Department = department;
}

string Student::getDepartment()
{
    return Department;
}

void Student::setStudentID(int studentID)
{
    StudentID = studentID;
}

int Student::getStudentID()
{
    return StudentID;
}

void Student::print()
{
    cout << "Name:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "Address:" << getAddress() << endl;

    cout << "Birthday:" << getBirthday().getYear(); // getBirthday()返回的是类,再调用类中的子函数满足cout的返回值。
    cout << " " << getBirthday().getMonth();
    cout << " " << getBirthday().getDay() << endl;

    cout << "Department:" << getDepartment() << endl;
    cout << "StudentID:" << getStudentID() << endl;
    cout << endl;

}

​ Teacher.cpp

c++ 复制代码
#include "Teacher.h"
#include <iostream>
using namespace std;

Teacher::Teacher()
{

}

Teacher::Teacher(string name, int id, string address, Date date, string department, double salary)
{
    setPerson(name, id, address);
    setBirthday(date);
    setDepartment(department);
    setSalary(salary);
}

Teacher::~Teacher()
{
    //cout << "object Destructor is called" << endl;
}

void Teacher::setDepartment(string department)
{
    Department = department;
}

string Teacher::getDepartment()
{
    return Department;
}

void Teacher::setSalary(double salary)
{
    Salary = salary;
}

double Teacher::getSalary()
{
    return Salary;
}

void Teacher::print()
{
    cout << "Name:" << getName() << endl;
    cout << "ID:" << getID() << endl;
    cout << "Address:" << getAddress() << endl;

    cout << "Birthday:" << getBirthday().getYear(); // getBirthday()返回的是类,再调用类中的子函数满足cout的返回值。
    cout << " " << getBirthday().getMonth();
    cout << " " << getBirthday().getDay() << endl;

    cout << "Department:" << getDepartment() << endl;
    cout << "Salary:" << getSalary() << endl;
    cout << endl;
}

​ 结果如下:

c++ 复制代码
Name:Bob
ID:2
Address:456 Avenue
Birthday:0 0 0

Name:Charlie
ID:3
Address:789 Boulevard
Birthday:2000 3 1
Department:Math
StudentID:1001

Name:David
ID:4
Address:101 Lane
Birthday:2001 7 22
Department:Physics
StudentID:1002

Name:Eve
ID:5
Address:202 Road
Birthday:1975 1 1
Department:Biology
Salary:50000


Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.

5 文件操作


​ 程序运行时产生的数据都属于临时数据,程序一旦运行结束都会被释放。

通过文件可以将数据持久化

C++中对文件操作需要包含头文件 < fstream >

​ 文件类型分为两种:

  1. 文本文件 - 文件以文本的ASCII码形式存储在计算机中。
  2. 二进制文件 - 文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们。

​ 操作文件的三大类:

  1. ofstream:写操作
  2. ifstream: 读操作
  3. fstream : 读写操作

5.1文本文件


5.1.1写文件

写文件步骤如下

  1. 包含头文件

    c++ 复制代码
    #include <fstream>
  2. 创建流对象

    c++ 复制代码
    ofstream ofs;
  3. 打开文件

    c++ 复制代码
    ofs.open("文件路径",打开方式);
  4. 写数据

    c++ 复制代码
    ofs << "写入的数据";
  5. 关闭文件

    C++ 复制代码
    ofs.close();

文件打开方式

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

例5.1.1

C++ 复制代码
#include <iostream>
#include <fstream>

using namespace std;

void test01()
{
	ofstream ofs;
	ofs.open("test.txt", ios::out);

	ofs << "姓名:张三" << endl;
	ofs << "性别:男" << endl;
	ofs << "年龄:18" << endl;

	ofs.close();
}

int main()
{

	test01();

	return 0;
}

​ test.txt 内容如下:

C++ 复制代码
姓名:张三
性别:男
年龄:18
5.1.2读文件

读文件步骤如下

  1. 包含头文件

    c++ 复制代码
    #include <fstream>
  2. 创建流对象

    c++ 复制代码
    ifstream ifs;
  3. 打开文件并判断文件是否打开成功

    c++ 复制代码
    ifs.open("文件路径",打开方式);
  4. 读数据

    c++ 复制代码
    四种方式读取
  5. 关闭文件

    c++ 复制代码
    ifs.close();

例5.1.2

c++ 复制代码
#include <iostream>
#include <fstream>

using namespace std;

void test01()
{
	ifstream ifs;
	ifs.open("C://Users//TeaInCoffee//Desktop//test.txt", ios::in);

	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}

	//第一种方式
	//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)
	{
		cout << c;
	}
	ifs.close();
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

C++ 复制代码
姓名:张三
性别:男
年龄:18

Process returned 0 (0x0)   execution time : 0.014 s
Press any key to continue.

5.2 二进制文件


​ 以二进制的方式对文件进行读写操作。

​ 打开方式要指定为 ios::binary

5.2.1 写文件

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

​ 函数原型 :

C++ 复制代码
ostream& write(const char * buffer,int len);

​ 参数解释:字符指针buffer指向内存中一段存储空间,len是读写的字节数。

例5.2.1

c++ 复制代码
#include <iostream>
#include <fstream>

using namespace std;

class Person
{
public:
	char m_Name[64];
	int m_Age;
};

//二进制文件  写文件
void test01()
{
	//1、包含头文件

	//2、创建输出流对象
	ofstream ofs("C://Users//TeaInCoffee//Desktop//person.txt", ios::out | ios::binary);

	//3、打开文件
	//ofs.open("C://Users//TeaInCoffee//Desktop//person.txt", ios::out | ios::binary);

	Person p = {"张三"  , 18};

	//4、写文件
	ofs.write((const char *)&p, sizeof(p));

	//5、关闭文件
	ofs.close();
}

int main()
{

	test01();

	return 0;
}

​ person.txt 内容如下:

c++ 复制代码
엕﷈                               
5.2.2 读文件

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

​ 函数原型:

c++ 复制代码
istream& read(char *buffer,int len);

​ 参数解释:字符指针buffer指向内存中一段存储空间。len是读写的字节数。

例5.2.2

c++ 复制代码
#include <iostream>
#include <fstream>

using namespace std;

class Person
{
public:
	char m_Name[64];
	int m_Age;
};

void test01()
{
	ifstream ifs("C://Users//TeaInCoffee//Desktop//person.txt", ios::in | ios::binary);

	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
	}

	Person p;
	ifs.read((char *)&p, sizeof(p));

	cout << "姓名: " << p.m_Name << " 年龄: " << p.m_Age << endl;
}

int main()
{

	test01();

	return 0;
}

​ 结果如下:

c++ 复制代码
姓名: 张三 年龄: 18

Process returned 0 (0x0)   execution time : 0.011 s
Press any key to continue.
相关推荐
qing_04060319 分钟前
C++——string的模拟实现(上)
开发语言·c++·string
我不会JAVA!1 小时前
排序算法(3) C++
c++·算法·排序算法
Ddddddd_1585 小时前
C++ | Leetcode C++题解之第504题七进制数
c++·leetcode·题解
J_z_Yang5 小时前
LeetCode 202 - 快乐数
c++·算法·leetcode
Y.O.U..8 小时前
STL学习-容器适配器
开发语言·c++·学习·stl·1024程序员节
lihao lihao8 小时前
C++stack和queue的模拟实现
开发语言·c++
姆路9 小时前
QT中使用图表之QChart概述
c++·qt
西几9 小时前
代码训练营 day48|LeetCode 300,LeetCode 674,LeetCode 718
c++·算法·leetcode
风清扬_jd9 小时前
Chromium HTML5 新的 Input 类型week对应c++
前端·c++·html5
南东山人10 小时前
C++静态成员变量需要在类外进行定义和初始化-error LNK2001:无法解析的外部符号
c++