Pesquisar na Comunidade

Este programa escolhe automaticamente as posições de uma matriz para receber caracteres pela entrada de dados, isto mesmo, o computador é quem faz a escolha da posição da matriz que irá receber o caractere digitado pelo usuário, imagine o quanto é útil este programa, para quem gosta de programar jogos, precisa muito destes tipos de recursos, temos muitas vêzes de deixar o computador fazer determinadas operações. https://www.youtube.com/watch?v=YMgVN6dZEe4

Já vi muitos iniciantes em c perguntando como criar um programa para fazer sorteios de um nome dentro de uma matriz aleatoriamente e sem repetições dos mesmos. Sortear apenas um nome entre dez aleatoriamente não seria tão complicado, agora fazer sorteio de todos os dez nomes um por um sem repetir nenhum, já é algo mais difícil, e é isto que faz este programa, que após escolher todos os nomes em modo aleatório, imprime em outra matriz a formação modificada. https://www.youtube.com/watch?v=6HP5g3lKkRM

Meu código para um programa de paciência está apresentando os seguintes erros: C:\Users\Pc\Documents\CS350B\teste.cpp In function 'Informacao* novaInformacao(int, int)': 47 35 C:\Users\Pc\Documents\CS350B\teste.cpp [Error] invalid conversion from 'void*' to 'Informacao*' [-fpermissive] C:\Users\Pc\Documents\CS350B\teste.cpp In function 'void inicializaPaciencia()': 421 40 C:\Users\Pc\Documents\CS350B\teste.cpp [Error] invalid conversion from 'void*' to 'Informacao**' [-fpermissive] alguém poderia me ajudar? Segue o Codigo do programa: #include <stdio.h> #include <stdlib.h> #include <time.h> /* Pilha, marca o comeco e o fim da pilha num vetor */ typedef struct { int comeco; int ocultas; /* marcas as cartas ocultas, ajuda na hora de ver o comeco e o fim das cartas não ocultas */ int fim; /* algumas flags para as pilhas, ajudam na hora de ficar fazendo procura de jogadas */ int podeEntrar; /* diz se existe algum monte na pilha de jogo pode ou não entrar nessa pilha */ int podeSair; /* diz se esse monte pode entrar ou não em alguma pilha de jogo ou pilha final */ } Pilha; /* minha definicao de carta: * um inteiro, entre 0 e 51 * para saber o simbola da carta c (valor) basta pegar (c%13 + 1) * onde 1 representa A, 2 = 2 ... 10 = 10 , 11 = J, 12 = Q, 13 = K * para saber o naipe da carta c basta pegar c/13 * onde 0 = ouro, 1 = espada, 2 = copas, 3 = paus * * Vantagens dessa organizacao: * * Saber se as cartas a e b são da mesma cor * (a/13)%2 == (b/13)%2 * * Saber se a carta a pode ser colocada em acima da carta b, na pilha de jogo * ser um simbolo a menos e cor diferente * (a%13 == (b%13 -1)) && (a/13)%2 != (b/13)%2 */ /* Carta é um inteiro, apenas a posicao do meu vetor onde está suas informacoes */ typedef int Carta; /* estrutura que contem informacao sobre a carta */ typedef struct { int valor; /* valor da carta, descrito acima */ int virada; /* se 1, a carta ta virada, se 0 a carta não pode ser vista pelo jogador */ Pilha *pilha; /* ponteiro para a pilha que a carta pertence */ } Informacao; Informacao *novaInformacao(int valor, int virada) { Informacao *i = malloc(sizeof*i); i->valor = valor; i->virada = virada; i->pilha = NULL; return i; } Informacao **baralho; /* um vetor de ponteiros para Informacao é o meu baralho */ /* para facilitar algumas coisas no programa, * vou deixar as estruturas de pilhas e o vetor * como variaveis globais */ Pilha pilhaJogo[7]; /* Como não é permitido tirar cartas da pilha de saida, * para deixar mais rapido, vou deixa-los todos numa unica pilha * e guardar apenas quem foi o ultimo colocado de cada naipe */ Pilha pilhaSaida; int podeSaida[4]; /* diz se o cara da saida pode receber cartas */ int ultimoSaida[4]; /* diz a ultima carta da saida */ /* Para quem já jogou paciencia, * é intuitivo que as pilhas de estoque e de descarte * são as que ficam maiores durante o jogo. * Como o espaco para todas as pilhas é apenas de 60, tudo junto * faz sentido querer alterar as pilhas de estoque e de descarta a * menor quantidade de vezes possiveis, então vou colocalas nas pontas * ou seja, a pilha de descarte vai sempre terminar no 0 * e a pilha de estoque no 59. * Olhando de outra menira, se a pilha de descarte termina em n, * e a pilha de estoque termina em m * eu vou organizar as outras pilhas entre n+1 e m-1 */ Pilha estoqueDescarte; /* estoque e descarta */ /* assinaturas de algumas funcoes uteis */ /* responde se pode mover uma carta, para uma pilha */ int podeMoverCarta(Carta carta, Pilha b); /* responde se pode mover a pilha a, para a pilha b */ int podeMoverPilha(Pilha a, Pilha b); /* procura no no Topo de uma pilha de jogo a carta de valor dado */ int procuraTopo(int valor, Pilha pilha); /* responde se a carta pode ser colocada no topo ou não */ int podeSair(int valor); /* coloca a ultima carta de uma Pilha de Jogo numa das pilhas finais */ void mudaFinal(Pilha *pilha); /* coloca uma pilha na outra */ void movePilha(Pilha *a, Pilha *b); /* coloca uma carta em uma determinada posicao do baralho */ void moveCarta(Informacao *carta, int posicao, int meio); /* move da pilha de descarta para a pilha de Saida */ void moveSairDescarte(); /* pega uma carta da pilha de estoque e coloca na pilha de descarte */ void pescaGrimorio(); /* imprime o jogo */ void imprimeJogo(); /* imprime a pilha de Estoque e de Descarte */ void imprimeEstoqueDescarta(); /* inicializa o jogo */ void inicializaPaciencia(); /* imprime uma pilha */ void imprimePilha(Pilha pilha); /* imprime uma pilha de saida */ void imprimeSaida(int pilha); /* imprime uma carta */ void imprimeCarta(int valor, int virada); /* responde se pode mover uma carta, para uma pilha */ int podeMoverCarta(Carta carta, Pilha b) { Carta topoB = b.fim - 1; int va = baralho[carta]->valor, vb ; /* se for um reis */ if(baralho[carta]->valor%13 == 12) { /* se b estiver vazio pode mover um Reis */ if(b.comeco == b.fim) return 1; return 0; } /* se b estiver vazia não pode */ if(b.comeco == b.fim) return 0; vb = baralho[topoB]->valor; /* verifica se a carta pode ir em b */ if(va%13 == (vb%13-1) && (va/13)%2 != (vb/13)%2) return 1; return 0; } /* responde se pode mover a pilha a, para a pilha b */ int podeMoverPilha(Pilha a, Pilha b) { Carta comecoA = a.comeco + a.ocultas; /* comeco de A despresando as cartas ocultas */ /* se a pilha a estiver vazia, ela não pode ser movida pra lugar nenhum */ if(a.comeco == a.fim) return 0; /* se for um reis */ if(baralho[comecoA]->valor%13 == 12 && a.comeco == comecoA) { /* não faz sentido removar o Reis de A e deixar o A vazio */ return 0; } return podeMoverCarta(comecoA, b); } /* procura no no Topo de uma pilha de jogo a carta de valor dado */ int procuraTopo(int valor, Pilha pilha) { Carta topo = pilha.fim - 1; /* se a pilha estiver vazia, a carta não está nela */ if(pilha.comeco == pilha.fim) return 0; return baralho[topo]->valor == valor; } /* responde se a carta pode ser colocada no topo ou não */ int podeSair(int valor) { int naipe = valor/13; if(ultimoSaida[naipe] == valor%13) return 1; return 0; } /* coloca a ultima carta de uma Pilha de Jogo numa das pilhas finais */ void mudaFinal(Pilha *pilha) { Carta topo = pilha->fim -1; baralho[topo]->pilha = &pilhaSaida; pilha->fim--; ultimoSaida[(baralho[topo]->valor)/13]++; if(ultimoSaida[(baralho[topo]->valor)/13] != 13) podeSaida[(baralho[topo]->valor)/13] = 1; /* como mudei o topo da pilha, eu digo que agora alguém pode entrar */ else podeSaida[(baralho[topo]->valor)/13] = 0; /* se chegou um reis, não pode entrar mais aqui */ /* se não tem mais cartas mostradas na pilha e ainda tem cartas na pilha*/ if(pilha->fim == (pilha->comeco + pilha->ocultas) && pilha->fim != pilha->comeco) { pilha->ocultas--; topo = pilha->fim -1; baralho[topo]->virada = 1; } } int procuraVazio() { int i; for(i=0;i<60;i++) if(baralho==NULL) break; return i; } /* coloca uma pilha na outra */ void movePilha(Pilha *a, Pilha *b) { Pilha auxiliar; int i, vazio; auxiliar.fim = a->fim; auxiliar.comeco = a->comeco + a->ocultas; a->fim = a->comeco + a->ocultas; if(a->ocultas) { baralho[a->comeco + a->ocultas]->virada = 1; a->ocultas--; } for(i=auxiliar.comeco;i<auxiliar.fim;i++) { baralho->pilha = &auxiliar; } for(i=auxiliar.fim-1;i>=auxiliar.comeco;i--) { Informacao *carta = baralho; baralho = NULL; carta->pilha = b; /* caso b seja vazio */ if(b->fim == b->comeco) { vazio = procuraVazio(); b->fim = vazio + 1; b->comeco = vazio; b->ocultas = 0; baralho[vazio] = carta; continue; } moveCarta(carta, b->fim, 1); } b->podeEntrar = a->podeEntrar; b->podeSair = a->podeSair || b->podeSair; a->podeEntrar = 1; a->podeSair = 1; } /* coloca uma carta em uma determinada posicao do baralho */ void moveCarta(Informacao *carta, int posicao, int meio) { Informacao *proxima; int mesmaPilha, proximaPosicao = posicao + 1; if(posicao == estoqueDescarte.comeco) { moveCarta(carta, estoqueDescarte.fim, meio); return; } if(carta->pilha==&pilhaSaida) { posicao = procuraVazio(); baralho[posicao] = carta; return; } carta->pilha->fim = posicao+1; /* lugar vago */ if(baralho[posicao]==NULL) { baralho[posicao]=carta; return; } else { mesmaPilha = baralho[posicao]->pilha == carta->pilha; proxima = baralho[posicao]; imprimeCarta(proxima->valor, 1); if(!mesmaPilha) { proxima->pilha->comeco = proximaPosicao; } baralho[posicao] = carta; moveCarta(proxima, proximaPosicao, mesmaPilha); } } /* move da pilha de descarta para a pilha de Saida */ void moveSairDescarte() { int valor = baralho[estoqueDescarte.fim -1]->valor; baralho[estoqueDescarte.fim -1]->pilha = &pilhaSaida; ultimoSaida[valor/13]+=1; podeSaida[valor/13]=1; estoqueDescarte.fim--; } /* pega uma carta da pilha de estoque e coloca na pilha de descarte */ void pescaGrimorio() { Informacao *carta = baralho[estoqueDescarte.fim]; /* ver se tem carta pra pescar */ if(estoqueDescarte.comeco == 59) return; baralho[estoqueDescarte.fim] = baralho[estoqueDescarte.comeco + 1]; baralho[estoqueDescarte.fim]->virada = 1; baralho[estoqueDescarte.comeco + 1] = NULL; if(carta!=NULL) { if(baralho[estoqueDescarte.comeco-1]==NULL || baralho[estoqueDescarte.comeco-1]->pilha != carta->pilha) { carta->pilha->comeco = estoqueDescarte.fim +1; } imprimeCarta(carta->valor, 1); moveCarta(carta, estoqueDescarte.fim + 1, 1); } estoqueDescarte.fim++; estoqueDescarte.comeco++; } /* imprime o jogo */ void imprimeJogo() { int i; printf("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\n"); imprimeEstoqueDescarta(); printf("\nPilhas de Jogo\n"); for(i=0;i<7;i++) { printf("%d : ",i+1); imprimePilha(pilhaJogo); } printf("\nPilhas de Saida\n"); for(i=0;i<4;i++) { imprimeSaida(i); } printf("--\n"); } /* imprime a pilha de Estoque e de Descarte */ void imprimeEstoqueDescarta() { int i; printf("Pilha de Estoque\n"); for(i=59;i>estoqueDescarte.comeco;i--) { imprimeCarta(baralho->valor, baralho->virada); printf(" "); } printf("\n\n"); printf("Pilha de Descarte\n"); for(i=0;i<estoqueDescarte.fim;i++) { imprimeCarta(baralho->valor, baralho->virada); printf(" "); } printf("\n\n"); } /* imprime uma pilha */ void imprimePilha(Pilha pilha) { int i; for(i=pilha.comeco;i<pilha.fim;i++) { imprimeCarta(baralho->valor, baralho->virada); printf(" "); } printf("\n"); } /* imprime uma pilha de saida */ void imprimeSaida(int pilha) { int i; for(i=0;i<ultimoSaida[pilha];i++) { imprimeCarta(pilha*13 + i, 1); printf(" "); } printf("\n"); } /* imprime uma carta */ char getNaipe(int valor) { if(valor/13 == 0) return 'O'; if(valor/13 == 1) return 'E'; if(valor/13 == 2) return 'C'; return 'P'; } void imprimeCarta(int valor, int virada) { printf("[%2d%c %c]",valor%13+1, getNaipe(valor), virada ? ' ' : 'X'); } void atualizaPilha(int pi, int pf, int pilha) { for(;pi<=pf;pi++) { baralho[pi]->pilha = &pilhaJogo[pilha]; } } /* inicializa o jogo */ void inicializaPaciencia() { int cartas[52], i, pos, aux; for(i=0;i<52;i++) /* incializando */ cartas = i; /* embaralhando */ for(i=0;i<51;i++) { pos = i + rand()%(52 - i); aux = cartas; cartas = cartas[pos]; cartas[pos] = aux; } baralho = malloc(60*(sizeof*baralho)); for(i=1;i<=52;i++) { baralho[60 - i] = novaInformacao(cartas[i-1], 0); } for(;i<=60;i++) baralho[60 - i] = NULL; pos = 35; for(i=0;i<7;i++) { /* incializando pilhas de jogo */ pilhaJogo.comeco = pos - i; pilhaJogo.fim = pos + 1; pilhaJogo.ocultas = i; pilhaJogo.podeSair = 1; pilhaJogo.podeEntrar = 1; atualizaPilha(pos - i, pos, i); baralho[pilhaJogo.comeco + pilhaJogo.ocultas]->virada = 1; pos-=(i+1); } estoqueDescarte.comeco = 35; estoqueDescarte.fim = 0; for(i=0;i<4;i++) { podeSaida = 1; ultimoSaida = 0; } } /* funcao que joga o paciencia */ void jogar() { int i,j, houveMovimento; /* a variavel houveMovimento serve para garantir que só faco uma jogada a cada iteracao do meu laco */ while(1) { if(estoqueDescarte.fim == 0) pescaGrimorio(); imprimeJogo(); houveMovimento = 0; /* passo 1, verifico se algum monte final quer carta */ for(i=0;i<4 && !houveMovimento ;i++) { /* se a quer receber carta */ if(podeSaida == 1) { for(j=0;j<7;j++) { /* procuro na pilha de jogo */ if(procuraTopo(i*13 + ultimoSaida,pilhaJogo[j])) { printf("Colocar carta da pilha %d para pilha final\n",j+1); mudaFinal(&pilhaJogo[j]); /* coloca o topo de j em i */ houveMovimento = 1; break; } } if(!houveMovimento) podeSaida = 0; /* se ninguém quis entrar em Saida i, eu anoto isso */ } } if(houveMovimento) continue; /* passo 2 do jogo, procuro alguma pilha que pode ser movida para outra */ for(i=0;i<7 && !houveMovimento ;i++) { if(pilhaJogo.podeSair) { /* se pode sair então procuro algum monte pra ele ir */ for(j=0;j<7;j++) { if(j!=i && podeMoverPilha(pilhaJogo, pilhaJogo[j]) ) { printf("Colocar pilha %d na pilha %d\n", i+1, j+1); movePilha(&pilhaJogo, &pilhaJogo[j]); houveMovimento = 1; break; } } if(!houveMovimento && podeSair( baralho[pilhaJogo.comeco + pilhaJogo.ocultas]->valor) ) { mudaFinal(&pilhaJogo); houveMovimento = 1; break; } if(!houveMovimento) pilhaJogo.podeSair = 0; /* se ninguém aceitou essa pilha eu anoto isso */ } if(pilhaJogo.podeEntrar && !houveMovimento) { /* se pode entrar então procuro alguém pra vir */ for(j=0;j<7;j++) { if(j!=i && podeMoverPilha(pilhaJogo, pilhaJogo) ) { printf("Movendo da pilha %d pra pilha %d\n", j,i); movePilha(&pilhaJogo[j], &pilhaJogo); houveMovimento = 1; break; } } if(!houveMovimento) pilhaJogo.podeEntrar = 0; /* se ninguém entrou na minha pilha eu anoto isso tambem */ } } if(houveMovimento) continue; /* passo 3, verificar se a pilha de descarta pode ir pra algum lugar */ if(estoqueDescarte.fim != 0) { /* se a pilha de descarte não esta vazia */ imprimeCarta(baralho[estoqueDescarte.fim-1]->valor, 1); if(podeSair( baralho[estoqueDescarte.fim-1]->valor )) { printf("Colocar carta da pilha de descarta na pilha de saida\n"); moveSairDescarte(); houveMovimento = 1; } if(!houveMovimento) { for(i=0;i<7;i++) { if(podeMoverCarta(estoqueDescarte.fim -1, pilhaJogo)) { Informacao *carta; printf("Carta da pilha de descarte para a pilha de jogo Numero %d\n", i+1); carta = baralho[estoqueDescarte.fim -1]; baralho[estoqueDescarte.fim -1]= NULL; carta->pilha = &pilhaJogo; /* se tiver vazia */ if(carta->pilha->comeco == carta->pilha->fim) { int vazio = procuraVazio(); carta->pilha->comeco = vazio; carta->pilha->fim = vazio +1; moveCarta(carta, vazio, 1); } else { moveCarta(carta, carta->pilha->fim, 1); } estoqueDescarte.fim--; houveMovimento = 1; break; } } } } if(houveMovimento == 1) continue; if(estoqueDescarte.comeco == 59) break; printf("pescando uma carta\n"); pescaGrimorio(); } } /* main pra compilar */ int main() { int semente = 1133229541; srand(semente); inicializaPaciencia(); jogar(); return 0; }

