计算机信息管理课程实验 C++篇

已于 2023-05-15 10:30:10 修改
阅读量421 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-05-13 02:33:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33205391/article/details/130652643
版权

计算机信息管理课程实验 C++篇

一、环境搭建

  • 开发工具：vc++6.0，Visual Studio Community 2022版本（推荐）
  • vc++6.0：
    • 文件 - 新建 - 工程 - Win32 Console Application - 输入工程名称 - 确定
    • 文件 - 新建 - 文件 - C++ Source File - 输入文件名 - 确定
  • VS:
    • 下载c++桌面应用支持包
    • 创建新项目 - 控制台应用 - 下一步 - 输入名称 - 创建

以下为了同屏看到更多代码，选择省略了函数间的空白行、一行实现某些函数等，参考本文代码的同时，请务必保持良好的代码规范！

二、编程练习

  1. 定义盒子Box类，要求具有以下成员：长、宽、高分别为x、y、z，可设置盒子形状；可计算盒子体积；可计算盒子的表面积。
#include<iostream>
using namespace std;

class Box {
public:
	// 构造函数
	Box(){};
	// 带参数的构造函数
	Box(double a, double b, double c):x(a), y(b), z(c){}
	// 设置盒子大小
	void setBox(double a, double b, double c) {
		x = a; y = b; z = c;
	}
	// 获取面积
	double getArea() {
		return 2 * (x * y + y * z + z * x);
	}
	// 获取体积
	double getVolume() {
		return x * y * z;
	}
	void display() {
		cout << "x: " << x << " y: " << y << " z: " << z;
		cout << " area: " << getArea();
		cout << " volume: " << getVolume() << endl;
	}
private:
	double x, y, z;
};

void main() {
	// 使用默认构造函数不需要Box b2();
	Box b1;
	b1.setBox(1, 2, 3);
	b1.display();

	// 使用带参数的构造函数，需要传入指定参数
	Box b2(2, 3, 4);
	b2.display();

	// 使用new运算符创建动态对象，需要用delete运算符销毁，否则会造成内存泄漏
	Box* b3 = new Box(4, 5, 6);
	b3->display();

	delete b3;
}

输出结果：
x: 1 y: 2 z: 3 area: 22 volume: 6
x: 2 y: 3 z: 4 area: 52 volume: 24
x: 4 y: 5 z: 6 area: 148 volume: 120

  1. 声明一个类模板，分别实现两个整数、浮点数和字符的比较，求出最大数和最小数。
#include<iostream>
#include<string>
using namespace std;

template<class numtype>	// 声明类模板
class Compare {
public:
	Compare(numtype a, numtype b):x(a), y(b){}
	// 获取最大值
	numtype max(){ return x > y ? x : y; }
	// 获取最小值
	numtype min(){ return x > y ? y : x; }
	void display() {
		cout << "x: " << x;
		cout << " y: " << y;
		cout << " max: " << max();
		cout << " min: " << min() << endl;
	}
private:
	numtype x, y;
};

void main() {
	Compare<int> c1(1, 2);
	c1.display();	

	Compare<double> c2(22.2, 33.3);
	c2.display();

	Compare<string> c3("hello", "world");
	c3.display();
}

输出结果：
x: 1 y: 2 max: 2 min: 1
x: 22.2 y: 33.3 max: 33.3 min: 22.2
x: hello y: world max: world min: hello

  1. 建立一个对象数组，内放5个学生的数据（学号、成绩），用指针指向数组首元素，输出第1，3，5个学生的数据。初值自拟。
#include<iostream>
using namespace std;

class Student {
public:
	Student(int n, double s): num(n), score(s){};
	void display() {
		cout << "num: " << num;
		cout << " score: " << score << endl;
	}
private:
	int num;
	double score;
};

void main() {
	Student s[5] = {
		Student(101, 100.0),
		Student(102, 33.50),
		Student(103, 60.0),
		Student(104, 89.50),
		Student(105, 95.50)
	};
	Student* p = s;
	for(int i = 0; i < 5; i ++) {
		if((i % 2) == 0)
			(p+i)->display();
	}
}

输出结果：
num: 101 score: 100
num: 103 score: 60
num: 105 score: 95.5

  1. 建立一个对象数组，内放5个学生的数据（学号、成绩），设立一个函数max，用指向对象的指针作函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号。初值自拟。
#include<iostream>
using namespace std;

class Student {
public:
	Student(int n, double s): num(n), score(s){};
	double getScore() {
		return score;
	}
	void display() {
		cout << "num: " << num;
		cout << " score: " << score << endl;
	}
private:
	int num;
	double score;
};

void max(Student* p) {
	int k = 0;
	double max_score = 0;
	for(int i = 0; i < 5; i ++) {
		int cur_score = (p+i)->getScore();
		if (max_score < cur_score) {
			k = i;
			max_score = cur_score;
		}
	}
	cout << "the student with the highest score is ";
	(p+k)->display();
}

void main() {
	Student s[5] = {
		Student(101, 55.0),
		Student(102, 33.50),
		Student(103, 60.0),
		Student(104, 89.50),
		Student(105, 95.50)
	};
	Student* p = s;
	max(p);
}

输出结果：
the student with the highest score is num: 105 score: 95.5

  1. 用new建立一个动态一维数组，并初始化int[10]={1,2,3,4,5,6,7,8,9,10}，用指针输出，最后销毁数组所占空间。
#include<iostream>
using namespace std;

void main() {
	int* p;
	// C++11可改为p = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	p = new int[10];
	for(int i = 0; i < 10; i ++) {
		*(p+i) = i+1;
	}
	for(int j = 0; j < 10; j ++) {
		cout << *(p+j) << " ";
	}
	cout << endl;
	delete[] p;
}

