C++类与对象

类的定义、对象的定义和访问数据成员

类的定义是以关键字 class 开头，后跟类的名称，类的主体是包含在一对花括号中，类定义后必须跟着一个分号或一个声明列表。

关键字 public 确定了类成员的访问属性为公共成员，在类对象作用域内，公共成员在类的外部是可访问的。若为protected则为保护成员，仅允许本类成员函数和派生类成员函数访问；若为private则为私有成员，仅允许本类成员函数访问。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。使用范围解析运算符时必须在前面加上类名。

对象是根据类来创建的，声明类的对象，就像声明基本类型的变量一样。

类的对象的公共数据成员可以使用直接成员访问运算符 (.) 来访问，私有成员和保护成员则不可以。使用指针访问形式（对象指针变量名->公有成员）也可以用来访问公有成员。

#include <iostream>
using namespace std;
class Box
{
   public:
      double length;   // 长
      double breadth;  // 宽
      double height;   // 高
};
 
 int main( )
{
   Box Box1;
   Box Box2;
   double volume = 0.0;     // 存储体积
 
   Box1.height = 5.0;  
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   volume = Box1.height * Box1.length * Box1.breadth;   // box 1 的体积
   cout << "Box1 的体积：" << volume <<endl;
 
   volume = Box2.height * Box2.length * Box2.breadth;   // box 2 的体积
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

类定义和使用中的注意事项：

• 类的定义中不能对数据成员进行初始化。
• 类的任何成员都应有其成员属性，一般数据成员定义为私有或保护，成员函数定义为公共。
• 类的成员可以是其他类的对象，但不能是自身的对象作为类的成员。
• 类的定义以“;”结束。

函数重载：
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形参必须不同。

构造函数、析构函数

构造函数：特殊的成员函数，名字和类名相同，没有返回值，不需要且无法显式调用，在创建对象时自动执行。

• 构造函数是为了保证对象的每个数据成员都被正确初始化。
• 构造函数必须是 public 属性的，否则创建对象时无法调用。
• 构造函数没有返回值，因为没有变量来接收返回值。
• 不管是声明还是定义，函数名前面都不能出现返回值类型，函数体中不能有 return 语句。

析构函数：特殊的成员函数，没有返回值，不需要且无法显式调用，在销毁对象时自动执行。构造函数的名字和类名相同，而析构函数的名字是在类名前面加一个~符号。

• 析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。

复制构造函数：特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。常用于：

• 通过使用另一个同类型的对象来初始化新创建的对象。
• 复制对象把它作为参数传递给函数。
• 复制对象，并从函数返回这个对象。

复制构造函数常见形式为：

classname (const classname &obj) {
  // 函数主体
}

静态成员函数

把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。

静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。

如：

#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;
         objectCount++;         // 每次创建对象时增加 1
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // 长
      double breadth;    // 宽
      double height;     // 高
};
int Box::objectCount = 0;     // 初始化类 Box 的静态成员
 
int main(void)
{
   cout << "Inital Stage Count: " << Box::getCount() << endl；
   Box Box1(3.3, 1.2, 1.5); 
   Box Box2(8.5, 6.0, 2.0);
   cout << "Final Stage Count: " << Box::getCount() << endl;    // 在创建对象之后输出对象的总数
   return 0;
}

友元函数

类的友元函数定义在类外部，但有权访问类的所有私有成员和保护成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend。
如：

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

声明类 ClassA 的所有成员函数作为类ClassB的友元，需要在类 ClassA 的定义中放置如下声明：

friend class ClassB

示例如下：

#include <iostream>
using namespace std;
class Box
{
   double width;
public:
   friend void printWidth( Box box );
   void setWidth( double wid );
};
 
void Box::setWidth( double wid )// 成员函数定义
{
    width = wid;
}
 
void printWidth( Box box )//printWidth() 不是任何类的成员函数
{
   
   cout << "Width of box : " << box.width <<endl;  //因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 
}
 
int main( )
{
   Box box;
   box.setWidth(10.0);
   printWidth( box );
   return 0;
}