ポケモンのタイプ相性を返すプログラムを作りたいが、関数が目的の条件に引っかからない

Question

実現したいこと

ポケモンのタイプ相性結果を返すプログラム

前提

プログラミング初学者です。
構造体や関数の勉強として、C++でポケモンのタイプ相性を判定するプログラムを作成しています。
攻撃技のタイプ、防御側のタイプ1,2の3つを構造体に設定し、
そこから参照して各関数に渡すことによって、相性を判断します。

発生している問題・エラーメッセージ

コンパイルエラーはなくプログラムは最後まで走るのですが、
type_compatibility()において、どのswitch条件にも引っかからずに終了してしまいます。
例えば
・攻撃技のタイプ：ノーマル
・防御側のタイプ1：いわ
・防御側のタイプ2：ゴースト
の場合、「こうかがないようだ…」のメッセージが出力されるのが理想ですが
どのswitch条件にも引っかからないため、こうかふつう(メッセージなし)となってしまいます。

該当のソースコード

#include <iostream>
#include <stdio.h>
#include <map>

using std::map;

//////////////////////////////
//////////使用データ//////////
//////////////////////////////

enum Type //タイプ一覧
{
	Null,		//なし ※単タイプ用
	Normal,		//ノーマル
	Fire,		//ほのお
	Water,		//みず
	Electric,	//でんき
	Grass,		//くさ
	Ice,		//こおり
	Psychic,	//エスパー
	Fighting,	//かくとう
	Poison,		//どく
	Ground,		//じめん
	Flying,		//ひこう
	Bug,		//むし
	Rock,		//いわ
	Ghost,		//ゴースト
	Dragon,		//ドラゴン
	Dark,		//あく
	Steel,		//はがね
	Fairy		//フェアリー
};

//攻撃技のタイプと防御側のタイプを保持する構造体
struct info
{
	int atk_type	= Normal;
	int def_type1	= Rock;
	int def_type2	= Ghost;
};

//相性メッセージ
const char* msg_super_effective	= "こうかはばつぐんだ！";
const char* msg_not_effective	= "こうかはいまひとつのようだ";
const char* msg_not_affect		= "こうかがないようだ…";

//タイプごとの「こうかはばつぐん」の配列
const int fire_super_effective[4]		= { Grass, Ice, Bug, Steel };
const int water_super_effective[3]		= { Fire, Ground, Rock };
const int electric_super_effective[2]	= { Water, Flying };
const int grass_super_effective[3]		= { Water, Ground, Rock };
const int ice_super_effective[4]		= { Grass, Ground, Flying, Dragon };
const int psychic_super_effective[2]	= { Fighting, Poison };
const int fighting_super_effective[4]	= { Normal, Ice, Rock, Steel };
const int poison_super_effective[2]		= { Grass, Fairy };
const int ground_super_effective[5]		= { Fire, Electric, Poison, Rock, Steel };
const int flying_super_effective[3]		= { Grass, Fighting, Bug };
const int bug_super_effective[3]		= { Grass, Psychic, Dark };
const int rock_super_effective[4]		= { Fire, Ice, Flying, Bug };
const int ghost_super_effective[2]		= { Psychic, Ghost };
const int dragon_super_effective[1]		= { Dragon };
const int dark_super_effective[2]		= { Psychic, Ghost };
const int steel_super_effective[3]		= { Ice, Rock, Fairy };
const int fairy_super_effective[3]		= { Fighting, Dragon, Dark };

//タイプごとの「こうかはいまひとつ」の配列
int normal_not_effective[2]			= { Rock, Steel };
const int fire_not_effective[4]		= { Fire, Water, Rock, Dragon };
const int water_not_effective[3]	= { Water, Grass, Dragon };
const int electric_not_effective[3] = { Electric, Grass, Dragon };
const int grass_not_effective[7]	= { Fire, Grass, Poison, Flying, Bug, Dragon, Steel };
const int ice_not_effective[4]		= { Fire, Water, Ice, Steel };
const int psychic_not_effective[2]	= { Psychic, Steel };
const int fighting_not_effective[5] = { Psychic, Poison, Flying, Bug, Fairy };
const int poison_not_effective[4]	= { Poison, Ground, Rock, Ghost };
const int ground_not_effective[2]	= { Grass, Bug };
const int flying_not_effective[3]	= { Electric, Rock, Steel };
const int bug_not_effective[7]		= { Fire, Fighting, Poison, Flying, Ghost, Steel, Fairy };
const int rock_not_effective[3]		= { Fighting, Ground, Steel };
const int ghost_not_effective[1]	= { Dark };
const int dragon_not_effective[1]	= { Steel };
const int dark_not_effective[3]		= { Fighting, Dark, Fairy };
const int steel_not_effective[4]	= { Fire, Water, Electric, Steel };
const int fairy_not_effective[3]	= { Fire, Poison, Steel };

//Typeとタイプ名を対応付ける辞書
std::map <int, const char*> type_dic = {
	{1, "ノーマル"},
	{2, "ほのお"},
	{3, "みず"},
	{4, "でんき"},
	{5, "くさ"},
	{6, "こおり"},
	{7, "エスパー"},
	{8, "かくとう"},
	{9, "どく"},
	{10, "じめん"},
	{11, "ひこう"},
	{12, "むし"},
	{13, "いわ"},
	{14, "ゴースト"},
	{15, "ドラゴン"},
	{16, "あく"},
	{17, "はがね"},
	{18, "フェアリー"}
};



