实验2
实验2 类和对象
一、实验环境及目的
实验环境:Windows 10 + Dev-C++(TDM-GCC 4.9.2,
g++ -std=c++11,64 位)
代码组织:全部采用多文件结构(头文件放声明、cpp 放实现、taskN.cpp放测试与main)
实验目的
- 加深对 OOP 概念(类、对象)和特性(封装)的理解;
- 会用 C++ 定义、实现、测试类,能用类创建对象并基于对象编程;
- 理解构造函数、析构函数的用途与调用时机,理解 C++ 的内存资源管理;
- 会用多文件结构组织代码,并练习用
static、friend、const、访问权限控制在“数据共享”与“数据保护”之间取得平衡。
二、实验内容
1. 实验任务1:简单类 T 的定义与测试
1.1 代码组织与源码
三个文件:t.h(类 T 声明、友元函数声明)、t.cpp(类 T 实现、友元函数实现)、task1.cpp(测试模块与 main)。
t.h
#pragma once
#include <string>
class T {
public:
T(int x = 0, int y = 0); // 普通构造函数
T(const T &t); // 复制构造函数
T(T &&t); // 移动构造函数
~T(); // 析构函数
void adjust(int ratio); // 按系数成倍调整数据
static int get_cnt(); // 显示当前T类对象总数
friend void output(const T &t); // 友元, 以(m1, m2)形式输出对象t
static const std::string doc; // 类T的描述信息
static const int MAX_CNT; // 类T对象上限
private:
int m1, m2; // 对象数据成员
static int current_cnt; // 当前T类对象数目
};
t.cpp
#include "t.h"
#include <iostream>
#include <stdexcept>
#include <string>
// static成员数据: 类内声明、类外初始化
const std::string T::doc{"a simple class sample"};
const int T::MAX_CNT = 999;
int T::current_cnt = 0;
// 对象方法
T::T(int x, int y): m1{x}, m2{y} {
if(current_cnt == MAX_CNT) {
throw std::runtime_error("T: maximum object count exceeded");
}
++current_cnt;
std::cout << "T constructor called.\n";
}
T::T(const T &t): m1{t.m1}, m2{t.m2} {
if(current_cnt == MAX_CNT) {
throw std::runtime_error("T: maximum object count exceeded");
}
++current_cnt;
std::cout << "T copy constructor called.\n";
}
T::T(T &&t): m1{t.m1}, m2{t.m2} {
if(current_cnt == MAX_CNT) {
throw std::runtime_error("T: maximum object count exceeded");
}
++current_cnt;
std::cout << "T move constructor called.\n";
}
T::~T() {
--current_cnt;
std::cout << "T destructor called.\n";
}
void T::adjust(int ratio) {
m1 *= ratio;
m2 *= ratio;
}
// 类方法
int T::get_cnt() {
return current_cnt;
}
// 友元
void output(const T &t) {
std::cout << "(" << t.m1 << ", " << t.m2 << ")";
}
task1.cpp
#include <iostream>
#include <utility>
#include "t.h"
void test() {
using std::cout;
using std::endl;
cout << "T info: " << T::doc << endl;
cout << "T objects'max count: " << T::MAX_CNT << endl;
cout << "T objects'current count: " << T::get_cnt() << endl << endl;
{
T t1;
cout << "t1 = "; output(t1); cout << endl;
T t2(3, 4);
cout << "t2 = "; output(t2); cout << endl;
T t3(t2);
t3.adjust(2);
cout << "t3 = "; output(t3); cout << endl;
T t4(std::move(t2));
cout << "t4 = "; output(t4); cout << endl;
cout << "test: T objects'current count: " << T::get_cnt() << endl;
}
cout << "test: T objects'current count: " << T::get_cnt() << endl;
}
int main() {
std::cout << "test Class T: \n";
test();
}
1.2 运行结果