运行结果：
1 2 3 4 5 6 7 8 9 10

  1. 定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求两个复数之和。初值自拟。

复数是由实部和虚部构成的数学对象。复数可以表示为 a + bi 的形式，其中 a 和 b 都是实数，i 是虚数单位，满足 i² = -1。
在这个表示中，a 是复数的实部，b 是复数的虚部。实部和虚部都是实数。两个复数相等当且仅当它们的实部相等并且它们的虚部相等。
与实数不同的是，复数之间存在着更加复杂的乘法和除法运算。例如，如果 z₁ = 2 +i 3，z₂ = - 4 + i 5，则彼此相乘将得到：z₁z₂ = - 22 + i 7。因此，除了一般的加法和减法外，还需要引入其他算术规则和操作来处理复数。
复数具有很多实际应用，例如物理、工程、金融、电子学等领域。在计算机科学中，复数被广泛应用于信号处理、数字图像处理、动画和游戏编程等方面。

代码把+-*/都写了，供参考

#include<iostream>
using namespace std;

class Complex {
public:
	Complex(double r, double i): real(r), imag(i) {}
	double getReal() { return real; }
	double getImag() { return imag; }
	void display() {
		cout << "(" << real << " ," << imag << ")" << endl;
	}
private:
	double real, imag;
};

// (a, b)-(c, d) = (a+c, b+d)
Complex operator+(Complex& c1, Complex& c2) {
	return Complex(c1.getReal() + c2.getReal(), c1.getImag() + c2.getImag());
}

// (a, b)-(c, d) = (a-c, b-d)
Complex operator-(Complex& c1, Complex& c2) {
	return Complex(c1.getReal() - c2.getReal(), c1.getImag() - c2.getImag());
}

// (a, b)*(c, d) = (ac - bd, ad + bc)
Complex operator*(Complex& c1, Complex& c2) {
	return Complex(c1.getReal() * c2.getReal() - c1.getImag() * c2.getImag(),
		c1.getReal() * c2.getImag() + c1.getImag() * c2.getReal());
}

// (a, b)/(c, d) = ((ac + bd) / (c^2 + d^2), (bc - ad) / (c^2 + d^2))
Complex operator/(Complex& c1, Complex& c2) {
	double m = c2.getReal() * c2.getReal() + c2.getImag() * c2.getImag();
	double real = (c1.getReal() * c2.getReal() + c1.getImag() * c2.getImag()) / m;
	double imag = (c1.getImag() * c2.getReal() - c1.getReal() * c2.getImag()) / m;
	return Complex(real, imag);
}

void main() {
	Complex c1(2, 3);
	cout << "c1 = ";
	c1.display();
	Complex c2(-4, 5);
	cout << "c2 = ";
	c2.display();

	cout << "c1 + c2 = ";
	(c1 + c2).display();

	cout << "c1 - c2 = ";
	(c1 - c2).display();

	cout << "c1 * c2 = ";
	(c1 * c2).display();

	cout << "c1 / c2 = ";
	(c1 / c2).display();
}

运行结果：
c1 = (2 ,3)
c2 = (-4 ,5)
c1 + c2 = (-2 ,8)
c1 - c2 = (6 ,-2)
c1 * c2 = (-23 ,-2)
c1 / c2 = (0.170732 ,-0.536585)

  1. 定义一个复数类Complex，重载运算符“+”，“-”，使之能用于复数的加，减运算，运算符重载函数作为Complex类的成员函数。编程序，分别求出两个复数之和，差。初值自拟。
#include<iostream>
using namespace std;

class Complex {
public:
	Complex(double r, double i): real(r), imag(i) {}
	Complex operator+(Complex& c);
	Complex operator-(Complex& c);
	void display() {
		cout << "(" << real << " ," << imag << ")" << endl;
	}
private:
	double real, imag;
};

Complex Complex::operator+(Complex& c) {
	return Complex(real + c.real, imag + c.imag);
}

Complex Complex::operator-(Complex& c) {
	return Complex(real - c.real, imag - c.imag);
}

void main() {
	Complex c1(2, 3);
	cout << "c1 = ";
	c1.display();
	Complex c2(-4, 5);
	cout << "c2 = ";
	c2.display();

	cout << "c1 + c2 = ";
	(c1 + c2).display();

	cout << "c1 - c2 = ";
	(c1 - c2).display();
}

输出结果：
c1 = (2 ,3)
c2 = (-4 ,5)
c1 + c2 = (-2 ,8)
c1 - c2 = (6 ,-2)

  1. 定义一个复数类Complex，重载运算符“＋”，使之能用于复数的加法运算。参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。例如：c1+c2，i+c1，c1+i均合法（设i为整数，c1，c2为复数）。编程序，分别求两个复数之和、整数和复数之和。初值自拟。

友元函数的概念是在 C++ 标准化之后引入的，VC6.0 是一个较为古老的编译器版本，发布于 1998 年，仅支持部分 C++98 的特性，并不支持 C++11、C++14或更高标准提出的许多新特性，包括现代意义上的友元函数。
虽然 VC6.0 可以定义和使用传统意义上的自由函数（非成员函数），但实际上它并没有真正支持友元函数。因此，在使用 VC6.0 时，您需要采用传统的方法来定义和访问类的私有成员。

#include<iostream>
using namespace std;

class Complex {
public:
	Complex() { real = 0; imag = 0; }
	Complex(double r, double i) : real(r), imag(i) {}
	double getReal() { return real; }
	double getImag() { return imag; }
	Complex operator+(Complex& c);
	friend Complex operator+(int& i, Complex& c);
	friend Complex operator+(Complex& c, int& i);
	void display() {
		cout << "(" << real << " ," << imag << ")" << endl;
	}
private:
	double real, imag;
};

