初识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      }

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

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

 

转载于:https://www.cnblogs.com/L-Lotus-F/p/4067258.html