UTF-8 | Programming Place Plus　新C++編

#include <iostream>
#include <limits>
#ifdef _WIN32
#include <Windows.h>
#endif

int main()
{
    std::cout << std::numeric_limits<int>::min() << "\n";
    std::cout << std::numeric_limits<int>::max() << "\n";
}

#include <iostream>
#include <limits>
#ifdef _WIN32
#define NOMINMAX
#include <Windows.h>
#endif

int main()
{
    std::cout << std::numeric_limits<int>::min() << "\n";
    std::cout << std::numeric_limits<int>::max() << "\n";
}

#include <algorithm>
#include <iostream>

int main()
{
    int a {5};
    int b {3};

    std::cout << std::min(a, b) << "\n"
              << std::max(a, b) << "\n";
}

inline std::ostream& operator<<(std::ostream& os, const char8_t* s) {
    return os << reinterpret_cast<const char*>(s);
}
inline std::ostream& operator<<(std::ostream& os, const std::u8string& s) {
    return os << s.c_str();
}

// １文字版
inline std::ostream& operator<<(std::ostream& os, utf8_char s) {
    return os << static_cast<char>(s);
}

// strean.h
#ifndef STREAM_H_INCLUDED
#define STREAM_H_INCLUDED

#include <iostream>
#include <string>

#ifdef __cpp_char8_t

// UTF-8 を扱うための型
using utf8_char = char8_t;
using utf8_string = std::u8string;

// UTF-8 の文字、文字列を出力する
inline std::ostream& operator<<(std::ostream& os, utf8_char s) {
    return os << static_cast<char>(s);
}
inline std::ostream& operator<<(std::ostream& os, const utf8_char* s) {
    return os << reinterpret_cast<const char*>(s);
}
inline std::ostream& operator<<(std::ostream& os, const utf8_string& s) {
    return os << s.c_str();
}
#else

// UTF-8 を扱うための型
using utf8_char = char;
using utf8_string = std::string;

#endif

#endif

// main.cpp
#include <iostream>
#include <sstream>
#ifdef _WIN32
#define NOMINMAX
#include <Windows.h>
#endif
#include "card.h"
#include "poker_hand.h"
#include "stream.h"

constexpr CardNumber nothing_card_number = -1;  // カードがないことを表すダミー値

// 手札を配る
static void hand_out_cards(cards_type& deck, cards_type& hand_cards);

// カードを補充する
static void reload_cards(cards_type& deck, cards_type& hand_cards);

// カードの情報を出力する
static void print_cards(const cards_type& cards);

// 捨てるカードを選ぶときの出力
static void print_choose_discard(const cards_type& cards, const std::vector<bool>& is_discard);

// カードの文字列表現を返す
static utf8_string get_card_string(const Card& card);


int main()
{
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);  // コマンドプロンプトでの表示に UTF-8 を使う
#endif

    while (true) {

        // 山札を準備
        cards_type deck(trump_card_num);
        init_trump(deck);
        shuffle_cards(deck);

        // 最初の手札を配る
        cards_type player_cards {};
        hand_out_cards(deck, player_cards);

        // ユーザーにカードを提示
        std::cout << u8"あなたに配られたカードです。\n";
        print_cards(player_cards);

        // 捨てるカードを選ばせる
        std::vector<bool> is_discard(hand_card_num);
        while (true) {
            print_choose_discard(player_cards, is_discard);

            std::string input_string {};
            std::getline(std::cin, input_string);
            if (!std::cin) {
                std::cout << u8"入力が正しくありません。\n";
            }
            else if (input_string.empty()) {
                break;
            }
            else {
                int index {input_string[0] - '0'};  // 数字から整数に変換
                if (0 <= index && index < hand_card_num) {
                    is_discard[index] = !is_discard[index];
                }
                else {
                    std::cout << u8"入力が正しくありません。\n";
                }
            }
        }

        // 選ばれたカードを捨てる
        for (std::vector<bool>::size_type i = 0; i < is_discard.size(); ++i) {
            if (is_discard.at(i)) {
                auto& card = player_cards.at(i);
                std::cout << get_card_string(card) << u8" を捨てました。\n";

                // 何もないことをあらわすダミー値を入れる
                card.number = nothing_card_number;
            }
        }
        std::cout << u8"\n";

        // 新しいカードを補充する
        reload_cards(deck, player_cards);
        sort_cards(player_cards);
        std::cout << u8"\n";
        print_cards(player_cards);

        // 役判定
        auto poker_hand = judge_poker_hand(player_cards);
        if (poker_hand == PokerHand::no_pair) {
            std::cout << u8"残念でした。\n";
        }
        else {
            std::cout << get_poker_hand_string(poker_hand) << u8"ができました。\n";
        }

        // ゲームの続行確認
        std::cout << u8"\n"
                  << u8"ゲームを続けますか？\n"
                  << u8"はい: Y  いいえ: N\n";
        std::string input_string {};
        std::getline(std::cin, input_string);
        if (input_string == "Y" || input_string == "y") {
            continue;
        }
        else {
            break;
        }
    }
}


