实验2
#pragma once #include <string> #include <iostream> 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类对象总数 static const std::string doc; // 类T的描述信息 static const int max_cnt; // 类T对象上限 private: static int cnt; // 当前T类对象数目 // 类T友元函数声明 friend void func(); }; // 普通函数声明 void func();
#include "T.h" // 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; // 友元可以访问 private std::cout << "t5 = "; t5.display(); std::cout << '\n'; }
#include "T.h" #include <iostream> 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; } int main() { std::cout << "test Class T: \n"; test_T(); std::cout << "\ntest friend func: \n"; func(); }
运行测试截图
main() 需要外部声明才能调用。
| 函数 | 功能 | 调用时机 |
|---|---|---|
T(int x=0, int y=0) |
普通构造函数，初始化对象成员 | 创建对象时，直接赋初值（如 T t1; 或 T t2(3,4);） |
T(const T &t) |
复制构造函数，按已有对象初始化新对象 | 用已有对象初始化新对象（如 T t3(t2);）或传值调用函数 |
T(T &&t) |
移动构造函数，从右值对象“窃取”资源 | 用右值对象初始化新对象（如 T t4(std::move(t2));） |
~T() |
析构函数，销毁对象 | 对象生命周期结束时自动调用，释放资源（如作用域结束或 delete） |
-
不能正确编译
-
原因：静态成员变量只能在一个 cpp 文件中定义，放到头文件会导致多重定义。
实验任务2
#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;
}
#ifndef MY_COMPLEX_H #define MY_COMPLEX_H #include <string> class Complex{ private: float real, imag; public: static const std::string doc; public: Complex() :real(0.f), imag(0.f){} Complex(float re) :real(re), imag(0.f){} Complex(float re, float im) :real(re), imag(im){ } Complex(const Complex& obj) :real(obj.real), imag(obj.imag){ } public: float get_real() const; float get_imag() const; void add(const Complex& c); public: friend void output(const Complex& c); friend float abs(const Complex& c); 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); }; #endif
#include "Complex.h" #include <iostream> #include <cmath> const std::string Complex::doc = "a simplified complex class"; float Complex::get_real() const{ return this->real; } float Complex::get_imag() const{ return this->imag; } void Complex::add(const Complex& c){ this->real += c.real; this->imag += c.imag; } void output(const Complex& c){ std::cout << c.real; if (c.imag < 0) std::cout << " - "; else std::cout << " + "; std::cout << std::abs(c.imag) << "i\n"; } float abs(const Complex& c){ return sqrt(c.real * c.real + c.imag * c.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); }
运行截图
实验任务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.parse(control_str);
controller.execute(cmd);
std::cout << "Current Player control: " << PlayerControl::get_cnt() << "\n\n";
}
}
int main() {
test();
}
#include "PlayerControl.h" #include <iostream> #include <algorithm> int PlayerControl::total_cnt = 0; PlayerControl::PlayerControl() {} // 待补足 // 1. 将输入字符串转为小写，实现大小写不敏感 std::string toLower(const std::string&str) { std::string s=str; std::transform(s.begin(),s.end(),s.begin(),[](unsigned char c) { return std::tolower(c); } ); return s; } // 2. 匹配"play"/"pause"/"next"/"prev"/"stop"并返回对应枚举 // 3. 未匹配的字符串返回ControlType::Unknown // 4. 每次成功调用parse时递增total_cnt ControlType PlayerControl::parse(const std::string& control_str) { std::string lstr=toLower(control_str); if(lstr=="play") { total_cnt++; return ControlType::Play; } else if(lstr=="pause") { total_cnt++; return ControlType::Pause; } else if(lstr=="next") { total_cnt++; return ControlType::Next; } else if(lstr=="prev") { total_cnt++; return ControlType::Prev; } else if(lstr=="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; }
#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; };
实验任务4
#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
#include "Fraction.h" #include<iostream> #include<cmath> #include<stdexcept> using namespace std; const string Fraction::doc="Fraction类 v 0.01版. \n目前仅支持分数对象的构造、输出、加/减/乘/除运算."; int Fraction::maxyueshu(int a,int b) const { a=abs(a); b=abs(b); while(b!=0) { int t=b; b=a%b; a=t; } return a; } void Fraction::reduce() { if(down==0) return; int yue=maxyueshu(up,down); up/=yue; down/=yue; if(down<0) { up=-up; down=-down; } } Fraction::Fraction(int upp,int downn):up(upp),down(downn) { reduce(); } Fraction::Fraction(const Fraction& other) : up(other.up), down(other.down){} 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) { if (f.down == 0) { return; } if (f.down == 1) { cout << f.up; } else { cout << f.up << "/" << f.down; } } Fraction add(const Fraction& f1, const Fraction& f2) { int new_up = f1.up * f2.down + f2.up * f1.down; int new_down = f1.down * f2.down; return Fraction(new_up, new_down); } Fraction sub(const Fraction& f1, const Fraction& f2) { int new_up = f1.up * f2.down - f2.up * f1.down; int new_down = f1.down * f2.down; return Fraction(new_up, new_down); } Fraction mul(const Fraction& f1, const Fraction& f2) { int new_up = f1.up * f2.up; int new_down = f1.down * f2.down; return Fraction(new_up, new_down); } Fraction div(const Fraction& f1, const Fraction& f2) { if (f2.up == 0) { cout<<"分母不能为0"; } int new_up = f1.up * f2.down; int new_down = f1.down * f2.up; return Fraction(new_up, new_down); }
#ifndef FRACTIONG_H #define FRACTION_H #include<string> class Fraction { private: int up; int down; void reduce(); int maxyueshu(int a, int b)const; public: static const std::string doc; Fraction(int upp=0,int downn=1); Fraction(const Fraction&other); int get_up() const; int get_down() const; Fraction negative() const; 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); }; void output(const Fraction &f); Fraction add(const Fraction &f1,const Fraction &f2); Fraction sub(const Fraction &f1,const Fraction &f2); Fraction mul(const Fraction &f1,const Fraction &f2); Fraction div(const Fraction &f1,const Fraction &f2); #endif
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; }
通过本次实验，我完成了四个任务，分别练习了类的构造与析构、友元函数、运算符重载、文件分离编译以及简单控制逻辑的设计，实现了面向对象程序设计的基本思想。
在实验任务1和2中，通过对 friend 的使用进行验证，我理解到：
-
友元不是必须，但当外部函数需要访问类的私有成员时，会带来便利
-
取消
friend声明会导致外部函数无法访问私有数据，从而产生编译错误 -
将函数定义随意放入头文件，会导致重复定义问题，不利于工程化管理
-
对象的生命周期可通过构造函数与析构函数输出观察到
在任务2中对比了自定义 Complex 与标准库 std::complex：
-
标准库模板类封装更好，使用更简洁，如可以直接使用
+、<<等运算符 -
标准库
abs()并不是友元，而是通过运算符或成员函数访问，体现更安全的封装性 -
友元仅在确实需要访问私有成员时使用，否则会破坏封装
在任务3和任务4中：
-
体会到将类声明与实现分离的结构化编程方式，更适合集成开发
-
通过实现播放控制与分数类运算，加深对封装、抽象与模块化的认识
-
分数类可通过自由函数、友元函数、静态成员、命名空间等多种设计方式实现
-
每种方式都有适用场景：
-
友元：操作与类强关联，且需访问私有数据
-
自由函数：操作逻辑更独立，减少耦合
-
静态成员：与对象实例无关的功能
-
命名空间：提供扩展性与层次管理
-
总体体会
本次实验让我真正体会到：
-
面向对象设计的核心是封装、抽象、接口分离
-
合理文件划分与模块化能提升代码可维护性
-
友元函数和运算符重载必须谨慎使用
-
对象行为的正确性需要通过测试与调试验证
结论：通过本次实验，我不仅掌握了面向对象的基础语法，还理解了工程实践中的代码组织方式，对 C++ 类设计的理解更加深入，为后续学习打下了良好基础。
浙公网安备 33010602011771号