分割コンパイル | Programming Place Plus　新C++編

複数のソースファイル 🔗

前のページまでで、トランプのカードを表現できるようになり、山札までは用意できています。手札を表現することも、要素数が 5 の std::vector<Card> とすればいいだけなので簡単です。手札は、前のページの方法で、整列してプレイヤーに提示するといいでしょう。

残された大きめの課題は役の判定です。ポーカーのルールは色々ありますが、ここでは以下の役があることを想定します。下にいくほど、強い役です。

ノーペア (同じ番号が 1つもない)
ワンペア (同じ番号の組が 1つ)
ツーペア (同じ番号の組が 2つ)
スリーカード (同じ番号が 3枚)
ストレート (5枚が連続した数字。K と A は連続しているものとする)
フラッシュ (5枚とも同じマーク)
フルハウス (同じ番号が 3枚＋同じ番号が 2枚)
フォーカード (同じ番号が 4枚)
ストレートフラッシュ (5枚とも同じマークで連続した数字。K と A は連続しているものとする)
ロイヤルストレートフラッシュ (同じマークで 10・J・Q・K・A)

これらの役を scoped enum で表現するとして、手札の情報から、当てはまる役を判定する関数を作ります。

// 役を判定する
// cards: 手札（要素数は 5 で、整列済みでなければならない）
// 戻り値: 役
PokerHand judge_poker_hand(const std::vector<Card>& cards);

judge_poker_hand関数はそれなりに規模が大きくなります。また、１度作ってしまえば、ポーカーのルールを変えないかぎりはずっと使いまわせるソースコードになるはずです。そこで、役判定に関するソースコードを、別のソースファイルに分離することにします。つまり、main関数があるソースファイルのほかに、もう１つソースファイルがある構造になります。

どこかのソースファイルに main関数がなければいけません。また、main関数があちこちにあってもいけません。

このようなプログラムを Visual Studio で作成するには、プロジェクトに複数のソースファイルを登録すればいいだけです。ビルドや実行の方法はこれまでどおりです。プロジェクトにソースファイルを追加する方法は、「Visual Studio編＞ソースファイルを追加する」を参照してください。

役判定のコードを集めたソースファイル (poker_hand.cpp とします) の内容は次のようになります。

#include <algorithm>
#include <string>
#include <vector>

// カードの数字の型
using CardNumber = signed char;

// カードのマークの型
enum class CardMark : signed char {
    spade,
    club,
    diamond,
    heart,
};

// カード型
struct Card {
    CardNumber number;  // 数字
    CardMark mark;      // マーク
};

// 役
enum class PokerHand {
    no_pair,
    one_pair,
    two_pairs,
    three_cards,
    straight,
    flush,
    full_house,
    four_cards,
    straight_flush,
    royal_straight_flush,
};

constexpr auto card_mark_num = 4;                                    // マークの総数
constexpr auto each_mark_card_num = 13;                              // 各マークのカードの枚数
constexpr auto trump_card_num = each_mark_card_num * card_mark_num;  // トランプに含まれるカードの枚数
constexpr auto hand_card_num = 5;                                    // 手札の枚数

// ストレートが成立しているか判定する
bool is_straight(const std::vector<Card>& cards)
{
    // 13 から 1 に戻ってくるケースを先に判定
    if (cards[0].number == 1 && cards[4].number == 13) {
        return cards[1].number ==  2 && cards[2].number ==  3 && cards[3].number ==  4
            || cards[1].number ==  2 && cards[2].number ==  3 && cards[3].number == 12
            || cards[1].number ==  2 && cards[2].number == 11 && cards[3].number == 12
            || cards[1].number == 10 && cards[2].number == 11 && cards[3].number == 12
            ;
    }

    return cards[0].number + 1 == cards[1].number
        && cards[1].number + 1 == cards[2].number
        && cards[2].number + 1 == cards[3].number
        && cards[3].number + 1 == cards[4].number
        ;
}

