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

1. 实验任务1

验证性实验：简单类T的定义和测试。实践、阅读代码，回答问题。

这个简单任务覆盖以下内容：

　　类的定义（封装）

　　类的使用：对象的创建、访问

　　数据共享机制

　　　　在同一个对象的所有操作之间共享数据 —— 实现机制：封装

　　　　在同一个类的所有对象之间共享数据 —— 实现机制：类的static成员

　　　　在不同模块（类、函数）之间共享数据 —— 实现机制：友元

　　数据保护机制

　　　　const对象

　　　　const引用作为形参

　　　　const成员数据/函数

　　代码组织方式：多文件结构

　　代码组织方式：

　　　　t.h 内容：类T的声明、友元函数声明

　　　　t.cpp 内容：类T的实现、友元函数实现

　　　　task1.cpp 内容：测试模块、main函数

　　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

// 类T: 实现
// 普通函数实现

#include "t.h"
#include <iostream>
#include <string>

using std::cout;
using std::endl;
using std::string;

// static成员数据类外初始化
const std::string T::doc{"a simple class sample"};
const int T::max_cnt = 999;
int T::cnt = 0;


// 对象方法
T::T(int x, int y): m1{x}, m2{y} { 
    ++cnt; 
    cout << "T constructor called.\n";
} 

T::T(const T &t): m1{t.m1}, m2{t.m2} {
    ++cnt;
    cout << "T copy constructor called.\n";
}

T::T(T &&t): m1{t.m1}, m2{t.m2} {
    ++cnt;
    cout << "T move constructor called.\n";
}    

T::~T() {
    --cnt;
    cout << "T destructor called.\n";
}           

void T::adjust(int ratio) {
    m1 *= ratio;
    m2 *= ratio;
}    

void T::display() const {
    cout << "(" << m1 << ", " << m2 << ")" ;
}     

// 类方法
int T::get_cnt() {
   return cnt;
}

// 友元
void func() {
    T t5(42);
    t5.m2 = 2049;
    cout << "t5 = "; t5.display(); cout << endl;
}

　　task1.cpp

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

using std::cout;
using std::endl;

void test();

int main() {
    test();
    cout << "\nmain: \n";
    cout << "T objects'current count: " << T::get_cnt() << endl;
}

void test() {
    cout << "test class T: \n";
    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 << "t3 = "; t4.display(); cout << endl;

    cout << "T objects'current count: " << T::get_cnt() << endl;

    func();
}

　　运行结果截图

　　阅读代码，结合运行结果，理解使用C++封装类涉及的关联知识点。

　　 问题1： t.h中，普通函数 func 作为类X的友元，在类的内部声明了友元关系。在类外部，去掉line36，重 新编译，是否能正确运行。如果能，回答说明可以去掉line36。如果不能，以截图形式给出编译报 错信息，分析可能的原因。　

　　　　答：不能。

　　　　全部重新编译后，编译器报错显示没有找到“func”，这可能与友元函数的函数表示有关。

 

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

 　　　　答：普通构造函数：用于创建对象并通过其接收到的参数初始化对象的成员变量。

 　　　　　　复制构造函数：用于创建对象，并通过另一个对象参数来初始化成员变量。

　　　　　　移动构造函数：用一个临时对象来初始化另一个同类型的新对象。相比于复制构造函数复制资源的方式，移动构造函数直接将临时对象的资源占有权转移给新对象，临时对象会进入一个可以被安全析构的状态。

　　　　　　析构函数的调用时机：1、对于栈上的对象，当对象的作用域结束时（函数返回、代码块结束），其析构函数会被自动调用。

　　　　　　　　　　　　　　　　2、对于堆上通过new创建的对象，需要手动用delete来销毁对象，否则会造成内存泄漏。

 

　　 问题3： t.cpp中，line13-15，调整到t.h，重新编译，程序能否正确编译运行。

 　　　　不能。

 

2. 实验任务2

不使用C++标准库提供的复数模板类，设计并实现一个简化版的复数类Complex。要求如下：

　　类属性

　　　　用于对自定义复数类Complex做描述说明的doc，用 string 类型，常量，公有

　　　　描述信息为: a simplified complex class

　　对象属性

　　　　用于表示复数的实部real和虚部imag, 均为小数形式，私有

　　对象方法

　　　　构造函数

　　　　　　要求支持以下方式构造复数对象

　　　　接口

　　　　　　get_real() 返回复数实部

　　　　　　get_imag() 返回复数虚部

　　　　　　add() 用于把一个复数加到自身，如 c1.add(c2) , 相当于 c1 += c2

　　　　友元函数 a

　　　　　　dd() 用于实现两个复数相加，返回复数。比如 c3 = add(c1, c2)

