とりあえず構造体に慣れてもらうことから始めましょう。
まずは次の構造体を作ってみてください。
タグ名 Card メンバ変数 int型でnumberとsuit 実体名 card
宣言を書いて、main関数で実体を作りましょう。
解答例です。
<sample program 101-01>
#include <stdio.h>
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card card;
return 0;
}
|
ここから、値を代入して単純に中身を表示するプログラムにしてみます。
numberを１に、suitを２に設定し表示します。
<sample program 101-02>
#include <stdio.h>
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card card;
card.number = 1;
card.suit = 2;
printf("number = %d\n", card.number);
printf("suit = %d\n", card.suit);
return 0;
}
|
<実行結果>
number = 1 suit = 2 続行するには何かキーを押してください・・・
変数や配列の場合、実体の作成時に初期値が代入できました。
＜変数＞
＜一次元配列＞
int a[2] = { 1, 2 };
＜二次元配列＞
int a[3][2] = { { 1, 2 }, { 3, 4 }, { 5, 6 }, };
構造体も同じように初期値を代入できます。
<sample program 101-03>
#include <stdio.h>
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card card = { 1, 2 };
printf("number = %d\n", card.number);
printf("suit = %d\n", card.suit);
return 0;
}
|
<実行結果>
number = 1 suit = 2 続行するには何かキーを押してください・・・
宣言時に書いたメンバ変数の順番に数値を入れておけば良いです。
さて、この構造体はカード１枚分のデータを入れることが出来ます。
このカードが５２枚あればトランプのデッキが作れそうです。
そこで、Card構造体を配列にしてみます。
初期値や表示も変更しなければならないので、まずは実体を作るところまで書きましょう。
トランプの枚数５２は#defineで定義したいところですが、コラム「#defineの罠」で書いたように定義してみましょう。
#include <stdio.h>
#define NUMBER 13
#define SUIT 4
#define CARD (NUMBER * SUIT)
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card deck[CARD];
return 0;
}
|
一種類のスートにつき１から１３までの数がありますから５２枚としています。
deckは配列ですから、メンバ変数にアクセスするには、
deck[0].number
や
deck[5].suit
などと指定します。
さて、初期値を代入してカードのデッキを作ってみましょう。
numberには１から１３をsuitには０から３を入れることにします。
＜suit＞ ０ スペード １ ハート ２ ダイヤ ３ クラブ
上でやったような初期値の代入は厳しそうですね。
一応、実体の作成と同時に初期値を入れる方法を書いておきますが、あまり良くない方法だと思います。
<sample program 101-05>
#include <stdio.h>
#define NUMBER 13
#define SUIT 4
#define CARD (NUMBER * SUIT)
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card deck[CARD] = {
{ 1, 0 },
{ 2, 0 },
{ 3, 0 },
{ 4, 0 },
{ 5, 0 },
{ 6, 0 },
{ 7, 0 },
{ 8, 0 },
{ 9, 0 },
{ 10, 0 },
{ 11, 0 },
{ 12, 0 },
{ 13, 0 },
{ 1, 1 },
{ 2, 1 },
{ 3, 1 },
{ 4, 1 },
{ 5, 1 },
{ 6, 1 },
{ 7, 1 },
{ 8, 1 },
{ 9, 1 },
{ 10, 1 },
{ 11, 1 },
{ 12, 1 },
{ 13, 1 },
{ 1, 2 },
{ 2, 2 },
{ 3, 2 },
{ 4, 2 },
{ 5, 2 },
{ 6, 2 },
{ 7, 2 },
{ 8, 2 },
{ 9, 2 },
{ 10, 2 },
{ 11, 2 },
{ 12, 2 },
{ 13, 2 },
{ 1, 3 },
{ 2, 3 },
{ 3, 3 },
{ 4, 3 },
{ 5, 3 },
{ 6, 3 },
{ 7, 3 },
{ 8, 3 },
{ 9, 3 },
{ 10, 3 },
{ 11, 3 },
{ 12, 3 },
{ 13, 3 },
};
return 0;
}
|
二次元配列の初期化と似ています。
ただ、こんな風に書きたくは無いですよね。
よく見ると一定の法則で数字が並んでいますので、プログラムを使ってスマートに設定したいところです。
分かった方は自分で作ってみてください。
まずは簡単そうなスートの方を考えてみましょう。
５２枚のトランプを順番にみると、最初の１３枚は０、次の１３枚は１という具合に１３ごとに１増えています。
方法は色々ありますが、５２枚のカードの設定をするため、５２回繰り返すプログラムを追加してみます。
<sample program 101-06>
#include <stdio.h>
#define NUMBER 13
#define SUIT 4
#define CARD (NUMBER * SUIT)
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card deck[CARD];
int i;
for (i = 0; i < CARD; i++) {
}
return 0;
}
|
変数ｉが０から５１まで変化しますので、それを利用してスートを初期化します。
対応させなければならない数値は以下のようになります。
※法則を見て、式を考えるという癖を身につけてください。
ｉ suit ０ ０ １ ０ ２ ０ ３ ０ ４ ０ ５ ０ ６ ０ ７ ０ ８ ０ ９ ０ 10 ０ 11 ０ 12 ０ 13 １ 14 １ 15 １ 16 １ 17 １ 18 １ 19 １ 20 １ 21 １ 22 １ 23 １ 24 １ 25 １ 26 ２ 27 ２ 28 ２ 29 ２ 30 ２ 31 ２ 32 ２ 33 ２ 34 ２ 35 ２ 36 ２ 37 ２ 38 ２ 39 ３ 40 ３ 41 ３ 42 ３ 43 ３ 44 ３ 45 ３ 46 ３ 47 ３ 48 ３ 49 ３ 50 ３ 51 ３
ｉの値が、
０〜12までの場合 suitは０ 13〜25までの場合 suitは１ 26〜38までの場合 suitは２ 39〜51までの場合 suitは３
さて、どういった式を作ればｉの値からsuitが導き出せるでしょうか？
考えてください。
解答例です。
ｉ ／ １３ （小数点以下切り捨て）
ｉ ０ ／ 13 ＝ 0.000 １ ／ 13 ＝ 0.077 ２ ／ 13 ＝ 0.154 ３ ／ 13 ＝ 0.231 ４ ／ 13 ＝ 0.308 ５ ／ 13 ＝ 0.385 ６ ／ 13 ＝ 0.462 ７ ／ 13 ＝ 0.538 ８ ／ 13 ＝ 0.615 ９ ／ 13 ＝ 0.692 10 ／ 13 ＝ 0.769 11 ／ 13 ＝ 0.846 12 ／ 13 ＝ 0.923 13 ／ 13 ＝ 1.000 14 ／ 13 ＝ 1.077 15 ／ 13 ＝ 1.154 16 ／ 13 ＝ 1.231 17 ／ 13 ＝ 1.308 18 ／ 13 ＝ 1.385 19 ／ 13 ＝ 1.462 20 ／ 13 ＝ 1.538 21 ／ 13 ＝ 1.615 22 ／ 13 ＝ 1.692 23 ／ 13 ＝ 1.769 24 ／ 13 ＝ 1.846 25 ／ 13 ＝ 1.923 26 ／ 13 ＝ 2.000 27 ／ 13 ＝ 2.077 28 ／ 13 ＝ 2.154 29 ／ 13 ＝ 2.231 30 ／ 13 ＝ 2.308 31 ／ 13 ＝ 2.385 32 ／ 13 ＝ 2.462 33 ／ 13 ＝ 2.538 34 ／ 13 ＝ 2.615 35 ／ 13 ＝ 2.692 36 ／ 13 ＝ 2.769 37 ／ 13 ＝ 2.846 38 ／ 13 ＝ 2.923 39 ／ 13 ＝ 3.000 40 ／ 13 ＝ 3.077 41 ／ 13 ＝ 3.154 42 ／ 13 ＝ 3.231 43 ／ 13 ＝ 3.308 44 ／ 13 ＝ 3.385 45 ／ 13 ＝ 3.462 46 ／ 13 ＝ 3.538 47 ／ 13 ＝ 3.615 48 ／ 13 ＝ 3.692 49 ／ 13 ＝ 3.769 50 ／ 13 ＝ 3.846 51 ／ 13 ＝ 3.923
何度も説明していますが、int型の割り算は小数点以下切り捨てです。
整数部分だけを見ると、ちゃんとスートの数字になっています。
それでは、この式を使ってスートの初期値設定をしましょう。
１３は＃defineでNUMBERと定義されていますよね。
<sample program 101-07>
#include <stdio.h>
#define NUMBER 13
#define SUIT 4
#define CARD (NUMBER * SUIT)
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card deck[CARD];
int i;
for (i = 0; i < CARD; i++) {
deck[i].suit = i / NUMBER;
}
return 0;
}
|
最後にnumberの設定をします。
分かった方は早速作ってください。
numberも同じループの中で設定します。
変数ｉと必要な数字の組み合わせは以下の通りです。
ｉ number ０ １ １ ２ ２ ３ ３ ４ ４ ５ ５ ６ ６ ７ ７ ８ ８ ９ ９ 10 10 11 11 12 12 13 13 １ 14 ２ 15 ３ 16 ４ 17 ５ 18 ６ 19 ７ 20 ８ 21 ９ 22 10 23 11 24 12 25 13 26 １ 27 ２ 28 ３ 29 ４ 30 ５ 31 ６ 32 ７ 33 ８ 34 ９ 35 10 36 11 37 12 38 13 39 １ 40 ２ 41 ３ 42 ４ 43 ５ 44 ６ 45 ７ 46 ８ 47 ９ 48 10 49 11 50 12 51 13
ｉの値が、
０、13、26、39の場合 numberは１ １、14、27、40の場合 numberは２ ２、15、28、41の場合 numberは３ ・ ・ ・ 12、25、38、51の場合 numberは13
さて、どういった式を作ればｉの値からnumberが導き出せるでしょうか？
考えてください。
解答例です。
ｉ ％ １３ ＋ １
ｉ ０ ％ 13 ＝ ０ ＋ １ ＝ １ １ ％ 13 ＝ １ ＋ １ ＝ ２ ２ ％ 13 ＝ ２ ＋ １ ＝ ３ ３ ％ 13 ＝ ３ ＋ １ ＝ ４ ４ ％ 13 ＝ ４ ＋ １ ＝ ５ ５ ％ 13 ＝ ５ ＋ １ ＝ ６ ６ ％ 13 ＝ ６ ＋ １ ＝ ７ ７ ％ 13 ＝ ７ ＋ １ ＝ ８ ８ ％ 13 ＝ ８ ＋ １ ＝ ９ ９ ％ 13 ＝ ９ ＋ １ ＝ 10 10 ％ 13 ＝ 10 ＋ １ ＝ 11 11 ％ 13 ＝ 11 ＋ １ ＝ 12 12 ％ 13 ＝ 12 ＋ １ ＝ 13 13 ％ 13 ＝ ０ ＋ １ ＝ １ 14 ％ 13 ＝ １ ＋ １ ＝ ２ 15 ％ 13 ＝ ２ ＋ １ ＝ ３ 16 ％ 13 ＝ ３ ＋ １ ＝ ４ 17 ％ 13 ＝ ４ ＋ １ ＝ ５ 18 ％ 13 ＝ ５ ＋ １ ＝ ６ 19 ％ 13 ＝ ６ ＋ １ ＝ ７ 20 ％ 13 ＝ ７ ＋ １ ＝ ８ 21 ％ 13 ＝ ８ ＋ １ ＝ ９ 22 ％ 13 ＝ ９ ＋ １ ＝ 10 23 ％ 13 ＝ 10 ＋ １ ＝ 11 24 ％ 13 ＝ 11 ＋ １ ＝ 12 25 ％ 13 ＝ 12 ＋ １ ＝ 13 26 ％ 13 ＝ ０ ＋ １ ＝ １ 27 ％ 13 ＝ １ ＋ １ ＝ ２ 28 ％ 13 ＝ ２ ＋ １ ＝ ３ 29 ％ 13 ＝ ３ ＋ １ ＝ ４ 30 ％ 13 ＝ ４ ＋ １ ＝ ５ 31 ％ 13 ＝ ５ ＋ １ ＝ ６ 32 ％ 13 ＝ ６ ＋ １ ＝ ７ 33 ％ 13 ＝ ７ ＋ １ ＝ ８ 34 ％ 13 ＝ ８ ＋ １ ＝ ９ 35 ％ 13 ＝ ９ ＋ １ ＝ 10 36 ％ 13 ＝ 10 ＋ １ ＝ 11 37 ％ 13 ＝ 11 ＋ １ ＝ 12 38 ％ 13 ＝ 12 ＋ １ ＝ 13 39 ％ 13 ＝ ０ ＋ １ ＝ １ 40 ％ 13 ＝ １ ＋ １ ＝ ２ 41 ％ 13 ＝ ２ ＋ １ ＝ ３ 42 ％ 13 ＝ ３ ＋ １ ＝ ４ 43 ％ 13 ＝ ４ ＋ １ ＝ ５ 44 ％ 13 ＝ ５ ＋ １ ＝ ６ 45 ％ 13 ＝ ６ ＋ １ ＝ ７ 46 ％ 13 ＝ ７ ＋ １ ＝ ８ 47 ％ 13 ＝ ８ ＋ １ ＝ ９ 48 ％ 13 ＝ ９ ＋ １ ＝ 10 49 ％ 13 ＝ 10 ＋ １ ＝ 11 50 ％ 13 ＝ 11 ＋ １ ＝ 12 51 ％ 13 ＝ 12 ＋ １ ＝ 13
１３で割った余りは０〜１２ですから、それに１を加えることで１〜１３になります。
では、numberの設定をしましょう。
#include <stdio.h>
#define NUMBER 13
#define SUIT 4
#define CARD (NUMBER * SUIT)
struct Card
{
int number;
int suit;
};
int main(void)
{
struct Card deck[CARD];
int i;
for (i = 0; i < CARD; i++) {
deck[i].suit = i / NUMBER;
deck[i].number = i % NUMBER + 1;
}
return 0;
}
|
トランプの初期値を設定するプログラムを題材にしてみましたが、後々トランプのゲームも作ってみましょう。