实验2 类和对象_基础编程2

实验一：

类的定义文件 t.h

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

using namespace std;

// 类T的声明

class T {

public:
    T(int x = 0, int y = 0);             // 带有默认形值的构造函数

    T(const T& t);                         // 复制构造函数

    T(T&& t);                            // 移动构造函数

    ~T();                                // 析构函数

    void set_m1(int x);                    // 设置T类对象的数据成员m1

    int get_m1() const;                    // 获取T类对象的数据成员m1

    int get_m2() const;                    // 获取T类对象的数据成员m2

    void display() const;                    // 显示T类对象的信息

    friend void func();                        // 声明func()为T类友元函数

private:
    int m1, m2;

public:
    static void disply_count();                    // 类方法，显示当前T类对象数目

public:
    static const string doc;                    // 类属性，用于描述T类

    static const int max_count;                    // 类属性，用于描述T类对象的上限

private:
    static int count;                            // 类属性，用于描述当前T类对象数目
};
void func();                                    // 普通函数声明

类的实现文件t.cpp

 #define _CRT_SECURE_NO_WARNINGS 1
// 类的static数据成员：类外初始化
#include "t.h"

const string T::doc{ "a simple class" };

const int T::max_count = 99;

int T::count = 0;

// 类T的实现

T::T(int x, int y) : m1{ x }, m2{ y } {
    ++count;
    cout << "constructor called.\n";
}

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

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

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

void T::set_m1(int x) {
    m1 = x;
}

int T::get_m1() const {
    return m1;
}

int T::get_m2() const {
    return m2;
}

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

// 类方法

void T::disply_count() {
    cout << "T objects: " << count << endl;
}
// 函数func()：实现

void func() {
    T t1;
    t1.set_m1(55);
    t1.m2 = 77;                        // 虽然m2是私有成员，依然可以直接访问

    t1.display();
}

主函数main 

#include "t.h"

// 测试

void test() {
    cout << "T class info: " << T::doc << endl;
    cout << "T objects max_count: " << T::max_count << endl;
    T::disply_count();
    T t1;
    t1.display();
    t1.set_m1(42);
    T t2{ t1 };
    t2.display();
    T t3{ std::move(t1) };
    t3.display();
    t1.display();
    T::disply_count();
}

// 主函数

int main() {
    cout << "============测试类T============" << endl;
    test();
    cout << endl;
    cout << "============测试友元函数func()============" << endl;
    func();
}

 方式二：

类的声明和实现t.hpp：

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

using namespace std;

// 类T的声明

class T {

public:
    T(int x = 0, int y = 0); // 带有默认形值的构造函数

    T(const T& t); // 复制构造函数

    T(T&& t);// 移动构造函数

    ~T(); // 析构函数

    void set_m1(int x); // 设置T类对象的数据成员m1

    int get_m1() const; // 获取T类对象的数据成员m1

    int get_m2() const; // 获取T类对象的数据成员m2

    void display() const; // 显示T类对象的信息

    friend void func(); // 声明func()为T类友元函数

private:
    int m1, m2;

public:
    static void disply_count();// 类方法，显示当前T类对象数目
public:
    static const string doc; // 类属性，用于描述T类

    static const int max_count;// 类属性，用于描述T类对象的上限

private:
    static int count;// 类属性，用于描述当前T类对象数目

};

// 类的static数据成员：类外初始化

const string T::doc{ "a simple class" };

const int T::max_count = 99;

int T::count = 0;

// 类T的实现

T::T(int x, int y) : m1{ x }, m2{ y } {
    ++count;
    cout << "constructor called.\n";
}

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

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

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

void T::set_m1(int x) {
    m1 = x;
}

int T::get_m1() const {
    return m1;
}

int T::get_m2() const {
    return m2;
}

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

// 类方法

void T::disply_count() {
    cout << "T objects: " << count << endl;
}
// 函数func()：实现

void func() {
    T t1;
    t1.set_m1(55);
    t1.m2 = 77; // 虽然m2是私有成员，依然可以直接访问

    t1.display();
}

主函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include"t.hpp"
// 测试

void test() {
    cout << "T class info: " << T::doc << endl;
    cout << "T objects max_count: " << T::max_count << endl;
    T::disply_count();
    T t1;
    t1.display();
    t1.set_m1(42);
    T t2{ t1 };
    t2.display();
    T t3{ std::move(t1) };
    t3.display();
    t1.display();
    T::disply_count();
}

// 主函数

int main() {
    cout << "============测试类T============" << endl;
    test();
    cout << endl;
    cout << "============测试友元函数func()============" << endl;
    func();
}

 实验二：

