Ir ao conteúdo
  • Cadastre-se
Regras do Clube do Hardware

C Preciso fazer um programa em C que exiba alguns itens de um cadastro

Aeviles Aguiar Silva

Por Aeviles Aguiar Silva
em C/C#/C++

 Compartilhar

Posts recomendados

Aeviles Aguiar Silva
 

Aeviles Aguiar Silva

Postado
Postado

Preciso fazer um programa o qual precisa fazer algumas listagens. Sou nova em programação e estou em duvidas como fazer a exibição desses dados. para poder listar, 

Regras

O código do cadastro é sequencial, o sistema incrementa sozinho

no maximo 4 cadastros

Ao cadastrar o item no campo status deve ser armazenado 1,2,3 - 1 representa -A fazer, 2 -Fazendo e 3 -Concluído.

Os dados não serão armazenados em arquivos , após encerrado eles serão apagados

A minha duvida principal é como listar os dados  a fazer, fazendo e concluido.

Se alguém puder me auxiliar eu agradeço;

<

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>        // UTILIDADE = COPIAR UMA STRING EM OUTRA
#include <conio.h>    //UTILIDADE = MUDANCA DE COR
#define MAX 4


typedef struct {
    
    int codigo;
    char titulo[20];
    char descricao[30];
    int ano;
    char status[10];
    int ativo;
    int codst;
    char responsavel[30];
}ProjetoDados;

 ProjetoDados projeto[MAX];/*Maximo de projetos cadastrados*/
 

 /*Protótipo da função*/
void menu();
void cadastrar();
void listar();
void andamento();
void afazer();
void concluido();
void pesquisar();
void remover();


 int main(int argc, char *argv[]) {
 setlocale(LC_ALL, "Portuguese");
system("color 03");        //Testando cor


menu();


     return 0;
 }

/*Function Menu*/
 void menu(){
     int op;
     do{
    
    system("cls");
     printf(" %c----------------------------------------------------------------------------%c\n",201,187);
      printf(" | ");printf("\t\t\t     CADASTRO DE PROJETOS");printf("\t\t\t      |\n");
      printf(" %c----------------------------------------------------------------------------%c\n",200,188);
     printf(" %c----------------------------------------------------------------------------%c\n",201,187);
      printf(" | ");printf("\t\t\t     *****   MENU   *****");printf("\t\t\t      |\n");
      printf(" %c----------------------------------------------------------------------------%c\n",200,188);
      printf(" %c----------------------------------------------------------------------------%c \n",201,187);
      printf(" | <1>  Cadastro de Projeto                                                   |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <2>  Listar Todos os projetos                                              |\n");      
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <3>  Listar projetos em andamento(fazendo)                                 |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <4>  Listar projetos a fazer                                               |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <5>  Listar projetos Concluidos                                            |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <6>  Pesquisar                                                             |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <7>  Remover                                                               |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <0>  Sair                                                                  |\n");
      printf(" %c----------------------------------------------------------------------------%c",200,188);
      printf("\n\n\n\n");
      
    scanf("%d", &op);/*&op -ponteiro - endereço de memoria*/
    fflush(stdin);
    getchar();

    switch(op){
        
        case 1:
            cadastrar();
        break;
            
        case 2:
            listar();
        break;
        
        case 3:
            andamento();
        break;
        case 4:
            afazer();
        break;
        
        case 5:
            concluido();
        break;
        case 6:
            pesquisar();
        break;
        case 7:
            remover();
        break;

    }
    getchar();
    }while(op!=0);

}