Complex Complex::operator+(Complex& c) {
	return Complex(real + c.real, imag + c.imag);
}

Complex operator+(Complex& c, int& i) {
	return Complex(c.getReal() + i, c.getImag());
}

Complex operator+(int& i, Complex& c) {
	return Complex(c.getReal() + i, c.getImag());
}

void main() {
	Complex c1(2, 3);
	cout << "c1 = ";
	c1.display();
	Complex c2(-4, 5);
	cout << "c2 = ";
	c2.display();

	cout << "c1 + c2 = ";
	(c1 + c2).display();

	int i = 2;
	cout << "c1 + 2 = ";
	(c1 + i).display();

	cout << "2 + c1 = ";
	(i + c1).display();
}

输出结果：
c1 = (2 ,3)
c2 = (-4 ,5)
c1 + c2 = (-2 ,8)
c1 + 2 = (4 ,3)
2 + c1 = (4 ,3)

  1. 有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于矩阵相加。如c=a+b。初值自拟。
#include<iostream>
using namespace std;

class Matrix {
private:
	int data[2][3];
public:
	Matrix();
	Matrix(const int (&arr)[2][3]);
	friend Matrix operator+(const Matrix& m1, const Matrix& m2);
	void display();
};

Matrix::Matrix() {
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			data[i][j] = 0;
		}
	}
}
Matrix::Matrix(const int (&arr)[2][3]) {
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			data[i][j] = arr[i][j];
		}
	}
}

Matrix operator+(const Matrix& m1, const Matrix& m2) {
	Matrix m;
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			m.data[i][j] = m1.data[i][j] + m2.data[i][j];
		}
	}
	return m;
}

void Matrix::display() {
	cout << "{ ";
	for (int i = 0; i < 2; i++) {
		cout << (i == 0 ? "" : ", ") << "{";
		for (int j = 0; j < 3; j++) {
			cout << (j == 0 ? "" : ", ") << data[i][j];
		}
		cout << "}";
	}
	cout << " }" << endl;
}

void main() {
	int arr1[2][3] = { {1, 2, 3}, {4, 5, 6} };
	Matrix m1(arr1);
	int arr2[2][3] = { {7, 8, 9}, {10, 11, 12} };
	Matrix m2(arr2);

	Matrix m3 = m1 + m2;
	cout << "m3 = ";
	m3.display();
}

输出结果：
m3 = { {8, 10, 12}, {14, 16, 18} }

  1. 将运算符“＋”重载为适用于复数加法，重载函数不作为成员函数，而放在类外，作为Complex类的友元函数。初值自拟。
#include<iostream>
using namespace std;

class Complex {
private:
	double real, imag;
public:
	Complex();
	Complex(const double& r, const double& imag);
	friend Complex operator+(const Complex& c1, const Complex& c2);
	void display();
};

Complex::Complex() {
	real = 0; imag = 0;
}

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

void Complex::display() {
	cout << "(" << real << ", " << imag << ")" << endl;
}

Complex operator+(const Complex& c1, const Complex& c2) {
	return Complex(c1.real + c2.real, c1.imag + c2.imag);
}


void main() {
	Complex c1(3, 4);
	Complex c2(5, 6);
	cout << "c1 + c2 = ";
	(c1 + c2).display();
}

输出结果：
c1 + c2 = (8, 10)

  1. 定义一个字符串类String，用来存放不定长的字符串，重载运算符“＝＝”，用于两个字符串的等于比较运算。初值自拟。
#include<iostream>
#include<string>
using namespace std;

class String {
private:
	char* p;
public:
	String() { p = nullptr; }
	String(const char* s) { 
		p = new char[strlen(s) + 1];
		strcpy_s(p, strlen(s) + 1, s);
	}
	String(const String& other) {
		if (other.p == nullptr) {
			p = nullptr;
		}
		else {
			p = new char[strlen(other.p) + 1];
			strcpy_s(p, strlen(other.p) + 1, other.p);
		}
	}
	void display() const {
		cout << p << endl;
	}
	friend bool operator==(const String& s1, const String& s2);
};

bool operator==(const String& s1, const String& s2) {
	return strcmp(s1.p, s2.p) == 0 ? true : false;
}

void main() {
	String s1("Hello");
	String s2("World");
	String s3(s1);
	String s4;
	s4 = "World";

	if (s1 == s2)
		cout << "s1 equals to s2." << endl;
	else
		cout << "s1 doesn't equal to s2." << endl;

	if (s1 == s3)
		cout << "s1 equals to s3." << endl;
	else
		cout << "s1 doesn't equal to s3." << endl;

	if (s2 == s4)
		cout << "s2 equals to s4." << endl;
	else
		cout << "s2 doesn't equal to s4." << endl;
}

输出结果：
s1 doesn’t equal to s2.
s1 equals to s3.
s2 equals to s4.

  1. 定义一个字符串类String，用来存放不定长的字符串，重载运算符"<"，用于两个字符串的小于的比较运算。初值自拟。
#include<iostream>
#include<string>
using namespace std;

class String {
private:
	char* p;
public:
	String() { p = nullptr; }
	String(const char* s) { 
		p = new char[strlen(s) + 1];
		strcpy_s(p, strlen(s) + 1, s);
	}
	String(const String& other) {
		if (other.p == nullptr) {
			p = nullptr;
		}
		else {
			p = new char[strlen(other.p) + 1];
			strcpy_s(p, strlen(other.p) + 1, other.p);
		}
	}
	void display() const {
		cout << p << endl;
	}
	friend bool operator==(const String& s1, const String& s2);
	friend bool operator<(const String& s1, const String& s2);
	friend bool operator>(const String& s1, const String& s2);
};