// 役を判定する
PokerHand judge_poker_hand(const std::vector<Card>& cards)
{
    if (cards.size() != hand_card_num) {
        return PokerHand::no_pair;
    }

    // フラッシュ系
    if (cards[0].mark == cards[1].mark
     && cards[0].mark == cards[2].mark
     && cards[0].mark == cards[3].mark
     && cards[0].mark == cards[4].mark
    ) {
        // ロイヤルストレートフラッシュ
        if (cards[0].number == 1
         && cards[1].number == 10
         && cards[2].number == 11
         && cards[3].number == 12
         && cards[4].number == 13
        ) {
            return PokerHand::royal_straight_flush;
        }

        // ストレートフラッシュ
        if (is_straight(cards)) {
            return PokerHand::straight_flush;
        }
        
        // フラッシュ
        return PokerHand::flush;
    }

    // ストレート
    if (is_straight(cards)) {
        return PokerHand::straight;
    }

    // 数字ごとのカードの枚数を数える
    std::vector<int> number_count(each_mark_card_num + 1);
    for (auto& card : cards) {
        number_count.at(card.number) += 1;
    }

    // 一番枚数が多い数字
    int number_count_max {*std::max_element(std::cbegin(number_count), std::cend(number_count))};

    // フォーカード
    if (number_count_max == 4) {
        return PokerHand::four_cards;
    }

    // フルハウス or スリーカード
    if (number_count_max == 3) {

        // ２枚ある番号が存在すればフルハウス
        if (std::find(std::cbegin(number_count), std::cend(number_count), 2) != std::cend(number_count)) {
            return PokerHand::full_house;
        }

        // スリーカード
        return PokerHand::three_cards;
    }

    // ツーペア or ワンペア
    if (number_count_max == 2) {

        // ２枚ある番号が２つあればツーペア
        if (std::count(std::cbegin(number_count), std::cend(number_count), 2) == 2) {
            return PokerHand::two_pairs;
        }

        // ワンペア
        return PokerHand::one_pair;
    }

    // ノーペア
    return PokerHand::no_pair;
}

// 役の文字列表現を返す
std::string get_poker_hand_string(PokerHand poker_hand)
{
    switch (poker_hand) {
    case PokerHand::no_pair:                return "ノーペア";
    case PokerHand::one_pair:               return "ワンペア";
    case PokerHand::two_pairs:              return "ツーペア";
    case PokerHand::three_cards:            return "スリーカード";
    case PokerHand::straight:               return "ストレート";
    case PokerHand::flush:                  return "フラッシュ";
    case PokerHand::full_house:             return "フルハウス";
    case PokerHand::four_cards:             return "フォーカード";
    case PokerHand::straight_flush:         return "ストレートフラッシュ";
    case PokerHand::royal_straight_flush:   return "ロイヤルストレートフラッシュ";
    default:                                return "";
    }
}

main関数を含んだソースファイル（main.cpp とします）が必要です。シャッフルされた山札から 5枚のカードを配り、整列し、役判定を行うようにしてみます。

#include <algorithm>
#include <iostream>
#include <random>
#include <string>
#include <vector>

// カードの数字の型
using CardNumber = signed char;

// カードのマークの型
enum class CardMark : signed char {
    spade,
    club,
    diamond,
    heart,
};

// 役
enum class PokerHand {
    no_pair,
    one_pair,
    two_pairs,
    three_cards,
    straight,
    flush,
    full_house,
    four_cards,
    straight_flush,
    royal_straight_flush,
};

// カード型
struct Card {
    CardNumber number;  // 数字
    CardMark mark;      // マーク
};

constexpr auto each_mark_card_num = 13;                  // 各マークのカードの枚数
constexpr auto trump_card_num = each_mark_card_num * 4;  // トランプに含まれるカードの枚数
constexpr auto hand_card_num = 5;                        // 手札の枚数

// poker_hand.cpp にある関数の宣言
PokerHand judge_poker_hand(const std::vector<Card>& cards);
std::string get_poker_hand_string(PokerHand poker_hand);

