面向对象编程的C++，和平时做题用的C++还是有差距的。实验的题目都是小题目，就都做一下吧。
实验一 简单C＋＋程序设计
1、 猜价格游戏
编写C++程序完成以下功能：
（1） 假定有一件商品，程序用随机数指定该商品的价格（1-1000的整数）；
（2） 提示用户猜价格，并输入：若用户猜的价格比商品价格高或低，对用户作出相应的提示；
（3） 直到猜对为止，并给出提示。
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
int main() {
srand((int)time());
int price=rand()%+;//产生1到1000的随机数
int l=,r=;
while() {
cout<<"您可以猜一个价格，当前范围["<<l<<","<<r<<"]的整数。"<<endl;
int guess;
cin>>guess;
if(guess>||guess<||cin.fail()) {
cout<<"输入不合法，请重新输入"<<endl;
cin.clear();
cin.ignore(,'\n');
continue;
}
if(guess>price) {
cout<<"猜大了"<<endl;
if(r>guess)
r=guess;//缩小范围
} else if(guess<price) {
cout<<"猜小了"<<endl;
if(l<guess)
l=guess;//缩小范围
} else {
cout<<"您猜对了，价格就是"<<price<<endl;
break;
}
}
return ;
}
实验问题
- 如何产生随机数
通过srand((int)time(0));生成随机数种子
然后用rand()%1000+1来产生1到1000的随机数 - 是否要提示当前范围
为了人性化，每次猜了一个价格，就会根据猜大了或者小了来缩小下一次猜的范围。但是如果用户输入的数字不在当前范围内，则不改变猜的范围。 - 如果输入的不是数字怎么办
cin.fail()为真则代表输入失败然后就
cout<<"输入不合法，请重新输入"< cin.clear();
cin.ignore(10000,'\n');
continue;
（可是这样真麻烦，后面的程序就不写了）
2、 计算 N 以内的所有素数
编写C++程序完成以下功能：
（1） 提示用户输入N；
（2） 计算出从2到N之间的所有素数；
（3） 将结果保存在一个文本文件中。
#include <iostream>
#include <cstring>
#include <fstream>
#define N 1000000
using namespace std;
int prime[N],cnt,n;
void getPrime(){
for(int i=;i<=n;i++){
if(!prime[i])prime[++cnt]=i;
for(int j=;j<=cnt&&prime[j]<=N/i;j++){
prime[prime[j]*i]=;
if(i%prime[j]==)break;
}
}
}
int main(){
ofstream f("prime.txt");
cout<<"请输入n"<<endl;
cin>>n;
getPrime();
for(int i=;i<=cnt;i++)
f<<prime[i]<<" ";
f.close();
return ;
}
3、 袋中取球
编写C++程序完成以下功能（使用 enum）：
（1） 袋子中有 red, yellow, blue, white, black 五种颜色的球多个；
（2） 一次从袋子里取出3个颜色不同的球，有几种取法；
（3） 将每种方法的所有取法输出到屏幕上。
#include <iostream>
using namespace std;
enum ball{
red,yellow,blue,white,black
};
void output(int i){
switch(i){
case red:cout<<"red ";break;
case yellow:cout<<"yellow ";break;
case blue:cout<<"blue ";break;
case white:cout<<"white ";break;
case black:cout<<"black ";break;
}
} int main(){
for(int i=red;i<=black;i++)
for(int j=i+;j<=black;j++)
for(int k=j+;k<=black;k++){
output(i);
output(j);
output(k);
cout<<endl;
}
return ;
}
4、 乘法口诀表
编写C++程序完成以下功能：
（1） 输出乘法口诀表；
（2） 显示格式如下所示。
1*1=1 1*2=2 1*3=3 1*4=4 1*5=5 1*6=6 1*7=7 1*8=8 1*9=9
2*2=4 2*3=6 2*4=8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
3*3=9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
6*6=36 6*7=42 6*8=48 6*9=54
7*7=49 7*8=56 7*9=63
8*8=64 8*9=72
9*9=81
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
for(int i=;i<=;i++){
for(int j=;j<=i*;j++)
cout<<" ";
for(int j=i;j<=;j++)
cout<<i<<"*"<<j<<"="<<setw()<<left<<i*j;
cout<<endl;
}
}
5、 最大公约数和最小公倍数
编写C++程序完成以下功能：
（1） 提示用户输入两个无符号整数；
（2） 计算两者的最大公约数和最小公倍数，并输出。
#include <iostream>
#define uint unsigned int
using namespace std; uint gcd(uint a,uint b){
return b?gcd(b,a%b):a;
}
int main(){
uint a,b;
cout<<"请输入两个无符号整数"<<endl;
cin>>a>>b;
cout<<a<<"和"<<b<<"的最大公约数是"<<gcd(a,b);
cout<<",最小公倍数是"<<b/gcd(a,b)*a<<endl;
return ;
}
6、 计算Fibonacci级数
fib(1) = fib(2) = 1
fib(n) = fib(n-1) + fib(n-2)
分别编写递归和非递归的C++程序完成以下功能：
（1） 提示用户输入整数n；
（2） fib(n)，并输出结果。
//递归
#include <iostream>
using namespace std;
int fib(int x){
if(x==||x==)return ;
return fib(x-)+fib(x-);
}
int main(){
int n;
cout<<"请输入整数n"<<endl
cin>>n;
cout<<"fib("<<n<<")="<<fib(n)<<endl;
return ;
}
//非递归
#include <iostream>
using namespace std;
int fib(int x){
int a=,b=;
for(int i=;i<=x;i++){
int t=b;
b+=a;
a=t;
}
return b;
}
int main(){
int n;
cout<<"请输入整数n"<<endl;
cin>>n;
cout<<"fib("<<n<<")="<<fib(n)<<endl;
return ;
}
7、 计算n 阶勒让德多项式
编写C++程序完成以下功能：
（1） 提示用户输入整数n和实数x；
（2） Pn(x)，并输出结果。
aaarticlea/png;base64,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*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*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" alt="" name="对象1" width="409" height="105" align="absmiddle" />
#include <iostream>
using namespace std;
double p(int n,int x){
if(!n)return ;
if(n==)return x;
return ((*n-)*p(n-,x)-(n-)*p(n-,x))/n;
}
int main(){
int n,x;
cout<<"请输入n、x"<<endl;
cin>>n>>x;
cout<<"Pn("<<x<<")="<<p(n,x)<<endl;
return ;
}
实验二 类与对象
1、 矩形
编写C++程序完成以下功能：
（1） 定义一个Point类，其属性包括点的坐标，提供计算两点之间距离的方法；
（2） 定义一个矩形类，其属性包括左上角和右下角两个点，提供计算面积的方法；
（3） 创建一个矩形对象，提示用户输入矩形左上角和右下角的坐标；
（4） 观察矩形对象以及Point类成员的构造函数与析构函数的调用；
（5） 计算其面积，并输出。
#include <iostream>
#include <cstdlib>
using namespace std;
class Point {
private:
int x,y;
public:
Point(int _x=,int _y=):x(_x),y(_y) {};
Point(Point &p):x(p.x),y(p.y) {};
~Point() {};
int disX(const Point &b) {
return b.x-x;
};
int disY(const Point &b) {
return b.y-y;
}
}; class Rectangle {
private:
Point a,b;
public:
Rectangle(Point _a,Point _b):a(_a),b(_b) {};
Rectangle(int ax=,int ay=,int bx=,int by=):a(ax,ay),b(bx,by) {}
Rectangle(Rectangle &r):a(r.a),b(r.b) {};
~Rectangle() {
cout<<"hh"<<endl;
};
int area() {
return abs(a.disX(b)*a.disY(b));
};
}; int main() {
cout<<"请输入矩形的左上角和右下角坐标(整数)"<<endl;
int ax,ay,bx,by;
while() {
cin>>ax>>ay>>bx>>by;
if(ax>bx||ay<by||cin.fail()) {
cout<<"输入的矩形不合法"<<endl;
cin.clear();
cin.ignore(,'\n');
} else {
Rectangle myRectangle(ax,ay,bx,by);
cout<<"该矩形的面积为"<<myRectangle.area()<<endl;
break;
}
}
return ;
}
实验问题
- 构造函数和析构函数写在哪？
写在public里（声明必须在..里，定义里外都可以） - 析构函数里面要写什么？
留空就可以了吧，如果有动态申请的内存就delete掉 - 拷贝构造函数怎么写？
Point(Point &p){ x=p.x;y=p.y; };
或者
Point(Point &p):x(p.x),y(p.y){}; - 编译错误提示 call of overloaded `Point()' is
ambiguous
Point()构造时，Point(){};和Point(int _x=0,int _y=0):x(_x),y(_y){};都可以被调用，于是就被overloaded了。 - 编译错误提示 In member function int
Rectangle::area()':
int Point::x' is private
因为x是Point类的私有成员，不能在Rectangle类里面使用，关于x的计算函数都要写在Point类的public里。 - 初始化时Rectangle myRectangle=Rectangle（ax,ay,bx,by）;报错.
应该为Rectangle myRectangle(ax,ay,bx,by); - 析构函数怎么调用
不用显式调用，需要显式时：p.~Point();即可
2、 圆形
编写C++程序完成以下功能：
（1） 定义一个Point类，其属性包括点的坐标，提供计算两点之间距离的方法；
（2） 定义一个圆形类，其属性包括圆心和半径；
（3） 创建两个圆形对象，提示用户输入圆心坐标和半径，判断两个圆是否相交，并输出结果。
#include <iostream>
#include <cmath>
#define sqr(x) ((x)*(x))
using namespace std; class Point{
private:
int x,y;
public:
Point(int x=,int y=):x(x),y(y){}
double dis(Point &b)const{
return sqrt(sqr(x-b.x)+sqr(y-b.y));
}
};
class Circle{
private:
Point c;
double r;
public:
Circle(int x=,int y=,double r=):c(x,y),r(r){}
double dis(Circle &b)const{
return c.dis(b.c);
}
double getR()const{
return r;
}
};
int main(){
int x,y,r;
cout<<"请输入a 圆心坐标半径"<<endl;
cin>>x>>y>>r;
Circle a(x,y,r);
cout<<"请输入b 圆心坐标半径"<<endl;
cin>>x>>y>>r;
Circle b(x,y,r);
if(a.dis(b)<=a.getR()+b.getR())
cout<<"两圆相交"<<endl;
else
cout<<"两圆相离"<<endl;
return ;
}
3、 友元
编写C++程序完成以下功能：
（1） 定义一个Boat和Car两个类，他们都具有私用属性——重量；
（2） 编写一个函数，计算两者的重量和。
double TotalWeight(Boat& b, Car& c);
#include <iostream>
using namespace std;
class Car;
class Boat {
private:
double weight;
public:
Boat() {};
Boat(double w=):weight(w) {};
~Boat() {};
friend double TotalWeight(Boat&,Car&);
}; class Car {
private:
double weight;
public:
Car() {};
Car(double w=):weight(w) {};
~Car() {};
friend double TotalWeight(Boat&,Car&);
};
double TotalWeight(Boat& b,Car& c) {
return b.weight+c.weight;
}
int main() {
cout<<"请输入Boat、Car的重量"<<endl;
while() {
double bw,cw;
cin>>bw>>cw;
if(cin.fail()) {
cout<<"输入不合法"<<endl;
cin.clear();
cin.ignore(,'\n');
} else {
Boat myBoat(bw);
Car myCar(cw);
cout<<"Boat和Car的总重量为"<<TotalWeight(myBoat,myCar)<<endl;
break;
}
}
return ;
}
实验问题
- 什么时候需要用友元？
当一个函数要用到这个类时（可能还有其他类）的私有成员，但是它不是这个类独享的函数，调用时不需要通过对象或指针。 - 友元函数定义在哪？
定义在主函数外面，类定义后面，要加上friend然后声明在类的公有属性里。
4、 分数
编写C++程序完成以下功能：
（1） 定义一个分数类，他们都具有私用属性——分子和分母；
（2） 定义分数类的构造函数和析构函数；
（3） 定义方法Set，设置分子和分母；
（4） 定义方法print，打印分数，格式如：2/7；
（5） 定义方法value，返回double型的分数值；
（6） 定义方法invert, 分子和分母交换。
#include <iostream>
using namespace std; class Fractions{
private:
int num,den;
public:
Fractions(int n=,int d=):num(n),den(d){}
~Fractions(){}
void set(int n,int d){
num=n;den=d;
}
void print(){
cout<<num<<"/"<<den<<endl;
}
double value(){
return num*1.0/den;
}
void invert(){
int t=den;
den=num;
num=t;
}
};
int main(){
return ;
}
实验三 数组与指针
1、 矩阵（一）
编写C++程序完成以下功能：
（1） 假定矩阵大小为4×5（整型数组表示）；
（2） 定义矩阵初始化函数，可以从cin中输入矩阵元素；
（3） 定义矩阵输出函数，将矩阵格式化输出到cout；
（4） 定义矩阵相加的函数，实现两个矩阵相加的功能,结果保存在另一个矩阵中；
（5） 定义矩阵相减的函数，实现两个矩阵相减的功能,结果保存在另一个矩阵中；
（6） 定义三个矩阵：A1、A2、A3；
（7） 初始化A1、A2；
（8） 计算并输出：A3 = A1加A2，A3 = A1减A2。
#include <iostream>
#define ROW 4
#define COL 5
using namespace std;
class Matrix {
private:
int mat[ROW][COL];
public:
Matrix() {};
void init() {
cout<<"please input the Matrix(4 row and 5 col)"<<endl;
for(int i=; i<ROW; i++)
for(int j=; j<COL; j++)
cin>>mat[i][j];
}
void output() {
cout<<"The Matrix:"<<endl;
for(int i=; i<ROW; i++) {
for(int j=; j<COL; j++)
cout<<mat[i][j]<<"\t";
cout<<endl;
}
}
void add(Matrix &a,Matrix &b) {
for(int i=; i<ROW; i++)
for(int j=; j<COL; j++)
mat[i][j]=a.mat[i][j]+b.mat[i][j];
}
void sub(Matrix &a,Matrix &b) {
for(int i=; i<ROW; i++)
for(int j=; j<COL; j++)
mat[i][j]=a.mat[i][j]-b.mat[i][j];
}
};
int main() {
Matrix A1,A2,A3;
A1.init();
A2.init();
A3.add(A1,A2);
A3.output();
A3.sub(A1,A2);
A3.output();
return ;
}
2、 矩阵（二）
编写C++程序完成以下功能：
（1） 假定矩阵大小为4×5（整型）；
（2） 矩阵空间采用new动态申请，保存在指针中；
（3） 定义矩阵初始化函数，可以从cin中输入矩阵元素；
（4） 定义矩阵输出函数，将矩阵格式化输出到cout；
（5） 定义矩阵相加的函数，实现两个矩阵相加的功能,结果保存在另一个矩阵中；
（6） 定义矩阵相减的函数，实现两个矩阵相减的功能,结果保存在另一个矩阵中；
（7） 动态申请三个矩阵：A1、A2、A3；
（8） 初始化A1、A2；
（9） 计算并输出A3 = A1加A2，A3 = A1减A2；
（10） 释放矩阵空间。
#include <iostream>
#include <cstdio>
#include <cstring>
const int row = ;
const int col = ;
using namespace std;
bool malloc_array(int **&a,int row,int col) {
a=new int *[row];
if(a==NULL) {
cout<<"error:no enough space"<<endl;
return ;
}
for(int i=; i<row; i++) {
*(a+i)=new int[col];
if(a+i==NULL) {
cout<<"error:no enough space"<<endl;
return ;
}
}
return ;
}
class Matrix
{
private:
int **mat;
public:
Matrix()
{
malloc_array(mat, row, col);
}
Matrix(Matrix &b)
{
if(malloc_array(mat, row, col))
for(int i = ; i < row; i++)
for(int j = ; j < col; j++)
mat[i][j] = b.mat[i][j];
}
~Matrix()
{
for(int i = ; i < row; i++)
delete [] *(mat + i);
delete [] mat;
mat = NULL;
}
void input()
{
cout << "please input the Matrix:" << endl;
for(int i = ; i < row; i++)
for(int j = ; j < col; j++)
cin >> mat[i][j];
}
void output()
{
for(int i = ; i < row; i++)
{
for(int j = ; j < col; j++)
cout << mat[i][j] << "\t";
cout << endl;
}
}
void cal(Matrix &a, Matrix &b, int op)
{
for(int i = ; i < row; i++)
for(int j = ; j < col; j++)
mat[i][j] = a.mat[i][j] + b.mat[i][j] * op;
}
};
int main()
{
Matrix *A1 = new Matrix();
A1->input();
Matrix *A2 = new Matrix();
A2->input();
Matrix *A3 = new Matrix();
A3->cal(*A1, *A2, );
cout << "Matrix A1 + Matrix A2 =" << endl;
A3->output();
A3->cal(*A1, *A2, -);
cout << "Matrix A1 - Matrix A2 =" << endl;
A3->output();
A1->~Matrix();
A2->~Matrix();
A3->~Matrix();
A1 = NULL;
A2 = NULL;
A3 = NULL;
return ;
}
实验问题
- 动态分配内存？
定义：int **mat;
分配：
mat=new int *[ROW];
for(int i=0; i *(mat+i)=new int[COL];
加上判断是否分配成功 - 释放空间？
for(int i=0;i delete [] *(mat+i);
delete [] mat;
3、 矩阵（三）
编写C++程序完成以下功能：
（1） 用类来实现矩阵，定义一个矩阵的类，属性包括：
- 矩阵大小，用 lines, rows（行、列来表示）；
- 存贮矩阵的数组指针，根据矩阵大小动态申请（new）。
（2） 矩阵类的方法包括：
- 构造函数，参数是矩阵大小，需要动态申请存贮矩阵的数组；
- 析构函数，需要释放矩阵的数组指针；
- 拷贝构造函数，需要申请和复制数组；
- 输入，可以从cin中输入矩阵元素；
- 输出，将矩阵格式化输出到cout；
- 矩阵相加的函数，实现两个矩阵相加的功能,结果保存在另一个矩阵类，但必须矩阵大小相同；
- 矩阵相减的函数，实现两个矩阵相减的功能,结果保存在另一个矩阵类，但必须矩阵大小相同。
（3） 定义三个矩阵：A1、A2、A3；
（4） 初始化A1、A2；
（5） 计算并输出A3 = A1加A2，A3=A1减A2；
（6） 用new动态创建三个矩阵类的对象：pA1、pA1、pA3；
（7） 初始化pA1、pA2；
（8） 计算并输出pA3=pA1加pA2，pA3=pA1减pA2；
（9） 释放pA1、pA1、pA3。
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
bool malloc_array(int **&a,int row,int col) {
a=new int *[row];
if(a==NULL) {
cout<<"error:no enough space"<<endl;
return ;
}
for(int i=; i<row; i++) {
*(a+i)=new int[col];
if(a+i==NULL) {
cout<<"error:no enough space"<<endl;
return ;
}
}
return ;
}
class Matrix {
private:
int **mat;
int row,col;
public:
Matrix(int _row=,int _col=):row(_row),col(_col) {
malloc_array(mat,row,col);
}
Matrix(Matrix &b):row(b.getRow()),col(b.getCol()) {
if(malloc_array(mat,row,col))
for(int i=; i<row; i++)
for(int j=; j<col; j++)
mat[i][j]=b.mat[i][j];
}
~Matrix() {
for(int i=; i<row; i++)
delete [] *(mat+i);
delete [] mat;
mat=NULL;
}
int getRow() {
return row;
}
int getCol() {
return col;
}
void input() {
cout<<"please input the Matrix:"<<endl;
for(int i=; i<row; i++)
for(int j=; j<col; j++)
cin>>mat[i][j];
}
void output() {
for(int i=; i<row; i++) {
for(int j=; j<col; j++)
cout<<mat[i][j]<<"\t";
cout<<endl;
}
}
int cal(Matrix &a,Matrix &b,int op) {
if(a.getRow()!=b.getRow()||a.getCol()!=b.getCol()) {
cout<<"error:These two Matrix don't have the same size."<<endl;
return ;
}
for(int i=; i<row; i++)
for(int j=; j<col; j++)
mat[i][j]=a.mat[i][j]+b.mat[i][j]*op;
return ;
}
};
int main() {
int row,col;
cout<<"please input Matrix A1's row and col:"<<endl;
cin>>row>>col;
Matrix *pA1=new Matrix(row,col);
pA1->input();
cout<<"please input Matrix A2's row and col:"<<endl;
cin>>row>>col;
Matrix *pA2=new Matrix(row,col);
pA2->input();
Matrix *pA3=new Matrix(row,col);
if(pA3->cal(*pA1,* pA2,)) {
cout<<"Matrix A1 + Matrix A2 ="<<endl;
pA3->output();
pA3->cal(*pA1,* pA2,-);
cout<<"Matrix A1 - Matrix A2 ="<<endl;
pA3->output();
}
pA1->~Matrix();
pA2->~Matrix();
pA3->~Matrix();
pA1=NULL;
pA2=NULL;
pA3=NULL;
return ;
}
实验问题
- line和row，不应该是row和col吗？
那就用row和col - 加减的函数基本一样，我可以写在一起吗？
其实用了乘法会降低速度，不过，这种同一级别的计算量，差别微小。 - 拷贝函数怎么写
里面不能用memcpy(mat,b.mat,sizeof mat); - 遇到错误error: passing ‘const Matrix’ as ‘this’
argument discards qualifiers [-fpermissive] in call to ‘int
Matrix::getRow()’
这是因为const型的Matrix参数要调用getRow，要在getRow的大括号前加上const。不过这个const型的Matrix参数我改回引用了。 - 怎么释放
显式调用析构函数，再将指针指向NULL
4、 字符串翻转
编写C++程序完成以下功能：
（1） 输入一段字符串；
（2） 将字符串翻转以后输出（不要利用库函数）。
#include <iostream>
using namespace std; int main(){
char s[];
cin>>s;
int len;
for(len=;s[len];len++);
len--;
for(int i=;i<=len/;i++){
char c=s[i];
s[i]=s[len-i];
s[len-i]=c;
}
cout<<s;
return ;
}
5、 函数指针
实现二分法求解方程。编写以下函数求方程 f(x)=0的解：
double RolveRoot(double (*pf)(double x), double a, double b, int n)；
其中pf是一个函数指针（指向f(x)），RolveRoot()，用来获得f(x)=0在区间[a，b]内的解，f(x)的形式如 f(x)=x*x-3x+6等。a,b指定了方程 f(x)=0解存在的区间。n是迭代次数，次数越多，精度越高。
二分法的步骤：
（1） 计算 f(a) 、f(b)、f((a+b)/2)；
（2） 若f(a)与f((a+b)/2)异号，则在[a，(a+b)/2]区间内有解，令b = (a+b)/2, 回到第一步继续迭代，直到到达足够精度；
（3） 否则，令a = (a+b)/2, 回到第一步继续迭代，直到到达足够精度。
实现RolveRoot()，并采用不同 f(x) 验证。
#include <iostream>
using namespace std;
double RolveRoot(double (*pf)(double x), double a, double b, int n){
double fa,fm;
for(int i=;i<=n;i++){
double m=(a+b)/;
fa=pf(a);
fm=pf(m);
if(fa*fm<)b=m;
else a=m;
}
return a;
}
double f1(double x){
return x*+;
}
double f2(double x){
return x+;
}
int main(){
cout<<RolveRoot(f1,-,,)<<endl;
cout<<RolveRoot(f2,-,,)<<endl;
return ;
}
实验四 继承与派生
1、 形状（一）
编写C++程序完成以下功能：
（1） 声明一个基类Shape（形状），其中包含一个方法来计算面积；
（2） 从Shape派生两个类矩形和圆形；
（3） 从矩形派生正方形；
（4） 分别实现派生类构造函数、析构函数和其他方法；
（5） 创建派生类的对象，观察构造函数、析构函数调用次序；
（6） 不同对象计算面积。
#include <iostream>
#include <cmath>
#define output(a) cout<<"The Area of "<<#a<<" is "<<a.getArea()<<endl
using namespace std;
const double pi=acos(-1.0);
class Shape {
public:
double getArea();
};
class Rectangle: public Shape {
private:
int w,h;
public:
Rectangle(int _w=,int _h=):w(_w),h(_h) {}
~Rectangle() {}
double getArea() {
return w*h;
} };
class Square:public Rectangle {
private:
int a;
public:
Square(int _a=):a(_a) {}
~Square() {}
double getArea() {
return a*a;
}
};
class Circle:public Shape {
private:
int r;
public:
Circle(int _r=):r(_r) {}
~Circle() {}
double getArea() {
return pi*r*r;
}
};
int main() {
Circle c();
Square s();
Rectangle r(,);
output(c);
output(s);
output(r);
return ;
}
实验问题
- 基类要面积这个参数吗，怎么计算面积？
不用，不用计算，只是有这个方法放在那。 - 怎么继承，区别是什么？
公有继承，父类的私有成员都是不可访问，公有成员只有公有继承时是都可访问，私有继承则只能类内访问。
2、 形状（二）——虚函数
（1） 将【形状（一）】 中的基类计算面积的方法定义为虚函数，比较与【形状（一）】程序的差异；
（2） 将【形状（一）】中的基类定义抽象类，比较与【形状（一）】程序的差异。
#include <iostream>
#include <cmath>
using namespace std;
const double pi=acos(-1.0);
class Shape {
public:
virtual double getArea()=;
};
class Rectangle: public Shape {
private:
int w,h;
public:
Rectangle(int _w=,int _h=):w(_w),h(_h) {}
~Rectangle() {}
double getArea() {
return w*h;
}
};
class Square:public Rectangle {
private:
int a;
public:
Square(int _a=):a(_a) {}
~Square() {}
double getArea() {
return a*a;
}
};
class Circle:public Shape {
private:
int r;
public:
Circle(int _r=):r(_r) {}
~Circle() {}
double getArea() {
return pi*r*r;
}
};
int main() {
Shape *ptr[];
ptr[]=new Circle();
ptr[]=new Square();
ptr[]=new Rectangle(,);
for(int i=; i<=; i++)
cout<<"The Area of Shape "<<i<<" is "<<ptr[i]->getArea()<<endl;
return ;
}
实验问题
- 虚函数是什么？
C++的虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。
子类可以重写父类的虚函数实现子类的特殊化。 - 虚函数程序差异在哪里？
在函数前面加了个virtual 关键字 - 抽象类是什么？
就是不能new出对象的类，有纯虚函数，“只提供声明，没有实现”，是对子类的约束，是“接口继承”。
抽象类的区别？
虚函数基础上在基类中不给定义函数，只声明。体现了面向对象编程的多态性。
3、 高斯消去法解线性方程组（选做）
阅读理解和掌握教材第7.6节实例，编程实现用高斯消去法解线性方程的程序，并且上机调试通过。
#include <iostream>
#define N 100
using namespace std;
void Gauss(double c[][N],int n,int cnt){
if(cnt<n){
cout<<"无穷个解"<<endl;
return ;
}
for(int i=,s=;i<cnt&&s<n;i++){
int r=i;
while(c[r][i]==&&r<cnt)r++;
if(c[r][i]){
swap(c[r],c[i]);
for(int j=i+;j<cnt;j++){
double t=c[j][i]/c[i][i];
for(int k=i;k<=n;k++)
c[j][k]-=c[i][k]*t;
}
s++;
}else{
for(int j=i;j<cnt;j++)if(c[j][n]){
cout<<"无解"<<endl;
return;
}
cout<<"无穷个解"<<endl;
return;
}
}
double x[N];
for(int i=n-;i>=;i--){
x[i]=c[i][n]/c[i][i];
for(int j=;j<i;j++){
c[j][n]-=x[i]*c[j][i];
c[j][i]=;
}
}
for(int i=;i<n;i++)
cout<<x[i]<<" ";
cout<<endl;
}
int main(){
int n,m;
cout<<"请输入变量个数"<<endl;
cin>>n;
cout<<"请输入方程个数"<<endl;
cin>>m;
cout<<"请输入系数矩阵"<<endl;
double mat[N][N];
for(int i=;i<m;i++)
for(int j=;j<=n;j++)
cin>>mat[i][j];
Gauss(mat,n,m);
return ;
}
实验五 多态性
1、 对Point类重载＋＋和――运算符
编写C++程序完成以下功能：
（1） Point类的属性包括点的坐标（x，y）；
（2） 实现 Point类重载＋＋和――运算符：
- ++p，--p，p++，p--。
- ＋＋和――分别表示x，y增加或减少1。
#include<iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point(int x=,int y=):x(x),y(y){}
Point(Point &b):x(b.x),y(b.y){}
Point operator++(int){//p++
Point t(x,y);
x++;
y++;
return t;
}
Point operator++(){//++p
x++;
y++;
return *this;
}
Point operator--(int){//p--
Point t(x,y);
x--;
y--;
return t;
}
Point operator--(){//--p
x--;
y--;
return *this;
}
Point operator+(Point &b){
Point t(x+b.x,y+b.y);
return t;
}
void out(){
cout<<"("<<x<<","<<y<<")"<<endl;
}
};
int main(){
Point p(,);
(p++).out();
p.out();
(++p).out();
p.out();
(p--).out();
p.out();
(--p).out();
p.out();
return ;
}
实验问题
- 如何实现左右的两种不同运算？
重载 operator++ 和 operator--时带一个 int 参数表示后缀，不带参数表示前缀 - 怎么验证运算符？
通过(++p).out()来输出验证。
2、 实现复数类的运算重载
编写C++程序完成以下功能：
（1） 实现复数类的运算重载：＋，－，*，/，^（乘方）。
#include <iostream>
using namespace std;
class Complex{
private:
double re,im;
public:
Complex(double r=,double i=):re(r),im(i){}
Complex(Complex &b):re(b.re),im(b.im){}
~Complex(){}
Complex operator +(Complex &b){
Complex t(re+b.re,im+b.im);
return t;
}
Complex operator -(Complex &b){
Complex t(re-b.re,im-b.im);
return t;
}
Complex operator *(Complex &b){
Complex t(re*b.re-im*b.im,re*b.im+im*b.re);
return t;
}
Complex operator /(Complex &b){
double t=im*im+b.im*b.im;
Complex a((re*b.re+im*b.im)/t,(im*b.re-re*b.im)/t);
return a;
}
Complex operator ^(int b){
Complex t(*this);
for(int i=;i<b;i++)
t=t*(*this);
return t;
}
void out(){//我自己加了严格的输出要求
if(re){
cout<<re;
if(im>)cout<<"+";
}
if(im==-)cout<<"-";
else if(im!=)cout<<im;
if(im)cout<<"i";
cout<<endl;
}
};
int main(){
int r,i;
cout<<"请输入a的实部和虚部"<<endl;
cin>>r>>i;
Complex a(r,i);
cout<<"请输入b的实部和虚部"<<endl;
cin>>r>>i;
Complex b(r,i);
cout<<"a*b=";
(a*b).out();
cout<<"a+b=";
(a+b).out();
cout<<"a/b=";
(a/b).out();
cout<<"a-b=";
(a-b).out();
cout<<"a^3=";
(a^).out();
return ;
}
3、 参考【实验二】中分数类，为分数类重载运算符，使之能够进行＋，－，*，/，^（乘方）的运算。
#include <iostream>
using namespace std; class Fractions{
private:
int num,den;
public:
Fractions(int n=,int d=):num(n),den(d){}
Fractions(Fractions &b):num(b.num),den(b.den){}
~Fractions(){}
Fractions operator +(Fractions &b){
Fractions t(num+b.num,den+b.den);
return t;
}
Fractions operator -(Fractions &b){
Fractions t(num-b.num,den-b.den);
return t;
}
Fractions operator *(Fractions &b){
Fractions t(num*b.num,den*b.den);
return t;
}
Fractions operator /(Fractions &b){
Fractions a(num*b.den,den*b.num);
return a;
}
Fractions operator ^(int b){
Fractions t(*this);
for(int i=;i<b;i++)
t=t*(*this);
return t;
}
void set(int n,int d){
num=n;den=d;
}
void print(){
cout<<num<<"/"<<den<<endl;
}
};
int main(){
Fractions a(,),b(,);
(a/b).print();
return ;
}
4、 参考【实验三】中矩阵（三），重载运算符＋和－，实现矩阵的加减。（懒得做了- -）
5、 求积分（选做）（懒得做了- -）
阅读理解和掌握教材第8.5节实例，编程实现求函数定积分的程序，并且上机调试通过
实验六 流式IO
1、 流式IO（一）
编写C++程序完成以下功能：
（1） 使用ofstream 向一个文本文件中输出各种类型的数据，并打开文件观察结果：
- 整数、无符号整型、长整型、浮点型、字符串、……
（2） 用十进制、八进制、十六进制方式向文本文件中输出整数；
（3） 使用控制符和成员函数来控制输出的格式：
- set（） precision() ...
#include <iostream>
#include <iomanip>
#include <fstream> using namespace std;
int main(){
int hh=;
unsigned int un=;
long l=;
double d=123.533456780123; ofstream f("out.txt");
f<<"整数："<<hh<<endl;
f<<"无符号整型："<<un<<endl;
f<<"长整型："<<l<<endl;
f<<"浮点型："<<d<<endl;
f<<"我是一个字符串"<<endl;
f.close(); cout <<showbase;//显示进制的格式
cout<<"十进制："<<hh<<endl;
cout<<"十六进制："<<hex<<hh<<endl;
cout<<"八进制："<<oct<<hh<<endl;
cout<<"回到十进制："<<dec<<hh<<endl<<endl; cout<<"精度10位:"<<setprecision()<<d<<endl;
cout<<"当前精度："<<cout.precision()<<endl;
cout<<"定点小数："<<fixed<<d<<endl ;
return ;
}
2、 流式IO（二）
编写C++程序完成以下功能：
（1） 输入一个文本文件名
（2） 使用ofstream 向一个二进制文件中输出各种类型的数据，并打开文件观察结果：
- 整数、无符号整型、长整型、浮点型、字符串、……
#include <iostream>
#include <iomanip>
#include <fstream> using namespace std;
int main(){
int hh=;
unsigned int un=;
long l=;
double d=123.533456780123; char file[];
cout<<"请输入文件名"<<endl;
cin>>file;
ofstream f(file, ios::binary);
f<<"整数："<<hh<<endl;
f<<"无符号整型："<<un<<endl;
f<<"长整型："<<l<<endl;
f<<"浮点型："<<d<<endl;
f<<"我是一个字符串"<<endl;
f.close();
return ;
}
3、 流式IO（三）
编写C++程序完成以下功能：
（1） 输入一个文本文件名；
（2） 打开文件名，在该文件的每一行前面加上一个行号，保存在另外一个文本文件中。
#include <iostream>
#include <cstdio>
#include <string>
#include <fstream>
using namespace std;
int main(){
char file[];
cout<<"请输入文件名"<<endl;
cin>>file;
ifstream in(file);
if(!in){
cout<<"文件打开失败!\n";
return ;
}
ofstream out("out.txt");
if(!out){
cout<<"文件打开失败!\n";
return ;
} int i=;
string s;
/*另一种实现方式
cout<<i++<<" ";
while(in>>s){
cout<<s;
if(in.peek()=='\n')cout<<endl<<i++<<" ";
}*/
while(getline(in,s))
cout<<i++<<s<<endl;
in.close();
out.close();
return ;
}
实验问题
- 怎么读入一行？
一是用string库函数的getline，另一种是通过判断peek()=='\n'。
实验七 C＋＋程序设计应用
1、 电话本
编写C++程序完成以下功能：
（1） 实现简单电话本功能，用姓名来搜索电话号码；
（2） 用户输入姓名，程序查找并输出结果；
（3） 用户可以通过输入，添加姓名和电话号码；
（4） 用户可以删除姓名和电话号码；
（5） 电话本可以保存在指定文件中；
（6） 电话可被从指定文件中读入到内存。
#include <iostream>
#include <string>
#include <fstream>
using namespace std;
class People{
private:
string name,tel;
public:
People* next;
People(string n="\0",string t="\0"):name(n),tel(t){next=NULL;}
People(People& p):name(p.name),tel(p.tel){}
~People(){next=NULL;}
string Name(){return name;}
string Tel(){return tel;}
}; string n,t;
char op,file[];
class TelBook{
private:
People *head,*p;
public:
TelBook(){head=p=NULL;}
~TelBook(){
People *tp;
while(head!=NULL){
tp=head->next;
delete head;
head=tp;
}
p=NULL;
head=NULL;
}
void find(string n){
People *q=head;
while(q!=NULL){
if(q->Name()==n){
cout<<"找到了（下一个? y/n）"<<q->Name()<<": "<<q->Tel()<<endl;
while(cin>>op){
if(op=='n'||op=='N')return;
if(op=='y'||op=='Y')break;
}
}
q=q->next;
}
cout<<"已遍历结束，找不到了。"<<endl;
}
void add(string n,string t){
People *q=p;
p=new People(n,t);
if(q!=NULL)q->next=p;
else head=p;
cout<<"添加了一条记录"<<endl;
}
void remove(string n){
People *last=NULL,*q=head;
while(q!=NULL){
if(q->Name()==n){
cout<<"是否删除（y/n(下一个)）"<<q->Name()<<": "<<q->Tel()<<endl;
while(cin>>op){
if(op=='n'||op=='N')break;
if(op=='y'||op=='Y'){
if(head==q)
head=p=NULL;
else{
last->next=q->next;
if(p==q)p=last;
}
q->~People();
cout<<"删除成功"<<endl;
break;
}
}
}
last=q;
q=q->next;
}
cout<<"已遍历结束。"<<endl;
}
void input(){
cout<<"请输入需要打开电话本的文件名:"<<endl;
cin>>file;
ifstream in(file);
if(!in){
cout<<"文件打开失败!\n";
return;
}
while(in>>n>>t) add(n,t);
cout<<"电话本打开成功!"<<endl;
in.close();
}
void output(){
cout<<"请输入需要保存电话本的文件名："<<endl;
cin>>file;
ofstream out(file);
if(!out){
cout<<"文件打开失败!\n";
return;
}
People *q=head;
while(q!=NULL){
out<<q->Name()<<" "<<q->Tel()<<endl;
q=q->next;
}
cout<<"电话本保存成功！"<<endl;
out.close();
}
}b;
int main(){
while(){
cout<<"（1）打开电话本（2）保存电话本（3）查找（4）添加（5）删除"<<endl;
while(cin>>op && (op<''||op>''));
switch(op){
case '':b.input();break;
case '':b.output();break;
case '':
cout<<"请输入需要查找的姓名："<<endl;
cin>>n;
b.find(n);
break;
case '':
cout<<"请输入姓名 电话："<<endl;
cin>>n>>t;
b.add(n,t);
break;
case '':
cout<<"请输入需要删除的人的姓名："<<endl;
cin>>n;
b.remove(n);
break;
default:break;
}
}
return ;
}
实验问题
- 用什么实现删除、插入数据？
很容易想到链表，于是在电话本这个类里面就有一个head指针指向开头和p指针指向最后一个。 - 电话号码用整型？
不行，不但是因为位数不够，还有可能有前导0或短线。 - 删除时，也需要查找，是否调用find？
不好，因为需要另外传递参数，这样find的设计就变复杂了，而且在指针传参时，没有改变指针的值，所以干脆在remove函数里另外写过查找。 - error: no matching function for call to
'std::basic_ifstream::open(std::string&)
原因是C++的string类无法作为open的参数，string file 改为char file[1000]。