类与对象 C++

基于对象（Object Based）和面向对象（Object Oriented）是对象的两个核心类型。基于对象，根据是否包含指针成员（指针操作需要很小心）可以划分成两类，只有对单个对象有了很好的设计才能进入下一步，对象之间的关联性。面向对象，对象之间的耦合关系，继承与复合，委托等对象耦合关系。人类在认知自然世界的时候，具备很好的类型划分和简单组合法逻辑功能（相反人类对于函数抽象不熟练），高级C++语言引入了对象概念。因此，面向对象的意义在于：

（1）将日常生活中的习惯性思维引入到程序设计中；

（2）将需求中的概念直观的映射到解决方案中；

（3）以模块为中心构建可服用的软件系统；

（4）提高软件的可维护性和扩展性

1. 类和对象

类，值一类事物，是抽象的概念。类是一种模型，用于创建出不同的实体对象。对象，值某个类的具体实体。一个类可以有多个对象，一个对象必然属于某个类。属性和行为是对物体进行抽象的两个大维度，软件抽象的核心是为了对客观世界事物记性描述，并解决物体相关的问题和规律。

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

让我们看看之前定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员：

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以您可以按照如下方式定义 getVolume() 函数：

概念	描述
类成员函数	类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
类访问修饰符	类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
构造函数 & 析构函数	类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数	拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数	友元函数可以访问类的 private 和 protected 成员。
C++ 内联函数	通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
C++ 中的 this 指针	每个对象都有一个特殊的指针 this，它指向对象本身。
C++ 中指向类的指针	指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员	类的数据成员和函数成员都可以被声明为静态的。

3. 封装

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。

一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。

数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。

C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有项目都是私有的。例如：

为了使类中的成员变成公有的（即，程序中的其他部分也能访问），必须在这些成员前使用 public 关键字进行声明。所有定义在 public 标识符后边的变量或函数可以被程序中所有其他的函数访问。

把一个类定义为另一个类的友元类，会暴露实现细节，从而降低了封装性。理想的做法是尽可能地对外隐藏每个类的实现细节。

通常情况下，我们都会设置类成员状态为私有（private），除非我们真的需要将其暴露，这样才能保证良好的封装性。

这通常应用于数据成员，但它同样适用于所有成员，包括虚函数。

3.1 封装

接口是一个类或者对象和外界沟通方式。面向接口编程是现代编程中一项核心的设计理念。正常情况下，一个类分为两部分，类自己内部的实现细节和基本原理，另外一部分是使用方式（接口）。我们使用一个类时，实际是不需要关心类内部的实现细节的。就像我们雇佣一个人打扫卫生一样，我们不需要关注人的实现原理，很多时候我们也不知道内部实现细节，这些也对我们不重要。我们只需要关心，这是一个专业培训过的保洁公司员工，他有专业工具实现打扫的功能，我们付钱就可以帮我们解决家里的所有打扫任务。

        封装，实际代码使用过程中，我们不是需要公开类中的所有属性或者行为，需要对行为或者属性进行公开界别的限制。C++中成员变量函数访问级别分为public和private两种。

（1）public，成员变量和成员函数可以在类的内部和外界访问和调用

（2）private，成员变量和成员函数只能在类的内部被访问和调用

#include <stdio.h>

#include <stdio.h>

struct Biology
{
    bool living;
};

struct Animal : Biology
{
    bool movable;

    void findFood()
    {
    }
};

struct Plant : Biology
{
    bool growable;
};

struct Beast : Animal
{
    void sleep()
    {
    }
};

struct Human : Animal
{
    void sleep()
    {
        printf("I'm sleeping...\n");
    }

    void work()
    {
        printf("I'm working...\n");
    }
};

struct Girl : Human
{
private:
    int age;
    int weight;
public:
    void print()
    {
        age = 22;
        weight = 48;

        printf("I'm a girl, I'm %d years old.\n", age);
        printf("My weight is %d kg.\n", weight);
    }
};

struct Boy : Human
{
private:
    int height;
    int salary;
public:
    int age;
    int weight;

    void print()
    {
        height = 175;
        salary = 9000;

        printf("I'm a boy, my height is %d cm.\n", height);
        printf("My salary is %d RMB.\n", salary);
    }
};

