Sou iniciante em c++ e gostaria de uma opinião sobre um programa que fiz

24 de julho de 2016 9 respostas

nleo96 24 de julho de 2016

Comecei a aprender C++ não tem muito tempo e eu tentei recriar parte de um programa que vi no livro que estou lendo, mas eu reescrevi o código do meu jeito e tentei aplicar as coisas que aprendi, que pelo menos eu acredito que aprendi, no livro nesse programa e eu gostaria da sincera opinião de alguém sobre ele.

Eu tentei comentar o máximo que o pude o código e eu queria saber se ele está pelo menos relativamente bem escrito ou se eu fiz as coisas de tal forma que não seja tão eficiente.

O livro que estou lendo é o : “Começando a aprender C++ para leigos”

O projeto do programa está anexado e junto com ele está o executável do programa.
PS: Eu fiz usando o Code Blocks

CodeBlocks Projects.rar (640.0 KB)

9 Respostas

Joao_Gabrielaaj 24 de jul. de 2016

Poderia postar o código aqui??

Feliphe 24 de jul. de 2016 1 like

Não cheguei a executar o seu programa por motivos de segurança, porém, analisando o seu código, parece bem formulado, está bem identado, codigo mt bom pra um iniciante. Parabens.

nleo96 24 de jul. de 2016

@Feliphe
Obrigado pelo elogio cara
Pelo o que você viu no código em alguma prática de programação que eu deveria ter ou mudar?

nleo96 24 de jul. de 2016 2 likes

Cara eu vou tentar postar aqui, não sei se vai da pra entender muita coisa desse jeito.

Arquivo: main.cpp

#include <locale>
#include <iostream>
#include <stdlib.h>
#include <cstring>

#include "text.h"
#include "account.h"

using namespace std;

void display_Operation_Options();
void choose_Operation(Register accounts[], int* count_Accounts, int* max_Accounts);

//A FUNÇÃO MAIN SÓ É CHAMADA UMA ÚNICA VEZ DURANTE O PROGRAMA
//TALVEZ ISSO SEJA ALGO UM TANTO QUANTO ÓBVIO MAS COMO EU SOU INICIANTE
//EU NÃO SEI SE É COMUM CHAMAR A FUNÇÃO MAIN() VÁRIAS VEZES DENTRO DE UM PROGRAMA

int main()
{
    setlocale(LC_ALL,"Portuguese");
    //VARIÁVEIS PARA O CONTROLE DO Nº DE CONTAS CRIADAS
    //ESTAS VARIÁVEIS TAMBÉM SÃO UTILIZADAS COMO UM ÍNDICE PARA PASSAR POR ALGUMAS ARRAYS[]
    //PS: TODAS AS REFERENCIAS A "count_Accounts" e "max_Accounts" DENTRO DO CÓDIGO SÃO PONTEIROS PARA ESTAS VARIÁVEIS
    int count_Accounts = 0;
    int max_Accounts = 200;

    //CRIA UM OBJETO[] QUE VAI ARMAZENAR AS CONTAS CRIADAS
    //TODAS AS REFERENCIAS A "accounts[]" OU "accounts" DENTRO DO CÓDIGO SÃO PONTEIROS PARA ESTE OBJETO
    Register accounts[max_Accounts];

    //ESTA FUNÇÃO EXIBE AS OPÇÕES QUE O USUÁRIO TEM PARA COMEÇAR A UTILIZAR O PROGRAMA
    display_Operation_Options();

    //ESTA FUNÇÃO EXIGE QUE O USUÁRIO INFORME O QUE ELE DESEJA FAZER
    //E INICIA UM DOS MÉTODOS DA CLASSE "Register" DE ACORDO COM A ESCOLHA DO USUÁRIO
    //A CLASSE "Register" FOI DECLARADA NO ARQUIVO "account.h"
    choose_Operation(accounts, &count_Accounts, &max_Accounts);
    return 0;
}

