C++——类 & 对象,继承,重载运算符和重载函数

class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};

Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};
 
int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;

   return 0;
}

Box1 的体积：210

class derived-class: access-specifier base-class

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示： #include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   return 0;
}

Total area: 35

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

Total area: 35
Total paint cost: $2450

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}

整数为: 5
浮点数为: 500.263
字符串为: Hello C++

Box operator+(const Box&);

如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示：
Box operator+(const Box&, const Box&);

	
	

		#include <iostream>
	

	

		using namespace std;
	

	

		 
	

	

		class Box
	

	

		{
	

	

		   public:
	

	

		 
	

	

		      doublegetVolume(void)
	

	

		      {
	

	

		         return length * breadth * height;
	

	

		      }
	

	

		      voidsetLength(doublelen )
	

	

		      {
	

	

		          length = len;
	

	

		      }
	

	

		 
	

	

		      voidsetBreadth(doublebre )
	

	

		      {
	

	

		          breadth = bre;
	

	

		      }
	

	

		 
	

	

		      voidsetHeight(doublehei )
	

	

		      {
	

	

		          height = hei;
	

	

		      }
	

	

		      // 重载 + 运算符，用于把两个 Box 对象相加
	

	

		      Box operator+(constBox& b)
	

	

		      {
	

	

		         Box box;
	

	

		         box.length =this->length + b.length;
	

	

		         box.breadth =this->breadth + b.breadth;
	

	

		         box.height =this->height + b.height;
	

	

		         return box;
	

	

		      }
	

	

		   private:
	

	

		      double length;     // 长度
	

	

		      double breadth;    // 宽度
	

	

		      double height;     // 高度
	

	

		};
	

	

		// 程序的主函数
	

	

		intmain( )
	

	

		{
	

	

		   Box Box1;               // 声明 Box1，类型为 Box
	

	

		   Box Box2;               // 声明 Box2，类型为 Box
	

	

		   Box Box3;               // 声明 Box3，类型为 Box
	

	

		   doublevolume =0.0;    // 把体积存储在该变量中
	

	

		 
	

	

		   // Box1 详述
	

	

		   Box1.setLength(6.0);
	

	

		   Box1.setBreadth(7.0);
	

	

		   Box1.setHeight(5.0);
	

	

		 
	

	

		   // Box2 详述
	

	

		   Box2.setLength(12.0);
	

	

		   Box2.setBreadth(13.0);
	

	

		   Box2.setHeight(10.0);
	

	

		 
	

	

		   // Box1 的体积
	

	

		   volume = Box1.getVolume();
	

	

		   cout <<"Volume of Box1 : "<< volume <<endl;
	

	

		 
	

	

		   // Box2 的体积
	

	

		   volume = Box2.getVolume();
	

	

		   cout <<"Volume of Box2 : "<< volume <<endl;
	

	

		 
	

	

		   // 把两个对象相加，得到 Box3
	

	

		   Box3 = Box1 + Box2;
	

	

		 
	

	

		   // Box3 的体积
	

	

		   volume = Box3.getVolume();
	

	

		   cout <<"Volume of Box3 : "<< volume <<endl;
	

	

		 
	

	

		   return0;
	

	

		}
	

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

• . ：成员访问运算符
• .*, ->* ：成员指针访问运算符
• :: ：域运算符
• sizeof ：长度运算符
• ?: ：条件运算符
• # ： 预处理符号