Transformar um vetor em matriz usando a função memcpy, é algo muito fácil de se fazer. A função memcpy(); faz parte do arquivo de cabeçalho string.h. Com o recebimento de seus três parâmetros que são: memcpy ( *Mat, A, sizeof ( *Mat ) * 3 ); *Mat => destino. A => origem. 3 => número de bytes a serem copiados. Esta função está ápta a copiar blocos de memória, por isto não importa o tipo de dados armazenados a exemplos de outras funções. Neste código trago um claro exemplo de como utilizar esta importante função do C. O programa é um verdadeiro achado para iniciantes que querem aprender a gerar números aleatórios sem repetições de dígitos, onde nove sequência diferentes são geradas e é finalizado no fim da nona sequência. Veja abaixo uma imagem do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/12/memcpy-de-vetor-para-matriz.html

Pessoal, preciso de uma ajudinha de vocês :/ Estou fazendo um programinha em C, no qual o usuário insere as informações do veículo, como: código, modelo e marca. Depois de inserir os dados, ao digitar a opção para se exibir os veículos na fila, o código sai certo, porém as informações armazenadas na fila saem zeradas, o que será que está acontecendo? Aqui está o source code: #include<stdio.h> #include<stdlib.h> #include <locale.h> typedef struct type_car{ int cod; char marca[20]; char modelo[20]; char cor[20]; }car; car carro; typedef struct Node{ int num; struct Node *prox; }node; int tam; int menu(void); void opcao(node *FILA, int op); void inicia(node *FILA); int vazia(node *FILA); node *aloca(); void insere(node *FILA); node *retira(node *FILA); void exibe(node *FILA); void libera(node *FILA); int main(void){ node *FILA = (node *) malloc(sizeof(node)); if(!FILA){ printf("Sem memoria disponivel!\n"); exit(1); }else{ inicia(FILA); int opt; do{ opt=menu(); opcao(FILA,opt); }while(opt); free(FILA); return 0; } } int menu(void){ setlocale(LC_ALL, "Portuguese"); int choose; printf("\n\t\t\t\tEscolha a opção\n"); printf("1 - Remover todos os carros\n"); printf("2 - Exibir todos os carros na fila\n"); printf("3 - Adicionar carro a fila\n"); printf("4 - Remover carro da fila\n"); printf("0 - Sair do programa\n"); printf("\nOpção: "); scanf("%d", &choose); system("cls"); return choose; } void opcao(node *FILA, int op){ node *tmp; switch(op){ case 0: libera(FILA); break; case 1: libera(FILA); inicia(FILA); break; case 2: exibe(FILA); break; case 3: insere(FILA); break; case 4: tmp= retira(FILA); if(tmp != NULL){ printf("Carro removido: %3d\n\n", tmp->num); libera(tmp); } break; default: printf("Comando invalido!\n\n"); } } void inicia(node *FILA){ FILA->prox = NULL; tam=0; } int vazia(node *FILA){ if(FILA->prox == NULL) return 1; else return 0; } node *aloca(){ node *novo=(node *) malloc(sizeof(node)); if(!novo){ printf("Sem memória disponivel!\n"); exit(1); }else{ printf("Código do carro: "); scanf("%d", &carro.cod); fflush(stdin); printf("Modelo do carro: "); scanf("%s", &carro.modelo); fflush(stdin); printf("Marca do carro: "); scanf("%s", &carro.marca); fflush(stdin); printf("Cor do carro: "); scanf("%s", &carro.cor); fflush(stdin); return novo; } } void insere(node *FILA){ node *novo=aloca(); novo->prox = NULL; if(vazia(FILA)) FILA->prox=novo; else{ node *tmp = FILA->prox; while(tmp->prox != NULL) tmp = tmp->prox; tmp->prox = novo; } tam++; } node *retira(node *FILA){ if(FILA->prox == NULL){ printf("Não a carros em espera!\n"); return NULL; }else{ node *tmp = FILA->prox; FILA->prox = tmp->prox; tam--; return tmp; } } void exibe(node *FILA){ if(vazia(FILA)){ printf("Sem carros!\n\n"); return ; } node *tmp; tmp = FILA->prox; printf("Fila :"); while( tmp != NULL){ printf("%5d", tmp->num); tmp = tmp->prox; } printf("\n "); int count; for(count=0 ; count < tam ; count++) printf(" ^ "); printf("\nOrdem:"); for(count=0 ; count < tam ; count++) printf("%5d", count+1); printf("\n\n"); } void libera(node *FILA){ if(!vazia(FILA)){ node *proxNode, *atual; atual = FILA->prox; while(atual != NULL){ proxNode = atual->prox; free(atual); atual = proxNode; } } } Alguém poderia me explicar o que fiz de errado e uma possível solução :)

