Logo Hardware.com.br
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas

[Resolvido] Como fazer parar de imprimir lixo, código em C!

#1 Por ldm2005 26/10/2007 - 16:58
Quando insiro todos os campos do registro corretamente, inclusive no campo descrição do problema[200] e cometário técnico[200], se eu digitar uns 180 caracteres em cada um, quando mando imprimir, aparere, o que digitei no campo descrição do problema[200] e cometário técnico[200], e também na linha dos outros campos.

[php]

#include
#include
#include
#include
#include
#define REG_MAX 50

//declaração da estrutura de tipo ROL
typedef struct{
int num_chamado;
char data_ocorrencia[10];
char descricao_problema[200];
char nome_professor[40];
char id_micro[5];
char data_verificacao[10];
char comentario_tecnico[200];
char laboratorio[4];
} ROL;

//declaração dos (métodos || funções || rotinas)
void Le_Dados();
void Inclui_Inicio();
void Inclui_Fim();
void Inclui_Registro();
void Imprimir_Todos_Registros();
void Consulta_Registro();
void Ordenar_Registros();
void Alterar_Registro();
void Excluir_Registro();
int procura_nodo( int chamada );
//void Reorganiza_numero_chamada();

ROL registro[REG_MAX] = {'\0'}; //maximo 50 registros
ROL aux;
int fim_lista = 0; //variavel para controle da lista de registros (fim da lista)
int numeracao_chamada = 1; //variavel para controle da numeração dos chamados
int coordenada_y = 0; //coordenada Y do gotoxy(x,y);

//****************************** MAIN *****************************************//
// Rotina principal do programa
// É ela quem controla todo programa, é através dela que são chamadas as
// outras rotinas do programa.
//*******************************************************************************//
int main (){

char op;
int i;

/* ############################################## */
/* --------------- MENU PRINCIPAL --------------- */
/* ############################################## */
while ( 1 ){

system("cls");
textcolor(WHITE);
printf("\n\n--------------------------------MENU----------------------------------\n\n");
printf("\n 1 - Registrar Ocorrencia (inclui no fim da lista de Registros)");
printf("\n 2 - Inclui Registro no inicio da Lista de Registros");
printf("\n 3 - Inclui Registro antes ou depois de um Registro de referencia");
printf("\n 4 - Imprimir Todos Registros");
printf("\n 5 - Consultar Registro(s)");
printf("\n 6 - Ordenar Registros");
printf("\n 7 - Alterar Registro");
printf("\n 8 - Excluir Registro(s)");
printf("\n 9 - Sair");
printf("\n\n----------------------------------------------------------------------");
printf("\n Informe a Opcao desejada: ");
op = getche();


switch (op){
case '1':
system("cls");
printf("\n\n *** Registrar Ocorrencia (inclui no fim da lista de Registros) *** ");
Inclui_Fim();
break;

case '2':
system("cls");
printf("\n\n *** Inclui Registro no inicio da Lista de Registros *** ");
Inclui_Inicio();
break;

case '3':
system("cls");
printf("\n\n *** Inclui Registro antes ou depois de um Registro de referencia *** ");
Inclui_Registro();
break;

case '4':
system("cls");
textcolor(YELLOW);
printf("\n\n --------------------------------Registros Atuais-------------------------------");
textcolor(WHITE);
Imprimir_Todos_Registros();
break;

case '5':
system("cls");
printf("\n\n *** Consultar Registro(s) *** ");
Consulta_Registro();
break;

case '6':
system("cls");
printf("\n\n *** Ordenar Registros *** ");
Ordenar_Registros();
break;

case '7':
system("cls");
printf("\n\n *** Alterar Registro *** ");
Alterar_Registro();
break;

case '8':
system("cls");
printf("\n\n *** Excluir Registro(s) *** ");
Excluir_Registro();
break;

case '9':
system("cls");
printf("\n\n\n\n Projeto desenvolvido para a cadeira de estruturas de dados - FTEC-POA");
printf("\n\n Leandro Duarte Medeiros");
printf("\n Douglas Fernandes\n\n\n\n");
printf(" Pressione qualquer tecla para ENCERRAR O PROGRAMA...");
getch();
exit( 1 ); // término do programa
break;


default:
printf("\n\n Opcao invalida, opcoes de 1 - 9 \n\n");
system("pause");

}
fflush( stdin );
}
return 0;
}

