实验二 类和对象的定义与使用

课程名称 类和对象的定义与使用 实验日期2010/04/01       成绩         

同组实验者                      

protected：

<类成员的说明或定义>

public：

<类成员的说明和定义>

}；

<类成员函数的定义>

<类型> <类名>::<成员函数名>（<形参表>）

{函数体；}

(2)基本要求

了解类的定义格式和说明格式，了解类在程序的作用。

2．对象的定义

(1)问题描述

对象是类的具体实例，是面向对象的核心概念，是组成程序的实体，在程序中使用的是利用类建立的对象，抽象的类是不能够使用的，因此必须将其具体化，这就是引进对象的原因。

对象的定义格式

<类名> <对象名表>;

有关解释：

a.可以同时定义多个对象，不同对象之间用逗号相隔。

b.可以定义对象指针，格式如下：

<类名> *<对象指针>=&<普通对象>;

普通对象对类成员的调用

<对象名>.<公有数据成员>

<对象名>.<公有成员函数>（<实参表>）

对象指针

<对象指针名>-><公有数据成员>

<对象指针名>-><公有成员函数>（<实参表>）;

不难看出，还可以如下格式的调用：

<*对象指针名>.<公有数据成员>

(*<对象指针名>.<公有成员函数>)（<实参表>）;

(2)基本要求

{Time t1(10,13,56);

 Date d1(12,25,2004);

 t1.display(d1);

 return 0;

}

测试结果：

例2

#include

class Student

 {public:

   Student(int n,float s):num(n),score(s){}

   void change(int n,float s) {num=n;score=s;}

void display(){cout<  private:

   int num;

   float score;

 };

int main()

{Student stud(101,78.5);

 stud.display();

 stud.change(101,80.5);

 stud.display();

 return 0;

}

测试结果：

3．对象的初始化和删除

(1)问题描述

对象建立的时候系统自动调用构造函数，对象在删除时候系统自动调用析构函数。构造函数与析构函数是类中特殊的成员函数，决定了类对象的创建、初始化、拷贝和删除。它们具有普通成员函数的许多特性，可以在类内说明和定义它们，也可以在类内进行说明而在类外定义它们。

(1)基本要求

熟悉构造函数与析构函数，并且了解缺省构造函数和缺省析构函数，至于拷贝初始化构造函数观察它的三种调用时机。

(3) 实验程序

例4#include 

class Point

{

public:

    Point(int i,int j)     //构造函数

    {

        x=i;

        y=j;

        cout<<"constructor called"<    }

    Point()          //缺省构造函数

    {

        x=y=0;

        cout<<"default constructor called"<    }

    ~Point()       //析构函数

    {

        cout<<"destructor called"<    Point(int i,int j)     //构造函数

{

        x=i;

        y=j;

        cout<<"constructor called"<    }

    Point()          //缺省构造函数

    {

        x=y=0;

        cout<<"default constructor called"<    }

    ~Point()       //析构函数

    {

        cout<<"destructor called"<    }

Point(Point &p)

{

x=p.x;

y=p.y;

cout<<“copy constructor called”<}

    void Setxy(int x,int y)

    {

        i=x;

        j=y;

    }

    void Print();

private:

    int x,y,i,j;

};

void Point::Print()

{

cout<<"("<}

void main()

{

    Point p1(1,2);

    Point p2(p1);

    p2.Print();

}

测试结果：

};

A fun(A a)

{

cout<<"Hi"<    int x=10;

    int y=20;

    A r(x,y);

    return r;

}

void main()

{

    A aa1(1,2),aa2;

    A aa3(aa1);

    aa2=fun(aa3);

    aa2.print();

}

测试结果：

3．成员函数的特性

(1)问题描述

成员函数有类似普通函数相同的性质，可以设置参数缺省值、可以设置为内联函数和可以进行函数重载。

(2)基本要求

根据实验程序了解掌握成员函数的有关特性。

(3)实验程序

例7#include 

class A

    例8#include 

class A 

{

public:

    A(int i)

{

        x=i;

        y=i*i;

cout<<"con1"<    }

    A(int i,int j)

    {

        x=i;

        y=j;

        cout<<"con2"<    }

    int add()

    {

        return x+y;

    }

    int add(int i)

    {

        return i+x+y;

    }

    int add(int i,int j)

    {

        return i+j;

    }

private:

    int x,y;

};

void main()

{

    A a1(5),a2(10,20);

cout< cout< cout<}

测试结果：

    }

private:

    int a;

    char name[80];

};

void main()

{

    A a1("echo"),a2(33);

    a1.set(32);

    a2.set("sam");

    a1.print();

    a2.print();

}

测试结果：

例10#include 

class A

{

public:

    A(int i,int j)  //内联函数

    {

        a1=i;

        a2=j;

    }

    void print();   //外联函数

private:

    int a1,a2;

都是一样的，因为返回的都是同一个b，即11。

例12中show是静态成员函数，因此可以直接操作静态数据成员（y），但是不能直接操作非静态数据成员（x），因此必须通过实参传递的对象对调用x（r.x）。因此静态成员函数比非静态成员函数的访问权限小。

(3)实验程序

例11#include 

class X

{

    int a;

    static int b;

public:

    X()

    {

        a=0;

    }

    X(int i)

    {

        a=i;

        b++;

    }

    X(X &p)

    {

        a=p.a;

        b+=a;

    }

    int getb()

    {

        return b;

    }

};

int X::b=0;

void main()

{

    X a1,a2(10),a3(a2);

cout<}

测试结果：

测试结果：

                                                    教师签字：