void cadastrar(){
    
    int op, i;
    int totalfazer=0, totalFazendo=0, totalConcluido=0;
    int totalProjeto=0;
    int codst;
    char opst;
    
    
    
    do{
        system("cls");/*limpa a tela*/
      printf(" %c----------------------------------------------------------------------------%c \n",201,187);
      printf(" |      Cadastro de Projeto                                                   |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      
      printf("\nCodigo: %d\n",i+1);
      printf("\nTitulo:");;
      gets(projeto[i].titulo);
      fflush(stdin);
      printf("\nDescricao:");
      gets(projeto[i].descricao);
      fflush(stdin);
      printf("\nAno:");
      scanf("%d",&projeto[i].ano);
      fflush(stdin);
      printf("\nResponsavel:");
      gets(projeto[i].responsavel);      
      fflush(stdin);

      
     printf("\nDefina o status do projeto:");
            printf("\n1- A fazer");
            printf("\n2- Fazendo");
            printf("\n3-Concluido\n");
            opst=getch();
            switch(opst){    
                case '1':
                    projeto[totalProjeto].codst=1;
                    strcpy(projeto[totalProjeto].status, "A fazer");
                    totalfazer+=1;
                    break;
                    
                case '2':
                    projeto[totalProjeto].codst=2;
                    strcpy(projeto[totalProjeto].status, "Fazendo");
                    totalFazendo+=1;
                    break;
                    
                case '3':
                    projeto[totalProjeto].codst=3;
                    strcpy(projeto[totalProjeto].status, "Concluido");
                    totalConcluido+=1;
                    break;
            default:
                printf("Opcao Invalida\n");
                strcpy(projeto[totalProjeto].status,"não cadastrado");
            getch();
            }
            printf("\n\n");
      
      /**/
      /*Armazenar no vetor*/
      
         for(i=0; i< MAX; ++i)
                    {
                        
                    if(projeto[i].ativo==0){
                    projeto[i].codigo=i+1;
                    strcpy(projeto[i].titulo,"titulo");
                    strcpy(projeto[i].descricao,"descricao");
                    projeto[i].ano;
                    strcpy(projeto[i].responsavel,"responsavel");
                    strcpy(projeto[i].status,"opst");
                    projeto[i].ativo=1;    
                    
                            
                    break; /*tenho que colocar o break senão ele vai ficar imprimindo sem parar    */
                    
                    }
            }
                    
        
        printf("\n1- Continuar  \n0-Sair");
                scanf("%d",&op);
                fflush(stdin);
                getchar();
            }while(op!=0);
    

}
void listar(){
    system("cls");/*limpar tela*/
    int i;
    
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | Listar Todos os projetos                                                   |\n");      
      printf(" |----------------------------------------------------------------------------|\n");
    
    for (i=0; i< MAX; ++i){
        
        
        if(projeto[i].ativo==1){
                        printf("-----------------\n");
                        /*Armazenar os dados*/
                    printf("Codigo: %d\n",i+1);
                    printf("Titulo: %s\n",projeto[i].titulo);
                    printf("Descricao: %s\n",projeto[i].descricao);
                    printf("Ano: %d \n",projeto[i].ano);
                    printf("Responsavel: %s\n",projeto[i].responsavel);
                    printf("Status: %s", projeto[i].status);
                        printf("-----------------");
                    
        }
    
}
    
    

}
void andamento(){

}


void afazer(){

}
void concluido(){

}
void pesquisar(){

}
void remover(){

}

>

  • Obrigado 1
Link para o comentário
Compartilhar em outros sites
devair1010
 

devair1010

Postado
Postado

@Aeviles Aguiar Silva    olá ,  a listagem é como você fez mesmo , porém você está listando tudo , até mesmo os cadastros que ainda não foram feitos , ao colocar o MAX no loop for da listagem , e seria melhor você usar um contador de cadastros , que indicaria o total de cadastros já realizados e assim na listagem use esse contador como limite no for ,  e no cadstro não precisa inserir novamente os dados no typedef struc  , apenas marcar aquele como ativo = 1 ,  e as cores , essa que você está yentando usar até que funciona , mas é muito limitada , então seria melhor usar a textcolor ,  e organizando seu código ficou assim  : 

#include <stdio.h>
#include <windows.h>
#include <time.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>   // UTILIDADE = COPIAR UMA STRING EM OUTRA
#include <conio.h>    //UTILIDADE = MUDANCA DE COR
#define MAX 4
#define getch() _getch()
typedef struct
{
    int  codigo;
    char titulo[20];
    char descricao[30];
    int  ano;
    char status[10];
    int  ativo;
    int  codst;
    char responsavel[30];
}ProjetoDados;
ProjetoDados projeto[MAX];   /// Maximo de projetos cadastrados
                             /// Protótipo das funnçõeso
void menu();
void cadastrar();
void listar();
void andamento();
void afazer();
void concluido();
void pesquisar();
void remover();
void nome_das_cores();
void textcolor(int,int); /// são 16 cores , vai zero até Quinze (  0...15 )
///  0 = pret
///  7 = cinza
/// 14 = amarelo
/// 15 = branco
int main(int argc, char *argv[])
{
    srand(time(NULL)); /// semente para random
    int i;
    for(i=0;i<MAX;i++) projeto[i].codigo = 0; // inicializar a variável , senão terá um qq valor desconhecido
    setlocale(LC_ALL, "Portuguese");
    //system("color 03");        //Testando cor
    textcolor(12,14); /// cres -:> 1º cor da Letra   2º cor de fundo da tela
    menu();
    return 0;
}
/*Function Menu*/
void menu()
{
    int op;
    char r[20];
    do
    {
        textcolor(12,14); /// cres -:> 1º cor da Letra   2º cor de fundo da tela
        system("cls");
        printf(" %c----------------------------------------------------------------------------%c\n",201,187);
        printf(" | ");printf("\t\t\t     CADASTRO DE PROJETOS");printf("\t\t\t      |\n");
        printf(" %c----------------------------------------------------------------------------%c\n",200,188);
        printf(" %c----------------------------------------------------------------------------%c\n",201,187);
        printf(" | ");printf("\t\t\t     *****   MENU   *****");printf("\t\t\t      |\n");
        printf(" %c----------------------------------------------------------------------------%c\n",200,188);
        printf(" %c----------------------------------------------------------------------------%c \n",201,187);
        printf(" | <1>  Cadastro de Projeto                                                   |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <2>  Listar Todos os projetos                                              |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <3>  Listar projetos em andamento(fazendo)                                 |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <4>  Listar projetos a fazer                                               |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <5>  Listar projetos Concluidos                                            |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <6>  Pesquisar                                                             |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <7>  Remover                                                               |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <8>  Mostrar o Nome das cores                                              |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf(" | <0>  Sair                                                                  |\n");
        printf(" %c---------------------------------------------------------------------------%c\n",200,188);
        printf("        Escolha ");
        /// scanf("%d", &op);/*&op -ponteiro - endereço de memoria*/

        op = getch() - 48;  /// valor do código ASCII e menos 48 pois o zero é  o 48º
        /// sem pressionar ENTER

        //fflush(stdin);
        //fgets(r,19,stdin);  /// pega o resto que estive no buffer do teclado , limpando o
        switch( op )
        {
        case 0:
            printf("\n\n Saindo do programa . . . !\n\n\n");
            break;
        case 1:
            cadastrar();
            break;
        case 2:
            listar();
            break;
        case 3:
            andamento();
            break;
        case 4:
            afazer();
            break;
        case 5:
            concluido();
            break;
        case 6:
            pesquisar();
            break;
        case 7:
            remover();
            break;
        case 8:
            nome_das_cores();
            break;
        default :
            printf("Opcao InvaLidA . . . !\n");
        }
        getchar();
    }while( op != 0 );
}
void cadastrar()
{
    int op, i=0,codigo = rand() % 32768;
    int totalfazer     = 0,
        totalFazendo   = 0,
        totalConcluido = 0;
    int totalProjeto   = 0;
    int codst; // essa variavel simple , tem um clone membro da typdef projeto
    char opst;
    do
    {
        system("cls");/*limpa a tela*/
        printf("\t\t\tCadAstrandO . . . !\n)");
        printf(" %c----------------------------------------------------------------------------%c \n",201,187);
        printf(" |      Cadastro de Projeto                                                   |\n");
        printf(" |----------------------------------------------------------------------------|\n");
        printf("Codigo ------: %d\n",i+1);
        printf("Titulo ------: ");

        /// fgets é Atual e o gets já foi ultrapssada e está em desuso é ruim !
        fgets(projeto[i].titulo,19,stdin);
        /// aqui o buffer já está limpo e então não precisa de fflush(stdin);

        projeto[i].titulo[strlen( projeto[i].titulo ) - 1 ] = '\0'; /// remover o newLine
        /// senão dá erro nas comparações

        printf("\nDescricao ---:");
        gets(projeto[i].descricao); /// pode modificar esses outros gets por fgets também  , viu  !
        fflush(stdin);
        printf("\nAno:");
        scanf("%d",&projeto[i].ano);
        fflush(stdin);
        printf("\nResponsavel:");
        gets(projeto[i].responsavel);
        fflush(stdin);
        printf("\nDefina o status do projeto:");
        printf("\n\t1- A fazer");
        printf("\n\t2- Fazendo");
        printf("\n\t3-Concluido\n");
        opst=getch();
        switch(opst)
        {
        case '1':
            projeto[totalProjeto].codst=1;
            strcpy(projeto[totalProjeto].status, "A fazer");
            totalfazer += 1;
            break;
        case '2':
            projeto[totalProjeto].codst=2;
            strcpy(projeto[totalProjeto].status, "Fazendo");
            totalFazendo+=1;
            break;
        case '3':
            projeto[totalProjeto].codst=3;
            strcpy(projeto[totalProjeto].status, "Concluido");
            totalConcluido+=1;
            break;
        default:
            printf("Opcao Invalida\n");
            strcpy(projeto[totalProjeto].status,"não cadastrado");
            getch();
        }
        printf("\n\n");
        /**/
        /*Armazenar no vetor*/
        for(i=0; i< MAX; ++i)
        {
            if( projeto[i].ativo == 0 )
            {
                projeto[       i].codigo     = i+1           ;
                /*
                strcpy(projeto[i].titulo     , "titulo"     );
                strcpy(projeto[i].descricao  , "descricao"  );
                projeto[       i].ano                        ; esse bloco não precisa
                strcpy(projeto[i].responsavel, "responsavel");
                strcpy(projeto[i].status     , "opst"       );
                */
                projeto[       i].ativo      = 1             ;
                break; /*tenho que colocar o break senão ele vai ficar imprimindo sem parar    */
            }          /// por que já resolveu essa Questão então não precisa prosseguir com o Loop
        }
        printf("\n\t1 - Continuar\n");
        printf(  "\t0 - Sair "      );
        scanf("%d",& op             );
        fflush( stdin               );
    }while( op != 0                 );
}
void listar()
{
    system("cls");/*limpar tela*/
    int i;
    printf(" |----------------------------------------------------------------------------|\n");
    printf(" | Listar Todos os projetos                                                   |\n");
    printf(" |----------------------------------------------------------------------------|\n");
    for (i=0; i< MAX; ++i)
    {
        if( projeto[i].ativo == 1 )
        {
            printf("-----------------\n");
            /*Mostrar os dados*/
            printf("Codigo -------: %d\n" , i+1                    );
            printf("Titulo -------: %s\n" , projeto[i].titulo      );
            printf("Descricao ----: %s\n" , projeto[i].descricao   );
            printf("Ano ----------: %d\n" , projeto[i].ano         );
            printf("Responsavel --: %s\n" , projeto[i].responsavel );
            printf("Status -------: %s\n" , projeto[i].status      );
            printf("-------------------------------------------"   );
        }
    }
}
void andamento()
{

}
void afazer()
{

}
void concluido()
{

}
void pesquisar()
{

}
void remover()
{

}
void textcolor(int letra,int fundo)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            letra + (fundo << 4));
}
void      nome_das_cores()
{
    int i;
    char cor[][20] =
    {
        "preto"           , "azul escuro" , "verde escuro" , "azul claro"  ,
        "vermelho escuro" , "magenta"     , "marrom"       , "cinza claro" ,
        "cinza escuro"    , "azul claro"  , "verde claro"  , "celeste"     ,
        "vermelho claro"  , "lilas"       , "amarelo"      , "branco"
    };
    for(i=0;i<16;i++)
    {
        textcolor(7,0);
        printf("o nome da cor numero %3d eh %15s -> ",i,cor[i]);
        textcolor(i,0);
        printf("%c%c%c\n",219,219,219);
    }
}

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites
Aeviles Aguiar Silva
 

