实验2_实验报告

实验2:类和对象_基础编程1

四、实验结论

1. 实验任务1

源代码

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();
    friend void output(const T &t);
    static const std::string doc;
    static const int MAX_CNT;
private:
    int m1, m2;
    static int current_cnt;
};

t.cpp

#include "t.h"
#include <iostream>
#include <stdexcept>
#include <string>
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();
}

运行测试截图

image

问题与思考

  1. t.h中给出了普通构造函数、复制构造函数、移动构造函数和析构函数。用文字简洁说明它们各自的功能和调用时机。结合t1-t4,说明它们分别触发了哪个构造函数。

    普通构造函数在创建对象时初始化成员,t1没有传入参数,使用默认值0;t2传入3和4,分别初始化m1和m2。
    复制构造用已有对象来初始化新对象,因此t3(t2)调用复制构造。
    移动构造函数用一个对象来初始化新对象。t4(std::move(t2))中,std::move让t2可以匹配移动构造函数,因此创建t4时调用移动构造。
    析构函数在对象被销毁时调用,可以释放对应的空间,当然本例中也可以维护对象的实施计数。

  2. 把t.cpp中line 8-10的代码剪切到t.h末尾,重新编译,程序能否正确编译?如果不能,请给出报错截图并分析原因。

    按代码分析,这样改后无法完成联合编译,会在链接时出现重复定义错误。这时候t.cpp和task1.cpp都包含t.h,把这三行放进头文件后,两边就各有一份定义。
    其中#pragma once只能防止同一个源文件重复包含头文件,解决不了两个源文件各自定义一次的问题。故程序编译报错

image-1

  1. 说明测试模块test中对象t1-t4的作用域和生命期。在这个作用域内,能否通过t1访问其私有成员m1、m2?这体现了类的什么特性?

    t1-t4的作用域分别从各自的声明处开始,到test函数内部的花括号结束。它们是局部对象,生命期从各自构造完成开始,正常离开这个代码块时依次析构。
    其名字在作用域内可见,并不代表可以访问所有成员,t1.m1和t1.m2仍然受到private限制,普通的,外部的函数不能访问。
    这里体现了类访问权限的控制,外部可以调用公有函数,获者通过已声明的友元函数output来读取数据。

  2. 查询并说明throw的功能。把t.cpp中的T::MAX_CNT改为2,重新编译、运行程序。程序是正常结束还是异常终止?如果异常终止,已经创建的对象(如t1)会被正常销毁吗?请给出答案并说明理由。

    询问AI得道:“throw用于抛出异常,执行到它时会中断当前正常流程,寻找匹配的catch”
    此处MAX_CNT改为2后,t1、t2构造成功,创建t3时对象数量已达到上限,复制构造会抛出runtime_error,t4不会被创建。
    询问AI得到:已经创建的t1、t2不一定会正常析构。因为程序没有catch来处理这个异常,终止前是否调用它们的析构函数,要看编译器和运行环境的具体实现,不能认为一定会像正常离开花括号时那样销毁对象。参考:C++异常处理说明。
    image

2. 实验任务2

源代码

Complex.h

#pragma once
#include <string>
class Complex {
public:
    static const std::string doc;
    Complex(double real0 = 0, double imag0 = 0);
    double real() const;
    double imag() const;
    void add(const Complex &c);
    friend void output(const Complex &c);
    friend double abs(const Complex &c);
    friend Complex add(const Complex &c1, const Complex &c2);
    friend bool is_equal(const Complex &c1, const Complex &c2);
    friend bool is_not_equal(const Complex &c1, const Complex &c2);
private:
    double real_part;
    double imag_part;
};

Complex.cpp