Algumas vêzes precisamos preencher uma matriz em posições aleatórias, isto é, escolher exatamente onde inserir o elemento aceito pelo tipo da matriz. Isto é perfeitamente possível e muito útil. Num jogo da velha por exemplo as posições são escolhidas deste modo. Neste exemplo mostro como isto pode ser feito, num código bem identado, com recursos da biblioteca conio.h, inserindo coordenadas na tela com os textos bem posicionados, com côres e fundo bem definido. Código indicado aos interessados por linguagem c.

Apagar dígitos de uma frase ou matriz com o exemplo aqui proposto é muito fácil, e o programa é indicado a iniciantes em linguagem c. Veja abaixo uma imagem do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/11/frase-apagando-digitos.html

Ter domínio em arquivos de textos e binários são obrigações de programadores em linguagem c, por isto apresento mais este código de pesquisa em arquivo. Uma novidade que quero mostrar aqui, é que o programa marca as ocorrências na própria leitura, olha, criar esta rotina me deu muito trabalho, muitas horas de empenho e dedicação, quer saber procure um outro código em c que faz isto diferente do meu e me mostre, estou ansioso por vê-lo. Qualquer estudante intermediário em c não terá dificuldades em acompanhar este código. Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/10/arquivo-pesquisando-e-marcando.hml