//****************************** LE_DADOS **********************************************//
// Rotina para leitura dos dados da ocorrência.
// É utilizada pelas rotinas inclui_fim, inclui_inicio, inclui_registro, altera_registro
// utilizada para ler os dados do teclado e guardar em uma variavel auxiliar.
// Foi feito algumas validações com while(1) break dentro, e do-while, sabemos que as duas
// funcionam iguais, colocamos para mostrar a funcionalidade das duas.
//****************************************************************************************//
void Le_Dados(){

int n, i=0;

do{
textcolor(WHITE); //texto da proxima linha em branco
gotoxy( 1, coordenada_y ); //coordenada para o cursor
clreol(); //limpa somente a linha, utilizada para o caso do usuario digitar algo invalido, o clreol(); limpa o que foi digitado errado.
printf(" Nome do professor......................: ");
textcolor(LIGHTCYAN); //texto digitado na cor azul claro
fflush(stdin);
gets(aux.nome_professor); //leitura da entrada de dados
}while(strlen(aux.nome_professor)==0); //não pode estar vazio


while(1){
textcolor(WHITE);
gotoxy( 1, coordenada_y+1 );
clreol();
printf(" Informe Data da Ocorrencia [dd/mm/aaaa]: ");
textcolor(LIGHTCYAN);
fflush(stdin);
scanf(" %10[0123456789/]",aux.data_ocorrencia);

if((strlen(aux.data_ocorrencia)!=0) && (aux.data_ocorrencia[2]== '/') && (aux.data_ocorrencia[5]== '/'))
break;
}


while(1){
textcolor(WHITE);
gotoxy( 1, coordenada_y+2 );
clreol();
printf(" Informe o Laboratorio [LAB1 ou LAB2]...: ");
textcolor(LIGHTCYAN);
fflush(stdin);
gets(aux.laboratorio);

for(i=0; i aux.laboratorio[i] = toupper(aux.laboratorio[i]);
}
if((aux.laboratorio[0]=='L') && (aux.laboratorio[1]=='A') && (aux.laboratorio[2]=='B') && (aux.laboratorio[3]=='1' || aux.laboratorio[3]=='2') && (strlen(aux.laboratorio)==4))
break;
}


while(1){
textcolor(WHITE);
gotoxy( 1, coordenada_y+3 );
clreol();
printf(" Informe ID do Computador [ex.: F1-M1]..: ");
textcolor(LIGHTCYAN);
fflush(stdin);
gets(aux.id_micro);


for(i=0; i aux.id_micro[i] = toupper(aux.id_micro[i]);
}
if((aux.id_micro[0]=='F') && (aux.id_micro[1]>'0') && (aux.id_micro[1]<'6') && (aux.id_micro[2]=='-') && (aux.id_micro[3]=='M') && (aux.id_micro[4]>'0') && (aux.id_micro[4]<'6') && (strlen(aux.id_micro)==5))
break;
}


//SEM VALIDAÇÃO, POIS A VERIFICAÇÃO TÉCNICA PODE AINDA NÃO TER SIDO FEITA, ENTÃO ACEITA-SE CAMPO VAZIO
textcolor(WHITE);
gotoxy( 1, coordenada_y+4 );
clreol();
printf(" Data Verificacao Tecnica...............: ");
textcolor(LIGHTCYAN);
fflush(stdin);
gets(aux.data_verificacao);



do{
textcolor(WHITE);
gotoxy( 1, coordenada_y+6 );
printf(" -------------------------------------------------------------------------------\n");
clreol();
printf(" Descreva o Problema do Micro...........: ");
textcolor(LIGHTCYAN);
fflush(stdin);
scanf(" %200[^\n]", aux.descricao_problema); //leitura de 200 caracteres ou até enter, oque acontecer 1º
}while(strlen(aux.descricao_problema)==0);


//COM VALIDAÇÃO, POIS AQUI TEM QUE SER DIGITADO ALGO, NEM QUE SEJA "AGUARDANDO TÉCNICO"
do{
textcolor(WHITE);
gotoxy( 1, coordenada_y+11 );
printf(" -------------------------------------------------------------------------------\n");
clreol();
printf(" Comentario Tecnico.....................: ");
textcolor(LIGHTCYAN);
fflush(stdin);
scanf(" %200[^\n]", aux.comentario_tecnico); //leitura de 200 caracteres ou até enter, oque acontecer 1º
}while(strlen(aux.descricao_problema)==0);

aux.num_chamado = numeracao_chamada;
system("cls");

}
//****************************** INCLUI_INICIO **********************************************//
// Rotina para incluir registro no inicio da lista de registros.
// É utilizada sempre que usuario quiser colocar um registro no topo da lista de registros
// só registra se tiver espaço na lista
//****************************************************************************************//