关键现象:t1、t2 触发普通构造,t3 触发复制构造,t4 触发移动构造;内层块执行到 } 前计数为 4,块结束后 4 个对象依次析构、计数回到 0,印证了“对象生命期与作用域一致”。
1.3 问题回答
问题1:各种构造函数、析构函数的功能与调用时机,以及 t1–t4 分别触发哪个
| 函数 | 功能 | 调用时机 | 本例触发者 |
|---|---|---|---|
T(int x = 0, int y = 0) 普通构造函数 |
用实参(或默认值 0、0)初始化 m1、m2,并登记对象计数 |
定义对象并给出初始值时;两个参数都有默认值,因此它同时充当默认构造函数 | t1(T t1;,用默认实参)、t2(T t2(3, 4);) |
T(const T &t) 复制构造函数 |
用同类型的已存在对象逐成员复制出新对象 | 用左值对象初始化新对象;对象按值传参、按值返回时也会调用 | t3(T t3(t2);,t2 是左值) |
T(T &&t) 移动构造函数 |
用将要消亡的对象(右值)构造新对象,语义上是“接管”其资源 | 用右值初始化新对象,如临时对象、std::move(x) 后的对象 |
t4(T t4(std::move(t2));) |
~T() 析构函数 |
对象生命期结束时做清理,本例把对象计数减 1(真实项目中用于释放堆内存、关闭文件等) | 对象离开作用域、被 delete、或程序结束(全局/静态对象)时自动调用,不可带参数、不可重载 |
内层 { } 结束时,t4、t3、t2、t1 逆序析构(4 次 T destructor called.) |
补充:本例的移动构造函数只做了成员复制(int 无需“窃取”资源),但它与复制构造的语义区别在于形参是右值引用 T&&,编译器据此在重载决议中优先选择它。
问题2:把 t.cpp 中 line 8–10(三行 static 成员定义)剪切到 t.h 末尾后能否正确编译
不能。现象与原因:

- 两个翻译单元
t.cpp、task1.cpp都能各自编译通过,错误发生在链接阶段:multiple definition of 'T::doc' / 'T::MAX_CNT' / 'T::current_cnt',collect2.exe: error: ld returned 1 exit status。 - 原因:
static数据成员在类内只是声明(不分配存储、不进行定义),必须在类外定义一次且仅一次。头文件会被每个包含它的.cpp展开,把定义写进头文件后,t.cpp和task1.cpp各自的目标文件里都有一份同名全局符号的定义,链接器无法判定用哪一个,于是报重复定义(违反 ODR,One Definition Rule)。 - 另外,
const std::string T::doc需要在类外构造,类内无法完成;类内给初值的写法(static const int MAX_CNT = 999;)只对整型常量成立,且一旦被 odr-use 仍需类外定义(C++17 起可用inline变量避免重复定义)。 - 正确做法:头文件只放声明,定义放唯一的
.cpp(本项目即t.cpp)。
问题3:t1–t4 的作用域与生命期;能否通过 t1 访问私有成员 m1、m2;体现了什么特性
- 作用域:
t1–t4定义在test()内部的那对花括号{ }里,属于块作用域,从各自定义点起、到该块的}为止;块外(test()余下代码、main())不可见。 - 生命期:它们是自动存储期的栈对象,生命期与作用域一致——进入定义语句时构造,离开该块时按构造的逆序自动析构(
t4 → t3 → t2 → t1)。运行结果中 4 行T destructor called.正好出现在内层块结束处。 - 不能在
test()中通过t1.m1、t1.m2访问私有成员:private的可见范围只有本类的成员函数和友元,外部代码即使拿到了对象也无法直接访问,编译器在编译期就报错('int T::m1' is private)。 - 这体现了类的封装(信息隐藏 + 访问权限控制):数据被“藏”在类内部,对外只暴露公有接口(本例为
adjust()、output()友元、get_cnt()静态方法),使用者的操作被约束在类允许的范围内,内部表示可以随实现修改而不影响外部用法。
问题4:throw 的作用;把 MAX_CNT 改成 2 后的运行结果;已创建对象是否被销毁
throw 用于抛出异常:当函数检测到无法正常继续的错误(本例是对象数目达到上限)时,throw 表达式 会构造一个异常对象并立即中断当前函数的正常执行路径,把控制权沿调用栈向上“传播”(称为栈展开 stack unwinding),直到找到类型匹配的 catch;若一路无人捕获,则调用 std::terminate() 终止进程(通常会 abort)。异常类型决定了能被哪个 catch 接住。
把 T::MAX_CNT 改为 2 后重新编译运行,程序崩溃(异常终止):