Geralmente pra se ter uma leitura com êxito de um arquivo devemos analizá-lo antes, isto porque o arquivo pode está todo desorganizado, então criamos um certo padrão. Agora pergunto, se estamos criando um arquivo que será lido pelo programa Porque não organizá-lo antes? Precisamos saber quantas strings, floats e inteiros o programa precisa para a leitura; Então criei um arquivo e estou utilizando-o para preenchimento dos campos de uma struct,onde declarei cinco chars e três ints. A struct recebe memória alocada dinamicamente, e é liberada por free(); no término do programa. Veja abaixo imagens do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/10/arquivo-inserindo-dados-em-struct.html

Programadores em linguagem c tem que ter pleno domínio em manipulação de arquivos, e para provar que não estamos de blá-blá-blá, criei este programa interessante. No programa são usados duas funções para leitura nos arquivos,que é a função fscanf(); e a função fgets(); Más o impressionante aqui é que temos a ousadia de escolher as colunas do arquivo a ser lida, ou o arquivo inteiro é claro. Tá certo que utilizei a função fseek(); em conjunto com a função fscanf();se não seria quase impossível conseguir isto. Já já função fggets(); que é muito mais fácil de trabalhar não se fez necessário a função fseek(); para posicionar a leitura só da coluna dos nomes. Fica difícil falar aqui de cada uma das funções, comandos, ou linha de códigos utilizados no programa, más disponibilizo gratuitamente o código para todos os amantes de linguagem c. Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/10/arquivo-escolhendo-colunas-para-leitura.html