void Inclui_Inicio(){

int i;
coordenada_y = 6; //incrementa coordenada gotoxy() para a entrada de dados desta função, quando chamar Le_Dados()

if( fim_lista >= REG_MAX ){ //se lista estiver cheia, imprimi --> puts( "\n\n\n Lista de registros cheia!\n\n" );
textcolor(LIGHTRED);
puts( "\n\n\n Lista de registros cheia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{ //senão,
for( i=fim_lista; i > 0; i-- ){
registro[i] = registro[i-1]; //movimenta a lista até abrir o espaço do 1º registro
}
printf("\n\n\n");
Le_Dados(); //le os dados do registro
registro[0] = aux;
fim_lista++; //incrementa fim da lista
numeracao_chamada++; //incrementa numeração de chamados
}
}

//****************************** INCLUI_FIM **********************************************//
// Rotina para incluir registro no fim da lista de registros.
// É utilizada sempre que usuario quiser colocar um registro no fim da lista de registros
// só registra se tiver espaço na lista
//****************************************************************************************//
void Inclui_Fim(){

coordenada_y = 6;

if ( fim_lista >= REG_MAX ){
textcolor(LIGHTRED);
puts("\n\n\n Lista de registros cheia!\n\n");
textcolor(WHITE);
system("pause");
}
else{
printf("\n\n\n");
Le_Dados();
registro[fim_lista] = aux;
fim_lista++;
numeracao_chamada++;
}
}
//****************************** INCLUI_REGISTROS **********************************************//
// Rotina para incluir registro antes e depois de um registro de referencia.
// É utilizada sempre que usuario quiser colocar um registro antes ou depois de um registro especifico
// só registra se tiver espaço na lista
//****************************************************************************************//
void Inclui_Registro(){
int i, chamada_referencia, pf=0;
char opcao;

if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{
if( fim_lista >= REG_MAX ){
textcolor(LIGHTRED);
puts( "\n\n\n Lista de registros cheia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{

do{ //MENU PARA SABER SE USUARIO DESEJA REGISTRAR ANTES OU DEPOIS DE UM REGISTRO
system("cls");
printf("\n\n *** Inclui Registro antes ou depois de um Registro de referencia *** ");
printf("\n\n\n 1 - Incluir Antes de Registro de Referencia");
printf("\n 2 - Incluir Depois de Registro de Referencia");
printf("\n\n Informe a opcao desejada: ");
fflush(stdin);
opcao=getche();
if(opcao != '1' && opcao != '2'){
textcolor(LIGHTRED);
printf("\n\n Opcao invalida, somente 1 ou 2!");
textcolor(WHITE);
getch();
}
}while(opcao != '1' && opcao != '2');


printf("\n\n\n Numero da chamada, do registro de referencia: " );
fflush( stdin ); // limpa buffer do teclado, funciona junto com entrada de dados
textcolor(LIGHTGREEN);
scanf( "%d", &chamada_referencia );
textcolor(WHITE);
pf = procura_nodo( chamada_referencia ); // procura chamada de referencia

if (( pf >= 0 ) && ( pf < fim_lista )){

printf("\n\n\n");
coordenada_y = 16;
Le_Dados(); // le dados

if (opcao == '1'){

for( i=fim_lista-1; i >= pf; i-- ){ // desloca a lista até abrir um espaco antes do REGISTRO de referencia
registro[i+1]= registro[i];
} // fim for
registro[pf] = aux; // insere na lista
fim_lista++; //incrementa o tamanho da lista
numeracao_chamada++; //incrementa numero dos chamados
}
else{

for( i=fim_lista-1; i > pf; i-- ){ // desloca da lista até abrir espaco depois do REGISTRO de referencia
registro[i+1]= registro[i];
} // fim for
registro[pf+1] = aux; // insere na lista
fim_lista++; //incrementa o tamanho da lista
numeracao_chamada++; //incrementa numero dos chamados
} // fim else
}
else{

textcolor(LIGHTRED);
printf( "\n\n\n Numero de Chamada nao existe! \n\n" ); //senão encontrar o registro de referencia
textcolor(WHITE);
system("pause");
}
}

}
}

//****************************** IMPRIMIR_TODOS_REGISTROS **********************************************//
// Rotina para imprimir todos registros
// É utilizada sempre que usuario quiser imprimir os reistros atuais de ocorrência
// só imprimi se tiver no minimo 1 registro
//****************************************************************************************//


void Imprimir_Todos_Registros(){
int i;

if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{

for (i=0; i < fim_lista; i++){
printf("\n\n\n Numero da Chamada = %03d", registro[i].num_chamado);
printf("\n\n Nome do professor.............: %s", registro[i].nome_professor);
printf("\n Data da Ocorrencia............: %s", registro[i].data_ocorrencia);
printf("\n Laboratorio da Ocorrencia.....: %s", registro[i].laboratorio);
printf("\n Identificacao do Computador...: %s", registro[i].id_micro);
printf("\n Data Verificacao Tecnica......: %s", registro[i].data_verificacao);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Descricao do Problema do Micro: %s", registro[i].descricao_problema);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Comentario Tecnico............: %s", registro[i].comentario_tecnico);

textcolor(YELLOW);
printf("\n\n\n *******************************************************************************");
printf("\n *******************************************************************************");
textcolor(WHITE);

}
printf("\n\n");
system("pause");
}
}

//****************************** CONSULTA_REGISTROS **********************************************//
// Rotina para consultar registro, consulta por numero do chamado ou identificação do micro
// É utilizada sempre que usuario quiser consultar uma ocorrência
// só consulta se tiver no minimo 1 registro
//****************************************************************************************//
void Consulta_Registro(){

int i, j, vazio, consulta_chamada, pf=0;
char opcao, lab[4], consulta_id[5];

if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{

do{
system("cls"); //MENU PARA CONSULTAR REGISTRO
printf("\n\n *** Consultar Registro(s) *** ");
printf("\n\n\n 1 - Consultar por Numero de Chamada");
printf("\n 2 - Consultar por ID do micro");
printf("\n\n Informe a opcao desejada: ");
fflush(stdin);
opcao=getche();
if(opcao != '1' && opcao != '2'){
textcolor(LIGHTRED);
printf("\n\n Opcao invalida, somente 1 ou 2!");
textcolor(WHITE);
getch();
}
}while(opcao != '1' && opcao != '2');

printf("\n\n\n");
if(opcao == '1'){
//NUMERO DO CHAMADO DO REGISTRO A CONSULTAR
printf( " Numero do chamado, registro a ser consultado: " );
fflush( stdin ); // limpa buffer do teclado, funciona junto com entrada de dados
textcolor(LIGHTGREEN);
scanf( "%d", &consulta_chamada );
textcolor(WHITE);
pf = procura_nodo( consulta_chamada ); // procura chamado de referencia

if (( pf >= 0 ) && ( pf < fim_lista )){

printf("\n----------------------------------------------------------------------\n");
//IMPRIMI O REGISTRO CONSULTADO
printf("\n Numero da Chamada = %03d", registro[pf].num_chamado);
printf("\n\n Nome do Professor.............: %s", registro[pf].nome_professor);
printf("\n Data da Ocorrencia............: %s", registro[pf].data_ocorrencia);
printf("\n Laboratorio da Ocorrencia.....: %s", registro[pf].laboratorio);
printf("\n Identificacao do Computador...: %s", registro[pf].id_micro);
printf("\n Data Verificacao Tecnica......: %s", registro[pf].data_verificacao);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Descricao do Problema do Micro: %s", registro[pf].descricao_problema);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Comentario Tecnico............: %s\n\n\n", registro[pf].comentario_tecnico);

system("pause");
}
else{ //se não encontrar o registro
textcolor(LIGHTRED);
printf( "\n\n\n Numero da Chamada nao existe! \n\n" );
textcolor(WHITE);
system("pause");
}
}
else{
while(1){ //LABORATORIO DO REGISTRO A CONSULTAR
printf( " Laboratorio que deseja consultar [LAB1 ou LAB2]: ");
textcolor(LIGHTGREEN);
fflush(stdin);
gets(lab);
textcolor(WHITE);

for(i=0; i lab[i] = toupper(lab[i]);
}
if((lab[0]=='L') && (lab[1]=='A') && (lab[2]=='B') && (lab[3]=='1' || lab[3]=='2') && (strlen(lab)==4))
break;
}
printf("\n");
while(1){ //ID DO MICRO DO REGISTRO A CONSULTAR
printf( " ID do micro, do registro a ser consultado [ex.: F1-M1]: ");
textcolor(LIGHTGREEN);
fflush(stdin);
gets(consulta_id);
textcolor(WHITE);

for(i=0; i consulta_id[i] = toupper(consulta_id[i]);
}
if((consulta_id[0]=='F') && (consulta_id[1]>'0') && (consulta_id[1]<'6') && (consulta_id[2]=='-') && (consulta_id[3]=='M') && (consulta_id[4]>'0') && (consulta_id[4]<'6'))
break;
}


j=0;
vazio=0; //VERIFICAÇÃO SE REGISTRO A SER CONSULTADO EXISTE DENTRO DO LAB A SER CONSULTADO
while(j < fim_lista){
if( strcmp(lab, registro[j].laboratorio)==0){
if( strcmp(consulta_id, registro[j].id_micro)==0){

printf("\n----------------------------------------------------------------------\n");

printf("\n Numero do Chamado = %03d", registro[j].num_chamado);
printf("\n\n Nome do Professor.............: %s", registro[j].nome_professor);
printf("\n Data da Ocorrencia............: %s", registro[j].data_ocorrencia);
printf("\n Laboratorio da Ocorrencia.....: %s", registro[j].laboratorio);
printf("\n Identificacao do Computador...: %s", registro[j].id_micro);
printf("\n Data Verificacao Tecnica......: %s", registro[j].data_verificacao);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Descricao do Problema do Micro: %s", registro[j].descricao_problema);
printf("\n -------------------------------------------------------------------------------\n");
printf("\n Comentario Tecnico............: %s\n\n\n", registro[j].comentario_tecnico);

vazio=1;
}
}
j++;
}
if (vazio == 0){
textcolor(LIGHTRED); //SENÃO HOUVER O REGISTRO NO LAB PESQUISADO
printf( "\n\n\n Sem registros para o ID %s no laboratorio %s \n\n", consulta_id, lab);
textcolor(WHITE);
}
system("pause");
}
}
}

