Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.

vangodp

Membros Plenos
  • Total de itens

    1.028
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

361

7 Seguidores

Sobre vangodp

  • Data de Nascimento 16-02-1977

Informações gerais

  • Cidade e Estado
    Málaga/Espanã
  • Sexo
    Masculino
  1. ??
  2. Quando você criar um projeto serão criados 2 arquivos, um é o main.c ou cpp dependendo da linguagem, o outro é o arquivo de configuração. quando for abrir o projeto você deve fazer click com o mouse no arquivo de configuração em caso você fechar o arquivo e quiser continuar ele mais tarde. Ao fazer click no projeto a tela parece assim de cor cinza, mas no lado izquerdo você deveria ver algo como isso: aí estará seus arquivos... main.c/cpp, .h, .hpp, etc. É só fazer click no main(arquivo principal) que ele aparece na area de edição: Se esse painel lateral não abrir prove apertar control + F2. Para abrir a janelinha de avisos use somente F2. ctrl+F2 = gestor de projetos F2 = janela de logs Espero ter ajudado.
  3. pode usar o glutBitmapString em vez de glutBitmapCharacter. Só se estiver usando freeglut: Aqui um exemplo: http://www.programming-techniques.com/2012/05/font-rendering-in-glut-using-bitmap.html
  4. Prove ctrl+enter. Pelo menos no codeblocks é assim.
  5. Busque um bom tutorial/curso para opengl porque o tema é complexo. videos, livros, blogs.... As funções de C/C++ não servem para opengl. Sobre tudo as que são de entrada e saída padrão. Existem muitas formas de fazer o que você quer em opengl... buscar uma imagem com as letras e ir "cortando" quadrados em cima de cada letra para mostrar, pintar cada um dos pixels de uma letra, etc etc etc. Deve ter varias formas de fazer isso. Não é factível explicar tudo isso por aqui em poucas linhas. Precisa ser em 3d? Se puder er em 2d seria algo mais fácil com SFML.
  6. Basicamente você tem 2 erros. 1º Como falei você tem um \n em cada linha. O %*c impede que o \n entre no buffer e cause erros de leitura. No caso as linhas: fscanf(f, "%19[^\n]%*c", m.cd); fscanf(f, "%d", &m.excluido); ...deveriam estar: fscanf(f, "%19[^\n]%*c", m.cd); fscanf(f, "%d%*c", &m.excluido); ...com %*c depois do %d. Isso resolve parcialmente o problema, já que são 2, e já impede a copia de todos os elementos menos o ultimo, que é o segundo problema. Faça as mudanças e veja que agora só repete o ultimo numero. 2º você faz uso "indiscriminado" do feof, sem nem saber como funciona realmente. Sabe como atua feof? Certamente não como você acha. O feof averigua se a ultima leitura foi bem sucedida, e não se encontrou o fim do arquivo, como realmente foi bem sucedida a ultima leitura e gravou o ultimo elemento, o laço se repete uma vez mais(Bug!!), porém da segunda vez o programa não se comporta corretamente e falha quando chega na parte das 2 fscanfs comentadas no ponto anterior, ambas fscanfs vão chocar com o fim do arquivo, e não farão a leitura desta vez, porém é tarde de mais, você ja tinha lido os dados no passo anterior, e guardou os dados em "m", dai chega no if ( m.excluido == 0 ), mas como no m permanece os dados feito da leitura anterior, ele volta a entrar no if com esses dados uma vez mais, conclusão... o programa repete uma vez mais o frintf antes de sair imprimindo duas vezes a mesma linha no outro arquivo. Espero que tenha entendido... Qual a solução para o segundo problema??? Em vez de usar feof por que você não usa o proprio valor de retorno de fscanf para averiguar se chocou com o fim do arquivo???? Se você tentar ler com fscanf e chocar com o fim do arquivo, o fscanf retorna -1 que é o valor da macro EOF. Basicamente seu programa arrumado seria: #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct musica { char cd[20]; int excluido; } MUSICA; void insere ( FILE *f, MUSICA novo ) { fprintf ( f, "%s\n", novo.cd ); fprintf ( f, "%d\n", novo.excluido ); } MUSICA *buscaCD ( FILE *f, char cd[20], long *checkPoint, long *checkPoint2 ) { MUSICA *m = malloc ( sizeof ( MUSICA ) ); fseek ( f, SEEK_SET, 0 ); while ( !feof ( f ) ) { *checkPoint = ftell ( f ); fscanf ( f, "%19[^\n]%*c", m->cd ); *checkPoint2 = ftell ( f ); fscanf ( f, "%d", &m->excluido ); if ( strcmp ( m->cd, cd ) == 0 ) return m; } return NULL; } void altera ( FILE *f, char busca[20], MUSICA alterado ) { MUSICA *m; long checkPoint, checkPoint2; m = buscaCD ( f, busca, &checkPoint, &checkPoint2 ); fseek ( f, checkPoint, 0 ); if ( m != NULL ) { fprintf ( f, "%s\n", alterado.cd ); fprintf ( f, "%d\n", alterado.excluido ); printf ( "\nRegistro alterado!" ); } else printf ( "\nRegistro inexistente!" ); } void exclui ( FILE *f, char busca[20] ) { MUSICA *m; long checkPoint, checkPoint2; m = buscaCD ( f, busca, &checkPoint, &checkPoint2 ); fseek ( f, checkPoint2, 0 ); if ( m != NULL && m->excluido == 0 ) { fprintf ( f, "%d\n", 1 ); printf ( "\nRegistro apagado!" ); } else printf ( "\nRegistro inexistente!" ); } void reorganiza ( FILE *f ) { MUSICA m; FILE *g = fopen ( "auxx.txt", "w+" ); fseek ( f, SEEK_SET, 0 ); while ( fscanf ( f, "%19[^\n]%*c %d%*c", m.cd, &m.excluido ) != EOF ) { //escanea o arquivo... se topar com o fim do arquivo não lê nada, e retorna EOF(-1) que significa que não há mais nada para ler evitando entrar 2 vezes ao final. if ( m.excluido == 0 ) { fprintf ( g, "%s\n", m.cd ); fprintf ( g, "%d\n", m.excluido ); } } fclose ( g ); } int main() { FILE *f = fopen ( "arq.txt", "w+" ); MUSICA novo; MUSICA *busca; strcpy ( novo.cd, "CD 123" ); novo.excluido = 0; insere ( f, novo ); strcpy ( novo.cd, "CD 456" ); novo.excluido = 0; insere ( f, novo ); strcpy ( novo.cd, "CD 789" ); novo.excluido = 0; insere ( f, novo ); long checkPoint, checkPoint2; busca = buscaCD ( f, "CD 123", &checkPoint, &checkPoint2 ); if ( busca != NULL ) { printf ( "Achou: %s", busca->cd ); } else { printf ( "Não achou!" ); } busca = buscaCD ( f, "CD 111", &checkPoint, &checkPoint2 ); if ( busca != NULL ) { printf ( "\nAchou: %s", busca->cd ); } else { printf ( "\nNão achou!" ); } strcpy ( novo.cd, "CD 666" ); novo.excluido = 0; altera ( f, "CD 123", novo ); strcpy ( novo.cd, "CD 777" ); novo.excluido = 0; altera ( f, "CD 111", novo ); exclui ( f, "CD 456" ); exclui ( f, "CD 456" ); reorganiza ( f ); fclose ( f ); return 0; } Capiche? >_< Tem que praticar muito com arquivos ou podem lhe "sodomizar". Em vez de usar feof procure usar o próprio valor de retorno das funções que você usa para ler o arquivo, tanto fread como fscanf retornam valores ao chocar com o fim do arquivo. SÃO FUNÇÕES lembra?. Funções retornam valores!!! Procure conhecer esses valores. E não digo que conheça somente o valor de retorno de fscanf... si não que de todas as funções que usas, esses valores posso lhe assegurar que são mágicos hsueshehusehu.
  7. com a função quando você vai fazer a busca em um arquivo é óbvio que você tem que começar desde a primeira letra, já seja usando rewind, ou abrindo o ponteiro em modo leitura, seja como seja confio que isso não seja um problema para você. Com a função que lhe indiquei, supondo que você começa do inicio, se no seu arquivo você tiver algo como: CD 123 CD 456 CD 789 na realidade seu arquivo é assim: CD 123\n CD 456\n CD 789\n -1 Só que na realidade os \n e o -1 você não vê pois são caracteres não imprimíveis realizam ações em vez de mostrar aparência. Antes de nada quero esclarecer alguns pontos. 1º Que é realmente n\? Resposta: O caractere n\ todo mundo sabe que é um salto de linha, mas o que poucos sabem é que ele em realidade é que ele atua de diferentes formas dependendo do sistema operativo no qual você está. Em Linux por exemplo n\ ocupa um byte pois na tabela asc2 ele é o elemento lf(Linux format), ocupa a posição 10 da tabela asc2: ...Por tanto lf é um char igual que 'a', 'b' ou ' '(espaço). porém quando estamos no windows a coisa muda, pois neste caso \n é formado pela união de 2 caracteres, o char numero 13+ o char numero 10(cr+lf), isso é o que é realmente \n(n\ == cr+lf) e agora vou demonstrar. Se vamos no codeblocks ou qualquer editor algo mais avançado que o notepad >_<, temos uma opção com um nome parecido a "mostrar EOF chars" (sow end-of-file chars), no meu caso no codeblocks em opções do editor, podemos ativar para visualizar o \n como ele é realmente: como você pode ver a partir do momento que ativamos essa opção vemos os caracteres "ocultos" que estão no fim da linha como podemos ver na seguinte imagem: Pode tomar como cr+lf representa \n(enter) que faz o salto de linha. Beleza? Por que to mostrando tudo isso? Por que você pode averiguar que no seu arquivo você tem em cada linha isso "CD 123\n" porém \n equivale a 2 chars, contando com o espaço e tudo em cada linha você tem 8 chars. Três vezes oito é igual vinte e quatro(24), esse é o tamanho em bytes que tem seu arquivo, e vamos averiguar. Faça a prova. Tenha claro que \n em linux ocupa 1 byte e em windows 2 como acabo de demonstrar. Beleza... Continuando onde estávamos antes, ao iniciar uma consulta você inicia ao principio do arquivo isso quer dizer que seu ponteiro está situado aqui: Quando fazemos uma leitura com fscanf(f,"%19[^\n]%*c", m->cd)... na parte "%19[^\n]" o ponteiro para aqui: justo depois do lf, pero na realidade crlf é na linha seguinte, então você ta no inicio da 2º linha como na imagem abaixo: O %*c evita que o ultimo char(cr+lf) entre na string. Que podemos perceber com isso tudo??? Que quando fazemos a leitura avançamos até a seguinte linha!!! Dah!!! porém quando isso acontece ja passamos do ponto no qual queriamos alterar se supostamente queria alterar "CD 123" pois agora me encontro na linha de abaixo. Agora a grande pergunta.... Como arrumamos isso? Isso é o que você quer saber certo??? Bom, certamente você já deve saber que existe uma função que permitem fazer uma espécie de "check point" da posição atual do ponteiro, to falando da função ftell que retorna um long int, que nada mais é que o numero de caracteres que existe desde o inicio do arquivo. Se eu ler fscanf(f,"%19[^\n]%*c", m->cd) ...me adianto 8 bytes me situando no inicio da segunda linha mas se o que eu queria era o que estava na seguinte linha então teria que voltar atrás, poderia usar rewind, mas se o que quero estiver em outras linhas então não serve, tenho que voltar ao inicio da ultima linha que foi lida e não do arquivo. Para isso basta usar long int checkPoint=ftell (f) e logo depois fazer a leitura com fscanf(f,"%19[^\n]%*c", m->cd). Neste caso depois de fazer a leitura com fscanf e comparar para ver se são os dados que andamos buscando é tão fácil voltar ao inicio da linha como fazer o seguinte: fseek(f, checkPoint, SEEK_SET); Quer dizer que antes de fazer a leitura com fscanf eu guardei em que posição em bytes com ftell, e guardei na variável checkpoint, logo usei o checkpoint como parâmetro da função fseek para "voltar" atrás. Então os passos são: 1) Antes de fazer a leitura de uma linha guardar a posição do ponteiro com ftell 2) Ler a linha e fazer comprovações para saber se é o que andas buscando. 3) Se encontrou o que anda buscando usa o fseek com o valor que lhe retornou ftell antes de fazer a leitura, assim você voltará atrás no tempo. >_< Se tiver duvidas pergunte, isso já esta grande de mais para continuar escrevendo. Espero ter ajudado. http://www.cplusplus.com/reference/cstdio/ftell/ http://www.cplusplus.com/reference/cstdio/fseek/
  8. le no maximo 19 chars deixando espaço para o nulo. O programa lê uma string de máximo 19 chars até encontrar o \n(enter), e o especificador %*c ignora esse enter para que não entre na string e cause erros. Resumindo lê a linha completa ignorando espaços e o enter e não ultrapassa a 19 chars. adicionado 2 minutos depois Se na linha tem 5 chars somente serão lidos 5 chars, se na linhativer 400 chars, somente será lido 19 e o null(\0) será inserido ao final da string. adicionado 4 minutos depois %*c é o contrario de %c... Se %c lê um char, %*c ignora um char. Igual existe %*s, %*d, etc
  9. verá... a função fread não é a proposta mais acertada para fazer a leitura neste caso. Isso é assim por que você está lendo sizeof(MUSICA) bytes desde o arquivo porém cada linha tem menos de sizeof(MUSICA) bytes. Para deixar mais claro a "situechion" o que está acontecendo é que sizeof(MUSICA) exatamente tem o tamanho do que tem dentro, e dentro tem 20 chars(bytes), ou seja você ta mandando o programa ler 20 bytes até encontrar feof, isso se traduz em um bug danado. No lugar de tentar ler com fread o mais acertado seria ler com fscanf por exemplo. #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct musica { char cd[20]; } MUSICA; void insere(FILE *f, MUSICA novo) { fprintf(f, "%s\n", novo.cd); } MUSICA *buscaCD(FILE *f, char cd[20]) { MUSICA *m = malloc(sizeof(MUSICA)); fseek(f, SEEK_SET, 0); while (!feof(f)) { //fread(m, sizeof(MUSICA), 1, f); fscanf(f,"%19[^\n]%*c", m->cd); //para comprovaçoes //printf("\n\n***%s***\n", m->cd); //getchar(); if (strcmp(m->cd, cd) == 0) return m; } return NULL; } void altera(FILE *f, char busca[20], MUSICA alterado) { int ok = 0; MUSICA *m = malloc(sizeof(MUSICA)); fseek(f, SEEK_SET, 0); while (!feof(f) && ok == 0) { fread(m, sizeof(MUSICA), 1, f); if (!strcmp(m->cd, busca)) { ok = 1; fwrite(m, sizeof(MUSICA), 1, f); fclose(f); } } } int main() { FILE *f = fopen("arq.txt", "w+"); MUSICA novo; MUSICA *busca; strcpy(novo.cd, "CD 123"); insere(f, novo); strcpy(novo.cd, "CD 456"); insere(f, novo); strcpy(novo.cd, "CD 789"); insere(f, novo); rewind(f); char procura[20]; strcpy(procura, "CD 123"); busca = buscaCD(f, procura); if (busca != NULL) { printf("Achou: %s", busca->cd); } else { printf("Não achou!"); } busca = buscaCD(f, "CD 111"); if (busca != NULL) { printf("\nAchou: %s", busca->cd); } else { printf("\nNão achou!"); } rewind(f); strcpy(procura, "CD 123"); strcpy(novo.cd, "CD 666"); altera(f, procura, novo); free(busca); fclose(f); return 0; } Alterei somente a função de busca... agora toca você arrumar o resto. ok doc?
  10. O que tem nesse for é isso "XXX insira o valor de %d em palavras: XXX", mas você está achando que nós sabemos o que você vai escrever. De exemplos de entrada para ficar mais claro Como assim retornar em palavras? Se o que eu imagino for certo você quer receber algo como "vinte dois" e depois "um"e você quer isso: vetor[1] = 22. Mas primeiro que os números são infinitos, ou você tem um range de valores "pequeno" para trabalhar. Como digo fico trabalhando em cima de suposições porque não conheço suas ideias. você não postou o enunciado do problema.
  11. Use o botão <> para postar o código
  12. Sua forma de explicar é complicada vei. Da para reformular a pergunta não?
  13. Faltaria dizer que o processo de passar uma matriz é ligeiramente distinto ao de passar um vetor. Ao passar v, como no exemplo de isrnick, para a função teste, você realmente está passando um ponteiro. É possível averiguar o anterior dito fazendo printf("%d\n", v), tanto como printf("%d", &(v[0][0])), o que será impresso é a direção do primeiro elemento da matriz(mesmo resultado). Que quer dizer isso...? Que realmente nunca se passa uma copia e sim uma referencia! Existem algumas formas de passar uma cópia de uma matriz... como por exemplo enviando a matriz dentro de uma estrutura, mas realmente é mais bem como fazer uma gambiarra. Se pensamos um pouco passar uma matriz no ponto de vista da eficiência é algo sem sentido, pois matrizes podem ser grandes volumes de dados, passar uma matriz GIGANTE por copia faria com que seu programa ficasse lento e ocupasse muita memória, para isso é melhor trabalhar com referencia. Certo?! Pense... Realmente você precisa passar uma matriz por cópia? Certamente não. >_< No seu exemplo você está esperando uma matriz de ponteiros a boleanos. Para você fazer uma ideia é como se dentro de main você tentar fazer isso: bool b1 = true; bool b2 = false; bool *v[2][2]; v[0][0] = &b1; v[0][1] = &b2; ... Um pouco sem sentido não é?
  14. Apenas sei nada de win API. Somente uso SFML para jogos.
  15. uma vez salvado todo o arquivo https://en.wikipedia.org/wiki/Email_address em um arquivo txt e renomeá-lo a "Entrada.txt", ao abrir esse arquivo com o notepad++ e selecionar todo o texto, deu como quantidade de caracteres um total de 123.081 caracteres como você pode averiguar na imagem: coisa que coincide mais ou menos com o tamanho do arquivo: 120KB == 120 mil bytes +/- Depois de fazer umas pequenas modificaçoes no seu código tais como usar memória dinâmica para reservar uns 150KB mais ou menos fiz com que todo o arquivo se carregue na string char *caracteres = (char*)malloc( sizeof(char)*150000 ). Provavelmente agora você seja capaz de continuar desde aqui. Se precisar de ajuda pergunte. Na sua imagem fiquei com duvida sobre que caractere é esse aqui: Parece ser uma arroba, mas tem pinta de u O.o adicionado 0 minutos depois #include <stdio.h> #include <stdlib.h> #include <string.h> #define NMAX 76959 //caracteres aceitos que são do tipo letra, num, ponto, traço, @ int SelecionaSimbolosValidos ( char Simbolo ); void qInicial ( char Simbolo[NMAX] ); void q0 ( int contador, char Simbolo[NMAX] ); void q1 ( int contador, char Simbolo[NMAX] ); void q2 ( int contador, char Simbolo[NMAX] ); void q3 ( int contador, char Simbolo[NMAX] ); void q4 ( int contador, char Simbolo[NMAX] ); void q5 ( int contador, char Simbolo[NMAX] ); void q6 ( int contador, char Simbolo[NMAX] ); void q7 ( int contador, char Simbolo[NMAX] ); void q8 ( int contador, char Simbolo[NMAX] ); void q9 ( int contador, char Simbolo[NMAX] ); void q10 ( int contador, char Simbolo[NMAX] ); void q11 ( int contador, char Simbolo[NMAX] ); void qErro ( int Contador, char Simbolo[NMAX] ); int SelecionaSimbolosValidos ( char Simbolo ){ if (( Simbolo >= 'a' && Simbolo <= 'z' ) || ( Simbolo >= 'A' && Simbolo <= 'Z' ) || Simbolo == '@' || Simbolo == '-' || Simbolo == '.' || ( Simbolo >= '0' && Simbolo <= '9' ) ){ return 1; } return 0; } void qInicial ( char Simbolo[NMAX] ) { int contador = 0; q0 ( contador, Simbolo ); } void q0 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) ) { printf ( "%c", Simbolo[contador] ); q1 ( ++contador, Simbolo ); } /*else qErro(contador, Simbolo);*/ } } void q1 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q2 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '@' ) { printf ( "%c", Simbolo[contador] ); q3 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '-' ) { printf ( "%c", Simbolo[contador] ); q4 ( ++contador, Simbolo ); } /*else qErro(++contador, Simbolo);*/ } } void q2 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q2 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '@' ) { printf ( "%c", Simbolo[contador] ); q3 ( ++contador, Simbolo ); } else { q0 ( contador, Simbolo ); } /* else qErro(contador, Simbolo); */ } } void q3 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q10 ( ++contador, Simbolo ); } else if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) ) { printf ( "%c", Simbolo[contador] ); q11 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q4 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q5 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q5 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q5 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '@' ) { printf ( "%c", Simbolo[contador] ); q3 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '-' ) { printf ( "%c", Simbolo[contador] ); q4 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q6 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q7 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q7 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q7 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '-' ) { printf ( "%c", Simbolo[contador] ); q8 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '@' ) { printf ( "%c", Simbolo[contador] ); q3 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q8 ( int contador, char Simbolo[NMAX] ){ if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q9 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q9 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q9 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '@' ) { printf ( "%c", Simbolo[contador] ); q3 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '-' ) { printf ( "%c", Simbolo[contador] ); q8 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q10 ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) || Simbolo[contador] == '-' ) { printf ( "%c", Simbolo[contador] ); q10 ( ++contador, Simbolo ); } else if ( Simbolo[contador] == '.' ) { printf ( "%c", Simbolo[contador] ); q11 ( ++contador, Simbolo ); }/* else qErro(contador, Simbolo);*/ } } void q11 ( int contador, char Simbolo[NMAX] ){ if ( contador < NMAX ) { if ( ( Simbolo[contador] >= 'a' && Simbolo[contador] <= 'z' ) || ( Simbolo[contador] >= 'A' && Simbolo[contador] <= 'Z' ) || ( Simbolo[contador] >= '0' && Simbolo[contador] <= '9' ) ) { printf ( "%c", Simbolo[contador] ); q11 ( ++contador, Simbolo ); } }else qErro ( contador, Simbolo ); } void qErro ( int contador, char Simbolo[NMAX] ) { if ( contador < NMAX ) q0 ( ++contador, Simbolo ); else exit ( 1 ); } int main() { int i = 0; int teste_validacao; int tamanho = 0; //char caracteres[NMAX]; char *caracteres = (char*)malloc( sizeof(char)*150000 ); int caracter; FILE *arquivo; arquivo = fopen ( "Entrada.txt", "r" ); if ( arquivo == NULL ){ perror("Erro: "); return EXIT_FAILURE; } while ( !feof ( arquivo ) ){ caracter = getc ( arquivo ); teste_validacao = SelecionaSimbolosValidos ( caracter ); if ( teste_validacao == 1 ) { caracteres[i] = (char)caracter; i++; tamanho++; } } printf("%s", caracteres); //qInicial ( caracteres ); /*int j; for(j = 0; j < tamanho; j++) printf("%c", caracteres[j]); printf("\nnumCaracteresValidos: %d\n", tamanho); */ fclose ( arquivo ); free(caracteres); return 0; }

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações 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

×