codigo da jogo forca em c++

//arquivo forca.h

#include <vector>
#include <string>

using namespace std;

class gerenciamento_palavras
{
 public:
 gerenciamento_palavras() {}; //Construtor
 ~gerenciamento_palavras() {}; //Destrutor

 char letra; //Recebe letra escolhida pelo usuário para adivinhar palavra

 vector<string> dicionario; //Armazena as palavras que estão no arquivo para serem posteriormente sorteadas.

 void insere_palavra(); //Função para inserir nova palavra
 void remove_palavra(); //Função para remover palavra
 string sorteio(); //Função que sorteia um número, sendo que este representa a localização de uma palavra no vector dicionário
 void preenche_dicionario(vector<string> &dicionario); //Preenche vector dicionario com as plavras armazenadas em Dicionário_palavras.txt
};

class gerenciamento_jogo
{
 public:
  vector<string> dicionario; //Armazena as palavras que estão no arquivo para serem posteriormente sorteadas.

  gerenciamento_jogo(){}; //Construtor da classe
  ~gerenciamento_jogo(){}; //Destrutor da classe

 void menu_jogo();
 void verificacao();
 void exibir(string palavra, vector<bool> exibe);
 void jogar();
};

#############################################################
//arquivo palavras.cpp
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <fstream> //Para manipular arquivos
#include <cstdlib> //Usar comando rand()
#include <ctime> //Usar time
#include "forca.h" //Permite usar o arquivo forca.h

#define MAX_LINE 1000

using namespace std;

gerenciamento_jogo gj;

void gerenciamento_palavras::preenche_dicionario(vector<string> &dicionario)
{
 char linha[MAX_LINE];

 ifstream arquivo("./dicionario_palavras", ios::in);

 while (arquivo.good())
 {
  arquivo.getline(linha,MAX_LINE-1);
  if (linha[0]!='\0')dicionario.push_back(linha); //Coloca palavras lidas no arquivo no vector dicionario
 }
 arquivo.close();
}

void gerenciamento_palavras::insere_palavra()
{
 //system("cls");
 string palavra;

 cout<< "Digite a palavra que deseja inserir:\n\n";
 cin >> palavra;

 ofstream arquivo("./dicionario_palavras", ios::app | ios::out);

 if (!arquivo.is_open())
  {
   cout << "Erro: Não foi possível abrir o arquivo." << endl;
  }

  arquivo << palavra << endl;
  arquivo.close();
  dicionario.clear(); //Apaga tudo o que está no vector dicionario
  preenche_dicionario(dicionario); //Preenche vector dicionario com as novas e antigas palavras

  //system("pause");
  gj.menu_jogo();
}

void gerenciamento_palavras::remove_palavra()
{
 //system("cls");
  if(dicionario.empty()) //Inicializa vector dicionario, caso isso já não tenha sido feito na função insere_palavra
  preenche_dicionario(dicionario);

 if (dicionario.empty()) //Se depois de inicializar o vector dicionario for constado que não há palavras no arquivo, não permite remoção
  {
   cout<< "Nao ha palavras para serem removidas!\n\n";
   gj.menu_jogo();}

   int op;
   cout << "Escolha a palavra que deseja remover ou digite -1 para voltar ao menu do jogo:\n\n";

   int i=0;
   for (vector<string>::iterator it = dicionario.begin(); it!=dicionario.end(); it++)
    {
     if((*it) != "")cout << "[" << i << "] " << (*it) << endl;
     i++;
    }
    cin >> op;

    if(op == -1)gj.menu_jogo(); //Volta ao menu do jogo
    else //Verifica se o usuário digitou uma opção diferente das listadas
    {
     bool aux = false;
     for(int i=0; i<dicionario.size(); i++){
     if (op == i)aux = true;
    }
    if(aux == false)
    {
     cout<< "A opcao digitada nao corresponde a nenhuma das listadas acima! Tente novamente.\n";
     //system("pause");
     remove_palavra();
    }
  }
   dicionario.erase(dicionario.begin()+ op);
   //remove("./dicionario_palavras"); //Apaga arquivo dicionario_palavras.txt

   ofstream arquivo("./dicionario_palavras", ios::app | ios::out);

   if (!arquivo.is_open())
    {
     cout << "Erro: Não foi possível abrir o arquivo.\n\n" << endl;
    }
    for (int i=0; i<dicion:ario.size(); i++)arquivo << dicionario[i] << endl; //Insere o conteúdo do vector dicionário, depois que o mesmo foi alrerado

    arquivo.close();
    //system("pause");
   gj.menu_jogo();
}

