C++中(封闭)类的定义及使用特性---知识要点篇1

1、类的含义

在面向对象的编程中，类是其核心特征，通常被称为用户定义的类型。
特征：类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类被称为类的成员。

2、定义

定义一个类，本质上是定义一个数据类型的蓝图

class Box
{
   public:
      double length;   // Length of a box
      double breadth;  // Breadth of a box
      double height;   // Height of a box
};
1
2
3
4
5
6
7

类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。关键字 public 确定了类成员的访问属性。

2.2 数据隐藏

作用 ：数据隐藏是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。
类成员的访问限制是通过在类主体内部对各个区域标记 public、private（）、protected 来指定的。

• 公有（public）成员：在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值，
• 私有（private）成员：变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。默认情况下，类的所有成员都是私有的。
• 保护（protected）成员：变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

具体实例见：http://www.codebaoku.com/cpp/cpp-class-access-modifiers.html

2.3 构造函数和析构函数

类的构造函数 是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
特性 ：构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值；默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
特性：析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

实例：

#include 
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

编译执行的结果为：

Object is being created
Length of line : 6
Object is being deleted
1
2
3

3、封闭类

定义 ：有成员对象的类，举例：普通类分为了轮胎类,引擎类,…可将封闭类可以看作一个完整的汽车，包含有轮胎、引擎等类。

定义：

#include
using namespace std;
class CCar{ //汽车类 
private:
  int price; //汽车的价格 
  CTyre tyre; //汽车的轮胎   已定义的普通类
  CEngine engine; //汽车的引擎   已定义的普通类
public:
CCar(int p){//构造函数 
  price=p; //赋值 
} 
~CCar(){ //析构函数 
  printf("%d\n",price); //只用输出这个价格 
}                         //因为轮胎和引擎类消亡后会自动使用祈构函数      
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

封闭类使用的注意事项

任何生成封闭类的语句,都要让编译器明白,对象中的成员对象,是如何进行初始化的.

• 封闭类对象生成时,先执行所有对象成员的构造函数,然后才执行封闭类自己的构造函数.

• 对象成员的构造函数调用次序和对象成员在类中的说明次序一致.

• 和构造函数正好相反,当封闭类对象消亡时,先执行封闭类的析构函数,然后再执行成员对象的析构函数.调用次序也和构造函数的调用次序相反.

完整实例代码

#include
using namespace std;
class CEngine{ //引擎类 
  private:
      bool use; //是否正在使用
      bool good_bad; //这个引擎是好的还是坏的
      int parts; //零件的个数
      string production; //生产公司的名称
  public:
  CEngine(){ //构造函数初始化 
      use=false;
      good_bad=true;
      parts=10000; //一般汽车引擎就是这么多零件
      production="丰田汽车"; //目前世界上最大汽车公司 
  } 
  ~CEngine(){ //析构函数 
      cout<<use<<" "<<good_bad<<" "<<parts<<" "<<production<<endl;
  }
  /*
  ......  这个引擎是否是好的 
  ......  这个引擎现在在使用吗? 
  ......  等等 
  */
};
class CTyre{ //轮胎类 
  private:
      int redius; //半径
      int width;  //宽度或长度
      int height; //高度
  public:
  CTyre(){ //构造函数 
      redius=0,width=0,height=0; //赋值 
  } 
  ~CTyre(){ //析构函数 
      printf("%d %d %d\n",redius,width,height); //类销毁时输出这3个成员的值 
  }
  /*
  ......  圆的体积 
  ......  圆的表面积 
  ......  等等 
  */
};
class CCar{ //汽车类 
  private:
      int price; //汽车的价格 
      CTyre tyre; //汽车的轮胎 
      CEngine engine; //汽车的引擎
  public:
  CCar(int p){//构造函数 
      price=p; //赋值 
  } 
  ~CCar(){ //析构函数 
      printf("%d\n",price); //只用输出这个价格 
  }                         //因为轮胎和引擎类消亡后会自动使用祈构函数      
};
int main(){
  CCar a(10000);
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

程序编译运行输出：

1000 
0 1 10000 Toyato
0 0 0 
1
2
3

小结

类的使用总结