// トランプを初期化する
void init_trump(std::vector<Card>& cards)
{
    for (auto i = 0; i < each_mark_card_num; ++i) {
        auto number = static_cast<CardNumber>(i + 1);
        cards.at(i + each_mark_card_num * 0).number = number;
        cards.at(i + each_mark_card_num * 0).mark = CardMark::spade;
        cards.at(i + each_mark_card_num * 1).number = number;
        cards.at(i + each_mark_card_num * 1).mark = CardMark::club;
        cards.at(i + each_mark_card_num * 2).number = number;
        cards.at(i + each_mark_card_num * 2).mark = CardMark::diamond;
        cards.at(i + each_mark_card_num * 3).number = number;
        cards.at(i + each_mark_card_num * 3).mark = CardMark::heart;
    }
}

// 手札を配る
void hand_out_cards(std::vector<Card>& deck, std::vector<Card>& hand_cards)
{
    while (hand_cards.size() < hand_card_num) {
        hand_cards.push_back(deck.back());
        deck.pop_back();
    }

    // 整列
    std::sort(std::begin(hand_cards), std::end(hand_cards),
        [](const Card& a, const Card& b){
            if (a.number == b.number) {
                return a.mark < b.mark;
            }
            return a.number < b.number;
        }
    );
}

// カードのマークの文字列表現を返す
std::string get_mark_string(CardMark card_mark)
{
    switch (card_mark) {
    case CardMark::spade:
        return "spade";
    case CardMark::club:
        return "club";
    case CardMark::diamond:
        return "diamond";
    case CardMark::heart:
        return "heart";
    default:
        return "";
    }
}

int main()
{
    std::vector<Card> deck(trump_card_num);
    init_trump(deck);

    // 山札のカードをシャッフルする
    std::random_device rand_dev {};
    std::mt19937 rand_engine(rand_dev());
    std::shuffle(std::begin(deck), std::end(deck), rand_engine);
    
    // 手札を配る
    std::vector<Card> player_cards {};
    hand_out_cards(deck, player_cards);

    // 手札の内容を表示
    for (auto& card : player_cards) {
        std::cout << get_mark_string(card.mark) << " : " << static_cast<int>(card.number) << "\n";
    }

    // 役判定
    auto judge = judge_poker_hand(player_cards);
    std::cout << get_poker_hand_string(judge) << "\n";
}

実行結果：

diamond : 4
spade : 10
heart : 10
club : 12
diamond : 12
ツーペア

実行するたびに手札の内容が変わり、役判定の結果が出力されます。

main.cpp から、poker_hand.cpp にある関数を呼びだすために、関数の宣言が見えていなければなりません。そのため、main.cpp の側に宣言を書いています。ほかのソースファイルにある関数であることを分かりやすくするために、宣言の先頭に externキーワードを付加する方法もあります。

extern PokerHand judge_poker_hand(const std::vector<Card>& cards);
extern std::string get_poker_hand_string(PokerHand poker_hand);

extern を付加しても意味は変わりませんが、これが宣言であることが明確になり、定義はほかのところにあるといっていることにもなります。

こうして、ほかのソースファイルにある関数を呼び出せますが、この方法はあまり良いものではありません。より適切な方法を、次のページで取り上げることにします。また、同じ型の定義を２つのソースファイルに重複して記述していることも気になりますが、これについても次のページで解決を図ります。

ビルドの過程 🔗

Visual Studio では、ビルドのコマンドだけで、実行ファイルの生成まで完了します。実際にはいくつか踏まなければならない過程があって、ビルドはそれを順番に行うコマンドです。この過程の中から、コンパイルとリンクを説明しておきます。

コンパイル 🔗

C++ で書かれたソースファイルをコンパイルすることによって、オブジェクトファイル (object file) が生成されます。

Visual Studio であれば、ソースファイルの名前に対応した .obj という拡張子のファイルが生成されています（main.cpp に対して main.obj といったように）。

ソースファイルが複数あるとしても、全部一括でコンパイルしているのではなく、ソースファイルを１つずつコンパイルします。そのため、あるソースファイルをコンパイルしているとき、ほかのソースファイルの存在はみえていません。このような手法は、分割コンパイル (separate compilation) と呼びます。

main.cpp をコンパイルしているとき、sub.cpp のことは見えていないので、main.cpp から sub.cpp にある関数を呼び出すコードを書いたものの、実は sub.cpp にその関数の定義が記述されていなかったとしても、コンパイルエラーとしては検知できません。