bool operator==(const String& s1, const String& s2) {
	return strcmp(s1.p, s2.p) == 0;
}
bool operator<(const String& s1, const String& s2) {
	return strcmp(s1.p, s2.p) < 0;
}
bool operator>(const String& s1, const String& s2) {
	return strcmp(s1.p, s2.p) > 0;
}

void main() {
	String s1("Hello");
	String s2("World");
	String s3(s1);
	String s4;
	s4 = "World";

	if(s1 == s2)
		cout << "s1 == s2." << endl;
	else if (s1 < s2)
		cout << "s1 < s2." << endl;
	else if (s1 > s2)
		cout << "s1 > s2." << endl;

	if (s1 == s3)
		cout << "s1 == s3." << endl;
	else if (s1 < s3)
		cout << "s1 < s3." << endl;
	else if (s1 > s3)
		cout << "s1 > s3." << endl;

	if (s2 == s4)
		cout << "s1 == s4." << endl;
	else if (s2 < s4)
		cout << "s2 < s4." << endl;
	else if (s2 > s4)
		cout << "s2 > s4." << endl;
}

输出结果：
s1 < s2.
s1 == s3.
s1 == s4.

  1. 定义一个字符串类String，用来存放不定长的字符串，重载运算符">"，用于两个字符串的大于的比较运算。初值自拟。（同12题，‘<’，'>'都包含）
#include<iostream>
#include<string>
using namespace std;

const double PI = 3.1415926;

class Point {
protected:
	double x, y;
public:
	Point(double x = 0, double y = 0) {
		this->x = x;
		this->y = y;
	}
	friend ostream& operator<<(ostream& os, const Point& p);
	friend istream& operator>>(istream& is, Point& p);
};
ostream& operator<<(ostream& os, const Point& p) {
	os << "(" << p.x << ", " << p.y << ")";
	return os;
}
istream& operator>>(istream& is, Point& p) {
	is >> p.x >> p.y;
	return is;
}

class Circle : public Point {
protected:
	double r;
public:
	Circle(double x = 0, double y = 0, double r = 0) :Point(x, y) {
		this->r = r;
	}
	double area() const {
		return PI * r * r;
	}
	friend ostream& operator<<(ostream& os, const Circle& c);
	friend istream& operator>>(istream& is, Circle& c);
};
ostream& operator<<(ostream& os, const Circle& c) {
	os << "Center:" << (Point)c << ", Radius:" << c.r << ", Area:" << c.area();
	return os;
}
istream& operator>>(istream& is, Circle& c) {
	is >> (Point&)c >> c.r;
	return is;
}

class Cylinder : public Circle {
protected:
	double h;
public:
	Cylinder(double x = 0, double y = 0, double r = 0, double h = 0) : Circle(x, y, r) {
		this->h = h;
	}
	double volume() const {
		return area() * h;
	}
	friend ostream& operator<<(ostream& os, const Cylinder& c);
	friend istream& operator>>(istream& is, Cylinder& c);
};
ostream& operator<<(ostream& os, const Cylinder& c) {
	os << "Center:" << (Point)c << " Radius:" << c.r << " Height:" << c.h << " Volume:" << c.volume();
	return os;
}
istream& operator>>(istream& is, Cylinder& c) {
	is >> (Circle&)c >> c.h;
	return is;
}

int main() {
	Point p(1, 2);
	cout << p << endl;
	Circle c(1, 2, 3);
	cout << c << endl;
	Cylinder cy(1, 2, 3, 4);
	cout << cy << endl;
	return 0;
}

输出结果：
(1, 2)
Center:(1, 2), Radius:3, Area:28.2743
Center:(1, 2) Radius:3 Height:4 Volume:113.097

  1. 写一个程序，定义抽象类型Shape，由他派生三个类：Circle（圆形），Rectangle（矩形），Trapezoid（梯形），用一个函数printArea分别输出三者的面积，3个图形的数据在定义对象是给定。
#include<iostream>
#include<string>
using namespace std;

const double PI = 3.1415926;

class Shape {
public:
	virtual double area() const = 0; // 纯虚函数
};

class Circle: public Shape {
protected:
	double r;
public:
	Circle(double r = 0) {
		this->r = r;
	}
	double area() const {
		return PI * r * r;
	}
};

class Rectangle: public Shape {
protected:
	double w, h;
public:
	Rectangle(double w = 0, double h = 0) {
		this->w = w;
		this->h = h;
	}
	double area() const {
		return w * h;
	}
};

class Trapezoid: public Shape {
protected:
	double t, b, h;
public:
	Trapezoid(double t = 0, double b = 0, double h = 0) {
		this->t = t;
		this->b = b;
		this->h = h;
	}
	double area() const {
		return (t + b) * h / 2;
	}
};

void printArea(Shape& s) {
	cout << "The area is: " << s.area() << endl;
}

int main() {
	Circle c(5.0);
	printArea(c);
	Rectangle r(3.0, 4.0);
	printArea(r);
	Trapezoid t(2, 4, 5);
	printArea(t);
	return 0;
}

输出结果：
The area is: 78.5398
The area is: 12
The area is: 15

  1. 定义一个人员类CPerson，包括数据成员：姓名、编号、性别和用于输入输出的成员函数。在此基础上派生出学生类CStudent(增加成绩)和老师类CTeacher(增加教龄)，并实现对学生和教师信息的输入输出。
#include<iostream>
#include<string>
using namespace std;