int main()
{
    Girl g;
    Boy b;

    g.print();

    b.age = 19;
    b.weight = 120;
    //b.height = 180;

    b.print();

    return 0;
}

3.2. 类成员作用域

类成员的作用域只在类的内部，外部无法直接访问。成员函数可以直接访问成员变量和调用成员函数。类成员外部可以通过类变量访问public成员，类成员的作用域和访问级别没有关系。 类成员的作用域与类成员的访问级别不是一回事，它们之间没有关系。类成员的作用域在整个类的内部。而访问级别是对外部而言的。

struct定义的类中所有成员默认为public，实例如下：

#include <stdio.h>

int i = 1;

struct Test
{
private:
    int i;

public:
    int j;

    int getI()
    {
        i = 3;

        return i;
    }
};

int main()
{
    int i = 2;

    Test test;

    test.j = 4;

    printf("i = %d\n", i);              // i = 2;
    printf("::i = %d\n", ::i);          // ::i = 1;
    // printf("test.i = %d\n", test.i);    // Error
    printf("test.j = %d\n", test.j);    // test.j = 4
    printf("test.getI() = %d\n", test.getI());  // test.getI() = 3

    return 0;
}

2.3. 虚函数private

C++中, 虚函数可以为private, 并且可以被子类覆盖（因为虚函数表的传递），但子类不能调用父类的private虚函数。虚函数的重载性和它声明的权限无关。

一个成员函数被定义为private属性，标志着其只能被当前类的其他成员函数(或友元函数)所访问。而virtual修饰符则强调父类的成员函数可以在子类中被重写，因为重写之时并没有与父类发生任何的调用关系，故而重写是被允许的。

编译器不检查虚函数的各类属性。被virtual修饰的成员函数，不论他们是private、protect或是public的，都会被统一的放置到虚函数表中。对父类进行派生时，子类会继承到拥有相同偏移地址的虚函数表（相同偏移地址指，各虚函数相对于VPTR指针的偏移），则子类就会被允许对这些虚函数进行重载。且重载时可以给重载函数定义新的属性，例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！

纯虚函数可以设计成私有的，不过这样不允许在本类之外的非友元函数中直接调用它，子类中只有覆盖这种纯虚函数的义务，却没有调用它的权利。

3. this指针

在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。简单讲每一个对象都可以通过地址引用自己，这个地址就是this指针。

友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。

某一个class类我们可以认为成员函数在编译过程中实例化的对象公用一份成员函数，具体是进行那个数据操作，我们可以认为在调用方法的时候是将对应的对象地址通过this指针传递到对应的方法中。下面的实例有助于更好地理解 this 指针的概念：

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

当我们调用成员函数时，实际上是替某个对象调用它。

成员函数通过一个名为 this 的额外隐式参数来访问调用它的那个对象，当我们调用一个成员函数时，用请求该函数的对象地址初始化 this。例如，如果调用 total.isbn()则编译器负责把 total 的地址传递给 isbn 的隐式形参 this，可以等价地认为编译器将该调用重写成了以下形式：

//伪代码，用于说明调用成员函数的实际执行过程
Sales_data::isbn(&total)

其中，调用 Sales_data 的 isbn 成员时传入了 total 的地址。

在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为 this 所指的正是这个对象。任何对类成员的直接访问都被看作是对 this 的隐式引用，也就是说，当 isbn 使用 bookNo 时，它隐式地使用 this 指向的成员，就像我们书写了 this->bookNo 一样。

对于我们来说，this 形参是隐式定义的。实际上，任何自定义名为 this 的参数或变量的行为都是非法的。我们可以在成员函数体内部使用 this，因此尽管没有必要，我们还是能把 isbn 定义成如下形式：

std::string isbn() const { return this->bookNo; }

因为 this 的目的总是指向“这个”对象，所以 this 是一个常量指针（参见2.4.2节，第56页），我们不允许改变 this 中保存的地址。

this指针可以理解为某个类*。

需要注意一点，static修饰的成员函数是不包含this指针的，当然static成员函数就只能处理静态数据了。