实验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();
}
运行测试截图

问题与思考
-
t.h中给出了普通构造函数、复制构造函数、移动构造函数和析构函数。用文字简洁说明它们各自的功能和调用时机。结合t1-t4,说明它们分别触发了哪个构造函数。普通构造函数在创建对象时初始化成员,t1没有传入参数,使用默认值0;t2传入3和4,分别初始化m1和m2。
复制构造用已有对象来初始化新对象,因此t3(t2)调用复制构造。
移动构造函数用一个对象来初始化新对象。t4(std::move(t2))中,std::move让t2可以匹配移动构造函数,因此创建t4时调用移动构造。
析构函数在对象被销毁时调用,可以释放对应的空间,当然本例中也可以维护对象的实施计数。 -
把
t.cpp中line 8-10的代码剪切到t.h末尾,重新编译,程序能否正确编译?如果不能,请给出报错截图并分析原因。按代码分析,这样改后无法完成联合编译,会在链接时出现重复定义错误。这时候t.cpp和task1.cpp都包含t.h,把这三行放进头文件后,两边就各有一份定义。
其中#pragma once只能防止同一个源文件重复包含头文件,解决不了两个源文件各自定义一次的问题。故程序编译报错

-
说明测试模块
test中对象t1-t4的作用域和生命期。在这个作用域内,能否通过t1访问其私有成员m1、m2?这体现了类的什么特性?t1-t4的作用域分别从各自的声明处开始,到test函数内部的花括号结束。它们是局部对象,生命期从各自构造完成开始,正常离开这个代码块时依次析构。
其名字在作用域内可见,并不代表可以访问所有成员,t1.m1和t1.m2仍然受到private限制,普通的,外部的函数不能访问。
这里体现了类访问权限的控制,外部可以调用公有函数,获者通过已声明的友元函数output来读取数据。 -
查询并说明
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);
}
运行测试截图

问题与思考
-
测试代码中的c6是const对象。
① 为了让
c6.real()和c6.imag()能编译通过,在设计Complex类的成员函数时必须加上什么关键字?如果不加,编译器会报什么错误?在real()和imag的参数列表后加上const。即使函数里只是读取数据,也不能省略这个声明,否则c6调用时仍会报错,提示常量对象不能调用非const成员函数。
② 在测试代码中添加
c6.add(c2);,能编译通过吗?为什么?这体现了类的什么保护机制?不能。add会修改实部和虚部,是非const成员函数,而c6是常量对象,不能调用它。
是const对对象的保护,用于防止通过这类权限较高的函数修改常量对象。 -
比较自定义类Complex和标准库类模板
std::complex的用法。在使用形式上,哪一种更简洁?据此推断函数和运算是否存在内在关联。自定义类Complex 标准库类模板 std::complexc1.add(c2)c1 += c2c4 = add(c2, c3)c4 = c2 + c3is_equal(c1, c2)c1 == c2is_not_equal(c1, c2)c1 != c2output(c1)cout << c1abs(c2)abs(c2)标准库的写法更简洁,c2 + c3比add(c2, c3)更接近平时写的数学式子。C++通过运算符重载,让这些表达式调用对应的函数来完成运算,所以加号这样的运算符也可以和函数联系起来。abs在两种写法中都是直接调用函数。
-
关于友元函数:
① 本练习中,
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;
}
运行测试截图

问题与思考
-
接口
void execute(ControlType cmd) const;是const成员函数,为什么在其内部允许执行++total_cnt?total_cnt是static成员,该类所有对象共用这一份计数。const限制的是通过当前对象修改对象内部数据,total_cnt属于整个类,所以仍然可以执行自➕。
-
思考(选做):如果希望模拟播放控制时的输出更现代,例如使用emoji,应如何调整代码实现?
可以在
execute函数的switch语句中修改各控制命令对应的输出字符串。播放、暂停、下一首、上一首和停止分别使用 ▶️、⏸️、⏭️、⏮️ 和 ⏹️,未知命令使用 ❓。即emoji直接写入字符串

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);
}
运行测试截图

问题与思考
-
分数运算
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,多次计算后可能受到浮点误差影响。目前给出的测试数据比较简单,还没有覆盖这些情况。


浙公网安备 33010602011771号