实验2

实验2 类和对象

一、实验环境及目的

实验环境:Windows 10 + Dev-C++(TDM-GCC 4.9.2,g++ -std=c++11,64 位)
代码组织:全部采用多文件结构(头文件放声明、cpp 放实现、taskN.cpp 放测试与 main)

实验目的

  1. 加深对 OOP 概念(类、对象)和特性(封装)的理解;
  2. 会用 C++ 定义、实现、测试类,能用类创建对象并基于对象编程;
  3. 理解构造函数、析构函数的用途与调用时机,理解 C++ 的内存资源管理;
  4. 会用多文件结构组织代码,并练习用 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 运行结果

task1 运行结果

关键现象: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 后重新编译运行,程序崩溃(异常终止):

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 运行结果

task2 运行结果

输出与文档预期完全一致: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 的报错如下:

未加 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 保护机制:对象一旦被声明为 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。

task3 运行结果

可见 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 无需改动。运行结果:

task3 emoji 版本运行结果

要点小结:① 源码编码、控制台代码页、终端字体三者都要支持,才能正确显示 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 运行结果

task4 运行结果

输出与文档预期一致: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:分数类 + 友元函数。理由:

  1. 数据访问成本最低:这些运算必须同时读取两个操作数的分子、分母,友元函数可直接访问 m_up、m_down,无需为“内部表示”额外增加公有的 getter/setter,也不会因为层层调用 get_up()/get_down() 降低可读性。
  2. 封装仍然成立:友元只是“点对点的授权”,普通用户代码依旧无法直接触碰 up/down;外部只能通过 Fraction 的构造函数与工具函数操作分数,类的不变量(分母非 0、已约分、负号在分子)由类自己维护。
  3. 接口与题目测试代码一致:调用形式 add(f1, f2)、output(f1) 就是文档给定的写法,不需要像方案2那样在测试代码里加 frac:: 前缀,改动最小。
  4. 可维护性:运算符/工具函数集中在 Fraction.cpp,新增运算只需再加一个友元声明与实现;而如果走方案2,则需要在命名空间 frac 中另开一套函数,并依赖公有访问器,接口面更大。

代价与风险也要承认:friend 会削弱封装、增加类与函数之间的耦合,因此只把必要的运算设为友元,并保持数量可控;如果运算需要复用到别的数据类型(如后续要支持 Fraction + int 的混合运算),或想避免修改类声明,那么方案2(命名空间自由函数,配合公有 get_up()/get_down())会更灵活。


三、实验总结

  1. 从“过程”到“对象”的转变:T、Complex、PlayerControl、Fraction 四个类都遵循同一套模式——数据私有、行为公有、用构造函数建立不变量、用析构函数收尾。把不变量(如分母非 0、分数已约分、对象数不超上限)交给类自己去守,外部代码就只需要关心“语义”,不必操心“表示”。
  2. 构造函数/析构函数是资源管理的骨架:任务1 的输出让我直观看到“构造顺序 t1→t4、析构顺序 t4→t1”,也看到 throw 未被捕获时 std::terminate 直接中止、析构函数没有执行。这反过来解释了为什么 RAII 强调“资源在构造中获取、在析构中释放”,以及为什么异常安全要求用 try/catch 包住可能抛异常的区域。
  3. static 是“类级共享”,不是“对象级共享”:current_cnt、total_cnt 让同一类的所有对象共享一份数据,static 成员必须类外定义(否则链接期重复定义)。另外 const 成员函数可以修改 static 成员这一现象,提醒我 const 的语义边界是“这个对象”,不是“整个世界”。
  4. const 的价值在编译期兑现:常成员函数、const 对象、const 引用形参三者配合,让“只读”的承诺由编译器检查;c6.real() 少写一个 const 就编不过——这种“提前失败”比运行期的隐性修改可靠得多。
  5. friend 是一把双刃剑:任务2 让我确认 std::complex 的 abs 根本不需要 friend(公有 real()/imag() 足够),任务4 才在“运算函数要同时读两个对象的内部数据”时选择 friend。判断标准不是“方便”,而是“是否有公有接口无法表达的访问需求”。
  6. 多文件组织让职责清晰:*.h 只放声明与接口契约,*.cpp 放实现,taskN.cpp 只做测试;同时踩过一次“把 static 定义搬进头文件 → 链接期重复定义”的坑,对“声明 vs 定义”和 ODR 的理解比只看书更牢。

待解疑问:① 移动构造函数在本例中没有真正“窃取”资源(只有 int 成员),如果成员是堆上数组,如何正确实现“接管指针并把源对象置空”?② 运算符重载(operator+、operator<<)相比友元函数工具,是否在“可读性 vs 隐式转换带来的歧义”之间更难权衡?这两点希望在后续实验中继续验证。

四、附录(实验代码运行截图)

task1-maxcnt2

task1-run

task1-static-in-header-error

task2-const-add-error

task2-no-const-error

task2-run

task3-emoji

task3-run

task4-run

posted @ 2026-11-19 12:32  xuak  阅读(2)  评论(0)    收藏  举报