//****************************** ORDENAR_REGISTROS **********************************************//
// Rotina para ordenar registros,
// É utilizada sempre que usuario quiser ordenar os registros, ordena por numero do chamado
// só ordena se tiver no minimo 2 registros
//****************************************************************************************//

void Ordenar_Registros(){

int i, j;
ROL auxiliar;
char imprimi_registros;
if( fim_lista == 1 ){
textcolor(LIGHTRED);
printf( "\n\n\n Impossivel ordenar, somente 1 registro!\n\n" );
textcolor(WHITE);
system("pause");
}
else{
if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{ //ordena a lista
for( i=0; i for( j=i+1; j if( registro[i].num_chamado > registro[j].num_chamado){
auxiliar = registro[i];
registro[i] = registro[j];
registro[j] = auxiliar;
}
}
}
textcolor(YELLOW);
textbackground(BLUE);
printf("\n\n\n Ordenado com sucesso!");
textcolor(WHITE);
textbackground(BLACK);

do{ //verificação se usuario apos ordenar, deseja imprimir ordenado
printf("\n\n Deseja imprimir Registros Ordenados? [ S / N ]: ");
imprimi_registros = getche();
}while((toupper(imprimi_registros)!= 'S') && (toupper(imprimi_registros)!= 'N'));

if ( imprimi_registros == 'S' || imprimi_registros == 's' ){
textcolor(YELLOW);
printf("\n\n\n------------------------Registros Atuais Ordenados----------------------------");
textcolor(WHITE);
Imprimir_Todos_Registros();
}
}
}
}

