いしな.net

C言語でオブジェクト指向

クラス構造

  1. struct MyClassA_VFTABLE;
  3. /* データ部定義 */
  4. struct MyClassA_OBJECT
  5. {
  6. float x, y, z;
  7. };
  9. struct MyClassA_DATA
  10. {
  11. struct MyClassA_OBJECT MyClassA;
  12. };
  15. /* クラス本体定義 */
  16. struct MyClassA
  17. {
  18. struct MyClassA_VFTABLE *call;
  19. struct MyClassA_DATA data;
  20. };
  22. /* 仮想関数定義 */
  23. struct MyClassA_VFPTR
  24. {
  25. unsigned int offset;
  26. void (*Release)( struct MyClassA *this );
  27. void (*Func1)( struct MyClassA *this, int arg1 );
  28. void (*Func2)( struct MyClassA *this, int arg1 );
  29. };
  31. struct MyClassA_VFTABLE
  32. {
  33. struct MyClassA_VFPTR MyClassA;
  34. };
  36. /* インスタンス作成用 */
  37. struct MyClassA* MyClassA_new( void );
  39. /* メンバ関数 */
  40. void MyClassA_Release( struct MyClassA *this );
  41. void MyClassA_Func1( struct MyClassA *this, int arg1 );
  42. void MyClassA_Func2( struct MyClassA *this, int arg1 );

これは以下のように使う

  1. struct MyClassA *myA;
  2. /* インスタンス作成 */
  3. myA = MyClassA_new();
  5. /* メソッド呼び出し */
  6. myA->call->MyClassA.Func1( myA, 1 );
  8. /* インスタンス破棄 */
  9. myB->call->MyClassB.Release( myB );
2014/01/02（木）

単一継承してみる

MyClassAから派生したMyClassBを作ってみる。
  1. struct MyClassB_VFTABLE;
  3. /* データ部定義 */
  4. struct MyClassB_OBJECT
  5. {
  6. float s, t, u;
  7. };
  9. struct MyClassB_DATA
  10. {
  11. struct MyClassA_OBJECT MyClassA;
  12. struct MyClassB_OBJECT MyClassB;
  13. };
  15. /* クラス本体定義 */
  16. struct MyClassB
  17. {
  18. struct MyClassB_VFTABLE *call;
  19. struct MyClassB_DATA data;
  20. };
  22. /* 仮想関数定義 */
  23. struct MyClassB_VFPTR
  24. {
  25. void (*Func1)( struct MyClassB* this, int arg1 );
  26. };
  28. struct MyClassB_VFTABLE
  29. {
  30. struct MyClassA_VFPTR MyClassA;
  31. struct MyClassB_VFPTR MyClassB;
  32. };
  34. /* インスタンス作成用 */
  35. struct MyClassB* MyClassB_new( void );
  37. /* メンバ関数 */
  38. void MyClassB_Release( struct MyClassB *this );
  39. void MyClassB_Func1( struct MyClassB *this, int arg1 );
  40. void MyClassB_Func2( struct MyClassB *this, int arg1 );

データ構造のイメージはこんな感じになります

MyClassBは以下のように使う

  1. struct MyClassA *myA;
  2. struct MyClassB *myB;
  3. /* インスタンス作成 */
  4. myB = MyClassB_new();
  5. myA = (struct MyClassA*)myB;
  7. /* メソッド呼び出し */
  8. myB->call->MyClassA.Func1( myB, 1 );
  9. myB->call->MyClassA.Func2( myB, 1 );
  10. myB->call->MyClassB.Func1( myB, 1 );
  12. myA->call->MyClassA.Func1( myA, 2 );
  13. myA->call->MyClassA.Func2( myA, 2 );
  15. /* インスタンス破棄 */
  16. myB->call->MyClassA.Release( myB );

12、13行目のように、MyClassAとしても動作する。
warningが出るのは、とりあえず気にしてはいけない。

2014/01/02（木）

MyClassAの実装

