初识C++类

　　认识类，先认识对象。

　　1. 对象：一个对象标识现实世界中独一无二的实体。例如，一名学生，一张桌子，一个圆……一个对象具备惟一的身份、状态和行为。对象的状态用数据域（data fileds）来表示，也成为对象的属性，在程序实现中用变量、数组来体现。对象的行为用一组函数来表示，对对象调用一个函数就是请求对象执行一个任务。

　　2. 类（class）：类是相同类型的对象的一个通用模版。在C++类中，用变量定义数据域，用函数定义行为。同时一个类还提供了一些特殊的函数——构造函数（constructor），在建立新的对象时候，这些函数会被调用。

 1 class Circle
 2 {
 3 public:
 4     // The radius of this circle -----data filed
 5     double radius;
 6 
 7     // Constructor function on argument
 8     Circle()  //--- default. Name is same to the class name
 9    {
10         radius = 1.0;  
11     }
12    
13    // Constructor function on argument
14    Circle(double newradius)  // no return type, include void
15     {
16        radius = newraduis;  
17     }
18 
19     // function
20    double getArea()
21     {
22         return radius*radius*3.1415926;
23     }         
24 };

　　3. 构造函数

　　　　一个类的构造函数的名字与类名是相同的。构造函数能够被重载，只要它们的签名（原型）不同。

　　　　一个类一般都会有一个无实参的构造函数，例如Circle()，若是一个类中没有构造函数被声明，C++会隐含的声明这样一个无实参的空构造函数。

　　　　构造函数没有返回类型，即函数名前面没有类型关键字。

　　　　其做用是建立对象并初始化。

　　 关于默认构造函数：

          默认构造函数让“声明对象但不初始化”成为了可能。即：

               Circle  C1;  // 这里正是调用了默认构造函数    等价于  int x;

         当且仅当没有定义任何构造函数时，编译器才会提供默认构造函数。即：若是定义了一个非默认的构造函数，则默认的构造函数就不存在。此时“声明对象且不初始化”将出错。

          定义默认构造函数有两种方式：

              （1） 给已有的构造函数的参数提供全部的默认值。

                  Circle(double radius=10);

              （2） 经过函数重载来定义另外一个构造函数。   

            Circle()  //--- default. Name is same to the class name

            {

 radius = 1.0;  }

 

　　4. 对象

　　建立对象的语法：

ClassName　　variableName;
ClassName　　variableName(arguments);　　// 带参数的构造函数建立对象

例如：Circle circle1;
Circle circle2(10.2);

 

　　访问对象：当一个对象建立之后，能够用对象成员访问运算符（. ，点运算符）来访问对象的数据和调用对象的函数。

objectName.dataFiled
objectName.function(argument)

　　5. 关键字public

　　　　　代表全部的数据域、构造函数和普通成员函数都是能够经过类对象来访问的。

 

　　6. 匿名对象（anonymous object）：当须要建立一个对象，而且只使用一次的时候能够建立为匿名对象。

　　

// 无参数构造函数建立匿名对象
ClassName()
// 带参数构造函数建立匿名对象
ClassName(arguments)

// 建立了一个对象，并将其内容复制给circle1
circle1 = Circle();

circle2 = Circle(5.0);

　　

　　注意：

　　　　1） 与普通变量相似，可使用赋值运算符（=）来进行对象间的复制。

　　　　circle1 = circle2;　　// 将对象circle2的内容复制给circle1，circle1和circle2仍然是两个不一样的对象；

　　　　2）和数组名同样。一旦一个对象被声明以后，它是独一无二的，是一个特定的对象，不能对它从新赋值，让他表示另一个对象。

 

 

 

类的声明和实现分离

　　　C++容许将类的声明和实现分离。类声明描述了类的约定（数据域的定义和函数的原型），而类实现则实现了这一约定。声明放在.h文件中，实现放在.cpp文件中，实现和分离应该使用相同的名字。在实现中应该用#indclude “**.h”包含声明文件。

　　　在实现文件（.cpp）中，全部的函数名以前必须有ClassName::，以代表该函数是定义域这个类中的。::称为二元做用于解析运算符。

　　Circle.h

 1 class Circle
 2 {
 3 public:
 4     // The radius of this circle -----data filed
 5     double radius;
 6 
 7     // Constructor function on argument
 8     Circle()  //--- default. Name is same to the class name
 
13    // Constructor function on argument
14    Circle(double newradius)  // no return type, include void
18 
19     // function
20    double getArea()      
24 };