　　　　　　is_equal() 用于判断两个复数是否相等，相等返回 true , 否则，返回 false

　　　　　　is_not_equal() 用于判断两个复数是否相等，不相等返回 true , 否则，返回 false

　　　　　　output() 用于输出一个复数，以a+bi的形式。比如3 + 4i

　　　　　　abs() 用于对复数进行取模运算。比如， Complex c(3, 4); 对其取模运算后 abs(c) 结果为 5.0

　　　　代码要求

　　　　要求采用多文件方式组织代码。

　　　　　   Complex.h

　　　　　　　　类Complex声明、友元函数声明

　　　　　　Complex.cpp

　　　　　　　　类Complex实现、友元函数实现

　　　　　　task2.cpp

　　　　　　　　测试代码、main()函数 （测试代码已经在task2.cpp给出）

　　　　类设计及编码风格要求

　　　　　　设计并实现类时，合理利用数据的共享和保护机制，尽可能在数据共享和保护之间达到平衡

　　　　　　关注编码风格，可读性、易维护性

　　根据描述和测试代码，设计的Complex UML类图如下。

 　　Complex.h

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

using namespace std;

class Complex
{
public:

    //类的属性
    static const string doc;

    //构造函数声明
    Complex();
    Complex(double r, double i = 0);
    Complex(const Complex& other);

    //外部接口
    double get_real()const;
    double get_imag()const;
    void add(const Complex& other);

    //友元函数声明
    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);
    friend void output(const Complex& c);
    friend double abs(const Complex& c);

private:
    double real;
    double imag;
};

　　Complex.cpp

//用于对Complex类的实现

#include"Complex.h"
//类的属性实现
const string Complex::doc{ "a simplified Complex class" };

//类的构造函数的实现
Complex::Complex() :real{ 0 }, imag{ 0 } {};
Complex::Complex(double r, double i ) :real{ r }, imag{i} {};
Complex::Complex(const Complex& other) :real(other.get_real()), imag(other.get_imag()) {};

//外部接口实现
double Complex::get_real() const{ return real; }
double Complex::get_imag() const{ return imag; }
void Complex::add(const Complex& other) { real += other.get_real(), imag = other.get_imag(); }