//****************************** ALTERAR_REGISTRO **********************************************//
// Rotina para alterar registro,
// É utilizada sempre que usuario quiser alterar um registro
// só altera se tiver no minimo 1 registro
//****************************************************************************************//

void Alterar_Registro(){
int altera_registro, j, achou_registro=0;

if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{
printf("\n\n\n Informe o Numero da Chamada do registro a ser alterado: ");
textcolor(LIGHTGREEN);
scanf("%d",&altera_registro);
textcolor(WHITE);

for (j=0; j < fim_lista; j++){
//procura o registro a ser alterado, na lista de registros
if (altera_registro == registro[j].num_chamado){

printf("\n\n Nome do professor.............: %s", registro[j].nome_professor);
printf("\n Data da Ocorrencia............: %s", registro[j].data_ocorrencia);
printf("\n Laboratorio da Ocorrencia.....: %s", registro[j].laboratorio);
printf("\n Identificacao do Computador...: %s", registro[j].id_micro);
printf("\n Data Verificacao Tecnica......: %s", registro[j].data_verificacao);
printf("\n Descricao do Problema do Micro: %s", registro[j].descricao_problema);
printf("\n Comentario Tecnico............: %s\n\n\n\n", registro[j].comentario_tecnico);

coordenada_y = 20;
Le_Dados();
aux.num_chamado = altera_registro;
registro[j] = aux;
break; // com break o laço é finalizado nao testando os outros registros após já ter encontrado
}
}
if (achou_registro == 0){
system("cls");
textcolor(LIGHTRED);
printf("\n\n\n Numero de Chamada nao encontrado!\n\n");
textcolor(WHITE);
system("pause");
}
}
}

//****************************** PROCURA_POSIÇÃO_FISICA **********************************************//
// Rotina para procurar a posição de um registro,
//******************************************************************************************************//

int procura_nodo( int chamada ){
int i, pf=-1; // i= indice; pf= posicao fisica
for( i=0; i < fim_lista; i++ ){ // anda pela lista até o final ou até encontrar registro desejado
if( chamada == registro[i].num_chamado){
pf = i; // guarda posicao fisica
break;
}
}
return( pf ); // posicao fisica do registro de referencia
}