//EXIBE PARA O USUÁRIO 3 OPÇÕES DO QUE ELE PODE FAZER NO PROGRAMA
void display_Operation_Options()
{
    //A FUNÇÃO "insert_txt()" PODE SER ENCONTRADA NOS ARQUIVOS "txt.cpp" E "txt.h"
    //ESTA FUNÇÃO RECEBE COMO ARGUMENTO: O TEXTO, A VEZES QUE ELA DEVE SER REPETIDA, -
    //A COR DO TEXTO (A MUDANÇA DE COR É FEITA POR UMA FUNÇÃO QUE VEM DO 'CONIO.H'
    //E COMO ÚLTIMO ARGUMENTO RECEBE A QUANTIDADE DE "<< ENDLL;" OU " '\n' QUE
    //DEVE SER APLICADO NO FINAL DA FUNÇÃO

    //PS: A TABELA DE CORES DO CONIO.H PODE SER ECONTRADA COM FACILIDADE NA INTERNET
    insert_txt("=", 90, 9, 1);

    insert_txt("DIGITE 1 PARA: ", 1, 15, 0);
    insert_txt("CRIAR UMA NOVA CONTA.", 1, 10, 1);

    insert_txt("DIGITE 2 PARA: ", 1, 15, 0);
    insert_txt("EXIBIR/MODIFICAR UMA CONTA JÁ EXISTENTE.", 1, 10, 1);

    insert_txt("DIGITE 3 PARA: ", 1, 15, 0);
    insert_txt("ENCERRAR O PROGRAMA.", 1, 12, 1);

    insert_txt("-", 90, 9, 1);
}

