「c++小学期」实验题目及代码

面向对象编程的C++，和平时做题用的C++还是有差距的。实验的题目都是小题目，就都做一下吧。

实验一 简单C＋＋程序设计

1、  猜价格游戏

编写C++程序完成以下功能：

（1）      假定有一件商品，程序用随机数指定该商品的价格（1-1000的整数）；

（2）      提示用户猜价格，并输入：若用户猜的价格比商品价格高或低，对用户作出相应的提示；

（3）      直到猜对为止，并给出提示。

 

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
int main() {
    srand((int)time(0));
    int price=rand()%1000+1;//产生1到1000的随机数
    int l=1,r=1000;
    while(1) {
        cout<<"您可以猜一个价格，当前范围["<<l<<","<<r<<"]的整数。"<<endl;
        int guess;
        cin>>guess;
        if(guess>1000||guess<1||cin.fail()) {
            cout<<"输入不合法，请重新输入"<<endl;
            cin.clear();
            cin.ignore(10000,'\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 0;
}

实验问题

• 如何产生随机数 
  通过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=2;i<=n;i++){
        if(!prime[i])prime[++cnt]=i;
        for(int j=1;j<=cnt&&prime[j]<=N/i;j++){
            prime[prime[j]*i]=1;
            if(i%prime[j]==0)break;
        }
    }
}
int main(){
    ofstream f("prime.txt");
    cout<<"请输入n"<<endl;
    cin>>n;
    getPrime();
    for(int i=1;i<=cnt;i++)
        f<<prime[i]<<" ";
    f.close();
    return 0;
}

 

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+1;j<=black;j++)
            for(int k=j+1;k<=black;k++){
                output(i);
                output(j);
                output(k);
                cout<<endl;
            }    
    return 0;
}

 

 

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=1;i<=9;i++){
        for(int j=1;j<=i*7;j++)
            cout<<" ";
        for(int j=i;j<=9;j++)
            cout<<i<<"*"<<j<<"="<<setw(3)<<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 0;
}

 

　　

　　

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==1||x==2)return 1;
    return fib(x-1)+fib(x-2);
}
int main(){
    int n;
    cout<<"请输入整数n"<<endl
    cin>>n;
    cout<<"fib("<<n<<")="<<fib(n)<<endl;
    return 0;
}

 

　　

//非递归
#include <iostream>
using namespace std;
int fib(int x){
    int a=1,b=1;
    for(int i=3;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 0;
}

 

　　

7、  计算n 阶勒让德多项式

 

编写C++程序完成以下功能：

（1）      提示用户输入整数n和实数x；

（2）      P_n(x)，并输出结果。

 

#include <iostream>
using namespace std;
double p(int n,int x){
    if(!n)return 1;
    if(n==1)return x;
    return ((2*n-1)*p(n-1,x)-(n-1)*p(n-2,x))/n;
}
int main(){
    int n,x;
    cout<<"请输入n、x"<<endl;
    cin>>n>>x;
    cout<<"Pn("<<x<<")="<<p(n,x)<<endl;
    return 0;
}

 

　　

实验二 类与对象

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=0,int _y=0):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=0,int ay=0,int bx=1,int by=1):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(1) {
        cin>>ax>>ay>>bx>>by;
        if(ax>bx||ay<by||cin.fail()) {
            cout<<"输入的矩形不合法"<<endl;
            cin.clear();
            cin.ignore(10000,'\n');
        } else {
            Rectangle myRectangle(ax,ay,bx,by);
            cout<<"该矩形的面积为"<<myRectangle.area()<<endl;
            break;
        }
    }
    return 0;
}

 

实验问题

• 构造函数和析构函数写在哪？ 
  写在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=0,int y=0):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=0,int y=0,double r=0):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 0;
}

 

　　

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=0):weight(w) {};
    ~Boat() {};
    friend double TotalWeight(Boat&,Car&);
};