// 手札を配る
static void hand_out_cards(cards_type& deck, cards_type& hand_cards)
{
    while (hand_cards.size() < hand_card_num) {
        hand_cards.push_back(deck.back());
        deck.pop_back();
    }
    sort_cards(hand_cards);
}

// カードを補充する
static void reload_cards(cards_type& deck, cards_type& hand_cards)
{
    // 何もないことをあらわすダミー値が入っているところに、新しいカードを補充する
    for (cards_type::size_type i = 0; i < hand_cards.size(); ++i) {
        if (hand_cards.at(i).number == nothing_card_number) {
            auto& card = deck.back();

            std::cout << get_card_string(card) << u8" が配られました。\n";
            hand_cards.at(i) = card;
            deck.pop_back();
        }
    }
}

// カードの情報を出力する
static void print_cards(const cards_type& cards)
{
    for (cards_type::size_type i = 0; i < cards.size(); ++i) {
        auto& card {cards.at(i)};

        if (card.number == nothing_card_number) {
            std::cout << i << u8": \n";
        }
        else {
            std::cout << i << u8": " << get_card_string(card) << u8"\n";
        }
    }
}

// 捨てるカードを選ぶときの出力
static void print_choose_discard(const cards_type& cards, const std::vector<bool>& is_discard)
{
    std::cout << u8"\n"
              << u8"左端の番号を入力して、カードを選んでください。\n"
              << u8"何も入力せず Enterキーを押すと決定します。\n";

    for (cards_type::size_type i = 0; i < cards.size(); ++i) {
        std::cout << i << u8": " << get_card_string(cards.at(i));

        // 捨てるカードに含まれているか
        if (is_discard[i]) {
            std::cout << u8" <-- 捨てる";
        }

        std::cout << u8"\n";
    }
}

// カードの文字列表現を返す
static utf8_string get_card_string(const Card& card)
{
#if CARD_MARK_STRING == CARD_MARK_STRING_KANA
    return get_mark_string(card.mark) + u8"の" + get_card_number_string(card.number);
#else
    return get_mark_string(card.mark) + u8" " + get_card_number_string(card.number);
#endif
}

// poker_hand.cpp
#include "poker_hand.h"
#include <algorithm>
#include <cassert>

