实验2 现代C++编程初体验

实验任务1

源码

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

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);     // 按比例调整
    void display() const;       // 输出对象信息

private:
    int m1, m2;

public:
    static int get_cnt();       // 获取对象总数
    static const std::string doc;
    static const int max_cnt;

private:
    static int cnt;

    friend void func();         // 友元函数
};

void func();

task.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；如果不能，以截图形式提供编译报错信息，说明原因。

答：去掉友元声明后，编译错误。func()无法访问类的私有成员m2.

 

问题2：

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

答：

构造函数与析构函数的作用与调用时机：

普通构造：创建对象时；

拷贝构造：以对象初始化对象；

移动构造：右值或临时对象转移；

析构：生命周期结束时。

问题3：

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

答：静态成员初始化语句应位于.cpp文件中第8–10行（非13–15）。

若放入.h文件会造成重复定义错误。

 

实验任务2

源码：

 Complex.h

#pragma once
#include <string>
#include <cmath>

class Complex {
public:
    Complex(double r = 0.0, double i = 0.0);
    Complex(const Complex &c);

    double get_real() const;
    double get_imag() const;
    void add(const Complex &c);

    static const std::string doc;

private:
    double real, imag;
    friend void output(const Complex &c);
    friend double abs(const Complex &c);
    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);
};

Complex.cpp

#include "Complex.h"
#include <iostream>

const std::string Complex::doc = "a simplified complex class";

Complex::Complex(double r, double i): real{r}, imag{i} {}
Complex::Complex(const Complex &c): real{c.real}, imag{c.imag} {}

double Complex::get_real() const { return real; }
double Complex::get_imag() const { return imag; }

void Complex::add(const Complex &c) {
    real += c.real;
    imag += c.imag;
}

void output(const Complex &c) {
    std::cout << c.real << (c.imag >= 0 ? " + " : " - ")
              << std::abs(c.imag) << "i";
}

double abs(const Complex &c) {
    return std::sqrt(c.real * c.real + c.imag * c.imag);
}

Complex add(const Complex &a, const Complex &b) {
    return Complex(a.real + b.real, a.imag + b.imag);
}

bool is_equal(const Complex &a, const Complex &b) {
    return a.real == b.real && a.imag == b.imag;
}

bool is_not_equal(const Complex &a, const Complex &b) {
    return !(is_equal(a, b));
}

 

运行测试结果截图：

 

 

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

答：标准库的std::complex更简洁，因为它使用了运算符重载，而自定义类通过函数实现。

 

 

问题2：
2-1：自定义complex中 的用法，output/abs/add/ 等均设为友元，它们真的需要访问私有数据吗？

答：output/add等函数确实需要访问私有数据，因此设置为friend。

2-2：标准库std::complex 是否把 abs 设为友元？

答：标准库abs不是友元，而是独立函数。
2-3：什么时候才考虑使用 friend？总结你的思考。

答：只有当外部函数确实需要访问私有数据时，才使用friend，避免破坏封装性。

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

答：将 Complex 类的拷贝构造函数声明为 explicit。

实验任务3

源码：

 

#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.parase(control_str);
        controller.execute(cmd);
        std::cout<<"Current Player control: "<<PlayerControl::get_cnt()<<"\n\n";
}
}
int main()
{
    test();
}

 

运行测试结果截图：

 

 

实验任务4

源码：

 

#pragma once
#include <string>

class Fraction {
public:
    Fraction(int up = 0, int down = 1);
    Fraction(const Fraction& f);

    int get_up() const;
    int get_down() const;
    Fraction negative() const;

    static const std::string doc;

private:
    int up, down;
    void simplify();

    friend void output(const Fraction& f);
    friend Fraction add(const Fraction& a, const Fraction& b);
    friend Fraction sub(const Fraction& a, const Fraction& b);
    friend Fraction mul(const Fraction& a, const Fraction& b);
    friend Fraction div(const Fraction& a, const Fraction& b);
};

#include "Fraction.h"
#include <iostream>
#include <numeric>
#include <stdexcept>

const std::string Fraction::doc = "Fraction类 v0.01版";

Fraction::Fraction(int u, int d): up{u}, down{d} {
    if (down == 0) throw std::invalid_argument("Denominator cannot be zero");
    simplify();
}

Fraction::Fraction(const Fraction& f): up{f.up}, down{f.down} {}

void Fraction::simplify() {
    if (down < 0) { down = -down; up = -up; }
    int g = std::gcd(up, down);
    if (g != 0) { up /= g; down /= g; }
}

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& a, const Fraction& b) {
    return Fraction(a.up * b.down + b.up * a.down, a.down * b.down);
}

Fraction sub(const Fraction& a, const Fraction& b) {
    return Fraction(a.up * b.down - b.up * a.down, a.down * b.down);
}

Fraction mul(const Fraction& a, const Fraction& b) {
    return Fraction(a.up * b.up, a.down * b.down);
}

Fraction div(const Fraction& a, const Fraction& b) {
    if (b.up == 0) throw std::invalid_argument("Division by zero");
    return Fraction(a.up * b.down, a.down * b.up);
}

 

运行测试结果截图：

 

 

问题：分数的输出和计算，output/add/sub/mul/div ，你选择的是哪一种设计方案？（友元/自由函数/命名空间+自由函数/类+static)
你的决策理由？如友元方案的优缺点、静态成员函数方案的适用场景、命名空间方案的考虑因素等。

答：采用友元函数方案实现 output/add/sub/mul/div。

理由：它们需要访问分子分母的私有成员，友元方式简洁直观。

若仅作读操作，亦可使用命名空间自由函数，但友元更贴合此场景。