#include "Complex.h"
#include <cmath>
#include <iostream>
const std::string Complex::doc{"a simplified complex class"};
Complex::Complex(double real0, double imag0): real_part{real0}, imag_part{imag0} {}
double Complex::real() const {
    return real_part;
}
double Complex::imag() const {
    return imag_part;
}
void Complex::add(const Complex &c) {
    real_part += c.real_part;
    imag_part += c.imag_part;
}
void output(const Complex &c) {
    std::cout << c.real_part;
    if (c.imag_part >= 0)
        std::cout << " + " << c.imag_part << "i";
    else
        std::cout << " - " << -c.imag_part << "i";
}
double abs(const Complex &c) {
    return std::sqrt(c.real_part * c.real_part + c.imag_part * c.imag_part);
}
Complex add(const Complex &c1, const Complex &c2) {
    return Complex(c1.real_part + c2.real_part, c1.imag_part + c2.imag_part);
}
bool is_equal(const Complex &c1, const Complex &c2) {
    return c1.real_part == c2.real_part && c1.imag_part == c2.imag_part;
}
bool is_not_equal(const Complex &c1, const Complex &c2) {
    return !is_equal(c1, c2);
}

运行测试截图

image-4

问题与思考

  1. 测试代码中的c6是const对象。

    ① 为了让c6.real()和c6.imag()能编译通过,在设计Complex类的成员函数时必须加上什么关键字?如果不加,编译器会报什么错误?

    在real()和imag的参数列表后加上const。即使函数里只是读取数据,也不能省略这个声明,否则c6调用时仍会报错,提示常量对象不能调用非const成员函数。

    ② 在测试代码中添加c6.add(c2);,能编译通过吗?为什么?这体现了类的什么保护机制?

    不能。add会修改实部和虚部,是非const成员函数,而c6是常量对象,不能调用它。
    是const对对象的保护,用于防止通过这类权限较高的函数修改常量对象。

  2. 比较自定义类Complex和标准库类模板std::complex的用法。在使用形式上,哪一种更简洁?据此推断函数和运算是否存在内在关联。

    自定义类Complex 标准库类模板std::complex
    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)

    标准库的写法更简洁,c2 + c3比add(c2, c3)更接近平时写的数学式子。C++通过运算符重载,让这些表达式调用对应的函数来完成运算,所以加号这样的运算符也可以和函数联系起来。abs在两种写法中都是直接调用函数。

  3. 关于友元函数:

    ① 本练习中,output、abs、add(非成员版本)等被设为Complex的友元。这是必须的吗?如果将其声明为普通非成员函数,不使用friend,能否实现相同功能?请简述思路。

    不一定。普通函数通过real()和imag()也能读到实部和虚部。例如add可以分别求出两个实部、两个虚部的和,再用这两个结果构造新的Complex对象。这样不直接访问私有成员,就不需要声明为友元。

    ② 标准库std::complex是否把abs设为友元?查阅cppreference后回答,并提供页面的具体链接地址。

    cppreference将std::abs列为std::complex的非成员函数模板,标准接口没有要求把它声明为友元。它可以通过公开的实部、虚部访问接口计算复数的模,无须直接访问私有数据。需注意,友元也属于非成员函数,参考:std::abs(std::complex)。

    ③ 工业场景中,什么时候才考虑使用friend?和AI讨论后,在150字以内简洁概括自己的思考和结论。

    可以先看现有的公有接口够不够用。如果某个函数或类确实需要访问内部数据,增加公有接口又会暴露过多细节的时候,就可以考虑friend。但只应该给需要的函数或类授权,否则私有成员一改,很多地方都要跟着修改。

3. 实验任务3

源代码

PlayerControl.cpp中自行补足的parse函数

ControlType PlayerControl::parse(const std::string& control_str) {
    std::string control = control_str;
    for (char &ch : control) {
        if (ch >= 'A' && ch <= 'Z')
            ch = static_cast<char>(ch - 'A' + 'a');
    }
    if (control == "play")
        return ControlType::Play;
    if (control == "pause")
        return ControlType::Pause;
    if (control == "next")
        return ControlType::Next;
    if (control == "prev")
        return ControlType::Prev;
    if (control == "stop")
        return ControlType::Stop;
    return ControlType::Unknown;
}

运行测试截图

image-7

