类和对象那些事儿(b)

问题前瞻：
1.友元函数的功能和使用？独特性和便利性？
2.this 指针，
3.指向类的指针？
4.C++ 类的静态成员？

1.C++友元函数
1.1 功能
友元函数有权访问累的所有私有成员和保护成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。
1,2 定义
友元可以是一个函数，也可以是一个类，成为友元类。
如果声明一个函数为类的友元函数，需要在类中提供函数原型时，加上前缀friend。
eg：

class Box
{
   double width;
public:
   double length;
   friend void printWidth( Box box );
   void setWidth( double wid );
};

声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明：friend class ClassTwo;

2.C++中的this 指针
2.1 功能
C++中，每一个对象都能通过this指针来访问自己的地址。this指针是所有成员函数的隐含参数。因此，在成员函数内部，他可以用来指向调用对象。
2.2 使用
eg：

#include <iostream>
 
using namespace std;

class Box
{
   public:
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      int compare(Box box)
      {
         return this->Volume() > box.Volume();	//		this用于指向被调用的对象。 
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2

   if(Box1.compare(Box2))
   {
      cout << "Box2 is smaller than Box1" <<endl;
   }
   else
   {
      cout << "Box2 is equal to or larger than Box1" <<endl;
   }
   return 0;
}
结果如下：
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1

this 是默认的指向自己的指针，那么一般情况下指向类的指针该怎么创建和使用呢？

3. C++中指向类的指针
   指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
   所以：指向类的指针和指向结构的指针用法一样。

#include <iostream>
 
using namespace std;

class Box
{
   public:
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
   Box *ptrBox;                // Declare pointer to a class.

   // 保存第一个对象的地址
   ptrBox = &Box1;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box1: " << ptrBox->Volume() << endl;

   // 保存第二个对象的地址
   ptrBox = &Box2;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box2: " << ptrBox->Volume() << endl;
  
   return 0;
}

4. C++类的静态成员
   4.1 为什么引入静态，静态成员有什么特点？
   当我们声明类成员是静态的时候意味着无论创建多少个类的对象，静态成员都只有一个副本。静态成员在所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为0.
   静态变量不能放置在类的定义中，但是可以在类的外部通过范围解析运算符::来重新声明静态变量进行初始化。
   4.2 创建和使用
   eg:

#include <iostream>
 
using namespace std;

class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2

   // 输出对象的总数
   cout << "Total objects: " << Box::objectCount << endl;

   return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Constructor called.
Constructor called.
Total objects: 2

4.3 静态函数成员
4.3.1 功能
如果把函数成员声明为静态的，就可以把 函数 与 类的任何一个特定对象独立开来。
静态成员函数即使在类对象 不存在的情况下 也能被调用，
只能访问静态的 数据成员，不能访问其他静态成员函数和类外部其它函数
静态成员函数有一个类范围，他们不能访问类的this指针，所以可以使用静态成员函数来判断类的某些对象是否已经被创建。

4.3.2 创建和使用
eg:

#include <iostream>
 
using namespace std;

class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;

int main(void)
{
  
   // 在创建对象之前输出对象的总数
   cout << "Inital Stage Count: " << Box::getCount() << endl;

   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2

   // 在创建对象之后输出对象的总数
   cout << "Final Stage Count: " << Box::getCount() << endl;

   return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2