C++面向对象程序设计举例

【例8.1】最简单的例子。

#include <iostream>
using namespace std;
class Time //定义Time类
{
public : //数据成员为公用的
    int hour;
    int minute;
    int sec;
};
int main( )
{
    Time t1;//定义t1为Time类对象
    cin>>t1.hour;//输入设定的时间
    cin>>t1.minute;
    cin>>t1.sec;
    //输出时间:
    cout<<t1.hour<<":"<<t1.minute<<":"<<t1.sec<<endl;
    return 0;
}

运行情况如下：
1232 43↙
12:32:43

几点注意：
1) 在引用数据成员hour，minute，sec时不要忘记在前面指定对象名。

2) 不要错写为类名，如写成
Time.hour,Time.minute,Time.sec
是不对的。因为类是一种抽象的数据类型，并不是一个实体，也不占存储空间，而对象是实际存在的实体，是占存储空间的，其数据成员是有值的，可以被引用的。

3) 如果删去主函数的3个输入语句，即不向这些数据成员赋值，则它们的值是不可预知的。

【例8.2】引用多个对象的成员。

1） 程序(a)

#include <iostream>
using namespace std;
class Time
{
public :
int hour;
int minute;
int sec;
};
int main( )
{
    Time t1;//定义对象t1
    cin>>t1.hour;//向t1的数据成员输入数据
    cin>>t1.minute;
    cin>>t1.sec;
    cout<<t1.hour<<":"<<t1.minute<<":"<<t1.sec<<endl;//输出t1中数据成员的值
    Time t2;//定义对象t2
    cin>>t2.hour;//向t2的数据成员输入数据
    cin>>t2.minute;
    cin>>t2.sec;
    cout<<t2.hour<<":"<<t2.minute<<":"<<t2.sec<<endl;//输出t2中数据成员的值
    return 0;
}

运行情况如下：
1032 43↙
10:32:43
22 32 43↙
22:32:43

程序是清晰易懂的，但是在主函数中对不同的对象一一写出有关操作，会使程序冗长。为了解决这个问题，可以使用函数来进行输入和输出。见程序(b)。

2） 程序(b)

#include <iostream>
using namespace std;
class Time
{
public :
    int hour;
    int minute;
    int sec;
};
int main( )
{
    void set_time(Time&);//函数声明
    void show_time(Time&);//函数声明
    Time t1;//定义t1为Time类对象
    set_time(t1);//调用set_time函数，向t1对象中的数据成员输入数据
    show_time(t1);//调用show_time函数，输出t1对象中的数据
    Time t2;//定义t2为Time类对象
    set_time(t2);//调用set_time函数，向t2对象中的数据成员输入数据
    show_time(t2);//调用show_time函数，输出t2对象中的数据
    return 0;
}
void set_time(Time& t) //定义函数set_time，形参t是引用变量
{
    cin>>t.hour;//输入设定的时间
    cin>>t.minute;
    cin>>t.sec;
}
void show_time(Time& t) //定义函数show_time，形参t是引用变量
{
    cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;//输出对象中的数据
}

运行情况与程序(a)相同。

3) 程序(c)
可以对上面的程序作一些修改，数据成员的值不再由键盘输入，而在调用函数时由实参给出，并在函数中使用默认参数。将程序(b)第8行以下部分改为：

int main( )
{
    void set_time(Time&,int hour=0,int minute=0,int sec=0);//函数声明
    void show_time(Time&);//函数声明
    Time t1;
    set_time(t1,12,23,34);//通过实参传递时、分、秒的值
    show_time(t1);
    Time t2;
    set_time(t2);//使用默认的时、分、秒的值
    show_time(t2);
    return 0;
}
void set_time(Time& t,int hour,int minute,int sec)
{
    t.hour=hour;
    t.minute=minute;
    t.sec=sec;
}
void show_time(Time& t)
{
    cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;
}

