はじめに

UML表記法やUMLモデリングのセミナー講師をしていると、「自分の言語ではどのように実装すればよいのか」というご質問を受けることがあります。また、講師側としても、受講生が使っているプログラミング言語でUMLを説明すると、すんなりと分かって頂ける経験が幾度となくあります。多くのプログラマがUMLモデリングに興味を持って頂けているようですが、UMLのモデルをどのようにソースコードにするかについては意外と知られていません。これが、UMLモデリングが広まらない原因の1つではないかと考えています。

UMLからソースコードへの変換を「マッピング」といい、プログラミング言語名を付けて、「UML/C++マッピング」のように呼びます。このシリーズは、さまざまなプログラミング言語への「UML/Xマッピング」を紹介して、馴染みのあるプログラミング言語からUMLを逆に理解して貰えるように企画したものです。ただし、マッピングは様々なマッピング方法を考える事が可能です。ご紹介するものは、その具体例の1つだとお考え下さい。

この記事を理解するために必要な基本的な知識

この記事は、最小限のUML表記法が分かることを前提としています。例えば、クラス図では属性/操作や関連端名/多重度および可視性の読み方、汎化関係/実現関係の意味、シーケンス図のメッセージとクラスの操作の対応関係、を理解していることが前提です。

この記事のマッピングの方針

この記事は、現在C言語で開発しており、C++への移行はハードルが高いが、C言語でもクラスを再利用したコーディングをしたい、という人向けに、疑似的にクラスのインスタンス化を実現するマッピングを紹介します。

基本的には、属性群と操作群（変数群と関数群）を分ける考え方を採ります。クラスの属性群をまとめたstructを宣言し、そのstruct型を用いてインスタンスの数だけ実体を宣言します。
操作群は、クラス＝.cファイルとして、.cファイル内に関数宣言します。関数の引数に、struct型の変数を渡すことで、疑似的にインスタンス化します。関数名の先頭には「クラス名_」を付けます。

クラスの基本要素(クラス,属性,操作)のマッピング

A.h

#ifndef A_H
#define A_H

typedef struct {
    int member1;
    // char member2[50]; // protectedは対応しません
    int member3;
    // char member4[50]; // packageは対応しません
} A;

// コンストラクタとデストラクタ
A* A_create(int member1, const char* member2, int member3, const char* member4);
void A_destroy(A* a);

// メソッド
void A_method1(A* a);
// char* A_method2(A* a); // protectedは対応しません
void A_method3(A* a);
// char* A_method4(A* a); // packageは対応しません

#endif

A.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "A.h"

// コンストラクタ
A* A_create(int member1, const char* member2, int member3, const char* member4) {
    A* a = (A*)malloc(sizeof(A));
    if (a == NULL) {
        return NULL; // メモリ確保失敗
    }
    a->member1 = member1;
    // strncpy(a->member2, member2, sizeof(a->member2) - 1); // protectedは対応しません
    // a->member2[sizeof(a->member2) - 1] = '\0';
    a->member3 = member3;
    // strncpy(a->member4, member4, sizeof(a->member4) - 1); // packageは対応しません
    // a->member4[sizeof(a->member4) - 1] = '\0';
    return a;
}

// デストラクタ
void A_destroy(A* a) {
    free(a);
}

// メソッド
void A_method1(A* a) {
    printf("A::method1 called\n");
}

char* A_method2(A* a) {
    printf("A::method2 called\n");
    return a->member2;
}

void A_method3(A* a) {
    printf("A::method3 called\n");
}

char* A_method4(A* a) {
    printf("A::method4 called\n");
    return a->member4;
}

B.h

#ifndef B_H
#define B_H

typedef struct {
    // メンバーなし
} B;

// コンストラクタとデストラクタ
B* B_create();
void B_destroy(B* b);

// メソッド
char* B_method1();
char* B_hookMethod();

#endif

B.c

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

// コンストラクタ
B* B_create() {
    B* b = (B*)malloc(sizeof(B));
    if (b == NULL) {
        return NULL; // メモリ確保失敗
    }
    return b;
}

// デストラクタ
void B_destroy(B* b) {
    free(b);
}

// メソッド
char* B_method1() {
    printf("B::method1 called\n");
    return "B::method1 return value";
}

char* B_hookMethod() {
    printf("B::hookMethod called\n");
    return "B::hookMethod return value";
}

C.h

#ifndef C_H
#define C_H

typedef struct {
    // 静的変数なのでstructには含めない
} C;

// コンストラクタとデストラクタ
C* C_create();
void C_destroy(C* c);

// メソッド
int C_method1();

#endif

C.c

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

// 静的変数 (クラス全体で共有される)
static int member1;

// コンストラクタ
C* C_create() {
    C* c = (C*)malloc(sizeof(C));
    if (c == NULL) {
        return NULL; // メモリ確保失敗
    }

    // 静的変数に初期値を設定（インスタンスごとではなく、クラス全体で保持）
    member1 = 100;

    return c;
}

// デストラクタ
void C_destroy(C* c) {
    free(c);
}