Programadores em linguagem c tem boas opções em funções que fazem leitura de arquivos de texto, e uma outra função que pode ser usada para isto é a função fread(); Aliás, é mais recomendado o uso de fread(); para leitura por trabalhar com dados binários ao contrário de outras que trabalham com ASCII, e provoca perda de desempenho em arquivos maiores. A função retorna o número total de elementos lidos, que pode ser menor do que o que foi especificado na chamada da rotina se o final do arquivo for atingido ou se ocorrer um erro. Arquivos binários também podem ser lidos como registros de dados estruturados, Além disso, uma vez que todos os registros tem o mesmo tamanho, os dados podem ser acessados de forma não-sequencial (acesso aleatório). A sintaxe de fread (); é: fread ( &tipo_nome, sizeof ( tamanho ), quantidade, arquivo ); sendo: A variável recebe o endereço dos dados lidos do arquivo tamanho é o número de bytes a ser lido. Para calcular isso você deve usar o operador sizeof, quantidade indica quantos itens serão lidos ( cada item do tamanho especificado ) arquivo é um ponteiro para o arquivo aberto anteriormente. Uma boa prática, aliás sempre uso, é analisar o retorno de fread para ver se não ocorreram erros. Isto pode ser feito com uma instrução deste tipo: if ( fread ( &nome, sizeof ( nome ), 1, arquivo ) != 1 ) printf("Erro de leitura.\n"); O programa é simples e indicado a iniciantes em c. Veja o link do código abaixo: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/10/arquivo-leitura-com-fread.html

