东华大学(C++)程序设计实验报告（代码详解版）
C++程序设计实验报告
（不完整版本。）
目录
实验1： C++程序设计初步
实验2： 类和对象（一）
实验3： 类和对象（二）
实验4： 运算符重载
实验5： 类模板和string字符串处理
实验6： 多态性和继承
实验7： 多态性和继承
实验8 输入输出流
实验9 C++工具
实验1： C++程序设计初步
一、实验目的
了解在C++编译系统（Visual C++6.0）上如何编辑、编译、连接和
运行一个C++程序。
通过运行简单的C++程序，初步了解C++源程序的结构和特点。
掌握简单C++程序的编写和调试方法。
理解数组的概念，掌握数组应用的一般方法。
理解指针的概念，掌握指针的使用。
掌握重载函数的定义方法。
能正确使用引用型变量。
二、实验内容
实验内容1
在Visual C++环境下编译和运行C++程序。
①先进入Visual C++6.0环境。
②在自己指定的子目录中建立一个名为test.cpp的新文件。
③从键盘输入以下程序：
int main()
{
int a,b;
c=a+b;
cout>> “a+b=”>>a+b;
}
④选择Build→Compile test.cpp命令，对此源程序进行编译。观察和分析
编译信息。
⑤根据编译信息指出的错误，修改程序。再进行编译，如果还有错，再重
复此过程，直到编译不出错为止。
⑥选择Build→Build test.exe命令，对程序进行连接，如果不出错，就会
生成可执行程序test.exe。
⑦选择Build→Execute test.exe命令，执行可执行程序test.exe。观察屏幕
的变化。在输出窗口应显示程序运行结果。
⑧分析结果是否正确，如果不正确或认为输出格式不理想，可以修改程序，
然后重新执行以上④和⑧步骤。
实验内容2
定义一个函数invert()，将数组a中的n个整数按相反顺序存放。程序实现要求如下：
①用数组作为函数形参实现该函数invert(int A[], int n)，函数调用时实参为数组。
②用数组作为函数形参实现该函数invert(int A[], int n)，函数调用时实参为指针。
③用指针作为函数形参实现该函数invert(int *A, int n)，函数调用时实参为数组。
④用指针作为函数形参实现该函数invert(int *A, int n)，函数调用时实参为指针。
实验内容3
编一个程序，用同一个函数名对n个数据进行从小到大排序，数据类型可以是整型、单精度型、双精度型。用重载函数实现。
实验内容4
对3个变量按由小到大顺序排序，要求使用变量的引用。
三、需求分析
实验内容1：
1.输入的形式和输入值的范围
提示输入变量的值之后，由用户通过标准输入（常为键盘）初始化变量。
根据代码实际，输入数据大小范围限定为 有符号整型数范围，即 int类型范围：-2*10^9 ~ 2*10^9 - 1（即 -2147483648 ~ +2147483647）
2.输出形式为："a + b = "
3.程序所能达到的功能：计算两个有符号整型数之和
4.测试数据：见第八部分之“实验内容1：”。
实验内容2：
1. 无输入，数组声明时初始化；
2. 将数组元素反序存放，并验证输出。
3. 测试数据：见第八部分之“实验内容2：”。
实验内容3：
1. 实验重载函数实现多个基本数据类型的数组元素大小排序算法；
2. 使用函数模板输出各个不同类型的数组元素。
3. 无输入，数组声明时初始化。
4. 测试数据：见第八部分之“实验内容3：”。
实验内容4：
1. 无输入（设定为3个整型数）；
2. 实现排序函数，要求使用引用传递。
3. 测试数据：见第八部分之“实验内容4：”。
四、概要设计
实验内容1：
本程序仅包含主函数main（）函数，用于程序执行：
直接输入整型变量a和b，输出a+b结果，熟悉并正确使用软件来编译、运行程序。
实验内容2：
本程序包含的函数 及其 功能设计分别为：
Main（）；程序执行入口，调用其他函数。
void invert1(int A[], int n); 函数作为形参
void invert2(int *A, int n); 指针作为形参
void print(int *A, int n); 输出数组元素，为显示函数
实验内容3：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
void mySort(int *A, int n); 排序函数，重载整型数组
void mySort(float *A, int n); 排序函数，重载单精度浮点型数组
void mySort(double *A, int n); 排序函数，重载双精度浮点型数组
template <class T>
void print(T *A, int n); 模板函数，格式化输出不同类型数组元素
实验内容4：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
template <class T>
void mySwap(T &,T &); 模板函数，引用传递调用实参进行数据交换
template <class T, const int n>
void mySort(T(&A)[n]); 模板函数，引用传递数组，排序数组元素
template <class T, const int n>
void print(T(&A)[n]); 模板函数，引用传递数组，格式化输出数组元素
五、详细设计
详见末尾“九、附录：代码”部分。
六、调试分析
调试正常。
七、使用说明
直接运行即可。
八、测试结果
实验内容1：
实验内容2：
实验内容3：
实验内容4：
九、附录：代码
实验内容1：
#include <iostream>
using namespace std;
int main(){
int a, b, c;
cout << "Input a:\n";
cin >> a;
cout << "Input b:\n";
cin >> b;
c = a + b;
cout << "a + b = " << a + b;
return 0;
}
实验内容2：
#include <iostream>
using namespace std;
void invert1(int A[], int n);
void invert2(int *A, int n);
void print(int *A, int n);
int const N = 11;
int main(){
int a[5][N] = { { 1,3,5,7,9,10,8,6,4,2,0 },{ 1,3,5,7,9,10,8,6,4,2,0 },
{ 1,3,5,7,9,10,8,6,4,2,0 },{ 1,3,5,7,9,10,8,6,4,2,0 },{ 1,3,5,7,9,10,8,6,4,2,0 } };
int *p[5] = { a[0],a[1],a[2],a[3],a[4] };
cout << "原始数据：\n";
print(a[0], N);
print(p[0], N);
cout << "函数形参，函数实参：\n";
invert1(a[1], N);
print(a[1], N);
print(p[1], N);
cout << "函数形参，指针实参：\n";
invert1(p[2], N);
print(a[2], N);
print(p[2], N);
cout << "指针形参，函数实参：\n";
invert2(a[3], N);
print(a[3], N);
print(p[3], N);
cout << "指针形参，指针实参：\n";
invert2(p[4], N);
print(a[4], N);
print(p[4], N);
return 0;
}
void invert1(int A[], int n) {
for ( int i = 0,j = n-1-i; i < j; ++i,--j) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
void invert2(int *A, int n) {
for ( int i = 0, j = n - 1 - i; i < j; ++i, --j) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
void print(int *A, int n) {
for (int i = 0; i < n; ++i) {
cout << A[i] << " ";
}
cout << endl;
}
实验内容3：
#include <iostream>
using namespace std;
void mySort(int *A, int n);
void mySort(float *A, int n);
void mySort(double *A, int n);
template <class T>
void print(T *A, int n);
int const N = 11;
int main() {
int a[N] = { 1,3,5,7,9,10,8,6,4,2,0 };
float b[N] = { 1.1,3.3,5.5,7.7,9.9,10.0,8.8,6.6,4.4,2.2,0.0 };
double c[N] = { 1.1,3.3,5.5,7.7,9.9,10.0,8.8,6.6,4.4,2.2,0.0 };
cout << "整型原始数据：\n";
print(a, N);
cout << "排序之后数据：\n";
mySort(a, N);
print(a, N);
cout << "单精度型原始数据：\n";
print(b, N);
cout << "排序之后数据：\n";
mySort(b, N);
print(b, N);
cout << "双精度型原始数据：\n";
print(c, N);
cout << "排序之后数据：\n";
mySort(c, N);
print(c, N);
return 0;
}
void mySort(int *A, int n) {//insertion sort
for (int i = 0; i + 1 < n ; ++i) {
int k = i;
for (int j = i + 1; j < n ; ++j) {
if (A[j] < A[i]) {
k = j;
}
}
if (k != i) {
int temp = A[k];
A[k] = A[i];
A[i] = temp;
}
}
}
void mySort(float *A, int n) {//insertion sort
for (int i = 0; i + 1 < n ; ++i) {
int k = i;
for (int j = i + 1; j < n ; ++j) {
if (A[j] < A[i]) {
k = j;
}
}
if (k != i) {
float temp = A[k];
A[k] = A[i];
A[i] = temp;
}
}
}
void mySort(double *A, int n) {//insertion sort
for (int i = 0; i + 1 < n ; ++i) {
int k = i;
for (int j = i + 1; j < n ; ++j) {
if (A[j] < A[i]) {
k = j;
}
}
if (k != i) {
double temp = A[k];
A[k] = A[i];
A[i] = temp;
}
}
}
template <class T>
void print(T *A, int n) {
for (int i = 0; i < n; ++i) {
cout << A[i] << " ";
}
cout << endl;
}
实验内容4：
#include <iostream>
using namespace std;
template <class T>
void mySwap(T &,T &);
int const N = 3;
template <class T, const int n>
void mySort(T(&A)[n]);
template <class T, const int n>
void print(T(&A)[n]);
int main() {
int num[N] = { 5,9,1 };
cout << N << "个变量原始数据为：\t";
print(num);
mySort(num);
cout << "排序过后，" << N << "个变量的数据为：\t";
print(num);
return 0;
}
template <class T>
void mySwap(T &a, T &b) {
T t = a;
a = b;
b = t;
}
template <class T,const int n>
void mySort(T (&A)[n]) {
for (int i = 0; i < n - 1; ++i) {
int k = i;
for (int j = i + 1; j < n; ++j) {
if (A[k] > A[j]) {
k = j;
}
}
if (k != i) {
mySwap(A[k], A[i]);
}
}
}
template <class T, const int n>
void print(T(&A)[n]) {
for (int i = 0; i < n; ++i) {
if (i != n - 1) { cout << A[i] << " "; }
else { cout << A[i] << endl; }
}
}
C++程序设计实验报告
实验2： 类和对象（一）
一、实验目的
掌握声明类的方法，类和类的成员的的概念以及定义对象的方法。
深入理解C++中类的封装性。
初步掌握用类和对象编制基于对象的程序。
掌握对象的各种成员的使用方法。
通过定义构造函数实现对象的初始化。
学习检查和调试基于对象的程序。
二、实验内容
实验内容1
有以下程序：
#include <iostream>
using namespace std;
class Time //定义Time类
{public: //数据成员为公用的
int hour;
int minute;
int sec;
};
int main( )
{ Time t1; //定义t1为Time类对象
cin>>t1.hour; //输入设定的时间
cin>>t1.minute;
cin>>t1.sec;
cout<<t1.hour<<“:”<<t1.minute<< “:”<<t1.sec<<endl; //输出时间
return 0;
}
改写程序，要求：
将数据成员改为私有的；
将输入和输出的功能改为由成员函数实现；
在类体内定义成员函数。
然后编译和运行程序。请分析什么成员应指定为公用的？什么成员应指定为私有的？什么函数最好放在类中定义？什么函数最好放在类外定义？
答：
（1）代码详见“九、附录：代码”之“实验内容1”部分。
（2）分析如下：
函数成员要作为对外接口，应指定为公用public；
数据成员要保护其隐私，应指定为私有private；
输入、输出、友元函数、运算符重载函数等成员函数，最好放在类中定义，因为要使用类中私有的数据成员。
这些函数的定义，可以直接在类中声明并实现，但是当函数体较大时，建议在类中声明，在类外实现。
全局方法/函数（比如：实现算法的函数），内联inline函数，普通函数等，最好放在类外定义。
实验内容2
分别给出如下的3个文件：
含类定义的头文件student.h，
//student.h （这是头文件，在此文件中进行类的声明）
class Student //类声明
{ public:
void display( ); //公用成员函数原型声明
private:
int num;
char name[20];
char sex;
};
包含成员函数定义的源文件student.cpp
//student.cpp //在此文件中进行函数的定义
#include <iostream>
#include “student.h” //不要漏写此行，否则编译通不过
void Student::display( ) //在类外定义display类函数
{ cout<<“num:”<<num<<endl;
cout<<“name:”<<name<<endl;
cout<<“sex:”<<sex<<endl;
}
包含主函数的源文件main.cpp。
为了组成一个完整的源程序，应当有包括主函数的源文件：
//main.cpp 主函数模块
#include <iostream>
#include “student.h” //将类声明头文件包含进来
int main( )
{Student stud; //定义对象
stud.display(); //执行stud对象的display函数
return 0;
}
请完善该程序，在类中增加一个对数据成员赋初值的成员函数set_value。上机调试并运行。
实验内容3
需要求3个长方柱的体积，请编一个基于对象的程序。数据成员包括length(长)、width(宽)、height(高)。要求用成员函数实现以下功能：
由键盘分别输入3个长方柱的长、宽、高；
计算长方柱的体积；
输出3个长方柱的体积。
请编程序，上机调试并运行。
三、需求分析
略。
四、概要设计
实验内容1：
本程序包含的函数或类 及其 功能设计分别为：
main（）函数，用于程序执行：
包含class Time类:
private数据成员：int hour;int minute;int sec;
public成员函数:
void init(); 初始化数据成员
void output();输出数据成员
实验内容2：
本程序包含的函数 及其 功能设计分别为：
Main（）；程序执行入口，调用其他函数。
4个文件：
Main.cpp,student.h,student.cpp和main.h
相关内容较为繁杂，具体详见末尾“九、附录：代码”之“实验内容2”。
实验内容3：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
包含class cuboid类:
Private 数据成员：
int Length; int Width; int Height; int Volume;int Area;
public 成员函数:
void initBox(const int& x, const int&, const int&); 初始化数据成员
void setVolume(); 计算体积
void setArea(); 计算表面积
void show(); 输出数据成员
五、详细设计
详见末尾“九、附录：代码”部分。
六、调试分析
调试正常。
七、使用说明
直接运行即可。
八、测试结果
实验内容1：
实验内容2：
实验内容3：
九、附录：代码
实验内容1：
#include <iostream>
using namespace std;
class Time{
private:
int hour;
int minute;
int sec;
public:
void init() { cin >> hour >> minute >> sec; }
void output(){ cout << hour << " : " << minute << " : " << sec << endl; }
};
int main(){
Time t;
t.init();
t.output();
return 0;
}
实验内容2：
Main.cpp代码如下：
#include "student.h"//将类声明头文件包含进来
#include <iostream>
using namespace std;
int main(){
Student stud; //定义对象
stud.set_value();
stud.display(); //执行stud对象的display函数
return 0;
}
main.h代码如下：
#pragma once
Student.h代码如下：
#ifndef PCH_H
#define PCH_H
// TODO: 添加要在此处预编译的标头
class Student //类声明
{
public:
void set_value(); //初始化
void display(); //公用成员函数原型声明
private:
int num;
char name[20];
char sex;
};
#endif //PCH_H
Student.cpp代码如下：
#include <iostream>
#include "student.h" //不要漏写此行，否则编译通不过
void Student::display() //在类外定义display类函数
{
std::cout << "num:" << num << std::endl;
std::cout << "name:" << name << std::endl;
std::cout << "sex:" << sex << std::endl;
}
void Student::set_value() {
std::cin >> num;
std::cin.get();
std::cin >> name;
std::cin.get();
std::cin >> sex;
}
实验二特别说明：
若是不能正常编译运行，还需要配置项目属性的预编译头，因为 VS2017默认使用的是pch.h,步骤如图：
实验内容3：
#include <iostream>
using namespace std;
class cuboid {
private:
int Length; //长度
int Width; //宽度
int Height; //高度
int Volume;
int Area;
public:
void initBox(const int& x, const int&, const int&); //设置尺寸
void setVolume(); //计算体积
void setArea(); //计算表面积
void show(); //输出信息，输出形式见“输出说明”
};
void cuboid::initBox(const int& x, const int& y, const int& z) {
Length = x;
Width = y;
Height = z;
}
void cuboid::setVolume() {
Volume = Length * Width * Height;
}
void cuboid::setArea() {
Area = 2 * (Length * Width + Length * Height + Width * Height);
}
void cuboid::show() {
cout << "长: "<< Length << " " << "宽: "<< Width << " " << "高: "<< Height << endl;
cout << "体积: " << Volume << endl;
cout << "表面积: "<< Area << endl;
}
int const N = 3;
int main() {
int intLength, intWidth, intHeight;
cuboid cub[N];
for (int i = 0; i < N; ++i) {
cout << "第" << i + 1 << "个长方体：" << endl;
cout << "请输入长: ";
cin >> intLength;
cout << "请输入宽: ";
cin >> intWidth;
cout << "请输入高: ";
cin >> intHeight;
cub[i].initBox(intLength, intWidth, intHeight);
cub[i].setVolume();
cub[i].setArea();
cub[i].show();
cout << endl;
}
return 0;
}
C++程序设计实验报告
实验3： 类和对象（二）
一、实验目的
进一步加深对类和对象的理解。
掌握类的构造函数和析构函数的概念和使用方法。
掌握对对象数组、对象的指针及其使用方法。
掌握友元的概念和使用。
了解类模板的使用方法。
二、实验内容
实验内容1
有以下程序：
#include <iostream.h>
class Student
{public:
Student(int n,float s):num(n),score(s){ }
void change(int n,float s){num=n;score=s;}
void display(){cout<<num<<“ ”<<score<<endl; }
private：
int num;
float score;
};
void main()
{Student stud(101,78.5);
stud.display();
stud.change(101,80.5);
stud.display();
}
阅读此程序，分析其执行过程，然后上机运行，对比输出结果。
修改上面的程序，增加一个fun函数，改写main函数。
在main函数中调用fun函数，在fun函数中调用change和display函数。
在fun函数中使用对象的引用（Student &）作为形参。
答：
（1）程序分析如下：
Mian函数为程序入口，开始执行；
先创建Student类对象stud并调用构造函数的初始化列表进行赋值，接着输出stud的数据成员num和score，数据分别为101和78.5；
再接着通过成员函数change修改成员数据，并在数据更新后再次输出，num和score依次分别为101和80.5。
对比：
程序运行结果详见“八、测试结果”之“实验内容1”部分。
运行结果与分析上述一致。
（2）程序修改：
具体代码详见“九、附录：代码”之“实验内容1”部分。
实验内容2
商店销售某一商品，商店每天公布统一的折扣（discount）。同时允许销售人员在销售时灵活掌握售价（price）,在此基础上，对一次购10件以上者，还可以享受9.8折优惠。现已知当天3个销售员销售情况为
销货员号（num） 销货件数(quantity) 销货单价（price）
101 5 23.5
102 12 24.56
103 100 21.5
请编程序，计算出当日此商品的总销售款sum以及每件商品的平均售价。要求用静态数据成员和静态成员函数。
（提示：将折扣discount，总销售款sum和商品销售总件数n声明为静态数据成员，再定义静态成员函数average（求平均售价）和display（输出结果）。
答：
已按照题目需求写好相关代码，满足静态限制条件。
具体代码详见“九、附录：代码”之“实验内容2”部分。
实验内容3
（3）有以下程序：
#include <iostream>
using namespace std;
class Date; //对Date类的提前引用声明
class Time //定义Time类
{public:
Time(int,int,int);
void display(Date &); //display是成员函数，形参是Date类对象的引用
private:
int hour;
int minute;
int sec;
};
class Date //声明Date类
{public:
Date(int,int,int);
friend void Time∷display(Date &); //声明Time中的display函数为友元成员函数
private:
int month;
int day;
int year;
};
Time∷Time(int h,int m,int s) //类Time的构造函数
{hour=h;
minute=m;
sec=s;
}
void Time∷display(Date &d) //display的作用是输出年、月、日和时、分、秒
{cout<<d.month<<“/”<<d.day<<“/”<<d.year<<endl; //引用Date类对象中的私有数据
cout<<hour<<“：”<<minute<<“：”<<sec<<endl; //引用本类对象中的私有数据
}
Date∷Date(int m,int d,int y) //类Date的构造函数
{month=m;
day=d;
year=y;
}
int main( )
{Time t1(10,13,56); //定义Time类对象t1
Date d1(12,25,2004); //定义Date类对象d1
t1.display(d1); //调用t1中的display函数，实参是Date类对象d1
return 0;
}
请分析和运行此程序，注意友元函数Time::display的作用。将程序中的display函数不放在Time类中，而作为类外的普通函数，然后分别在Time和Date类中将display声明为友元函数。在主函数中调用display函数，display函数分别引用Time和Date两个类的对象的私有数据，输出年、月、日和时、分、秒。修改后上机调试和运行。
答：
所给程序代码有标点错误，即 域名::符号使用了中文的了：：。
修改为两个类的友元函数，代码详见“九、附录：代码”之“实验内容3”部分。
实验内容4
有以下使用类模板程序：
#include <iostream>
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)?x:y;}
private:
numtype x,y;
};
int main( )
{Compare<int> cmp1(3,7); //定义对象cmp1，用于两个整数的比较
cout<<cmp1.max( )<< “is the Maximum of two integer numbers.”<<endl;
cout<<cmp1.min( )<< “is the Minimum of two integer numbers. ”<<endl<<endl;
Compare<float> cmp2(45.78,93.6); //定义对象cmp2，用于两个浮点数的比较
cout<<cmp2.max( )<< “is the Maximum of two float numbers. ”<<endl;
cout<<cmp2.min( )<< “is the Minimum of two float numbers. ”<<endl<<endl;
Compare<char> cmp3(′a′,′A′); //定义对象cmp3，用于两个字符的比较
cout<<cmp3.max( )<< “is the Maximum of two characters. ”<<endl;
cout<<cmp3.min( )<< “is the Minimum of two characters. ”<<endl;
return 0;
}
运行此程序，体会类模板的作用。
将它改写为在类模板外定义各成员函数。
答：
（一） 类模板的作用：使得类的实现不关注数据元素的具体类型，而只关注类所需要实现的功能，因而可以减少不必要的重的代码工作。
（二） 程序已做修改：代码详见“九、附录：代码”之“实验内容4”部分。
三、需求分析
略。
四、概要设计
实验内容1：
本程序包含的函数或类 及其 功能设计分别为：
main（）函数，用于程序执行：
包含class Student{}类:
private数据成员：int num; float score;
public成员函数:
Student(int n, float s); 构造函数，初始化参数列表初始化数据成员
void change(int n, float s); 修改数据成员数值
void display(); 输出数据成员
实验内容2：
本程序包含的函数 及其 功能设计分别为：
Main（）；程序执行入口，调用其他函数。
包含class saleGoods{}类
Private 数据成员：
string num; //货号
double price; //销售单价
static int quantity; //销售件数
static double discount; //折扣价
static double sum; //总销售款
static double average; //每件商品的平均售价
public 成员函数:
class Time 中：
void setSaleGoods(string num, int quantity, double price); 赋值操作
void setSum(); 计算sum
static void setAverage(); 计算average
void display(); 输出相关数据
实验内容3：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
包含class Date{} 和 class Time{}两个类
Private 数据成员：
class Time 中：int hour; int minute; int sec;
class Date 中： int month; int day; int year;
public 成员函数:
class Time 中：
Time(int, int, int); 构造函数，初始化相关数据成员
class Date 中：
Date(int, int, int); 构造函数，初始化相关数据成员
两个类都有的，友元函数：
friend void display(Date &, Time &); 输出函数
实验内容4：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
template<class numtype>
class Compare{} 类模板，实现不同数据类型的相同功能的类
Private 数据成员：numtype x, y;
public 成员函数:
Compare(numtype a, numtype b); 构造函数，初始化数据成员
numtype max(); 经比较大小，返回较大数据成员
numtype min(); 经比较大小，返回较小数据成员
只不过要熟练掌握模板类的实现写法，形式、格式有所要求。
五、详细设计
详见末尾“九、附录：代码”部分。
六、调试分析
调试正常。
七、使用说明
直接编译运行即可。
八、测试结果
实验内容1：
实验内容2：
实验内容3：
实验内容4：
九、附录：代码
实验内容1：
#include <iostream>
using namespace std;
class Student{
public:
Student(int n, float s) :num(n), score(s) { }
void change(int n, float s) { num = n; score = s; }
void display() { cout << num << " " << score << endl; }
private:
int num;
float score;
};
void fun(Student& );
int main(){
Student stud(101, 78.5);
fun(stud);
return 0;
}
void fun(Student& stud){
stud.display();
stud.change(101, 80.5);
stud.display();
}
实验内容2：
#include <iostream>
#include <string>
using namespace std;
class saleGoods {
private:
string num; //货号
//int quantity; //销售件数
double price; //销售单价
static int quantity; //销售件数
static double discount; //折扣价
static double sum; //总销售款
static double average; //每件商品的平均售价
public:
//static int quantity; //销售件数,main函数等类外调用,不可设为private私有保护
void setSaleGoods(string num, int quantity, double price) {
this->num = num; saleGoods::quantity = quantity; this->price = price;
}
//void setSaleGoods(string num, double price) {
// this->num = num; this->price = price;
//}
void setSum();
static void setAverage();
void display() { cout << "总销售款sum: " << saleGoods::sum << "\n每件商品的平均售价: " << " " << saleGoods::average << endl; }
};
int saleGoods::quantity = 0;
double saleGoods::discount = 0.98;
double saleGoods::sum = 0;
double saleGoods::average = 0;
void saleGoods::setAverage() {
saleGoods::average = saleGoods::sum / saleGoods::quantity;
}
void saleGoods::setSum() {
if (saleGoods::quantity > 10) {
saleGoods::sum = saleGoods::quantity * price * saleGoods::discount;
}
else {
saleGoods::sum = saleGoods::quantity * price;
}
}
int const N = 3;
int main() {
string num;
int quantity;
double price;
saleGoods sg[N];
for (int i = 0; i < N; ++i) {
cout << "请输入第"<<i+1<<"个销货员的相关数据：\n" << "销货员号（num）: ";
cin >> num;
cout << "销货件数(quantity): ";
cin >> quantity;
cout << "销货单价（price): ";
cin >> price;
sg[i].setSaleGoods(num, quantity, price);
//sg[i].setSaleGoods(num, price);
//saleGoods::quantity = quantity; //static int quantity;在类外调用静态数据成员的话，要将其设为public属性
sg[i].setSum();
saleGoods::setAverage();
sg[i].display();
cout << endl;
}
return 0;
}
//当 静态成员变量未有初始化时，有以下报错：
//error LNK2001: 无法解析的外部符号 “private: static int ETH::m_age” (?m_age@ETH@@0HA)
实验内容3：
#include <iostream>
using namespace std;
class Date; //对Date类的提前引用声明
class Time //定义Time类
{
public:
Time(int, int, int);
//void display(Date &); //display是成员函数，形参是Date类对象的引用
friend void display(Date &, Time &);
private:
int hour;
int minute;
int sec;
};
class Date //声明Date类
{
public:
Date(int, int, int);
//friend void Time::display(Date &); //声明Time中的display函数为友元成员函数
friend void display(Date &, Time &);
private:
int month;
int day;
int year;
};
Time::Time(int h, int m, int s) //类Time的构造函数
{
hour = h;
minute = m;
sec = s;
}
//void Time::display(Date &d) //display的作用是输出年、月、日和时、分、秒
void display(Date &d,Time &t)
//特此强调说明，一定要通过对象调用私有数据成员
{
cout << d.month << " / " << d.day << " / " << d.year << endl; //引用Date类对象中的私有数据
cout << t.hour << "：" << t.minute << "：" << t.sec << endl; //引用本类对象中的私有数据
}
Date::Date(int m, int d, int y) //类Date的构造函数
{
month = m;
day = d;
year = y;
}
int main()
{
Time t1(10, 13, 56); //定义Time类对象t1
Date d1(12, 25, 2004); //定义Date类对象d1
//t1.display(d1); //调用t1中的display函数，实参是Date类对象d1
display(d1,t1);
return 0;
}
实验内容4：
#include <iostream>
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) ? x : y;
//}
private:
numtype x, y;
};
//template<class numtype> class Compare{}说明了 Compare只是类的模板，而不是一个实实在在的类，故不能直接用于创建对象
//需要先 类模板实例化（即 指定好数据类型），然后再用于创建对象。
int main(){
Compare<int> cmp1(3, 7); //定义对象cmp1，用于两个整数的比较
cout << cmp1.max() << " is the Maximum of two integer numbers." << endl;
cout << cmp1.min() << " is the Minimum of two integer numbers." << endl << endl;
Compare<float> cmp2(45.78, 93.6); //定义对象cmp2，用于两个浮点数的比较
cout << cmp2.max() << " is the Maximum of two float numbers." << endl;
cout << cmp2.min() << " is the Minimum of two float numbers." << endl << endl;
Compare<char> cmp3('a', 'A'); //定义对象cmp3，用于两个字符的比较
cout << cmp3.max() << " is the Maximum of two characters." << endl;
cout << cmp3.min() << " is the Minimum of two characters." << endl;
return 0;
}
//在类模板外定义成员函数，应写成类模板形式：
//template <class 虚拟类型参数>
//函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) { … }
template<class numtype>
Compare<numtype> :: Compare(numtype a, numtype b) {
x = a; y = b;
}
template<class numtype>
numtype Compare<numtype> :: max() {
return (x > y) ? x : y;
}
template<class numtype>
numtype Compare<numtype> :: min() {
return (x < y) ? x : y;
}
C++程序设计实验报告
实验4： 运算符重载
一、实验目的
进一步了解运算符重载的概念和使用方法。
掌握几种常用的运算符重载的方法。
了解转换构造函数的使用方法。
了解在Visual C++6.0环境下进行运算符重载要注意的问题。
二、实验内容
事先编写好程序，上机调试和运行程序，分析结果。
实验内容1
声明一个复数类Complex，重载运算符 “+”、 “-”、 “*”、 “/”，使之能用于复数的加、减、乘、除，运算符重载函数作为Complex类的成员函数。编程序，分别求两个复数之和、差、积和商。
请思考：你编的程序能否用于一个整数与一个复数的算术运算？如4+（5-2i）
答：
还不能。由于运算符重载函数的形参只有复数类的对象的引用，故只能够用于都为复数形式的数之间进行相关运算。
不过程序代码可改进，即 通过重载函数实现多种形参，把整数作为形参进行设计即可，具体内容详见 “实验内容2”部分.
实验内容2
声明一个复数类Complex，重载运算符 “+”,使之能用于复数的加法运算。参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。例如：c1+c2，i+c1, c1+i，均合法（设i为整数，c1，c2为复数）。
运行程序，分别求两个复数之和、整数和复数之和。
实验内容3
有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符 “+”，使之能用于矩阵相加。如c=a+b。如c=a+b。
实验内容4
声明一个Teacher（教师）类和一个Student（学生）类，二者有一部分数据成员是相同的，例如num(号码)，name(姓名)，sex(性别).。编写程序，将一个Student对象（学生）转换为Teacher(教师)类，只将以上3个相同的数据成员移植过去。可以设想为：一位大学生大学毕业了，留校担任教师，他原有的部分数据对现在的教师身份来说仍然是有用的，应当保留并成为其教师的一部分。
三、需求分析
略。
四、概要设计
实验内容1：
本程序包含的函数或类 及其 功能设计分别为：
main（）函数，用于程序执行：
包含class Complex类:
private数据成员：
double real; 实部
double imag; 虚部
public成员函数:
Complex(int real ,int imag ):real(real),imag(imag) { }
Complex(double real =.0, double imag=.0 ) 构造函数，初始化数据成员
Complex operator+(Complex& ); + 运算符重载函数
Complex operator-(Complex& ); - 运算符重载函数
Complex operator*(Complex& ); * 运算符重载函数
Complex operator/(Complex &); / 运算符重载函数
void display(); 输出数据成员
相关内容具体详见末尾“九、附录：代码”之“实验内容1”。
实验内容2：
本程序包含的函数 及其 功能设计分别为：
Main（）；程序执行入口，调用其他函数。
在实验内容1的基础上增加相关设计，即
Complex operator+(int& i);
成员函数即可实现，复数在运算符右边，整型数数在右边
friend Complex operator+(int&, Complex& );
友元函数实现整型数在运算符左边，复数在右边
同理 可设计出其他的运算符的相关函数。
相关内容较为繁杂，具体详见末尾“九、附录：代码”之“实验内容2”。
实验内容3：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
包含class Matrix类:
Private 数据成员：
public 成员函数:
void input(); 输入函数，初始化数据成员
friend Matrix operator+(Matrix &, Matrix &); 友元函数实现运算符重载
friend Matrix operator-(Matrix &, Matrix &); 友元函数实现运算符重载
void display(); 输出数据成员
相关内容具体详见末尾“九、附录：代码”之“实验内容3”。
实验内容4：
本程序包含的函数及其功能设计为：
Main（）；程序执行入口，调用其他函数。
包含class Student类; 和 class Teacher类;
Private 数据成员：
class Student类:
int num; 号码 string name; 姓名
char sex; 性别 float score; 成绩
class Teacher类:
int num; 号码 string name; 姓名
char sex; 性别 float pay; 薪水
public 成员函数:
class Student类:
Student(){} 构造函数用于初始化数据成员
Student(int& , string& , char& , float& );
int get_num() { return num; } 返回数据成员 号码 num
string get_name() { return name; } 返回数据成员 姓名 name
char get_sex() { return sex; } 返回数据成员 性别 sex
void display(); 输出数据成员
class Teacher类:
Teacher() {} 构造函数用于初始化数据成员
Teacher(int& , string& , char& , float& );
Teacher(Student& ); 复制构造函数，实现student留校任教变为teacher
void set_pay(float& ); 修改数据成员 薪水 pay
void display(); 数据成员的输出函数
需要注意的是，教师类class Teacher除了要有设计一个复制构造函数 Teacher::Teacher(Student& student);
还要给 数据成员 薪水 pay 设计相关赋值函数。
相关内容具体详见末尾“九、附录：代码”之“实验内容4”。
五、详细设计
详见末尾“九、附录：代码”部分。
六、调试分析
调试正常。
七、使用说明
直接运行即可。
八、测试结果
实验内容1：
实验内容2：
实验内容3：
实验内容4：
九、附录：代码
实验内容1：
#include<iostream>
using namespace std;
class Complex{
public:
Complex(int real ,int imag ):real(real),imag(imag) { }
Complex(double real =.0, double imag=.0 ) { this->real = real; this->imag = imag; }
//Complex(Complex& c){ this->real = c.real; this->imag = c.imag; }
Complex operator+(Complex& );
Complex operator-(Complex& );
Complex operator*(Complex& );
Complex operator/(Complex &);
void display();
private:
double real;
double imag;
};
// (a+bi)+(c+di)=(a+c)+(b+d)i
Complex Complex::operator +(Complex &c2){
Complex c;
c.real = real + c2.real;
c.imag = imag + c2.imag;
return c;
}
// (a+bi)-(c+di)=(a-c)+(b-d)i
Complex Complex::operator -(Complex &c2){
Complex c;
c.real = real - c2.real;
c.imag = imag - c2.imag;
return c;
}
// (a+bi)(c+di)=(ac-bd)+(ad+bc)i
Complex Complex::operator *(Complex &c2){
Complex c;
c.real = real * c2.real - imag * c2.imag;
c.imag = real * c2.imag + imag * c2.real;
return c;
}
// (a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +((bc-ad)/(c^2+d^2))i
// *this / c2
Complex Complex::operator /(Complex &c2){
Complex c;
c.real = (real*c2.real + imag * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
c.imag = (imag*c2.real - real * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
return c;
}
void Complex::display(){
cout << "( " << real << " , " << imag << "i )" << endl;
}
int main(){
Complex c1(1, -2), c2(3, 4), c3;
cout << "c1 = "; c1.display();
cout << "c2 = "; c2.display();
cout << endl;
c3 = c1 + c2;
cout << "c1 + c2 = "; c3.display();
cout << endl;
c3 = c1 - c2;
cout << "c1 - c2 = "; c3.display();
cout << endl;
c3 = c1 * c2;
cout << "c1 * c2 = "; c3.display();
cout << endl;
c3 = c1 / c2;
cout << "c1 / c2 = "; c3.display();
cout << endl;
return 0;
}
实验内容2：
#include<iostream>
using namespace std;
class Complex{
public:
Complex(int real ,int imag ):real(real),imag(imag) { }
Complex(double real =.0, double imag=.0 ) { this->real = real; this->imag = imag; }
//Complex(Complex& c){ this->real = c.real; this->imag = c.imag; }
Complex operator+(Complex& );
Complex operator+(int& i);
friend Complex operator+(int&, Complex& );
Complex operator-(Complex& );
Complex operator-(int & );
friend Complex operator-(int& , Complex& );
Complex operator*(Complex& );
Complex operator*(int& );
friend Complex operator*(int&, Complex& );
Complex operator/(Complex &);
Complex operator/(int&);
friend Complex operator/(int&, Complex&);
void display();
private:
double real;
double imag;
};
// (a+bi)+(c+di)=(a+c)+(b+d)i
Complex Complex::operator +(Complex &c2){
Complex c;
c.real = real + c2.real;
c.imag = imag + c2.imag;
return c;
}
// 复数右加整数
Complex Complex::operator +(int &i) {
Complex c, c2(i);
c.real = real + c2.real;
c.imag = imag + c2.imag;
return c;
}
// 复数左加整数
Complex operator+(int& i, Complex& c) {
return c + i;
}
// (a+bi)-(c+di)=(a-c)+(b-d)i
Complex Complex::operator -(Complex &c2){
Complex c;
c.real = real - c2.real;
c.imag = imag - c2.imag;
return c;
}
//复数减整数
Complex Complex::operator-(int &i) {
Complex c, c2(i);
c.real = real - c2.real;
c.imag = imag - c2.imag;
return c;
}
// 整数减复数
Complex operator-(int& i, Complex& cTemp) {
Complex c,c1(i), c2(cTemp);
c.real = c1.real - c2.real;
c.imag = c1.imag - c2.imag;
return c;
}
// (a+bi)(c+di)=(ac-bd)+(ad+bc)i
Complex Complex::operator *(Complex &c2){
Complex c;
c.real = real * c2.real - imag * c2.imag;
c.imag = real * c2.imag + imag * c2.real;
return c;
}
// 复数乘以整数
Complex Complex::operator *(int &i) {
Complex c, c2(i);
c.real = real * c2.real - imag * c2.imag;
c.imag = real * c2.imag + imag * c2.real;
return c;
}
// 整数乘以复数
Complex operator *(int& i, Complex& cTemp) {
Complex c, c1(i), c2(cTemp);
c.real = c1.real * c2.real - c1.imag * c2.imag;
c.imag = c1.real * c2.imag + c1.imag * c2.real;
return c;
}
// (a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +((bc-ad)/(c^2+d^2))i
// *this / c2
Complex Complex::operator /(Complex &c2){
Complex c;
c.real = (real*c2.real + imag * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
c.imag = (imag*c2.real - real * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
return c;
}
// 复数除以整数
Complex Complex::operator /(int &i) {
Complex c, c2(i);
c.real = (real*c2.real + imag * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
c.imag = (imag*c2.real - real * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
return c;
}
// 整数除以复数
Complex operator /(int& i, Complex& cTemp) {
Complex c, c1(i), c2(cTemp);
c.real = (c1.real*c2.real + c1.imag * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
c.imag = (c1.imag*c2.real - c1.real * c2.imag) / (c2.real*c2.real + c2.imag*c2.imag);
return c;
}
void Complex::display(){
cout << "( " << real << " , " << imag << "i )" << endl;
}
int main(){
Complex c1(1, -2), c2(3, 4), c3;
int i = 3;
cout << "c1 = "; c1.display();
cout << "c2 = "; c2.display();
cout << "i = " << i << endl << endl;
c3 = c1 + c2;
cout << "c1 + c2 = "; c3.display();
c3 = c1 + i;
cout << "c1 + i = "; c3.display();
c3 = i + c1;
cout << "i + c1 = "; c3.display();
cout << endl;
c3 = c1 - c2;
cout << "c1 - c2 = "; c3.display();
c3 = c1 - i;
cout << "c1 - i = "; c3.display();
c3 = i - c1;
cout << "i - c1 = "; c3.display();
cout << endl;
c3 = c1 * c2;
cout << "c1 * c2 = "; c3.display();
c3 = c1 * i;
cout << "c1 * i = "; c3.display();
c3 = i * c1;
cout << "i * c1 = "; c3.display();
cout << endl;
c3 = c1 / c2;
cout << "c1 / c2 = "; c3.display();
c3 = c1 / i;
cout << "c1 / i = "; c3.display();
c3 = i / c1;
cout << "i / c1 = "; c3.display();
cout << endl;
return 0;
}
实验内容3：
#include <iostream>
using namespace std;
int const n = 2;
int const m = 3;
class Matrix {
public:
Matrix();
friend Matrix operator+(Matrix &, Matrix &);
friend Matrix operator-(Matrix &, Matrix &);
//friend Matrix operator*(Matrix &, Matrix &);
//friend Matrix operator/(Matrix &, Matrix &);
void input();
void display();
private:
int mat[n][m];
};
Matrix::Matrix(){
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
mat[i][j] = 0;
}
Matrix operator+(Matrix &a, Matrix &b){
Matrix c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c.mat[i][j] = a.mat[i][j] + b.mat[i][j];
}
}
return c;
}
Matrix operator-(Matrix &a, Matrix &b){
Matrix c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c.mat[i][j] = a.mat[i][j] - b.mat[i][j];
}
}
return c;
}
void Matrix::input(){
cout << "input value of matrix: ( " << n << " X " << m << " )" << endl;
int i, j;
for (i = 0; i < n; i++){
for (j = 0; j < m; j++){
cin >> mat[i][j];
}
}
}
void Matrix::display() {
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
cout << mat[i][j] << " ";
}
cout << endl;
}
}
int main(){
Matrix a, b, c;
a.input();
b.input();
cout << endl << "Matrix a:" << endl;
a.display();
cout << endl << "Matrix b:" << endl;
b.display();
c = a + b;
cout << endl << "Matrix c = Matrix a + Matrix b :" << endl;
c.display();
c = a - b;
cout << endl << "Matrix c = Matrix a - Matrix b :" << endl;
c.display();
return 0;
}
实验内容4：
#include <iostream>
#include <string>
using namespace std;
class Student{
public:
Student(){}
Student(int& , string& , char& , float& );
int get_num() { return num; }
string get_name() { return name; }
char get_sex() { return sex; }
void display();
private:
int num;
string name;
char sex;
float score;
};
Student::Student(int& num, string& name, char& sex, float& score){
this->num = num;
this->name = name;
this->sex = sex;
this->score = score;
}
void Student::display() {
cout << "num: " << num << "\nname: " << name << "\nsex: " << sex << "\nscore: " << score << "\n\n";
}
class Teacher{
public:
Teacher() {}
Teacher(Student& );// 留校担任教师。。
Teacher(int& , string& , char& , float& );
void set_pay(float& );
void display();
private:
int num;
string name;
char sex;
float pay;
};
Teacher::Teacher(int& num, string& name, char& sex, float& pay) {
this->num = num;
this->name = name;
this->sex = sex;
this->pay = pay;
}
Teacher::Teacher(Student& student){
num = student.get_num();
name = student.get_name();
sex = student.get_sex();
}
void Teacher::set_pay(float& pay) {
this->pay = pay;
}
void Teacher::display(){
cout << "num: " << num << "\nname: " << name << "\nsex: " << sex << "\npay: " << pay << "\n\n";
}
int main(){
int num;
string name;
char sex;
float score, pay;
cout << "Input Student`s Message:\n";
cout << "num(int): ";
cin >> num;
cin.get();
cout << "name(string): ";
getline(cin ,name);
cout << "sex(char): ";
cin >> sex;
cout << "score(float): ";
cin >> score;
Student student(num, name, sex, score);
cout << endl;
cout << "student:" << endl;
student.display();
cout << "As A Teacher,Input Pay:\n";
Teacher teacher(student);
cout << "pay(float): ";
cin >> pay;
teacher.set_pay(pay);
cout << "teacher:" << endl;
teacher.display();
return 0;
}
C++程序设计实验报告
实验5： 类模板和string字符串处理
一、实验目的
进一步理解类模板的概念。
掌握类模板的定义、实例化过程。
掌握类模板运用的运用，进一步理解C++中代码重用思想。
理解C++中的string类。
使用C++标准类库中的string定义字符串对象。
能使用string类成员函数、操作符对字符串对象进行各种操作。
二、实验内容
事先编写好程序，上机调试和运行程序，分析结果。
实验内容1
定义一个通用队列模板类，队列中数据元素类型可以是字符型、双精度型和其他数据类型。队列的基本操作包括队列初始化、队列的析构、进队列、出队列、判断队列是否为空、判断队列是否为满队列等，并测试该队列。
实验内容2
编写程序，对输入文件中的内容进行分析，统计文件的行数、单词数和每