C语言程序员

C++ 类和对象

2019-06-30  本文已影响6人  _年少无为

序言

类（class）是面向对象程序设计的最基本的概念，是C++最强有力的特征，是进行封装和数据隐藏的工具，它将一个数据结构与一个操作集紧密地结合起来。类对象是类的实例，用类对象模拟现实世界中的事物比用数据对象更确切。

1、类的构成

1.1 从结构到类

结构是C的一种自定义的数据类型，它把相关联的数据元素组成一个单独的统一体。

例2.1有关日期结构的例子

#include <iostream.h>
struct Date {
    int year;
    int month;
    int day;
};
int main()
{
    Date date1;
    date1.year=2003;
    date1.month=8;
    date1.day=25;
    cout<<date1.year<<"."<<date1.month<<"."
    <<date1.day<<endl;
    return 0;
}

class与struct的比较

1.2 类的构成

类的成员分两部分：一部分对应数据的状态，称为数据成员，另一部分为作用于该数据状态的函数，称为成员函数。

类声明的一般格式如下:

class 类名 {
public:
    公有数据成员;
    公有成员函数;
protected:
    保护数据成员;
    保护成员函数;
private:
    私有数据成员;
    私有成员函数;
};

3个关键字： private、protected和public,称为访问权限关键字。每个关键字下面又都可以有数据成员和成员函数。

注意：

class Date {
public:
    void setDate(int y,int m,int d);
    void showDate();
private:
    int m_year;
    int m_month;
    int m_day;
};

2、成员函数的声明

成员函数的声明通常采用以下两种方式：

2.1 普通成员函数形式

即在类的声明中只给出成员函数的原型，而成员函数体写在类的外部。

返回类型 成员函数 (参数列表);

类外定义的一般形式是：

返回类型 类名∷成员函数名(参数表)
{
// 函数体
}

例如, 以下是表示坐标点的类Coord的声明

class Coord {
public:
    void setCoord (int,int); // 设置坐标点
    int getx(); // 取x坐标点
    int gety(); // 取y坐标点
private:
    int x,y;
};
void Coord∷setCoord(int a,int b){ x=a; y=b;}
int Coord::getx(){ return x;}
int Coord::gety(){ return y;}

内联函数和外联函数

类的成员函数可以分为内联函数和外联函数。

2.2 将成员函数以内联函数的形式进行说明

有两种格式将成员函数声明为类的内联函数：

（1）隐式声明 直接将函数声明在类内部。

class Coord{
public:
  void setCoord(int a,int b)
  { x=a; y=b;}
  int getx()
  { return x;}
  int gety()
  { retrun y;}
private:
  int x,y;
};

（2）显式声明

在类声明中只给出成员函数的原型，而成员函数体写在类的外部。为了使它起内联函数的作用，在成员函数返回类型前冠以关键字“inline”。

这种成员函数在类外定义的一般形式是：

inline 返回类型 类名::成员函数名(参数表)
{
// 函数体
}

class Coord{
public:
    void setCoord(int,int);
    int getx();
    int gety();
private:
    int x,y;
};
inline void Coord::setCoord(int a,int b)
{ x=a; y=b;}
inline int Coord::getx(){ return x;}
inline int Coord::gety(){ return y; }

说明

(1)使用inline说明内联函数时，必须使函数体和inline说明结合在一起，否则编译器将它作为普通函数处理。

inline void Coord:: setCoord(int ,int);
// 不能说明这是一个内联函数

(2) 通常只有较短的成员函数才定义为内联函数，对较长的成员函数最好作为一般函数处理。

class Date{
public:
    void showDate();
private:
    int year;
    int month;
    int day;
};
inline void Date::showDate()
{cout<<year<<'.';<<month<<'.'<<day<<endl;}

3、对象的定义和使用

类与对象的关系

通常我们把具有共同属性和行为的事物所构成的集合叫做类。

在C++中,可以把相同数据结构和相同操作集的对象看成属于同一类。

在C++中，类也是一种用户自定义数据类型，类的对象可以看成是该类类型的一个实例，定义一个对象和定义一个变量相似。类与对象间的关系，可以用数据类型int和整型变量i之间的关系类比。

C++把类的变量叫做类的对象，对象也称为类的实例。

3.1 对象的定义

对象的定义， 也称对象的创建

在C++中可以用以下两种方法定义对象：

(1) 在声明类的同时,直接定义对象。

class Coord {
public:
    void setCoord(int,int);
    int getx();
    int gety();
private:
    int x,y;
} op1,op2;

(2) 声明了类之后,在使用时再定义对象

class Coord {
    //…
};
// …
main()
{
    Coord op1,op2;
    // …
}

说明：

3.2 对象中成员的访问