class CPerson {
protected:
	string name;
	int id;
	char gender;
public:
	void input() {
		cout << "Enter Name: ";
		cin >> name;
		cout << "Enter ID: ";
		cin >> id;
		cout << "Enter Gender (M or F): ";
		cin >> gender;
	}
	void output() {
		cout << "Name: " << name << endl;
		cout << "ID: " << id << endl;
		cout << "Gender: " << gender << endl;
	}
};

class CStudent: public CPerson {
protected:
	double score;
public:
	void input() {
		CPerson::input();
		cout << "Enter Score: ";
		cin >> score;
	}
	void output() {
		CPerson::output();
		cout << "Score: " << score << endl;
	}
};

class CTeacher : public CPerson {
protected:
	int seniority;
public:
	void input() {
		CPerson::input();
		cout << "Enter Seniority: ";
		cin >> seniority;
	}
	void output() {
		CPerson::output();
		cout << "Seniority; " << seniority << endl;
	}
};

int main() {
	CStudent cs;
	cout << "--- input student's infomation ---" << endl;
	cs.input();
	cout << "--- output student's infomation ---" << endl;
	cs.output();

	CTeacher ct;
	cout << "--- input teacher's infomation ---" << endl;
	ct.input();
	cout << "--- output teacher's infomation ---" << endl;
	ct.output();

	return 0;
}

输出结果：
— input student’s infomation —
Enter Name: Kk
Enter ID: 101
Enter Gender (M or F): M
Enter Score: 100
— output student’s infomation —
Name: Kk
ID: 101
Gender: M
Score: 100
— input teacher’s infomation —
Enter Name: JJ
Enter ID: 202
Enter Gender (M or F): F
Enter Seniority: 20
— output teacher’s infomation —
Name: JJ
ID: 202
Gender: F
Seniority; 20

  1. 某商店经销一种货物，货物成箱购进，成箱卖出，购进和卖出时以重量为单位，各箱的重量不一样，因此，商店需要记下目前库存货物的总量，要求把商店货物购进和卖出的情况模拟出来。
#include<iostream>
using namespace std;

class Goods {
private:
	int weight; // 单位：克
public:
	Goods(int w = 0) {
		weight = w;
	}
	int getWeight() const {
		return weight;
	}
};

class Store {
private:
	Goods* inventory; // 库存商品
	int size;	// 库存商品数量
	int capacity; // 当前最大容量
public:
	Store(int c = 50) {
		capacity = c;
		size = 0;
		inventory = new Goods[c];
	}
	~Store() {
		delete[] inventory;
	}
	void addGoods(Goods g) {
		if (size < capacity) {
			inventory[size++] = g;
		}
		else {	// 容量不足，需要扩容
			Goods* temp = new Goods[capacity * 2];
			for (int i = 0; i < capacity; i++) {
				temp[i] = inventory[i];
			}
			delete[] inventory;
			inventory = temp;
			capacity = capacity * 2;
			inventory[size++] = g;
		}
		cout << "Add a goods with weight of " << g.getWeight() << endl;
	}
	void sellGoods(int amount) {	// 出售商品
		if (amount < size) {
			for (int i = 0; i < amount; i++) {
				size--;	// 出售一件商品，库存-1
				cout << "Sell a goods with weight of " << inventory[size].getWeight() << endl;
			}
		}
		else {
			cout << "Inventory is not enough!" << endl;
		}
	}
	int getInventorySize() const {	// 获取当前库存量
		return size;
	}
};

int main() {
	Store store(5);
	store.addGoods(Goods(100));
	store.addGoods(Goods(500));
	store.addGoods(Goods(300));
	cout << "Current inventory: " << store.getInventorySize() << endl;

	store.sellGoods(2);
	cout << "Current inventory: " << store.getInventorySize() << endl;

	store.addGoods(Goods(400));
	cout << "Current inventory: " << store.getInventorySize() << endl;

	store.sellGoods(10);
	return 0;
}

输出结果：
Add a goods with weight of 100
Add a goods with weight of 500
Add a goods with weight of 300
Current inventory: 3
Sell a goods with weight of 300
Sell a goods with weight of 500
Current inventory: 1
Add a goods with weight of 400
Current inventory: 2
Inventory is not enough!

  1. 设计一个Time类，包括三个私有数据成员：hour、minute、sec，用构造函数初始化，内设公用函数display(Date &d)，设计一个Date类，包括三个私有数据成员：month、day、year，也用构适函数初始化；分别定义两个带参数的对象t1(12,30,55)、d1(3,25,2010)，通过友员成员函数的应用，输出d1和t1的值。

这里vs有个坑，就是在Time类里面直接实现函数display，会出现“Date::year”: 无法访问 private 成员(在“Date”类中声明) ，后来改为外部实现才编译通过。
还有两个地方要注意：
开头需要加上class Date;
class Time在class Date上面。

#include<iostream>
#include<string>
using namespace std;

class Date;
class Time {
private:
	int hour, minute, sec;
public:
	Time(int h = 0, int m = 0, int s = 0) : hour(h), minute(m), sec(s) {}
	void display(Date& d);
};

class Date {
private:
	int month, day, year;
public:
	Date(int m = 0, int d = 0, int y = 0) : month(m), day(d), year(y) {}

	friend void Time::display(Date& d);
};

void Time::display(Date& d) {
	cout << d.month << "/" << d.day << "/" << d.year << " ";
	cout << hour << ":" << minute << ":" << sec << endl;
}

int main() {
	Date d(5, 20, 2020);
	Time t(10, 10, 20);
	t.display(d);
	return 0;
}