さて、それぞれのクラスの実装がどうなっているかというと。
  1. void MyClassA_INIT( void );
  2. void MyClassA_VFTABLE_INIT ( struct MyClassA_VFTABLE *vfptr );
  4. /* MyClassA_VFTABLEのインスタンスは１つだけあれば良い */
  5. struct MyClassA_VFTABLE MyClassA_vfptr;
  7. void MyClassA_INIT( void )
  8. {
  9. MyClassA_VFTABLE_INIT( &MyClassA_vfptr );
  10. }
  12. void MyClassA_VFTABLE_INIT ( struct MyClassA_VFTABLE *vfptr )
  13. {
  14. vfptr->MyClassA.Release = MyClassA_Release;
  15. vfptr->MyClassA.Func1 = MyClassA_Func1;
  16. vfptr->MyClassA.Func2 = MyClassA_Func2;
  17. };
  23. void MyClassA_Release( struct MyClassA *this )
  24. {
  25. struct MyClassA_DATA *data = (struct MyClassA_DATA*)(((char*)this) + this->call->MyClassA.offset);
  26. free( this );
  27. }
  29. void MyClassA_Func1( struct MyClassA *this, int arg1 )
  30. {
  31. puts( "MyClassA_Func1" );
  32. }
  34. void MyClassA_Func2( struct MyClassA *this, int arg1 )
  35. {
  36. puts( "MyClassA_Func2" );
  37. }
  39. struct MyClassA* MyClassA_new( void )
  40. {
  41. struct MyClassA *p = (struct MyClassA*)malloc( sizeof(struct MyClassA) );
  42. /* 各VFTABLEにはポインタを仕込むだけ */
  43. p->call = &MyClassA_vfptr;
  44. return p;
  45. }
2014/01/02（木）

MyClassBの実装

  1. void MyClassB_INIT( void );
  2. void MyClassB_VFTABLE_INIT ( struct MyClassB_VFTABLE *vfptr );
  3. void MyClassA_VFTABLE_INIT ( struct MyClassB_VFTABLE *vfptr );
  5. /* MyClassB_VFTABLEのインスタンスは１つだけあれば良い */
  6. struct MyClassB_VFTABLE MyClassB_vfptr;
  8. void MyClassB_INIT( void )
  9. {
  10. MyClassB_VFTABLE_INIT( &MyClassB_vfptr );
  11. }
  13. void MyClassB_VFTABLE_INIT ( struct MyClassB_VFTABLE *vfptr )
  14. {
  15. /* MyClassAのVFPTRを先に初期化して */
  16. MyClassA_VFTABLE_INIT( (struct MyClassA_VFTABLE *)vfptr );
  17. /* オーバーライドとはVFPTRの関数ポインタ書き換えに他ならない */
  18. vfptr->MyClassA.Release = (void (*)(struct MyClassA*))MyClassB_Release;
  19. vfptr->MyClassA.Func2 = (void (*)(struct MyClassA*,int))MyClassB_Func2;
  21. /* VFPTRのVFPTR初期化 */
  22. vfptr->MyClassB.Func1 = MyClassB_Func1;
  23. };
  26. void MyClassB_Release( struct MyClassB* this )
  27. {
  28. free( this );
  29. }
  31. void MyClassB_Func1( struct MyClassB* this, int arg1 )
  32. {
  33. puts( "MyClassB_Func1" );
  34. }
  36. void MyClassB_Func2( struct MyClassB* this, int arg1 )
  37. {
  38. puts( "MyClassB_Func2" );
  39. }
  41. struct MyClassB* MyClassB_new( void )
  42. {
  43. struct MyClassB *p = (struct MyClassB*)malloc( sizeof(struct MyClassB) );
  45. p->call = &MyClassB_vfptr;
  46. return p;
  47. }
2014/01/02（木）

MyClassAからコピペして作ったMyClassC

“MyClassC”は“MyClassA”とそっくりですが、全く別のクラスです。なんと、floatとintが入れ替わっているのです！！
  1. struct MyClassC_VFTABLE;
  3. /* データ部定義 */
  4. struct MyClassC_OBJECT
  5. {
  6. int x, y, z;
  7. };
  9. struct MyClassC_DATA
  10. {
  11. struct MyClassC_OBJECT MyClassC;
  12. };
  15. /* クラス本体定義 */
  16. struct MyClassC
  17. {
  18. struct MyClassC_VFTABLE *call;
  19. struct MyClassC_DATA data;
  20. };
  22. /* 仮想関数定義 */
  23. struct MyClassC_VFPTR
  24. {
  25. unsigned int offset;
  26. void (*Release)( struct MyClassC *this );
  27. void (*Func1)( struct MyClassC *this, float arg1 );
  28. void (*Func2)( struct MyClassC *this, float arg1 );
  29. };
  31. struct MyClassC_VFTABLE
  32. {
  33. struct MyClassC_VFPTR MyClassC;
  34. };
  36. /* インスタンス作成用 */
  37. struct MyClassC* MyClassC_new( void );
  39. /* メンバ関数 */
  40. void MyClassC_Release( struct MyClassC *this );
  41. void MyClassC_Func1( struct MyClassC *this, float arg1 );
  42. void MyClassC_Func2( struct MyClassC *this, float arg1 );
2014/01/02（木）