O c nos dá amplas possibilidades em leitura e escrita de arquivos, na verdade podemos lê entradas formatadas através de arquivos com fscanf();do mesmo modo em que lemos do teclado com scanf(); Assim como imprimimos um texto com printf(); podemos imprimir um arquivo com fprintf(); Neste programa mostro como lê uma matriz do tipo float com fscanf(); A sintaxe de fscanf é: int fscanf(FILE *arq, char *string_formatada); fscanf(); faz a leitura completa da matriz float no arquivo, más na hora da impressão imprimimos uma coluna por vez, que representa as notas de cada aluno, são quatro alunos e são quatro notas para cada disciplinas escolares atuais. Programa indicado a iniciantes em linguagem c.

Um dos sonhos de um iniciante em linguagem c é poder usar o mouse para acessar opções de um menu no proprio console do windows (cmd), pensando nisto cliei este simples exemplo que faz uso de poucos recursos da API do windows para capturar eventos do mouse na janelinha do dos. Veja o link abaixo:

Eu tava fazendo um código para um programa de clínica pediátrica. O programa cadastra, lista e exclui. Porém, quando algum cadastro é excluído, por exemplo: Se eu excluir o usuário com o código 1, ninguém poderá mais ocupar aquele código. Tentei mexer mais to apanhando quem puder ajudar eu agradeço. Vou deixar o código abaixo: #include <stdio.h> #include <stdlib.h> //Estrutura que sera usada para realizar cadastro struct tipo_cadastro { int cod; char endereco[60]; char responsavel[60]; char sexo[60]; int idade; int telefone; char nomepaciente[60]; char anamnese[60]; int vazio; } registros[100]; //Funçoes que serao usadas void cadastrar(int cod, int pos); // pos = posição //Funçao para consulta void consultar( void ); //Funçao para exibir relatorio int relatorio( void ); //Função para verificar posição int verifica_pos( void ); //Função para verificar codigo int verifica_cod( int cod ); //Função para verificar posição do codigo int verifica_pos( void ); //Função para excluir cadastro void excluir( void ); //Começo do programa principal int main( void ) { int op = 0, posicao, codaux, retorno; while ( op != 5 ) { printf("\n\n\t\t\t\t Clinica Bebe a Bordo\n\n\n"); printf("MENU\n\n1 - Cadastrar\n2 - Pesquisar\n3 - Excluir\n4 - Relatorio\n5 - Sair\n\nOpcao: "); scanf("%d",&op); system("cls"); switch ( op ) { case 1: // CADASTRAR { posicao=verifica_pos(); if ( posicao != -1 ) { printf("\nEntre com o codigo de cadastro (Somente numeros): \n"); scanf("%d",&codaux);fflush(stdin); retorno = verifica_cod( codaux ); if ( retorno == 1 ) cadastrar( codaux, posicao ); else printf("\nCodigo já existente\n"); } else printf("\nNao e possivel realizar mais cadastros!\n"); break; } case 2: // CONSULTAR { consultar(); break; } case 3: { excluir(); break; } case 4: { int main(); break; } case 5: { printf("\n Encerrando o Programa"); getchar(); break; } default : printf("Opcao Invalida"); break; } } getchar(); return 0; }//Final da Main // FUNÇAO CADASTRAR void cadastrar( int cod, int pos ) { pos = verifica_pos(); registros[pos].cod = cod; printf("\nNome do Paciente:\n"); gets(registros[pos].nomepaciente); printf("\nIdade do Paciente:\n"); scanf("%d",&registros[pos].idade); fflush(stdin); printf("\nSexo:\n"); gets(registros[pos].sexo); printf("\nNome do Responsavel:\n"); gets(registros[pos].responsavel); printf("\nEndereco:\n"); gets(registros[pos].endereco); printf("\nTelefone:\n"); scanf("%d",&registros[pos].telefone); fflush(stdin); printf("\nAnamnese:\n"); gets(registros[pos].anamnese); registros[pos].vazio = 1; printf("\nCadastro Realizado com Sucesso!\n\n"); getchar(); system("cls"); } //Final da Função Cadastrar //FUNÇÃO CONSULTAR void consultar( void ) { int cont = 0, cod; printf("\nEntre com o codigo\n"); scanf("%d",&cod); system("cls"); while ( cont <= 100 ) { if (registros[cont].cod==cod) { if (registros[cont].vazio==1) { printf("\nNome do Paciente: \n%s\n",registros[cont].nomepaciente); printf("\nIdade do Paciente: \n%d\n",registros[cont].idade); printf("\nSexo:\n%s\n",registros[cont].sexo); printf("\nNome do Responsavel: \n%s\n",registros[cont].responsavel); printf("\nEndereco: \n%s\n",registros[cont].endereco); printf("\nTelefone:\n%d\n",registros[cont].telefone); printf("\nAnamnese:\n%s\n",registros[cont].anamnese); printf("\n"); system ("pause"); system("cls"); break; } } cont++; if ( cont > 100 ) printf("\nCodigo não encontrado\n"); } } //FUNÇÃO VERIFICA POSIÇÃO int verifica_pos( void ) { int cont = 0; while ( cont <= 100 ) { if ( registros[cont].vazio == 0 ) return(cont); cont++; } return(-1); } //FUNÇÃO ZERAR void zerar( void ) { int cont; for ( cont = 0; cont <= 100; cont++ ) registros[cont].vazio = 0; } //FUNÇÃO VERIFICA CODIGO int verifica_cod( int cod ) { int cont = 0; while ( cont <= 100 ) { if ( registros[cont].cod == cod ) return(0); cont++; } return(1); } //FUNÇÃO EXCLUIR void excluir( void ) { int cod, cont = 0; char resp; // variavel para perguntar sim ou não printf("\nEntre com o codigo do registro que deseja excluir\n"); scanf("%d", &cod ); while ( cont <= 100 ) { if ( registros[cont].cod == cod ) { if ( registros[cont].vazio == 1 ) { printf("\nNome do Paciente: \n%s\n", registros[cont].nomepaciente ); printf("\nIdade do Paciente: \n%d\n", registros[cont].idade ); printf("\nSexo:\n%s\n",registros[cont].sexo); printf("\nNome do Responsavel: \n%s\n", registros[cont].responsavel ); printf("\nEndereco: \n%s\n", registros[cont].endereco); printf("\nTelefone:\n%d\n",registros[cont].telefone); printf("\nAnamnese:\n%s\n",registros[cont].anamnese); getchar(); printf("\nDeseja realmente excluir? S/N:"); scanf("%c",&resp); if ( ( resp == 'S' ) || ( resp == 's' ) ) { registros[cont].vazio=0; printf("\nExclusao feita com sucesso\n"); break; } else { if ( ( resp == 'N' ) || ( resp == 'n' ) ) { printf("Exclusao cancelada!\n"); break; } } } } cont++; if ( cont > 100 ) printf("\nCodigo não encontrado\n"); } system("pause"); system("cls"); }