string gerenciamento_palavras::sorteio()
{
 string Palavra;
 srand(time(0)); //Gera uma sequência de números aleatórios diferentes toda vez que o programa é executado

 int id = rand() % (dicionario.size()-1); //Sorteia o índice de uma palavra aleatoriamente, de zero até o tamanho do vector dicionario

 if(dicionario[id] == "")sorteio();
 else
 {
  Palavra=dicionario[id];
 }
 return Palavra;
}

############################################################
//arquivo jogo.cpp

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <fstream> //Para manipular arquivos
#include <cstdlib> //Usar comando rand()
#include <ctime> //Usar time
#include "forca.h" //Permite usar o arquivo forca.h

using namespace std;

void gerenciamento_jogo::menu_jogo()
{
 //system("cls");
 int opcao;
 cout << "####JOGO DA FORCA####\n\n"
      << "[1]Inserir palavra;\n"
      << "[2]Remover palavra;\n"
      << "[3]Jogar;\n"
      << "[4]Sair.\n\n";
 cin >> opcao;

 if(opcao != 1 && opcao != 2 && opcao != 3 && opcao != 4) //Verifica se o usuário digitou algo diferente das opções listadas
  {
   cout<< "Opcao invalida! Digite novamente.\n";
   //system("pause");
   //system("cls");
   menu_jogo();
  }
 else
 if(opcao == 1)insere_palavra();
 else
 if(opcao == 2)remove_palavra();
 else
 if(opcao == 3)jogar();
 else
 {
  cout << "Finalizando Forca...\n\n";
  //system("pause");
  //system("cls");
 }
}

void gerenciamento_jogo::verificacao()
{
 char opcao;
 cin >> opcao;
 if((opcao == 's')||(opcao == 'S'))jogar();
 else
 if((opcao == 'n')||(opcao == 'N'))menu_jogo();
 else
 {
  cout << "A opcao digitada nao corresponde a nenhuma das opcoes acima.\n"
       << "Por favor, tente novamente!\n\n";
  //system ("pause");
  verificacao();
 }
}

void gerenciamento_jogo::exibir(string palavra, vector<bool> exibe)
{
 for (int i = 0 ; i < palavra.size() ; i++ )
 if (exibe[i] || palavra[i] == ' ' )cout << palavra[i];
 else
 cout << "_" << " ";
}

void gerenciamento_jogo::jogar()
{
 //system("cls");
 char letra;
 string palavra;
 if(dicionario.empty())preenche_dicionario(dicionario);//Preenche vector dicionario somente se este ainda não foi inicializado
 if(dicionario.empty()) //Verifica se vector dicionario está vazio antes de iniciar o jogo
 {
  cout << "Antes de jogar cadastre uma palavra! \n";
  //system("pause");
  menu_jogo();
 }
 palavra=sorteio();
 vector<bool> aparece(palavra.size(),false);

 cout << "A palavra sorteada tem " << palavra.size() << " letras.\n\n";
 cout << "Digite uma letra: \n";

 int cont_acerto=0;
 int cont_erro=0;
 bool aux;

 while (cont_acerto!= palavra.size())
 {
  cin >> letra;
  aux = false;

  for (int i=0; i<palavra.size(); i++)
  {
   if (palavra[i] == letra)
   {
    aparece[i]=true;
    aux= true;
    cont_acerto=cont_acerto+1;
   }
  }

  exibir(palavra, aparece);
  cout << endl;

  if(aux == false)cont_erro=cont_erro+1;
  if(cont_erro == 5) //Quando o jogador atinge o numero maximo de erros, ele perde
  {
   //system("cls");
   cout << "GAME OVER \n\n"
        << "A palavra eh: " << palavra << "\n"
        << "Erros: " << cont_erro << "\n"
        << "Que pena, vc perdeu!\n\n"
        << "Deseja jogar novamente (S/N)? \n\n";
   verificacao();
  }
}

//Mostra mensagem abaixo se o usuario acerta todas as letras
//system("cls");
 cout << "YOU WON!!! \n\n"
      << "A palavra eh: " << palavra << "\n"
      << "Erros: " << cont_erro << "\n"
      << "Parabens, vc acertou!\n\n"
      <<" Deseja jogar novamente (S/N)?\n\n " << endl;
  verificacao();
}

#########################################################
//arquivo main.cpp

#include <iostream>
#include "forca.h" //Permite usar o arquivo forca.h

using namespace std;

int main()
{
 gerenciamento_jogo gj;

 gj.menu_jogo(); //Inicializa programa com a função menu_jogo()

 return 0;
}