MyClassBとMyClassCから派生したMyClassD

SVG表示失敗 こんな感じにするのですが。
ClassD_VFTABLEはこれの先頭を指し、ClassC_VFTABLEはこれのClassC_VFPTRの先頭を指す
  1. struct MyClassD_VFTABLE;
  2. struct MyClassD_VFTABLE2;
  4. /* データ部定義 */
  5. struct MyClassD_OBJECT
  6. {
  7. int dummy;
  8. };
  10. struct MyClassD_DATA
  11. {
  12. struct MyClassA_OBJECT MyClassA;
  13. struct MyClassB_OBJECT MyClassB;
  14. struct MyClassD_OBJECT MyClassD;
  15. };
  16. struct MyClassD_DATA2
  17. {
  18. struct MyClassC_OBJECT MyClassC;
  19. };
  21. /* クラス本体定義 */
  22. struct MyClassD
  23. {
  24. struct MyClassD_VFTABLE *call;
  25. struct MyClassD_DATA data;
  26. struct MyClassD_VFTABLE2 *call2;
  27. struct MyClassD_DATA2 data2;
  28. };
  30. /* 仮想関数定義 */
  31. struct MyClassD_VFPTR
  32. {
  33. void (*Func1)( struct MyClassD* this, int arg1 );
  34. };
  36. struct MyClassD_VFTABLE
  37. {
  38. struct MyClassA_VFPTR MyClassA;
  39. struct MyClassB_VFPTR MyClassB;
  40. struct MyClassD_VFPTR MyClassD;
  41. struct MyClassC_VFPTR MyClassC;
  42. };
  43. struct MyClassD_VFTABLE2
  44. {
  45. struct MyClassC_VFPTR MyClassC;
  46. };
  48. /* インスタンス作成用 */
  49. struct MyClassD* MyClassD_new( void );
  51. /* メンバ関数 */
  52. void MyClassD_Release( struct MyClassD *this );
  53. void MyClassD_Func1( struct MyClassD *this, int arg1 );

MyClassDは以下のように使う。

  1. struct MyClassA *myA;
  2. struct MyClassB *myB;
  3. struct MyClassC *myC;
  4. struct MyClassD *myD;
  5. /* インスタンス作成 */
  6. myD = MyClassD_new();
  7. myA = (struct MyClassA*)myD;
  8. myB = (struct MyClassB*)myD;
  9. /* MyClassCへのキャストはこうしなければならない */
  10. myC = (struct MyClassC*)(&myD->call2);
  12. /* メソッド呼び出し */
  13. myB->call->MyClassA.Func1( myB, 1 );
  14. myB->call->MyClassA.Func2( myB, 1 );
  15. myB->call->MyClassB.Func1( myB, 1 );
  17. myA->call->MyClassA.Func1( myA, 2 );
  18. myA->call->MyClassA.Func2( myA, 2 );
  20. myD->call2->MyClassC.Func1( myC, 2 );
  21. myC->call->MyClassC.Func2( myC, 2 );
  23. /* インスタンス破棄 */
  24. myB->call->MyClassA.Release( myB );

この20行目の呼び出しが正常に行われないと、「継承した」などとは言えないのである。
しかし、その制限によって、MyClassCのメソッドは19行目のように、thisポインタとしてMyClassCへキャストしたものを渡さなければならない。

MyClassAのメソッドは、『VFTABLEポインタの直後からMyClassA用のデータが存在する』ことを要求し、同様にMyClassCのメソッドは、『VFTABLEポインタの直後からMyClassC用のデータが存在する』ことを要求するためである。

これに関連し、もう一つ厄介なことがある。MyClassCのメソッドをオーバーライドした場合だよ！！thisポインタを戻さないとMyClassDのデータ領域にアクセスできないのだ！菱形継承をすると、さらにとんでもないことになるし。

マジ、メンドイのである。だからJavaやC#では多重継承というものが無くなったのだろう。

2014/01/03（金）

インターフェースだとどうなるか？

SVG表示失敗 こうなる。
InterfaceA / InterfaceB / InterfaceD / MyClassのVFTABLEのポインタは同一となるため、1つだけ持っていれば良い。
InterfaceCとInterfaceEは別のVFTABLEへのポインタを持つ必要があるのだが、ここで問題なのがInterfaceEはInterfaceAを継承していることである。
このため、InterfaceE_VFPTRの直前にInterfaceA_VFPTRが存在している必要があるのだああああああッッ！！
この重複したInterfaceA_VFPTRには全く同一のものが入ることになる。
それは、インスタンス作成ルーチンの中に自分で記述する必要がある。
C言語はそれらの補助を一切してくれない。