class Car {
  private:
    double weight;
  public:
    Car() {};
    Car(double w=0):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(1) {
        double bw,cw;
        cin>>bw>>cw;
        if(cin.fail()) {
            cout<<"输入不合法"<<endl;
            cin.clear();
            cin.ignore(10000,'\n');
        } else {
            Boat myBoat(bw);
            Car myCar(cw);
            cout<<"Boat和Car的总重量为"<<TotalWeight(myBoat,myCar)<<endl;
            break;
        }
    }
    return 0;
}

 

实验问题

• 什么时候需要用友元？ 
  当一个函数要用到这个类时（可能还有其他类）的私有成员，但是它不是这个类独享的函数，调用时不需要通过对象或指针。
• 友元函数定义在哪？ 
  定义在主函数外面，类定义后面，要加上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=0,int d=0):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 0;
}

 

实验三 数组与指针

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=0; i<ROW; i++)
            for(int j=0; j<COL; j++)
                cin>>mat[i][j];
    }
    void output() {
        cout<<"The Matrix:"<<endl;
        for(int i=0; i<ROW; i++) {
            for(int j=0; j<COL; j++)
                cout<<mat[i][j]<<"\t";
            cout<<endl;
        }
    }
    void add(Matrix &a,Matrix &b) {
        for(int i=0; i<ROW; i++)
            for(int j=0; j<COL; j++)
                mat[i][j]=a.mat[i][j]+b.mat[i][j];
    }
    void sub(Matrix &a,Matrix &b) {
        for(int i=0; i<ROW; i++)
            for(int j=0; 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 0;
}

 

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 = 4;
const int col = 5;
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 0;
    }
    for(int i=0; i<row; i++) {
        *(a+i)=new int[col];
        if(a+i==NULL) {
            cout<<"error:no enough space"<<endl;
            return 0;
        }
    }
    return 1;
}
class Matrix
{
private:
    int **mat;
public:
    Matrix()
    {
        malloc_array(mat, row, col);
    }
    Matrix(Matrix &b)
    {
        if(malloc_array(mat, row, col))
            for(int i = 0; i < row; i++)
                for(int j = 0; j < col; j++)
                    mat[i][j] = b.mat[i][j];
    }
    ~Matrix()
    {
        for(int i = 0; i < row; i++)
            delete [] *(mat + i);
        delete [] mat;
        mat = NULL;
    }
    void input()
    {
        cout << "please input the Matrix:" << endl;
        for(int i = 0; i < row; i++)
            for(int j = 0; j < col; j++)
                cin >> mat[i][j];
    }
    void output()
    {
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
                cout << mat[i][j] << "\t";
            cout << endl;
        }
    }
    void cal(Matrix &a, Matrix &b, int op)
    {
        for(int i = 0; i < row; i++)
            for(int j = 0; 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, 1);
    cout << "Matrix A1 + Matrix A2 =" << endl;
    A3->output();
    A3->cal(*A1, *A2, -1);
    cout << "Matrix A1 - Matrix A2 =" << endl;
    A3->output();
    A1->~Matrix();
    A2->~Matrix();
    A3->~Matrix();
    A1 = NULL;
    A2 = NULL;
    A3 = NULL;
    return 0;
}

 

实验问题

• 动态分配内存？ 
  定义：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 0;
    }
    for(int i=0; i<row; i++) {
        *(a+i)=new int[col];
        if(a+i==NULL) {
            cout<<"error:no enough space"<<endl;
            return 0;
        }
    }
    return 1;
}
class Matrix {
  private:
    int **mat;
    int row,col;
  public:
    Matrix(int _row=0,int _col=0):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=0; i<row; i++)
        for(int j=0; j<col; j++)
            mat[i][j]=b.mat[i][j];
    }
    ~Matrix() {
        for(int i=0; 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=0; i<row; i++)
            for(int j=0; j<col; j++)
                cin>>mat[i][j];
    }
    void output() {
        for(int i=0; i<row; i++) {
            for(int j=0; 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 0;
        }
        for(int i=0; i<row; i++)
            for(int j=0; j<col; j++)
                mat[i][j]=a.mat[i][j]+b.mat[i][j]*op;
        return 1;
    }
};
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,1)) {
        cout<<"Matrix A1 + Matrix A2 ="<<endl;
        pA3->output();
        pA3->cal(*pA1,* pA2,-1);
        cout<<"Matrix A1 - Matrix A2 ="<<endl;
        pA3->output();
    }
    pA1->~Matrix();
    pA2->~Matrix();
    pA3->~Matrix();
    pA1=NULL;
    pA2=NULL;
    pA3=NULL;
    return 0;
}

 