//PERGUNTA AO USUÁRIO O QUE ELE DESEJA FAZER COM BASE NAS OPÇÕES EXIBIDAS ANTERIORMENTE
//PELA FUNÇÃO "display_Operation_Options()"
void choose_Operation(Register accounts[], int* count_Accounts, int* max_Accounts)
{
    //ARMAZENA A INFORMAÇÃO QUE O USUÁRIO DAR NA VARIÁVEL "char choose[256]"
   char choose[256];
   insert_txt("ESCOLHA UMA DAS 3 OPERAÇÕES E PRESSIONE ENTER PARA CONFIRMAR: ", 1 , 10, 0);
   cin.getline(choose, 256);
   insert_txt("=", 90, 9, 2);

   //O PROGRAMA VAI CONSIDERAR COMO RESPOSTA APENAS O PRIMEIRO CARACTERE DO TEXTO QUE
   //O USUÁRIO DIGITAR COMO RESPOSTA
   switch(choose[0])
   {
   case'1':
    //O OBJETO "accounts[index] RECEBE O NOVA CONTA CADASTRADA QUE É RETORNADA PELA FUNÇÃO
    //"Register Register::register_Account(Arg1, Arg2, Arg3)" QUE POR SUA VEZ SE ENCONTRA NO ARQUIVO
    //"account.cpp" E FOI DECLARADA NO ARQUIVO "account.h"
    //--------------------------------------------------------------------------------------------------------------
    //O OBJETO "accounts[]" É PASSADO COMO ARGUMENTO PARA A FUNÇÃO
    //Register Register::register_Account(Arg1, Arg2, Arg3) PORQUE ELE VAI SER UTILIZADO PARA UMA CHECAGEM
    //DE DADOS NA HORA DO CADASTRO
    //DÊ UMA OLHADA NA FUNÇÃO QUE CITEI ANTERIORMENTE QUE TALVEZ VOCÊ ENTENDA O QUE QUERO DIZER, PELO MENOS É O QUE ESPERO
    accounts[*count_Accounts] = accounts[*count_Accounts].register_Account(accounts, count_Accounts, max_Accounts);

    //AO RETORNAR DA FUNÇÃO ANTERIOR É CHAMADA NOVAMENTE A FUNÇÃO "display_Operation_Options()"
    //E LOGO EM SEGUIDA A FUNÇÃO "choose_Operation(Arg1, Arg2)"
    //PARA QUE O USUÁRIO POSSA ESCOLHER O QUE DESEJA FAZER APÓS O TÉRMINO DO CADASTRO
    display_Operation_Options();
    choose_Operation(accounts, count_Accounts, max_Accounts);
    break;

   case'2':

    //CHAMA A FUNÇÃO "void Register::change_Account(Arg1, Arg2)" QUE VAI REALIZAR O PROCEDIMENTO
    //DE ALTERAÇÃO DE DADOS DE UMA CONTA.
    accounts[*count_Accounts].change_Account(accounts, count_Accounts);

    //AO RETORNAR DA FUNÇÃO ANTERIOR É CHAMADA NOVAMENTE A FUNÇÃO "display_Operation_Options()"
    //E LOGO EM SEGUIDA A FUNÇÃO "choose_Operation(Arg1, Arg2)"
    //PARA QUE O USUÁRIO POSSA ESCOLHER O QUE DESEJA FAZER
    //APÓS O TÉRMINO DAS ALTERAÇÕES FEITAS NA CONTA QUE ELE ESCOLHEU
    display_Operation_Options();
    choose_Operation(accounts, count_Accounts, max_Accounts);
    break;

   case'3':
       insert_txt("OBRIGADO POR TESTAR O PROGRAMA!", 1, 10, 1);
       insert_txt("=", 90, 9, 1);
       system("PAUSE");
    break;

   default:
       insert_txt("OPÇÃO INVÁLIDA. TENTE NOVAMENTE", 1, 12, 1);
       choose_Operation(accounts, count_Accounts, max_Accounts);
    break;
   }

Arquivo: account.h:

#ifndef ACCOUNT_H_INCLUDED
#define ACCOUNT_H_INCLUDED

class Register
{
public:
    //DADOS EXIGIDOS PARA O CADASTRO
    char login[256];
    char password[256];
    char securityCode[256];
    //FUNÇÕES PARA REGISTRE E EDIÇÃO DE CADASTROS
    Register register_Account(Register accounts[], int* count_Accounts, int* max_Account);
    void change_Account(Register accounts[], int* max_Index);
};


#endif // ACCOUNT_H_INCLUDED

Arquivo: account.cpp:

#include <locale>
#include <iostream>
#include <stdlib.h>
#include <cstring>

#include "text.h"
#include "account.h"

using namespace std;

//==========================================================================================================================
//AS FUNÇÕES: void display_Account(Arg1, Arg2); void display_Options(); void choose_Option(Arg1, Arg2)
//SÓ SÃO UTILIZADAS/CHAMADAS DENTRO DA FUNÇÃO: void Register::change_Account(Arg1, Arg2)
//QUE SE CONTRA NESTE MESMO ARQUIVO: account.cpp
//==========================================================================================================================

//==========================================================================================================================
//ESTA PARTE DO CÓDIGO É RESPONSÁVEL POR EXIBIR OS DADOS DE UMA CONTA ESPECÍFICA
//==========================================================================================================================
void display_Account(Register accounts[], int* index)
{
    insert_txt("-", 90, 9, 1);
    insert_txt("1 - LOGIN: ", 1, 10, 0);
    cout << accounts[*index].login << endl;

    insert_txt("2 - PASSWORD: ", 1, 10, 0);
    cout << accounts[*index].password << endl;

    insert_txt("3 - SECURITY CODE: ", 1, 10, 0);
    cout << accounts[*index].securityCode << endl;
    insert_txt("-", 90, 9, 1);
}
//==========================================================================================================================
//ESTA PARTE DO CÓDIGO É RESPONSÁVEL POR EXIBIR AS OPÇÕES DE EDIÇÃO DE DADOS DE UMA CONTA ESPECÍFICA.
//ESTA CONTA ESPECÍFICA É EXIBIDA PELA FUNÇÃO ANTERIOR A ESTA: "display_Account(Arg1, Arg2)".
//==========================================================================================================================
void display_Options()
{
    insert_txt("DIGITE 1 PARA: EDITAR O LOGIN", 1, 12, 1);
    insert_txt("DIGITE 2 PARA: EDITAR O PASSWORD", 1, 12, 1);
    insert_txt("DIGITE 3 PARA: EDITAR O SECURITY CODE", 1, 12, 1);
    insert_txt("DIGITE 4 PARA: CANCELAR A OPERAÇÃO", 1 ,12, 1);

    insert_txt("-", 90, 9, 1);
}
//==========================================================================================================================
//ESTA PARTE DO CÓDIGO É RESPONSÁVEL POR EXIGIR QUE O USUÁRIO ESCOLHA UMA DAS OPÇÕES
//EXIBIDAS NA FUNÇÃO ANTRIOR: "display_Options()"
//==========================================================================================================================
void choose_Option(Register accounts[], int* index)
{
    //PEDE PARA O USUÁRIO ESCOLHER UMA DAS OPÇÕES EXIBIDAS PELA FUNÇÃO: void display_Options()
    char choose[256];
    insert_txt("ESCOLHA UMA DAS OPÇÕES ACIMA E PRESSIONE ENTER PARA CONFIRMAR: ", 1 ,10, 0);
    cin.getline(choose, 256);
    insert_txt("-", 90, 9, 1);
    //VERIFICA QUAL DAS OPÇÕES O USUÁRIO ESCOLHEU
    switch (choose[0])
    {
    case '1':
        //SOLICITA QUE O USUÁRIO INFORME O NOVO LOGIN DA CONTA
        insert_txt("DIGITE O NOVO LOGIN: ", 1, 10, 0);
        cin.getline(accounts[*index].login, 256);
        insert_txt("O LOGIN FOI ALTERADO COM SUCESSO!", 1 , 12, 1);
        insert_txt("-", 90 ,9 ,1);

        //EXIBE NOVAMENTE AS OPÇÕES PARA QUE O USUÁRIO POSSA EDITAR ALGUM OUTRA INFORMAÇÃO NA MESMA CONTA
        display_Options();

        //CHAMA NOVAMENTE ESTA MESMA FUNÇÃO PARA QUE SEJA SOLICITADO UMAS DA OPÇÕES EXIBIDAS AO USUÁRIO
        //PELA FUNÇÃO: void display_Options()
        choose_Option(accounts, index);
        break;
    case '2':
        //SOLICITA QUE O USUÁRIO INFORME O NOVO PASSWORD DA CONTA
        insert_txt("DIGITE O NOVO PASSWORD: ", 1, 10, 0);
        cin.getline(accounts[*index].password, 256);
        insert_txt("O PASSWORD FOI ALTERADO COM SUCESSO!", 1 , 12, 1);
        insert_txt("-", 90 ,9 ,1);

        //EXIBE NOVAMENTE AS OPÇÕES PARA QUE O USUÁRIO POSSA EDITAR ALGUM OUTRA INFORMAÇÃO NA MESMA CONTA
        display_Options();

        //CHAMA NOVAMENTE ESTA MESMA FUNÇÃO PARA QUE SEJA SOLICITADO UMAS DA OPÇÕES EXIBIDAS AO USUÁRIO
        //PELA FUNÇÃO: void display_Options()
        choose_Option(accounts, index);
        break;

    case '3':
        //SOLICITA QUE O USUÁRIO INFORME O NOVO SECURITY CODE DA CONTA
        insert_txt("DIGITE O NOVO SECURITY CODE: ", 1, 10, 0);
        cin.getline(accounts[*index].securityCode, 256);
        insert_txt("O SECURITY CODE FOI ALTERADO COM SUCESSO!", 1 , 12, 1);
        insert_txt("-", 90 ,9 ,1);

        //EXIBE NOVAMENTE AS OPÇÕES PARA QUE O USUÁRIO POSSA EDITAR ALGUM OUTRA INFORMAÇÃO NA MESMA CONTA
        display_Options();

        //CHAMA NOVAMENTE ESTA MESMA FUNÇÃO PARA QUE SEJA SOLICITADO UMAS DA OPÇÕES EXIBIDAS AO USUÁRIO
        //PELA FUNÇÃO: void display_Options()
        choose_Option(accounts, index);
        break;
    case '4':
        //EXIBE UMA MENSSAGEM DE ENCERRAMENTO DA OPERAÇÃO
        insert_txt("-", 90, 9, 1);
        insert_txt("A OPERAÇÃO FOI CANCELADA!", 1, 12, 1);
        insert_txt("-", 90, 9, 1);
        //EXIBE UMA O ESTADO ATUAL DA CONTA COM AS NOVAS INFORMAÇÕES
        insert_txt("ESTADO ATUAL DA CONTA:", 1, 10,1);
        display_Account(accounts, index);
        break;
    default:
        //EXIBE UMA MENSSAGEM DE ERRO E EM SEGUIDA CHAMA ESTA MESMA FUNÇÃO EXIGINDO
        //QUE O USUÁRIO ENTRE COM UMA OPÇÃO VÁLIDA.
        insert_txt("OPÇÃO INVÁLIDA. TENTE NOVAMENTE!", 1, 12, 1);
        choose_Option(accounts, index);
        break;
    }
}

//==========================================================================================================================
//ESTA PARTE DO CÓDIGO É RESPONSÁVEL POR VERIFICAR SE EXISTEM INFORMAÇÕES DUPLICADAS ENTRE A CONTA QUE ESTÁ SENDO CRIADA
//E AS CONTAS QUE JÁ EXISTEM E DEPOIS RETORNA UMA VARIÁVEL DO TIPO BOOL "bool info_Check"
//COM O VALOR DE: TRUE NO CASO DE NÃO HAVER NEM UMA INFORMAÇÃO DUPLICADA. OU FALSE PRO CASO DE HAVER INFORMAÇÃO DUPLICADA
//==========================================================================================================================
bool register_Check(Register accounts[], Register* new_account, int* max_Accounts)
{
    bool info_Check = true;
    for(int index = 0; index <= *max_Accounts; index++)
    {
        if (strcmp(new_account -> login, accounts[index].login) == 0)
        {
            insert_txt("O LOGIN JÁ ESTÁ SENDO USADO POR OUTRA CONTA!", 1 ,12 ,1);
            info_Check = false;
        }
        if (strcmp(new_account -> securityCode, accounts[index].securityCode) == 0)
        {
            insert_txt("O CÓDIGO DE SEGURANÇA JÁ ESTÁ SENDO USADO POR OUTRA CONTA!", 1 ,12 ,1);
            info_Check = false;
        }
    }
    return info_Check;
}


//==========================================================================================================================
//===================================ESTA PARTE DO CÓDIGO TRATA DE REGISTRAR NOVAS CONTAS===================================
//==========================================================================================================================
Register Register::register_Account(Register accounts[], int* count_Accounts, int* max_Accounts)
{
    //ESTE OBJETO RECEBE TEMPORARIAMENTE A NOVA CONTA E DEPOIS É PASSADA COMO ARGUMENTO
    //PARA A FUNÇÃO "register_Check(Arg1, Arg2, Arg3)" PARA CHECAR A VALIDADE DO CADASTRO
    Register new_account;

    //ESTE OBJETO É USADO QUANDO NÃO É POSSÍVEL FINALIZAR O CADASTRO POR ALGUM MOTIVO
    //ESTE OBJETO NÃO É MODIFICADO EM MOMENTO ALGUM
    Register case_Max_Accounts;

    if (*count_Accounts < *max_Accounts)
    {
        //PASSA AS INSTRUÇÕES DE COMO PROSSEGUIR COM O CADASTRO AO USUÁRIO
        insert_txt("=", 90, 9, 1);
        insert_txt("INFORME OS DADOS EXIGIDOS ABAIXO E PRESSIONE ENTER PARA CONFIRMAR CADA INFORMAÇÃO:", 1, 12, 1);
        insert_txt("-", 90, 9, 1);

        //EXIGE O LOGIN DO USUÁRIO E ARMAZENA NA VARIÁVEL 'LOGIN' DO OBJETO "NEW_ACCOUNT"
        insert_txt("LOGIN: ", 1 ,10, 0);
        cin.getline(new_account.login, 256);
        //EXIGE A SENHA DO USUÁRIO E ARMAZENA NA VARIÁVEL 'PASSWORD' DO OBJETO "NEW_ACCOUNT"
        insert_txt("PASSWORD: ", 1 ,10, 0);
        cin.getline(new_account.password, 256);

        //EXIGE O CÓDIGO DE SEGURANÇA DO USUÁRIO E ARMAZENA NA VARIÁVEL 'SECURITY_CODE' DO OBJETO "NEW_ACCOUNT"
        insert_txt("SECURITY CODE: ", 1 ,10, 0);
        cin.getline(new_account.securityCode, 256);
        insert_txt("-", 90, 9, 1);

        //CHAMA A FUNÇÃO "register_Check(Arg1, Arg2, Arg3)" QUE VERIFICA SE EXISTEM INFORMAÇÕES
        //IGUAIS ENTRE A CONTA QUE ESTA SENDO CRIADA E ALGUMA QUE JÁ EXISTE
        if(register_Check(accounts, &new_account, max_Accounts) == true)
        {
            //EXIBE UMA CONFIRMAÇÃO DA CRIAÇÃO DA CONTA E INCREMENTA A VARIÁVEL DE CONTROLE DO Nº DE CONTAS CRIADAS
            insert_txt("CONTA CRIADA COM SUCESSO!", 1, 12, 1);
            insert_txt("=", 90, 9, 2);
            *count_Accounts += 1; //INCREMENTA A VARIÁVEL DE CONTROLE DO Nº DE CONTAS CRIADAS
            return new_account; //RETORNA A NOVA CONTA PARA O OBJETO[INDEX] QUE CHAMOU A FUNÇÃO
        }
        else
        {
            insert_txt("-", 90, 9, 1);
            insert_txt("NÃO FOI POSSÍVEL CONCLUIR O CADASTRO", 1, 12, 1);
            insert_txt("-", 90, 9, 2);
            return case_Max_Accounts;//NO CASO DE FALHA NO CADASTRO RETORNA UM OBJETO "VAZIO"
        }
    }
    else
    {
      //EXIBE UMA MENSAGEM DE ERRO AO ATINGIR O Nº MÁXIMO DE CONTAS E RETORNA UM OBJETO "VAZIO"
      insert_txt("VOCÊ ATINGIU O NÚMERO MÁXIMO DE CONTAS CRIADAS!", 1, 12, 1);
      insert_txt("=", 90, 9, 1);
      return case_Max_Accounts;
    }
}
//==========================================================================================================================
//==============================ESTA PARTE DO CÓDIGO TRATA DE ALTERAR INFORMAÇÕES DE UMA CONTA==============================
//==========================================================================================================================
void Register::change_Account(Register accounts[], int* max_Index)
{
    char code[256];
    //SOLICITA QUE O USUÁRIO INFORME O CÓDIGO DE SEGURANÇA (SECURITY CODE) QUE ELE DESEJA EXIBIR/MODIFICAR
    //E ARMAZENA ESTA INFORMAÇÃO NA VARIÁVEL "char code[256]"
    insert_txt("=", 90, 9, 1);
    insert_txt("INSIRA O CÓDIGO DE SEGURANÇA DA CONTA QUE DESEJA MODIFICAR: ", 1, 12, 0);
    cin.getline(code, 256);
    insert_txt("-", 90, 9, 1);

    //COMPARA O CÓDIGO DE SEGURANÇA INFORMADO PELO USUÁRIO COM O CÓDIGO DE SEGURANÇA DE TODAS
    //AS CONTAS CADASTRADAS ATÉ O MOMENTO
    //O PONTEIRO "*max_Index" SE REFERE AO NÚMERO DE CONTAS CRIADAS ATÉ AGORA QUE É DADO PELA
    //VARIÁVEL "count_Accounts" QUE POR SUA VEZ FOI DECLARADA NA FUNÇÃO MAIN()
    for(int index = 0; index <= *max_Index; index++)
    {
        //FAZ A COMPARAÇÃO ENTRE A INFORMAÇÃO PASSADA PELO USUÁRIO E A INFORMAÇÃO CONTIDA NAS CONTAS
        //CRIADAS ATÉ O MOMENTO
        if (strcmp(code, accounts[index].securityCode) == 0)
        {

           insert_txt("CONTA ENCONTRADA!", 1, 12, 1);
           //ESTA FUNÇÃO EXIBE A CONTA CORRESPONDENTE AO CÓDIGO DE SEGURANÇA INFORMADO
           display_Account(accounts, &index);
           //EXIBE AS OPÇÕES DO QUE O USUÁRIO PODE MODIFICAR NA CONTA
           display_Options();
           //SOLOCITA QUE O USUÁRIO ESCOLHA O QUE DESEJA FAZER E APLICA AS ALTERAÇÕES REALIZADAS
           choose_Option(accounts, &index);
           break;
        }
        else if (index >= *max_Index)
        {
            //EXIBE UMA MENSSAGEM DE ERRO NO CASO DO CÓDIGO DE SEGURANÇA SER INVÁLIDO
            //PORÉM O PROGRAMA NÃO SOLICITA O CÓDIGO NOVAMENTE
            //NESTE CASO O PROGRAMA SIMPLESMENTE VOLTA A EXIBIR AS OPÇÕES INICIAIS
            insert_txt("CÓDIGO DE SEGURANÇA INVÁLIDO", 1 ,12 ,1);
            break;
        }
    }
}

Arquivo: txt.h:

#ifndef TEXT_H_INCLUDED
#define TEXT_H_INCLUDED

//AVISO: ABAIXO ESTÃO LISTAS 8 POSSIBILIDADES DE USO PARA A MESMA FUNÇÃO!

void insert_txt(char const* text, int const* times, int const* txt_color, int const* new_line);
void insert_txt(char const* text, int times, int txt_color, int new_line);

void insert_txt(char const* text, int const* times, int txt_color, int new_line);
void insert_txt(char const* text, int const* times, int const* txt_color, int new_line);
void insert_txt(char const* text, int const* times, int txt_color, int const* new_line);

void insert_txt(char const* text, int times, int const* txt_color, int new_line);
void insert_txt(char const* text, int times, int const* txt_color, int const* new_line);

void insert_txt(char const* text, int times, int txt_color, int const* new_line);
char* testing();

#endif // TEXT_H_INCLUDED

Arquivo: txt.cpp:

#include <locale>
#include <iostream>
#include <stdlib.h>
#include <cstring>

#include <conio.c>
#include <conio.h>
using namespace std;

//AVISO: ABAIXO ESTÃO LISTAS 8 POSSIBILIDADES DE USO PARA A MESMA FUNÇÃO!

void insert_txt(char const* text, int const* times, int const* txt_color, int const* new_line)
{
    textcolor(*txt_color);
    for (int i = 0; i < *times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < *new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int times, int txt_color, int new_line)
{
    textcolor(txt_color);
    for (int i = 0; i < times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int const* times, int txt_color, int new_line)
{
    textcolor(txt_color);
    for (int i = 0; i < *times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int const* times, int const* txt_color, int new_line)
{
    textcolor(*txt_color);
    for (int i = 0; i < *times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int const* times, int txt_color, int const* new_line)
{
    textcolor(txt_color);
    for (int i = 0; i < *times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < *new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int times, int const* txt_color, int new_line)
{
    textcolor(*txt_color);
    for (int i = 0; i < times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int times, int const* txt_color, int const* new_line)
{
    textcolor(*txt_color);
    for (int i = 0; i < times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < *new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

void insert_txt(char const* text, int times, int txt_color, int const* new_line)
{
    textcolor(txt_color);
    for (int i = 0; i < times; i++)
    {
        cout << text;
    }
    for (int i = 0; i < *new_line; i++)
    {
        cout << endl;
    }
    textcolor(15);
}

Dragoon 24 de jul. de 2016 2 likes

Sinceramente, a edentação é uma coisa primordial no seu código, está de Parabéns, não sei bem como esse código funciona, mas, a organização é algo que me fascina.

Joao_Gabrielaaj 24 de jul. de 2016 1 like

Ainda não tenho muita experiência, e provavelmente você sabe mais do que eu, mas gostei muito do seu código, e não achei nenhuma prática condenável, e como nosso colega Dragoon falou, está muito organizado.

nleo96 24 de jul. de 2016

@Dragoon

@Joao_Gabrielaaj

Muito obrigado a todos que responderam
Fico feliz em saber que estou indo bem pra quem ta começando.

Feliphe 25 de jul. de 2016 1 like

Então brother, vou te dar uma dica, por exemplo, se você precisa que toda vez que o cliente fazer algo errado envie uma mensagem na tela, você pode criar uma função e ate por-la dentro de uma classe de mensagens, pra chama-la toda vez que necessário, o essencial é sempre que possível, reduzir as linhas de código, deixando o programa menor e mais leve.

nleo96 26 de jul. de 2016

@Feliphe

Valeu pela dica cara

Criado 24 de julho de 2016

Ultima resposta 26 de jul. de 2016

Respostas 9

Participantes 4

9 Respostas

Topicos relacionados