//****************************** EXCLUIR_REGISTRO **********************************************//
// Rotina para excluir registro(s),
// É utilizada sempre que usuario quiser excluir um ou todos registros
// só exclui se tiver no minimo 1 registro
//****************************************************************************************//
void Excluir_Registro(){
int i, exclui_num_chamado, pf=0;
char opcao, excluir_todos;
if( fim_lista == 0 ){
textcolor(LIGHTRED);
printf( "\n\n\n Lista de registros vazia!\n\n" );
textcolor(WHITE);
system("pause");
}
else{

do{ //MENU PARA EXCLUIR REGISTRO
system("cls");
printf("\n\n *** Excluir Registro(s) *** ");
printf("\n\n\n 1 - Excluir UM unico registro");
printf("\n 2 - Excluir TODOS registros");
printf("\n\n Informe a opcao desejada: ");
fflush(stdin);
opcao=getche();
if(opcao != '1' && opcao != '2'){
textcolor(LIGHTRED);
printf("\n\n Opcao invalida, somente 1 ou 2!");
textcolor(WHITE);
getch();
}
}while(opcao != '1' && opcao != '2');

if ( opcao == '1'){
//se for um registro a excluir, digitar o numero do chamado
printf( "\n\n\n Numero do Chamado, do registro a excluir: " );
textcolor(LIGHTGREEN);
fflush( stdin ); // limpa buffer do teclado, funciona junto com entrada de dados
scanf( "%d", &exclui_num_chamado );
textcolor(WHITE);
pf= procura_nodo( exclui_num_chamado ); // procura posição fisica do registro a excluir

if (( pf >= 0 ) && ( pf < fim_lista )){
for( i=pf; i registro[i] = registro[i+1];
} // fim for
fim_lista--; // decrementa o tamanho da lista

textcolor(YELLOW);
textbackground(BLUE);
printf("\n\n\n Excluido com sucesso!\n\n");
textcolor(WHITE);
textbackground(BLACK);
system("pause");
} // fim if
else{
textcolor(LIGHTRED);
printf( "\n\n\n Numero de Chamada nao existe!\n\n" );
textcolor(WHITE);
system("pause");
}
}
else{

do{ //se deseja excluir todos registros, tem averificação se não é engano
textcolor(LIGHTRED);
printf("\n\n\n\a Atencao!!! Deseja mesmo excluir todos registros? [ S / N ]: ");
textcolor(WHITE);
excluir_todos = getche();
}while((toupper(excluir_todos)!= 'S') && (toupper(excluir_todos)!= 'N'));

if ( excluir_todos == 'S' || excluir_todos == 's' ){
fim_lista = 0;
//numeracao_chamada = 1; //SE QUISER QUE OS NUMEROS DE CHAMADA DOS REGISTROS INICIEM APARTIR DO 1 NOVAMENTE É SÓ DESCOMENTAR ESTA LINHA
textcolor(YELLOW);
textbackground(BLUE);
printf("\n\n\n Registros excluidos com sucesso!\n\n");
textcolor(WHITE);
textbackground(BLACK);
system("pause");
}
}
}
}

//******************** ROTINA UTILIZADA ****************************************************//

/*void Reorganiza_numero_chamada(){

int i, j;
ROL auxiliar;


for( i=0; i for( j=i+1; j if( registro[i].num_chamado > registro[j].num_chamado){
auxiliar = registro[i];
registro[i] = registro[j];
registro[j] = auxiliar;
}
}
}

for ( i=0; i registro[i].num_chamada = i+1;
}

numeracao_chamada = fim_lista + 1;
} */

[/php]
200 problema descricao include imprimir parar campo fazer resolvido
Responder
Fergo
Fergo Highlander Registrado
9.3K Mensagens 1.1K Curtidas
#2 Por Fergo
26/10/2007 - 17:00
O código é ligeiramente grande, seria melhor indicar qual o lixo que está sendo impresso ou indicar mais ou menos a região do código onde ocorre o problema. Mas suspeito que seja a falta de um null-terminator (caractere "\0") no final de cada vetor de caracteres, verifique se é isso mesmo.

Fergo
Site pessoal ● www.fergonez.net
Portfolio ● www.fbirck.com
Artigos ● Informática
tpcvasco
tpcvasco General de Pijama Registrado
2.9K Mensagens 330 Curtidas
#3 Por tpcvasco
26/10/2007 - 17:05
No seu post, vc teve 1 acerto:
-Disse a linguagem
E vários erros no seu post:
-Não explicou oq seu código faz.
-Não identou seu códido com o uso da tag CODE
https://www.hardware.com.br/comunidade/codigo-postar/229032/
-Não "resumiu" seu código para mostrar onde provavelmente está o erro.
-A sua explicação para o erro q acontece é bem vaga... Seu código imprime lixo... Como assim, imprime na impressora, imprime na tela? Lixo? qual lixo? Oq vc quer dizer com lixo?

Assim fica difícil te ajudar.
"Milhouse: - Médicos e bombeiros são heróis.
Bart Simpson: - Olha, as casas continuam pegando fogo e as pessoas continuam doentes. Os verdadeiros heróis são os Schwarzenegger's, os Stallone's, e, em menores proporções, os Vandame's..."
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas
#4 Por ldm2005
26/10/2007 - 17:07
Fergo disse:
O código é ligeiramente grande, seria melhor indicar qual o lixo que está sendo impresso ou indicar mais ou menos a região do código onde ocorre o problema. Mas suspeito que seja a falta de um null-terminator (caractere "\0") no final de cada vetor de caracteres, verifique se é isso mesmo.

Fergo



Olá Fergo,

Quando insiro todos os campos do registro corretamente, inclusive no campo descrição do problema[200] e cometário técnico[200], se eu digitar uns 180 caracteres em cada um, quando mando imprimir, aparere, oque digitei no campo descrição do problema[200] e cometário técnico[200], também na linha dos outros campos.
cadeado_alegrinho.gif
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas
#5 Por ldm2005
26/10/2007 - 17:19
tpcvasco disse:
No seu post, vc teve 1 acerto:
-Disse a linguagem
E vários erros no seu post:
-Não explicou oq seu código faz.
-Não identou seu códido com o uso da tag CODE
https://www.hardware.com.br/comunidade/codigo-postar/229032/
-Não "resumiu" seu código para mostrar onde provavelmente está o erro.
-A sua explicação para o erro q acontece é bem vaga... Seu código imprime lixo... Como assim, imprime na impressora, imprime na tela? Lixo? qual lixo? Oq vc quer dizer com lixo?