实验问题

• 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[1000];
    cin>>s;
    int len;
    for(len=0;s[len];len++);
    len--;
    for(int i=0;i<=len/2;i++){
        char c=s[i];
        s[i]=s[len-i];
        s[len-i]=c;
    }
    cout<<s;
    return 0;
}

 

　　

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=1;i<=n;i++){
        double m=(a+b)/2;
        fa=pf(a);
        fm=pf(m);
        if(fa*fm<0)b=m;
        else a=m;
    }
    return a;
}
double f1(double x){
    return x*6+16;
}
double f2(double x){
    return x+1;
}
int main(){
    cout<<RolveRoot(f1,-10,10,20)<<endl;
    cout<<RolveRoot(f2,-10,10,20)<<endl;
    return 0;
}

 

　　

实验四 继承与派生

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=0,int _h=0):w(_w),h(_h) {}
    ~Rectangle() {}
    double getArea() {
        return w*h;
    }

};
class Square:public Rectangle {
  private:
    int a;
  public:
    Square(int _a=0):a(_a) {}
    ~Square() {}
    double getArea() {
        return a*a;
    }
};
class Circle:public Shape {
  private:
    int r;
  public:
    Circle(int _r=0):r(_r) {}
    ~Circle() {}
    double getArea() {
        return pi*r*r;
    }
};
int main() {
    Circle c(1);
    Square s(2);
    Rectangle r(2,3);
    output(c);
    output(s);
    output(r);
    return 0;
}

 

实验问题

• 基类要面积这个参数吗，怎么计算面积？ 
  不用，不用计算，只是有这个方法放在那。
• 怎么继承，区别是什么？ 
  公有继承，父类的私有成员都是不可访问，公有成员只有公有继承时是都可访问，私有继承则只能类内访问。

2、  形状（二）——虚函数

（1）      将【形状（一）】 中的基类计算面积的方法定义为虚函数，比较与【形状（一）】程序的差异；

（2）      将【形状（一）】中的基类定义抽象类，比较与【形状（一）】程序的差异。

 

#include <iostream>
#include <cmath>
using namespace std;
const double pi=acos(-1.0);
class Shape {
  public:
    virtual double getArea()=0;
};
class Rectangle: public Shape {
  private:
    int w,h;
  public:
    Rectangle(int _w=0,int _h=0):w(_w),h(_h) {}
    ~Rectangle() {}
    double getArea() {
        return w*h;
    }
};
class Square:public Rectangle {
  private:
    int a;
  public:
    Square(int _a=0):a(_a) {}
    ~Square() {}
    double getArea() {
        return a*a;
    }
};
class Circle:public Shape {
  private:
    int r;
  public:
    Circle(int _r=0):r(_r) {}
    ~Circle() {}
    double getArea() {
        return pi*r*r;
    }
};
int main() {
    Shape *ptr[5];
    ptr[1]=new Circle(1);
    ptr[2]=new Square(2);
    ptr[3]=new Rectangle(2,3);
    for(int i=1; i<=3; i++)
        cout<<"The Area of Shape "<<i<<" is "<<ptr[i]->getArea()<<endl;
    return 0;
}

 

实验问题