问题与思考

  1. 接口void execute(ControlType cmd) const;是const成员函数,为什么在其内部允许执行++total_cnt?

    total_cnt是static成员,该类所有对象共用这一份计数。const限制的是通过当前对象修改对象内部数据,total_cnt属于整个类,所以仍然可以执行自➕。

  2. 思考(选做):如果希望模拟播放控制时的输出更现代,例如使用emoji,应如何调整代码实现?

    可以在execute函数的switch语句中修改各控制命令对应的输出字符串。播放、暂停、下一首、上一首和停止分别使用 ▶️、⏸️、⏭️、⏮️ 和 ⏹️,未知命令使用 ❓。即emoji直接写入字符串

image-8

4. 实验任务4

源代码

Fraction.h

#pragma once
#include <string>
class Fraction {
public:
    static const std::string doc;
    Fraction(int up0 = 0, int down0 = 1);
    int get_up() const;
    int get_down() const;
    Fraction negative() const;
    friend void output(const Fraction &f);
    friend Fraction add(const Fraction &f1, const Fraction &f2);
    friend Fraction sub(const Fraction &f1, const Fraction &f2);
    friend Fraction mul(const Fraction &f1, const Fraction &f2);
    friend Fraction div(const Fraction &f1, const Fraction &f2);
private:
    int up;
    int down;
    void simplify();
};

Fraction.cpp

#include "Fraction.h"
#include <iostream>
#include <stdexcept>
const std::string Fraction::doc{"Fraction类 v 0.01版.\n目前仅支持分数对象的构造、输出、加/减/乘/除运算."};
Fraction::Fraction(int up0, int down0): up{up0}, down{down0} {
    if (down == 0)
        throw std::invalid_argument("Fraction: 分母不能为0");
    simplify();
}
void Fraction::simplify() {
    if (down < 0) {
        up = -up;
        down = -down;
    }
    int a = up < 0 ? -up : up;
    int b = down;
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    if (a != 0) {
        up /= a;
        down /= a;
    }
}
int Fraction::get_up() const {
    return up;
}
int Fraction::get_down() const {
    return down;
}
Fraction Fraction::negative() const {
    return Fraction(-up, down);
}
void output(const Fraction &f) {
    std::cout << f.up << "/" << f.down;
}
Fraction add(const Fraction &f1, const Fraction &f2) {
    return Fraction(f1.up * f2.down + f2.up * f1.down, f1.down * f2.down);
}
Fraction sub(const Fraction &f1, const Fraction &f2) {
    return Fraction(f1.up * f2.down - f2.up * f1.down, f1.down * f2.down);
}
Fraction mul(const Fraction &f1, const Fraction &f2) {
    return Fraction(f1.up * f2.up, f1.down * f2.down);
}
Fraction div(const Fraction &f1, const Fraction &f2) {
    return Fraction(f1.up * f2.down, f1.down * f2.up);
}

运行测试截图

image-6

问题与思考

  1. 分数运算output/add/sub/mul/div选择的是哪一种设计方案?说明你的决策理由。

    • 方案1:分数类 + 友元函数
    • 方案2:分数类 + 命名空间自由函数

    我选了方案1,分数类加友元函数。

    1)这几个函数都需要读取分子、分母,声明为友元后可以直接使用up和down,逻辑上+计算过程写起来比较直观
    2)加、减、乘、除都需要两个分数参与,用add(f1, f2)这样的形式比较自然,也能直接配合给出的测试代码。
    3)为了练习friend的语法和使用方式。

五、实验总结(选写)

1.const和static比较容易混淆。需要判断能某个变量不能修改时,重点应该看变量属于对象还是整个类。

2.还有两个地方可以继续考虑:
1)分数的分子、分母用int存储,数值较大时相乘可能溢出;
2)复数直接用等于比较double,多次计算后可能受到浮点误差影响。目前给出的测试数据比较简单,还没有覆盖这些情况。

posted @ 2026-11-20 00:56  Morever11  阅读(3)  评论(0)    收藏  举报