《面向对象程序设计》实验教学大纲
课程总学时：64 学分：4
实验学时：16 实验个数： 6个 实验学分：1分
课程性质：专业必修课 适用专业：计算机类专业
教材及参考书：《C++语言程序设计（第四版）》，郑莉、董渊编著，北京：清华大学出版社，2011
大纲执笔人：*** 大纲审定人：***
一、实验课的性质与任务
本课程实验大纲是面向计算机专业学生开设的《C++程序设计》实验课计划指导大纲，是依据《面向对象程序设计》课程教学计划指导大纲编制。本课程主要讲述了利用C++进行程序设计的思想和方法，既有面向过程和面向对象的程序设计的理论知识，又包括极强的实践应用能力的培养。本实验大纲力求结合该课程教学计划大纲的相应内容，由浅入深的指导学生了解和掌握如何利用C++程序设计语言进行程序设计，提高学生的动手能力，做到理论和实践相结合，培养学生理解，分析程序，编写，调试程序的能力，使之能把程序设计应用到今后的专业学习中。
二、实验目的与要求
1．实验目的
通过本课程的学习，使学生掌握面向过程的程序设计思想和编程思路，初步掌握面向对象的程序设计思想，学会调试程序，能独立编写实用的小型程序。
2．实验要求
(1) 学生应该自始至终贯彻课程中所介绍的程序设计风格,养成良好的编程习惯；
(2) 应独立完成所布置习题。为保证尽量在统一安排的上机时间内编译运行通过程序，学生应事先设计好程序。
三、实验项目及内容提要
四、实验内容安排：实验一 类与对象
（ 设计性实验 4学时）
1. 目的要求：
1) 掌握类的定义和使用；掌握类对象的声明；练习具有不同访问属性的成员的访问方式；观察构造函数和析构函数的执行过程；
2) 学习类组合使用方法；
3) 使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。
2. 实验内容：
1) 编写重载函数Max1可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。
#include"iostream"
using namespace std;
int max(int a,int b)
{
if(a>=b)
return a;
else
return b;
}
int max(int a,int b,int c)
{
return max(max(a,b),c);
}
double max(double a,double b)
{
if(a>=b)
return a;
else
return b;
}
double max(double a,double b,double c)
{
return max(max(a,b),c);
}
void main()
{
cout<<max(1,5)<<endl;
cout<<max(5,6,7)<<endl;
cout<<max(1.0,2.1)<<endl;
cout<<max(1.0,2.2,1.5)<<endl;
}
2) 写一个函数，具有一个引用作为形参参数，在函数中改变引用变量的值，观察实参变量的变化。
#include <iostream>
using namespace std;
void swap(int &a,int &b)
{
int t=a;
a=b;
b=t;
}
int main()
{
int x=3,y=5;
cout<<"x="<<x<<" y="<<y<<endl;
swap(x,y);
cout<<"x="<<x<<" y="<<y<<endl;
return 0;
}
3) 定义一个CPU类，包含等级（Rank）、频率（frequency）、电压(voltage)等属性，有两个公有成员函数run、stop。其中，rank为枚举类型CPU__Rank,定义为enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7},frequency为单位是MHz的整型数，voltage为浮点型的电压值。观察构造函数和析构函数的调用顺序。
#include <iostream+
>
using namespce std;
enum CPU_Rank {P1=1,P2,P3,P4,P5,P6,P7};
class CPU
{
private:
CPU_Rank rank;
int frequency;
float voltage;
public:
CPU (CPU_Rank r, int f, float v)
{
rank = r;
frequency = f;
voltage = v;
cout << "构造了一个CPU!" << endl;
}
~CPU () { cout << "析构了一个CPU!" << endl; }
CPU_Rank GetRank() { return rank; }
int GetFrequency() { return frequency; }
float GetVoltage() { return voltage; }
void SetRank(CPU_Rank r) { rank = r; }
void SetFrequency(int f) { frequency = f; }
void SetVoltage(float v) { voltage = v; }
void Run() {cout << "CPU开始运行!" << endl; }
void Stop() {cout << "CPU停止运行!" << endl; }
};
void main()
{
CPU a(P6,300,2.8);
a.Run();
a.Stop();
}
4) 定义一个简单的Computer类，有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，定义并实现这个类，为以上的类编写构造和析构函数，观察组合类和内嵌类的构造函数和析构函数的调用顺序。
#include<iostream.h>
enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7};
class CPU //定义CPU类
{
private:
CPU_Rank rank;
int frequency;
float voltage;
public:
CPU(CPU_Rank r,int f,float v)
{
rank=r;
frequency=f;
voltage=v;
cout<<"构造了一个CPU!"<<endl;
}
~CPU(){cout<<"析构了一个CPU!"<<endl;}
CPU_Rank GetRank()const{return rank;}
int GetFrequency()const{return frequency;}
float GetVoltage()const{return voltage;}
void SetRank(CPU_Rank r){rank=r;}
void SetFrequency(int f){frequency=f;}
void SetVoltage(float v){voltage=v;}
void Run(){cout<<"CPU开始运行!"<<endl;}
void Stop(){cout<<"CPU停止运行!"<<endl;}
};
class RAM //定义RAM类
{
int x;
public:
RAM(int a){x=a;
cout<<"构造了一个RAM!"<<endl;}
~RAM(){cout<<"析构了一个RAM!"<<endl;}
};
class CDROM //定义CDROM类
{
char y;
public:
CDROM(char v){y=v;cout<<"构造了一个CDROM!"<<endl;}
~CDROM(){cout<<"析构了一个CDROM!"<<endl;}
};
class Computer //定义Computer类
{
CPU a;
RAM b;
CDROM c;
public:
Computer(CPU_Rank x,int y,float z,int xx,char yy)//构造函数
:a(x,y,z),b(xx),c(yy)
{
cout<<"构造了一个Computer!"<<endl;}
~Computer(){cout<<"析构了一个Computer!"<<endl;}
void Run(){cout<<"Computer开始运行!"<<endl;}
void Stop(){cout<<"Computer停止运行!"<<endl;}
};
void main()
{
Computer niu(P6,3,2.9,4,'G');
niu.Run();
niu.Stop();
}
5) 为题目2）的类编写复制构造函数，在主函数中利用复制构造的方式创建新的对象，观察对象的状态。
6) 思考并回答以下概念：
函数重载：有相同的函数名，但形参的个数或者类型不同
数据成员：
函数成员：
访问属性：
内嵌对象：
初始化列表：
3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0
4.
实验二 C++程序的结构
（ 设计性实验 2学时）
1. 目的要求：
1) 观察程序运行中变量的作用域、生存期和可见性；
2) 学习类的静态成员的使用；
3) 学习多文件结构在C++程序中的使用。
2. 实验内容：
1) 实现客户机(CLIENT)类。定义字符型静态数据成员ServerName，保存其服务器名称；整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeServerName()改变服务器名称。
#include "iostream"
using namespace std;
class CLIENT
{
public:
CLIENT()
{
cout<<"调用构造函数"<<endl;
ClientNum++;
}
~CLIENT()
{
cout<<"调用析构函数！"<<endl;
ClientNum--;
}
char getName()
{
return ServerName;
}
int getNum()
{
return ClientNum[20];
}
void InputName();
void ChangeName();
private:
char ServerName[20];
int ClientNum;
};
void CLIENT::InputName()
{
cout<<"请输入需要加入的服务器名称："<<endl;
cin>>ServerName;
ClientNum++;
}
void CLIENT::ChangeName()
{
cout<<"暂时无法修改服务器名称！"<<endl;
}
int main()
{
CLIENT client;
client.InputName();
client.ChangeName();
cout<<client.getName()<<endl;
cout<<client.getNum<<endl;
return 0;
}
2) 利用多文件结构实现题目1），在头文件client.h中定义类，在文件client.cpp中实现该类，在文件test.cpp 中测试这个类，观察相应的成员变量取值的变化情况，要求ClientNum能够实时记录客户机对象的数量。
//client.h
#include "iostream"
using namespace std;
class Client
{
private:
static char SeverName[10];
static int Clientnum;
public:
Client()
{
cout<<"Client构造函数被调用"<<endl;
Clientnum++;
}
~Client()
{
cout<<"Client析构函数被调用"<<endl;
Clientnum--;
}
static void ChangeServername()
{
cout<<"请输入服务器的名字："<<endl;
cin>>SeverName;
}
void show();
};
int Client::Clientnum=0;
char Client::SeverName[10]="abcd";
//client.cpp
#include "iostream"
#include "client.h"
using namespace std;
void Client::show()
{
cout<<"该用户机的服务器端名字是:"<<endl;
cout<<SeverName<<endl;
cout<<"用户数量有： "<<endl;
cout<<Clientnum<<endl;
}
//Client.exe
void main()
{
Client::ChangeServername();
Client a;
a.show();
Client::ChangeServername();
Client b;
b.show();
Client::ChangeServername();
Client c;
c.show();
}
3) 思考并回答以下概念： 类的静态数据成员，类的静态函数成员，多文件结构，文件包含。
3. 主要仪器设备及软件：Windows 2000+VC 6.0
实验三 数组、指针与字符串实验
（设计性实验 4学时）
1. 目的要求：
1) 学习使用数组；学习字符串数据的组织和处理；学习标准C++库的使用；
2) 掌握指针的使用方法；练习通过debug观察指针的内容及其所指的对象的内容；练习通过动态内存分配实现动态数组，并体会指针在其中的作用；
3) 分别使用字符数组和标准C++库练习处理字符串的方法。
2. 实验内容：
1) 编写一个类用于处理3×3矩阵转置，测试转置的效果，输出转置前后的矩阵。
#include<iostream>
using namespace std;
class juzhen
{
public:
juzhen(int m[3][3])
{
for(i=0;i<3;i++)
for(j=0;j<3;j++)
a[i][j]=m[i][j];
}
void zhuanzi()
{
int temp;
for(i=0;i<3;i++)
for(j=0;j<i;j++)//转置只需要转对角线的一边
{
temp=a[i][j];
a[i][j]=a[j][i];
a[j][i]=temp;
}
}
void show()
{
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<" "<<a[i][j];
cout<<endl;
}
}
private:
int a[3][3];
int i,j;
};
int main()
{
int a[3][3]={1,2,3,3,4,5,5,7,9};
juzhen b(a);
cout<<"原始矩阵："<<endl;
b.show();
b.zhuanzi();
cout<<endl;
cout<<"转置矩阵："<<endl;
b.show();
return 0;
}
2) 定义一个具有构造函数和析构函数的类，如实验一的CPU类，定义一个CPU的对象数组，观察构造函数的析构函数的调用过程。
#include"iostream"
using namespace std;
class Point
{
public:
Point()
{
x = y = 0;
cout<<"无形参的Point类构造成功！"<<endl;
}
Point(int x,int y)
{
this->x = x;
this->y = y;
cout<<"有形参的Point类构造成功！"<<endl;
}
~Point()
{
cout<<"Point类析构成功！"<<endl;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
private:
int x,y;
};
int main()
{
Point p[2] = {Point(1,2)};
cout<<"p[0]("<<p[0].getX()<<","<<p[0].getY()<<")"<<endl;
cout<<"p[1]("<<p[1].getX()<<","<<p[1].getY()<<")"<<endl;
return 0;
}
3) 利用动态内存分配的方式重新完成题目2）。
#include"iostream"
using namespace std;
class Point
{
public:
Point()
{
x = y = 0;
cout<<"无形参的Point类构造成功！"<<endl;
}
Point(int x,int y)
{
this->x = x;
this->y = y;
cout<<"有形参的Point类构造成功！"<<endl;
}
~Point()
{
cout<<"Point类析构成功！"<<endl;
}
int getX() const
{
return x;
}
int getY() const
{
return y;
}
void move(int newX,int newY)
{
x = newX;
y = newY;
}
private:
int x,y;
};
int main()
{
Point *p = new Point[2];
p[0].move(1,2);
p[1].move(3,4);
cout<<"p[0]("<<p[0].getX()<<","<<p[0].getY()<<")"<<endl;
cout<<"p[1]("<<p[1].getX()<<","<<p[1].getY()<<")"<<endl;
delete [] p;
return 0;
}
4) 使用系统提供的string类定义字符串对象并初始化，实现从原始字符串中提取一个子串。
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str1="abcdefgh",str2;
unsigned int a=0;
unsigned int n=0;
cout<<"取从字符串1第几个字符开始的字符a=";
cin>>a;
cout<<"取几个子串n=";
cin>>n;
if(a<str1.length()&&n<=str1.length()-a)
str2=str1.substr(a,n);
cout<<str2<<endl;
return 0;
}
5) 选做：定义一个Point（二维点类）的对象数组，利用该数组实现直线的线性拟合。
6) 选做：定义一个动态数组类。
7) 思考并回答：数组，指针，对象数组，动态内存分配，默认构造函数，标准类库，字符串类 string，线性拟合。
3. 主要仪器设备及软件：Windows 2000+VC 6.0
实验四 继承与派生
（设计性实验 2学时）
1. 目的要求：
1) 学习定义和使用类的继承关系，定义派生类；熟悉不同继承方式下对基类成员的访问控制；
2) 学习利用虚基类解决二义性问题。
2. 实验内容：
1) 定义一个基类Animal，有私有整型成员变量age，构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把 age改为公有成员变量，还会有问题吗？编程试试看。
#include <iostream>
using namespace std;
class Animal
{
public:
int age;
};
class dog:public Animal
{
public:
dog()
{
cout<<"构造函数Create a dog!"<<endl;
}
~dog()
{
cout<<"析构函数Delete a dog!"<<endl;
}
void SetAge(int n);
};
void dog::SetAge(int n)
{
age = n;
}
int main()
{
dog d;
d.SetAge(4);
return 0;
}
2) 定义一个基类BaseClass,有整型成员变量Number，构造其派生类DerivedClass,定义该派生类的对象,观察构造函数和析构函数的执行情况。
#include "iostream"
using namespace std;
class BaseClass
{
private:
int Number;
public:
BaseClass(int number)
{
Number = number;
cout<<"Create BaseClass!"<<endl;
}
~BaseClass()
{
cout<<"Delete BaseClass!"<<endl;
}
};
class DerivedClass:public BaseClass
{
public:
DerivedClass(int n):BaseClass(n)
{
cout<<"Create DevidedClass!"<<endl;
}
~DerivedClass()
{
cout<<"Delete DerivedClass!"<<endl;
}
};
int main()
{
DerivedClass d(4);
return 0;
}
3) 定义一个车（vehicle）基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车（bicycle）类，汽车（motorcar）类。自行车（bicycle）类有高度（Height）等属性，汽车（motorcycle）类有座位数（SeatNum）等属性。从bicycle和motorcycle派生出摩托车(Motorcar)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle 设置为虚基类，会有什么问？编程实验及分析原因。
不设为虚基类，不能访问派生类。
#include "iostream"
using namespace std;
class vehicle
{
private:
int MaxSpeed;
int Weight;
public:
/* vehicle(int m,int w)
{
MaxSpeed = m;
Weight = w;
cout<<"Create vehicle!"<<endl;
}
~vehicle()
{
cout<<"Delete vehicle!"<<endl;
}*/
void Run()
{
cout<<" vehicle Run!"<<endl;
}
void Stop()
{
cout<<" vehicle
Stop!"<<endl;
}
};
class bicycle:virtual public vehicle
{
private:
int Height;
/*public:
bicycle(int h,int m,int w):Height(h),vehicle(m),vehicle(w)
{
cout<<"Create bicycle!"<<endl;
}
~bicycle()
{
cout<<"Delete bicycle!"<<endl;
}*/
};
class motorcycle:virtual public vehicle
{
private:
int SeatNum;
/*public:
motorcycle(int s,int m,int w):SeatNum(s),vehicle(m),vehicle(w)
{
cout<<"Create motorcycle!"<<endl;
}
~motorcycle()
{
cout<<"Delete motorcycle!"<<endl;
}*/
};
class Motorcar:public bicycle,public motorcycle
{
/*public:
Motorcar(int m,int w,int h,int s):MaxSpeed(m),Weight(w),Height(h),SeatNum(s)
{
cout<<"Create Motorcar!"<<endl;
}
~motorcycle()
{
cout<<"Delete Motorcar!"<<endl;
}*/
};
int main()
{
// Motorcar m(1,2,3,4);
Motorcar m;
m.Run();
m.Stop();
return 0;
}
4) 思考并回答：继承，派生，子类对基类成员的访问权限，继承方式，继承时的构造函数和析构函数的调用顺序，虚基类
3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0
实验五 多态和运算符重载
（ 设计性实验 2学时）
1. 目的要求：
掌握运算符重载的方法；学习使用虚函数实现动态多态性。
2. 实验内容：
1) 定义Point类，有坐标x,y两个私有成员变量;对Point类重载“+”（相加）、“-”（相减）和“==”（相等）运算符，实现对坐标的改变，要求用友元函数和成员函数两种方法实现。对Point类重载<<运算符，以使得代码 Point p; cout<<p<<endl;可以输出该点对象的坐标。
/*1) 定义Point类，有坐标x,y两个私有成员变量;
对Point类重载"+"（相加）、"-"（相减）和"=="（相等）运算符，
实现对坐标的改变，要求用友元函数和成员函数两种方法实现。
对Point类重载<<运算符，以使得代码 Point p; cout<<p<<endl;可以输出该点对象的坐标*/
#include<iostream>
#include<cmath>
using namespace std;
class point
{
public:
point(int xx=0,int yy=0):x(xx),y(yy)
{}
point operator+(point &b)
{
return point(x+b.x,y+b.y);
}
point operator-(point &b)
{
return point(x-b.x,y-b.y);
}
bool operator==(point &b)
{
if(x==b.x&&y==b.y)
return true;
else
return false;
}
friend ostream & operator<<(ostream &out,const point &b)
{
out<<"("<<b.x<<","<<b.y<<")";
return out;
}
private:
int x,y;
};
int main()
{
point a(1,3),b(3,1);
point p;
if(a==b)
cout<<" a=b "<<endl;
else
cout<<" a!=b "<<endl;
p=a+b;
cout<< " p=a+b= "<<p<<endl;
p=a-b;
cout<<" p=a-b= "<<p<<endl;
return 0;
}
2) 定义一个车(vehicle)基类，有虚函数Run、Stop等成员函数，由此派生出自行车（bicycle）类、汽车（motorcar）类，它们都有Run、Stop等成员函数。在主函数中用不同的方法调用Run、Stop成员函数，观察这些函数的执行结果，思考如何实现动态多态性，如果Run、Stop没有被定义为虚函数，执行结果会怎样，把结果和分析写入实验报告。
#include<iostream>
using namespace std;
class Vehicle
{
public:
virtual void Run()
{
cout<<"Vehicle::Run called\n";
}
virtual void Stop()
{
cout<<"Vehicle::Stop called\n";
}
};
class motorcar:public Vehicle
{
public:
void Run()
{
cout<<" motorcar Run called\n";
}
virtual void Stop()
{
cout<<"
motorcar Stop called\n";
}
};
class bicycle :public Vehicle
{
public:
virtual void Run()
{
cout<<" bicycle Run called\n";
}
void Stop()
{
cout<<" bicycle Stop called\n";
}
};
class motorcycle:public bicycle,public motorcar
{
public:
void Run()
{
cout<< " motorcycle Run called\n";
}
void Stop()
{
cout<<" mototrcycle Stop called\n";
}
};
void main()
{
Vehicle ve;
bicycle bi;
motorcar mo;
motorcycle mocy;
Vehicle *pclass=&ve;
pclass->Run();
pclass->Stop();
pclass=&bi;
pclass->Run();
pclass->Stop();
pclass=&mo;
pclass->Run();
pclass->Stop();
}
3) 选做，利用类完成求函数的积分（参考教材）。
4) 思考并回答：多态，实现多态性的方法，虚函数，运算符重载，前++，后++，实现运算符重载的方式。
3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0
实验六 模板和文件
（设计性实验 2学时）
1. 目的要求：
1) 理解模板的作用和语法。
2) 学习掌握C++文件处理类的基本用法。
2. 实验内容：
1) 使用函数模板实现一个求3个数最大值的函数，并完成测试。
#include<stdio.h>
int max(int a,int b,int c);
void main()
{
int a,b,c,m;
printf("请输入第一个数的值:\n");
scanf("%d",&a);
printf("请输入第二个数的值:\n");
scanf("%d",&b);
printf("请输入第三个数的值:\n");
scanf("%d",&c);
m=max(a,b,c);
printf("这三个数的最大值是:%d\n",m);
}
int max(int a,int b,int c)
{
if(a>b && a>c)
return a;
else if(b>a && b>c)
return b;
else
return c;
}
2) 编写程序，用二进制方式打开指定的一个文件，在每一行前加行号。
/*编写程序，用二进制方式打开指定的一个文件，在每一行前加行号。*/
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <iomanip>
#include <string>
using namespace std;
void new_line(ifstream& fin,char& temp);
int main(int argc,char *argv[])
{
ifstream fin;
ofstream fout;
int num_line=1;
char temp,inFileName[128];
string buffer;
if(argc==1)
{
printf("请用格式:SetLineNUm filename\n");
exit(0);
}
else
{
strcpy(inFileName,argv[1]);
}
cout<<"正打开输入文件...\n";
fin.open(inFileName); //打开输入文件
if(fin.fail())
{
cout<<"输入文件打开失败!\n";
exit(1);
}
cout<<"正打开输出文件...\n";
fout.open("output.txt"); //打开输出文件
if(fout.fail())
{
cout<<"输出文件打开失败!\n";
exit(1);
}
do
{
new_line(fin,temp);
getline(fin,buffer);
if(buffer.length()>0)
{
fout<<setw(3)<<num_line++<<": "; //设置行号
fout<<buffer;
fout<<endl;
}
} while(!fin.eof());
fin.close(); //关闭文件
fout.close();
cout<<"成功关闭输入输出文件。\n";
cout<<"程序结束。\n";
return 0;
}
void new_line(ifstream& fin,char& temp)
{
do//跳过行首空格和空行
{
fin.get(temp);
}while(isspace(temp));
}
3) 选做，练习使用STL中的vector模板类。
4) 选做，定义一个异常类CException,有成员函数Reason(),用来显示异常的类型。在子函数中触发异常，在主程序中处理异常，观察程序的执行过程。
5) 思考并回答：模板，函数模板，类模板，文件，文件读写，文件流类，文件操作方式，文件存储方式； STL，容器，异常处理。
3. 主要仪器设备及软件：PC+Windows 2000+VC 6.0
五 实验报告的格式（本部分要求各学院设计成表格作为教学大纲附件）
实验完毕，应用专门的实验报告本，根据预习和实验中的现象及数据记录等，及时而认真地写出实验报告。实验报告一般包括以下内容：
实验（序号） 实验名称
（一）实验目的
（二）仪器工具及材料 列出实验中所使用的主要仪器工具及材料。
（三）内容及程序 应简明扼要地写出实验步骤流程。
（四）结果及分析 应用文字、表格、图形等形式将数据表示出来。根据实验要求对数据进行分析和误差处理。
（五）问题讨论 结合有关理论对实验中的现象、产生的误差等进行讨论和分析，以提高自己的分析问题、解决问题的能力，并提出应注意的事项，也为以后的科学研究打下一定的基础。
六、考核方式、方法及实验成绩评定方法
1、考核方式、方法：
面向对象程序设计实验课成绩占面向对象程序设计总成绩的20%，即共20分。考核方法为采用实验课随堂检查学生完成情况及现场提问让学生回答，根据学生完成情况及答辩情况给分次给出平时成绩，共15分。学生在完成实验后应将自己的实验过程，结果，经验写入实验报告并提交实验报告，实验报告成绩占5分，根据学生实验报告的书写质量打出。
2、实验成绩评定方法：
评定各级成绩时，可参考以下标准：
（一）优秀（很好）18-20
能正确理解实验的目的要求，能独立、顺利而正确地完成各项实验操作，会分析和处理实验中遇到的问题，能掌握所学的各项实验技能，能较好地完成实验报告及其它各项实验作业，有一定创造精神和能力。有良好的实验工作作风和习惯。
（二）良好（较好）15-17
能理解实验的目的和要求，能认真而正确地完成各项实验操作，能分析和处理实验中遇到的一些问题。能掌握所学实验技能的绝大部分，对难点较大的操作完成有困难。能一般完成实验报告和其它实验作业。有较好的实验习惯和工作作风。
（三）中等（一般）12-14
能粗浅理解实验目的要求，能认真努力进行各项实验操作，但技巧较差。能分析和处理实验中一些较容易的问题，掌握实验技能的大部分。有30%掌握得不好。能一般完成各项实验作业和报告。处理问题缺乏条理。工作作风较好。能认真遵守各项规章制度。学习努力。
（四）及格（较差）10-12
只能机械地了解实验内容，能一般性地按实验步骤完成实验操作，能完成60%所学的实验技能，有些虽作但不准确。遇到问题常常缺乏解决的办法，在别人启发下能作些简单处理，但效果不理想。能一般完成实验报告，能认真遵守实验室各项规章制度，工作中有小的习惯性毛病（如工作无计划，处理问题缺乏条理）。
（五）不及格（很差）0-9
盲目地操作，只掌握50%的所学实验技能。有些实验虽能作，但一般效果不好，操作不正确。工作忙乱无条理。一般能遵守实验室规章制度，但常有小的错误。实验报告较多的时候有结果，遇到问题时说不明原因，在教师指导下也较难完成各项实验作业。或有些小聪明但不努力，不求上进。
七、实验主要应配套仪器设备及台（套）数（以一个实验教学班40人为标准）
八、主要教材及参考书
2. 《C++语言程序设计（第四版）》，郑莉、董渊编著，北京：清华大学出版社，2011