データ指向の話 第一章「基礎編」

●目指すもの

　まず、データ指向の目指すところは「わかりやすいこと」です。 特にコード上では「可読性」を重視します。 すべてにおいてこれが優先されます。

● データ指向という言葉

　「データ指向」という言葉ですが、聞いたことはない と思いますが、 それもそのはずで、わたしが勝手に名付けた言葉ですから、 心配しないでください。
　もし、この言葉を「以前に聞いたことがある」という方がいましたら、 それは、おそらく別の概念と思われます。気を付けてください。 その場合は「データ主眼設計」とか、「スコープ指向設計」などと、読み替えていただいても結構です。 もしくは、「コンポーネント指向」という言葉が近い概念かもしれません。
　基本的な考え方は「データを大切にしよう！」とか 「機能ではなく、データに着目して考えよう！」というものです。 この概念による効果は「可読性の向上」や「わかりやすさ」「保守のしやすさ」だと思っています。 おそらく、プログラマの方であれば、メリットのある話だと思います。 難しい話ではないので、気楽に読んでください。

● オブジェクト指向との違い

　オブジェクト指向の概念は、主に「値（変数）と機能（関数）を 部品（オブジェクト）としてまとめて切り出すこと」「どちらかといえば機能を重視して切り出すこと」を薦めている概念だと思います。
　データ指向の概念では、主に「値（変数）を優先的に切り出すこと」を薦めます。 機能（関数）の切り出しの優先度はその次になります。
　データ指向はオブジェクト指向へのアプローチの１つの方法（概念）である と考えていただいても、問題ないと思います。
　一般的なプログラム開発では、機能や振る舞い「何をするのか？」に着目して 切り出し／分割／実装 して行きますが、 データ指向では、まずデータ（変数）「何があるのか？」に着目し 切り出し／分割／実装して行きます。 実際にコードを書いてみるとわかると思いますが、 このほうが、切り出しやすく、実装しやすすく、 さらに「わかりやすい」のです。

●データを切り出す

　データを切り出すと言っても、難しく考えないで下さい。 下の Ｃ言語での例を見れば簡単に理解していただけると思います。

int  main() {     int  a = 10 ;      int  b = 20 ;      printf( "a: %d \n", a ) ;      printf( "b: %d \n", b ) ;      return 0 ;  }

int  main() {     {         int  a = 10 ;          printf( "a: %d \n", a ) ;      }     {         int  b = 20 ;          printf( "b: %d \n", b ) ;      }     return 0 ;  }

int  x = 0 ;  int  y = 0 ;  int  i = 0 ;

int  point_x = 0 ;    // ローカルで使う座標Ｘ int  point_y = 0 ;    // ローカルで使う座標Ｙ int  gr_count_i = 0 ; // グローバル（広範囲）で使うカウンタ

int  a ;         // a は どこからでもアクセス可能 static int  b ;  // b は このファイル内しかアクセスできない int  main() {     int  c ;     // c は main() 関数内でのみアクセス可能     {         int  d ; // d は このスコープ内のみアクセス可能              }     return 0 ; }

a : グローバル変数 b : ファイルローカルな変数 c : 関数ローカルな変数 d : ローカルな変数

