实验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

#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;
}

运行结果：

问题1：T.h中，在类T内部，已声明func是T的友元函数。在类外部，去掉line36，重新编译，程序能否正常运行。

如果能，回答YES；如果不能，以截图形式提供编译报错信息，说明原因。

答：YES

问题2：T.h中，line9-12给出了各种构造函数、析构函数。总结它们各自的功能、调用时机。

答：T(int x = 0, int y = 0)是有默认参数值的成员函数，能够给对象传递参数或提供初始值，当创建有两个整型参数或没有参数的T类对象时调用；T(const T &t)能够复制一个T类型的参数，利用其进行操作；T(T &&t)能够临时创建一个新的T类对象，可以提高操作效率，初始化时可调用；~T()是析构函数，能够释放内存，T类对象结束时调用。它们都能在调用时给count++，反映当前objects个数。

问题3：T.cpp中，line13-15，剪切到T.h的末尾，重新编译，程序能否正确编译。如不能，以截图形式给出报错信息，分析原因。

答：不能。

原因：需要在类外声明。

任务2

complex.h

#pragma once
#include <iostream>
#include <iomanip>
#include <complex>
#include <string>
class Complex{
public:
    Complex();    
    Complex(double a);
    Complex(double a,double b);
    Complex(const Complex &i);
private:
    double real=0,imag=0;
public:
    static const std::string doc;
    double get_real()const;
    double get_imag()const;
    void add(Complex &i);
    friend void output(Complex &i);
    friend double abs(Complex &i);
    friend Complex add(Complex &i1,Complex &i2);
    friend bool is_equal(Complex &i1,Complex &i2);
    friend bool is_not_equal(Complex &i1,Complex &i2);
};
void output(Complex &i);
double abs(Complex &i);
Complex add(Complex &i1,Complex &i2);
bool is_equal(Complex &i1,Complex &i2);
bool is_not_equal(Complex &i1,Complex &i2);

Complex.cpp

#include"Complex.h"
#include <iostream>
#include <iomanip>
#include <complex>
#include <string>
const std::string Complex::doc{"a simplified complex class"};
double Complex::get_real()const{
    return real;
}
double Complex::get_imag()const{
    return imag;
}
void Complex::add(Complex &i){
    real+=i.real;
    imag+=i.imag;
}
Complex::Complex(){};
Complex::Complex(double a){
    real=a;
}
Complex::Complex(double a,double b){
    real=a,imag=b;
}
Complex::Complex(const Complex &i){
    real=i.real,imag=i.imag;
}
void output(Complex &i){
    if(i.imag>=0){
        std::cout<<i.real<<"+"<<i.imag<<"i"<<std::endl;
    }
    else{
        std::cout<<i.real<<i.imag<<"i"<<std::endl;
    }
}
double abs(Complex &i){
    return sqrt(i.real*i.real+i.imag*i.imag);
}
Complex add(Complex &i1,Complex &i2){
    Complex i;
    i.real=i1.real+i2.real;
    i.imag=i1.imag+i2.imag;
    return i;
}
bool is_equal(Complex &i1,Complex &i2){
    if(i1.get_real()==i2.get_real()&&i1.get_imag()==i2.get_imag()){
        return true;
    }
    else{
        return false;
    }
}
bool is_not_equal(Complex &i1,Complex &i2){
    if(i1.get_real()==i2.get_real()&&i1.get_imag()==i2.get_imag()){
        return false;
    }
    else{
        return true;
    }
}

task2.cpp

// 待补足头文件
// xxx
#include"Complex.h"
#include <iostream>
#include <iomanip>
#include <complex>
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();
}
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;
}

运行结果：

问题1：比较自定义类Complex和标准库模板类complex的用法，在使用形式上，哪一种更简洁？函数和运算内在有关联吗？

答：标准库模板类更简洁。有关联，二者底层逻辑相似。

问题2：

2-1：自定义Complex中, output/abs/add/ 等均设为友元，它们真的需要访问 私有数据 吗？（回答“是/否”并给出理由）

答：是，因为他们都需要实部和虚部来进行操作，须设友元才能访问。

2-2：标准库 std::complex 是否把 abs 设为友元？（查阅 cppreference后回答）

答：否。标准库的abs是普通函数，他通过类的公有接口来计算模长，不需访问私有数据，所以不用设为友元。

2-3：什么时候才考虑使用 friend？总结你的思考。

答：需要直接访问类的私有数据。

问题3：如果构造对象时禁用=形式，即遇到Complex c4 = c2;编译报错，类Complex的设计应如何调整？

答：在类中显式定义拷贝构造函数（ Complex(const Complex &other) ），并确保其访问权限为 public ，在函数体内正确复制实部和虚部的值（如 real = other.real; imag = other.imag; ）。这样就能支持对象的拷贝初始化形式。

任务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);      // 实现std::string --> ControlType转换
     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
ControlType PlayerControl::parse(const std::string& control_str) {
     std::string s;
     for(auto c:control_str){
         s+=tolower(c);
     } 
    total_cnt++;
    if (s == "play") return ControlType::Play;
    else if (s == "pause") return ControlType::Pause;
    else if (s == "next") return ControlType::Next;
    else if (s == "prev") return ControlType::Prev;
    else if (s == "stop") 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();
}

运行结果：

任务4

Fraction.h

#pragma once
#include <iostream>
#include<string>
class Fraction{
public:
    Fraction(int a);
    Fraction(int a,int b);
    Fraction(const Fraction &t);
private:
    int up,down=1;
public:
    static const std::string doc;
    int get_up()const;
    int get_down()const;
    Fraction negative();
public:
    friend void output(const Fraction &t);
    friend Fraction add(const Fraction &t1,const Fraction &t2);
    friend Fraction sub(const Fraction &t1,const Fraction &t2);
    friend Fraction mul(const Fraction &t1,const Fraction &t2);
    friend Fraction div(const Fraction &t1,const Fraction &t2);
}; 
void output(const Fraction &t);
Fraction add(const Fraction &t1,const Fraction &t2);
Fraction sub(const Fraction &t1,const Fraction &t2);
Fraction mul(const Fraction &t1,const Fraction &t2);
Fraction div(const Fraction &t1,const Fraction &t2);

Fraction.cpp

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

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;
}

运行结果：