// main.cpp

extern int f1(int x);  // sub.cpp にあるはずの関数の宣言

int main()
{
    f1(10);  // f1() の宣言がみえているのでコンパイルできる
}

// sub.cpp

// f1 ではなく f2 の定義。f1 の定義はどこにもない
int f2(int x)
{
    return x;
}

main.cpp だけをみるとコンパイル可能なコードですし、sub.cpp だけをみてもやはりコンパイル可能なコードです。実際、どちらのソースファイルもコンパイルは成功しますが、この次のリンクの過程で f1 の定義がないことが発覚してエラーになります。

Visual Studio でコンパイルだけを行う方法は、VisualStudio編「コンパイルを行う」のページを参照してください。

なお、ビルド時間を削減するために、最後にコンパイルされたあと、変更のないソースファイルについてはコンパイルされないのが普通です。そのため、プログラムを複数のソースファイルに分割することは、ビルド時間を減らし、開発効率を高めるという利点もあります。

リンク 🔗

コンパイルによって生成されたオブジェクトファイルは、１つのプログラムの一部分のコードに過ぎず、単体では実行できません。これらを１つにまとめて、実行できる形式のファイル（実行ファイル）を生成する必要があります。この過程をリンク (link) と呼び、リンカ (linker) というソフトウェアによって行われます。

Visual Studio にはリンカも統合されています。

各オブジェクトファイルのコードに不備があれば、リンクエラー (link error) として報告されます。たとえば先ほどの例のように、関数を呼び出そうしているが、その定義がどのオブジェクトファイルにも含まれていないことが分かると、リンクエラーになります。

結合（リンケージ） 🔗

複数のソースファイルがあると、それぞれに同じ名前の定義が現れる可能性があります。

定義した名前がほかのソースファイルから使用できることを「外部結合（外部リンケージ） (external linkage) をもつ」と表現し、使用できないことを「内部結合（内部リンケージ） (internal linkage) をもつ」と表現します。また、関数内で定義された変数のように、ほかのソースファイルとの関わりがないものは、「無結合 (no linkage) である（リンケージをもたない）」といいます。

各種の定義がどの結合になるのかをまとめておきます。正確なルールはかなり複雑なので、ここでは現時点の知識の範囲のことに限っています。

内部結合^[2]
- 関数の外側で定義された constexpr変数
外部結合^[3]
- （※いずれも、{} で囲まれた場所で定義されている場合を除く）
  - 関数
  - クラス（構造体）と、そのメンバ関数^[4]
  - 列挙型と、その列挙子
無結合^[5]
- 関数内で定義された変数
- クラス（構造体）のデータメンバ

【上級】関数は、static を付加していたり、無名名前空間（「スコープと名前空間」のページを参照）で宣言していたりする場合は内部結合になります。

【上級】データメンバは、static が付加されている場合は、所属するクラスの結合に合わせられます^[4]。

内部結合であれば、名前が同じだがコードに違いがある（初期値や型が違うなど）定義を、複数のソースファイルに記述できます。それぞれの定義は、まったく別のものであると認識されます。

外部結合であれば、ほかのソースファイルからでもその名前を使えますが、コードに違いがある定義を記述してはいけません。ポーカープログラムでは、構造体や列挙型の定義を２箇所に書いていますが、そのコードは完全に同じにしています。しかし、そもそも定義は１つに限るべきですし、必ず１つでなければならない場合もあります。定義を１つにする方法は、次のページで解説します。

外部結合では、ほかのソースファイルからでも名前が使えるといっても、それは名前だけの話であって、同じソースファイル内に定義したときのような無制限な利用ができることを意味しません。たとえば、ほかのソースファイルで定義している外部結合の関数を呼ぶには、宣言が必要です（ポーカープログラムの例では、関数の宣言を呼び出し側のソースファイルに記述しました）。同じ理屈で、ほかのソースファイルで定義されている構造体や列挙型の名前は使えますが、メンバや列挙子にアクセスするには定義が見えていなければなりません。

【上級】名前は使えるので、ほかのソースファイルで定義された外部結合の構造体や列挙型の宣言を記述することができます。