• 虚函数是什么？ 
  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=0,s=0;i<cnt&&s<n;i++){
        int r=i;
        while(c[r][i]==0&&r<cnt)r++;
        if(c[r][i]){
            swap(c[r],c[i]);
            for(int j=i+1;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-1;i>=0;i--){
        x[i]=c[i][n]/c[i][i];
        for(int j=0;j<i;j++){
            c[j][n]-=x[i]*c[j][i];
            c[j][i]=0;
        }
    }
    for(int i=0;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=0;i<m;i++)
        for(int j=0;j<=n;j++)
            cin>>mat[i][j];
    Gauss(mat,n,m);
    return 0;
}

 

　　

实验五 多态性

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=0,int y=0):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(0,0);
    (p++).out();
    p.out();
    (++p).out();
    p.out();
    (p--).out();
    p.out();
    (--p).out();
    p.out();
    return 0;
}

 

实验问题

• 如何实现左右的两种不同运算？ 
  重载 operator++ 和 operator--时带一个 int 参数表示后缀，不带参数表示前缀
• 怎么验证运算符？ 
  通过(++p).out()来输出验证。

2、  实现复数类的运算重载

    编写C++程序完成以下功能：

（1）      实现复数类的运算重载：＋，－，*，/，^（乘方）。

 

#include <iostream>
using namespace std;
class Complex{
private:
    double re,im;
public:
    Complex(double r=0,double i=0):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=0;i<b;i++)
            t=t*(*this);
        return t;
    }
    void out(){//我自己加了严格的输出要求
        if(re){
            cout<<re;
            if(im>0)cout<<"+";
        }
        if(im==-1)cout<<"-";
        else if(im!=1)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^3).out();
    return 0;
}

 

　　

3、  参考【实验二】中分数类，为分数类重载运算符，使之能够进行＋，－，*，/，^（乘方）的运算。

 

#include <iostream>
using namespace std;

class Fractions{
private:
    int num,den;
public:
    Fractions(int n=0,int d=0):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=0;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(1,2),b(2,3);
    (a/b).print();
    return 0;
}

 

　　

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=2333;
    unsigned int un=100;
    long l=100000;
    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(10)<<d<<endl;
    cout<<"当前精度："<<cout.precision()<<endl;
    cout<<"定点小数："<<fixed<<d<<endl ;
    return 0;
}

 

2、  流式IO（二）

编写C++程序完成以下功能：

（1）      输入一个文本文件名

（2）      使用ofstream 向一个二进制文件中输出各种类型的数据，并打开文件观察结果：

•  整数、无符号整型、长整型、浮点型、字符串、……

 

#include <iostream>
#include <iomanip>
#include <fstream>

using namespace std;
int main(){
    int hh=2333;
    unsigned int un=100;
    long l=100000;
    double d=123.533456780123;

    char file[1000];
    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 0;
}

 

 

3、  流式IO（三）

编写C++程序完成以下功能：

（1）      输入一个文本文件名；

（2）      打开文件名，在该文件的每一行前面加上一个行号，保存在另外一个文本文件中。

#include <iostream>
#include <cstdio>
#include <string>
#include <fstream>
using namespace std;
int main(){
    char file[1000];
    cout<<"请输入文件名"<<endl;
    cin>>file;
    ifstream in(file);
    if(!in){
        cout<<"文件打开失败!\n";
        return 0;
    }
    ofstream out("out.txt");
    if(!out){
        cout<<"文件打开失败!\n";
        return 0;
    }

    int i=1;
    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 0;
}

 

实验问题

• 怎么读入一行？ 
  一是用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[1000];
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(1){
        cout<<"（1）打开电话本（2）保存电话本（3）查找（4）添加（5）删除"<<endl;
        while(cin>>op && (op<'1'||op>'5'));
        switch(op){
            case '1':b.input();break;
            case '2':b.output();break;
            case '3':
                cout<<"请输入需要查找的姓名："<<endl;
                cin>>n;
                b.find(n);
                break;
            case '4':
                cout<<"请输入姓名 电话："<<endl;
                cin>>n>>t;
                b.add(n,t);
                break;
            case '5':
                cout<<"请输入需要删除的人的姓名："<<endl;
                cin>>n;
                b.remove(n);
                break;
            default:break;
        }
    }
    return 0;
}

 

实验问题

• 用什么实现删除、插入数据？ 
  很容易想到链表，于是在电话本这个类里面就有一个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]。