Quando seus programas em linguagem c se tornarem mais avançados, é sinal que você futuro programador necessita de um menu que acompanhe seus avanços. Já postei um Programa no qual entitulei de: "Menu inteligente", más o programa apesar da alta eficiência só permitia o uso de duas setas do teclado, que são as setas pra baixo e pra cima, e olha, ele é campeão disparado em visualizações no meu blog, este aqui com certeza é bem melhor, aceita as quatro setas do teclado e rejeita qualquer outra tecla exceto o Esc que também é um canal de saída do programa. Programa indicado a estudantes, e hobistas avançados em linguagem c. Pessoal se o vídeo não estiver abrindo por favor me avisem. Abraço a todos

Na formação do conjunto dos números Naturais existe um tipo de numeral que possui a propriedade de ser divisível somente por um e por ele mesmo, recebendo a denominação de número primo. A descoberta dos números primos é imprescindível na Matemática, pois eles intitulam o princípio central na teoria dos números, consistindo no Teorema Fundamental da Aritmética. Esse Teorema satisfaz uma condição interessante no conjunto dos números naturais, ele afirma que todo número inteiro natural, sendo maior que 1, pode ser escrito como um produto de números primos, enfatizando a hipótese que o número 1 não pode ser considerado primo, pois ele tem apenas um divisor e não pode ser escrito na forma de produto de números primos. Quer saber mais detalhes sobre o assunto acesse o seguinte link abaixo de onde foi extraído partes do texto: http://www.brasilescola.com/matematica/numeros-primos.htm Más minha paixão é linguagem c, e o propósito deste trabalho é de ensinar os iniciantes em c criarem uma tabela de 1 a 100 e marcar na própria tabela as ocorrências dos números primos e não primos em côres destacadas veja na imagem abaixo: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/matriz-de-primos-e-não-primos.html

Um dos primeiros passos de um futuro programador em c, é aprender sobre resto de divisão, o operador que representa o resto de divisão em c é o %, ele faz o retorno do resto da divisão de um número por outro. Com certeza existe várias utilidades deste importante operador na linguagem c, más aqui destacamos apenas uma destas utilidades que é separar os números ímpares dos pares. Veja abaixo uma imagem do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/vetor-de-pares-e-de-impares.html