Assim fica difícil te ajudar.



Foi mau, não sabia como identar!

imprimi na tela, lixo que digo é quando digito algo em um campo do programa e quando mando imprimir aparece o que digitei no campo correto e nos dos outros campos tbm.
cadeado_alegrinho.gif
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas
#6 Por ldm2005
26/10/2007 - 17:22
Fergo disse:
O código é ligeiramente grande, seria melhor indicar qual o lixo que está sendo impresso ou indicar mais ou menos a região do código onde ocorre o problema. Mas suspeito que seja a falta de um null-terminator (caractere "\0") no final de cada vetor de caracteres, verifique se é isso mesmo.

Fergo



como faço isso quando declaro as variaveis dentro de um typedef struct?

assim comentário[200]= {'\0'} se for já tentei e não compilou, deu erro, inicialização invalida..
cadeado_alegrinho.gif
FabianoTraple
FabianoTrapl... Veterano Registrado
1.2K Mensagens 17 Curtidas
#9 Por FabianoTrapl...
27/10/2007 - 13:08
ldm2005...

Essa é moleza, você está esquecendo de limpar o conteúdo da variável antes de gravar ou ler o arquivo !

Utilize o comando memset( NomeVariável, '\0', TamanhoVariável );

Tente ai !





memset( registro, '\0', (sizeof(struct ROL)*REG_MAX)  );


Coloque esse comando no inicio da função main, ele zerar toda o vetor da estrutura ROL e prencher com zero.
[email]umbrsuporte@hotmail.com[/email] bebi_demais.gif
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas
#10 Por ldm2005
27/10/2007 - 13:23
GBonzani disse:
Olá ldm2005,

primeiramente, o seu programa ta bem bonitinho =D

E não encontrei defeito algum aqui, rodou normal. Me diga, o que voce faz aí que imprime 'um monte de lixo'? Me diz que daí eu testo aqui.

Flw, abraço.




Olá GBonzani, obrigado pelo elogio, e tbm obrigado por me ajudar, afinal foi para este código que vc me ajudou nos outros posts.


Para vc testar, faça no minimo 3 registros, preenchendo todos campos, nos campos descreva o problema[200] e comentario técnico[200] preencha utilizando usando todos caracteres, depois de 3 registros mande imprimir todos, sempre aparece o que escrevi nos campos descreva o problema[200] e comentario técnico[200] nos outros campos do registro.

Bom, acho que já consertei lendo novamente um tópico q vc respondeu, para o char data eu tava declarando data[10], ou seja era [10] = DD/MM/AAAA, mas na real eu tinha que colocar data[11] para garantir o '\0' [11] = DD/MM/AAAA'\0' , depois que aumentei em 1 caracter cada declaração parou do imprimir lixo depois dos conteudos das minhas variaveis.

Mas por favor se puder testar para mim para ter certeza se erra isso.

Uma dúvida: ler variavel com gets(variavel), o gets tbm respeita a regra de colocar o '\0' no ultimo espaço do vetor de caracteres?

char data[11];
com gets tbm fica assim ou só com scanf

data[0] = 'D'
data[1] = 'D'
data[2] = ' / '
data[3] = 'M'
data[4] = 'M'
data[5] = ' / '
data[6] = 'A'
data[7] = 'A'
data[8] = 'A'
data[9] = 'A'
data[10] = '\0'


Obrigado por tudo!
cadeado_alegrinho.gif
ldm2005
ldm2005 Novo Membro Registrado
70 Mensagens 0 Curtidas
#11 Por ldm2005
27/10/2007 - 13:50
FabianoTraple disse:
ldm2005...

Essa é moleza, você está esquecendo de limpar o conteúdo da variável antes de gravar ou ler o arquivo !

Utilize o comando memset( NomeVariável, '\0', TamanhoVariável );

Tente ai !



 

memset( registro, '\0', (sizeof(struct ROL)*REG_MAX)  );


Coloque esse comando no inicio da função main, ele zerar toda o vetor da estrutura ROL e prencher com zero.



Olá Fabiano,

Deu este erro, " invalid application of `sizeof' to incomplete type `ROL' "

Me diz uma coisa, colocando no memset a struct ROL, estou inicializando todas variaveis de dentro da estrutura, e as variaveis que declaro depois dentro do código como tipo ROL tbm? todas são inicializada.
as variaveis de dentro da struct são inicializadas independente se são char ou int?


Obrigado
cadeado_alegrinho.gif
GBonzani
GBonzani Super Participante Registrado
509 Mensagens 11 Curtidas
#13 Por GBonzani
27/10/2007 - 16:09
Olá ldm2005.