// ストレートが成立しているか判定する
static bool is_straight(const cards_type& cards)
{
    // [!] 1 を巻き込むストレートは、1・10・11・12・13 か 1・2・3・4・5 のいずれかしか認めないルールもあるが、
    //     ここでは、とにかく連続していればいいことにしている。

    // 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 cards_type& cards)
{
    assert(cards.size() == hand_card_num);
    assert(std::is_sorted(std::cbegin(cards), std::cend(cards), cards_sort_compare));

    // フラッシュ系
    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;
}

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

// poker_hand.h
#ifndef POKER_HAND_H_INCLUDED
#define POKER_HAND_H_INCLUDED

#include <string>
#include "card.h"
#include "stream.h"

constexpr auto hand_card_num = 5;               // 手札の枚数

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

// 役を判定する
// cards: 手札 (要素数は 5。card.h の cards_sort_compare() が定義する順序で整列されていなければならない）
// 戻り値: 役
PokerHand judge_poker_hand(const cards_type& cards);

// 役の文字列表現を返す
// poker_hand: 役
// 戻り値: 役の名前
utf8_string get_poker_hand_string(PokerHand poker_hand);

#endif

// card.cpp
#include "card.h"
#include <algorithm>
#include <random>

// トランプを初期化する
void init_trump(cards_type& 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 shuffle_cards(cards_type& cards)
{
    std::random_device rand_dev {};
    std::mt19937 rand_engine(rand_dev());
    std::shuffle(std::begin(cards), std::end(cards), rand_engine);
}

// カードを整列する
void sort_cards(cards_type& cards)
{
    std::sort(std::begin(cards), std::end(cards), cards_sort_compare);
}

// カードの整列に使う比較関数
bool cards_sort_compare(const Card& a, const Card& b)
{
    if (a.number == b.number) {
        return a.mark < b.mark;
    }
    return a.number < b.number;
}

// カードの数字の文字列表現を返す
utf8_string get_card_number_string(CardNumber number)
{
    switch (number) {
    case 1:     return u8"A";
    case 2:     return u8"2";
    case 3:     return u8"3";
    case 4:     return u8"4";
    case 5:     return u8"5";
    case 6:     return u8"6";
    case 7:     return u8"7";
    case 8:     return u8"8";
    case 9:     return u8"9";
    case 10:    return u8"10";
    case 11:    return u8"J";
    case 12:    return u8"Q";
    case 13:    return u8"K";
    default:    return u8"";
    }
}

// カードのマークの文字列表現を返す
utf8_string get_mark_string(CardMark card_mark)
{
#if CARD_MARK_STRING == CARD_MARK_STRING_EMOJI
    switch (card_mark) {
    case CardMark::spade:
        return u8"♠";
    case CardMark::club:
        return u8"♣";
    case CardMark::diamond:
        return u8"♦";
    case CardMark::heart:
        return u8"♥";
    default:
        return u8"";
    }
#elif CARD_MARK_STRING == CARD_MARK_STRING_KANA
    switch (card_mark) {
    case CardMark::spade:
        return u8"スペード";
    case CardMark::club:
        return u8"クラブ";
    case CardMark::diamond:
        return u8"ダイヤ";
    case CardMark::heart:
        return u8"ハート";
    default:
        return u8"";
    }
#elif CARD_MARK_STRING == CARD_MARK_STRING_ALPHABET
    switch (card_mark) {
    case CardMark::spade:
        return u8"spade";
    case CardMark::club:
        return u8"club";
    case CardMark::diamond:
        return u8"diamond";
    case CardMark::heart:
        return u8"heart";
    default:
        return u8"";
    }
#else
    #error "invalid CARD_MARK_STRING."
#endif
}

// card.h
#ifndef CARD_H_INCLUDED
#define CARD_H_INCLUDED

#include <string>
#include <vector>
#include "stream.h"

#define CARD_MARK_STRING_EMOJI      0   // 絵文字
#define CARD_MARK_STRING_KANA       1   // カタカナ
#define CARD_MARK_STRING_ALPHABET   2   // アルファベット
#define CARD_MARK_STRING            CARD_MARK_STRING_EMOJI  // カードマークの文字列表現の方法

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

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

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

// カードの集まりを表す型
using cards_type = std::vector<Card>;

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;  // トランプに含まれるカードの枚数


// トランプを初期化する
// cards: カードの集まり
void init_trump(cards_type& cards);

// カードをシャッフルする
// cards: カードの集まり
void shuffle_cards(cards_type& cards);

// カードを整列する
// cards: カードの集まり
void sort_cards(cards_type& cards);

// カードの整列に使う比較関数
// a: 対象のカード
// b: 対象のカード
// 戻り値: a と b が適切な順番で並んでいたら true、並んでいなければ false
bool cards_sort_compare(const Card& a, const Card& b);

// カードの数字の文字列表現を返す
// たとえば、3 は "3"、1 は "A"、13 は "K" と表現される。
//
// number: カードの数字
// 戻り値: カードの数字を文字列で表現したもの
utf8_string get_card_number_string(CardNumber number);

// カードのマークの文字列表現を返す
// 具体的な表現方法は、CARD_MARK_STRING マクロの定義によって異なる。
// 
// card_mark: カードのマーク
// 戻り値: カードのマークを文字列で表現したもの
utf8_string get_mark_string(CardMark card_mark);

#endif