Este é mais um programa onde trabalho com remoção em estrutura de dados, e neste algo mais avançado foi aplicado, a remoção da string procurada acontece na própria impressão da matriz, isto é se for encontrada. A função responsável pela remoção da string encontrada é a memset(); Da biblioteca padrão string.h; Estudem esta incrível função, todo programador deve estudar memset(); Usando o raciocínio e a lógica muitas outra coisas se podem fazer usando esta poderosa função. Na matriz, usei um poema de "Carlos Drummond de Andrade". Veja abaixo imagens do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/pesquisando-e-apagando-ocorrencias-de.html

No pouco tempo que tenho estive pensando por aqui: Ora, se meu programa recebe caracteres digitados pelo usuário, faz uma eficiente pesquisa, e achando-o caracter pedido faz a remoção das ocorrências daquele caracter, por que não colocar mais um recurso permitindo ao usuário recolocar o caracter removido em todas as suas ocorrências ou até mesmo de inserir um novo caracter em todas as posições que foram removidas? E foi isto que fiz, e disponibilizo-o gratuitamente para todos interessados em linguagem C. Veja abaixo imagens do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/caracteres-pesquisando-removendo-e.html

Grande é a eficiência deste programa, no qual usa um vetor dinâmico para armazenar a quantidade de inteiros que são inseridos pelo usuário, dentro de limitações estabelecida pela #Macro tam, apoiado por um if onde a condição não deixa ultrapassar, Já na declaração deste if temos as mensagens de advertência ao usuário, onde são apagadas após suas exibições pela função clreol(); que por sua vez trabalha apontada pela função gotoxy(); Más nada disto teria sentido se não fosse o repetidor do{}while(); que confirma as condições do if e força a repetição do bloco. Passando pelas condições estabelecidas, um bloco comandado por um único laço for(); colhe a quantidade de números escolhido pelo usuário e armazena num vetor estático que foi declarado e está pronto para isto, más paro por aqui nos meus comentários, e deixo por conta dos interessados no código procurar entender como tudo foi feito. Veja abaixo imagens do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/inteiros-pesquisando-e-removendo.html

Localizar e remover ocorrências de um caractere numa frase previamente digitada pelo usuário é a finalidade deste código didático. O programa está funcionando perfeitamente aqui no meu eclipse, e aposto que funcionará com perfeição na sua IDE favorita, portanto aproveite este ótimo trabalho dedicado a estudantes de linguagens C. Veja abaixo imagens do programa em execução: Veja abaixo o link do códigodo programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/caracteres-pesquisando-e-removendo.html

Em linguagem c matrizes de strings são matrizes bidimensionais e sua forma geral é: tipo_nome_da_variavel [ dimensão da esquerda ] [ dimensão da direita ]; onde a dimensão da esquerda indexa as linhas e a da direita indexa as colunas. Em linguagem C, ao contrário de outras linguagens, não existe um tipo de dados string original, por isso devemos criar vetores de caracteres ou matriz bidimensional para armazenamento de strings. Neste programa a matriz de string é lida caracter por caracter e é imprimida em duas dimensões, isto facilitou na busca de um caracter dentro da matriz. A função responsável pela busca de caracters dentro da matriz de string é a função int Pesq_let ( char Mat [ 11 ] [ 16 ], char *di );onde recebe dois parâmetros no protótipo, a matriz de char e um ponteiro para char. Este código pode ser adaptado para trabalhar com inteiros ou floats, basta um pouco de esforço e o futuro programador consegue fazer pesquisa dentro de uma matriz de inteiros ou float com sucesso. As configurações do cmd para esta janela estão na imagem abaixo, onde temos também imagens do funcionamento do programa. Veja abaixo imagens do programa em execução: Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/caracter-pesquisa-em-matriz.html

Aproveitando o uso da função strftime (); da biblioteca padrão time.h do C, que captura a data atual do sistema, criei este código que faz comparações e mostra o total de anos passados desde o que foi digitado com o atual que foi capturado. Código indicado a aprendizes de linguagem C. Veja abaixo imagens do programa em execução: https://1.bp.blogspot.com/-UdbICeblJ6I/Vet5O28p1_I/AAAAAAAACXc/-l-CA2dvdCo/s1600/dat.PNG http://1.bp.blogspot.com/-BqiW7G4WUwc/Vet5PDyVh1I/AAAAAAAACXg/Ol2qCyWkzKY/s1600/data.PNG http://3.bp.blogspot.com/-yMrC7FGstj0/Vet5PJVoSRI/AAAAAAAACXk/yJZkPfcY7rk/s1600/dta.PNG http://1.bp.blogspot.com/-ogtvXfYcvEQ/Vet5PX33aZI/AAAAAAAACX0/V1fGfQY1QQo/s1600/dtta.PNG Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/comparando-duas-datas.html

Este programa usa funções de bibliotecas padrões para validar a data atual, dica muito boa para os iniciantes em Linguagem C. Veja abaixo imagens do programa em execução: http://4.bp.blogspot.com/-JjerAbl8GVA/Ves1Lsln-eI/AAAAAAAACW8/jfekv3dHic4/s1600/dte.PNG http://2.bp.blogspot.com/-qp1zcoyKfQA/Ves23PdLPcI/AAAAAAAACXM/lvdRRvYX6dw/s1600/deat.PNG Veja abaixo o link do código do programa: http://codigosfontes-ccplus-plus.blogspot.com.br/2015/09/validando-data-atual.html