int main() {     int  a ;      int  b ;      int  c ;      int  d ;      int  e ;          ;      // ← ここ     return 0 ; }

int main() {     {         int  a ;          int  b ;            ;      }     {         int  c ;          int  d ;            ;      }     {         int  e ;            ;          // ← ここ     }     return 0 ; }

main() {     char st[]="ABCDEFG";      char *p;      p=st;      while(*p){          printf("%7s\n",p);          ++p;      } }

int  main()                                 //  ←(1)  {     char  abc_str[] = "ABCDEFG" ;           //  ←(2)     int   lng = strlen( abc_str ) ;         //  ←(3)     int   i = 0 ;     for ( ; i<lng ; ++i )                   //  ←(4)     {                                       //  ←(5)         printf( "%7s\n", & abc_str[i] ) ;      }     return  0 ;                             //  ←(6) }

void  boo() {     void *  p = malloc( size ) ; // ← ここで生まれた。       ;      {         free( p ) ; // ← ここで破棄           ;      }       ;  // ← (a) }

void  boo() {     void *  p = malloc( size ) ; // ← ここで生まれた。       ;      {         ;      }       ;      free( p ) ; // ← ここで破棄 }

void  boo() {       ;      {         void *  p = malloc( size ) ; // ←ここで生まれた           ;          free( p ) ; // ← ここで破棄     }       ;  }

class MemAlloc { public:     void *  m_ptr ; // ポインタ     // コンストラクタ public:     MemAlloc(         int  in_size     )     {         m_ptr = malloc( in_size ) ; // 生成     }     // デストラクタ public:     ~MemAlloc()     {         if ( m_ptr != 0 )         {             free( m_ptr ) ;      // 破棄             m_ptr = 0 ;          }     } } ;  int  main() {     MemAlloc  mem( 1024 ) ; // 自動的に生成       ;     return 0 ;              // 自動的に破棄  }

int  a ;

int  a = 0 ; // 初期値 0 を代入

int  a ;  int  f = foo() ;  if ( 0 < f ) {     a = f ;  }   ;  printf( "a : %d \n", a ) ;

int  a = 0 ;     // ←ここが違う  int  f = foo() ;  if ( 0 < f ) {     a = f ;  }   ;  printf( "a : %d \n", a ) ;

int  f = foo() ;  if ( 0 < f ) {     int  a = f ; // ←ここが違う        ;      printf( "a : %d \n", a ) ; // ←この位置も }

Boo  b ;

void  foo() {     int  i ;      for ( i=0 ; i<DATA_MAX ; ++i )     {         ;  // DATA_MAX回 繰り返す     }     for ( i=0 ; i<BUFF_MAX ; ++i )     {         ;  // BUFF_MAX回 繰り返す     } }

void  foo() {     {         int  i = 0 ;         for ( ; i<DATA_MAX ; ++i )         {             ;  // DATA_MAX回 繰り返す         }     }     {         int  i = 0 ;         for ( ; i<BUFF_MAX ; ++i )         {             ;  // BUFF_MAX回 繰り返す         }     } }

void  foo() {     { int  i = 0 ;       for ( ; i<DATA_MAX ; ++i )     {         ;  // DATA_MAX回 繰り返す     }}     { int  i = 0 ;       for ( ; i<BUFF_MAX ; ++i )     {         ;  // BUFF_MAX回 繰り返す     }} }

int main() {     int  a = 0 ;      a += 1 ;      {         int  b = 0 ;          // a と b を利用         b += 10 ;          {             int  c = 0 ;              // b, c を利用。             // a は使っていないけどアクセス可能              c += 100 ;              b += c ;          }         a += b ;      }     printf( "%d", a ) ;      return 0 ;  }

void  sub( int &  in_b ) {     int  c = 0 ;      // b, c を利用。     // a はアクセス不可。めでたしめでたし。     c    += 100 ;      in_b += c ;  } int main() {     int  a = 0 ;      a += 1 ;      {         int  b = 0 ;          // a と b を利用         b += 10 ;          sub( b ) ;          a += b ;      }     printf( "%d", a ) ;      return 0 ;  }

int main() {     // 深いインデント     if ( boo() > 5 )     {         if ( foo() > 10 )         {             if ( woo() > 15 )             {                 puts( "インデントは深い（４段）" ) ;              }         }     }     return 0 ; }

int main() {     // 浅いインデント     {         if ( boo() <= 5 )         {             goto next ;         }         if ( foo() <= 10 )         {             goto next ;         }         if ( woo() <= 15 )         {             goto next ;         }         puts( "インデントは浅い（２段）" ) ;         next : ; // インデントを浅くするためのラベル     }     return 0 ; }

// アドレス渡し void  Address( long *  adr ) {     *adr += 100 ;      printf( "Address:%d \n", * adr ) ;  } // コピー渡し void  Copy( long  cpy ) {     cpy += 10 ;      printf( "Copy:%d \n", cpy ) ;  } // リファレンス渡し void  Reference( long &  ref ) {     ref += 1 ;      printf( "Reference:%d \n", ref ) ;  } int main() {     long  test = 12345 ;      Address( & test ) ; // アドレス渡し     Copy( test ) ;      // コピー渡し     Reference( test ) ; // リファレンス渡し      printf( "main:%d \n", test ) ;      return 0 ;  }

void  str_set( char *  out_str ) // 文字列を返す {     strcpy( out_str, "データを返す" ) ;  } int main() {     char  buff[128] ; // 入れてもらうバッファ     str_set( buff ) ; // buff に入って返ってくる      printf( buff ) ;      return 0 ;  }

class Buff {     #define  SIZE  (128) public:     char  m_buff[SIZE] ; // 値を返すバッファ  public:     Buff() // コンストラクタ     {         strcpy( m_buff, "" ) ; // 初期化     } public:     void  str_set() // 文字列を返す     {         strncpy( m_buff, "データを返す", SIZE ) ;      }     #undef  SIZE } ; int main() {     Buff  b ; // ← バッファ     b.str_set() ; // バッファに入れてもらう。     printf( b.m_buff ) ; // buff は見える。     return 0 ;  }

void  sub( int  in_n ) {     in_n += 10 ; // ←コピーに上書きしている      printf( "in_n : %d \n", in_n ) ;  } int main() {     int  n = 1 ;      sub( n ) ; // n の内容は保証されている      printf( "n : %d \n", n ) ;      return 0 ;  }

void  sub( int &  in_n ) {     in_n += 10 ; // ←上書きしている（とても危険）      printf( "in_n : %d \n", in_n ) ;  } int main() {     int  n = 1 ;      sub( n ) ; // n がいつのまにか上書きされてしまう      printf( "n : %d \n", n ) ;      return 0 ;  }

void  sub( const int &  in_n ) // 上書き禁止 {     // in_n += 10 ; // ←上書き不可（コンパイルエラー）     int  cpy = in_n + 10 ; // ←コピーは意識して作る      printf( "cpy : %d \n", cpy ) ;  } int main() {     int  n = 1 ;      sub( n ) ; // n はそのまま     printf( "n : %d \n", n ) ;      return 0 ;  }

int main() {     printf( "面積 a : %d \n", 3 * 2 ) ;      printf( "面積 b : %d \n", 5 * 4 ) ;      return 0 ;  }

int main() {     int  a_width  = 3 ;  // 変数（ 面積 a の横 ）     int  a_height = 2 ;  // 変数（ 面積 a の縦 ）     int  b_width  = 5 ;  // 変数（ 面積 b の横 ）     int  b_height = 4 ;  // 変数（ 面積 b の縦 ）     printf( "面積 a : %d \n", a_width * a_height ) ;      printf( "面積 b : %d \n", b_width * b_height ) ;      return 0 ;  }

// 関数（面積を計算） int  area( int  in_w, int  in_h ) {     return  in_w * in_h ;  } int main() {     int  a_width  = 3 ;      int  a_height = 2 ;      int  b_width  = 5 ;      int  b_height = 4 ;      printf( "面積 a : %d \n", area( a_width, a_height ) ) ;      printf( "面積 b : %d \n", area( b_width, b_height ) ) ;      return 0 ;  }

struct  Rectangle // 構造体（長方形） {     int  m_width  ;  // 横     int  m_height ;  // 縦 } ;  int  area( Rectangle  in_r ) // 関数 {     return  in_r.m_width * in_r.m_height ;  } int main() {     Rectangle  rect_a = { 3, 2 } ;      Rectangle  rect_b = { 5, 4 } ;      printf( "面積 a : %d \n", area( rect_a ) ) ;      printf( "面積 b : %d \n", area( rect_b ) ) ;      return 0 ;  }

class Rectangle  // クラス化 {     // メンバ public:     int  m_width  ;      int  m_height ;      // コンストラクタ public:     Rectangle( int  in_w, int  in_h )     {         m_width  = in_w ;          m_height = in_h ;      }     // メソッド（面積を計算） public:     int  area()     {         return  m_width * m_height ;      } } ;  int main() {     Rectangle  rect_a( 3, 2 ) ;      Rectangle  rect_b( 4, 5 ) ;      printf( "面積 a : %d \n", rect_a.area() ) ;      printf( "面積 b : %d \n", rect_b.area() ) ;  // 隠蔽されてはいないので、以下のようなアクセスも可能。 // ここでは参照だが、勝手に更新される危険があるということ。 printf( "面積 a : %d \n", rect_a.m_width * rect_a.m_height );  printf( "面積 b : %d \n", rect_b.m_width * rect_b.m_height );      return 0 ;  }

class Rectangle {     // メンバ     private : int  m_width  ;  // ← 隠蔽     private : int  m_height ;  // ← 隠蔽     // コンストラクタ public:     Rectangle( int in_w, int in_h )     {         m_width  = in_w ;          m_height = in_h ;      }     // メソッド（面積を計算） public:     int  area()     {         return  m_width * m_height ;      } } ;  int main() {     Rectangle rect_a( 3, 2 ) ;      Rectangle rect_b( 4, 5 ) ;      printf( "面積 a : %d \n", rect_a.area() ) ;      printf( "面積 b : %d \n", rect_b.area() ) ;  /* 以下、隠蔽されているので、アクセス不可。コンパイルエラー。 printf( "面積 a : %d \n", rect_a.m_width * rect_a.m_height );  printf( "面積 b : %d \n", rect_b.m_width * rect_b.m_height );  */     return 0 ;  }

int main() {     // スコープにより「面積 a」でまとめる     {         int  width  = 3 ;  // 横         int  height = 2 ;  // 縦         printf( "面積 a : %d \n", width * height ) ;      }     // スコープにより「面積 b」でまとめる     {         int  width  = 5 ;  // 横         int  height = 4 ;  // 縦         printf( "面積 b : %d \n", width * height ) ;      }     return 0 ;  }

class Rectangle {     // メンバ     private : int  m_width  ;  // 横     private : int  m_height ;  // 縦     // コンストラクタ public:     Rectangle( int in_w, int in_h )     {         m_width  = in_w ;          m_height = in_h ;      }     // メソッド（面積を計算） public:     int  area()     {         return  m_width * m_height ;      } };  int main() {     // スコープにより「面積 a」でまとめる     {         Rectangle  rect( 3, 2 ) ;          printf( "面積 a : %d \n", rect.area() ) ;      }     // スコープにより「面積 b」でまとめる     {         Rectangle  rect( 4, 5 ) ;          printf( "面積 b : %d \n", rect.area() ) ;      }     return 0 ;  }

int main() {     int  all_area = 0 ;  // 総面積     {         int  width  = 3 ;  // 横         int  height = 2 ;  // 縦         printf( "面積 a : %d \n", width * height ) ;          all_area += width * height ;      }     {         int  width  = 5 ;  // 横         int  height = 4 ;  // 縦         printf( "面積 b : %d \n", width * height ) ;          all_area += width * height ;      }     printf( "総面積 : %d \n", all_area ) ;      return 0 ;  }

class Rectangle {     // ... 同じなので省略 } ;  int main() {     int  all_area = 0 ;  // 総面積     {         Rectangle  rect( 3, 2 ) ;          printf( "面積 a : %d \n", rect.area() ) ;          all_area += rect.area() ;      }     {         Rectangle  rect( 4, 5 ) ;          printf( "面積 b : %d \n", rect.area() ) ;          all_area += rect.area() ;      }     printf( "総面積 : %d \n", all_area ) ;      return 0 ;  }