实验一 类和对象
类与对象的实验报告
类与对象的实验报告类与对象的实验报告引言：在计算机科学领域，类与对象是面向对象编程（Object-Oriented Programming，简称OOP）的核心概念之一。
类是一种抽象的数据类型，用于描述具有相同属性和行为的对象集合。
对象则是类的实例，具体化了类的属性和行为。
本实验旨在通过编写一个简单的类与对象的程序，深入理解类与对象的概念及其在编程中的应用。
实验过程：1. 定义一个类：在这个实验中，我们以动物为例，定义了一个名为Animal的类。
该类具有以下属性和行为：- 属性：名称、年龄、种类- 行为：吃、睡、叫2. 创建对象：在主程序中，我们创建了两个Animal对象，分别代表一只狗和一只猫。
通过调用构造函数，为对象的属性赋值。
3. 调用对象的方法：我们通过调用对象的方法，模拟了动物的行为。
例如，我们调用了eat()方法，让动物吃东西；调用了sleep()方法，让动物睡觉；调用了make_sound()方法，让动物发出叫声。
4. 修改对象属性：我们还演示了如何修改对象的属性。
通过调用set_age()方法，我们改变了动物的年龄；通过调用set_type()方法，我们改变了动物的种类。
实验结果：通过运行程序，我们观察到以下结果：- 狗的名称是"旺财"，年龄是3岁，种类是"狗"。
狗吃骨头，睡觉时打呼噜，发出汪汪的叫声。
- 猫的名称是"咪咪"，年龄是2岁，种类是"猫"。
猫吃鱼，睡觉时打呼噜，发出喵喵的叫声。
- 经过修改后，狗的年龄变为5岁，种类变为"藏獒"；猫的年龄变为3岁，种类变为"波斯猫"。
讨论与分析：通过这个实验，我们深入理解了类与对象的概念及其在编程中的应用。
类是一种抽象的模板，用于描述具有相似属性和行为的对象集合。
对象是类的实例，具体化了类的属性和行为。
通过定义类和创建对象，我们可以更好地组织和管理程序的代码。
实验一 类与对象的创建(报告)
课程名称
C++程序设计A2
班级
1420561
实验日期
2015.3.24
姓名
刘翔翔
学号
21
实验成绩
实验名称
实验一类与对象的创建
实验目的及要求
1．掌握类的定义，根据具体需求设计类。
2．深入理解C++中类的封装性。
3．会根据类创建各种对象。
4．掌握对象的各种成员的使用方法。
实
验
环
境
Visual Studio 2010
实
验
内
容
1．Time函数
改写程序，要求：
①将数据成员改为私有的；
②将输入和输出的功能改为由成员函数实现；
③在类体内定义成员函数。
然后编译和运行程序。请分析什么成员应指定为公用的?什么成员应指定为私有的?什么函数最好放在类中定义?什么函数最好在类外定义?
2.Sudent函数
请完善该程序，在类中增加一个对数据成员赋初值的成员函数set_value。上机调试并运行。
3.Date函数
（1）用下面的格式输出日期：
（2）日/月/年
（3）可运行在当前日上加一天操作（4）设置日期。算 Nhomakorabea法
描
述
及
实
验
步
骤
1．Time函数
算法描述：由类实现时间的输入输出。
步骤：建一个简单的项目，定义实现Time类，调用time类，实现输出输出时间。
实
验
结
果
1．Time函数
面向对象程序设计(C++)实验一--类和对象
实验一类和对象一、实验目的：掌握类的设计和对象的创建及相关知识点如对象数组、类聚合、友元函数、静态成员。
二、实验内容：1、设计圆类，求两个圆的位置关系；2、设计圆类和直线类，求直线与圆的位置关系；3、设计学生类，求某班学生成绩的最高分、最低分及平均分；4、设计部门类和教师类，其中部门类成员为教师类的子对象；5、设计家庭银行账户类，其中账户资金为静态数据成员，为家庭成员共享；6、设计复数类，友元函数实现复数的加减。
三、实验过程：1、根据实验题目确定需要设计哪些类、各类中包含哪些数据成员和函数成员，设计各成员的访问权限，设计数据成员的数据类型，设计函数成员的函数原型；2、给出类设计的程序实现，特别要注意重载构造函数的实现；3、在主函数中完成题目中的逻辑，一般情况下需要创建相关类的对象，通过对象对成员函数的调用或者通过对象指针对成员函数的调用完成相应的功能。
四、参考程序代码：1、设计圆类，求两个圆的位置关系#include <iostream>#include <math.h>using namespace std;class Circle{private:float a,b,r;public:Circle(float c,float d,float e){a=c;b=d; r=e;}friend void position(Circle &,Circle &);};void position(Circle &c1,Circle &c2){float n,m,p;p=sqrt((c1.a-c2.a)*(c1.a-c2.a)+(c1.b-c2.b)*(c1.b-c2.b)); n=fabs(c1.r-c2.r);m=c1.r+c2.r;if(p>m)cout << "相离";if(p==m)cout << "相切";if(p<m)cout << "相交";}int main(){float a,b,c,d,e,f;cin >> a >> b >> c >> d >> e >> f ;Circle c1(a,b,c),c2(d,e,f);position(c1,c2);return 0;}运行结果:2、设计圆类和直线类，求直线与圆的位置关系#include<iostream>#include<math.h>using namespace std;class Circle//圆类{private:float x,y,r;public:Circle(float a,float b,float c) {x=a;y=b;r=c;}float getx(){return x;}float gety(){return y;}float getr(){return r;}};class Line//直线类{private:float a,b,c;public:Line(float x,float y,float z){a=x;b=y;c=z;}void position(Circle c1){float d=fabs(a*c1.getx()+b*c1.gety()+c)/sqrt(a*a+b*b) ;//圆心到直线的距离if(d<c1.getr())cout << "相交";if((d-c1.getr())<0.000001)cout << "相切";cout << "相离";}};int main(){Line l1(3,3,4);//创建直线对象Circle c1(-23,3,7);//创建圆对象l1.position(c1);return 0;}运行结果:3、设计学生类，求某班学生成绩的最高分、最低分及平均分#include <iostream>#include <string.h>using namespace std;class Student{private:char name[20],xuehao[20];float math;public:Student(){}Student(char *na,char *xu,float ma):math(ma) {strcpy(name,na);strcpy(xuehao,xu);}void set(char *na,char *xu,float ma){math=ma;strcpy(name,na);strcpy(xuehao,xu);}char *get_name(){return name;}char *get_xuehao(){return xuehao;float get_math(){return math;}};void max_min(Student stu[],int n){Student max,min;max=min=stu[0];for(int i;i<n;i++){if(stu[i].get_math()>max.get_math())max=stu[i];if(stu[i].get_math()<min.get_math())min=stu[i];}cout << "学生成绩最高:" << max.get_name() << "," << max.get_xuehao() << "," << max.get_math() << endl;cout << "学生成绩最低:" << min.get_name() << "," << min.get_xuehao() << "," << min.get_math() << endl;}void ave(Student stu[],int n){float sum=0;for(int i=0;i<n;i++){sum=sum+stu[i].get_math();cout << "ave=" << sum/n;}int main(){char na[20],xu[20];float ma;Student stu[20];int n;cout << "请输入学生总人数"; cin >> n;for(int i=0;i<n;i++){cin >> na >> xu >> ma ; stu[i].set(na,xu,ma); }max_min(stu,n);ave(stu,n);return 0;}运行结果:4、设计部门类和教师类，其中部门类成员为教师类的子对象#include <iostream>#include <string.h>using namespace std;class Department{private:int dep_num;char dep_master[20];char dep_name[20];public:Department(){}Department(int num,char *ma,char *na){dep_num=num;strcpy(dep_master,ma);strcpy(dep_name,na);}void show(){cout << dep_num << "," << dep_master << "," << dep_name ; }};class Teacher{private:char name[20];char haoma[20];Department dep;public:Teacher(char *n,char *nu,int num,char *ma,char *na):dep(num,ma,na) {strcpy(name,n);strcpy(haoma,nu);}void show(){dep.show();cout << "," << name << "," << haoma << endl;}};int main(){Teacher hp("wanghai","12345",6,"kiki","computer");hp.show();return 0;}运行结果:5、设计家庭银行账户类，其中账户为静态数据成员，为家庭成员共享#include <iostream>#include <string.h>using namespace std;class Familymember//家庭成员类{private:char membername[10];//成员名public:static float account;//共享账户资金 Familymember(char *name);static void save(float money);//存钱 static void pay(float money);//支出 static void show(); //显示账户余额};float Familymember::account=0;Familymember::Familymember(char *name) {strcpy(membername,name);}void Familymember:: save(float money) {account= account+money;}void Familymember:: pay(float money){account= account-money;}void Familymember:: show(){cout<<account<<endl;}int main()//主函数{ Familymember husband("wang"),wife("Li"); husband.save(10000);wife.pay(3000);wife.save(5000);wife.show();husband. show();}运行结果:6、设计复数类，友元函数实现复数的加减#include <iostream>using namespace std;class Fushu{private:float ss,xs;public:Fushu(){}Fushu(float a,float b){ss=a;xs=b;}friend Fushu jiafa(Fushu &f1,Fushu &f2){return Fushu((f1.ss+f2.ss),(f1.xs+f2.xs)); }friend Fushu jian(Fushu &f1,Fushu &f2){return Fushu((f1.ss-f2.ss),(f1.xs-f2.xs)); }void show(){cout << ss << " + " << xs << "i" << endl; }};int main(){Fushu f1(2,3),f2(4,5);Fushu f3,f4;f3=jiafa(f1,f2);f4=jian(f1,f2);f3.show();f4.show();return 0;}运行结果:。
类与对象实验报告
类与对象实验报告类与对象实验报告引言：类与对象是面向对象编程的基本概念，通过定义类和创建对象，可以实现对数据和行为的封装，使程序更加模块化和可扩展。
本实验旨在通过实际操作，加深对类与对象的理解，并掌握其基本用法。
实验过程：1. 定义类：在实验开始前，我们首先需要定义一个类。
类是对象的抽象描述，包含了对象的属性和方法。
以汽车为例，我们可以定义一个Car类，其中包含品牌、颜色和速度等属性，以及启动、加速和刹车等方法。
2. 创建对象：在定义了Car类之后，我们可以通过创建对象来实例化该类。
通过使用new关键字，我们可以创建多个汽车对象，每个对象都拥有独立的属性和方法。
例如，我们可以创建一个名为myCar的对象，它是Car类的一个实例。
3. 访问对象的属性和方法：创建了对象之后，我们可以通过点运算符来访问对象的属性和方法。
例如，通过myCar.brand可以获取myCar对象的品牌属性，通过myCar.start()可以调用myCar对象的启动方法。
这样，我们可以通过对象来操作和管理数据，使代码更加清晰和可读。
4. 对象之间的交互：在实际编程中，对象之间经常需要进行交互。
通过在类中定义方法，我们可以实现对象之间的数据传递和信息交流。
例如，我们可以定义一个方法来获取其他汽车对象的速度，并根据这些速度进行比较和判断。
实验结果：通过实验，我们深入了解了类与对象的概念和用法。
通过定义类和创建对象，我们可以更好地组织和管理代码，提高程序的可维护性和可扩展性。
通过访问对象的属性和方法，我们可以实现对数据和行为的封装，使代码更加模块化和易于理解。
通过对象之间的交互，我们可以实现数据的共享和协作，提高程序的效率和灵活性。
实验总结：类与对象是面向对象编程的核心概念，掌握了类与对象的基本用法对于开发高质量的程序至关重要。
通过本次实验，我们加深了对类与对象的理解，并通过实际操作掌握了其基本用法。
在以后的编程过程中，我们可以更加灵活地运用类与对象，提高代码的可读性和可维护性。
c++类和对象实验报告
实验一类和对象实验课程名：面向对象程序设计（C++）专业班级：学号：：实验时间：实验地点：指导教师：p->PrintList();cout<<"请输入要删除的元素所在的位置："<<endl;cin>>n;p->Delete(n);p->PrintList();return 0;}运行结果：2．设计一个带头结点的单链表类，要求：(1)生成一个整数线性表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
(2)设计一个测试主函数，实际运行验证所设计单链表类的正确性。
实验代码：#include<iostream>using namespace std;L3.PrintList( );cout<<"链表的长度为："<<L1.Length( )<<endl;cout<<"链表的第四个元素为："<<L1.Get(4)<<endl;cout<<"链表中元素5为第"<<L1.Locate(5)<<"个元素"<<endl;L1.Insert(4, 17);cout<<"插入元素后链表为：";L1.PrintList( );L1.Delete(8);cout<<"删除第8个元素后链表变为：";L1.PrintList( );return 0;}实验结果：3．设计一个不带头结点的单链表类，要求：(1)不带头结点单链表类的成员函数包括取数据元素个数、插入元素、删除所有值为k的元素、取数据元素。
{int a[10]={0,1,2,3,4,5,6,7,8,9};LinkList<int> L(a,10);cout<<"链表长为："<<L.Length()<<endl;cout<<"链表的第6个元素为："<<L.Get(6)<<endl;L.Insert(5,17);cout<<"在链表第5个位置插入元素17后链表变为：";L.PrintList();L.Delete(8);cout<<"删除第8个元素后链表变为：";L.PrintList();return 0;}实验结果为：4．设计一个带头结点的循环单链表类，实现约瑟夫环问题；问题描述：设编号为1,2,…，n(n>0)个人按顺时针方向围坐-圈，每人持有一个正整数密码。
java类与对象实验报告心得
java类与对象实验报告心得哇，做完这个Java类与对象的实验，真的是感触颇多呢。
在做这个实验之前呀，对于Java里的类和对象，我就只停留在理论知识上，觉得它们好抽象哦。
什么是类呢？就像是一个蓝图一样，描述了对象应该具有的属性和行为。
可那时候，我对这个概念也只是一知半解啦。
当开始做实验的时候，我才真正体会到其中的乐趣与挑战。
创建类的时候，我要去仔细思考这个类到底需要哪些属性。
就好比我要创建一个表示学生的类，那姓名、年龄、学号这些属性肯定是必不可少的呀。
这就像是在设计一个学生的模板一样，好有趣呢。
定义类中的方法也很有意思。
这些方法就像是这个类的功能一样。
比如说学生类中的学习方法，我可以在这个方法里编写一些代码来表示学生学习的过程。
刚开始写的时候，还老是出错呢，哎呀。
不是语法错误，就是逻辑上有点混乱。
不过这也是学习的过程嘛。
创建对象就像是根据这个蓝图来制造一个具体的东西。
我根据学生类创建了具体的学生对象，每个学生对象都有自己独特的属性值。
这就像是在现实生活中，每个学生都是独一无二的一样。
当我成功创建出这些对象并且让它们执行相应的方法时，那种成就感真的难以言表，哈哈。
在实验过程中，我还深刻体会到了封装的重要性。
把类的属性和方法封装起来，就像是给它们穿上了一层保护罩一样。
这样可以防止外部的代码随意修改类内部的数据，使得代码更加安全和可靠。
这让我觉得Java真的是一门很严谨的编程语言呢。
另外呀，类与类之间的关系也很复杂但又很有趣。
有继承关系，就像儿子类继承父亲类的属性和方法一样。
还有组合关系，一个类可以包含其他类的对象作为自己的属性。
理解这些关系的时候，我费了好大的劲呢，不过一旦理解了，就感觉像是打开了新世界的大门。
这次实验让我对Java类与对象的理解不再停留在书本上的文字，而是真正地可以运用它们来编写程序了。
我觉得自己在编程的道路上又前进了一大步呢。
希望以后还能做更多这样有趣又有挑战性的实验，让我可以更加熟练地掌握Java编程呀。
[实验报告]类和对象
![[实验报告]类和对象](https://img.taocdn.com/s3/m/b372f7ee0d22590102020740be1e650e52eacfce.png)
[实验报告]类和对象
一、实验目的
通过本次实验，了解抽象的一种程序设计概念“类”和“对象”，理解类之间的继承与多态性，以及封装对对象的各种属性和行为，实现软件对象模型与真实世界对象间的映射。
二、实验内容
1.定义类与对象
(1)类是代表一类实体的抽象。
它包含了一个共同拥有的结构和行为。
类是面向对象程序设计的基本元素。
(2)对象是一个实例。
它拥有一个特定于其类型的属性，并表现出对应的行为。
对象是程序中实际的可操作的元素。
2.类的成员
(1)类的成员可以是变量，函数，常量等等。
(2)变量：类的成员变量可以存储数据成员和提供给类的方法，这些变量被称为实例变量；类变量存储类及其对象的信息。
(3)函数：类的成员函数用于封装一定的行为或对对象的设置，它可以访问实例变量和类变量的值，以及实现一定的功能。
多态性是指一个类可以根据不同环境要求而采用不同的行为。
接口就是把数据和逻辑封装在一起的内部接口。
java类与对象实验报告
java类与对象实验报告Java类与对象实验报告一、引言Java是一种面向对象的编程语言，类和对象是Java编程的基本概念。
在本次实验中，我们将学习和掌握Java类和对象的概念、定义和使用方法，并通过实际的编程实验来加深对这些概念的理解。
二、实验目的1. 理解Java类和对象的概念；2. 学会定义和使用Java类；3. 掌握创建和操作Java对象的方法；4. 熟悉Java类和对象的相关语法和规范。
三、实验过程1. 类的定义在Java中，类是对象的模板，用于描述对象的属性和行为。
我们首先需要定义一个类，以便创建对象。
类的定义包括类名、属性和方法。
属性即对象的特征，方法即对象的行为。
2. 对象的创建通过使用关键字"new"，我们可以创建一个类的对象。
对象是类的实例化，每个对象都有自己的属性和方法。
3. 对象的属性和方法对象的属性和方法可以通过对象名加点操作符来访问。
属性可以是基本类型或其他类的对象，方法可以是对象的行为或功能。
4. 构造方法构造方法是一种特殊的方法，用于创建对象时进行初始化操作。
构造方法的名称必须与类名相同，没有返回类型，可以有参数。
5. 封装性封装性是面向对象编程的重要特性之一，它将数据和方法封装在类中，对外部隐藏内部实现细节。
通过使用访问修饰符(private, public, protected)来控制属性和方法的访问权限。
6. 继承继承是面向对象编程的另一个重要特性，它允许我们创建一个新类，并从现有类中继承属性和方法。
通过使用关键字"extends"来实现继承。
7. 多态性多态性是面向对象编程的核心概念之一，它允许我们使用一个父类类型的引用来引用子类的对象。
通过方法的重写和重载来实现多态性。
四、实验结果通过本次实验，我们成功定义了一个Java类，并创建了多个对象。
我们可以通过对象名来访问对象的属性和方法，并对其进行操作。
我们还学习了构造方法的使用，以及封装性、继承和多态性的相关概念。
c++程序设计类和对象实验总结
一、实验目的在本次C++程序设计实验中，主要目的是通过对类和对象的学习和掌握，进一步加深对C++程序设计语言的理解和应用。
通过具体的实验操作，提高学生的编程能力和解决问题的能力，培养学生的动手能力和团队协作精神。
二、实验内容1. 掌握类的概念和基本语法，包括类的定义、成员变量、成员函数等；2. 熟悉对象的概念和使用方法，了解对象的初始化和销毁；3. 学习类的继承和派生的知识，掌握继承与派生的语法和使用；4. 能够独立编写包含类和对象的程序，实现各种功能；5. 通过实践项目，提高自己的编程水平，锻炼解决问题的能力。
三、实验过程在实验过程中，首先我们需要了解类和对象的概念，理解类的定义和对象的创建方法。
编写简单的程序进行练习，例如创建一个包含学生信息的类，并实例化对象，调用成员函数来输出学生信息。
也需要深入学习类的继承和派生的知识，理解基类和派生类的关系，掌握虚函数的概念和使用方法。
在实验中，我们编写了多个实例程序来练习类的继承和派生，加深了对这一知识点的理解。
在实验过程中，我们还遇到了一些问题，例如在使用多重继承时需要特别注意类的构造和析构顺序，以及在使用虚函数时需要注意动态绑定的原理等。
通过解决这些问题，我们不断提高了自己的编程水平，加深了对C++语言的理解。
四、实验总结通过本次实验，我们深刻理解了类和对象的概念，掌握了类的定义和对象的创建方法。
在实验中，我们编写了多个功能丰富的程序，包括学生信息管理系统、图形类的继承等。
这些程序不仅巩固了所学的知识，也让我们感受到了编程的乐趣。
通过与同学的讨论和交流，我们也学到了很多新的知识和技巧。
本次实验对我们的帮助很大，让我们更深入地理解了C++程序设计语言，提高了我们的编程水平。
希望在以后的学习和实践中，能够进一步加深对类和对象的理解，不断提高自己的编程能力。
在本次的C++程序设计实验中，我们深入学习了类和对象的概念，并通过实际的编程练习加深了对C++程序设计语言的理解和应用。
类和对象实验报告
实验：类和对象System.out.println();}}}程序运行结果截图如下：2、用直接选择排序方法给一维数组{63,4,24,1,3,15}进行排序。
排序过程如下图所示：具体程序代码如下：package test;public class SelectSort {public static void main(String[] args){int array[]={63,4,24,1,3,15};SelectSort sorter=new SelectSort();sorter.sort(array);}public void sort(int[]array){int index;for(int i=1;i<array.length;i++){index=0;for(int j=1;j<=array.length-i;j++){if(array[j]>array[index]){index=j;}}int temp=array[array.length-i];array[array.length-i]=array[index];array[index]=temp;}showArray(array);}public void showArray(int[]array){System.out.println("选择排序的结果是：");for(int i:array){System.out.print(i+"\t");}System.out.println();}}程序运行结果截图如下：3、请编译下面程序段，如果出错，请写出出错原因，并修改程序使它正常运行。
public class Test4 {int x = 50;static int y =200 ;public static void method( ) {System.out.println(x+y);}public static void main(String[ ] args) {Test4.method( );}}具体程序代码如下：public class Test4 {static int x = 50;static int y =200 ;public static void method( ) {System.out.println(x+y);}public static void main(String[ ] args) {Test4.method( );}}程序运行结果截图如下：4、定义一个Father和Child类，并进行测试。
Java实验 类和对象
一、实验目的掌握类和对象的定义，以及它们之间的关系学习类中属性和方法的设计会用UML图来对类进行描述熟悉修饰符的作用，会用set/get方法对数据进行封装二、实验要求设计一个名为Rectangle的类表示矩形。
这个类包括：∙两个名为width和height的私有double型数据域。
用来表示宽、高。
默认值为1.0。
∙创建默认矩形的无参构造方法。
∙一个创建width和height为指定值的矩形的构造方法。
∙一个名为GetArea()的公有方法返回矩形面积double∙一个静态的Compare方法，比较两个矩形的面积大小是否相等并返回一个布尔型结果，相等返回true，不等返回false；画出UML 类图，实现Rectangle类，编写测试程序创建两个Rectangle类的对象。
第一个对象的width为1，height为1；第一个对象的width为5，height为6。
调用compare方法判断两个矩形是否相等并显示结果。
三、实验内容1.使用Jude工具绘制UML图2.编写代码实现类Rectanglepackage edu.neu.li.test;publicclass Rectangle {privatedouble width;privatedouble height;public Rectangle() {this.width = 1.0;this.height = 1.0;public Rectangle(double width, double height) {this.width = width;this.height = width;}publicdouble GetArea() {returnthis.width * this.height ;}publicstaticboolean Compare(Rectangle rec1, Rectangle rec2) { if(rec1.GetArea()==rec2.GetArea()){returntrue;}returnfalse;}}3.编写测试程序完成功能。
java类和对象的应用实验总结
Java类和对象的应用实验总结在Java编程语言中，类（Class）和对象（Object）是两个核心的概念。
类是对象的模板或蓝图，而对象则是类的实例。
通过使用类和对象，我们可以创建具有共享属性和方法的实体，也可以创建具有独特属性和行为的实体。
以下是我对Java类和对象应用实验的一些总结：类的定义和使用：在Java中，我们使用class关键字来定义一个类。
例如，我们可以创建一个名为Person的类，该类具有name、age 和height等属性，以及eat()和sleep()等方法。
我们可以通过创建类的实例（即对象）来使用类。
对象的创建和使用：我们使用new关键字来创建一个类的实例，这个实例就是一个对象。
例如，我们可以创建一个Person类的对象，并通过调用对象的方法来执行特定的行为。
我们也可以通过访问对象的属性来获取或修改对象的状态。
继承：Java中的类可以继承其他类的属性和方法。
通过继承，我们可以创建一个新的类，该类继承了父类的所有属性和方法，并可以添加自己的属性和方法。
这个过程被称为类的扩展或继承。
多态：在Java中，一个对象可以被引用为多种类型。
例如，我们可以有一个父类类型的引用指向一个子类对象。
当调用这个对象的方法时，会根据对象的实际类型来调用相应的方法。
这就是多态性的体现。
封装：封装是Java中一个重要的面向对象编程概念。
通过封装，我们可以将数据（属性）和处理数据的方法（方法）绑定在一起，形成一个独立的实体。
封装的目的是增加安全性和简化性，用户只知道对象提供哪些方法，至于内部的具体实现细节则一概不知。
通过这些实验，我深入理解了Java的类和对象的概念，以及它们在面向对象编程中的重要性。
这些实验也帮助我理解了如何使用类和对象来设计和实现复杂的系统。
类与对象的实验总结
类与对象的实验总结类与对象是面向对象编程中的重要概念，通过对类与对象的实验，我深入了解了它们的基本概念、特性和使用方法。
首先是对类的实验。
一个类是对象的抽象模板，它描述了对象的共同属性和行为。
在实验中，我创建了一个名为“Person”的类来描述人的属性和行为。
在类中，我定义了属性包括姓名（name）、年龄（age）和性别（gender），并通过构造函数来初始化这些属性。
我还定义了方法来获取和设置属性的值，以及一个方法来展示人的信息。
通过实例化该类，我创建了不同的人对象，每个对象具有不同的属性值。
这样，一个类可以创建多个对象，每个对象都有相同的属性和方法，但属性值可以不同。
这使得代码的复用性大大提高，并且能够方便地对对象进行操作和管理。
接下来是对对象的实验。
一个对象是类的一个实例，它具有类定义的属性和行为。
在实验中，我通过实例化“Person”类来创建了不同的人对象。
通过调用对象的方法，我可以获取和设置对象的属性值，以及展示对象的信息。
对象可以根据需求动态地改变自己的属性值，从而实现了对数据的灵活处理。
同时，对象之间可以相互调用对方的方法，实现了不同对象之间的交互与合作。
通过使用对象，我可以更加方便地管理和操作数据，使代码更加模块化和可维护。
在实验中，我还学习了类的继承和多态的概念，并实际操作了它们。
继承是一种机制，允许一个类从另一个类继承属性和方法。
通过创建一个子类，我可以继承父类的属性和方法，并可以在子类中添加新的属性和方法，或者重写父类的方法。
这种继承的关系使得代码更加灵活和可扩展，可以根据不同的需求创建不同的子类。
多态是一种机制，允许一个对象使用多种形态。
通过创建一个父类的对象，我可以将其赋值给父类和子类的变量，通过调用不同的变量实现对不同的方法的调用。
多态提高了代码的灵活性和可扩展性，使得代码更加易于拓展和维护。
在实验过程中，我遇到了一些问题，并通过实践得到了解决。
首先是对类的理解问题，刚开始接触类的概念时，我对类和对象之间的关系有些模糊，以及如何正确使用类和对象。
类和对象的实验报告
类和对象的实验报告类和对象的实验报告引言：在计算机科学领域，类和对象是面向对象编程（Object-Oriented Programming，简称OOP）的核心概念。
通过类和对象的使用，可以更好地组织和管理代码，提高代码的可重用性和可维护性。
本实验旨在通过实际操作，深入理解类和对象的概念以及它们在程序设计中的应用。
实验目的：1. 掌握类和对象的基本概念；2. 理解类的属性和方法的定义与使用；3. 熟悉对象的创建和使用过程；4. 学会通过类和对象实现程序的模块化和代码的重用。
实验过程：1. 定义类：首先，我们需要定义一个类来描述某个具体事物的属性和行为。
以“动物”为例，我们可以定义一个名为“Animal”的类，其中包含属性（如名称、年龄）和方法（如叫声、移动）。
2. 创建对象：在类的基础上，我们可以创建一个或多个对象，每个对象都是类的一个实例。
例如，我们可以创建一个名为“cat”的对象，代表一只猫。
3. 访问对象的属性和方法：通过对象，我们可以访问和修改类中定义的属性，并调用类中定义的方法。
例如，我们可以通过“”来获取猫的名称，通过“cat.age”来获取猫的年龄，通过“cat.meow()”来让猫发出叫声。
4. 类的继承：在某些情况下，我们可以创建一个新的类，该类继承了已有类的属性和方法，并可以在此基础上进行扩展。
例如，我们可以创建一个名为“Dog”的类，它继承了“Animal”类的属性和方法，并增加了额外的方法“bark()”。
实验结果：通过本次实验，我们成功地定义了“Animal”类和“Dog”类，并创建了相应的对象。
我们可以通过对象访问类中定义的属性和方法，实现了对动物的描述和操作。
此外，我们还学会了如何使用类的继承，提高了代码的重用性和可维护性。
实验总结：通过本次实验，我们深入理解了类和对象的概念，并掌握了它们在程序设计中的应用。
类和对象的使用可以更好地组织和管理代码，提高代码的可重用性和可维护性。
类与对象的设计实验报告
类与对象的设计实验报告一、实验目的本实验旨在通过设计类与对象，加深对面向对象编程的理解，掌握类的定义、对象的创建和调用以及类与对象之间的关系。
二、实验过程1. 类的定义首先根据需求分析，确定了需要设计的类，包括Student类和Course 类。
其中Student类包括学生的姓名、学号、性别和年龄等属性，还包括选修的课程信息；Course类包括课程的名称、学分和教师等属性。
pythonclass Student:def __init__(self, name, student_id, gender, age): = nameself.student_id = student_idself.gender = genderself.age = ageself.courses = []def add_course(self, course):self.courses.append(course)def show_courses(self):for course in self.courses:print(course)class Course:def __init__(self, name, credit, teacher): = nameself.credit = creditself.teacher = teacherdef __str__(self):return f"Course: {}, Credit: {self.credit}, Teacher: {self.teacher}"2. 对象的创建和调用在主程序中，我们可以创建相应的对象并进行属性赋值、方法调用等操作。
pythons1 = Student("Tom", 1001, "male", 18)c1 = Course("Math", 4, "Mr. Smith")c2 = Course("English", 3, "Ms. Johnson")s1.add_course(c1)s1.add_course(c2)s1.show_courses()3. 类与对象之间的关系通过调用对象的方法，我们可以为一个学生对象添加多门课程，进一步说明了类与对象之间的关系。
实验报告(类和对象1)
面向对象的编程C++ 课程实验报告课程名称面向对象的编程C++班级B0901 实验日期姓名贺军学号09405020107 实验成绩实验名称实验：类和对象（1）实验目的及要求了解面向对象程序设计基本原理及主要特点——抽象、封装、继承和多态，掌握类和对象的概念以及如何利用类来解决具体问题。
实验环境Visual C++集成环境、Windows XP 操作系统实验内容1. 写出声明一个称为Employee的类的代码，该类有一下数据成员：age、yearsOfService、Salary；重写Employee类使其数据成员为私有并提供公有方法来获得和设置每个数据成员；写一个带有Employee类的程序，生成两个Employees；设置它们的age、yearsOfService和Salary；且打印它们的值。
2. 定义一个Dog类，包含name、age、sex和weight等属性及对这些属性的操作方法。
实现并测试这个类。
参考输出结果：算法描述及实验步骤定义一个类Employee。
在主函数中，定义了该类的两个一般对象d1和d2，有定义了一个指向类Employee的指针pd，初始化后它指向对象d2。
通过调试成员函数setEmployee（）分别给对象d1和d2进行了赋值，即改变了这两个对象的数据成员的值。
根据给出的四个条件设置不同的类型的参数，在根据类的定义格式写出程序。
在定义name时，一定要注意设置参数。
调试过程及实验结果总结（对实验结果进行分析，问题回答，实验心得体会及改进意见）附录第一个程序：#include<iostream.h>class Employee{public:void setEmployee(int a,int b,int c){age=a;yearofservice=b;salary=c;}void Print(){cout<<"age="<<age<<"yearofservice="<<yearofservice<<"salary="<<salary<<endl;}private:int age,yearofservice,salary;};void main(){第二个程序：#include <iostream.h>#include <string.h>class Dog{public:Dog(char a[],int b,char c,float d){strcpy(name,a);age=b;sex=c;weight=d;}void print(){cout<<"Dog'name:"<<name<<endl;cout<<"Dog'age:"<<age<<endl;cout<<"Dog'sex:"<<sex<<endl;cout<<"Dog'weight:"<<weight<<endl;Employee d1,d2,*pd=&d2;d1.setEmployee(26,2,5000); pd->setEmployee(34,1,4800); d1.Print();d2.Print();}}private:char name[20];int age;char sex;float weight;};void main(){Dog d("旺财",3,'m',2.4);d.print();}。
实验一.类与对象实验报告
浙江理工大学信息学院面向对象程序设计实验报告实验名称：类的定义与使用学时安排：3实验类别：设计性实验实验要求：1人1组姓名：邵旸珂学号：2016329621068￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣一、实验目的1）掌握类的概念、类的定义格式、类与结构的关系、类的成员属性和类的封装性；2）掌握类对象的定义；3）理解类的成员的访问控制的含义，公有、私有和保护成员的区别；4）掌握构造函数和析构函数的含义与作用、定义方式和实现，能够根据要求正确定义和重载构造函数。
能够根据给定的要求定义类并实现类的成员函数；二、实验原理介绍通过建立类及对象，用类的成员函数和对象访问类的成员；利用建立类的构造函数，完成类的成员的初始化工作；三、实验设备介绍软件需求: windows或linux下的c++编译器硬件需求: 对于硬件方面的要求，建议配置是Pentium III 450以上的CPU 处理器，64MB以上的内存，200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。
四、实验内容编写一个程序，模拟电梯的功能。
功能接口包括电梯上行按钮、下行按钮、楼层选择和电梯在行驶过程中的楼层显示。
要求：1.由用户选择按上行按钮还是下行按钮，选择操作后再由用户输入要进入的楼层，进而电梯开始运行，显示所到的每一楼层层数。
2.如果是上行，则选择输入的楼层号不能比当前楼层号小，否则应给出不合法提示。
3. 如果是下行，则选择输入的楼层号不能比当前楼层号大，否则应给出不合法提示。
4.电梯一旦开始运作就会始终运行，直到窗口关闭。
5.电梯在经过不同楼层时，最好每个楼层的显示之间能有延迟，最终停靠的楼层的输出形式能更加醒目。
如果可以，在电梯最初开始运行时，能在电梯由内部显示当前日期（提示：实现这些功能时，需要调用系统api，实现时间显示功能可以使用CDate类）。
五程序清单#include <iostream>#include <ctime>#include <windows.h>using namespace std;int n,floorNumber;class Elevator{private:int floor; //电梯总的楼层数bool up; //是否上行,bool为布尔类型，可取值true或falsebool down; //是否下行int currentFloor; //当前所在楼层public:Elevator(int floor);void setUpButton(); //按下上行按钮void setDownButton(); //按下下行按钮void setFloorNumber(int floorNumber); //根据要进入的楼层电梯开始运行，并逐层显示经过的楼层int getCurrentFloor();//获得当前所在楼层void charge();int choice();};Elevator::Elevator(int f){floor =f;up=false;down=false;currentFloor=1;};void Elevator::setUpButton(){if(currentFloor>floorNumber){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"您不能上行！"<<endl<<endl;}else if(floorNumber>floor){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"没这一层！太高啦！您想上天？！"<<endl<<endl;}else up=true;}void Elevator::setDownButton(){if(currentFloor<floorNumber){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"您不能下行！"<<endl<<endl;}else if(floorNumber<1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"没这一层！太低啦！您想入地？！"<<endl<<endl;}else down=true;}void Elevator::setFloorNumber(int floorNumber){if(up){for(;currentFloor<floorNumber;currentFloor++){ cout<<"--"<<currentFloor<<"--"<<endl;Sleep(2000);}SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED);cout<<"第"<<currentFloor<<"层到了"<<endl<<endl;up=false;}if(down){for(;currentFloor>floorNumber;currentFloor--){ cout<<"--"<<currentFloor<<"--"<<endl;Sleep(2000);}SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED);cout<<"第"<<currentFloor<<"层到了"<<endl<<endl;down=false;}}int Elevator::getCurrentFloor(){return currentFloor;}int Elevator::choice(){cin>>n;if(n==2&&getCurrentFloor()==1){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"您已经在第一层了！除非您自己打洞，不然我是不会带你下去的！"<<endl<<endl;return 0;}switch(n){case 1:cout<<"请输入要进入的楼层"<<endl;cin>>floorNumber;setUpButton();setFloorNumber(floorNumber); break;case 2:cout<<"请输入要进入的楼层"<<endl;cin>>floorNumber;setDownButton();setFloorNumber(floorNumber); break;case 3:return -1;default:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREG ROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN);cout<<"只能选上升和下降！您难道还想玩电梯漂移？！"<<endl<<endl; break;}SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);cout<<"当前电梯停在"<<getCurrentFloor()<<"层"<<endl;}void Elevator::charge(){SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);cout<<"---请选择操作---"<<endl;cout<<"| 1.上升 |"<<endl;cout<<"| 2.下降 |"<<endl;cout<<"| 3.退出 |"<<endl;cout<<"|--------------|"<<endl;}int main(){long a;time(&a);int floor;cout<<"告诉我总共有几层"<<endl;cin>>floor;Elevator el(floor);SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_IN TENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);cout<<ctime(&a)<<endl;cout<<"本电梯共"<<floor<<"层，欢迎您的使用"<<endl<<endl;精选文档while(1){int i=0;el.charge();i=el.choice();if(i==-1) break;}return 0;}六运行结果七实验心得实验很有趣，让我初步体会了程序猿的感受。
类与对象基础实验（一）实验报告（精品）
浙江大学城市学院实验报告课程名称面向对象程序设计实验项目名称类与对象基础实验（一）学生姓名专业班级学号一. 实验目的和要求1. 掌握对象与类的关系2. 掌握类的域、方法、构造器的概念3. 掌握对象的创建与初始化4. 掌握方法和域（静态和非静态）的使用方式5. 掌握Math类，掌握静态成员的使用方式6. 理解方法和构造器重载现象二. 实验内容1. 程序阅读并回答问题2. 类的使用3. 编程实验：猜数字4. 编程实验：素数判断与统计三. 实验结果与分析（可将程序运行结果截屏，也可分析运行结果）1. . 程序阅读并回答问题：阅读实验讲义的对应代码，回答以下问题。
(1)将上述代码编译运行，将运行结果截图。
(2)上述源码中共定义了几个类？分别刻画了哪些数学图形？Triangle类有哪些域和方法？Triangle的这些域和方法是静态的还是非静态的？答：定义了三个类，分别刻画了求三角形，梯形，圆的周长以及面积问题Triangle类中域有double sideA,sideB,sideC,area,length;boolean boo;域是非静态的方法有double getLength()；public double getArea()以及public void setABC(double a,double b,double c)方法也是非静态的(3)类和对象是什么关系？请从上述AreaAndLength.java中举例说明如何创建对象。
答：类是对象的模版，对象是类的一个实例对象的创建利用构造器，比如在Triangle中存在着构造器Triangle(){};在最后的main函数中存在着triangle =new Triangle(3,5,4);创建函数对象并且赋值(4)Triangle类中出现的Math.sqrt是什么？请举例说明Math类中还有哪些常用域和方法？答：Math.sqrt为数学类中求开平方的静态方法area=Math.PI*radius*radius;得知math中存在Math.PI常用域常用的方法有Math.random（）返回随机数字等(5)静态域和方法与非静态域和方法在使用时有什么区别？请从上述AreaAndLength.java中举例说明。
类与对象实验报告
类与对象实验报告类与对象实验报告引言在计算机科学领域，类与对象是面向对象编程的基本概念之一。
通过定义类，我们可以创建对象，从而实现对数据和行为的封装和抽象。
本实验旨在通过实际操作，深入理解类与对象的概念，并掌握其在程序设计中的应用。
实验目的1. 理解类与对象的概念和关系；2. 学会使用类和对象进行数据封装和行为抽象；3. 掌握类与对象在程序设计中的应用。
实验过程1. 类的定义在本实验中，我们以一个简单的学生类为例进行说明。
首先，我们需要定义一个类来表示学生。
在类的定义中，我们可以包含学生的属性和行为。
比如，学生的姓名、年龄、性别等属性，以及学生的学习、休息等行为。
2. 对象的创建在类的定义完成后，我们可以通过创建对象来实例化这个类。
对象是类的具体实例，每个对象都有自己的属性和行为。
比如，我们可以创建一个名为"张三"的学生对象，给该对象的属性赋值，并调用对象的方法来执行相应的行为。
3. 属性的访问和修改通过对象，我们可以访问和修改类中定义的属性。
比如，我们可以通过对象的属性来获取学生的姓名和年龄，并通过修改属性的值来更新学生的信息。
4. 方法的调用类中的方法是对行为的抽象，通过方法，我们可以对对象进行操作。
比如，我们可以调用学生对象的学习方法，来模拟学生的学习行为。
同时，方法也可以接受参数，以实现更加灵活的功能。
实验结果通过实验，我们成功创建了一个学生类，并实例化了一个学生对象。
通过对象的属性和方法，我们可以获取和修改学生的信息，同时也可以模拟学生的行为。
这样，我们就实现了对学生的封装和抽象，提高了程序的可读性和可维护性。
实验总结通过本次实验，我深刻理解了类与对象的概念和关系。
类是对一类具有相同属性和行为的对象的抽象，而对象则是类的具体实例。
通过定义类和创建对象，我们可以实现对数据和行为的封装和抽象，提高了程序的可读性和可维护性。
在实际的程序设计中，类与对象是非常重要的概念，对于理解和应用面向对象编程具有重要意义。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一类和对象Visual C++ 6.0集成开发环境的使用：Visual C++系列产品是微软公司推出的一款优秀的C++集成开发环境，其产品定位为Windows 95/98、NT、2000 系列Win32 系统程序开发，由于其良好的界面和可操作性，被广泛应用。
由于2000 年以后，微软全面转向.NET 平台，Visual C++6.0 成为支持标准C/C++规范的最后版本。
1.启动安装完系统后，可以选择如下两种方式启动1) 点击Windows “开始”菜单，选择“程序”菜单下“Microsoft Visual Studio 6.0”子菜单下的快捷方式Microsoft Visual C++ 6.0 启动Visual C++ 6.0。
2) 点击Windows “开始”菜单，选择“运行”，输入msdev，即可启动。
启动后的界面如下：图 1 启动界面2.建立工程选择“File”菜单下的“New”菜单项或直接按Ctrl+N，启动新建向导，如图2 所示：图 2 新建向导选择在“Projects”属性页选择Win32 Console Application，在Project Name 中输入项目名称demo，在Location 中选择项目文件，如图2 中c:\test\demo，项目所有文件将保存在此文件。
输入完毕，单击确定按钮，进入下一界面如图3：图 3 项目类型向导在图 3 所示界面中选择a simple application，然后点击Finish 按钮，系统显示图4 所示界面。
如果想退回上一步可以选择“Back”按钮。
图 4 项目信息在图 4 中选择OK 按钮，系统完成项目的创建，并保存项目相关的信息。
项目的目录结构如图5 所示。
1) Demo.dsw 是项目工作区文件，双击此文件，即可打开此项目；2) Demo.dsp 为项目文件；3) demo.cpp 是项目中的一个源程序；stdafx.h 和stdafx.cpp 为自动创建的源程序，一般不用修改。
图 5 目录结构3.保存工程保存工程比较简单，选择File 菜单中的Save workspace 即可。
这还不够，项目由多个源程序构成，在保存工程时，需要保存相关的源程序，通过选择File 菜单中的Save 命令分别保存修改后的源程序即可。
4.打开工程选择File 菜单中的Open workspace，选择相应的项目工作区文件或项目文件即可，例如本例中打开“C:\test\demo\demo.dsw”即可，打开后的界面如图6 所示。
图 6 demo 项目1) 打开源程序文件有两种方式可以打开源程序文件。
a) 从File 菜单选择open 命令，输入相应文件名即可打开相关源程序，例如“C:\test\demo\demo.cpp”b) 在图6 所示FileView 页中选择相应的文件，单击即可。
2) 编辑源程序在图 6 所示主窗口中，即可直接编辑程序文件。
将文件demo.cpp 的内容修改如下：#include "stdafx.h"#include <stdio.h>int main(int argc, char* argv[]){printf("Hello, world\n");return 0;}3) 保存源程序选择File 菜单中的Save 命令即可保存当前文件，或直接按Ctrl+S4) 新建源程序选择File 菜单中的new 命令，在新建向导中，选择Files 属性，选择C++Source File，并在File 中输入文件名，单击OK 即可。
图7 新建文件向导5.编译源程序选择Build 菜单中的Compile 命令，或直接按Ctrl+F7 即可直接对当前打开的源程序进行编译，系统在如图8 所示界面显示代码中的编译结果。
图8 系统输出窗口6.链接程序选择Build 菜单中的Build 命令，或直接按F7 即可直接对当前项目进行链接，系统在如图9 所示窗口链接结果。
图9 链接结果7.运行程序选择Build 菜单中的Excute 命令，或直接按Ctrl+F5 即可直接运行，图10 为程序运行结果。
图10 运行结果一、实验目的1、练习C++对C语言的扩充部分内容的编程,并且通过练习调试程序能够总结出错信息，为以后的编程学习打下基础。
2、通过上机练习学会类和对象的定义方法。
3、熟悉构造函数和析构函数的特点和功能。
4、通过上机练习进一步弄清下述概念。
（1）对象数组、堆对象、子对象和常量对象；（2）指向类成员的指针，指向对象的指针，指向对象数组的指针、对象指针数组；（3）对象作为函数的参数、对象引用作为函数的参数和对象指针作为函数的参数。
二、实验环境硬件环境：PC586以上；操作系统：Windows 2000；系统软件：Visual C++ 6.0三、实验内容1．按教材P16-19的介绍的内容熟悉Visual C++ 6.0的基本用法，将例1.4，1.5的程序输入计算机中，用其练习单文序和多文件应用程序的实现方法；1.4#include<iostream.h>int add(int,int);void main(){int a,b;a=5;b=7;int c=add(a,b);cout<<"a+b="<<c<<endl;}int add(int x,int y){return x+y;}1.5f2.cpp#include<iostream.h>int add(int,int);void main(){int a,b;a=5;b=7;int c=add(a,b);cout<<"a+b="<<c<<endl;}f3.cppint add(int x,int y){return x+y;}2．P79教材中例3.2程序。
该程序段虽然不是一个完整程序，需要写出main()的内容，但是该程序中出现了条件编译预处理命令。
要求通过调试此程序练习对条件编译命令的使用；3．上机调试教材中P118例4.5程序。
注意该程序中出现了引用调用。
回答下列问题：（回答问题写入实验报告）#include<iostream.h>void swap3(int &x,int &y){int temp;temp=x;x=y;y=temp;cout<<"x="<<x<<","<<"y="<<y<<endl;}void main(){int a(5),b(9);swap3(a,b);cout<<"a="<<a<<","<<"b="<<b<<endl;}⑴引用调用和传值调用比较有什么不同？⑵引用调用和传址调用比较有什么不同？⑶引用调用在C++中为什么比传址调用使用的多？4．上机调试教材中P127例4.15程序，学会重载函数的定义方法。
函数重载的条件是什么？不满足条件的重载会出现什么问题？请上机试试。
（回答问题写入实验报告）#include<iostream.h>int min(int a,int b);int min(int a,int b,int c);int min(int a,int b,int c,int d);void main(){cout<<min(13,5,4,9)<<endl;cout<<min(-2,8,0);}int min(int a,int b){return a<b?a:b;}int min(int a,int b,int c){int t=min(a,b);return min(t,c);}int min(int a,int b,int c,int d){int t1=min(a,b);int t2=min(c,d);return min(t1,t2);}5、上机调试教材中例5.2程序。
熟悉类的定义方法和对象的定义方法，进一步了解对类中私有成员的操作方法。
#include<iostream.h>class TPoint{public:void SetPoint(int x,int y);int Xcoord(){return X;}int Ycoord() {return Y;}void Move(int xOffset,int yOffset);private:int X,Y;};void TPoint::SetPoint(int x,int y){X=x;Y=y;}void TPoint::Move(int xOffset,int yOffset){X+=xOffset;Y+=yOffset;}void main(){TPoint p1,p2;p1.SetPoint(3,5);p2.SetPoint(8,10);p1.Move(2,1);p2.Move(1,-2);cout<<"x1="<<p1.Xcoord()<<",y1="<<p1.Ycoord()<<endl;cout<<"x2="<<p2.Xcoord()<<",y2="<<p2.Ycoord()<<endl;}6、上机调试教材中例5.5程序。
在调试分析中，请注意下述语法内容：（回答问题写入实验报告）#include<iostream.h>class TPoint{public:TPoint(int x,int y){X=x;Y=y;}TPoint(TPoint&p);~TPoint(){cout<<"Destructor Called.\n";}int Xcoord(){return X;}int Ycoord(){return Y;}private:int X,Y;};TPoint::TPoint(TPoint&p){X=p.X;Y=p.Y;cout<<"Copy_initialization Constructor Called.\n";}TPoint f(TPoint Q);void main(){TPoint M(20,35),P(0,0);TPoint N(M);P=f(N);cout<<"P="<<P.Xcoord()<<","<<P.Ycoord()<<endl;}TPoint f(TPoint Q){cout<<"ok\n";int x,y;x=Q.Xcoord()+10;y=Q.Ycoord()+20;TPoint R(x,y);return R;}⑴构造函数，包括拷贝初始化构造函数的定义和调用；⑵对象作为函数参数时，如何将实参值传递给形参？⑶对象被创建后，何时调用析构函数来释放对象？⑷构造函数和析构函数是如何被自动调用的？7、上机调试教材中例5.11程序。