// メソッド
// クラス図で操作名に下線が付いています（＝static操作）が、そもそも、このマッピングでは操作はすべてstatic操作として実装されているため、特に違いがありません。
int C_method1() {
    printf("C::method1 called\n");
    return member1;
}

main.c

#include <stdio.h>
#include "A.h"
#include "B.h"
#include "C.h"

int main() {
    // クラスAのインスタンス作成とメソッドのテスト
    //  ※ main()内のインスタンス化に失敗した場合の処理は省略しています
    A* a = A_create(10, "Hello", 20, "World");
    A_method1(a);
    printf("A::method2 returns: %s\n", A_method2(a));
    A_method3(a);
    printf("A::method4 returns: %s\n", A_method4(a));
    A_destroy(a);

    // クラスBのインスタンス作成とメソッドのテスト
    B* b = B_create();
    printf("B::method1 returns: %s\n", B_method1());
    printf("B::hookMethod returns: %s\n", B_hookMethod());
    B_destroy(b);

    // クラスCのインスタンス作成とメソッドのテスト
    C* c = C_create();
    printf("C::method1 returns: %d\n", C_method1(c));
    C_destroy(c);

    return 0;
}

汎化関係のマッピング（継承でのマッピング）

言語的に継承の仕組みがある言語では継承で実装しますが、言語的に継承の仕組みがない言語では埋め込みで実装します。

汎化関係そのものは、C言語では対応できません。

汎化関係のマッピング（委譲でのマッピング）

継承による実装は基底クラスと派生クラスの結合度がより強くなるため、意図的に結合度を下げるために委譲による実装を使うことがあります。

A.h

#ifndef A_H
#define A_H

typedef struct {
    int member1;
} A;

// コンストラクタとデストラクタ
A* A_create(int member1);  // クラスAのインスタンスを作成
void A_destroy(A* a);

// メソッド
int A_method1(A* a);       // クラスAのメソッド

#endif

A.c

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

// コンストラクタ
A* A_create(int member1) {
    A* a = (A*)malloc(sizeof(A));
    if (a == NULL) {
        return NULL;  // メモリ確保失敗
    }
    a->member1 = member1;
    return a;
}

// デストラクタ
void A_destroy(A* a) {
    free(a);
}

// メソッド
int A_method1(A* a) {
    printf("A::method1 called\n");
    return a->member1;
}

B.h

#ifndef B_H
#define B_H

#include "A.h"

typedef struct {
    A* delegate;  // クラスAのインスタンス (基底クラス)
} B;

// コンストラクタとデストラクタ
B* B_create(int member1);   // クラスBがクラスAのインスタンスを作成。クラスAを継承しているのでクラスAの初期化に必要なパラメータも、ここで渡される。
void B_destroy(B* b);

// メソッド
void B_publicMethod(B* b);  // クラスAに処理を委譲するメソッド

#endif

B.c

#include <stdio.h>
#include <stdlib.h>
#include "B.h"
#include "A.h"

// コンストラクタ
B* B_create(int member1) {
    B* b = (B*)malloc(sizeof(B));
    if (b == NULL) {
        return NULL;  // メモリ確保失敗
    }

    // クラスAのインスタンスを生成し、delegateに設定
    // 基底クラス部分のインスタンスを生成している
    b->delegate = A_create(member1);  // クラスAのコンストラクタにパラメータを渡す

    if (b->delegate == NULL) {
        free(b);  // クラスAの作成が失敗した場合、クラスBも解放
        return NULL;
    }

    return b;
}

// デストラクタ
void B_destroy(B* b) {
    if (b->delegate != NULL) {
        A_destroy(b->delegate);  // クラスAのインスタンスを解放
    }
    free(b);
}

// クラスAのメソッドを呼び出して処理を委譲
void B_publicMethod(B* b) {
    if (b->delegate != NULL) {
        printf("B::publicMethod is delegating to A::method1\n");
        int result = A_method1(b->delegate);  // クラスAのメソッドを呼び出す
        printf("Result from A::method1: %d\n", result);
    } else {
        printf("B::publicMethod: delegate is not set.\n");
    }
}

main.c

#include <stdio.h>
#include "A.h"
#include "B.h"

int main() {
    // クラスBのインスタンスを作成（基底クラスであるクラスAのインスタンスも内部で作成される）
    //  ※ main()内のインスタンス化に失敗した場合の処理は省略しています
    B* b = B_create(100);

    // BのpublicMethodを呼び出して、クラスAに処理を委譲
    B_publicMethod(b);

    // クラスBを破棄（集約ではなくコンポジションなので、クラスAも内部で解放される）
    B_destroy(b);

    return 0;
}

実現関係のマッピング

C++のように純粋にインタフェースに対応できませんが、分かりやすく工夫し、インタフェースを「実現クラスを差し替えるクラス」として実装した例です。
実現クラスの数だけインタフェースクラスがインスタンスを保持するため、freeが必要な場合は追加してください。

InterfaceA.h

#ifndef INTERFACEA_H
#define INTERFACEA_H

#include "B.h"

