Pass enum to class and then return - c++

Question

I've got the following enum declared in code.cpp
and im using a switch statement that depends on the what the enum is set as.
enum State { HighMoral, PoorMoral, EndGame };
State CurrentState = HighMoral;
switch (CurrentState)
{
case HighMoral: random = rand()%3+1;
switch (random)
{
case 1: CurrentState = g_Solider.KillCommander(&CurrentState, random = rand()%2+1);
break;
case 2: CurrentState = g_Solider.KillSeniorCommander(&CurrentState,random = rand()%2+1);
break;
case 3: CurrentState = g_Solider.LessHalfStrength(&CurrentState);
break;
};
break;
case PoorMoral: CurrentState = g_Solider.JoinSeniorCommander();
break;
};
I want to pass this enum to a function in a class and then have it return either HighMoral, PoorMoral or EndGame and change the current state for my switch statement.
However I'm rather clueless when it comes to passing this and returning it.
I've looked around and have had no luck in finding how to do this.
I've got 3 files. code.cpp (contains void main() and the enum), solider.h (contains solider class does not know the state enum exists (how to do this?)), solider.cpp (contains all solider code but needs to take the current state and return a new state)
Here is an example of what I'm trying to do.
Solider.h
#include <time.h>
#include <iostream>
using namespace std;
extern enum State;
class Solider
{
private:
public:
void KillSeniorCommander(State& currentState, int random); // Kill the Senior Commander or random event
void JoinSeniorCommander(State& currentState); // Have the Commander join the group
void DefunctGroup(State& currentState); // Disband the group
};
Solider.cpp
void Solider::KillSeniorCommander(State& currentState, int random)
{
if (SeniorCommander==1) // If The SeniorCommander is Active
{
cout << "The Senior Commander has died!\n";
SeniorCommander--; // Kill the SeniorCommander
Groupsize--; // Reduce the Groupsize
Strength = Strength - (5*2.5); // Remove SeniorCommanders impact on Strength
SquadMoral = SquadMoral - (5*2.5);// Remove SeniorCommanders impact on SquadMoral
CurrentState = PoorMoral;
}
else // Otherwise do something random
{
switch (random)
{
case 1: cout << "Your group survives a ambush!\n";
break;
case 2: random = rand()%5+1; // Give random a new value
if (random>1)
{
cout << random << " group members have died!\n"; // Kill x Aamount of members
}
else
{
cout << "A group member has died!\n"; // Kill a member
}
Groupsize = Groupsize - random; // Remove the members from the group
Strength = Strength - (random*2.5); // Remove there effect Strength
SquadMoral = SquadMoral - (random*2.5); // Remove there effect on GroupMoral
break;
}
CurrentState = CurrentState;
}
} // KillSeniorCommander(int random)
void Solider::JoinSeniorCommander(State& currentState)
{
if (SeniorCommander==2 && Commander == 0) // Check to see if the Commander is dead and a
{ // SeniorCommander is not in service
cout << "The Senior Commander has joined!\n";
SeniorCommander--; // Change their status to active
Groupsize++; // Add them to the group
Strength = Strength - (5*2.5); // Add their impact to Strength
SquadMoral = SquadMoral - (5*2.5); // Add their impact to GroupMoral
CurrentState = HighMoral;
}
else // He isn't available to join
{
cout << "You fail to recruit new command!\n";
CurrentState = CurrentState;
}
} // JoinSeniorCommander()
void Solider::DefunctGroup(State& currentState)
{
cout << "Your group has been disbanded as it is not fit for duty.";
CurrentState = EndGame;
} // DefunctGroup()
code.cpp

Answer 1

Define the enum in a header and include that header in both files.
For instance:
#ifndef SOLDIERSTATE_H
#define SOLDIERSTATE_H
enum SoldierState
{
HighMorale,
PoorMorale,
EndGame
};
#endif

Answer 2

Enums can be treated as integers in interfaces. You can use on of two approaches: Pass by reference and have the function change it intenally, or pass by value and return the next State by value:
// one or the other
void nextState( State& currentState );
State nextState( State currentState );

Answer 3

As with everything else in C++, you need to see the declaration of something you want to use. In your case, this means the definition of State must be moved to a header file and this file then be included both in main.cpp and soldier.h. Then, you will be able to use the type State in declarations of Soldier member functions normally.

Answer 4

class Game
{
public:
enum State { HighMoral, PoorMoral, EndGame };
aMethod(State::PoorMoral);
};
Game::aMethod(State aState)
{
return State::HighMoral;
}