程序运行时的输出为：
12:23:34 (t1中的时、分、秒)
0:0:0 (t2中的时、分、秒)

以上两个程序中定义的类都只有数据成员，没有成员函数，这显然没有体现出使用类的优越性。在下面的例子中，类体中就包含了成员函数。

【例8.3】将例8.2的程序改用含成员函数的类来处理。

#include <iostream>
using namespace std;
class Time
{
public :
    void set_time( );//公用成员函数
    void show_time( );//公用成员函数
private : //数据成员为私有
    int hour;
    int minute;
    int sec;
};
int main( )
{
    Time t1;//定义对象t1
    t1.set_time( );//调用对象t1的成员函数set_time，向t1的数据成员输入数据
    t1.show_time( );//调用对象t1的成员函数show_time，输出t1的数据成员的值
    Time t2;//定义对象t2
    t2.set_time( );//调用对象t2的成员函数set_time，向t2的数据成员输入数据
    t2.show_time( );//调用对象t2的成员函数show_time，输出t2的数据成员的值
    return 0;
}
void Time::set_time( ) //在类外定义set_time函数
{
    cin>>hour;
    cin>>minute;
    cin>>sec;
}
void Time::show_time( ) //在类外定义show_time函数
{
    cout<< hour<<":"<< minute<<":"<< sec<< endl;
}

运行情况与例8.2中的程序(a)相同。

几点注意：

在主函数中调用两个成员函数时，应指明对象名(t1,t2)。表示调用的是哪一个对象的成员函数。
在类外定义函数时，应指明函数的作用域(如void Time∷set_time( ))。在成员函数引用本对象的数据成员时，只需直接写数据成员名，这时C++系统会把它默认为本对象的数据成员。也可以显式地写出类名并使用域运算符。
应注意区分什么场合用域运算符“∷”，什么场合用成员运算符“.”，不要搞混。

【例8.4】找出一个整型数组中的元素的最大值。这个问题可以不用类的方法来解决，现在用类来处理，读者可以比较不同方法的特点。

#include <iostream>
using namespace std;
class Array_max //声明类
{
public : //以下3行为成员函数原型声明
    void set_value( ); //对数组元素设置值
    void max_value( ); //找出数组中的最大元素
    void show_value( ); //输出最大值
private :
    int array[10]; //整型数组
    int max; //max用来存放最大值
};
void Array_max::set_value( ) //成员函数定义，向数组元素输入数值
{
    int i;
    for (i=0;i<10;i++)
    cin>> array[i];
}

void Array_max::max_value( ) //成员函数定义，找数组元素中的最大值
{
    int i;
    max=array[0];
    for (i=1;i<10;i++)
    if(array[i]> max) max=array[i];
}
void Array_max::show_value( ) //成员函数定义，输出最大值
{
    cout<< "max="<< max;
}
int main( )
{
    Array_max arrmax; //定义对象arrmax
    arrmax.set_value( ); //调用arrmax的set_value函数，向数组元素输入数值
    arrmax.max_value( ); //调用arrmax的max_value函数，找出数组元素中的最大值
    arrmax.show_value( ); //调用arrmax的show_value函数，输出数组元素中的最大值
    return 0;
}

运行结果如下：
12 12 39 -34 17 134 045 -91 76↙ (输入10个元素的值)
max=134 (输入10个元素中的最大值)

请注意成员函数定义与调用成员函数的关系，定义成员函数只是设计了一组操作代码，并未实际执行，只有在被调用时才真正地执行这一组操作。

可以看出： 主函数很简单，语句很少，只是调用有关对象的成员函数，去完成相应的操作。在大多数情况下，主函数中甚至不出现控制结构(判断结构和循环结构)，而在成员函数中使用控制结构。在面向对象的程序设计中，最关键的工作是类的设计。所有的数据和对数据的操作都体现在类中。只要把类定义好，编写程序的工作就显得很简单了。