這里主要介紹下在C語言中是如何實現的面向對象。知道了C語言實現面向對象的方式，再聯想下，C++中的class的運行原理是什么？

首先看一段C++的class，拿一個Student類來舉例子：

在頭文件中，我定義一個Student類：

#pragma once
class Student {
public:
  void SetNumber(int number);
  void SetGrade(int grade);
  void Print();
private:
  int number;
  int grade;
};

再在源文件中實現它：

#include "studentpp.h"
#include <stdio.h>
void Student::SetNumber(int number) { this->number = number; }
void Student::SetGrade(int grade) { this->grade = grade; }
void Student::Print() { printf("studentpp number : %d, grade : %d \n", this->number, this->grade);}

接下來是使用Student類：

#include <iostream>
#include "studentpp.h"
int main() {
  Student *stu1 = new Student;
  Student *stu2 = new Student;
  stu1->SetNumber(11);
  stu2->SetNumber(22);
  stu1->SetGrade(111);
  stu2->SetGrade(222);
  stu1->Print();
  stu2->Print();
  delete stu1;
  delete stu2;
}

再運行一下，運行結果不出所料。

有沒有想過，它的底層是怎么實現的？為什么不同對象，設置了不同的number和grade，它的輸出卻不一樣？

這個問題先放在這。等我用C語言實現一套這種方案后，估計就明白了。

首先，在頭文件中定義一個C語言的結構體Student：

#pragma once
typedef struct Student Student;
Student* CreateStudent();
void DestroyStudent(Student* student);
void SetNumber(Student* student, int number);
void SetGrade(Student* student, int grade);
void Print(Student* student);

注意在這里使用了一個typedef，即Student = struct Student;

但是卻沒有在頭文件中定義它：

struct Student {
  int number;
  int grade;
};

我把它放在了源文件中，在源文件中定義它，再實現相關的方法。

#include "student.h"
#include <stdlib.h>
#include <stdio.h>

struct Student {
  int number;
  int grade;
};

Student* CreateStudent() {
  Student* self = (Student*)malloc(sizeof(Student));
  return self;
}

void DestroyStudent(Student* student) {
  if (!student) return;
  free((void*)student);
}

void SetNumber(Student* student, int number) {
  if (!student) return;
  student->number = number;
}

void SetGrade(Student* student, int grade) {
  if (!student) return;
  student->grade = grade;
}

void Print(Student* student) {
  if (!student) return;
  printf("student number : %d, grade : %d \n", student->number, student->grade);
}

然后使用它：

#include "student.h"

int main() {
  Student* stu1 = CreateStudent();
  Student* stu2 = CreateStudent();
  SetNumber(stu1, 11);
  SetNumber(stu2, 22);
  SetGrade(stu1, 111);
  SetGrade(stu2, 222);
  Print(stu1);
  Print(stu2);
  DestroyStudent(stu1);
  DestroyStudent(stu2);
}

這是不是面向對象的原理？數據封裝到了不同的指針下，不同的指針傳到了相同的函數中，行為也會不同。

這時候再聯想一下C++中的面向對象是不也是這個原理：

平時我們使用的：

a->Print();

其實它的原理可能是這樣的：

void Print(Student* this) {
  this->number;
  this->grade;
}

只不過編譯器把默認的這個this參數隱藏在內部，我們看不見而已。其實每個成員函數默認都會有一個參數，就是對象的指針，也就是this指針。到這里你應該也就明白面向對象的原理了吧。

注意在這里我使用了一個typedef，即Student = struct Student;

但是我卻沒有在頭文件中定義它。

這樣可以更好的隱藏Student的實現，外面不知道Student究竟是什么東西，只有內部知道。在頭文件中對外只暴露Student的指針，然后指針傳到源文件中，再去解析它。

比如，我在其它地方想要得到Student的大小，編譯器會報錯，沒法使用sizeof，因為它不知道Student，它只知道它是不完整的類型。而只能在源文件中使用sizeof。

這種設計是不是比C++的class更安全一些，確實安全，其實C++也可以這樣實現，就是可以使用pImpl指針。

pimpl我暫時先不介紹，大家可以自己研究一下（其實歷史文章中介紹過）。

大家可以思考下，怎么用C語言實現多態呢？

這里有 一個優質的C++學習圈 等你加入，來一起鉆研C++吧。