输出结果：
5/20/2020 10:10:20

  1. 设计一个Time类，包括三个私有数据成员：hour、minute、sec，用构造函数初始化，设计一个Date类，包括三个私有数据成员：month、day、year，也用构适函数初始化；设计一个普通函数display(…)，将display分别设置为Time类和Date类的友元函数，在主函数中分别定义两个带参数的对象t1(12,30,55)、d1(3,25,2010)，调用desplay，输出年、月、日和时、分、秒。
#include<iostream>
#include<string>
using namespace std;

class Date;
class Time {
private:
	int hour, minute, sec;
public:
	Time(int h = 0, int m = 0, int s = 0) : hour(h), minute(m), sec(s) {}
	friend void display(const Date& d, const Time& t);
};

class Date {
private:
	int month, day, year;
public:
	Date(int m = 0, int d = 0, int y = 0) : month(m), day(d), year(y) {}

	friend void display(const Date& d, const Time& t);
};

void display(const Date& d, const Time& t) {
	cout << d.month << "/" << d.day << "/" << d.year << " ";
	cout << t.hour << ":" << t.minute << ":" << t.sec << endl;
}

int main() {
	Date d(5, 20, 2020);
	Time t(10, 10, 20);
	display(d, t);
	return 0;
}

输出结果：
5/20/2020 10:10:20

  1. 定义一个类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。
#include<iostream>
#include<string>
using namespace std;

class Point {
private:
	double x, y;
public:
	Point(double x = 0, double y = 0) : x(x), y(y) {}
	double getX() { return x; }
	double getY() { return y; }
};

class Distance {
private:
	double dist;
	Point pA, pB;
public:
	Distance(Point& p1, Point& p2): pA(p1), pB(p2) {
		double dx = abs(p1.getX() - p2.getX());
		double dy = abs(p1.getY() - p2.getY());
		dist = sqrt(dx * dx + dy * dy);
	}
	double getDist() {
		return dist;
	}
};

int main() {
	Point p1(0, 0);
	Point p2(3, 4);
	Distance d(p1, p2);
	cout << "The distance between p1 and p2 is " << d.getDist() << endl;
	return 0;
}

输出结果：
The distance between p1 and p2 is 5

  1. 定义点类（Point），再定义一个函数（Distance）描述两点之间的距离，其数据成员为两个点类对象，将两点之间距离函数声明为Point类的友元函数。
#include<iostream>
#include<string>
using namespace std;

class Point {
private:
	double x, y;
public:
	Point(double x = 0, double y = 0) : x(x), y(y) {}
	double getX() { return x; }
	double getY() { return y; }
	friend double Distance(Point& p1, Point& p2);
};

double Distance(Point& p1, Point& p2) {
	double dx = abs(p1.x - p2.x);
	double dy = abs(p1.y - p2.y);
	return sqrt(dx * dx + dy * dy);
}

int main() {
	Point p1(0, 0);
	Point p2(3, 4);
	cout << "The distance between p1 and p2 is " << Distance(p1, p2) << endl;
	return 0;
}

输出结果：
The distance between p1 and p2 is 5

  1. 实现重载函数Double(x)，返回值为输人参数的两倍；参数分别为整型、浮点型、双精度型，返回值类型与参数一样。（用类模板实现）
#include<iostream>
#include<string>
using namespace std;

template<class numtype>
class Double {
private:
	numtype x;
public:
	Double(numtype x):x(x){}
	numtype doubleValue() {
		return 2 * x;
	}
};

int main() {
	Double<int> d1(10);
	cout << "The double of 10 is " << d1.doubleValue() << endl;

	Double<float> d2(10.55);
	cout << "The double of 10.55 is " << d2.doubleValue() << endl;

	Double<double> d3(20.3333);
	cout << "The double of 20.3333 is " << d3.doubleValue() << endl;

	return 0;
}

输出结果：
The double of 10 is 20
The double of 10.55 is 21.1
The double of 20.333333 is 40.6666

  1. 有一个Time类，包含数据成员minute（分）和sec（秒），模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值。初值自拟。

这里为了实现每秒输出一次，引用了头文件window.h，Sleep(1000)表示休眠1000ms
引用头文件iomanip，setw(2)设置宽度为2，setfill(‘0’)设置填充’0’
实际练习可以忽略

#include<iostream>
#include<windows.h>
#include<iomanip>
using namespace std;

class Time {
private:
	int minute, sec;
public:
	Time(int m = 0, int s = 0) : minute(m), sec(s) {}
	void run() {
		while (true) {
			cout << "Current time:" << setw(2) << setfill('0') << minute;
			cout << ":" << setw(2) << setfill('0') << sec << endl;
			sec++;
			if (sec >= 60) {
				sec = 0;
				minute++;
			}
			if(minute >= 60) {
				minute = 0;
			}
			Sleep(1000);
		}
	}
};

int main() {
	Time t(59, 55);
	t.run();
	return 0;
}

输出结果：
Current time:59:55
Current time:59:56
Current time:59:57
Current time:59:58
Current time:59:59
Current time:00:00
Current time:00:01
Current time:00:02
Current time:00:03
Current time:00:04
Current time:00:05
…

  1. 分别用成员函数和友元函数重载运算符，使对实型的运算符“-”适用于复数运算。
#include <iostream>
using namespace std;

class Complex {
private:
    double real;  // 实部
    double imag;  // 虚部
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    // 成员函数方式重载运算符“-”
    Complex operator-(const Complex& other) const {
        return Complex(real - other.real, imag - other.imag);
    }
    // 友元函数方式重载运算符“-”
    friend Complex operator-(double d, const Complex& c) {
        return Complex(d - c.real, -c.imag);
    }
    // 友元函数方式重载输出运算符“<<”
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << ")";
        return os;
    }
};

