实验二
实验2-1
T.h
#pragma once
#include <string>
// 类T: 声明
class T {
// 对象属性、方法
public:
T(int x = 0, int y = 0); // 普通构造函数
T(const T &t); // 复制构造函数
T(T &&t); // 移动构造函数
~T(); // 析构函数
void adjust(int ratio); // 按系数成倍调整数据
void display() const; // 以(m1, m2)形式显示T类对象信息
private:
int m1, m2;
// 类属性、方法
public:
static int get_cnt(); // 显示当前T类对象总数
public:
static const std::string doc; // 类T的描述信息
static const int max_cnt; // 类T对象上限
private:
static int cnt; // 当前T类对象数目
// 类T友元函数声明
friend void func();
};
// 普通函数声明
void func();
T.cpp
#include "T.h"
#include <iostream>
#include <string>
// 类T实现
// static成员数据类外初始化
const std::string T::doc{ "a simple class sample" };
const int T::max_cnt = 999;
int T::cnt = 0;
// 类方法
int T::get_cnt() {
return cnt;
}
// 对象方法
T::T(int x, int y) : m1{ x }, m2{ y } {
++cnt;
std::cout << "T constructor called.\n";
}
T::T(const T& t) : m1{ t.m1 }, m2{ t.m2 } {
++cnt;
std::cout << "T copy constructor called.\n";
}
T::T(T&& t) : m1{ t.m1 }, m2{ t.m2 } {
++cnt;
std::cout << "T move constructor called.\n";
}
T::~T() {
--cnt;
std::cout << "T destructor called.\n";
}
void T::adjust(int ratio) {
m1 *= ratio;
m2 *= ratio;
}
void T::display() const {
std::cout << "(" << m1 << ", " << m2 << ")";
}
// 普通函数实现
void func() {
T t5(42);
t5.m2 = 2049;
std::cout << "t5 = "; t5.display(); std::cout << '\n';
}
task1.cpp
#pragma GCC optimize("O0")
#include "T.h"
#include <iostream>
void test_T();
int main() {
std::cout << "test Class T: \n";
test_T();
std::cout << "\ntest friend func: \n";
func();
}
void test_T() {
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 = "; t1.display(); cout << endl;
T t2(3, 4);
cout << "t2 = "; t2.display(); cout << endl;
T t3(t2);
t3.adjust(2);
cout << "t3 = "; t3.display(); cout << endl;
T t4(std::move(t2));
cout << "t4 = "; t4.display(); cout << endl;
cout << "test: T objects'current count: " << T::get_cnt() << endl;
}
注：源代码中没有在 func() 调用后打印 T::get_cnt()，所以看不到 func() 内部的计数变化。
Q1
原因：友元声明 ≠ 函数声明，友元函数唯一作用是授予函数 func 访问类 T 私有成员的权限，不能代替声明。
Q2
普通构造函数
功能：初始化新对象的m1和m2成员，递增静态计数器cnt
复制构造函数
功能：创建对象的完整副本，保持原始对象不变
移动构造函数
功能：转移右值对象的资源，将源对象置于可析构状态
析构函数
功能：递减对象计数器，执行必要的清理工作
调用时机：对象生命周期结束时自动调用
Q3
T.h 被 task1.cpp 和 T.cpp 同时包含
编译时，两个源文件都会包含 T.h 中的这些定义，会发现 T::doc, T::max_cnt, T::cnt 有两个重复的定义,因此报"多重定义"错误
实验2-2
Complex.h
#pragma once
#include<string>
class Complex
{
friend void output(const Complex &a);
friend double abs(const Complex &a);
friend Complex add(const Complex &a,const Complex &b);
friend bool is_equal(const Complex &a,const Complex &b);
friend bool is_not_equal(const Complex &a,const Complex &b);
public:
Complex();
Complex(double a,double b);
Complex(double a);
Complex(const Complex &b);
double get_real()const;
double get_imag()const;
void add(const Complex &b);
static std::string doc;
private:
double real;
double imag;
char sign;
};
Complex.cpp
#include"Complex.h"
#include<iostream>
#include<cmath>
using std::cout;
using std::endl;
std::string Complex::doc = "a simplified complex class";
Complex::Complex():real(0),imag(0),sign('+'){};
Complex::Complex(double a,double b):real(a),imag(b){
if(b>=0){
sign='+';
}
else{
sign='-';
}
};
Complex::Complex(double a):real(a),imag(0){
sign='+';
};
Complex::Complex(const Complex &b)
{
imag=b.imag;
real=b.real;
sign=b.sign;
};
double Complex::get_real()const
{
return real;
};
double Complex::get_imag()const
{
return imag;
};
void Complex::add(const Complex& b)
{
real+= b.real;
imag+= b.imag;
sign = (imag >= 0) ? '+' : '-';
}
void output(const Complex &a)
{
cout<< a.real<<' '<<a.sign<<' '<<abs(a.imag)<<'i'<<endl;
};
double abs(const Complex &a)
{
return sqrt(a.real*a.real+a.imag*a.imag);
};
Complex add(const Complex &a,const Complex &b)
{
double creal =a.real + b.real;
double cimag =a.imag + b.imag;
return Complex(creal,cimag);
};
bool is_equal(const Complex &a,const Complex &b)
{
const double eps = 1e-9;
return fabs(a.real - b.real) < eps && fabs(a.imag - b.imag) < eps;
};
bool is_not_equal(const Complex &a,const Complex &b)
{
return !is_equal(a, b);
};
task2.cpp
// 待补足头文件
// xxx
#include <iostream>
#include <iomanip>
#include <complex>
#include "Complex.h"
void test_Complex();
void test_std_complex();
int main() {
std::cout << "*******测试1: 自定义类Complex*******\n";
test_Complex();
std::cout << "\n*******测试2: 标准库模板类complex*******\n";
test_std_complex();
return 0;
}
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);
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.real = " << c5.get_real()
<< ", c5.imag = " << c5.get_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;
}
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;
const std::complex<double> c5(3.5);
cout << "c1 = " << c1 << endl;
cout << "c2 = " << c2 << endl;
cout << "c3 = " << c3 << endl;
cout << "c4 = " << c4 << endl;
cout << "c5.real = " << c5.real()
<< ", c5.imag = " << c5.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;
}
Q1
标准库更简洁，有关联，运算符号就是对函数的一种重载形式。
Q2
Q2-1
否，可以提供外部接口获得私有成员的值
Q2-2
否，std::abs(std::complex) 是一个普通的非成员函数，它通过调用 std::complex 对象的公开成员函数（如 .real() 和 .imag()）来计算复数的模。
Q2-3
1、两个类设计上高度耦合，需要频繁、直接地访问对方内部状态。
2、保证自定义类型与内置类型运算逻辑一致，且第一个操作数不是当前类对象。
Q3
使用复制构造函数
实验2-3
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);
void execute(ControlType cmd) const;
static int get_cnt();
private:
static int total_cnt;
};
PlayerControl.cpp
#include "PlayerControl.h"
#include <iostream>
#include <algorithm>
int PlayerControl::total_cnt = 0;
PlayerControl::PlayerControl() {}
// 待补足
// 1. 将输入字符串转为小写，实现大小写不敏感
// 2. 匹配"play"/"pause"/"next"/"prev"/"stop"并返回对应枚举
// 3. 未匹配的字符串返回ControlType::Unknown
// 4. 每次成功调用parse时递增total_cnt
void to_lower(std::string& str) {
for (size_t i = 0; i < str.size(); ++i) {
str[i] = static_cast<char>(tolower(static_cast<unsigned char>(str[i])));
}
}
ControlType PlayerControl::parse(const std::string& control_str) {
std::string lower_str = control_str;
to_lower(lower_str);
if (lower_str == "play") {
total_cnt++;
return ControlType::Play;
} else if (lower_str == "pause") {
total_cnt++;
return ControlType::Pause;
} else if (lower_str == "next") {
total_cnt++;
return ControlType::Next;
} else if (lower_str == "prev") {
total_cnt++;
return ControlType::Prev;
} else if (lower_str == "stop") {
total_cnt++;
return ControlType::Stop;
} else {
return ControlType::Unknown;
}
}
void PlayerControl::execute(ControlType cmd) const {
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 "PlayerControl.h"
#include <iostream>
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();
}
Q
用UTF-8编码，查找对应编码值插入即可
实验2-4
Fraction.h
#pragma once
#include <string>
class Fraction {
private:
int up;
int down;
bool is_valid;
public:
Fraction(int a);
Fraction(int a, int b);
Fraction(const Fraction &a);
int get_up() const;
int get_down() const;
Fraction negative() const;
static std::string doc;
bool valid() const ;
};
void output(const Fraction &a);
Fraction add(const Fraction &a, const Fraction &b);
Fraction sub(const Fraction &a, const Fraction &b);
Fraction mul(const Fraction &a, const Fraction &b);
Fraction div(const Fraction &a, const Fraction &b);
Fraction.cpp
#include "Fraction.h"
#include <iostream>
#include <stdexcept>
std::string Fraction::doc = "Fraction类 v 0.01版.\n目前仅支持分数对象的构造、输出、加/减/乘/除运算.\n";
Fraction::Fraction(int a) : up(a), down(1),is_valid(1) {}
int gcd(int a, int b)
{
a = abs(a);
b = abs(b);
return (b == 0) ? a : gcd(b, a % b); // 递归终止条件：b=0时返回a
}
Fraction::Fraction(int a, int b) : up(a), down(b),is_valid(1)
{
if (b == 0)
{
is_valid=0;
return;
}
if (down < 0)
{
up = -up;
down = -down;
int c=gcd(up,down);
up/=c;
down/=c;
}
}
bool Fraction::valid() const { return is_valid; }
Fraction::Fraction(const Fraction &a) : up(a.up), down(a.down),is_valid(1) {}
int Fraction::get_up() const
{
return up;
}
int Fraction::get_down() const
{
return down;
}
Fraction Fraction::negative() const
{
int c=gcd(up,down);
return Fraction(-up/c, down/c);
}
void output(const Fraction &a)
{
if (!a.valid()) {
std::cout<<"分母不能为0"<<std::endl;
return;
}
if(a.get_down() == 1){
std::cout << a.get_up() << std::endl;
return;
}
if(a.get_up() == 0) {
std::cout << 0 << std::endl;
return;
}
else
{
int c=gcd(a.get_up(),a.get_down());
std::cout << a.get_up()/c << '/' << a.get_down()/c<<std::endl;
}
}
Fraction add(const Fraction &a, const Fraction &b)
{
int new_up = a.get_up() * b.get_down() + a.get_down() * b.get_up();
int new_down = a.get_down() * b.get_down();
int c=gcd(new_up,new_down);
return Fraction(new_up/c, new_down/c);
}
Fraction sub(const Fraction &a, const Fraction &b)
{
int new_up = a.get_up() * b.get_down() - a.get_down() * b.get_up();
int new_down = a.get_down() * b.get_down();
int c=gcd(new_up,new_down);
return Fraction(new_up/c, new_down/c);
}
Fraction mul(const Fraction &a, const Fraction &b)
{
int new_up = a.get_up() * b.get_up();
int new_down = a.get_down() * b.get_down();
int c=gcd(new_up,new_down);
return Fraction(new_up/c, new_down/c);
}
Fraction div(const Fraction &a, const Fraction &b)
{
if (b.get_up() == 0)
{
return Fraction(1, 0);
}
int new_up = a.get_up() * b.get_down();
int new_down = a.get_down() * b.get_up();
int c=gcd(new_up,new_down);
return Fraction(new_up/c, new_down/c);
}
task4.cpp
#include "Fraction.h"
#include <iostream>
void test1();
void test2();
int main() {
std::cout << "测试1: Fraction类基础功能测试\n";
test1();
std::cout << "\n测试2: 分母为0测试: \n";
test2();
}
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;
}
Q
自由函数+类
自由函数方案的优点：
1、良好的封装性
所有自由函数都通过Fraction类的公有接口（get_up(), get_down()）访问数据
不需要破坏类的封装，符合面向对象设计原则
2、对称性处理
对于二元运算如add(a, b)，两个参数地位平等，语法对称
避免了成员函数方案中a.add(b)的不对称感
3、扩展性强
新增运算函数不需要修改Fraction类定义
可以改进加入命名空间
避免全局命名空间污染
更清晰地表达函数与Fraction类的关系
提高代码的可读性和可维护性
浙公网安备 33010602011771号