//友元函数实现
Complex add(const Complex& c1, const Complex& c2)
{
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

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

bool is_not_equal(const Complex& c1, const Complex& c2)
{
    return (c1.real != c2.real) || (c1.imag!=c2.imag);
}

void output(const Complex& c)
{
    cout << c.real;
    if (c.imag >= 0) { cout << '+'; }
    cout << c.imag << "i";
}

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

　　main.cpp

#include"Complex.h"
void test() {
    cout << "类成员测试: " << endl;
    cout << Complex::doc << endl;

    cout << endl;

    cout << "Complex对象测试: " << endl;
    Complex c1;
    Complex c2(3, -4);
    const Complex c3(3.5);
    Complex c4(c3);

    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 << "c4.real = " << c4.get_real() << ", c4.imag = " << c4.get_imag() << endl;

    cout << 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 != c3 : " << is_not_equal(c1, c3) << endl;
    c4 = add(c2, c3);
    cout << "c4 = c2 + c3, c4 = "; output(c4); cout << endl;
}

int main() {
    test();
}

 

 

 3. 实验任务3

验证性实验。使用标准库模板类complex实现复数运算。

complex 是C++标准库中提供的复数模板类，提供了关于复数类型的丰富计算接口。

complex模板类的丰富用法可参考：https://en.cppreference.com/w/cpp/numeric/complex  

在C++编码环境中，输入以下代码。

　　task3.cpp 

#include <iostream>
#include <complex>

using std::cout;
using std::endl;
using std::boolalpha;
using std::complex;

void test() {
    cout << "标准库模板类comple测试: " << endl;
    complex<double> c1;
    complex<double> c2(3, -4);
    const complex<double> c3(3.5);
    complex<double> c4(c3);

    cout << "c1 = " << c1 << endl;
    cout << "c2 = " << c2 << endl;
    cout << "c3 = " << c3 << endl;
    cout << "c4 = " << c4 << endl;
    cout << "c4.real = " << c4.real() << ", c4.imag = " << c4.imag() << endl;
    cout << 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 != c3 : " << (c1 != c3) << endl;
    c4 = c2 + c3;
    cout << "c4 = c2 + c3, c4 = " << c4 << endl;
}

int main() {
    test();
}

 阅读代码，结合运行结果，分析代码中使用了标准库complex模板类提供的哪些接口。

接口：1.通过real（）和image（）函数获取对象real和imag。

　　　2.通过abs(const complex& other)函数求模。

　　　3.直接通过算式的+-运算进行复数的+-运算并且可以直接通过==与！=判断两个复数是否相等。

 

 

对比任务2： 

1. 观察使用标准库模板类进行复数运算与输出时，代码比任务2的测试代码，哪些地方代码写法 不同/代码更简洁

　　1、输出不同，模板类是（real，imag）输出，手写类是real+/-imagi输出。

　　2、不同对象间的加减运算不同，模板类可直接对对象进行加减，手写类需要用外部接口或友元函数进行加减运算。

　　3、两个对象是否相等的判断不同。

 

 

2. 思考标准库模板类Complex的设计，与任务2对比，你是否有所启发 

　　1、complex类重载了多种运算符如+-*/，使得复数运算看起来像普通基础数据运算看起来一样自然。

　　2、模板类可以通过<type>使得程序员自定义实部虚部的类型，更加方便。

 

4. 实验任务4

设计并实现一个分数类Fraction. 要求如下：

　　类属性

　　　　对分数类Fraction做描述说明的doc，用 string 类型，常量，公有

　　　　描述信息为: Fraction类 v 0.01版. 目前仅支持分数对象的构造、输出、加/减/乘/除运算.

　　对象属性

　　　　用于表示分数的分子up和分母down, 均为整数形式，私有

　　对象接口

　　对象方法

　　　　构造函数

　　　　　　要求支持以下方式构造分数对象

 

 

　　　　接口

　　　　　　get_up() 返回分子

　　　　　　get_down() 返回分母

　　　　　　negative() 用于求负，支持 Fraction f2 = f1.negative(); 这样的操作，形如的 f2 = -f1

　　　　　　求负运算，分数对象f1本身不变，返回值是求负后的分数对象

　　友元函数

　　　　output() 用于输出一个分数，以形如2/3或-2/3这样的形式 （输出化简后的形式，比如-4/10，输出时化简后的-2/5）

　　　　add() 用于实现两个分数相加，返回分数。比如 f3 = add(f1, f2)

　　　　sub() 用于实现两个分数相减，返回分数。比如 f3 = sub(f1, f2)

　　　　mul() 用于实现两个分数相乘，返回分数。比如 f3 = mul(f1, f2)

　　　　div() 用于实现两个分数相除法，返回分数。比如 f3 = div(f1, f2)

　　代码要求

　　　　要求采用多文件方式组织代码。

　　　　　　Fraction.h 类Fraction声明、友元函数声明

　　　　　　Fraction.cpp 类Fraction实现、友元函数实现

　　　　　　task4.cpp 测试代码、main()函数 （测试代码已经在task4.cpp给出）

　　类设计及编码风格要求

　　设计并实现类时，可以设计必要的内部工具函数辅助分数计算；合理利用数据的共享和保护机 制

　　关注编码风格，可读性、易维护性 

 Fraction.h

#pragma once
#include<iostream>
#include<string>
#include<cstdlib>

using namespace std;

class Fraction
{
public:
    //类的属性
    static const string doc;

    //构造函数
    Fraction(int _up = 0,int _dowm = 1);
    Fraction(const Fraction& other);

    //外部接口
    int get_up() const;
    int get_down() const;
    Fraction negative();

    //友元函数
    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:
    //内部私有函数
    static int fac(int a,int b);
    void adjust();

private:
    int up;
    int down;

};

Fraction.cpp

//Fraction类的实现

#include"Fraction.h"

//类的属性
const string Fraction::doc{ "Fraction类 v 0.01版. \n目前仅支持分数对象的构造、输出、加 / 减 / 乘 / 除运算.\n" };

//构造函数
Fraction::Fraction(int _up, int _down) :up{ _up }, down{ _down } { Fraction::adjust(); };
Fraction::Fraction(const Fraction& other) :up{ other.get_up() }, down{ other.get_down() } { };

//外部接口
int Fraction::get_up()const { return up; }
int Fraction::get_down()const { return down; }
Fraction Fraction::negative() { return Fraction(-up, down); }

//内部私有函数
int Fraction::fac(int a,int b)
{
    if (!b) { return a; }
    return fac(b, a % b);
}
void Fraction::adjust() 
{
    int factor = fac(abs(up), abs(down));
    if (up * down > 0) { up = abs(up)/factor; down = abs(down)/factor; }
    else if (up * down < 0) { up = -abs(up)/factor; down = abs(down)/factor; }
}

//友元函数
void output(const Fraction& f)
{
    Fraction pf{f};
    if (pf.down == 0) { cout << "分母不能为0"; }
    else
    {
        pf.adjust();
        if (pf.down == 1) { cout << pf.up; }
        else if (pf.up == 0) { cout << pf.up; }
        else { cout << pf.up << "/" << pf.down; }
    }
}
Fraction add(const Fraction& f1, const Fraction& f2)
{
    Fraction pf1{ f1 }, pf2{ f2 };
    int factor = Fraction::fac(pf1.down, pf2.down);
    int lcm = (pf1.down * pf2.down / factor);
    pf1.up *= (lcm / pf1.down);
    pf2.up *= (lcm / pf2.down);
    return Fraction(pf1.up + pf2.up, lcm);
}
Fraction sub(const Fraction& f1, const Fraction& f2)
{
    Fraction pf1{ f1 }, pf2{ f2 };
    int factor = Fraction::fac(pf1.down, pf2.down);
    int lcm = (pf1.down * pf2.down / factor);
    pf1.up *= (lcm / pf1.down);
    pf2.up *= (lcm / pf2.down);
    return Fraction(pf1.up - pf2.up, lcm);
}
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, f2.up * f1.down);
}