Aeviles Aguiar Silva

Postado
  • Autor
Postado

@devair1010 Obrigada pela a ajuda eu vou tentar fazer dessa forma para ver se consigo, pois realmente fiquei com duvidas.

 

Muito obrigada! :)

@vangodp Eu estava tentando listar os itens selecionados.

Eu tentei exibir , da forma como citou mas não consigo, está dando erro nas listagem, tanto na listagem geral, e eu não tenho ideia como fazer a função para exibir os itens concluidos, a fazer e fazendo :( . Não tô conseguindo mesmo. 

  • Obrigado 1
Link para o comentário
Compartilhar em outros sites
Midori
 

Midori

Postado
Postado

@Aeviles Aguiar Silva Acho que ficaria melhor deixar o campo status como inteiro e só mostrar a string quando imprimir o cadastro. Outra coisa que poderia facilitar é criar a função do menu com o retorno da opção, assim poderá passar esse retorno para o loop e a variável que testa a opção escolhida. E a mesma função poderá ser aproveitada para mostrar as opções dos status. Criando funções com parâmetros poderá ter mais controle sobre o que deseja mostrar e até aproveitar em outros casos como para mostrar um dos status. Fiz um exemplo com apenas três campos para demonstrar como acho que poderia ser feito,

  

#include <stdio.h>

#define MENU_PRINCIPAL  1
#define MENU_STATUS     2
#define CADASTRA        1
#define LISTA_TODOS     2
#define LISTA_AFAZER    3
#define LISTA_FAZENDO   4
#define LISTA_CONCLUIDO 5
#define STATUS_AFAZER   1
#define STATUS_FAZENDO  2
#define STATUS_CONCLUIDO 3

typedef struct {
    int codigo;
    char titulo[20];
    int status;
}Projeto; 

int menu(int tipo){
    int opcao;
    if(tipo == MENU_PRINCIPAL){
        printf(
            "1] Cadastrar\n"
            "2] Listar todos\n"
            "3] Listar a fazer\n"
            "4] Listar fazendo\n"
            "5] Listar concluido\n"
            "0] Sair\n: "
        );
    }else if(tipo == MENU_STATUS){
        printf(
            "1] A fazer\n"
            "2] Fazendo\n"
            "3] Concluido\n: "
        );
    }
    scanf("%d%*c", &opcao);
    return opcao;
}

const char *status_str(int codigo){
    static const char *tipo[3] = {
        "A fazer", "Fazendo", "Concluido"
    };
    return tipo[codigo - 1];
}

Projeto *cadastra(Projeto *projeto, int codigo){
    projeto->codigo = codigo;
    printf("Titulo: ");
    fgets(projeto->titulo, 20, stdin);
    projeto->status = menu(MENU_STATUS);
    return projeto;
}

Projeto *imprime(Projeto *projeto, int codigos, int status){
    puts("----------------------------");
    for(int i = 0; i < codigos; i += 1){
        if(projeto[i].status == status ^ status == 0){
            printf(
                "%d | %9s | %s",
                projeto[i].codigo,
                status_str(projeto[i].status),
                projeto[i].titulo
            );
        }
    }
    puts("----------------------------");
    return projeto;
}

int main(int argc, char *argv[]){
    Projeto projeto[4];
    int opcao;
    int codigo = 0;
    
    while(opcao = menu(MENU_PRINCIPAL)){
        if(opcao == CADASTRA){
            if(codigo < 4){
                cadastra(&projeto[codigo], codigo);
                codigo += 1;
            }else{
                puts("Cadastros concluidos.");
            }
        }else if(opcao == LISTA_TODOS){
            imprime(projeto, codigo, 0);
        }else if(opcao == LISTA_AFAZER){
            imprime(projeto, codigo, STATUS_AFAZER);
        }else if(opcao == LISTA_FAZENDO){
            imprime(projeto, codigo, STATUS_FAZENDO);
        }else if(opcao == LISTA_CONCLUIDO){
            imprime(projeto, codigo, STATUS_CONCLUIDO);
        }
    }
    return 0;   
}

 

  • Curtir 3
  • Obrigado 1
Link para o comentário
Compartilhar em outros sites
Aeviles Aguiar Silva
 

Aeviles Aguiar Silva

Postado
  • Autor
Postado
Em 02/07/2021 às 11:58, Midori disse:

@Aeviles Aguiar Silva Acho que ficaria melhor deixar o campo status como inteiro e só mostrar a string quando imprimir o cadastro. Outra coisa que poderia facilitar é criar a função do menu com o retorno da opção, assim poderá passar esse retorno para o loop e a variável que testa a opção escolhida. E a mesma função poderá ser aproveitada para mostrar as opções dos status. Criando funções com parâmetros poderá ter mais controle sobre o que deseja mostrar e até aproveitar em outros casos como para mostrar um dos status. Fiz um exemplo com apenas três campos para demonstrar como acho que poderia ser feito,

  

#include <stdio.h>

#define MENU_PRINCIPAL  1
#define MENU_STATUS     2
#define CADASTRA        1
#define LISTA_TODOS     2
#define LISTA_AFAZER    3
#define LISTA_FAZENDO   4
#define LISTA_CONCLUIDO 5
#define STATUS_AFAZER   1
#define STATUS_FAZENDO  2
#define STATUS_CONCLUIDO 3

typedef struct {
    int codigo;
    char titulo[20];
    int status;
}Projeto; 

int menu(int tipo){
    int opcao;
    if(tipo == MENU_PRINCIPAL){
        printf(
            "1] Cadastrar\n"
            "2] Listar todos\n"
            "3] Listar a fazer\n"
            "4] Listar fazendo\n"
            "5] Listar concluido\n"
            "0] Sair\n: "
        );
    }else if(tipo == MENU_STATUS){
        printf(
            "1] A fazer\n"
            "2] Fazendo\n"
            "3] Concluido\n: "
        );
    }
    scanf("%d%*c", &opcao);
    return opcao;
}

const char *status_str(int codigo){
    static const char *tipo[3] = {
        "A fazer", "Fazendo", "Concluido"
    };
    return tipo[codigo - 1];
}

Projeto *cadastra(Projeto *projeto, int codigo){
    projeto->codigo = codigo;
    printf("Titulo: ");
    fgets(projeto->titulo, 20, stdin);
    projeto->status = menu(MENU_STATUS);
    return projeto;
}

Projeto *imprime(Projeto *projeto, int codigos, int status){
    puts("----------------------------");
    for(int i = 0; i < codigos; i += 1){
        if(projeto[i].status == status ^ status == 0){
            printf(
                "%d | %9s | %s",
                projeto[i].codigo,
                status_str(projeto[i].status),
                projeto[i].titulo
            );
        }
    }
    puts("----------------------------");
    return projeto;
}

int main(int argc, char *argv[]){
    Projeto projeto[4];
    int opcao;
    int codigo = 0;
    
    while(opcao = menu(MENU_PRINCIPAL)){
        if(opcao == CADASTRA){
            if(codigo < 4){
                cadastra(&projeto[codigo], codigo);
                codigo += 1;
            }else{
                puts("Cadastros concluidos.");
            }
        }else if(opcao == LISTA_TODOS){
            imprime(projeto, codigo, 0);
        }else if(opcao == LISTA_AFAZER){
            imprime(projeto, codigo, STATUS_AFAZER);
        }else if(opcao == LISTA_FAZENDO){
            imprime(projeto, codigo, STATUS_FAZENDO);
        }else if(opcao == LISTA_CONCLUIDO){
            imprime(projeto, codigo, STATUS_CONCLUIDO);
        }
    }
    return 0;   
}

 

Realmente não tinha pensado dessa forma , ficou muito bom o seu codigo, eu estava refazendo e deu mais de 600 linhas, quanta falta de experiencia minha. Seu codigo ficou limpo.

Muito Obrigada!

  • Obrigado 2
Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado
Em 01/07/2021 às 14:54, Aeviles Aguiar Silva disse:

eu não tenho ideia como fazer a função para exibir os itens concluidos, a fazer e fazendo

 

Basta testar o valor do status na hora de listar. 

 

Imagino que a primeira função que devia ter escrito seria a de listar, já que precisa testar o programa e sem isso não ia dar. Nessa função use um parâmetro que dá o critério. Algo ingênuo como 0,1,2,3 para listar tudo, a fazer, fazendo e concluído não seria nada original e funcionaria direitinho...

 

  • Escreva em torno dos dados. 
  • Não escreva um programa interativo. Quando estiver funcionando você coloca essas coisas, Não acrescenta nada ter um menu, ler coisas, nada. Só vai atrasar.
  • evite void e funções sem argumentos. Em geral é um erro
  • nunca use gets. Isso não existe há décadas e é mais uma chance de seu programa cancelar a toa ou de nem compilar
  • TESTE o retorno de scanf(). É ingênuo não testar e seguir cegamente adiante
  • Quando está aprendendo, mostre os valores lidos
  • entenda que em geral um printf() de 8 linhas é umas 8 vezes melhor que 8 printf() de uma linha.
  • nunca use fflush() na entrada. Em geral nem funciona e só indica um programa mal construído.
  • NUNCA declare nada fora de main(). É global e só dá problema. Por isso mesmo é proibido em toda parte, empresas e escolas. Não use valores globais. Não é mais simples. É mais complicado. Use parâmetros.

Compare: do seu programa
  

      printf(" | <1>  Cadastro de Projeto                                                   |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <2>  Listar Todos os projetos                                              |\n");      
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <3>  Listar projetos em andamento(fazendo)                                 |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <4>  Listar projetos a fazer                                               |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <5>  Listar projetos Concluidos                                            |\n"); 
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <6>  Pesquisar                                                             |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <7>  Remover                                                               |\n");
      printf(" |----------------------------------------------------------------------------|\n");
      printf(" | <0>  Sair                                                                  |\n");

 

Com o simples

  

      	printf("\
 | <1>  Cadastro de Projeto                                                   |\n\
 |----------------------------------------------------------------------------|\n\
 | <2>  Listar Todos os projetos                                              |\n\
 |----------------------------------------------------------------------------|\n\
 | <3>  Listar projetos em andamento(fazendo)                                 |\n\
 |----------------------------------------------------------------------------|\n\
 | <4>  Listar projetos a fazer                                               |\n\
 |----------------------------------------------------------------------------|\n\
 | <5>  Listar projetos Concluidos                                            |\n\
 |----------------------------------------------------------------------------|\n\
 | <6>  Pesquisar                                                             |\n\
 |----------------------------------------------------------------------------|\n\
 | <7>  Remover                                                               |\n\
 |----------------------------------------------------------------------------|\n\
 | <0>  Sair                                                                  |\n"
          );

 

É claro que chamar 15 vezes a MESMA função não é assim eficiente... E como deve ter descoberto é o d1@b0 alinhar e edita o texto. Use arquivos: é muito mais fácil. E você edita separado,  no próprio IDE.

  

/*Function Menu*/
 void menu(){
     int op;

 

Use comentários para explicar o que está fazendo e porque. Evite esses comentários óbvios, tipo 
  

/*Function Menu*/
 /*Protótipo da função*/

 

E, claro, não use acentos em comentários. Não acrescenta nada e muitas vezes nem mostra direito, como vê acima...

 

Qual a razão para não escrever o simples e retornar a opção do menu?

  

    char    menu();

 

para poder usar depois coisas como
  

    switch( menu() )
    {
         case '1':
            // opcao 1
            break;
  //..
    }

 

É mais simples e legível, como @Midori citou...

  

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>        // UTILIDADE = COPIAR UMA STRING EM OUTRA
#include <conio.h>    //UTILIDADE = MUDANCA DE COR
#define MAX 4

 

Evite esse tipo de comentário.  

Sobre conio.h: isso vem dos anos '80 e não há razão pra usar isso desde provavelmente os mesmos anos 80. Não é padrão e não é assim útil. 

 

Use os #define ANTES dos #include. Nem todos seus programas vão ser assim simples. E evite um nome assim clássico como MAX ou MIN que pode estar em uso em outras funções... Os símbolos que você define podem estar em uso em headers que você inclui...

 

Os dados

 

Entenda o que são seus dados: uma lista de dados. Eis como você escreveu:
  

typedef struct {
    
    int codigo;
    char titulo[20];
    char descricao[30];
    int ano;
    char status[10];
    int ativo;
    int codst;
    char responsavel[30];
}ProjetoDados;

 ProjetoDados projeto[MAX];/*Maximo de projetos cadastrados*/

 

Assim projeto[MAX] é global. Má ideia. E entenda que está claro que vai precisar controlar quantos valores em projeto estão em uso... Não escreva assim. E dá para imaginar sem aquele comentário o que é o vetor projeto. E nem é o que está escrito. projeto é um vetor para conter um MAX de projetos cadastrados. Não é o "máximo de projetos cadastrados".

 

Prefira o simples:
  

#define     MAX_PROJETOS    10
#include <stdio.h>

typedef struct
{
    int     codigo;
    char    titulo[20];
    char    descricao[30];
    int     ano;
    char    status[10];
    int     ativo;
    int     codst;
    char    responsavel[30];

}   Tarefa;

typedef struct
{
    int     limite;
    int     quantos;
    char    descricao[20];
    Tarefa  prj[MAX_PROJETOS];

}   Projeto;

int main(void)
{
    Projeto    projeto;
    Projeto    teste[80];

    Projeto    p =
    {
        .limite = MAX_PROJETOS,
        .quantos = 0, // vazio no inicio
        .descricao = "Reforma casa 2"
    };

    printf( "Projeto \"%s\" com %d tarefas cadastradas\n", p.descricao, p.limite );
    return 0;
}

 

E porque? Porque dentro do Projeto tem as tarefas. O projeto inclui DENTRO dele um nominho e um total de tarefas e mais um limite que pode permitir um controle adicional do tamanho. Assim você pode, como está acima, declarar vários projetos, um vetor deles, e tudo num mesmo programa e não tem dificuldade em controlar: cada projeto tem os seus dados.

 

Só para testar, o programa mostra
  

Projeto "Reforma casa 2" com 10 tarefas cadastradas

 

Claro, não serve pra nada. É só para você ver a mecânica.

 

Use argumentos, parâmetros:

 

Entenda: quando você escreve
  

    void cadastrar();


É algo praticamente inútil. Não entra nada, não sai nada. Um buraco negro. Vai depender totalmente de valores globais e só vai funcionar aqui dentro e para UM projeto. 

 

Compare
  

    int    cadastrar( Tarefa* T, Projeto* P);


E imagine que essa função cadastra a tarefa T no projeto P e devolve por exemplo zero se deu certo... Acho que entende a diferença: pode tratar qualquer tarefa e qualquer projeto... E não precisa controlar nada fora da função. Esse é o conceito de encapsulamento, um dos principais da tal orientação a objetos.

 

Use algo assim
  

// alternativas para as funcoes
char        menu();
int         cadastrar(Tarefa* T, Projeto* P);
int         listar(   Projeto*, int status); // status 0,1,2 ou 3
int         pesquisar(Tarefa*, Projeto*);
int         remover(  Tarefa*, Projeto*);

 

e seus programas ficam prontos muitas vezes na primeira vez em que rodam. É o comum.

 

 

 

 

Não use system(). Não estará fazendo nada. É proibida em toda parte e não vai aprender nada. Apenas passa uma string para o shell do sistema. Está programando em C  pode fazer qualquer coisa. system() foi escrita em C, o sistema foi escrito em C.

  • Curtir 2
Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado

@Aeviles Aguiar Silva  O que escrevi é o normal.

 

Pelo que vejo neste forum, nos programas de iniciantes e estudantes postados parece que os instrutores seguem uma mesma cartilha. E vários problemas se repetem.  Erros mesmo. Uma pena.

 

Seguindo o que expliquei, editei uma parte do seu programa para tentar mostrar como pode ser mais simples...

Apenas a parte que lista e que era a sua dúvida afinal. Entenda que seu programa não está bom do modo como escreveu, pelas razões que eu mostrei: é frágil e difícil de manter.

Segue o exemplo:

 

O EXEMPLO
  

#define     MAX_PROJETOS    10
#include <stdio.h>

typedef struct
{
    int     codigo;
    char    titulo[20];
    char    descricao[30];
    int     ano;
    char    status;
    int     ativo;
    int     codst;
    char    responsavel[30];

}   Tarefa;

typedef struct
{
    int     limite;
    int     quantos;
    char    descricao[20];
    Tarefa  prj[MAX_PROJETOS];

}   Projeto;

// alternativas para as funcoes
char        menu();
int         cadastrar(Tarefa* T, Projeto* P);
int         listar(   Projeto*, int status); // status 0,1,2 ou 3
int         pesquisar(Tarefa*, Projeto*);
int         remover(  Tarefa*, Projeto*);

int main(void)
{
    Projeto    p =
    {
        .limite = MAX_PROJETOS,
        .quantos = 0, // vazio no inicio
        .descricao = "Reforma casa 2"
    };

    // cria uma tarefa generica para testar a listagem
    Tarefa      tarefa_teste = 
    { 1,"Tarefa Generica","Descricao",2030,0,0,0,"Responsavel" };

    // carrega o projeto com tarefa
    for ( int i=0; i<MAX_PROJETOS; i+=1 )
    {
        tarefa_teste.codigo = i + 1000;
        tarefa_teste.status = 1 + i % 3; // 1,2,3,1,2,3...
        p.prj[p.quantos] = tarefa_teste;
        p.quantos += 1;
    };

    // lista todo mundo e depois por criterio
    listar(&p, 0);
    listar(&p, 1);
    listar(&p, 2);
    listar(&p, 3);
    return 0;
}


int         lista_uma( Tarefa* T, int status )
{   // lista uma unica tarefa
    const char* texto[] =
    {   // o primeiro fica em branco para poder usar o indice direto :) 
        "",
        "[Status: \"  A FAZER\"]",
        "[Status: \"  FAZENDO\"]",
        "[Status: \"CONCLUIDO\"]"
    };
    if ( status == 0 )
    {   // imprime o status
        printf("\
    #%d %s '%s' %s Ano: %d Resp: %s\n",
        T->codigo, T->titulo, T->descricao, texto[(int)T->status],
        T->ano, T->responsavel);
    }
    else
    {   // não faz sentido repetir o status: todos sao iguais
        printf("\
    #%d %s '%s' Ano: %d Resp: %s\n",
        T->codigo, T->titulo, T->descricao,
        T->ano, T->responsavel);
    }
    return 0;
};


// status 0 lista todas as tarefas, 1 a fazer 2 fazendo 3 concluido
int         listar(   Projeto* P, int status)
{
      // com a tabela fica mais fácil: não precisa testar nada
    const char* texto[4] =
    {
        "Listando todas as Tarefas",
        "Listando apenas Tarefas \"A FAZER\"",
        "Listando apenas Tarefas \"FAZENDO\"",
        "Listando apenas Tarefas \"CONCLUIDO\""
    };
    printf( "\n\n==> Projeto %s tem %d tarefas\n\t%s\n\n",
    P->descricao, P->quantos, texto[status]);
    // lista as tarefas uma a uma se o status for o esperado
    for ( int i=0; i<P->quantos; i+= 1)
        if( (status == 0) || (P->prj[i].status == status ))
            lista_uma(&P->prj[i],status);
    return 0;
}
//fim

 

E a saída

  

Clube>  cc -Wall -o tst xx.c
Clube>  ./tst

==> Projeto Reforma casa 2 tem 10 tarefas
        Listando todas as Tarefas

    #1000 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel
    #1001 Tarefa Generica 'Descricao' [Status: "  FAZENDO"] Ano: 2030 Resp: Responsavel
    #1002 Tarefa Generica 'Descricao' [Status: "CONCLUIDO"] Ano: 2030 Resp: Responsavel
    #1003 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel
    #1004 Tarefa Generica 'Descricao' [Status: "  FAZENDO"] Ano: 2030 Resp: Responsavel
    #1005 Tarefa Generica 'Descricao' [Status: "CONCLUIDO"] Ano: 2030 Resp: Responsavel
    #1006 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel
    #1007 Tarefa Generica 'Descricao' [Status: "  FAZENDO"] Ano: 2030 Resp: Responsavel
    #1008 Tarefa Generica 'Descricao' [Status: "CONCLUIDO"] Ano: 2030 Resp: Responsavel
    #1009 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel


==> Projeto Reforma casa 2 tem 10 tarefas
        Listando apenas Tarefas "A FAZER"

    #1000 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1003 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1006 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1009 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel


==> Projeto Reforma casa 2 tem 10 tarefas
        Listando apenas Tarefas "FAZENDO"

    #1001 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1004 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1007 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel


==> Projeto Reforma casa 2 tem 10 tarefas
        Listando apenas Tarefas "CONCLUIDO"

    #1002 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1005 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1008 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
Clube>

 

E qual a diferença?

 

Primeiro: nunca escreva um programa interativo nessas horas. Você quer antes de tudo TESTAR o programa e não INTERAGIR com ele. É um p0rr3 e só atrasa. Não quer usar um menu, por exemplo. Leva dias.

 

Quer um cadastro  com  tarefas dos 3 tipos para  testar? E aí?

 

  • Opção 1:  senta em frente ao computador e entra num tal menu e digita 8 campos por tarefa para cada projeto. Para cada teste digita tudo de novo. 10 tarefas 80 campos...
     
  • Opção 2: cria um projeto e uma tarefa genérica:
      
    •      // cria uma tarefa generica para testar a listagem
    Tarefa      tarefa_teste = 
    { 1,"Tarefa Generica","Descricao",2030,0,0,0,"Responsavel" };

    Projeto    p =
    {
        .limite = MAX_PROJETOS,
        .quantos = 0, // vazio no inicio
        .descricao = "Reforma casa 2"
    };
    • carrega a mesma tarefa no projeto. Mudando o status e o o código para poder ver se sumiu algo
        
          // carrega o projeto com tarefa
    for ( int i=0; i<MAX_PROJETOS; i+=1 )
    {
        tarefa_teste.codigo = i + 1000;
        tarefa_teste.status = 1 + i % 3; // 1,2,3,1,2,3...
        p.prj[p.quantos] = tarefa_teste;
        p.quantos += 1;
    };

       

      • 1 + i%3 vai dar 1,2,3,1,2,3 e assim garante que vai ter tarefas em todos os estágios...

      • os códigos estão numerados a partir de 1000
         

    • testa a listagem
        

      
    // lista todo mundo e depois por criterio
    listar(&p, 0);
    listar(&p, 1);
    listar(&p, 2);
    listar(&p, 3);

       

      • usando o parâmetro com o status é muito mais simples. A listagem é a mesma afinal

      • uma diferença na listagem pode ser apenas não repetir o status na listagem por critério já que obviamente será o mesmo: todas as tarefas concluídas estão, digamos, concluídas :) afinal

    • entenda que uma listagem é de tarefa, não do projeto. DO projeto mesmo basta o nome e o total de tarefas. Não misture. Então fica muito mais simples:
        

          // lista as tarefas uma a uma se o status for o esperado
    for ( int i=0; i<P->quantos; i+= 1)
        if( (status == 0) || (P->prj[i].status == status ))
            lista_uma(&P->prj[i],status);

      um comando só. Veja no programa.
       

    • listar uma tarefa fica muito mais simples se entender e separar isso
        

      int         lista_uma( Tarefa* T, int status )
{   // lista uma unica tarefa
    const char* texto[] =
    {   // o primeiro fica em branco para poder usar o indice direto :) 
        "",
        "[Status: \"  A FAZER\"]",
        "[Status: \"  FAZENDO\"]",
        "[Status: \"CONCLUIDO\"]"
    };
    if ( status == 0 )
    {   // imprime o status
        printf("\
    #%d %s '%s' %s Ano: %d Resp: %s\n",
        T->codigo, T->titulo, T->descricao, texto[(int)T->status],
        T->ano, T->responsavel);
    }
    else
    {   // não faz sentido repetir o status: todos sao iguais
        printf("\
    #%d %s '%s' Ano: %d Resp: %s\n",
        T->codigo, T->titulo, T->descricao,
        T->ano, T->responsavel);
    }
    return 0;
};

      Basta a tarefa e o status. Com o status define se vai mostrar o status em cada linha ou não... E assim sabe exatamente onde mudar se não ficar bom ou se der errado. Isso é o tal encapsulamento, também conhecido como "mão na roda" aqui nesse caso, Veja os dois casos:
        

      ==> Projeto Reforma casa 2 tem 10 tarefas
        Listando todas as Tarefas

    #1000 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel
    #1001 Tarefa Generica 'Descricao' [Status: "  FAZENDO"] Ano: 2030 Resp: Responsavel
    #1002 Tarefa Generica 'Descricao' [Status: "CONCLUIDO"] Ano: 2030 Resp: Responsavel
    #1003 Tarefa Generica 'Descricao' [Status: "  A FAZER"] Ano: 2030 Resp: Responsavel
    #1004 Tarefa Generica 'Descricao' [Status: "  FAZENDO"] Ano: 2030 Resp: Responsavel
 // ...

==> Projeto Reforma casa 2 tem 10 tarefas
        Listando apenas Tarefas "A FAZER"

    #1000 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel
    #1003 Tarefa Generica 'Descricao' Ano: 2030 Resp: Responsavel

       

 

  • Curtir 2
Link para o comentário
Compartilhar em outros sites
Aeviles Aguiar Silva
 

Aeviles Aguiar Silva

Postado
  • Autor
Postado

@arfneto Nossa , mais uma vez obrigada. Bem mais simples sua explicação, realmente o que você descreveu é coerente. Eu quis fazer muitas interações ao invés de focar na estrutura e nos testes, além da qualidade do código(Meu código repete demais, nem parece um programa :( ). Confesso que pela primeira vez vi um código limpo em C nesse 1 mês que venho estudando. Fiquei com vergonha do meu código, se posso chamar de código rsrsrsr.

 

Vou seguir as suas instruções e dicas, foram bem produtivas me ajudaram a enxergar melhor.

  • Curtir 1
Link para o comentário
Compartilhar em outros sites
arfneto
 

arfneto

Postado
Postado
10 minutos atrás, Aeviles Aguiar Silva disse:

focar na estrutura e nos testes, além da qualidade do código(Meu código repete demais, nem parece um programa

 

Você foi direto à essência do problema. Escreva em torno dos dados. Antes de começar a programar o exercício já podia partir do fato que faltava um nível de estrutura do modo como estava escrevendo de início: um Projeto é uma lista de um certo número de Tarefa. Sua estrutura deve refletir isso. E separar as tarefas dos projetos usando argumentos é a expressão do problema, ANTES de saber qual linguagem vai usar. C não tem encapsulamento, objetivamente falando, como em Python ou java ou C++, mas sempre se pode separar as coisas. Veja as funções como mostrei.

  • Curtir 2
Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

 

GRÁTIS: ebook Redes Wi-Fi – 2ª Edição

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!