ldm2005 disse:
Olá GBonzani, obrigado pelo elogio, e tbm obrigado por me ajudar, afinal foi para este código que vc me ajudou nos outros posts.


Voce se empenhou bastante nisso né? Mas o resultado ficou muito bom =D

ldm2005 disse:

Para vc testar, faça no minimo 3 registros, preenchendo todos campos, nos campos descreva o problema[200] e comentario técnico[200] preencha utilizando usando todos caracteres, depois de 3 registros mande imprimir todos, sempre aparece o que escrevi nos campos descreva o problema[200] e comentario técnico[200] nos outros campos do registro.


é isso meu amigo. Olha só : nem sempre o usuário terá uma descrição de problema e comentário ocupando os 200 chars do vetor. Porem, sempre tera um que ira 'entupir' seu vetor, então acho que seria legal dar uma espécie de folga pra ele. Algo do tipo:


scanf(" %199[^\n]", aux.descricao_problema);

Ou então declarar descricao_problema[201], por exemplo.

ldm2005 disse:

Bom, acho que já consertei lendo novamente um tópico q vc respondeu, para o char data eu tava declarando data[10], ou seja era [10] = DD/MM/AAAA, mas na real eu tinha que colocar data[11] para garantir o '\0' [11] = DD/MM/AAAA'\0' , depois que aumentei em 1 caracter cada declaração parou do imprimir lixo depois dos conteudos das minhas variaveis.

Mas por favor se puder testar para mim para ter certeza se erra isso.

Uma dúvida: ler variavel com gets(variavel), o gets tbm respeita a regra de colocar o '\0' no ultimo espaço do vetor de caracteres?

char data[11];
com gets tbm fica assim ou só com scanf

data[0] = 'D'
data[1] = 'D'
data[2] = ' / '
data[3] = 'M'
data[4] = 'M'
data[5] = ' / '
data[6] = 'A'
data[7] = 'A'
data[8] = 'A'
data[9] = 'A'
data[10] = '\0'


Sim isso vale para qualquer string, toda e qualquer string em C deve terminar em \0.

Da uma olhada nisso :


#include <stdio.h>

int main()

{

    char str[11];

    

    str[0] = 'O'; str[1] = 'L'; str[2] = 'A';

    str[3] = ' '; str[4] = 'l'; str[5] = 'd';    

    str[6] = 'm'; str[7] = '2'; str[8] = '0';

    str[9] = '0'; str[10] = '5';

         

    printf("Frase sem terminador '\\0' : %s", str);

    getchar();

    

    str[11] = '\0';

    printf("Frase com terminador '\\0' : %s", str);

    getchar();

}

Percebeu o 'lixo' ?

ldm2005 disse:

Obrigado por tudo!


Que é isso, tamo aew se precisar!

Abraço,
Gabriel.
tpcvasco
tpcvasco General de Pijama Registrado
2.9K Mensagens 330 Curtidas
#14 Por tpcvasco
29/10/2007 - 17:14
ldm2005 disse:

Uma dúvida: ler variavel com gets(variavel), o gets tbm respeita a regra de colocar o '\0' no ultimo espaço do vetor de caracteres?

char data[11];
com gets tbm fica assim ou só com scanf

data[0] = 'D'
data[1] = 'D'
data[2] = ' / '
data[3] = 'M'
data[4] = 'M'
data[5] = ' / '
data[6] = 'A'
data[7] = 'A'
data[8] = 'A'
data[9] = 'A'
data[10] = '\0'



Só um detalhe, o gets não é uma função mto confiável, pois se o usuário digitar mais caracteres do q o previsto, ela pega mais caracteres que o tamanho da sua string, oq pode interferir em outras variáveis do seu programa.
Mais detalhes sobre o assunto:
https://buildsecurityin.us-cert.gov/daisy/bsi/articles/knowledge/coding/300.html

O ideal é usar o fgets(), passando como parâmetro o número de caracteres da sua string e o stream de entrada:
fgets (data, strlen(data), stdin);
A diferença do fgets() para o gets() é q ela tb pega o ENTER q vc digita no final (o '\n'). Ou seja, uma string obtida com fgets() fica assim:

data[0] = 'D'
data[1] = 'D'
data[2] = ' / '
data[3] = 'M'
data[4] = 'M'
data[5] = ' / '
data[6] = 'A'
data[7] = 'A'
data[8] = 'A'
data[9] = 'A'
data[10] = '\n' //<-diferente!
data[11] = '\0'

Mas isso é fácil de se resolver, basta vc sempre colocar o código:
data[strlen(data)-1] = '\0';
Toda vez q chamar fgets().
"Milhouse: - Médicos e bombeiros são heróis.
Bart Simpson: - Olha, as casas continuam pegando fogo e as pessoas continuam doentes. Os verdadeiros heróis são os Schwarzenegger's, os Stallone's, e, em menores proporções, os Vandame's..."
Responder Tópico
© 1999-2024 Hardware.com.br. Todos os direitos reservados.
Imagem do Modal