声明和实现

#pragma once

// Employee类的定义

#include <iostream>
#include <string>
#include <iomanip>

using std::string;

using std::cout;

using std::endl;

using std::setfill;

using std::setw;

using std::left;

using std::right;

using std::to_string;

struct Date {
    int year;
    int month;
    int day;
};

// Employee类的声明

class Employee

{

public:
    Employee();
    Employee(string name0, double salary0, int y, int m, int d = 1);
    void set_info(string name0, double salary0, int y, int m, int d = 1); 

// 设置雇员信息

    string get_name() const;      // 获取雇员姓名

    double get_salary() const;    // 获取雇员薪水

    void display_info() const;    // 显示雇员信息

    void update_salary(double s);  // 更新雇员薪水

    void update_hire_date(int y, int m, int d); // 更新雇佣日期

    void raise_salary(double by_percent);  // 计算提薪加成

public:
    static void display_count();    // 类方法，显示雇员总数

private:
    string id;     // 雇员工号

    string name;   // 雇员姓名

    double salary; // 雇员薪水

    Date hire_date;  // 雇员雇佣日期

public:
    static const string doc;  // 类属性，用于描述类

private:
    static int count;   // 类属性，用于记录雇员总人数

};

const string Employee::doc {"a simple Employee class"};

int Employee::count = 0;

// 默认构造函数

Employee::Employee(): id{ to_string(count+1) } {
    ++count;
}

// 带参数的构造函数

Employee::Employee(string name0, double salary0, int y, int m, int d): 
          id{to_string(count+1)}, name{name0}, salary{salary0}, 

hire_date{y, m, d} {
    ++count;
}

// 设置员工信息

void Employee::set_info(string name0, double salary0, int y, int m, int d) 
{
name = name0;
    salary = salary0;
    hire_date.year = y;
    hire_date.month = m;
    hire_date.day = d;
}

// 获取员工姓名

string Employee::get_name() const {
    return name;
}

// 获取员工薪水

double Employee::get_salary() const {
    return salary;
}

// 显示雇员信息

void Employee::display_info() const {
    cout << left << setw(15) << "id: " << id << endl;
    cout << setw(15) << "name: " << name << endl;
    cout << setw(15) << "salary: " << salary << endl;
    cout << setw(15) << "hire_date: " << hire_date.year << "-";
    cout << std::right << setfill('0') << setw(2) << hire_date.month << "-" 
 << setw(2) << hire_date.day;
    
    cout << setfill(' ');  // 恢复到默认空格填充

}

// 更新薪水

void Employee::update_salary(double s) {
    salary = s;
}

// 更新雇佣日期

void Employee::update_hire_date(int y, int m, int d) {
    hire_date.year = y;
    hire_date.month = m;
    hire_date.day = d;
}

// 雇员提薪加成

// by_percent是提升比例

void Employee::raise_salary(double by_percent) {
    double raise = salary * by_percent / 100;
    salary += raise;
}

// 类方法

// 显示雇员总数

void Employee::display_count() {
    cout << "there are " << count << " employees\n";
}

主函数：

#include "Employee.hpp"
#include <iostream>

// 测试：Employee类

void test() {
    using std::cout;
    using std::endl;
    cout << Employee::doc << endl << endl;
    Employee employee1;
    employee1.set_info("Sam", 30000, 2015, 1, 6);
    employee1.update_hire_date(2019, 6, 30);
    employee1.update_salary(35000);
    employee1.display_info();
    cout << endl << endl;
    Employee employee2{"Tony", 20000, 2023, 3, 16};
    employee2.raise_salary(15); // 提成15%

    employee2.display_info();
    cout << endl << endl;
    Employee::display_count();
}

int main() {
    test();
}

运行结果：

 实验三：

选用hpp,cpp方式

类的声明与实现hpp：

#pragma once
#include <iostream>
#include <cmath>
// 复数类Complex：定义

// 待补足

class Complex {
private:
    double real;
    double imag;
public:
    // 构造函数
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数
    double get_real() const { return real; }
    double get_imag() const { return imag; }

    void show() const {
        std::cout << real;
        if (imag >= 0) {
            std::cout << " + " << imag << "i";
        }
        else {
            std::cout << " - " << -imag << "i";
        }
    }

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

    // 友元函数
    friend Complex add(const Complex& a, const Complex& b);
    friend bool is_equal(const Complex& a, const Complex& b);
    friend double abs(const Complex& a);
};
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;
}

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

测试函数，主函数：