// InterfaceAの定義
typedef struct {
    B* b_ref;  // クラスBへの参照
    // B以外の実現クラスが出来た場合は、追加する
} InterfaceA;

// コンストラクタとデストラクタ
InterfaceA* InterfaceA_create();  // InterfaceAのインスタンスを作成
void InterfaceA_destroy(InterfaceA* a);  // InterfaceAのインスタンスを破棄

// メソッド
void InterfaceA_setB(InterfaceA* a, B* b);  // クラスBの参照をセット
int InterfaceA_method1(InterfaceA* a);      // クラスBのmethod1を呼び出す

#endif

InterfaceA.c

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

// コンストラクタ
InterfaceA* InterfaceA_create() {
    InterfaceA* a = (InterfaceA*)malloc(sizeof(InterfaceA));
    if (a == NULL) {
        return NULL;  // メモリ確保失敗
    }
    a->b_ref = NULL;  // 初期状態ではクラスBの参照はNULL
    return a;
}

// デストラクタ
void InterfaceA_destroy(InterfaceA* a) {
    free(a);  // クラスBは別の場所で解放されるためここでは解放しない
}

// クラスBの参照をセット
void InterfaceA_setB(InterfaceA* a, B* b) {
    a->b_ref = b;  // クラスBへの参照をセット
}

// 実現クラスのmethod1を呼び出す
int InterfaceA_method1(InterfaceA* a) {
    if (a->b_ref != NULL) {
        printf("InterfaceA::method1 is calling B::method1\n");
        return B_method1(a->b_ref);  // クラスBのmethod1を呼び出す
    } else {
        printf("InterfaceA::method1: B reference is not set.\n");
        return -1;
    }
    // クラスB以外が増えた場合は、elseの前に if else を追加して呼び出す
}

B.h

#ifndef B_H
#define B_H

typedef struct {
    int value;  // クラスB固有のメンバー
} B;

// コンストラクタとデストラクタ
B* B_create(int value);  // クラスBのインスタンスを作成
void B_destroy(B* b);    // クラスBのインスタンスを破棄

// メソッド
int B_method1(B* b);     // クラスBのmethod1

#endif

B.c

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

// コンストラクタ
B* B_create(int value) {
    B* b = (B*)malloc(sizeof(B));
    if (b == NULL) {
        return NULL;  // メモリ確保失敗
    }
    b->value = value;
    return b;
}

// デストラクタ
void B_destroy(B* b) {
    free(b);
}

// クラスBのmethod1の実装
int B_method1(B* b) {
    printf("B::method1 called, value = %d\n", b->value);
    return b->value;
}

main.c

#include <stdio.h>
#include "InterfaceA.h"
#include "B.h"

int main() {
    // クラスBのインスタンスを作成
    //  ※ main()内のインスタンス化に失敗した場合の処理は省略しています
    B* b = B_create(100);

    // InterfaceAのインスタンスを作成
    InterfaceA* a = InterfaceA_create();

    // InterfaceAにクラスBの参照をセット
    InterfaceA_setB(a, b);

    // InterfaceAのmethod1を呼び出し、クラスBのmethod1を通して処理を実行
    int result = InterfaceA_method1(a);
    printf("Result from InterfaceA::method1: %d\n", result);

    // インスタンスを破棄
    InterfaceA_destroy(a);
    B_destroy(b);

    return 0;
}

パッケージ図の依存のマッピング

パッケージをコードでは実現できませんが、代わりにフォルダでファイルを整理することで実現できます。

おわりに

本記事は、今後も更新していく可能性があります。ご利用の際は、最新の情報をご覧ください。

UMLをプログラミング言語で実装するには？ C言語(インスタンス対応)編

はじめに

この記事を理解するために必要な基本的な知識

この記事のマッピングの方針

クラスの基本要素(クラス,属性,操作)のマッピング

関連（片方向多重度0..1）のマッピング

関連（双方向多重度0..1）のマッピング

関連（片方向関連多重度1）のマッピング

関連（片方向関連多重度0..*）のマッピング

関連（集約）のマッピング

関連（コンポジション）のマッピング

関連（限定子）のマッピング

汎化関係のマッピング（継承でのマッピング）

汎化関係のマッピング（委譲でのマッピング）

実現関係のマッピング

パッケージ図の依存のマッピング

おわりに

はじめに

この記事を理解するために必要な基本的な知識

この記事のマッピングの方針

クラスの基本要素(クラス,属性,操作)のマッピング

関連（片方向 多重度0..1）のマッピング

関連（双方向 多重度0..1）のマッピング

関連（片方向関連 多重度1）のマッピング

関連（片方向関連 多重度0..*）のマッピング

関連（集約）のマッピング

関連（コンポジション）のマッピング

関連（限定子）のマッピング

汎化関係のマッピング（継承でのマッピング）

汎化関係のマッピング（委譲でのマッピング）

実現関係のマッピング

パッケージ図の依存のマッピング

おわりに

関連（片方向多重度0..1）のマッピング

関連（双方向多重度0..1）のマッピング

関連（片方向関連多重度1）のマッピング

関連（片方向関連多重度0..*）のマッピング