t1、t2正常构造,计数达到 2;执行T t3(t2);时复制构造函数发现current_cnt == MAX_CNT,throw std::runtime_error抛出且无人捕获 →terminate called after throwing an instance of 'std::runtime_error'、what(): T: maximum object count exceeded,进程异常结束(返回码非 0)。- 已经创建的对象(如 t1)不会被正常销毁:异常未被捕获,程序经
std::terminate直接中止,此路径下并没有执行完整的栈展开,因此运行结果里没有任何一行T destructor called.(对比 1.2 节正常运行时能看到的 4 行析构输出),current_cnt也不会被回退;对象占用的内存只能靠操作系统在进程结束时统一回收。 - 补充说明(对比理解):如果该异常被外层
try/catch捕获,则栈展开会正常发生,t1、t2这两个已完整构造的对象会被析构;而正在构造中的t3因为构造尚未完成,其析构函数不会被调用(这也是 RAII 思想要求“资源在构造函数中获取、在析构函数中释放”的原因)。
2. 实验任务2:简化版复数类 Complex
2.1 设计要点
- 类属性
doc:static const std::string,公有,类内声明、Complex.cpp类外初始化,供所有对象共享; - 对象属性
m_real、m_imag:私有,只能通过成员函数和友元访问; - 构造函数
Complex(double re = 0.0, double im = 0.0):默认实参同时支持Complex c1;、Complex c2(3, -4);、Complex c5(3.5);,且不加explicit,所以const Complex c6 = 3.5;的隐式转换成立; - 接口
real()、imag()声明为 const 成员函数(可被 const 对象调用),add()为非 const 成员函数(要修改自身); - 工具函数
output、abs、add(非成员版)、is_equal、is_not_equal设为友元,直接读写私有数据,不必额外开放 getter/setter。
2.2 源码
Complex.h
#pragma once
#include <string>
class Complex {
public:
static const std::string doc; // 类说明,公有、常量,类级共享
Complex(double re = 0.0, double im = 0.0); // 普通构造函数
Complex(const Complex &c); // 复制构造函数
double real() const; // 返回实部
double imag() const; // 返回虚部
void add(const Complex &c); // c1.add(c2),相当于 c1 += c2
// 友元函数:需要直接访问私有数据成员 real/imag
friend void output(const Complex &c); // 以 a+bi 形式输出
friend double abs(const Complex &c); // 取模
friend Complex add(const Complex &lhs, const Complex &rhs); // 两复数相加
friend bool is_equal(const Complex &lhs, const Complex &rhs);
friend bool is_not_equal(const Complex &lhs, const Complex &rhs);
private:
double m_real; // 实部
double m_imag; // 虚部
};
Complex.cpp
#include "Complex.h"
#include <cmath>
#include <iostream>
#include <string>
// static成员数据: 类内声明、类外初始化
const std::string Complex::doc{"a simplified complex class"};
Complex::Complex(double re, double im): m_real{re}, m_imag{im} {}
Complex::Complex(const Complex &c): m_real{c.m_real}, m_imag{c.m_imag} {}
double Complex::real() const {
return m_real;
}
double Complex::imag() const {
return m_imag;
}
void Complex::add(const Complex &c) {
m_real += c.m_real;
m_imag += c.m_imag;
}
// 友元函数实现
void output(const Complex &c) {
std::cout << c.m_real;
if(c.m_imag < 0)
std::cout << " - " << -c.m_imag;
else
std::cout << " + " << c.m_imag;
std::cout << "i";
}
double abs(const Complex &c) {
return std::sqrt(c.m_real * c.m_real + c.m_imag * c.m_imag);
}
Complex add(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.m_real + rhs.m_real, lhs.m_imag + rhs.m_imag);
}
bool is_equal(const Complex &lhs, const Complex &rhs) {
return lhs.m_real == rhs.m_real && lhs.m_imag == rhs.m_imag;
}
bool is_not_equal(const Complex &lhs, const Complex &rhs) {
return !is_equal(lhs, rhs);
}
task2.cpp(题目给定,未改动)
#include <iomanip>
#include <iostream>
#include <complex>
#include "Complex.h"
// 测试自定义类Complex
void test_Complex() {
using std::cout;
using std::endl;
using std::boolalpha;
cout << "类成员测试: " << endl;
cout << Complex::doc << endl << endl;
cout << "Complex对象测试: " << endl;
Complex c1;
Complex c2(3, -4);
Complex c3(c2);
Complex c4 = c2;
const Complex c5(3.5);
const Complex c6 = 3.5;
cout << "c1 = "; output(c1); cout << endl;
cout << "c2 = "; output(c2); cout << endl;
cout << "c3 = "; output(c3); cout << endl;
cout << "c4 = "; output(c4); cout << endl;
cout << "c5 = "; output(c5); cout << endl;
cout << "c6.real = " << c6.real()
<< ", c6.imag = " << c6.imag() << endl << endl;
cout << "复数运算测试: " << endl;
cout << "abs(c2) = " << abs(c2) << endl;
c1.add(c2);
cout << "c1 += c2, c1 = "; output(c1); cout << endl;
cout << boolalpha;
cout << "c1 == c2 : " << is_equal(c1, c2) << endl;
cout << "c1 != c2 : " << is_not_equal(c1, c2) << endl;
c4 = add(c2, c3);
cout << "c4 = c2 + c3, c4 = "; output(c4); cout << endl;
}
// 测试标准库类模板complex
void test_std_complex() {
using std::cout;
using std::endl;
using std::boolalpha;
cout << "std::complex<double>对象测试: " << endl;
std::complex<double> c1;
std::complex<double> c2(3, -4);
std::complex<double> c3(c2);
std::complex<double> c4 = c2;
std::complex<double> c5 = 3.5;
const std::complex<double> c6(3.5);
cout << "c1 = " << c1 << endl;
cout << "c2 = " << c2 << endl;
cout << "c3 = " << c3 << endl;
cout << "c4 = " << c4 << endl;
cout << "c5 = " << c5 << endl;
cout << "c6.real = " << c6.real()
<< ", c6.imag = " << c6.imag() << endl << endl;
cout << "复数运算测试: " << endl;
cout << "abs(c2) = " << abs(c2) << endl;
c1 += c2;
cout << "c1 += c2, c1 = " << c1 << endl;
cout << boolalpha;
cout << "c1 == c2 : " << (c1 == c2) << endl;
cout << "c1 != c2 : " << (c1 != c2) << endl;
c4 = c2 + c3;
cout << "c4 = c2 + c3, c4 = " << c4 << endl;
}
int main() {
std::cout << "*******测试1: 自定义类Complex*******\n";
test_Complex();
std::cout << "\n*******测试2: 标准库类模板complex*******\n";
test_std_complex();
}
2.3 运行结果