//////////////////////////////
//////////   関数   //////////
//////////////////////////////

/// <summary>
/// タイプ相性を返す
/// </summary>
/// <param name="atk_type">攻撃技のタイプ</param>
/// <param name="def_type">防御側のタイプ</param>
/// <returns>
/// -2以下:こうかがないようだ・・・
/// -1:こうかはいまひとつのようだ
/// 0:こうかふつう
/// 1:こうかはばつぐんだ！
/// </returns>
int type_compatibility(int atk_type, int def_type)
{
	int result = 0;

	switch (atk_type)
	{
	Normal:
		if (def_type == Ghost){	result = -3; break; }
		for (int ary : normal_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Fire:
		for (int ary : fire_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : fire_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Water:
		for (int ary : water_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : water_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Electric:
		if (def_type == Ground) { result = -3; break; }
		for (int ary : electric_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : electric_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Grass:
		for (int ary : grass_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : grass_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Ice:
		for (int ary : ice_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : ice_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Psychic:
		if (def_type == Dark) { result = -3; break; }
		for (int ary : psychic_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : psychic_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Fighting:
		if (def_type == Ghost) { result = -3; break; }
		for (int ary : fighting_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : fighting_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Poison:
		if (def_type == Steel) { result = -3; break; }
		for (int ary : poison_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : poison_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Ground:
		if (def_type == Flying) { result = -3; break; }
		for (int ary : ground_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : ground_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Flying:
		for (int ary : flying_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : flying_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Bug:
		for (int ary : bug_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : bug_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Rock:
		for (int ary : rock_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : rock_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Ghost:
		if (def_type == Normal) { result = -3; break; }
		for (int ary : ghost_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : ghost_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Dragon:
		if (def_type == Fairy) { result = -3; break; }
		for (int ary : dragon_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : dragon_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Dark:
		for (int ary : dark_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : dark_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Steel:
		for (int ary : steel_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : steel_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;

	Fairy:
		for (int ary : fairy_super_effective)
		{
			if (ary == def_type) { result++; break; }
		}
		for (int ary : fairy_not_effective)
		{
			if (ary == def_type) { result--; break; }
		}
		break;
	}

	return result;

}

/// <summary>
/// タイプ相性判断結果を返す
/// </summary>
/// <param name="atk_type">攻撃技のタイプ</param>
/// <param name="def_type1">防御側のタイプ1</param>
/// <param name="def_type2">防御側のタイプ2</param>
/// <returns>
/// -2以下:こうかがないようだ・・・
/// -1:こうかはいまひとつのようだ
/// 0:こうかふつう
/// 1:こうかはばつぐんだ！
/// </returns>
int type_compatibility_main(int atk_type, int def_type1, int def_type2) {
	int result = 0;

	//防御側が2タイプか確認する
	if (def_type2 == 0)
	{
		//単タイプ用
		result += type_compatibility(atk_type, def_type1);
		return result;
	}
	else
	{
		//2タイプ用
		result += type_compatibility(atk_type, def_type1);
		result += type_compatibility(atk_type, def_type2);
		return result;
	}
}

/// <summary>
/// タイプ相性の結果を表示する
/// </summary>
/// <param name="result">type_compatibility()で判断した相性結果</param>
void dsp_compatibility_msg(int result) {
	struct info info;

	printf("攻撃技のタイプ：%s\n", type_dic[info.atk_type]);
	
	if (info.def_type2 != 0)
	{
		printf("防御側のタイプ1：%s\n", type_dic[info.def_type1]); 
		printf("防御側のタイプ2：%s\n", type_dic[info.def_type2]);
	}
	else
	{
		printf("防御側のタイプ：%s\n", type_dic[info.def_type1]);
	}
	
	if (result <= -2) { printf("%s", msg_not_affect); }
	else if (result == -1) { printf("%s", msg_not_effective); }
	else if (result == 1) { printf("%s", msg_super_effective); }
	else if (result == 2) { printf("%s(4倍弱点)", msg_super_effective); }
}



//////////////////////////////
//////////メイン処理 /////////
//////////////////////////////
int main()
{
	struct info info;

	int result = type_compatibility_main(info.atk_type, info.def_type1, info.def_type2);
	dsp_compatibility_msg(result);
}

お願い

勉強中のため、構造体や列挙型の使い方などで
「この書き方の方が、きれいになるよ」
などのご指摘がありましたらぜひお願いいたします。

Comments

[bsdfan]

(関係なさそうな内容なので削除)

[int32_t]

> コンパイルエラーはなく

コンパイル時に警告が出てたかもしれないですね。
どんな環境で開発しているか不明ですが、警告レベルは最高にしておくのがおすすめです。

Answer 1

「case」を書き忘れています。これだとgoto文で飛ぶためのラベルになってしまいます。

修正前一部抜粋

switch (atk_type)
{
Normal:

修正後一部抜粋

switch (atk_type)
{
case Normal:

Answer 2

switch (atk_type)

のところでブレークポイントを設定して実行を止め、atk_typeになにが入ってるのか見てみよう。