まとめ 🔗

コンパイルは１つのソースファイルだけが対象であり、１つのオブジェクトファイルを生成する
複数のソースファイルでプログラムを構築し、それぞれのソースファイルを別個にコンパイルする方式を、分割コンパイルと呼ぶ
複数のオブジェクトファイルから、１つの実行ファイルを生成する過程をリンクと呼び、リンカがこれを行う
定義された名前がほかのソースファイルから使用できることを、「外部結合をもつ」という
- 関数の外側で定義した constexpr変数などが該当する
定義された名前がほかのソースファイルから使用できないことを、「内部結合をもつ」という
- 関数、クラス（構造体）とメンバ関数、列挙型とその列挙子などが該当する
ほかのソースファイルと関わりがない名前は、「無結合である」という
- 関数内で定義された変数や、クラス（構造体）のデータメンバなどが該当する

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。

参考リンク 🔗

1. C++ standard working draft N4140 §2.1 Separate translation - 1 | 14882: Contents
2. C++ standard working draft N4140 §3.5 Program and linkage - 3 | 14882: Contents
3. C++ standard working draft N4140 §3.5 Program and linkage - 4 | 14882: Contents
4. C++ standard working draft N4140 §3.5 Program and linkage - 5 | 14882: Contents
5. C++ standard working draft N4140 §3.5 Program and linkage - 8 | 14882: Contents
Programming Place Plus　新C++編　参考書籍
- 当サイトの参考書籍一覧ページ。C++ に関する書籍を多数紹介
Programming Place Plus　新C++編　リンク集
- 当サイトの参考Webサイト集。C++ の全般的な学習に有益なサイトを紹介

練習問題 🔗

問題の難易度について。

(確認★) このページの内容の理解を確認する問題
(基本★～★★) このページの内容を使って解く問題
(応用★★～★★★) このページまでに学んだことを活用して、現実的な問題を解決する問題
(調査★★～★★★) 自力で情報を探したり、模索したりする問題
(発展★★★) プログラムの改善など、より上を目指すような問題

★は、すべての方が取り組める入門レベルの問題です。
★★は、自力でプログラミングができるようなるために、入門者の方であっても取り組んでほしい問題です。
★★★は、本格的にプログラマーを目指す人のための問題です。

問題１　（確認★）

複数のソースファイルに main関数の定義があるとどうなるか確認してみてください。

⇒解答・解説

問題２　（確認★）

ポーカープログラムでは、２つのソースファイルのそれぞれに、以下の定義があります。

constexpr auto each_mark_card_num = 13;

もし、どちらか一方の定義だけ、型を long int型に変更したとすると、何が起こりますか？

⇒解答・解説

問題３　（応用★★）

ポーカープログラムの init_trump関数や、get_mark_string関数は、ポーカー以外のトランプゲームでも流用できそうです。main.cpp から分離してみてください。

⇒解答・解説

問題４　（応用★★）

ポーカープログラムの judge_poker_hand関数に、手札が整列されているかどうかのチェックを加えてください。

⇒解答・解説

⇒解答・解説ページの先頭

はてなブックマークに保存	Pocket に保存	Facebook でシェア
X でポスト／フォロー	LINE で送る	noteで書く
RSS	管理者情報	プライバシーポリシー

分割コンパイル | Programming Place Plus　新C++編

このページの概要 🔗

複数のソースファイル 🔗

ビルドの過程 🔗

コンパイル 🔗

リンク 🔗

結合（リンケージ） 🔗

まとめ 🔗

参考リンク 🔗

練習問題 🔗

問題１　（確認★）

問題２　（確認★）

問題３　（応用★★）

問題４　（応用★★）

更新履歴 🔗

このページの概要 🔗

複数のソースファイル 🔗

ビルドの過程 🔗

コンパイル 🔗

リンク 🔗

結合（リンケージ） 🔗

まとめ 🔗

参考リンク 🔗

練習問題 🔗

問題１ （確認★）

問題２ （確認★）

問題３ （応用★★）

問題４ （応用★★）

更新履歴 🔗

問題１　（確認★）

問題２　（確認★）

問題３　（応用★★）

問題４　（応用★★）