  年  月  日

一、实验目的

1．掌握类的定义格式。

2．掌握C++对C语言的本质扩展，以对象和类编制程序。

二、实验预备知识

对象就是面向对象的核心概念，是组成程序的实体。其实说的通俗一些,对象就是一个物体或者是一个实体,我们的现实世界到处都充斥着对象,因为他们都是自包含的封闭的“小包”。对于一个对象而言，应该具有对象名以区别于其他对象，还需要有特征来描述对象的特点，另外还需要有操作和行为。对象的特征可以利用属性这个关键字来描述，这又有两层涵义，一是属性项，不同对象拥有的属性项是不一样的，即从哪些方面去描述对象，二是属性值，就是属性项的具体取值，在C++中利用数据成员实现。对象能够完成的行为又可以分为自身承受的操作和施加于其他对象的操作，在C++中利用成员函数实现。对象的特点（1）易维护性。（2）性。（3）连接性。

所谓类就是一组客观对象的抽象，是抽象的概念，而对象就是类的具体实例，因此是具体的概念。在C++程序编制过程中，是先建立类，在建立类的基础上再建立对象，是先抽象再具体。对于同类的对象应该具有以下特点（1）具有不同的对象名。（2）具有相同的属性项和不同的属性值。（3）具有相同的操作和行为。

三、实验内容

1．类的定义

(2)问题描述

类的定义格式与结构体定义的格式相似，其基本形式如下：

class 类名 

{

private：

了解对象在程序的作用，只有类没有对象，对于程序而言是没有意义的。

(3)实验程序

例1

#include

class Date;

class Time

 {public:

   Time(int,int,int);

   void display(const Date&);

  private:

   int hour;

   int minute;

   int sec;

 };

 class Date

 {public:

   Date(int,int,int);

   friend void Time::display(const Date &);

  private:

   int month;

   int day;

   int year;

 };

 Time::Time(int h,int m,int s)

 {hour=h;

  minute=m;

  sec=s;

 }

void Time::display(const Date &da)

{cout<cout< }

Date::Date(int m,int d,int y)

 {month=m;

  day=d;

  year=y;

 }

int main()

测试结果：

例3

#include

template

class Compare

 {public:

   Compare(numtype a,numtype b)

    {x=a;y=b;}

   numtype max()

{return (x>y)?x:y;}

   numtype min()

{return (x  private:

    numtype x,y;

 };

int main()

{Compare cmp1(3,7);

cout<cout<Compare cmp2(45.78,93.6);

cout<cout<Compare cmp3('a','A');

cout<cout< return 0;

}

测试结果：

}

    void Setxy(int x,int y)

    {

        i=x;

        j=y;

    }

    void Print()；

private:

    int x,y,i,j;

};

void Point::Print()

{

cout<<"("<}

void main()

{

    Point p1(1,2),p2;

    p2.Setxy(3,4);

    p1.Print();

    p2.Print();

}

测试结果：

例5#include 

class Point

{

public:

例6#include 

class A

{

public:

    A(int i=0,int j=0)

    {

        a1=i;

        a2=j;

        cout<<"con."<    }

    A(const A &p)

    {

        a1=p.a1;

        a2=p.a2;

        cout<<"copy."<    }

    ~A()

    {

        cout<<"des."<    }

    void print()

    {

        cout<    }

private:

    int a1,a2;

{

public:

    A(int i=0,int j=0)

    {

        x=i;

        y=j;

    }

    void print()

    {

        cout<<"x="<    }

private:

    int x,y;

};

void main()

{

    A a1,a2(1),a3(2,3);

    a1.print();

    a2.print();

    a3.print();

}

例9#include 

#include

class A

{

public:

    A(char *s)

    {

        strcpy(name,s);

        cout<<"con.string"<    }

    A(int i)

    {

        a=i;

        cout<<"con.int"<    }

    void set(int i)

    {

        a=i;

    }

    void set(char *s)

    {

        strcpy(name,s);

    }

    void print()

    {

        cout<};

inline void A::print() //利用inline将外联函数转换成内联函数

{

    cout<}

void main()

{

    A x(1,2),y(2,3);

    x.print();

    y.print();

}

测试结果：

5．静态成员

(1)问题描述

静态成员包括静态数据成员和静态成员函数，静态数据成员在类内定义，在类外初始化，且必须初始化，且只初始化一次。静态数据成员属于类，而不是对象，任何对象对静态数据成员的改变，对其他对象都是有效的。静态成员函数可以直接调用类中静态数据成员不可以直接调用类中非静态数据成员，可以通过函数形参调用类中的静态数据成员

(2)基本要求

例11中在类中设置了一个静态数据成员b，并且在类外初始化，初始化可以放在类外的任何位置。因b是静态数据成员，因此，它属于类，是所有对象共有的，任何对象对它的改变对其他对象都是有效的。在创建a1时，因为没有给出参数，因此调用缺省构造函数，将a1中a赋0，并没有改变b的数值。在创建a2对象时，调用具有一个参数的构造函数，将a2中的a赋10，并将b的数值改成1（b++;），这时，对于已经存在的对象a1和a2而言，静态数据成员的数值均为1。在创建a3时，调用拷贝初始化构造函数，将a2的非静态数据成员（a）的数值传递给a3中的（a），并对b进行累加的工作（b+=a;）,因此b的数值此时已经被改成11。当三个对象都建立后，静态数据成员的数值就已经被设置为11。利用a1调用getb()，和利用a2或者a3

例12#include 

class A

{

    int x;

    static int y;

public:

    A(int i=0)

    {

        x=i;

        y+=x;

    }

    static void show(A r)

    {

        cout<<"y="<    }

};

void main()

{

    A a1(3);

    A::show(a1);

    A a2(4),a3(10);

    A::show(a3);

}

int A::y=0;