• 类是面向对象编程中的核心概念，用于定义一个数据类型的蓝图，描述类的对象包括什么，以及可以在这些对象上执行那些操作。

• 类的成员

  • 数据成员

    • 描述数据的表示方法

      class ClassName {
      accessType:
      	MemberVariableType memberVariable;
      };
      

  • 函数成员

    • 定义和原型写在类定义内部的函数，可以操作类的任意对象，可以访问对象中的任意成员，定义方式如下

      class ClassName {
      accessType:	
          // 函数成员
          ReturnType functionName() {
          	// Body of the function
          }
      } ClassInstance;
      /** 
      	其中 ClassInstance 是类的实例，为可选项
      */
      

    • 成员函数定义的方式

      • 在类的内部定义

        class Animal {
        public:
             void run() {
                cout << "Animal is running." << endl;
            }
        };
        

      • 使用范围解析运算符 :: 在类的外部定义

        class Animal {
        // 数据成员
        public:
            int age;
        // 函数成员
        public:
            void run();
        };
        void Animal::run() {
            cout << "Animal is running" << endl;
        }
        

• 访问修饰符

  • 数据隐藏是OOP中重要的概念，C++使用访问修饰符实现数据隐藏的目的
  • 访问修饰符的种类
    • public
      • 在程序中类的外部可以访问
    • protected
      • 在该类中与私有成员的访问权限一样，但是在派生类中可以访问
    • private
      • 在程序中类的外部不可访问
      • 只有类和友元函数可以访问私有成员

• this指针

  • 每一个类对象都有一个this指针指向自己的内存地址
  • 注意
    • this指针是所有成员函数的隐含参数，用来指向调用对象
    • 非成员函数没有this指针，如：友元函数，静态成员函数
  • 示例

    • 成员函数

      // 向类Animal中，添加成员函数 int compare(Animal animal) 比较两个动物，哪个更年长
      int compare(Animal animal) {
          return this->age > animal.age;
      }
      

    • 友元函数

      // 向类Animal中添加友元函数 int compare(Animal animal)
      friend int compare(Animal animal);
      // 实现友元函数，在友元函数中使用this指针，会产生编译错误
      int compare(Animal animal) {
          // error: Invalid use of 'this' outside of a non-static member function
          return this->age > animal.age;
      }
      

• 指向类的指针

  • 指向类的指针与指向结构的指针类似，访问成员需要使用成员访问运算符 ->，且与其他任何指针一样，在使用之前必须先初始化

  • 示例

    int main(int argc, const char * argv[]) {
        // 类对象
        Animal dog;
        dog.age = 5;
        dog.run();
        // 指向类的指针
        Animal *animalPointer;
        animalPointer = &dog;
        // 通过指向类的指针访问类的成员
        cout << "Dog 的年龄为：" << animalPointer->age << endl;
        return 0;
    }
    

• 静态成员

  • 静态成员在类对象中只有一个副本，即被类的所有对象共享

  • 类型

    • 静态数据成员

      • 静态数据成员不能在类定义中初始化，在类定义外需要使用范围解析运算符 :: 重新声明从而对其初始化，若没有指定类的静态成员的初始化语句，静态数据成员会被初始化为零

      • 示例

        	// 向类Animal添加静态数据成员animalCount，用于计算创建的动物的总数
        private:
        	static int animalCount;
        	// 若在类定义中初始化静态数据成员，将会报如下的编译错误
            // Error: Non-const static data member must be initialized out of line
            // static int animalCount = 0;
        	// 在类定义外初始化Animal类中的静态数据成员animalCount
        	int Animal::animalCount = 0;
        

    • 静态函数成员

      • 静态函数成员在类对象不存在的情况下，使用类名加范围解析运算符 :: 调用，使成员函数与具体的对象分离开

      • 静态成员函数的访问限制

        • 只能访问静态数据成员
        • 不能访问其他静态成员函数和类外部的其他函数
        • 具有类范围，不能范文this指针（与实际的类对象无关）

      • 示例

        // 向类Animal中添加静态成员函数，获取当前类的对象总数
        static int getAnimalCount() {
            return animalCount;
        }
        

  • main()函数

    int main(int argc, const char * argv[]) {
        cout << Animal::getAnimalCount() << endl;
        Animal dog;
        cout << Animal::getAnimalCount() << endl;
        return 0;
    }
    

• 友元

  • 友元函数（有关函数的详细内容请参阅下方Blog）
    • C++语言-02-函数
  • 友元类

    • 多一个类是另一个类的友元，则该类及其所有成员都是友元

    • 定义

      // 类Animal
      class Animal {
          // 定义AnimalAction为Animal的友元类
          friend class AnimalAction;
      };
      // 友元类AnimalAction
      class AnimalAction {
         // body of the class
      };
      

对象

• 对象是类的具体实例，指向内存中的一块地址，保存有与该对象相关的信息