输出与文档预期完全一致:c1 = 0 + 0i、c2 = 3 - 4i、c5 = 3.5 + 0i、abs(c2) = 5、c1 == c2 : true、c4 = c2 + c3, c4 = 6 - 8i,并与 std::complex<double> 的测试结果一一对应。
2.4 问题回答
问题1:const 对象 c6 的访问与保护
① 为了让 c6.real()、c6.imag() 编译通过,成员函数必须加 const 关键字(写作 double real() const;,即“常成员函数”)。
原因:const 对象的隐含 this 指针类型是 const Complex*,而普通成员函数的 this 是 Complex*,把 const Complex* 传给 Complex* 会“丢掉 const 限定符”。不加 const 的报错如下:

error: passing 'const Complex' as 'this' argument of 'double Complex::real()' discards qualifiers [-fpermissive]
error: passing 'const Complex' as 'this' argument of 'double Complex::imag()' discards qualifiers [-fpermissive]
② 在测试代码中加一句 c6.add(c2); 不能编译通过:add(const Complex&) 是非 const 成员函数,要用它就得有可写的 this,而 c6 是 const 对象,同样报 discards qualifiers。

这体现了类的 const 保护机制:对象一旦被声明为 const,就只能调用 const 成员函数,编译器在编译期保证“只读对象不会被意外修改”,把“不该改”变成了编译错误而不是运行期隐患。
问题2:两种用法哪种更简洁?函数与运算的内在关联
自定义类 Complex |
标准库类模板 std::complex<T> |
|---|---|
c1.add(c2) |
c1 += c2 |
c4 = add(c2, c3) |
c4 = c2 + c3 |
is_equal(c1, c2) |
c1 == c2 |
is_not_equal(c1, c2) |
c1 != c2 |
output(c1) |
cout << c1 |
abs(c2) |
abs(c2) |
标准库 std::complex<T> 的用法明显更简洁:它用运算符重载,让复数运算的书写形式与数学表达式、与内置类型的习惯完全一致,不必记忆函数名和参数顺序,链式表达也更自然(c1 + c2 * c3)。自定义版本只能用“函数名 + 实参”的形式,可读性和表达力都更弱。
据此可以推断:函数和运算存在内在关联——运算符本质就是函数。c1 + c2 在语言层面就是调用 operator+(c1, c2),c1 == c2 就是 operator==(c1, c2),cout << c1 就是 operator<<(cout, c1)。C++ 的运算符重载正是“给函数换一个符号名字”,所以本任务把 add 写成友元函数、标准库把它实现成 operator+,二者在语义和实现上没有区别,只是书写形式不同。
问题3:友元的必要性、std::complex 的 abs、以及何时该用 friend
① 不是必须的。friend 授予的只是“访问私有成员的权限”,并不是实现这些功能的唯一途径。如果把 output、abs、add(非成员版)、is_equal、is_not_equal 声明为普通非成员函数,同样能实现相同功能,思路是只使用类的公有接口:
- 既然
real()、imag()已是公有的 const 访问器,output可以直接cout << c.real() << " + " << c.imag() << "i"; abs可用std::sqrt(c.real()*c.real() + c.imag()*c.imag());add(lhs, rhs)可以return Complex(lhs.real() + rhs.real(), lhs.imag() + rhs.imag());;is_equal比较两个对象的real()、imag()即可。
代价是:每次访问都要走一次函数调用(内联后可优化),且类必须把足够多的内部数据以公有接口暴露出来。两种方案的取舍在于“多开放公有接口”还是“多用一个 friend”。
② 标准库 std::complex 没有把 abs 设为友元。它是定义在命名空间 std 中的非成员函数模板:
template<class T> T abs(const complex<T>& z); // 见 <complex>,非成员函数
其实现只依赖 complex 的公有成员函数 real()、imag()(标准中写作 abs(z) 由 z.real()、z.imag() 计算模长),因此完全不需要 friend 权限。
参考页面:https://en.cppreference.com/w/cpp/numeric/complex/abs (标准库头文件 <complex> 中的“非成员函数”一节:https://en.cppreference.com/w/cpp/header/complex )
③ 我的结论(150 字内):
friend 适用于必须访问私有数据、且不便通过公有接口完成的紧密协作接口,如
operator<</operator>>、算术与比较运算符、需要读写内部状态的工具函数;它能避免为“内部实现”额外开放公有接口。但 friend 会放松封装、增加耦合,还会影响重载决议与接口清晰度。原则是:能用成员函数或公有接口解决就不用 friend,把它当作少量、边界清晰的特例来用。
3. 实验任务3:播放器控制类 PlayerControl
3.1 设计要点
- 用
enum class ControlType {Play, Pause, Next, Prev, Stop, Unknown};限定控制命令的取值,避免“裸字符串/魔术数字”在代码里乱飞; total_cnt为私有 static 成员,属于类而不属于某个对象,因此多个PlayerControl对象共享同一个计数器;parse()先把输入统一转成小写(std::transform+std::tolower),再逐一匹配,实现大小写不敏感,未匹配返回Unknown;execute()声明为 const 成员函数(执行控制不改变对象自身状态),每次调用(包括未知命令)先++total_cnt再switch打印。
3.2 源码
PlayerControl.h
#pragma once
#include <string>
enum class ControlType {Play, Pause, Next, Prev, Stop, Unknown};
class PlayerControl {
public:
PlayerControl();
ControlType parse(const std::string& control_str); // 实现std::string --> ControlType转换
void execute(ControlType cmd) const; // 执行控制操作(以打印输出模拟)
static int get_cnt();
private:
static int total_cnt;
};
PlayerControl.cpp
#include "PlayerControl.h"
#include <algorithm>
#include <cctype>
#include <iostream>
int PlayerControl::total_cnt = 0;
PlayerControl::PlayerControl() {}
// 1. 将输入字符串统一成转为小写,实现大小写不敏感
// 2. 匹配"play"/"pause"/"next"/"prev"/"stop"并返回对应枚举;
// 未匹配的字符串返回ControlType::Unknown
ControlType PlayerControl::parse(const std::string& control_str) {
std::string cmd(control_str);
std::transform(cmd.begin(), cmd.end(), cmd.begin(),
[](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
if(cmd == "play") return ControlType::Play;
if(cmd == "pause") return ControlType::Pause;
if(cmd == "next") return ControlType::Next;
if(cmd == "prev") return ControlType::Prev;
if(cmd == "stop") return ControlType::Stop;
return ControlType::Unknown;
}
void PlayerControl::execute(ControlType cmd) const {
// 每执行一次控制操作(含未知命令),total_cnt自增 1
++total_cnt;
switch (cmd) {
case ControlType::Play: std::cout << "[play] Playing music...\n"; break;
case ControlType::Pause: std::cout << "[Pause] Music paused\n"; break;
case ControlType::Next: std::cout << "[Next] Skipping to next track\n"; break;
case ControlType::Prev: std::cout << "[Prev] Back to previous track\n"; break;
case ControlType::Stop: std::cout << "[Stop] Music stopped\n"; break;
default: std::cout << "[Error] unknown control\n"; break;
}
}
int PlayerControl::get_cnt() {
return total_cnt;
}
task3.cpp(题目给定,未改动)
#include <iostream>
#include "PlayerControl.h"
void test() {
PlayerControl controller;
std::string control_str;
std::cout << "Enter Control: (play/pause/next/prev/stop/quit):\n";
while(std::cin >> control_str) {
if(control_str == "quit")
break;
ControlType cmd = controller.parse(control_str);
controller.execute(cmd);
std::cout << "Current Player control: " << PlayerControl::get_cnt() << "\n\n";
}
}
int main() {
test();
}
3.3 运行结果
测试输入:play、Play、next、STOP、foo(未知命令)、quit。

可见 play 与 Play 都被正确解析为 Play(大小写不敏感成立),STOP 解析为 Stop,foo 走到 [Error] unknown control 分支,并且未知命令也计入总数(计数依次为 1、2、3、4、5)。
3.4 问题回答
void execute(ControlType cmd) const; 是 const 成员函数,为什么内部允许 ++total_cnt?
因为 total_cnt 是静态数据成员(static),它属于类而不属于任何具体对象:它不占用对象内部空间,也没有 this 指针。
const 成员函数限制的是“不能通过 this 修改本对象的非静态数据成员”——在 const 函数中 this 的类型是 const PlayerControl*,任何对 m_xxx 这类普通成员的赋值都会被编译器拒绝。但 total_cnt 是类级变量,++total_cnt 并不经过 this,也不改变任何对象的状态,所以合法。
这也是一个值得警惕的设计点:const 成员函数并不能保证“对外部/全局状态只读”,本例的计数器、日志输出等副作用在 const 函数里依然存在。如果业务上要求“执行控制不产生任何可观察的状态变化”,就应把计数改为由非 const 接口负责,或让它成为可变状态(mutable,但要谨慎使用)。
3.5 选做:emoji 版本
思路:把 switch 分支里的纯文字提示替换为 emoji 前缀,并解决控制台编码问题——源文件必须保存为 UTF-8,程序在 Windows 控制台下还要把输出代码页设为 UTF-8,否则 emoji 会变成乱码或方框。因此在 task3.cpp 的 main() 里调用 SetConsoleOutputCP(CP_UTF8)(parse、get_cnt 等逻辑完全不变)。
// task3.cpp(emoji 版本,仅在 main 中增加编码设置,其余不变)
#include <iostream>
#ifdef _WIN32
#include <windows.h>
#endif
#include "PlayerControl.h"
void test() {
PlayerControl controller;
std::string control_str;
std::cout << "Enter Control: (play/pause/next/prev/stop/quit):\n";
while(std::cin >> control_str) {
if(control_str == "quit")
break;
ControlType cmd = controller.parse(control_str);
controller.execute(cmd);
std::cout << "Current Player control: " << PlayerControl::get_cnt() << "\n\n";
}
}
int main() {
#ifdef _WIN32
SetConsoleOutputCP(CP_UTF8); // 让控制台以UTF-8显示emoji
#endif
test();
}
// PlayerControl.cpp(emoji 版本,只改 execute 的打印内容)
void PlayerControl::execute(ControlType cmd) const {
++total_cnt;
switch (cmd) {
case ControlType::Play: std::cout << "🎵 Playing music...\n"; break;
case ControlType::Pause: std::cout << "⏸️ Music paused\n"; break;
case ControlType::Next: std::cout << "⏭️ Skipping to next track\n"; break;
case ControlType::Prev: std::cout << "⏮️ Back to previous track\n"; break;
case ControlType::Stop: std::cout << "⏹️ Music stopped\n"; break;
default: std::cout << "❓ unknown control\n"; break;
}
}
PlayerControl.h 无需改动。运行结果:

要点小结:① 源码编码、控制台代码页、终端字体三者都要支持,才能正确显示 emoji;② 只改“显示层”,控制逻辑(解析、计数)一行未动,说明把“行为”和“输出形式”分开是值得的。
4. 实验任务4:分数类 Fraction
4.1 设计方案:方案1「分数类 + 友元函数」
理由见 4.4 节的问题回答。核心设计如下:
doc为static const std::string,内容含换行,输出即两行说明;up、down私有;构造函数Fraction(int up0 = 0, int down0 = 1)支持Fraction f1(2)(分母默认 1)与Fraction f2(2, -3);分母为 0 时throw std::invalid_argument("Fraction: 分母不能为0");- 内部工具函数保证不变量:
gcd()求最大公约数、normalize()约分并把负号统一到分子(3/-4 → -3/4,-18/12 → -3/2,0/3 → 0/1),因此任何时候对象都处于最简形式; output对down == 1只打印分子(5而不是5/1,0而不是0/1),符合预期输出;negative()是 const 成员函数,返回新对象,不改自身;div的除数为 0 时新分母为 0,由构造函数抛异常,错误处理集中在一处。
4.2 源码
Fraction.h
#pragma once
#include <string>
class Fraction {
public:
static const std::string doc; // 类说明,公有、常量,类级共享
Fraction(int up0 = 0, int down0 = 1); // 普通构造函数(分母默认1)
Fraction(const Fraction &f); // 复制构造函数
int get_up() const; // 返回分子
int get_down() const; // 返回分母
Fraction negative() const; // 求负:返回-f,自身不变
// 方案1:分数类 + 友元函数,直接访问私有数据 up/down
friend void output(const Fraction &f);
friend Fraction add(const Fraction &lhs, const Fraction &rhs);
friend Fraction sub(const Fraction &lhs, const Fraction &rhs);
friend Fraction mul(const Fraction &lhs, const Fraction &rhs);
friend Fraction div(const Fraction &lhs, const Fraction &rhs);
private:
int m_up; // 分子
int m_down; // 分母
void normalize(); // 内部工具:约分、符号归一
static int gcd(int a, int b); // 内部工具:最大公约数
};
Fraction.cpp
#include "Fraction.h"
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
const std::string Fraction::doc{
"Fraction类 v 0.01版.\n目前仅支持分数对象的构造、输出、加/减/乘/除运算."};
Fraction::Fraction(int up0, int down0): m_up{up0}, m_down{down0} {
if(m_down == 0)
throw std::invalid_argument("Fraction: 分母不能为0");
normalize();
}
Fraction::Fraction(const Fraction &f): m_up{f.m_up}, m_down{f.m_down} {}
int Fraction::get_up() const {
return m_up;
}
int Fraction::get_down() const {
return m_down;
}
Fraction Fraction::negative() const {
return Fraction(-m_up, m_down);
}
// 内部工具:求最大公约数(辗转相除法)
int Fraction::gcd(int a, int b) {
a = std::abs(a);
b = std::abs(b);
while(b != 0) {
int r = a % b;
a = b;
b = r;
}
return a == 0 ? 1 : a;
}
// 内部工具:约分并把负号统一放到分子上
void Fraction::normalize() {
if(m_up == 0) { // 0/n 统一成 0/1
m_down = 1;
return;
}
if(m_down < 0) { // -2/-3 之类:符号归一到分子
m_up = -m_up;
m_down = -m_down;
}
int g = gcd(m_up, m_down);
m_up /= g;
m_down /= g;
}
// 友元函数实现
void output(const Fraction &f) {
if(f.m_down == 1)
std::cout << f.m_up;
else
std::cout << f.m_up << "/" << f.m_down;
}
Fraction add(const Fraction &lhs, const Fraction &rhs) {
return Fraction(lhs.m_up * rhs.m_down + rhs.m_up * lhs.m_down,
lhs.m_down * rhs.m_down);
}
Fraction sub(const Fraction &lhs, const Fraction &rhs) {
return Fraction(lhs.m_up * rhs.m_down - rhs.m_up * lhs.m_down,
lhs.m_down * rhs.m_down);
}
Fraction mul(const Fraction &lhs, const Fraction &rhs) {
return Fraction(lhs.m_up * rhs.m_up, lhs.m_down * rhs.m_down);
}
Fraction div(const Fraction &lhs, const Fraction &rhs) {
// 除数分子为0时,新分母为0,构造函数会抛出异常
return Fraction(lhs.m_up * rhs.m_down, lhs.m_down * rhs.m_up);
}
task4.cpp(题目给定,未改动)
#include <iostream>
#include "Fraction.h"
void test1() {
using std::cout;
using std::endl;
cout << "Fraction类测试: " << endl;
cout << Fraction::doc << endl << endl;
Fraction f1(5);
Fraction f2(3, -4), f3(-18, 12);
Fraction f4(f3);
cout << "f1 = "; output(f1); cout << endl;
cout << "f2 = "; output(f2); cout << endl;
cout << "f3 = "; output(f3); cout << endl;
cout << "f4 = "; output(f4); cout << endl;
const Fraction f5(f4.negative());
cout << "f5 = "; output(f5); cout << endl;
cout << "f5.get_up() = " << f5.get_up()
<< ", f5.get_down() = " << f5.get_down() << endl;
cout << "f1 + f2 = "; output(add(f1, f2)); cout << endl;
cout << "f1 - f2 = "; output(sub(f1, f2)); cout << endl;
cout << "f1 * f2 = "; output(mul(f1, f2)); cout << endl;
cout << "f1 / f2 = "; output(div(f1, f2)); cout << endl;
cout << "f4 + f5 = "; output(add(f4, f5)); cout << endl;
}
void test2() {
using std::cout;
using std::endl;
Fraction f6(42, 55), f7(0, 3);
cout << "f6 = "; output(f6); cout << endl;
cout << "f7 = "; output(f7); cout << endl;
cout << "f6 / f7 = "; output(div(f6, f7)); cout << endl;
}
int main() {
std::cout << "测试1: Fraction类基础功能测试\n";
test1();
std::cout << "\n测试2: 分母为0测试: \n";
test2();
}
4.3 运行结果

输出与文档预期一致:f2 = -3/4、f3 = -3/2(自动约分)、f5 = 3/2、f1 + f2 = 17/4、f1 / f2 = -20/3、f4 + f5 = 0;测试2 中 f7 = 0,div(f6, f7) 触发异常并因未捕获而终止:
terminate called after throwing an instance of 'std::invalid_argument'
what(): Fraction: 分母不能为0
这说明“分母为 0”被当作真正的错误处理,而不是输出一个无意义的分数。
4.4 问题回答
分数运算(output/add/sub/mul/div)选择了哪种设计方案?决策理由?
选择方案1:分数类 + 友元函数。理由:
- 数据访问成本最低:这些运算必须同时读取两个操作数的分子、分母,友元函数可直接访问
m_up、m_down,无需为“内部表示”额外增加公有的 getter/setter,也不会因为层层调用get_up()/get_down()降低可读性。 - 封装仍然成立:友元只是“点对点的授权”,普通用户代码依旧无法直接触碰
up/down;外部只能通过Fraction的构造函数与工具函数操作分数,类的不变量(分母非 0、已约分、负号在分子)由类自己维护。 - 接口与题目测试代码一致:调用形式
add(f1, f2)、output(f1)就是文档给定的写法,不需要像方案2那样在测试代码里加frac::前缀,改动最小。 - 可维护性:运算符/工具函数集中在
Fraction.cpp,新增运算只需再加一个友元声明与实现;而如果走方案2,则需要在命名空间frac中另开一套函数,并依赖公有访问器,接口面更大。
代价与风险也要承认:friend 会削弱封装、增加类与函数之间的耦合,因此只把必要的运算设为友元,并保持数量可控;如果运算需要复用到别的数据类型(如后续要支持 Fraction + int 的混合运算),或想避免修改类声明,那么方案2(命名空间自由函数,配合公有 get_up()/get_down())会更灵活。
三、实验总结
- 从“过程”到“对象”的转变:
T、Complex、PlayerControl、Fraction四个类都遵循同一套模式——数据私有、行为公有、用构造函数建立不变量、用析构函数收尾。把不变量(如分母非 0、分数已约分、对象数不超上限)交给类自己去守,外部代码就只需要关心“语义”,不必操心“表示”。 - 构造函数/析构函数是资源管理的骨架:任务1 的输出让我直观看到“构造顺序 t1→t4、析构顺序 t4→t1”,也看到
throw未被捕获时std::terminate直接中止、析构函数没有执行。这反过来解释了为什么 RAII 强调“资源在构造中获取、在析构中释放”,以及为什么异常安全要求用try/catch包住可能抛异常的区域。 - static 是“类级共享”,不是“对象级共享”:
current_cnt、total_cnt让同一类的所有对象共享一份数据,static成员必须类外定义(否则链接期重复定义)。另外const成员函数可以修改 static 成员这一现象,提醒我 const 的语义边界是“这个对象”,不是“整个世界”。 - const 的价值在编译期兑现:常成员函数、const 对象、const 引用形参三者配合,让“只读”的承诺由编译器检查;
c6.real()少写一个const就编不过——这种“提前失败”比运行期的隐性修改可靠得多。 - friend 是一把双刃剑:任务2 让我确认
std::complex的abs根本不需要 friend(公有real()/imag()足够),任务4 才在“运算函数要同时读两个对象的内部数据”时选择 friend。判断标准不是“方便”,而是“是否有公有接口无法表达的访问需求”。 - 多文件组织让职责清晰:
*.h只放声明与接口契约,*.cpp放实现,taskN.cpp只做测试;同时踩过一次“把 static 定义搬进头文件 → 链接期重复定义”的坑,对“声明 vs 定义”和 ODR 的理解比只看书更牢。
待解疑问:① 移动构造函数在本例中没有真正“窃取”资源(只有 int 成员),如果成员是堆上数组,如何正确实现“接管指针并把源对象置空”?② 运算符重载(operator+、operator<<)相比友元函数工具,是否在“可读性 vs 隐式转换带来的歧义”之间更难权衡?这两点希望在后续实验中继续验证。
四、附录(实验代码运行截图)









浙公网安备 33010602011771号