自学C++ 记录2 面向对象

自学C++ 记录2

类

本质上是定义一个数据类型的蓝图。

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

类成员函数

成员函数可以定义在类定义内部，在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符,如

class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};

也可以在类的外部使用范围解析运算符 :: 定义该函数，如

class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
      // 成员函数声明
	  double getVolume(void);
};
double Box::getVolume(void)
{
    return length * breadth * height;
}

类访问修饰符

public 成员在程序中类的外部是可访问的。默认情况下，类的所有成员都是私有的。如果没有使用任何访问修饰符，类的成员将被假定为私有成员。
private成员变量或函数在类的外部是不可访问的，甚至是不可查看的。
protected成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

类构造函数（constructor）

构造函数就是Java中的constructor。
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();  // 默认的构造函数
      Line(double len);  // 带有参数的构造函数
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
    length = 0;//默认值
}
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
    
}
double Line::getLength( void )
{
    return length;
}
int main( )
{
	Line line1// 使用 Line()构建
   Line line2(10.0);//使用 Line(double len)构建
 
   // 获取默认设置的长度
   cout << "Length of line1 : " << line1.getLength() <<endl;
   cout << "Length of line2 : " << line2.getLength() <<endl;
 
   return 0;
}

输出为：

Length of line1 : 0
Length of line2 : 10

析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

输出为

Object is being created
Length of line : 6
Object is being deleted

继承

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。一个子类可以有多个父类，它继承了多个父类的特性。

#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 <派生类名>:<继承方式><基类名>
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;
}

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。

class Rectangle: public Shape

即Shape前的public可改成protected 或 private

继承方式	基类的public成员	基类的protected成员	基类的private成员	继承引起的访问控制关系变化概括
public继承	仍为public成员	仍为protected成员	不可见	基类的非私有成员在子类的访问属性不变
protected继承	变为protected成员	变为protected成员	不可见	基类的非私有成员都为子类的保护成员
private继承	变为private成员	变为private成员	不可见	基类中的非私有成员都称为子类的私有成员

重载（overload）函数

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

#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;
      }
};

运算符重载

可以重定义或重载大部分 C++ 内置的运算符。这样，您就能使用自定义类型的运算符。

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。具体

多态

在我看来，就是一个基类可以有好多的派生类，每一个派生类都是这个基类的一种形态，所以这个基类就有了好多种形态，就是多态了~

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数.

静态多态

#include <iostream> 
using namespace std;
 
class Shape {
   public:
      int area()
      {
         cout << "Parent class area :" <<endl;//最后输出会是这一行
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      int area()
      { 
         cout << "Rectangle class area :" <<endl;
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
   return 0;
}

运行后的输出是

Parent class area

会发现调用的是基类Shape中的函数area()而不是我们真正想要的Reactangle中的area()。

这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了，有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置为Shape的函数了。

虚函数

上面主程序如果想要调用Rectangle中的area()，要对Shape类进行修改

class Shape {
   public:
      virtual int area()//多了virtual,变成了虚函数
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

此时，编译器看的是指针的内容，而不是它的类型。因此，由于rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

纯虚函数

没有内容的虚函数

在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

class Shape {
   public:
      virtual int area() = 0;//这是一个没有内容的虚函数，也是纯虚函数
};

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

抽象类（abstract class=ABC）

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的。

抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，