int main() {
    Complex a(3, 4);
    Complex b(1, 2);

    // 使用成员函数方式重载的减法运算符
    Complex c1 = a - b;
    cout << "c1 = a - b = " << c1 << endl;

    // 使用友元函数方式重载的减法运算符
    double d = 5.0;
    Complex c2 = d - b;
    cout << "c2 = " << d << " - b = " << c2 << endl;

    return 0;
}

输出结果：
c1 = a - b = (2, 2)
c2 = 5 - b = (4, -2)

  1. 商店销售某一商品，商店每天公布统一的折扣（discount）。同时允许销售人员在销售时灵活掌握售价（price），在此基础上，对一次购10件以上者，还可以享受9.8折优惠。请编程序，计算出当日此商品的总销售款sum，以及每件商品的平均售价。要求用静态数据成员和静态成员函数。（提示：将折扣discount、总销售款sum和商品销售总件数n声明为静态数据成员，再定义静态成员函数average（求平均售价）和display（输出结果）。现已知当天3名销货员的销售情况为：
    销货员号（num）|销货件数（quantity）|销售单价（price）
    –|–|–
    101|5|23.5
    102|12|24.56
    103|100|21.5
#include <iostream>
using namespace std;

class Product {
private:
    static double discount; // 折扣
    static double sum;      // 总销售款
    static int n;           // 总销售数
    int num;                // 销售员号
    int quantity;           // 销售件数
    double price;           // 销售单价
public:
    Product(int n, int q, double p) :num(n), quantity(q), price(p) {}
    void sale() {
        double total = quantity * price;
        if (quantity > 10) {
            total *= discount;
        }
        sum += total;
        n += quantity;
    }
    static double average() {
        return sum / n;
    }
    static void display() {
        cout << "The total sales amount is " << sum;
        cout << ", and average is " << average() << endl;
    }
};
double Product::discount = 0.98;
double Product::sum = 0;
int Product::n = 0;

int main() {
    Product p1(101, 5, 23.5);
    Product p2(102, 12, 24.56);
    Product p3(104, 100, 21.5);

    p1.sale();
    p2.sale();
    p3.sale();

    Product::display();
    return 0;
}

输出结果：
The total sales amount is 2513.33, and average is 21.4814

  1. 有一个Time类，包含数据成员minute（分）和sec（秒），模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值，且对后置自增运算符的重载。

后置自增运算符：Time& operator(int);
前置自增运算符：Time& operator();

#include <iostream>
using namespace std;

class Time {
private:
    int minute;
    int sec;
public:
    Time(int m = 0, int s = 0) : minute(m), sec(s) {}
    void display() {
        cout << "time: " << minute << ":" << sec << endl;
    }
    Time& operator++(int) { // Time++
        sec++;
        if (sec >= 60) {
            minute += sec / 60;
            sec %= 60;
        }
        return *this;
    }
    Time& operator++() {    // ++Time
        sec++;
        if (sec >= 60) {
            minute += sec / 60;
            sec %= 60;
        }
        return *this;
    }
};

int main() {
    Time t(6, 50);
    t.display(); // 输出当前时间

    t++;         // 模拟时间流逝，自增1秒
    t.display(); // 输出当前时间

    ++t;         // 模拟时间流逝，自增1秒
    t.display(); // 输出当前时间

    return 0;
}

输出结果：
time: 6:50
time: 6:51
time: 6:52