当定义了一个类的对象后，就可以访问对象的成员了。在类的外部可以通过类的对象对公有成员进行访问,访问对象成员要使用操作符“.”。

访问的一般形式是：

其中“.”叫做对象选择符,简称点运算符。

例2.2 使用类Coord的完整程序

#include<iostream.h>
class Coord {
public：
    void setCoord(int a,int b)
    { x=a; y=b; }
    int getx()
    { return x; }
    int gety()
    { return y; }
private：
    int x,y;
};
void main()
{
    Coord op1,op2;
    int i,j;
    op1.setCoord(5,6); // 调用op1的setCoord()，初始化对象op1
    op2.setCoord(7,8); // 调用op2的setCoord()，初始化对象op2
    i=op1.getx(); // 调用op1的getx()，取op1的x值
    j=op1.gety(); // 调用op1的gety()，取op1的y值
    cout<<"op1 i= "<<i<<" op1 j= "<<j<<endl;
    i=op2.getx(); // 调用op2的getx()，取op2的x值
    j=op2.gety(); // 调用op2的gety()，取op2的y值
    cout<<"op2 i= "<<i<<" op2 j= "<<j<<endl;
}

说明：

void main( )
{
   Date date1;
   date1.setDate(2006,9,21);
   //……
}

在类的内部所有成员之间都可以通过成员函数直接访问，但是类的外部不能访问对象的私有成员。

例2.3 一个存在错误的程序

#include <iostream.h>
class Date {
public:
    void setDate(int y,int m,int d);
    void showDate();
private:
    int year;
    int month;
    int day;
};
void Date∷setDate(int y,int m,int d)
{
    year=y;
    month=m;
    day=d;
}
inline void Date∷showDate()
{
    cout<<year<<"."<<month<<"."<<day<<endl;
}
void main()
{
    Date date1,date2;
    cout<<"Date1 set and output:"<<endl;
    date1.setDate(1998,4,28);
    cout<<date1.year<<"."<<date1.month<<"."<<date1.day<<endl; //错误
    date1.showDate();
    cout<<"Date2 set and output： "<<endl;
    date2.setDate(2002,11,14);
    cout<<date2.year<<"."<<date2.month<<"."<<date2.day<<endl; //错误
    date2.showDate();•
}

在定义对象时，若定义的是指向对象的指针，则访问此对象的成员时，要用“->”操作符。

void main( )
{
    Date *date3;
    date3->setDate(2001,8,15);
    //……
}

3.3 类成员的访问属性

类成员有三种访问属性:公有（public）、 私有（private） 和保护（protected） 。

类的成员对类对象的可见性和对类的成员函数的可见性是不同的。

类的成员函数可以访问类的所有成员，而类的对象对类的成员的访问是受类成员的访问属性的制约的。

3.4 类中成员的访问方式

class Sample{
public:
    int k;
    int geti(){return i;}
    int getj(){return j;}int getk(){return k;}
private:
    int i;
protected:
    int j;
};
//……
Sample a; //定义类Sample的对象a
a.i; //非法，类Sample的对象a不能访问类的私有成员i
a.j; //非法，类Sample的对象a不能访问类的保护成员j
a.k; //合法，类Sample的对象a能访问类的公有成员k
//……

一般来说，公有成员是类的对外接口，而私有成员和保护成员是类的内部数据和内部实现，不希望外界访问。

将类的成员划分为不同的访问级别有两个好处：一是信息隐蔽，即实现封装；二是数据保护，即将类的重要信息保护起来，以免其它程序不恰当地修改。

3.5 对象赋值语句

两个同类型的变量之间可以相互赋值。同类型的对象间也可以进行赋值，当一个对象赋值给另一个对象时，所有的数据成员都会逐位拷贝。

例2.5

#include<iostream.h>
class abc{
public:
    void init(int i,int j) { a=i; b=j; }
    void show(){ cout<<a<<" "<<b<<endl; }
private:
    int a,b;
};
main()
{
    abc o1,o2;
    o1.init(12,34);
    o2=o1; // 将对象o1数据成员的值赋给对象o2
    o1.show();
    o2.show();
    return 0;
}

说明：

3.6 类的作用域

所谓类的作用域就是指在类声明中的一对花括号所形成的作用域。

例2.6 理解类的作用域

# include<iostream.h>
class myclass{
public:
    int i;
    void init(int);
    void show(){ cout<<“i=” <<i<<endl;} // 可以访问类中的数据成员i
};
void myclass::init(int si){ i=si;} // 可以访问类中的数据成员i
int fun(){ return i; } // 非法,不能直接访问类中的i
void main()
{
    myclass ob;
    ob.init(5); // 给数据成员i赋初值5
    ob.show();
    i=8; // 非法,不能直接访问类中的i,可改写成ob.i=8
    ob.show();
}
上一篇下一篇

猜你喜欢

热点阅读