#include"t.hpp"
// 复数类Complex: 测试

void test() {
    using namespace std;
    Complex c1(3, -4);
    const Complex c2(4.5);
    Complex c3(c1);
    cout << "c1 = ";
    c1.show();
    cout << endl;
    cout << "c2 = ";
    c2.show();
    cout << endl;
    cout << "c2.imag = " << c2.get_imag() << endl;
    cout << "c3 = ";
    c3.show();
    cout << endl;
    cout << "abs(c1) = ";
    cout << abs(c1) << endl;
    cout << boolalpha;
    cout << "c1 == c3 : " << is_equal(c1, c3) << endl;
    cout << "c1 == c2 : " << is_equal(c1, c2) << endl;
    Complex c4;
    c4 = add(c1, c2);
    cout << "c4 = c1 + c2 = ";
    c4.show();
    cout << endl;
    c1.add(c2);
    cout << "c1 += c2, " << "c1 = ";
    c1.show();
    cout << endl;
}

int main() {
    test();
}

实验四：

 t.hpp

#pragma once
#include<string>
#include<iostream>
using namespace std;
class User {
public :
    User (string x = "Mary", string p = "111111", string e = "")
    {
        string name = x;
        string password = p;
        string email = e;
        n++;
    };
    ~User() {
        n--;
    }
private :
    string name;                                //类的数据成员，name,password,email
    string password;
    string email;    
    static int n;                                //描述类的对象个数，即用户总数
//成员函数
public :
    void set_email();                            //邮箱
    void change_password();                        //改密码
    void print_info ();                            //打印用户名，密码，邮箱
    static void print_n();
};
//实现类
int User:: n = 0;
 void User:: set_email(){
     cout << "Enter email address: abc@gmail.com" << endl;
     cin >> email;    
     cout << "email is set successfully..." << endl;
}
 void User::change_password() {
     cout << "Enter old password :" << endl;
     string password1;
     cin >> password1;
     for (int i = 0; i < 3; i++)
     {
         if (password != password1)  //判断密码是否相同
             cout << "password input error.Please re_enter again:" << password1 << endl;
         else
         {
             cout << "enter new password :" << endl;
             string password2;
             cin >> password2;                     //新密码
             password = password;
         }
     }
     cout << "password input error.Please try after again a while" << endl;
 }
 void User::print_info()
 {
     string p(password.size(), '*');
     cout << "name:   " << name << endl;
     cout << "passwd: " << password << endl;
     cout << "email:  " << email << endl;
 }
 void User::print_n()
 {
     cout << "there are " << n << " users." << endl;
 }

t.cpp

#include "User.hpp"
#include <iostream>
#include<string>

// 测试User类

void test() {
    using std::cout;
    using std::endl;
    cout << "testing 1......\n";
    User user1("Jonny", "92197", "xyz@hotmail.com");
    user1.print_info();
    cout << endl

        << "testing 2......\n\n";

    User user2("Leonard");
    user2.change_passwd();
    user2.set_email();
    user2.print_info();
    cout << endl;
    User::print_n();
}

int main() {
    test();
}

结果：

密码相同：

 修改密码错误：

 实验五：

account.h

class SavingsAccount {
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:
    SavingsAccount(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 data, double amount);
    void withdraw(int data, double amount);
    void settle(int data);
    void show() const; 
};

account.cpp

#include "account.h"
#include <cmath>
#include <iostream>
using namespace std;

double SavingsAccount::total=0;
SavingsAccount::SavingsAccount(int date, int id, double rate): id(id), balance(0), rate(rate), lastDate(date), accumulation(0) {
    cout << date << "\t#" << id << "is created" << endl;
}
void SavingsAccount::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 SavingsAccount::deposit(int date, double amount) {
    record(date, amount);
}
void SavingsAccount::withdraw(int date, double amount) {
    if(amount>getBalance())
      cout << "Error: not enough money" << endl;
    else
      record(date, -amount);
}
void SavingsAccount::settle(int date) {
    double interest = accumulate(date) * rate/365;
    if(interest != 0)
      record(date, interest);
    accumulation = 0;
}
void SavingsAccount::show() const {
    cout << "#" << id << "\tBalance: " << balance;
}

主函数main:

#include "account.h"
#include <iostream>
using namespace std;

int main() {
    SavingsAccount sa0(1, 21325302, 0.015);
    SavingsAccount 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(); cout << endl;
    sa1.show(); cout << endl;
    cout << "Total: " << SavingsAccount::getTotal() << endl;
    return 0;
}

运行结果：