論壇首頁 綜合技術論壇

c語言的面向對象要如何實現和易懂

瀏覽 396 次
精華帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隱藏帖 (0)
作者 正文
   發表時間:2020-08-26  
  1. 具體和抽象

  具體:客觀存在著的或在認識中反映出來的事物的整體,是具有多方面屬性、特點、關系的統一;

  抽象:從具體事物中被抽取出來的相對獨立的各個方面、屬性、關系等。

  以 Person 為例:“pmst”,“numbbbbb”,“MM”等都是客觀存在的,稱之為具體;然后我們抽取共同的特性:姓名,性別,年齡和介紹自己等(當然這是極小、極小的一部分)。

  這個資料可以進行學習參考
    C語言實現面向對象編程:[http://www.makeru.com.cn/live/1392_1051.html?s=45051

  2. C 語言抽象的雛形

  先用 C 語言抽象,實現如下:

  typedef struct Person Person;

  typedef void (*Method)(Person *my_self);

  typedef struct Person {

  char name[12];

  int age;

  int sex;

  Method behavior1; // 行為1

  } Person;

  void selfIntroducation(Person *my_self) {

  printf("my name is %s,age %d,sex %d\n",my_self->name,my_self->age,my_self->sex);

  }

  int main(int argc, const char * argv[]) {

  // 1

  Person *pmst = (Person *)malloc(sizeof(Person));

  // 1.1

  strcpy(pmst->name, "pmst");

  pmst->age = 18;

  pmst->sex = 0;

  // 2

  pmst->behavior1 = selfIntroducation;

  // 3

  pmst->behavior1(pmst);

  return 0;

  }

  int,float,struct 等類型在編譯之后轉變成對內存地址的訪問,比如 1 中的 pmst 指針在調用 malloc 方法后返回分配的地址為 0x12345678,會標識占 sizeof(Person) 個字節;pmst->age = 18 其實是對 0x12345678 偏移 12 字節內存的賦值,占4個字節;

  函數在編譯之后放置在代碼段,入口為函數指針;

  pmst->behavior1(pmst); 先取到 0x12345678 偏移 20 字節內存的值————函數指針,然后 call 命令調用

  編譯之后代碼都變成了對內存地址的訪問,稱之為靜態綁定;那么該如何實現 Runtime 運行時的動態訪問呢?比如在UI界面上(ps:Terminal那種古老的輸入輸出方式也是OK的)輸入一個類的名稱以及調用方法名稱,緊接著我們要實例化一個該類的對象,然后調用方法。

  3. C 語言實現動態性

  3.1 運行時如何實現抽象->具體

  想要運行時隨心所欲地將抽象轉變成具體,就需要在內存中保存一份對抽象的描述,這里的描述并非指 typedef struct Person {...}Person 定義 ———— 這是靜態的,而是開辟一塊內存加載一份 json 抽象描述:

  {

  "Name": "Person",

  "VariableList":[

  {

  "VarName":"name",

  "Type":"char[]",

  "MemorySize":12,

  },

  {

  "VarName":"age",

  "Type":"int",

  "MemorySize":4,

  },

  {

  "VarName":"sex",

  "Type":"int",

  "MemorySize":4,

  },

  ],

  "MethodList":[

  {

  "name":"selfIntroducation",

  "methodAddress":0x12345678

  },

  ]

  }

  關于這串json描述,可以是在編譯階段生成的,運行時使用 char *description 加載到堆內存上,需要時通過對應的 Key 取到 Value:例如 Key=Name 可以取到類名,Key=VariableList 可以取到變量列表,Key=MethodList 可以取到方法列表。這里可能需要有個小小的Parser解析器。

  3.2 二次抽象,生成類對象

  倘若每次用到時就要進行一次 char *description 信息 parser 解析,性能這關都過不去,正確做法是解析成某個數據結構,保存到堆內存中:

  // 偽代碼如下

  typedef struct Variable {

  char *name;

  char *type;

  int memorySize;

  }Variable;

  typedef struct Method {

  char *name;

  void (*callAddress)(void *my_self);// 顯然這里多參傳入 當然這些暫時不考慮

  }Method;

  typedef struct Class {

  char *className;

  /// Variable List 是一個數組 類型為 Variable

  Variable *variableList;

  /// Method List 也是一個數組 類型為 Method

  Method *methodList

  }

  上述是最簡單的抽象定義,現在我們將解析json信息,然后分配內存填充信息(抽象->具體)的過程,首先 Class 是一個抽象概念,抽象出類名、變量列表和方法列表等信息,但此刻我們開辟了一塊內存填充信息———— 客觀存在了,稱之為對象(通常我們稱之為class object,類對象)

  //////////////偽代碼如下/////////////////

  //////////////////////////////////////////

  // parse person json proccess get result

  ///////////////////end////////////////////

  // 分配一塊內存

  Class *personClsObject = (Class *)malloc(sizeof(Class));

  strcpy(personClsObject->className, "Person");

  personClsObject->variableList = (Variable *)malloc(sizeof(Variable) * 3);// 有3個變量

  Variable *nameVar = (Variable *)malloc(sizeof(Variable));

  strcpy(nameVar->name, "name");

  strcpy(nameVar->type, "char[]");

  nameVar->memorySize = 12;

  //... ageVar & sexVar 生成

  personClsObject->variableList[0] = nameVar;

  personClsObject->variableList[1] = ageVar;

  personClsObject->variableList[2] = sexVar;

  // 同理生成一個個Method 然后填充到 personClsObject->methodList;

  你、我、他是客觀存在的稱之為對象,進一步抽象出了姓名、性別和年齡三個方面,使用 struct Person 結構體定義,之前說了編譯之后不存在所謂的結構體,都會轉而變成對內存地址的訪問;我們換了種思路,又抽象出了一個 Class 結構體,然后分配一塊具體客觀存在的內存保存信息,即 personClsObject 類對象(class object),然后將所有變量信息存儲到variableList,方法信息存儲到 methodList。

  舉一反三,如果繼續定義typedef struct Animal,typedef struct Car 等一系列的類,那么必定也會各自在堆內存上生成有且僅有一個 AnimalClsObject 、CarClsObject 類對象!

  3.2 使用類對象來生成實例對象

  上文說到內存中保存了一份對 Person 抽象描述,即PersonClsObject類對象,包含類名稱,變量列表,方法列表等信息。此刻進一步具體到現實生活中某個具體的人,生成 “pmst” 博主我,"numbbbbb" 幫主梁杰,“mm”靈魂畫師,有種God創世的趕腳。這一個個都是現實存在的,即實例對象————自然要分配一塊內存給各自,填充 name名字,sex性別,age年齡。

  [圖片上傳失敗...(image-3d0165-1519970136607)]

  ///////////// 以下為偽代碼 ////////////////////

  // 可以遍歷 personClsObject 中variableList所有變量

  // 取到每個變量所占的內存大小memorySize,累加得到總的需要分配的內存大小

  int size = 0;

  for variable in personClsObject->variableList {

  size = variable->memorySize;// 當然這里肯定要考慮內存對齊問題

  }

  Person *pmst = (Person *)malloc(size); // 分配內存 得到指針0x10000000

  Person *numbbbb = (Person *)malloc(size); // 分配內存 得到指針0x10001000

  Person *MM = (Person *)malloc(size); // 分配內存 得到指針0x10002000

  note: 這里只為實例變量分配了內存,章節2中我們還包含一個8字節的函數指針,那么問題來了,現在我們該如何調用selfIntroducation函數呢?

  3.3 實例對象和類對象

  因為我們在內存中保存了一份對 Person 的抽象描述,在運行時就知道Person包含哪些允許調用的函數名稱,函數類型以及位于代碼段的函數入口地址。

  章節 2 中使用了 pmst->behavior1(pmst) 調用方式 :先取到函數指針,然后把實例對象自身指針作為傳參傳入調用。現在有了 personClsObject 我們又該如何實現這種調用呢?

  /// 偽代碼如下

  /// C語言函數返回類型為函數指針寫法如下:

  /// ps:當然也可以先typedef 然后替換返回類型,

  void (*findMethod(char *methodName))(void *myself) {

  for method in personClsObject->methodList {

  if methodName == method->name {

  return method->callAddress;

  }

  }

  return NULL;

  }

  可以看到我們會通過傳入函數名稱,遍歷類對象中的方法列表進行匹配,找到函數指針,接下去就是和章節2調用一樣。

  void (*call)(void *) = findMethod("selfIntroducation");

  call(pmst);

  現在的運行時動態性方案存在很多缺陷,隨便舉幾點:

  實例對象會有很多個,但是對應的類對象有且僅有一個,因為類對象是一份抽象描述,一個足矣。但是你會發現實例對象和類對象并沒有聯系在一起,導致我們得到一個實例對象無法運行時得知其屬于什么類(對應哪個 class object 類對象)!這也是后面我們要解決的;

  存在太多的硬編碼,比如 findMethod 寫死了是從 personClsObject 中去遍歷方法列表

  小總結:1.實例對象允許很多個,但是對應的類對象有且僅有一個,運行時保存在堆上;2.類對象是一份抽象描述,我們可以在運行通過查詢類對象,拿到關于類的信息,比如第一個變量名稱,占字節數,變量類型等等,拿到這些信息可以幫助我們實際訪問實例對象指針指向內存中的數據啦!—————— 因為我們知道字節偏移和變量類型。

  3.4 改進:實例對象關聯類對象

  3.3節中我們僅考慮只有一個personClsObject,并且在 findMethod 查詢函數中也硬編碼寫死了是從 Person 類對象方法列表中遍歷匹配,現在開始加入不同的類對象,findMethod 只需要新增一個入參即可:

  /// 分離硬編碼部分,傳入 `Class *classObject` 不同的類對象

  void (*findMethod(Class *classObject, char *methodName))(void *myself) {

  for method in classObject->methodList {

  if methodName == method->name {

  return method->callAddress;

  }

  }

  return NULL;

  }

  /// 現在調用方式改為:

  void (*call)(void *) = findMethod(personClsObject, "selfIntroducation");

  call(pmst);

  但是這樣實現 findMethod 的前提是知道 pmst 這個實例對象對應的類對象為 personClsObject,單純拿到指向實例對象內存的指針(0x1000 0000)顯然信息不足:

  [圖片上傳失敗...(image-e11e38-1519970136607)]

  試想知曉一個實例對象的指針 0x1000,0000,指針類型為 void * ,我們可以訪問這塊內存的數據,但是問題來了:

  這個實例對象到底占幾個字節呢?

  內存布局怎樣————比如第一個成員類型是Int,要讀入4個字節,ps:這里可能要考慮內存對齊問題;

  我們依舊不知道這個實例對象對應的類對象是哪個,或者說類對象所占的內存地址是多少。

  正如第三點指出,問題根本在于我們的實例對象沒有綁定類對象的內存地址!這樣問題就很好解決了,我們只需在內存頭部“塞入”類對象的指針就OK了,假設 personClsObject 類對象地址為0x2000 0000

  ————————————————— ——————————————————————————————————————————————

  | 0x2000 0000 -|--------------->| "Person"(char *className) |

  |_______________ | |____________________________________________|

  | "pmst" | | 0x2000 1000(Variable *variableList) |

  | 26 | |____________________________________________|

  | 0 | | 0x2000 2000(Method *methodList) |

  ————————————————— |____________________________________________|

  其中 0x2000,1000 0x02000,2000 都是指針,分別指向變量列表和方法列表內存地址。

  這樣的結構意味著要修改 Person 的結構體:

  typedef struct Person {

  Class *clsObject;

  char name[12];

  int age;

  int sex;

  } Person;

  ////////// 偽代碼(前提我們已經得到了person 類對象) /////////////

  int size = 0;

  for variable in personClsObject->variableList {

  size = variable->memorySize;// 當然這里肯定要考慮內存對齊問題

  }

  Person *pmst = (Person *)malloc(size +; // 因為多了一個指針,32位平臺占4字節 64位平臺占8字節

  pmst->clsObject = personClsObject;

  //...

  這樣就可以解決我們之前的問題了,給一個實例變量的指針,我們先取到內存首地址開始的8個字節,解釋成 Class * 指針指向了我們的類對象,愉快地獲取想要的所有信息。

  3.5 關于實例對象

  不過問題來了,上述實現必須在抽象出來的數據結構頂部插入一個 Class *clsObject ,如下:

  typedef struct Person {

  Class *clsObject; // 指向 personClsObject 類對象

  char name[12];

  int age;

  int sex;

  } Person;

  typedef struct Car {

  Class *clsObject; // 指向 carClsObject 類對象

  char brand[12];

  int color;

  int EngineDisplacement;

  //...

  } Car;

  //... 還有其他很多抽象類定義

  不同類的實例對象聲明如下:

  // Person 實例對象:pmst numbbbb

  Person *pmst = (Person *)malloc(person_size);

  pmst->clsObject = personClsObject;

  Person *numbbbb = (Person *)malloc(person_size);

  numbbbb->clsObject = personClsObject;

  // Car 實例對象:pmst's bmw & benz 以下表示客觀存在的兩輛車

  Car *bmw_pmst = (Car *)malloc(car_size);

  bmw_pmst->clsObject = carClsObject;

  Car *benz_pmst = (Car *)malloc(car_size);

  benz_pmst->clsObject = carClsObject;

  盡管 pmst numbbbb bmw_pmst benz_pmst 都是指針,但是指向類型分別是 Person 和 Car 結構體,那么在此種情況下,我們使用能夠使用一種統一的方式來定義一個實例對象呢?

  觀察上述實例對象聲明以及抽象類的定義,我們找出相同點:數據結構頂部都為 Class *clsObject 指針。

  struct object {

  Class *clsObject;

  };

  struct object *pmst = (Person *)malloc(person_size)

  pmst->clsObject = personClsObject;

  struct object *bmw_pmst = (Car *)malloc(car_size);

  bmw_pmst->clsObject = carClsObject;

  Person 和 Car 后面的成員,我們無法使用 -> 訪問了,轉而變成查詢各自的類對象中 variableList 變量列表————變量類型和地址偏移量。這樣可以間接訪問pmst這個實例指向內存內容了(當然內存前8個字節保存的是類對象指針)。

  至于為什么能這么做,先來說說C語言實現變長結構體。

  struct Data

  {

  int length;

  char buffer[0];

  };

  結構體中,length 其實表示分配的內存大小,而buffer是一個空數組,可理解為占位名稱罷了;buffer的真實地址緊隨 Data 結構體包含數據之后,可以看到這個結構體僅占4個字節,倘若我們在malloc時候分配了100個字節,那么剩下100-4=96個字節就是屬于 buffer 數組,非常巧妙不是嗎?

  char str[10] = "pmst demo";

  Data *data = (Data *)malloc(sizeof(Data) + 10);

  data->length = 10;

  memcpy(data->data,str, 10);

  回歸正題,現在我們可以使用 struct object 結構來統一指向我們的實例對象了,但是這并不意味著我們不需要Person類 Car類的定義,只不過現在抽象數據結構體的頂部不需要嵌入 Class *clsObject了。

  3.6 改寫實例對象的分配方式

  前文demo中是這么實例化一個對象的:

  /// ...

  Person *pmst = (Person *)malloc(person_size)

  pmst->clsObject = personClsObject;

  /// ...

  PersonClsObject 知道 Person 的一切。

  以 (Person *)malloc(person_size) 方式實例化一個對象,首先是要拿到 personClsObject 對象,然后遍歷 variableList 累加所有變量占的內存得到 person_size,最后調用 malloc 方法開辟內存返回指針。

  分配一塊內存給person實例對象 這種行為屬于person類對象的職責,因此將這種行為添加到 personClsObject 類對象的 methodList 中(其實細細想來,是不太恰當的,之后還會繼續改進),命名為 mallocInstance。

  /// 簡單修改下定義 真實定義結構名稱改為了 `Person_IMP`

  typedef struct object Person;

  struct Person_IMP {

  char name[12];

  int age;

  int sex;

  }

  /// 增加一個分配內存的方法 注意傳參為實例對象 對于當前方法來說應該傳NULL

  (struct object *)mallocIntance(void *myself) {

  /// 偽代碼

  int size = 0;

  for variable in personClsObject->variableList {

  size = variable->memorySize;// 當然這里肯定要考慮內存對齊問題

  }

  return (struct object *)malloc(size);

  }

  personClsObject->methodList[xx]=mallocInstance;

  /// 分配內存改寫如下:

  void (*mallocIntance)(void *) = findMethod(personClsObject, "mallocIntance");

  Person *pmst = mallocIntance(NULL); // 之前是要傳一個實例對象進去,為了方便操作,但是分配內存比較特殊,要知道此刻連實例都不存在!

  3.8 對象調用函數方式的思考

  實例對象函數調用過程: findMethod 傳入對應的類對象和函數名稱,遍歷 methodList 找到匹配項返回函數指針,傳入實例對象指針調用即可,譬如之前person實例調用自我介紹方法的demo。

  /// 現在調用方式改為:

  void (*call)(void *) = findMethod(personClsObject, "selfIntroducation");

  call(pmst);

  那么問題來了,實例對象的屬性變量如何修改呢?比如name,age和sex。現在已經不能像最開始之前那樣直接訪問內存地址進行修改了,盡管personClsObject知道這些變量的信息:變量名稱,類型以及所占內存大小。

  其實解決方案也很簡單,既然不能直接訪問變量,間接總可以把!

  Any problem in computer science can be solved by anther layer of indirection.

  現在為每個屬性變量都創建一個讀寫方法,通過調用這兩個方法來修改實例對象內存中的變量值(Note:前8個字節保存的是類對象地址)

  void setName(void *my_self, char *newName) {}

  char *getName(void *my_self) {}

  注意到不同函數的傳參個數也不同,如 selfIntroducation 傳參僅 void *my_self一個,而 setName 方法傳參個數為2。這其實是ok,Method封裝的是個函數指針(占4或8個字節),指向某塊代碼段的地址,C語言又是支持可變參數的函數,原理自行google關鍵字"C語言 函數 可變參數"。

  這里講下我的理解,函數其實就是封裝好的代碼塊,編譯之后轉成一串指令保存在代碼段。

  關于函數調用:正常的調用方式 functionName(variable1,variable2,variable3),編譯器會把functionName替換成函數地址(0x12345678),匯編可能是使用類似 call 0x12345678 來調用函數;

  關于函數入參實現:variable1 variable2 variable3,應該是會調用 push 指令一個個入棧(這里注意是先 push variable1 還是 push variable3 是由ABI決定的!)

  如果說函數是指令,那么棧就是給函數提供數據的源!函數實現是一串指令,使用push和pop操作棧上的數據,拿上面的函數入參來說,我們就使用 push 命令將variable1 variable2 variable3壓到棧里,其中 ebp 寄存器指向當前函數調用上下文的棧 base address,而esp寄存器則是根據push和pop改變指針地址,一開始ebp和esp指針都是指向 base address。

  [圖片上傳失敗...(image-f28fc2-1519970136607)]

  上面就是簡單的一個調用方式,至于variable1這些函數入參如何取,應該是依靠 ebp+ offset得到。

  當然如果是學習C語言的話也可以參考下面的資料

  C語言編程基礎

  [http://www.makeru.com.cn/live/1758_311.html?s=45051

  結構體普及與應用

  [http://www.makeru.com.cn/live/5413_1909.html?s=45051

  C語言玩轉鏈表

  [http://www.makeru.com.cn/live/1392_338.html?s=45051
論壇首頁 綜合技術版

跳轉論壇:
Global site tag (gtag.js) - Google Analytics 开心农场种蔬菜赚钱 喜乐彩喜乐彩官网 甘肃十一选五开奖结果查询结果77期 河南快3一定牛遗漏 甘肃快三开奖结果走势图一定牛一 广东十一选五一定牛 福建36选7开奖查询 彩票开奖查询内蒙古11选5 吉利期货配资网站 宁夏十一选五助手 十一运夺金个人见解 基金配资地址 黑龙江11选五走势图表 重庆时彩时彩官网 股红在线 杨方配资开户 河北11选五基本走势图 江西多乐彩走势农经网