main.cpp

#include"Fraction.h"

void test1() {
    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;

    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() {
    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;
}

int main() {
    cout << "测试1: Fraction类基础功能测试\n";
    test1();

    cout << "\n测试2: 分母为0测试: \n";
    test2();
}

运行结果截图：

 

5. 实验任务5

　　在C++编码环境中录入教材第5章5.7节例5-11源码（个人银行账户管理程序），编译、运行、测试程序。 结合第4-5章所学内容，理解代码，体会用面向对象思维思考、设计业务场景问题，理解面向对象的封装 特性、数据的共享、保护。

　　说明*：

　　　　个人银行账户管理程序是教材提供的一个面向对象设计与编程的综合实例。第4章4.8节是最初版本 的设计与实现。其后，是逐步迭代改进的版本。建议你从第4章的版本开始，关注在银行业务场景 下，类的抽象与设计，以及，其后每章的迭代改进。系统、连贯地阅读和分析这个实例代码，会更 有助于你理解和体会面向对象设计与编程。 

　　　　结合当下你使用银行业务（线下/银行app）的经历，分析教材上这个教学型实例目前的问题，思 考，如果由你来重构这个程序，你会如何抽象、设计。 

account.h

#pragma once
//储蓄账户类
class SavingAccount
{
private:
    int id;                 //账号
    double balance;         //余额
    double rate;            //存款年利率
    int lastDate;           //上次变更余额时期
    double accumulation;    //余额按日累加和
    static double total;    //所有账户总金额
    void record(int date, double amount);
    double accumulate(int date)const
    {
        return accumulation + balance * (date - lastDate);
    }
public:
    SavingAccount(int date, int id, double rate);
    int getId()const { return id; }
    double getBalance()const { return balance; }
    double getRate()const { return rate; }
    static double getTotal() { return total; }
    void deposit(int date, double amount);
    void withdraw(int date, double amount);
    void settle(int date);
    void show()const;
};

 

account.cpp

#include"account.h"
#include<cmath>
#include<iostream>
using namespace std;
double SavingAccount::total = 0;
SavingAccount::SavingAccount(int date, int id, double rate)
    :id(id),balance(0),rate(rate),lastDate(lastDate),accumulation(0)
{
    cout << date << "\t#" << id << "is created" << endl;
}
void SavingAccount::record(int date, double amount)
{
    accumulation = accumulate(date);
    lastDate = date;
    amount = floor(amount * 100 + 0.5) / 100;
    balance += amount;
    total += amount;
    cout << date << "\t#" << id << "\t" << amount << "\t" << balance << endl;
}
void SavingAccount::deposit(int date, double amount)
{
    record(date, amount);
}
void SavingAccount::withdraw(int date, double amount)
{
    if (amount > getBalance()) { cout << "Error: not enough money" << endl; }
    else
    {
        record(date, -amount);
    }
}
void SavingAccount::settle(int date)
{
    double interest = accumulate(date) * rate / 365;
    if (interest != 0)
    {
        record(date, interest);
    }
    accumulation = 0;
}
void SavingAccount::show()const
{
    cout << "#" << id << "\tBalance:" << balance;
}

 

main.cpp

#include"account.h"
#include<iostream>
using namespace std;
int main()
{
    SavingAccount sa0(1, 21325302, 0.015);
    SavingAccount sa1(1, 58320212, 0.015);
    sa0.deposit(5, 5000);
    sa1.deposit(25, 10000);
    sa0.deposit(45, 5500);
    sa1.withdraw(60, 4000);
    sa0.settle(90);
    sa1.settle(90);
    sa0.show();
    sa1.show();
    cout << "Total: " << SavingAccount::getTotal() << endl;
}

运行结果截图：

 

 1、日期处理上可以用专门的日期时间库，使日期处理更规范。

2、在record函数中对金额进行了四舍五入的处理，但不够灵活且小数点后的位数过少。