Circle.cpp

#include "Circle.h"

 7     // Constructor function on argument
 8     Circle::Circle()  //--- default. Name is same to the class name
 9    {
10         radius = 1.0;  
11     }
12    
13    // Constructor function on argument
14    Circle::Circle(double newradius)  // no return type, include void
15     {
16        radius = newraduis;  
17       }
18 
19     // function
20    double Circle::getArea()
21     {
22         return radius*radius*3.1415926;
23      }         
24 };

注意：若是一个函数在类声明（.h）内实现的，那么它就自动成为一个内联（inline）函数。

 

　　对象指针

　　能够定义一个对象指针变量，而后将一个对象的地址赋值给该指针变量，而后用该指针变量来使用访问对象。

　　

Circle circle1;
Circle *pCircle = &circle1;

　　利用指针访问对象成员（间接访问）：

　　1）解除指针引用，而后用点运算符访问：　　（*pCircle）.radius　　　　（*pCircle）.getArea()

　　2) 箭头运算符（->）：直接经过指针变量访问。　　pCircle->radius　　　　pCircle->getArea()

 

　　动态建立对象

　　ClassName *pObject;

　　pObject = new ClassName(arguments);

　　delete pObject;

 

　　数据域封装

　　为防止客户端程序直接修改类的属性（数据域），应该使用private关键字，将数据域声明为私有的，这就是数据域封装。若是一个数据域是私有的，那么在类以外的程序中，将没法经过直接引用类对象来访问它。 为使私有数据域能够被访问，能够定义一个成员函数get返回数据域的值，定义一个set函数为数据域设置新的值。

　

 1  class Circle
 2  {
 3  
 4      // Constructor function on argument
 5      Circle()  //--- default. Name is same to the class name
 6     {
 7          radius = 1.0;  
 8     }
 9    
10     // Constructor function on argument
11     Circle(double newradius)  // no return type, include void
12      {
13         radius = newraduis;  
14        }
15  
16      // function
17     double getArea()
18      {
19         return radius*radius*3.1415926;
20      }        
21        
22        // Return the radius of this circle
23        double getRadius()
24       {
25             return radius;
26       }
27 
28       // Set a new radius
29       double setRadius(double newRadius)
30      {
31         radius = (newRadius >= 0) ? newRadius : 0;
32        }
33 
34 
35 private:
36      // The radius of this circle -----data filed
37      double radius;
38  
39  };

 

   变量的做用域： 数据域定义为变量的形式，能够被类中的全部构造函数和成员函数访问，并且数据域和函数的声明顺序能够是任意的。

　　在类中，函数内声明的变量为局部变量，其做用域是在函数代码块内。可是局部变量的优先级比数据域高，若是两者的名字相同，则在函数中，数据域的值江北覆盖。所以，在类声明中，数据域和局部变量的名字不能相同。

 

　　this指针

　　前面说过的变量的做用域里，在类中局部变量的优先级比数据域高。有时候在类里面的构造函数或者成员函数中，要用数据域作参数，要访问数据域，这时这个参数就会覆盖掉数据域，为了不这种覆盖，能够用this指针。this指针是C++内置的一个特殊指针，用于引用（当前函数）的调用对象。

13    // Constructor function on argument
14    Circle::Circle(double radius)  // radius is a local variable
15     {
16        this->radius = raduis;  // this point to current object
17       }
18 

 

　　构造函数初始化列表

　　语法：

　　　　

ClassName(paramentList)

:datafiled1(value1), datafiled2(value2) //初始化列表，前面有个冒号，最后没有逗号

例如：

　　

1       // Constructor function on argument
2       Circle()  //--- default. Name is same to the class name
3       : radius(1.0)　　// 初始化列表
4      {
5      }

当一个数据域是一个对象，而这个对象又没有无实参构造函数，那么就必须使用初始化列表了。

由于在类中声明一个对象（做为数据域），会自动的调用这个对象的类的构造函数，以建立该数据域对象。同时，和变量同样，在类中建立对象是不能直接初始化的（即利用带参数的构造函数），因此只能调用无实参的构造函数，若是此时没有无实参构造函数，就会出错。