Kk丶丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
华师计算机c++课程设计销售管理和实验报告
02-03
【标题】：“华师计算机c++课程设计销售管理和实验报告” 在这个C++课程设计中，学生将深入学习如何使用C++编程语言来构建一个销售管理系统。这个系统旨在模拟实际商业环境中的销售流程，包括商品的录入、库存管理...
C++考场管理系统课程设计
07-27
本篇将详细介绍一个基于C++语言编写的考场管理系统，该系统适用于课程设计参考，并且包含了完整的实验报告，是学习者提升C++编程技能的理想案例。该系统由Visual Studio 2019开发环境构建，充分体现了C++在实际项目...
计算机科学与技术|计算机信息管理课程实验|C++上机考试复习题1
HRD的博客
01-03 544
123.cpp #include<iostream> using namespace std; int main() { int n=6378; while(n) { printf("%d\n",n%10); n/=10; } system("pause"); } N升序排序.cpp #include<iostream> using namespace std; void main() { ...
华南师范大学|计算机信息管理课程实验2020真题
HRD的博客
01-03 2425
计算机管理课程实验 试题一 1.采用递归求解的方法,用倒序输出字符串系统,用户输入字符串程序运行后,将倒序输出 举例如下 Sample Input: abcdef Sample Output: fedcba 程序如下 C语言版： 方法一 #include <iostream> void p() { char c; //getchar()函数获取键盘输入的字符，以换行符结束 if((c=getchar()) != '\n') { //以堆栈的方式将输入的字符...
2022年华南师范大学自考本计算机信息管理课程实验
槿梵梵博客
05-08 637
2022年11月华南师范大学计算机信息管理-专科-计算机信息管理课程实验（一）
槿梵梵博客
11-15 631
如图6所示，按照要求输入文字，并将第一页标题字体设置为微软雅黑，62号，加粗，第二页幻灯片“目录”为微软雅黑，40号，加粗，“评分标准”和“结束页”是微软雅黑，30号，并且加入超链接。第三页插入图表如图6所示，表格的内外框线为黑色，1.5磅，第一列字体为宋体，18号，其余字体为宋体，14号。4)插入柱状图，标题的字体为黑体，加粗，字号18，横轴字体为黑体，字号12，其余字体默认，黑色；5)柱状图横轴为品种，纵轴为销量，销量的最大值为900，主要网格线为黑色，宽度为1磅；
2022年11月华南师范大学自考本科-计算机信息管理课程实验—《数据库系统原理》实践题目
槿梵梵博客
11-15 1476
INSERT INTO Student(sno,sname,gender,Birthday) VALUES('2021230','张怡','女','2002-01-01');INSERT INTO Student(sno,sname,gender,Birthday) VALUES('2021234','雷琳','女','2002-04-08');1采用create命令创建数据库 school，并用show命令查看目前存在哪些数据库；6、查看女学生参加了俱乐部的情况，包括学生名，性别，俱乐部名字。
计算机信息管理专业教学改革,计算机信息管理专业实践教学改革探索
weixin_34352565的博客
06-19 161
摘要:结合浙江长征职业技术学院计算机信息管理专业的实际情况及实践教学中存在的一些问题进行了分析,提出了几种关于实践教学和考核方法等教学环节的改革措施,就如何加强学生实践能力的培养进行了探索。关键词:高职;计算机信息管理;实践技能;实践教学;教学改革计算机信息管理专业是一个复合型的专业,专业建设上要注重与市场要求相结合,培养既懂技术又懂管理的复合型技术应用型人才,同时还注重学生综合素质的提高。学生动...
2022年11月华南师范大学自考本科-《计算机信息管理课程实验—C++程序设计》实践题目
槿梵梵博客
11-15 1749
4、编程定义一个Box(盒子)类，在该类定义中包括数据成员：length(长)、width(宽) 和height(高)。在main函数中，要求创建Box对象，实现对象的复制，并求盒子的体积。先将在字符串s中的字符按逆序存放到t串中，然后把s中的字符按正序连接到t串的后面。实践题目发布后，学生在规定时间内完成编程，以word文件方式提交答卷，文件以“序号+姓名+课程名.例如：当s中的字符串为 “ABCDE”时，则t中的字符串应为“EDCBAABCDE”。例如：若high的值为100，则函数的值为732。
C++学校人员信息管理系统课程设计.doc
04-28
C++学校人员信息管理系统课程设计 该课程设计是一个使用C++语言开发的学校人员信息管理系统，旨在为大一大二学生提供一个实践性强的课程设计项目。该系统的开发使用到了C++语言的基本语法操作，如链表、文件读写等...
计算机与程序设计基础C++课程教学大纲.pdf
04-01
此外，课程还提供了丰富的课外资源，如教学课件、微课程视频、实验指导和作业管理系统，促进师生互动和自我评估。 课程内容分为多个部分，包括计算机基础知识，如计算机的发展、信息表示、系统组成和算法设计；C++...
一个由C++写成的简单的命令行学生信息管理系统 大一Cpp课程实验课项目.zip
03-05
学校管理系统帮助提高学校的组织效率和信息管理水平。 人力资源管理系统（HRM）： 用于处理组织内的人事信息，包括员工招聘、培训记录、薪资管理、绩效评估等。HRM系统有助于企业更有效地管理人力资源，提高员工的...
深圳大学计算机系统(2)实验一,深圳大学-计算机系统-实验报告4：四子棋
weixin_42303803的博客
07-21 594
深圳大学-计算机系统-实验报告4：四子棋 深 圳 大 学 实 验 报 告 课程名称 计算机系统1 项目名称 简易版四子棋游戏设计 学 院 计算机与软件学院 专 业 指导教师 报 告 人 学号 实验时间 2017年5月8日 提交时间 2017年6月4日星期日 教务处制 一、实验目的与要求 (1)分析和理解试验指定的问题； (2)掌握子函数的编写与使用； (3)利用LC-3的汇编代码设计实现比较复杂程...
计算机信息管理基础考试试题,计算机信息管理基础考试大纲2013.doc
weixin_36261487的博客
07-11 154
计算机信息管理基础考试大纲一、课程名称：计算机信息管理基础二、课程代码三、课程性质：专业必修课程四、考核内容：1、数据库概述(数据、信息、数据库、数据库系统、数据库管理系统、数据模型、联系)数据与信息的概念与关系；数据库技术的发展历程、数据库系统的组成要素及数据库系统的特点；数据模型的基本概念、数据实体间的联系类型、常用的三种数据模型；关系数据库的基本概念、关系的基本特点及关系运算；关系的数据结构...
C++ 多态
最新发布
wxk2227814847的博客
07-10 500
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 398
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C语言-动态内存管理
m0_73605503的博客
07-07 1057
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++初探究（2）
Frenemy__的博客
07-09 1265
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
【C++】include头文件中双引号和尖括号的区别
qq_35902025的博客
07-10 170
总结来说，最佳实践是使用尖括号来包含标准库的头文件，以确保代码的可移植性和避免潜在的命名冲突。对于项目特定的头文件，使用双引号可以提供更多的灵活性，但需要确保包含路径的正确性。使用双引号时，如果当前目录或子目录中存在与标准库同名的文件，它将被优先包含，这可能会导致意外地覆盖标准库文件。使用双引号 " " 时，编译器首先会在当前文件所在的目录搜索头文件，如果找不到，然后才会在系统的目录中搜索。这些目录通常包含了编译器自带的库文件。使用双引号时，如果头文件的位置发生变化，可能需要修改代码中的包含路径。
c++课程设计图书管理学士学位论文.doc
06-29
该文档是一份关于C++课程设计的...这份C++课程设计论文深入探讨了面向对象编程在图书管理系统的应用，涵盖了数据库设计、用户交互以及C++语言的实践，对于理解C++编程以及图书馆信息管理系统的实现具有较高的参考价值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值