Tag: Learn C

C, exercício de análise

assunto: vetor dinâmico de estruturas, ficheiro de texto, ficheiro binário

pergunta: Um banco armazena num ficheiro binário informação sobre os seus clientes. Os dados de cada cliente são guardados em estruturas do tipo pessoa. Além disso, um ficheiro de texto tem armazenados vários valores inteiros relativos a alguns números de conta (um inteiro em cada linha). Escreva uma função que crie um vetor dinâmico de estruturas do tipo pessoa, para onde devem ser copiadas todas as estruturas do ficheiro que não têm um número de conta que surja no ficheiro de texto. A função tem o seguinte protótipo:
pessoa* criaVetor(char* nomeB, char* nomeF, int *total);
Recebe como parâmetros os nomes dos ficheiros e o endereço de uma variável inteira onde deve colocar o tamanho do vetor criado. Devolve o endereço inicial do vetor dinâmico. Se ocorrer algum erro, deve devolver NULL.
Ao responder a esta questão, não deve assumir que a ordem pela qual a informação surge nos 2 ficheiros é igual. Além disso, podem surgir números de conta no ficheiro de texto que não se encontram nas estruturas do ficheiro binário.

typedef struct cliente pessoa;
struct cliente{
    char nome[200];      // Nome do cliente
    char morada[200];    // Morada do cliente
    int nConta;         // Número de conta
    int montante;       // Saldo da conta
};

resposta:

pessoa* criaVetor(char* nomeB, char* nomeF, int *total) {
    FILE *f, *g;
    int n = 0, i, flag;
    int tab[n], *auxT;
    pessoa clt[*total], *auxC, *lista;
    *total = 0;
    lista = &clt[*total];
    f = fopen(nomeB, "rb");
    if(f == NULL) {
        printf("Erro a abrir para leitura o ficheiro binario [%s]\n", nomeB);
        return NULL;
    }
    g = fopen(nomeF, "rt");
    if(g == NULL) {
        printf("Erro a abrir para leitura o ficheiro de texto [%s]\n", nomeF);
        fclose(f);
        return NULL;
    }
    auxT = malloc(sizeof(int));
    if(auxT == NULL) {
        printf("Erro na alocacao de memoria\n");
        return NULL;
    }
    while(fscanf(g, "%d", auxT) == 1) {
        tab[n] = *auxT;
        n++;
        auxT = malloc(sizeof(int));
        if(auxT == NULL) {
            printf("Erro na alocacao de memoria\n");
            return NULL;
        }
        tab[n] = *auxT;     
    }
    auxC = malloc(sizeof(pessoa));
    if(auxC = NULL) {
        printf("Erro na alocacao de memoria\n");
        return NULL;
    }
    while(fread(auxC, sizeof(pessoa), 1, f) == 1) {
        flag = 1;
        for(i = 0; i < n; i++)
            if(auxC->nConta == tab[i]) {
                flag = 0;
                break;
            }
        if(flag == 1) {
            clt[*total] = *auxC;
            (*total)++;
            auxC = malloc(sizeof(pessoa));
                if(auxC = NULL) {
                    printf("Erro na alocacao de memoria\n");
                    return NULL;
                }
        }
    }
    return lista;
}

Tags : , ,

C, exercício de análise

assunto: um vetor dinâmico de estruturas
pergunta: lidar com um vetor (vector) dinâmico de estruturas, e ficheiro binário

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct cliente pessoa;

struct cliente {
    char nome[200]; // Nome do cliente
    char morada[200]; // Morada do cliente
    int nConta; // Número de conta
    int montante; // Saldo da conta
};

void guarda_dados_binario(pessoa * exame, int totalC) {
    FILE *f;

    f = fopen("bancoBinario.bin", "wb");
    if (f == NULL) {
        printf("\n erro no acesso ao ficheiro \n");
        return;
    } else {
        fwrite(&totalC, sizeof (int), 1, f);
        fwrite(exame, sizeof (pessoa), totalC, f);
        fclose(f);
    }
}

pessoa * ler_dados_binario(int totalC) {
    FILE *f;
    pessoa * auxc;

    f = fopen("bancoBinario.bin", "rb");
    if (f == NULL) {
        printf("\n erro no acesso ao ficheiro \n");
        return 0;
    } else {
        fread(&totalC, sizeof (int), 1, f);
        auxc = malloc(sizeof (pessoa) * totalC);
        fread(auxc, sizeof (pessoa), totalC, f);
    }
    fclose(f);
    return auxc;
}

void mostra_todos(pessoa * exame, int totalC) {
    if (totalC == 0) {
        printf("nao existem clientes\n");
    } else {
        printf("\ntotal: %d", totalC);
        for (int i = 0; i < totalC; i++) {
            printf("\n%s", exame[i].nome);
        }
    }
}

pessoa * adiciona_pessoa(int * auxtotalC) {
    int auxTotal = 0, totalC = 0;

    pessoa * auxc;

    printf("\nquantas pessoas quer adicionar?");
    scanf("%d", &totalC);
    * auxtotalC = totalC;

    auxc = malloc(sizeof (pessoa) * totalC);
    do {
        printf("Qual o nome?");
        scanf(" %99[^\n]", auxc[auxTotal].nome);
        printf("Qual a morada?");
        scanf(" %99[^\n]", auxc[auxTotal].morada);
        printf("Qual o numero da conta?");
        scanf("%d", &(auxc[auxTotal].nConta));
        printf("Qual o montante?");
        scanf("%d", &(auxc[auxTotal].montante));
        auxTotal++;
    } while (auxTotal < totalC);
    return auxc;
}
int main(int argc, char** argv) {
    pessoa * listaPessoas = NULL; // um vetor dinâmico de estruturas 
    pessoa * listaPessoas2 = NULL; // um vetor dinâmico de estruturas, para testes
    int total = 0;

    listaPessoas = adiciona_pessoa(&total);
    mostra_todos(listaPessoas, total);
    guarda_dados_binario(listaPessoas, total);

    //auxliar/verificar/para testes
    listaPessoas2 = ler_dados_binario(total);
    mostra_todos(listaPessoas2, total);

    return (EXIT_SUCCESS);
}
Tags : , ,

C, exercício de análise

assunto: lista ligada simples
pergunta: Escreva a função pdados troca(pdados p); Esta função recebe o endereço do primeiro elemento de uma lista ligada simples, constituída por nós do tipo dados. Se a lista tiver menos de três elementos, ou se o nome armazenado no primeiro nó começar por Z, a função não faz nenhuma alteração. Caso contrário, troca o primeiro com o último elemento: o primeiro passa a ser o último e o último passa a ser o primeiro. Devolve o endereço do primeiro elemento da lista depois da alteração

typedef struct t dados, *pdados;
struct t{
   char nome[100];
   int id;
   pdados prox; 
};

resposta:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct t dados, *pdados;

struct t {
    char nome[100];
    int id;
    pdados prox;
};
int totalElementos(pdados exame) {
    int conta = 0;
    if (exame == NULL) {
        printf("\n[erro] lista vazia");
        return conta;
    } else {
        while (exame != NULL) {
            conta++;
            exame = exame->prox;
        }
    }
    printf("\nexistem %d pessoas da lista", conta);
    return conta;
}

int letraZ(pdados exame) {
    if (exame->nome[0] == 'Z' || exame->nome[0] == 'z') {
        printf("\nsim existe um Z na primeira letra do primeiro nome da lista");
        return 1;
    }
    return 0;
}

pdados troca(pdados t) {
    pdados copiaPrimeiraPosicao;
    pdados copiaUltimaPosicao;
    pdados aux;
    aux = t;


    pdados ajudaUltimaPosicao;

    pdados ajudaPrimeiraPosicao;
    copiaPrimeiraPosicao = NULL;
    copiaUltimaPosicao = NULL;
    ajudaUltimaPosicao = NULL;
    ajudaPrimeiraPosicao = NULL;

    if (totalElementos(t) > 3 || letraZ(t) == 1) {
        printf("\nvou trocar");
        //estou na primeira posição
        if (t->prox == NULL) {
            //mas é o unico elemento, não existe troca
            return t;
        } else {
            //vou para a ultima posicao
            while (aux->prox != NULL) {
                aux = aux->prox;
            }

            //fazer uma copia da primeira posicao
            copiaPrimeiraPosicao = malloc(sizeof (dados));
            copiaPrimeiraPosicao->id = t->id;
            strcpy(copiaPrimeiraPosicao->nome, t->nome);
            copiaPrimeiraPosicao->prox = NULL;

            //fazer uma copia da ultima posicao
            copiaUltimaPosicao = malloc(sizeof (dados));
            copiaUltimaPosicao->id = aux->id;
            strcpy(copiaUltimaPosicao->nome, aux->nome);


            //organizar
            t->id = copiaUltimaPosicao->id;
            strcpy(t->nome, copiaUltimaPosicao->nome);
            t->prox = t->prox;

            aux->id = copiaPrimeiraPosicao->id;
            strcpy(aux->nome, copiaPrimeiraPosicao->nome);
            aux->prox = copiaPrimeiraPosicao->prox;
        }
    } else {
        printf("\nnao troquei nada\n");
        return t;
    }
    return t;
}

void listar(pdados exame) {
    if (exame == NULL) {
        printf("\n[erro] lista vazia");
        return;
    } else {
        printf("\n--listagem dos elementos--\n");
        while (exame != NULL) {
            printf("\n%d\t%s", exame->id, exame->nome);
            exame = exame->prox;
        }
    }
}

pdados adicionarLista(pdados exame) {
    pdados novo = NULL;
    pdados aux = NULL;

    novo = malloc(sizeof (dados));
    if (novo == NULL) {
        printf("\nerro: alocacao de memoria");
        free(novo);
        return NULL;
    } else {
        printf("\nqual o id\n");
        scanf(" %d", &novo->id);

        printf("\nqual o nome\n");
        scanf("%s", novo->nome);
        novo->prox = NULL;

        if (exame == NULL) {
            exame = novo;
        } else {
            aux = exame;
            while (aux->prox != NULL) {
                aux = aux->prox;
            }
            aux->prox = novo;
        }
    }
    return exame;
}

int main(int argc, char** argv) {
    pdados exame = NULL;
    int continuar = 0;
    do {
        exame = adicionarLista(exame);
        listar(exame);
        printf("\nmais algum? 1-nao/0-sim\n");
        scanf("%d", &continuar);

    } while (continuar == 0);


    exame = troca(exame);
    listar(exame);


    return (EXIT_SUCCESS);
}
Tags : , ,

parte 6 – várias funções em C para manipulação de ficheiros e estruturas dinâmicas

Assunto deste post: várias funções em C para manipulação de ficheiros (de texto para binários e de binários para texto e estruturas dinâmicas (lista ligada e vector dinâmico de estruturas)

//ficheiro parte1.c
#include "parte1Comum.h"

int menu(){
    int i;
    puts("1 - adiciona grupo");
    puts("2 - remove grupo");
    puts("3 - lista grupo");
    puts("4 - pesquisa grupo");
    puts("5 - ");
    puts("6 - ");
    puts("7 - carregar grupo de um ficheiro binario");
    puts("8 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >8);
    
    return i;
}


void main() {
    int escolha;
    pGrupo listaGrupo=NULL;
    pMesa listaMesa[TAM]={NULL};
    int totalMesas=0;
    int h, m, pessoas;
    char mesa[20];
   
     do{
         printf("\ntotal de mesas: %d\n\n", totalMesas);
        escolha = menu();
        switch(escolha){
            case 1: 
                    printf("\nA que horas e minutos vem a reserva? (formato h m)\n");
                    scanf(" %d", &h);
                    scanf(" %d", &m);
                    printf("\nQuantas pessoas?\n");
                    scanf(" %d", &pessoas);
                    printf("\nQual a mesa?\n");
                    scanf(" %99[^\n]", mesa);
                    adicionaGrupo(listaMesa[TAM], &totalMesas, &listaGrupo, h, m, pessoas, mesa);
                    break;
            case 2: break;
            case 3: 
                    listagemGrupo(listaGrupo);
                    break;
            case 4: break;
            case 5: break;
            case 6: break;
            case 7: break;
        }
    }while(escolha != 8);
    
}


//ficheiro parte1Comum.h
#ifndef PARTE1COMUM_H
#define PARTE1COMUM_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 20

typedef struct tipoA mesa, *pMesa;
typedef struct tipoB grupo, *pGrupo;

struct tipoA{
    char id[20];
    int conta, valorTot;
};

struct tipoB{
    struct hora{int h, m;} in, out;
    int num, valor;
    pMesa ptr;
    pGrupo prox;
};

pGrupo adicionaGrupo(pMesa v, int *tot, pGrupo *lista, int h, int m, int pessoas, char *idM);
void adicionaGrupoAux();
pGrupo listagemGrupo(pGrupo lista);

#endif /* PARTE1COMUM_H */


//ficheiro parte1Comum.c
#include "parte1Comum.h"
//funções

//receber um grupo: dados do grupo e preenhcer os dados da mesa

pGrupo adicionaGrupo(pMesa v, int *tot, pGrupo *lista, int h, int m, int pessoas, char *idM){

    printf("\nvamos la ver se apanho os dados\n");
    printf("%d\t%d\t%d\t%d\t%s\t", *tot, h ,m ,pessoas, idM);
    pGrupo novo;
    novo = malloc(sizeof(grupo));
     if(novo==NULL){
         printf("\nerro: nao foi possivel reservar memoria");
         return NULL;
     }else{
     if(*tot==0){
         //primeira reserva mesa
        novo->in.h = h;
        novo->in.m = m;
        novo->num = pessoas;
        novo->prox = NULL;
        (*tot)++;
        //v[0].id = idM;
        //strcpy(v[0].id, idM);
        printf("\n\n%s",v[0].id);
        
        return novo;
    }
    
    
    }
    return novo;
    free(novo);
}

pGrupo listagemGrupo(pGrupo lista){

    printf("entrei");
    
    return NULL;
}
Tags : , ,

parte 5 – gestão dinâmica de memória (listas ligadas a listas ligadas)

O caso de uma lista de disciplinas que tem alunos inscritos.. :) as disciplinas é uma lista ligada e os alunos inscritos também o são.. vamos ver como corre

//listas de listas (listas ligadas)
#include <stdio.h>
#include <stdlib.h>

#define TAM 3
#define TAMNOME 10

typedef struct pessoa aluno, *paluno; 
typedef struct disciplina aUC, *pUC; 

struct pessoa{s
    int nif;
    char nome[TAMNOME];
    paluno pseguinte;
};


struct disciplina{
    int numeroUC;
    char nomeUC[TAMNOME];
    pUC pUCseguinte;
    paluno lista;
};

int lista_vazia(paluno p, pUC puc);
int menu();
pUC adicionaUC(int *auxTUC, pUC p);
void listaUCs(pUC p, int totalUC);
pUC removerUC(int *auxTUC, pUC p);
paluno adicionaAluno(paluno pA, pUC pU);



int lista_vazia(paluno p, pUC puc){
    if(p==NULL && puc == NULL){
        return 1;
    }else{
        return 0;
    }
}

int menu(){
    int i;
    //printf("total UCs: %d", totalUCs)
    puts("1 - adiciona UC");
    puts("2 - remove UC"); //last
    puts("3 - lista UCs");
    puts("4 - adiciona aluno a UC");
    puts("5 - remove aluno a UC"); //last
    puts("6 - lista UC de aluno");
    puts("7 - ");
    puts("8 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >8);
    
    return i;
}

pUC removerUC(int *auxTUC, pUC p){
    int retirarUC;
    pUC atual, anterior=NULL;
    
    atual = p;
    
    if(p==NULL){
        printf("\nerro: nao existe nada para remover");
        return p;
    }else{
        printf("\nqual o nif da UC a remover?\n");
        scanf("%d", &retirarUC);
        
        while(atual != NULL && atual->numeroUC != retirarUC){
            anterior = atual;
            atual= atual->pUCseguinte;
        }
        if(anterior == NULL){
            p = atual->pUCseguinte;
            (*auxTUC)--;
        }else{
            anterior->pUCseguinte = atual->pUCseguinte;
            (*auxTUC)--;
        }
        }
    free(atual);
    return p;
}

paluno adicionaAluno(paluno pA, pUC pU){
    
    
    
    

    return pA;
}


pUC adicionaUC(int *auxTUC, pUC p){
    int auxiliar;
    pUC novo, cursor;
    
    novo = malloc(sizeof(aUC));
    if(novo == NULL){
        printf("erro: nao e possivel alocar memoria para a UC");
        return p;
    }else{
    
    if(*auxTUC >= TAM){
        printf("erro: nao e possivel adicionar mais UC\n");
        free(novo);
        return p;
    }else{
        printf("Qual o numero da nova UC?\n");
        scanf("%d", &novo->numeroUC);
        printf("Qual o nome da nova UC?\n");
        scanf(" %99[^\n]", novo->nomeUC);
        novo->pUCseguinte = NULL;
        novo->lista = NULL;
        
        if(p==NULL){    
            p=novo;
            (*auxTUC)++;
            return p;
        }else{
            cursor=p;
            while(cursor->pUCseguinte != NULL){
                cursor=cursor->pUCseguinte;
                }
                cursor->pUCseguinte = novo;
                (*auxTUC)++;
                return p;
        }
    }
    }
    free(novo);
}

void listaUCs(pUC p, int totalUC){

    if(p==NULL){
        printf("\nerro: nao tem nada para listar de UCs");
    }else{
        printf("\nlistagem das %d UCs:\n", totalUC);
        while(p!=NULL){
            printf("%d\t%s\n", p->numeroUC, p->nomeUC);
            p=p->pUCseguinte;
        }
    }
}



int main() {
    int escolha, totalUC=0;
    paluno listaA=NULL;
    pUC listaUC=NULL;
    
    if(lista_vazia(listaA, listaUC)==1){
    do{
        escolha = menu();
        switch(escolha){
            case 1: listaUC=adicionaUC(&totalUC, listaUC); break;
            case 2: listaUC=removerUC(&totalUC, listaUC); break;
            case 3: listaUCs(listaUC, totalUC);
            case 4: listaA=adicionaAluno( listaA, listaUC);break;
            case 5: break;
            case 6: break;
            case 7: break;
            case 8: break;
        }
    }while(escolha != 8);
    }else{
        printf("nao foi possivel inicializar!");
    }
    
    
    return 0;
}


e ficou incompleto..

ajudas:
LINK1

Tags : , ,

parte 5 – gestão dinâmica de memória (lista duplamente ligada)

As listas duplamente ligadas pressupõem sempre que cada nó tem sempre dois ponteiros: um para o próximo nó e outro para o nó anterior

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 100

typedef struct elemento pessoa, *pelemento;

struct elemento{
    char nome[TAM];
    int idade;
    pelemento prox;
    pelemento antes;
};

int lista_vazia(pelemento p);
void mostra_elemento(pelemento p);
pelemento adiciona_elemento(pelemento p);
pelemento elimina_elemento(pelemento p);
void pesquisa_elemento(pelemento p);
void guarda_lista(pelemento p);
pelemento ler_lista(pelemento p);

int menu(){
    int i;
    puts("1 - adiciona elemento");
    puts("2 - elimina elemento");
    puts("3 - mostra a lista elementos");
    puts("4 - pesquisar na lista");
    puts("5 - esvaziar a lista");
    puts("6 - obter lista de um ficheiro");
    puts("7 - guardar lista de um ficheiro");
    puts("8 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >8);
    
    return i;
}

int lista_vazia(pelemento p){
    if(p==NULL){
        return 1;
    }else{
        return 0;
    }
}

pelemento elimina_elemento(pelemento p){
    pelemento aux=NULL;
    char apagar[TAM];

    if(p == NULL){
        printf("erro: nao existem elementos para elimninar");
        return p;
    }else{
    aux=p;
    printf("qual o nome que quer apagar?\n");
    scanf(" %99[^\n]", apagar);
    printf("vou procurar: %s\n", apagar);
    
    while(aux != NULL && strcmp(aux->nome, apagar) != 0){
        aux=aux->prox;
    }
    //nao encontrou
    if(aux == NULL){
        return p;
    }else{ 
       
    //primeiro elemento
    if(aux == p){
        printf("encontrei: vou apagar1\n");
        p=aux->prox;
        if(p != NULL){
            p->antes = NULL;
        }
    }else{
        printf("nao e o primeiro - encontrei: vou apagar2\n");
        aux->antes->prox = aux->prox;
        if(aux->prox != NULL){
            aux->prox->antes = aux->antes;
        }
    }
    }
    }
    free(aux);
    return p;
}


pelemento adiciona_elemento(pelemento p){
    pelemento novo, aux;
    novo = malloc(sizeof(pessoa));
   
    if(novo == NULL){
        printf("erro: na alocacao de memoria\n");
        return p;
    }
        
    if(p==NULL){ //se a lista estiver vazia
    //a lista está vazia
        printf("Qual o nome? ");
        scanf(" %99[^\n]", novo->nome);
        printf("Qual a idade? ");
        scanf("%d", &novo->idade);
        novo->prox=NULL;
        p=novo;
        
        return p;
    }else{
    //se a lista nao estiver vazia
        printf("Qual o nome?2 ");
        scanf(" %99[^\n]", novo->nome);
        printf("Qual a idade?2 ");
        scanf("%d", &novo->idade);
        //mas for o segundo elemento
        if(p->prox==NULL){
            p->prox=novo;
            novo->antes=p;
            novo->prox=NULL;
            return p;
        }else{
            aux = p;
            //se nao for o primeiro elemento
            while(aux->prox != NULL){
                aux=aux->prox;
            }
            novo->prox = aux->prox; //aponta para null ?? nao percebi
            novo->antes = aux;
            aux->prox = novo; 
            return p;
        }
    }
    free(novo);
    return p;
}

void mostra_elemento(pelemento p){

    if(p==NULL){
        printf("\nerro: lista esta vazia\n");
    }else{
        printf("\nLista de elementos:\n");
        while(p != NULL){       
            printf("%s\t%d\t\n", p->nome, p->idade);
            p = p->prox;
        }
    }
}

void pesquisa_elemento(pelemento p){
    pelemento aux;
    char apagar[TAM]; 
    
    if(p==NULL){
        printf("lista vazia\n");
    }else{
        aux=p;
        printf("Qual o nome do elemento que quer procurar?\n");
        scanf(" %99[^\n]", apagar);
        
        while(aux != NULL){
            if(strcmp(aux->nome, apagar)==0){
                printf(".........................encontrei\n");
                printf("%s\t%s", aux->nome, apagar);
            }
            aux=aux->prox;
        }
    }
}

void guarda_lista(pelemento p){
    FILE *f;
    pelemento aux;
    
    f = fopen("gd2.bin","wb");
    if(f == NULL){
        printf("nao foi possivel executar a operacao");
    }else{
        aux=p;
        while(aux != NULL){
            fwrite(aux,sizeof(pessoa),1,f);
            aux=aux->prox;
        }
    }
    printf("\nLista guardada\n");
    fclose(f);
}

pelemento ler_lista(pelemento p){
    FILE *f;
    pelemento novo=NULL;
    
   f = fopen("gd2.bin","rb");
   if(f == NULL){
        printf("nao foi possivel executar a operacao");
        return p;
    }else{
            while(feof(f) == 0){
                novo=malloc(sizeof(pessoa));
                fread(novo,sizeof(pessoa),1,f);
                novo->prox = p;
                p = novo;    
            }
        }
   
   free(novo);
   fclose(f);
   return p;
}
int main() {
    int escolha;
    pelemento lista = NULL; //1) criar a lista
    
    if(lista_vazia(lista)==1){
    do{
        escolha = menu();
        switch(escolha){
            case 1: lista = adiciona_elemento(lista); break;
            case 2: lista = elimina_elemento(lista);break;
            case 3: mostra_elemento(lista); break;
            case 4: pesquisa_elemento(lista); break;
            case 5: break;
            case 6: lista = ler_lista(lista); break;
            case 7: guarda_lista(lista); break;
            case 8: break;
        }
    
    }while(escolha != 8);
    }else{
        printf("nao foi possivel inicializar!");
    }
    return 0;
}


Tags : , ,

parte 5 – gestão dinâmica de memória (lista ligada)

Principal vantagem de se usar lista ligada: flexibilidade

O acesso é sequencial, em que cada estrutura contém: os campos e um ponteiro para o próximo elemento da lista
operações com listas ligadas:
1) criar a lista
2) verificar se está vazia
3) pesquisar/lustar
4) adicionar um elemento
5) retirar um elemento
6) destruir a lista

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 100


typedef struct objeto livro, *plivro;

struct objeto{
    char titulo[TAM], autor[TAM];
    int cota;
    plivro prox; //ponteiro para o proximo elemento da lista
};


//
int lista_vazia(plivro p);
plivro insere_inicio(plivro p);
plivro insere_final(plivro p);
plivro insere_ordenado(plivro p);
void mostra(plivro p);
plivro elimina(plivro p);
void destruir(plivro p);
plivro ler_ficheiro(plivro p);
void guarda_ficheiro(plivro p);

//2) verificar se está vazia
int lista_vazia(plivro p){
    if(p==NULL){
        return 1;
    }else{
        return 0;
    }
}

int menu(){
    int i;
    puts("1 - adiciona livro - inicio");
    puts("2 - adiciona livro - final");
    puts("3 - adiciona livro - ordenado");
    puts("4 - elimina livro");
    puts("5 - lista livros");
    puts("6 - esvaziar a lista");
    puts("7 - carregar lista de um ficheiro");
    puts("8 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >8);
    
    return i;
}

plivro insere_inicio(plivro p){
    plivro novo;
    novo = malloc(sizeof(livro)); //aponta para um qq espaço em memória
    
    if(novo == NULL){
        printf("\nerro: alocacao de memoria para esta tarefa de insere_inicio");
        return p;
    }else{
        printf("Titulo: ");
        scanf(" %99[^\n]", novo->titulo);
        printf("Autor: ");
        scanf(" %99[^\n]", novo->autor);
        printf("Cota: ");
        scanf("%d", &novo->cota);
               
        //surge agora uma parelha obrigatória
        novo->prox=p; //aponto o novo para a primeira posição
        p=novo; //a primeira posição é o novo
                
        return p;
    }
    free(novo);
}

plivro insere_final(plivro p){
    plivro novo, aux;
    novo = malloc(sizeof(livro)); //aponta para um espaço em memoria
    if(novo == NULL){
        printf("\nerro: alocacao de memoria para esta tarefa de insere_inicio");
        return p;
    }else{
        printf("Titulo: ");
        scanf(" %99[^\n]", novo->titulo);
        printf("Autor: ");
        scanf(" %99[^\n]", novo->autor);
        printf("Cota: ");
        scanf("%d", &novo->cota);
        novo->prox=NULL;
        
        //se estiver vazio, insere no inicio
        if(p == NULL){
            p = novo;
        }else{
        //se já tiver pelo menos um elemento
            aux=p;
            while(aux->prox != NULL){
                aux = aux->prox;
            }
            aux->prox = novo;
        }
        return p;
    }
    free(novo);
}

plivro insere_ordenado(plivro p){
     plivro novo, aux;
    novo = malloc(sizeof(livro)); //aponta para um espaço em memoria
    if(novo == NULL){
        printf("\nerro: alocacao de memoria para esta tarefa de insere_inicio");
        return p;
    }else{
        printf("Titulo: ");
        scanf(" %99[^\n]", novo->titulo);
        printf("Autor: ");
        scanf(" %99[^\n]", novo->autor);
        printf("Cota: ");
        scanf("%d", &novo->cota);
        novo->prox=NULL;
        
        //se estiver vazio
        if(p == NULL || strcmp(novo->titulo, p->titulo) < 0){
        //if(p == NULL || novo->cota < p->cota){
            novo->prox = p;
            p = novo;
        }else{
        //se já tiver pelo menos um elemento
            aux=p;
             while(aux->prox != NULL && strcmp(novo->titulo, aux->titulo) >0){
             //while(aux->prox != NULL && novo->cota > aux->cota){
                aux = aux->prox;
            }
            novo->prox = aux->prox;
            aux->prox = novo;
        }
        return p;
    }
    
    free(novo);

}


void mostra(plivro p){
    
    if(p==NULL){
        printf("\nerro: lista vazia, sem elementos para listar!\n\n");
    }else{
    while(p!=NULL){
        printf("%s\t%s\t%d\n", p->titulo, p->autor, p->cota);
        p = p->prox;
    }
    }
}


plivro elimina(plivro p){
    int apaga;
    plivro atual, anterior=NULL;
    
    atual= p;
    
    if(p==NULL){
        printf("\nerro: lista vazia sem informacao\n");
        return p;
    }else{
        mostra(p);
        printf("qual o livro e cota que pretende eliminar?");
        scanf("%d", &apaga);
        while(atual!=NULL && atual->cota != apaga){
            anterior = atual;
            atual = atual->prox;
        }
        if(anterior ==NULL){
            p = atual->prox;
        }else{
            anterior->prox = atual->prox;
        }
    free(atual);
    return p;
    }
}

void destruir(plivro p){
    plivro aux;
    
    if(p==NULL){
        printf("\nerro: nada para apagar!\n");
    }
    
    while(p!=NULL){
        aux = p;
        p=p->prox;
        free(aux);
    }

}

plivro ler_ficheiro(plivro p){
    FILE *f;
    plivro novo=NULL;
        
    if(p!=NULL){
        printf("\nerro: lista ja preenchida\n");
        return p;
    }else{
    
    f = fopen("listaLivros.dat", "rb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return p;
    }else{
       
       while(feof(f) == 0){
            novo = malloc(sizeof(livro));
            fread(novo, sizeof(livro), 1, f);
            novo->prox = p;
            p = novo; //erro aqui
        }
    }
    }
    free(novo);
    fclose(f);
    return p;
}

void guarda_ficheiro(plivro p){
    FILE *f;
    
    f = fopen("listaLivros.dat", "wb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return;
    }else{
        while(p != NULL){
        fwrite(p, sizeof(livro), 1, f);
        p=p->prox;
        }
        fclose(f);
        free(p);
    }
}


int main() {
    int escolha;
    plivro lista = NULL; //1) criar a lista
    
    if(lista_vazia(lista)==1){
    do{
        escolha = menu();
        switch(escolha){
            case 1: lista = insere_inicio(lista); break;
            case 2: lista = insere_final(lista); break;
            case 3: lista = insere_ordenado(lista); break;
            case 4: lista = elimina(lista); break;
            case 5: mostra(lista); break;
            case 6: destruir(lista); break;
            case 7: lista= ler_ficheiro(lista); break;
        }
    
    }while(escolha != 8);
    }else{
        printf("nao foi possivel inicializar!");
    }

    guarda_ficheiro(lista);
    return 0;
}



Tags : , ,

parte 4 – ficheiros (ainda…)

falta rever a situação de:
ftell –> exemplo ftell(f)/sizeof(struct pessoa) -> diz-me por exemplo quantas pessoas estão no ficheiro
fseek
SEEK_CUR
SEEK_END
SEEK_SET

Tags : , ,

parte 4 – ficheiros (texto)

O trabalho com ficheiros de texto já é um pouco diferente

notas acerca dos ficheiros de texto:
leitura de espaços vazios ou tabs é a mesma coisa

#include <stdio.h>
#include <stdlib.h>

/*
//exemplo do ficheiro de texto
Ana Mendes
3 5 7 12 20 1 3

Marcia Dantas
1	2	3	4	5	6	7
 */


int main() {
    FILE *f;
    char nome[100];
    f = fopen("ex3_dados.txt", "r");
    int i, lista[7];
    
    if(f != NULL){
           while(feof(f) == 0){
            fscanf(f, " %[^\n] ", nome);        
            printf("%s \n", nome);
            for(i=0; i< 7; i++){
                fscanf(f, "%d", &lista[i]);   
            }
            for(i=0; i< 7; i++){
                printf("%d ", lista[i]);   
            }
            //printf("\n");
            putchar('\n');
        }
    }else{
        printf("\n o ficheiro nao foi encotnrado!");
    }
    return 0;
}


Para trabalhar com o exemplo do banco e clientes, mas desta vez com ficheiros de texto, sem guardar o total de registos. Não consegui resolver a situação de ler ficheiros como deve ser..

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 5


/*
 //exemplo do conteudo do ficheiro de texto
 nome: pedro	Nº conta: 1	Saldo: 100
 */

typedef struct dados{
    char numeroConta[15];
    char nome[50];
    int montante;
} cliente;


int menu(){
    int i;
    puts("1 - adiciona cliente");
    puts("2 - elimina cliente");
    puts("3 - lista clientes");
    puts("4 - mostra mais rico");
    puts("5 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >5);
    
    return i;
}

cliente escreve_cliente(){
    cliente t;
    printf("Qual o numero da conta?");
    scanf(" %14s", t.numeroConta);
    printf("Qual o nome?");
    scanf(" %99[^\n]", t.nome);
    printf("Qual o montante?");
    scanf("%d", &(t.montante));
    
    return t;
}

void adiciona_cliente(cliente tabC[], int *totalC){
    
    if(*totalC>=TAM){
        printf("tabela de cliente cheia");
    }else{
        tabC[*totalC] = escreve_cliente();
        (*totalC)++;
    }
}

void mostra_todos(cliente tab[], int totalC){
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
    for(int i=0; i< totalC; i++){
        printf("%s \t %s \t %d \n", tab[i].numeroConta, tab[i].nome, tab[i].montante);
    }
    }
}



void procura_mais_rico(cliente tab[], int totalC){
    cliente maiorT;
    
    int aux=0, i=0;
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
        maiorT.montante = tab[i].montante;
        for(; i< totalC; i++){
            if(tab[i].montante > maiorT.montante ){
                aux = i;
            }
        }
        printf("\no maior vem %d:\n" , aux);
        printf("%s \t %s \t %d \n", tab[aux].numeroConta, tab[aux].nome, tab[aux].montante);
    
    }
}


void elimina_cliente(cliente tab[], int *totalC){
    char st[15];
    int i;
    
    printf("Qual o numero da conta a eliminar? (%d)", *totalC);
    scanf(" %14s", st);
    
    if(totalC<0){
        printf("nao existem clientes. nao se pode eliminar nada\n");
    }else{
        for(i=0; i < *totalC && strcmp(st, tab[i].numeroConta)!=0; i++) //serve para posicionar o i quando encontrei
            ;
        
        if(i==*totalC){
            printf("cliente nao existe\n");
        }else{
            tab[i]=tab[*totalC-1]; //serve para arrastar o ultimo para a posição atual
            (*totalC)--; 
        }
        }
}
    
void guarda_dados_texto(cliente *b, int total){
    FILE *f;
    
    f = fopen("bancoBinario2.txt", "wt");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return;
    }else{
        for(int i=0; i < total; i++){
            fprintf(f, "nome: %s\tN.conta: %s\tSaldo: %d\n", b[i].nome, b[i].numeroConta, b[i].montante);
        }
        fclose(f);
    }
}


int ler_dados_texto(cliente *b){
    FILE *f;
    int total=0;
    
    f = fopen("bancoBinario2.txt", "r");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return 0;
    }else{
        while(feof(f) == 0){
            printf("\nvou ler");
            fscanf(f, " %[^\n] %[^\n] %[^\n]", b[total].nome, b[total].numeroConta, &b[total].montante);
            total++;
        }
        fclose(f);
        return total;
    }
}

int main() {
    printf("estruturas\n");
    int totalClientes=0, escolha;
    cliente Banco[TAM];
    
    totalClientes = ler_dados_texto(Banco);
    printf("\n\n%d\n\n", totalClientes);
    
    do{
        escolha = menu();
        switch(escolha){
            case 1: adiciona_cliente(Banco,&totalClientes); break;
            case 2: elimina_cliente(Banco,&totalClientes); break;
            case 3: mostra_todos(Banco,totalClientes); break;
            case 4: procura_mais_rico(Banco,totalClientes); break;
        }
    
    }while(escolha != 5);
    
    guarda_dados_texto(Banco, totalClientes);
    
    return 0;
}
Tags : , ,

parte 4 – ficheiros (binários)

Existem dois tipos de ficheiros: binários e de texto
se for feito uso de um ficheiro binário é recomendável que se guarde o numero de estruturas logo no inicio do ficheiro e de seguida as estruturas

versão light onde indico qual o numero de estruturas que existem e que vão ser guardadas no ficheiro


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 5

typedef struct dados{
    char numeroConta[15];
    char nome[50];
    int montante;
} cliente;


int menu(){
    int i;
    puts("1 - adiciona cliente");
    puts("2 - elimina cliente");
    puts("3 - lista clientes");
    puts("4 - mostra mais rico");
    puts("5 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >5);
    
    return i;
}

cliente escreve_cliente(){
    cliente t;
    printf("Qual o numero da conta?");
    scanf(" %14s", t.numeroConta);
    printf("Qual o nome?");
    scanf(" %99[^\n]", t.nome);
    printf("Qual o montante?");
    scanf("%d", &(t.montante));
    
    return t;
}

void adiciona_cliente(cliente tabC[], int *totalC){
    
    if(*totalC>=TAM){
        printf("tabela de cliente cheia");
    }else{
        tabC[*totalC] = escreve_cliente();
        (*totalC)++;
    }
}

void mostra_todos(cliente tab[], int totalC){
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
    for(int i=0; i< totalC; i++){
        printf("%s \t %s \t %d \n", tab[i].numeroConta, tab[i].nome, tab[i].montante);
    }
    }
}



void procura_mais_rico(cliente tab[], int totalC){
    cliente maiorT;
    
    int aux=0, i=0;
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
        maiorT.montante = tab[i].montante;
        for(; i< totalC; i++){ if(tab[i].montante > maiorT.montante ){
                aux = i;
            }
        }
        printf("\no maior vem %d:\n" , aux);
        printf("%s \t %s \t %d \n", tab[aux].numeroConta, tab[aux].nome, tab[aux].montante);
    
    }
}


void elimina_cliente(cliente tab[], int *totalC){
    char st[15];
    int i;
    
    printf("Qual o numero da conta a eliminar? (%d)", *totalC);
    scanf(" %14s", st);
    
    if(totalC<0){
        printf("nao existem clientes. nao se pode eliminar nada\n");
    }else{
        for(i=0; i < *totalC && strcmp(st, tab[i].numeroConta)!=0; i++) //serve para posicionar o i quando encontrei
            ;
        
        if(i==*totalC){
            printf("cliente nao existe\n");
        }else{
            tab[i]=tab[*totalC-1]; //serve para arrastar o ultimo para a posição atual
            (*totalC)--; 
        }
        }
}
    
void guarda_dados_binario(cliente *b, int totalC){
    FILE *f;
    
    f = fopen("bancoBinario.bin", "wb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return;
    }else{
    
        fwrite(&totalC, sizeof(int), 1, f);
        fwrite(b, sizeof(cliente), totalC, f);
        fclose(f);
    }
}


int ler_dados_binario(cliente *b){
    FILE *f;
    int total;
    
    f = fopen("bancoBinario.bin", "rb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return 0;
    }else{
    
        fread(&total, sizeof(int), 1, f);
        fread(b, sizeof(cliente), total, f);
        fclose(f);
        return total;
    }
}

int main() {
    printf("estruturas\n");
    int totalClientes=0, escolha;
    cliente Banco[TAM];
    
    totalClientes = ler_dados_binario(Banco);
    
    do{
        escolha = menu();
        switch(escolha){
            case 1: adiciona_cliente(Banco,&totalClientes); break;
            case 2: elimina_cliente(Banco,&totalClientes); break;
            case 3: mostra_todos(Banco,totalClientes); break;
            case 4: procura_mais_rico(Banco,totalClientes); break;
        }
    
    }while(escolha != 5);
    
    guarda_dados_binario(Banco, totalClientes);
    
    return 0;
}

versão hardcore onde NAO indico qual o numero de estruturas que existem e que vão ser guardadas no ficheiro

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 5

typedef struct dados{
    char numeroConta[15];
    char nome[50];
    int montante;
} cliente;


int menu(){
    int i;
    puts("1 - adiciona cliente");
    puts("2 - elimina cliente");
    puts("3 - lista clientes");
    puts("4 - mostra mais rico");
    puts("5 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >5);
    
    return i;
}

cliente escreve_cliente(){
    cliente t;
    printf("Qual o numero da conta?");
    scanf(" %14s", t.numeroConta);
    printf("Qual o nome?");
    scanf(" %99[^\n]", t.nome);
    printf("Qual o montante?");
    scanf("%d", &(t.montante));
    
    return t;
}

void adiciona_cliente(cliente tabC[], int *totalC){
    
    if(*totalC>=TAM){
        printf("tabela de cliente cheia");
    }else{
        tabC[*totalC] = escreve_cliente();
        (*totalC)++;
    }
}

void mostra_todos(cliente tab[], int totalC){
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
    for(int i=0; i< totalC; i++){
        printf("%s \t %s \t %d \n", tab[i].numeroConta, tab[i].nome, tab[i].montante);
    }
    }
}



void procura_mais_rico(cliente tab[], int totalC){
    cliente maiorT;
    
    int aux=0, i=0;
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
        maiorT.montante = tab[i].montante;
        for(; i< totalC; i++){
            if(tab[i].montante > maiorT.montante ){
                aux = i;
            }
        }
        printf("\no maior vem %d:\n" , aux);
        printf("%s \t %s \t %d \n", tab[aux].numeroConta, tab[aux].nome, tab[aux].montante);
    
    }
}


void elimina_cliente(cliente tab[], int *totalC){
    char st[15];
    int i;
    
    printf("Qual o numero da conta a eliminar? (%d)", *totalC);
    scanf(" %14s", st);
    
    if(totalC<0){
        printf("nao existem clientes. nao se pode eliminar nada\n");
    }else{
        for(i=0; i < *totalC && strcmp(st, tab[i].numeroConta)!=0; i++) //serve para posicionar o i quando encontrei
            ;
        
        if(i==*totalC){
            printf("cliente nao existe\n");
        }else{
            tab[i]=tab[*totalC-1]; //serve para arrastar o ultimo para a posição atual
            (*totalC)--; 
        }
        }
}
    
void guarda_dados_binario(cliente *b, int total){
    FILE *f;
    
    f = fopen("bancoBinario2.bin", "wb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return;
    }else{
    
        fwrite(b, sizeof(cliente), total, f);
        fclose(f);
    }
}


int ler_dados_binario(cliente *b){
    FILE *f;
    int total=0;
    cliente aux;
    
    f = fopen("bancoBinario2.bin", "rb");
    if(f==NULL){
        printf("\n erro no acesso ao ficheiro \n");
        return 0;
    }else{
           
        fread(&aux, sizeof(cliente), 1, f);
        
        while(feof(f) == 0){
            b[total++]= aux;
            fread(&aux, sizeof(cliente), 1, f);
        }
        
        fclose(f);
        return total;
    }
}

int main() {
    printf("estruturas\n");
    int totalClientes=0, escolha;
    cliente Banco[TAM];
    
    totalClientes = ler_dados_binario(Banco);
    
    do{
        escolha = menu();
        switch(escolha){
            case 1: adiciona_cliente(Banco,&totalClientes); break;
            case 2: elimina_cliente(Banco,&totalClientes); break;
            case 3: mostra_todos(Banco,totalClientes); break;
            case 4: procura_mais_rico(Banco,totalClientes); break;
        }
    
    }while(escolha != 5);
    
    guarda_dados_binario(Banco, totalClientes);
    
    return 0;
}
Tags : , ,

parte 3 – estruturas

notas acerca das estruturas:

criar um novo tipo struct dados: 1º criar as variáveis, 2º declarar as variáveis

1º criar as variáveis

struct dados {
char nome[TAM];
char nconta[15];
int montate;
};

2º declarar as variáveis

struct dados m;

ou

Cliente b;

para aceder aos campos faz-se uso do ponto final -> m.nome
associar um novo nome à estrutura: typedef declaração-do-tipo sinónimo;

typdef struct dados cliente;

estruturas encadeadas:

struct data{
int dia, mes, ano;
};

struct dados{
char nome[TAM];
char nconta[15];
int montate;
};

notas acerca das estruturas:
operador de atribuição só para estruturas do mesmo tipo (faz copia em bloco ao invés de um a um)
comparação é sempre feita campo a campo
ponteiros e estruturas (*p).c equivalente a p->c
construir um vetor de estururas, struct dados clientes[30];
para calcula a dimensão de um vetor faz-se uso do sizeof(clientes) ou sizeof(struct dados) *30

exemplo clássico de trabalho com estruturas, sendo que o eliminar foi construído da seguinte forma:
mover o ultimo para a posição a eliminar e actualizar o total de posições

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 5

typedef struct dados{
    char numeroConta[15];
    char nome[50];
    int montante;
} cliente;


int menu(){
    int i;
    puts("1 - adiciona cliente");
    puts("2 - elimina cliente");
    puts("3 - lista clientes");
    puts("4 - mostra mais rico");
    puts("5 - terminar");
    puts("Escolha uma opcao: ");
    
    do{
        scanf(" %d", &i);
    }while(i <0 || i >5);
    
    return i;
}

cliente escreve_cliente(){
    cliente t;
    printf("Qual o numero da conta?");
    scanf(" %14s", t.numeroConta);
    printf("Qual o nome?");
    scanf(" %99[^\n]", t.nome);
    printf("Qual o montante?");
    scanf("%d", &(t.montante));
    
    return t;
}

void adiciona_cliente(cliente tabC[], int *totalC){
    
    if(*totalC>=TAM){
        printf("tabela de cliente cheia");
    }else{
        tabC[*totalC] = escreve_cliente();
        (*totalC)++;
    }
}

void mostra_todos(cliente tab[], int totalC){
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
    for(int i=0; i< totalC; i++){
        printf("%s \t %s \t %d \n", tab[i].numeroConta, tab[i].nome, tab[i].montante);
    }
    }
}



void procura_mais_rico(cliente tab[], int totalC){
    cliente maiorT;
    
    int aux=0, i=0;
    if(totalC==0){
        printf("nao existem clientes\n");
    }else{
        maiorT.montante = tab[i].montante;
        for(; i< totalC; i++){
            if(tab[i].montante > maiorT.montante ){
                aux = i;
            }
        }
        printf("\no maior vem %d:\n" , aux);
        printf("%s \t %s \t %d \n", tab[aux].numeroConta, tab[aux].nome, tab[aux].montante);
    
    }
}


void elimina_cliente(cliente tab[], int *totalC){
    char st[15];
    int i;
    
    printf("Qual o numero da conta a eliminar? (%d)", *totalC);
    scanf(" %14s", st);
    
    if(totalC<0){
        printf("nao existem clientes. nao se pode eliminar nada\n");
    }else{
        for(i=0; i < *totalC && strcmp(st, tab[i].numeroConta)!=0; i++) //serve para posicionar o i quando encontrei
            ;
        
        if(i==*totalC){
            printf("cliente nao existe\n");
        }else{
            tab[i]=tab[*totalC-1]; //serve para arrastar o ultimo para a posição atual
            (*totalC)--; 
        }
        }
}
    


int main() {
    printf("estruturas\n");
    int totalClientes=0, escolha;
    cliente Banco[TAM];
    
    do{
        escolha = menu();
        switch(escolha){
            case 1: adiciona_cliente(Banco,&totalClientes); break;
            case 2: elimina_cliente(Banco,&totalClientes); break;
            case 3: mostra_todos(Banco,totalClientes); break;
            case 4: procura_mais_rico(Banco,totalClientes); break;
        }
    
    }while(escolha != 5);
    
    return 0;
}



Tags : , ,

parte 2 – ponteiros (ou apontador)

notas acerca dos ponteiros, ou apontadores (aceder indirectamente a variáveis, através da sua localização):

Utilizar ponteiros para estabelecer a comunicação entre funções, se pretendo alterar o valor de uma variável dentro de uma função, tenho que passar como argumento um ponteiro para a variável e não uma copia do seu valor;

declaração: tipo *nome_ptr;

inicialização: tipo *nome_ptr = %qualquercoisaInt;

dois operadores:
& : obter o endereço de uma variável
* : aceder à variável para onde um ponteiro aponta

= : permite a atribuição entre ponteiros

notasM: quando faço p = &j; //estou a alterar o valor que está em j

notas acerca dos arrays (vetores):

[propriedade 1]

num array uni-dimensional a[i] ou *(a+i) é a mesma coisa. representam o primeiro elemento

[propriedade 2]

aritmética -> (p+i) ou (p-i) estou a deslocar posições dentro de um array

p+i equivalente a &a[i]

a[i] equivalente *(a+i)

declaração de uma função que recebe um vetor como argumento:
tipo funcao(tipo_de_vetor vetor[dimensao])
tipo funcao(tipo_de_vetor vetor[])
tipo funcao(tipo_de_vetor *vetor)

o uso da função é feito com nome do vector APENAS!

STRINGS

puts() //escreve strings <=> putchar()

strlen() //conta caracteres

strcat() //junta strings

tentar clearerr(stdin);

ao invés de usarmos array de caracteres (char st[TAM]) podemos usar ponteiro para carácter (char *p), vantagem? espaço em memória! Mas só funciona se as strings forem constantes.

como resolver isto?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 4

void mostra1(char **vB){

    for(int i=0; i<TAM; i++){
        puts(vB[i]);
    }

}

void mostra2(char *vA){

    for(int i=0; i<TAM; i++){
        //puts( vA[i]);
        //printf("%d\n", vA[i]);
    }

}

int main() {
    
    char vetorA[TAM][10]={"pedro","andre","maria","carlos"};
    char *vetorB[]={"portugal","espanha","marrocos","franca"};

    mostra1(vetorB);
    puts(vetorA[1]);
    mostra2(vetorA[TAM]);
    
    return (0);
}


ainda sobre o strcmp e para relembrar
se == 0, significa que são iguais
se < 0, a primeira é mais pequena que a segunda se > 0, a segunda é maior do que a segunda

Tags : , ,

Guião laboratorial n.º 3 – exercício 6

“O ficheiro “totoloto.txt” contém todas as combinações que saíram desde que o jogo do totoloto começou. Desenvolva um programa que leia do teclado a chave em que um jogador apostou e a compare com cada uma das chaves armazenadas no ficheiro, escrevendo quantos números comuns existem para cada chave.”

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 6

void totoloto(){
FILE *f1;
int ch,i=0, k=0, aux=1;
int tnum=0,contalinhas=0;
int chave[TAM], chavebd[TAM];

f1=fopen("totoloto.txt", "r");

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro");
  return;
}

//pedir numeros ao utilizador
while(tnum<TAM){
  printf("Qual o %d numero?", tnum+1);
  scanf(" %d", &chave[tnum]);
  tnum++;
}
//
printf("\na sua chave:\n");
tnum=0;
while(tnum<6){
  printf("%d\t", chave[tnum]);
  tnum++;
}

printf("\nesta e a chave guardada no ficheiro:\n");
while((ch=fgetc(f1))!=EOF){
printf("%c", ch);
if(ch=='\n'){
  contalinhas++;
}
}
printf("\ntotal de linhas no ficheiro: %d", contalinhas);
fclose(f1);
tnum=0;
//-----------------------
f1=fopen("totoloto.txt", "r");
while(contalinhas>0){
  fscanf(f1,"%d %d %d %d %d %d",&chavebd[0], &chavebd[1], &chavebd[2], &chavebd[3], &chavebd[4], &chavebd[5]);
  for(i=0; i < TAM; i++){
    for(k=0; k < TAM; k++){
        if(chave[i]==chavebd[k]){
          tnum++;
        }
    }
  }
  printf("\nna %d chave total de iguais: %d", aux, tnum);
  aux++;
  tnum=0;
  contalinhas--;
}


fclose(f1);
}


int main()
{
    totoloto();
    return 0;
}


ficheiro TXT usado:
1 2 3 45 44 5
22 2 3 45 44 5
27 2 3 45 44 24
1 2 3 45 44 13
33 2 3 34 44 11

Tags : , ,

Guião laboratorial n.º 3 – exercício 5

Desenvolva uma função que troque o conteúdo de dois ficheiros. Os nomes dos ficheiros são passados como argumentos da função.

#include <stdio.h>
#include <stdlib.h>

void trocaC(char *t1, char *t2){
FILE *f1;
FILE *f2;
FILE *temp1, * temp2;
char chO1,chO2;

f1=fopen(t1, "r");
f2=fopen(t2, "r");
temp1=fopen("temp1.txt", "w");
temp2=fopen("temp2.txt", "w");

if(f1==NULL){
 printf("\nerro ao abrir o ficheiro %c", *t1);
 return;
}
if(f2==NULL){
 printf("\nerro ao abrir o ficheiro %c", *t2);
 return;
}
if(temp1==NULL || temp2==NULL){
 printf("\nerro ao abrir o ficheiro temp");
 return;
}

//-----------------------copiar dos originais para o temporario
while((chO1=fgetc(f1))!=EOF){
fputc(chO1, temp1);
}
while((chO2=fgetc(f2))!=EOF){
fputc(chO2, temp2);
}
printf("\ncopia do ficheiro %c::%c para o temp com sucesso", *t1, *t2);
fclose(temp1);
fclose(temp2);
fclose(f1);
fclose(f2);

//-----------------------copiar do temporario para os originais
temp1=fopen("temp1.txt", "r");
temp2=fopen("temp2.txt", "r");
f1=fopen(t1, "w");
f2=fopen(t2, "w");


while((chO1=fgetc(temp1))!=EOF){
fputc(chO1, f2);
}
while((chO2=fgetc(temp2))!=EOF){
fputc(chO2, f1);
}
fclose(temp1);
fclose(temp2);
fclose(f1);
fclose(f2);

remove("temp1.txt");
remove("temp2.txt");
}


int main()
{
 char s1[20], s2[20];

 printf("Qual o nome do 1 ficheiro?");
 gets(s1);
 printf("Qual o nome do 2 ficheiro?");
 gets(s2);
 trocaC(s1, s2);

 return 0;
}

Tags : , ,

Guião laboratorial n.º 3 – exercício 7

“Considere a seguinte definição:
struct cliente{
char nome[200];
char morada[200];
int conta;
int montante;
};

a) Um banco tem informação armazenada sobre os seus clientes num ficheiro binário contendo estruturas do tipo struct cliente. Desenvolva uma função que escreva no monitor os nomes e os números de conta de todos os clientes que fazem parte do ficheiro. O nome do ficheiro é passado como argumento da função.

b) Desenvolva uma função que escreva no monitor o nome e o número de conta do cliente com o saldo mais elevado. O nome do ficheiro binário onde estão guardados os clientes é passado como argumento da função.

c) Desenvolva uma função que elimine uma estrutura do ficheiro de clientes do banco. A função recebe como argumento o nome do ficheiro e o nome do cliente a eliminar. O ficheiro a processar está ordenado alfabeticamente pelo nome dos clientes.

d) Desenvolva uma função que adicione um novo cliente ao ficheiro de clientes do banco. A função recebe como argumento o nome do ficheiro e a estrutura com a informação sobre o novo cliente (os campos da estrutura já estão preenchidos). O ficheiro original está ordenado alfabeticamente pelo nome dos clientes. A função deve garantir que a estrutura com informação do novo cliente é inserida no ficheiro na posição correta, de modo a que este continue ordenado.

e) Considere que o banco dividiu por dois ficheiros a informação sobre os seus clientes. Em cada um dos dois ficheiros as estruturas estão armazenadas por ordem alfabética do nome do cliente (não existem clientes com nomes iguais). O banco pretende agora reunir as estruturas num só ficheiro. Desenvolva uma função que permita realizar esta tarefa. Os nomes dos dois ficheiros originais e do novo ficheiro são passados como argumentos da função. No novo ficheiro, as estruturas devem continuar por ordem alfabética. Podem existir duplicações da informação de um
cliente (ou seja, o mesmo cliente tem uma estrutura em cada um dos ficheiros). Neste caso só uma delas deve ser passada para o novo ficheiro e o valor do montante deve ser a soma dos dois montantes existentes em cada uma das cópias.

f) Desenvolva uma função que escreva no monitor o número de bytes do ficheiro e o número de clientes que estão armazenados. O nome do ficheiro é passado como argumento da função.

g) Desenvolva uma função que crie um novo ficheiro em que a ordem das estruturas dos clientes apareça invertida (o primeiro passa a ser o último, o segundo o penúltimo e assim sucessivamente). Os nomes dos dois ficheiros são passados como argumento.”

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 100

typedef struct dados cliente;

struct dados{
  char nome[20];
  char morada[200];
  int conta;
  int montante;
};

void inserir(char *f, cliente *b, int *t){
//EXTRA: inserir registos no ficheiro caso nao exista o ficheiro!!
FILE *f1;
f1=fopen(f, "wb");
char r;
int i;
cliente *inicio = b;

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro");
  return;
}

do{
printf("\nDeseja inserir um cliente novo?");
scanf(" %c", &r);
  if(r=='s'){
    printf("\nQual o nome?");
    scanf(" %[^\n]", &(b->nome));
    printf("\nQual a morada?");
    scanf(" %[^\n]", &(b->morada));
    printf("\nQual o numero da conta?");
    scanf(" %d", &(b->conta));
    printf("\nQual o montante?");
    scanf(" %d", &(b->montante));
    (*t)++;
    b++;
  }
}while(r!='n');

for(i=0; i<*t; i++){
  fwrite((inicio+i), sizeof(cliente), 1, f1);
}

fclose(f1);
}

void ler(char *f){
//EXTRA: ler registos no ficheiro !!
FILE *f1;
f1=fopen(f, "rb");
struct dados c;

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro");
  return;
}
while(fread(&c, sizeof(struct dados), 1, f1) == 1){
     printf("\nnome:%s\tmorada:%s\tconta:%d\tmontante:%d", c.nome, c.morada, c.conta, c.montante);

    }
  fclose(f1);
}

void alienaA(char *f, cliente *b, int *t){
FILE *f1;
f1=fopen(f, "rb");
int total=0;

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro");
  return;
}

fread(&total, sizeof(total),MAX*4,f1);
fread(b, sizeof(cliente), total, f1);

*t=total;

fclose(f1);
}

int main()
{
    cliente banco[MAX];
    int total=0;

   // inserir("banco.dat", banco, &total);
   ler("banco.dat");
   // alienaA("banco.dat", banco, &total);
    //printf("\ntotal registos: %d", total);
    return 0;
}

+ajuda: ORDENAÇÃO

Tags : , , , ,

Guião laboratorial n.º 3 – exercício 4

Desenvolva uma função que escreva no monitor uma determinada linha de um ficheiro de texto. O nome do ficheiro e o número da linha são passados como argumentos da função.

#include <stdio.h>
#include <stdlib.h>

void mostraC(char *t1, int linha){
FILE *f1;
char ch;
int i=1;

f1=fopen(t1, "r");

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro %s", t1);
  return;
}

while((ch=fgetc(f1))!=EOF){
  if(i==linha)
  {
    printf("%c", ch);
  }
  if(ch=='\n'){
    i++;
  }
}

printf("\n ..lido tudo com sucesso");

fclose(f1);
}


int main()
{
    char s1[20];
    int l;

    printf("Qual o nome do 1 ficheiro?");
    gets(s1);
    printf("Qual o nome da linha a ler?");
    scanf("%d", &l);
    mostraC(s1, l);

    return 0;
}


Tags : ,

Guião laboratorial n.º 3 – exercício 3

altere a função da questão anterior de modo a garantir que as linhas do texto mostradas na consola surjam numeradas.

#include <stdio.h>
#include <stdlib.h>

void mostraC(char *t1){
FILE *f1;
char ch;
int i=1;

f1=fopen(t1, "r");

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro %s", t1);
  return;
}

printf("\n%d. ",i);
while((ch=fgetc(f1))!=EOF){
printf("%c", ch);
  if(ch=='\n'){
    printf("%d. ",i+1);
    i++;
  }
  }

printf("\n ..lido tudo com sucesso");

fclose(f1);
}


int main()
{
    char s1[20];

    printf("Qual o nome do 1 ficheiro?");
    gets(s1);
    mostraC(s1);

    return 0;
}


Tags : ,

Guião laboratorial n.º 3 – exercício 2

Desenvolva uma função que mostre o conteúdo de um ficheiro de texto na consola. O nome do ficheiro é passado como argumento.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

void mostraC(char *t1){
FILE *f1;
char ch;

f1=fopen(t1, "r");

if(f1==NULL){
  printf("\nerro ao abrir o ficheiro %s", t1);
  return;
}

while((ch=fgetc(f1))!=EOF)
  printf("%c", ch);

printf("\n ..lido tudo com sucesso");

fclose(f1);
}


int main()
{
    char s1[20];

    printf("Qual o nome do 1 ficheiro?");
    gets(s1);
    mostraC(s1);

    return 0;
}


Tags : ,

Guião laboratorial n.º 3 – exercício 1

1. Desenvolva um programa que duplique um ficheiro de texto. A informação de qual o nome do ficheiro original e do nome do novo ficheiro (cópia do original) deve ser feita através da linha de comando.
Exemplo (assumir que o programa se chama copia): ao ser chamado o programa copia com a linha de comando seguinte:
c: \> copia codigo.c novo.txt
é criado um novo ficheiro, novo.txt, que é uma réplica do ficheiro codigo.txt.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

void copia(char *t1, char *t2){


FILE *f1, *f2;
char ch;

f1=fopen(t1, "r");
f2=fopen(t2, "w");
if(f1==NULL){
 printf("\nerro ao abrir o ficheiro %s", t2);
 return;
}
if(f2==NULL){
 printf("\nerro ao abrir o ficheiro %s", t2);
 return;
}

while((ch=fgetc(f1))!=EOF)
 fputc(ch, f2);

printf("\n copia com sucesso");

fclose(f1);
fclose(f2);
}


int main()
{
 char s1[20], s2[20];

 printf("Qual o nome do 1 ficheiro?");
 gets(s1);
 printf("Qual o nome do 2 ficheiro?");
 gets(s2);
 copia(s1, s2);

 return 0;
}


Tags : ,

Guião laboratorial n.º 2 – exercício 4

O aeroporto de Coimbra pretende um programa para gerir a informação relativa às partidas de voos. Cada voo é identificado por: número do voo, nome da companhia, cidade destino e hora de partida (horas e minutos).
a) Crie um tipo estruturado chamado struct tempo que permita armazenar as componentes de uma determinada hora de um dia (horas e minutos).
b) Crie um tipo estruturado chamado struct voo que permita armazenar a informação relativa a um voo. O campo que armazena a hora de partida deve ser do tipo struct tempo.
c) Desenvolva uma função que escreva o conteúdo dos campos de uma variável estruturada do tipo struct voo. A função recebe como argumento a variável já preenchida.
d) Desenvolva uma função que permita introduzir informação relativa a um novo voo. É passado como argumento um ponteiro para a estrutura a inicializar.
e) Desenvolva uma função que altere a hora de partida de um voo. Recebe como argumento um ponteiro para uma estrutura já preenchida e solicita ao utilizador as novas componentes da hora para efetuar a alteração.
f) Desenvolva uma função que verifique se um determinado voo já partiu. Recebe como argumentos uma estrutura do tipo struct voo onde está armazenada a informação do voo e uma estrutura do tipo struct tempo onde está armazenada a hora atual. Devolve 1 se o voo já tiver partido, ou 0, se isso ainda não tiver acontecido.
g) Declare uma tabela que lhe permita armazenar informação relativa a 300 voos. A tabela deve ser uma variável local da função main().
h) Desenvolva uma função que permita adicionar novos voos à tabela. A função recebe como argumentos um ponteiro para o início da tabela e um ponteiro para o inteiro que indica quantos voos existem. É o utilizador que indica quantas novas entradas quer inserir e que especifica a informação relativa a cada um dos novos voos. A função deve atualizar a tabela e o inteiro referenciado pelo segundo argumento, indicando quantos voos passam a existir.
i) Desenvolva uma função que liste a informação completa de todos os voos armazenados na tabela. A função recebe como argumentos um ponteiro para o início da tabela e o número de voos que esta contém.
j) Desenvolva uma função que verifique quais os voos que partem nos próximos 30 minutos. Deve ser escrito o número, o destino e o tempo que falta para a partida de cada um desses voos. Um ponteiro para o início da tabela de voos, o número de elementos que esta contém e a hora atual são passados como argumentos.
k) Desenvolva uma função que retire da tabela todos os voos que já partiram. São passados como argumentos um ponteiro para o início da tabela, um ponteiro para um inteiro que indica quantos voos esta contém e a hora atual. A função deve atualizar a tabela e o contador de voos.
l) Crie um programa que construa um menu com o seguinte formato:
1. Introduzir novos voos
2. Listar todos os voos
3. Listar proximos voos
4. Atualizar tabela de voos
5. Terminar

O programa deve fazer a gestão das seleções que o utilizador for efetuando. Termina a execução quando for selecionada a opção 5.

Sugestão: Utilize a seguinte função para obter a hora atual do sistema. O resultado é devolvido numa estrutura do tipo struct tempo.

#include <stdio.h>
#include <time.h>

/* Estrutura auxiliar para guardar as componentes da hora */
struct tempo{
    int h, m;
};

struct tempo hora_atual()
{
 time_t a;
 struct tm* b;
 struct tempo atual;

 time(&a);
 b = localtime(&a);
 atual.h = b->tm_hour;
 atual.m = b->tm_min;
return atual;
}

 

/* Exemplo de utilização da função hora_atual() */
int main()
{
 struct tempo t = hora_atual();

 printf(" São %2.2d:%2.2d\n", t.h, t.m);
 return 0;
}

Proposta de trabalho: Altere o programa de gestão do aeroporto de modo a que os voos fiquem ordenados na tabela por hora de partida. Efetue as alterações necessárias nas funções que implementou.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define ST_TAM 50
#define MAX 300


// Estrutura auxiliar para armazenar as componentes de uma hora: horas + minutos (alinea a))

struct tempo{
 int h, m;
};

// Estrutura para armazenar informacao sobre um voo (alinea b))

struct voo{
 int num; // Numero do voo
 char companhia[ST_TAM]; // Companhia
 char destino[ST_TAM]; // cidade de destino
 struct tempo hora_p; // Hora de partida
};


// Funcao que obtem a hora do sistema e a devolve numa estrutura do tipo struct tempo
struct tempo hora_atual()
{
 time_t a;
 struct tm* b;
 struct tempo atual;

 time(&a);
 b = localtime(&a);
 atual.h = b->tm_hour;
 atual.m = b->tm_min;
 return atual;
};


// Funcao auxiliar para mostrar o menu e obter a opcao desejada pelo utilizador
// Devolve a opcao selecionada como resultado
int menu()
{
 int op;
 struct tempo t = hora_atual();

 printf("\n%2.2d:%2.2d\n", t.h, t.m);

 printf("\n1 - Introduzir novos voos");
 printf("\n2 - Listar todos os voos");
 printf("\n3 - Listar proximos voos");
 printf("\n4 - Actualizar tabela de voos");
 printf("\n5 - Veriricar se um voo ja partiu");
 printf("\n6 - Terminar");
 do{
 printf("\nOpcao: ");
 scanf("%d", &op);
 }while(op<1 || op>6);
 return op;
}

//------------------- funcoes a implementar

void alineac(struct voo *p, int t){
int i;
printf("\nTotal de registos: %d", t);
for(i=0; i<t;i++, p++){
 //printf("\nvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->, p[i].companhia, p[i].destino, p[i].hora_p.h, p[i].hora_p.m);
 printf("\nvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
 // printf("\nvoo: %d", p->num);
}

}

void alinead(struct voo *p, int *t, int m){
 char r;
 do{
 printf("\nQuer inserir?");
 scanf(" %c", &r);
 if(r=='s'){
 printf("\n---------------------------");
 printf("\nQual o numero do voo?");
 scanf(" %d", &(p->num));
 printf("Qual o nome da companhia?");
 scanf(" %[^\n]", &(p->companhia));
 printf("Qual o nome do destino?");
 scanf(" %[^\n]", &(p->destino));
 printf("Qual a hora e minutos de partida?");
 scanf("%d %d", &(p->hora_p.h), &(p->hora_p.m));
 (*t)++;
 p=p+(*t);
 }
 }while(r=='s' && *t < m);


}

void alineae(struct voo *p, int t){
 int r, i;

 printf("\nQual o voo que quer alterar? 0 se nenhum");
 scanf(" %d", &r);
 for(i=0; i< t; i++, p++){
 if(r==p->num){
 printf("\n o horario atual e: %d:%d", p->hora_p.h, p->hora_p.m);
 printf("Qual a NOVA hora e minutos de partida?");
 scanf("%d %d", &(p->hora_p.h), &(p->hora_p.m));
 }
 }
}


void alienaf(struct voo *p, int t){
 //nao vai devolver, escreve no final o valor 1 ou 0 dependendo
 int i, sita;
 struct tempo usa = hora_atual();
 for(i=0; i<t;i++, p++){
 if(p->hora_p.h < usa.h && p->hora_p.m < usa.m){
 sita=1;
 }else{
 sita=0;
 }
 printf("\nsituacao: %d\tvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", sita, p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
 }


}

void alienaj(struct voo *p, int t){
 struct tempo usa = hora_atual();
 int i, auxHaM=0, auxHrM=0,y;
 auxHaM=(usa.h*60)+usa.m;
 for(i=0; i<t;i++, p++){
 printf("\n%d:%d-%d:%d", usa.h, usa.m, p->hora_p.h, p->hora_p.m);
 auxHrM=(p->hora_p.h*60)+p->hora_p.m;
 // y= atoi(auxHrM);
 if(auxHrM < auxHaM){
 printf("\n%d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
 }else{
 printf("\nno can do");
 }
 printf("\n%d-%d", auxHaM, auxHrM);

 }
}


int main(int argc, char *argv[])
{
 int i;

 // Declaracao das variaveis locais: (alinea g)
 struct voo aero[MAX];
 int total=0;

 //alinea c
 struct voo testec ={11,"TAP", "London", {12,30}}, tested;

 /*
 struct voo testec ={
 {11,"TAP", "London", {12, 00}},
 {22,"RYN", "Faro", {13, 30}};
 {33,"TAP", "Paris", {18, 00}};
 {44,"RYN", "NY",{22, 30}}
 };
*/
 // Ciclo principal do programa
 do{
 i=menu();
 switch(i){
 case 1:
 //aliena d
 alinead(&aero, &total, MAX);
 break;
 case 2:
 //aliena c
 alineac(aero, total);

 break;
 case 3:
 //alinea j)
 alienaj(aero, total);
 break;
 case 4:
 //alterar a hora do voo alinea e)
 alineac(aero, total); //listar primeiro
 alineae(&aero, total);

 break;
 case 5:
 //verificar se um voo ja partiu f)
 alienaf(aero, total);
 break;
 }
 }while(i!=6);

 return 0;
}

falta verificar as horas e a ultima aliena… :P

ajuda(atoi): LINK

ajuda(estruturas e arrays): LINK

Tags :

Guião laboratorial n.º 2 – exercício 3

Pretende-se criar uma agenda para armazenar números de telefone (nome, rede e número).
a) Crie um tipo estruturado que lhe permita armazenar essa informação.
b) Declare uma tabela que lhe permita armazenar 100 números de telefones. A tabela deve ser uma variável local da função main().
c) Desenvolva uma função que inicialize uma estrutura do tipo telefone. É passado como argumento um ponteiro para a estrutura a inicializar. Os dados são fornecidos pelo utilizador.
d) Desenvolva uma função que liste todas as pessoas cujo telefone pertença a uma determinada rede. A função recebe como argumentos um ponteiro para o início da tabela, o número de elementos que esta contém e a indicação de qual a rede em causa.
e) Desenvolva uma função que descubra todas as pessoas que vivem na mesma casa. Considere que duas pessoas vivem na mesma casa se tiverem o mesmo número de telefone;
f) Desenvolva uma função para retirar da tabela a informação relativa a uma pessoa cujo nome é passado como parâmetro. Pode assumir que os nomes são únicos.
g) Criar um programa que inicialize tabela com informação sobre determinado número de pessoas (o número de pessoas é introduzido através da linha de comando). A seguir deve listar todas as pessoas que pertencem a uma determinada rede (cuja identificação também é passado como argumento da linha de comando). Finalmente, o programa deve pedir ao utilizador que introduza o nome de uma pessoa para ser retirada da tabela.

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TAM 100

struct agenda{
char nome[20];
char rede[20];
int numero;
};

void preenhcer(struct agenda *a, int *t, int tam){
  char r;
  do{
  printf("\nQuer inserir?");
  scanf(" %c", &r);
    if(r=='s'){
      printf("\n---------------------------");
      printf("\nQual o nome?");
      scanf(" %[^\n]", &(a->nome));
      printf("\nQual a rede?");
      scanf(" %[^\n]", &(a->rede));
      printf("\nQual o numer?");
      scanf(" %d", &(a->numero));
      (*t)++;
      a=a+(*t);
    }
  }while(r=='s' && *t < tam);
}

void listar(struct agenda *l, int *t){
int i, a = *t;

for(i=0;i<a;i++, l++){
  printf("\n%s", l->nome);
  printf("\n%s", l->rede);
  printf("\n%d", l->numero);

}

}

void listar_filtro(struct agenda *l, int t, char *f){
struct agenda *k;
int i;
     printf("\n--------------------------- listar com filtro1 %s", f);

      for(i=0, k=l; i<t; i++, k++){

          if(strcmp(f, k->rede)==0){
            printf("\n%s", k->nome);
            printf("\n%s", k->rede);
            printf("\n%d", k->numero);
          }
      }
}


void listar_filtro2(struct agenda *r, int t, int f){
int i;
 printf("\n--------------------------- listar com filtro2 %d", f);
for(i=0;i<t; i++, r++){
    if(r->numero == f){
      printf("\n %d: %s", i, r->nome);
    }
}
r=0;
}

int retirar(struct agenda *l, int t, char *f){
struct agenda *k;
int i;
     printf("\n--------------------------- retriar da lista: %s", f);

      for(i=0, k=l; i<t; i++, k++, l++){

          if(strcmp(f, k->nome)==0){
            k[i]=k[i+1];
            t=t-1;
          }
      }

return t;
}

void listaR(struct agenda *l, int t){
int i;

for(i=0;i<t;i++, l++){
  printf("\n%s", l->nome);
  printf("\n%s", l->rede);
  printf("\n%d", l->numero);

}

}

int main()
{
  //alinea a
  struct agenda guarda[TAM];
  int t=0;
  preenhcer(guarda, &t, TAM);
  //listar(guarda, t);
  //alinea d - listar filtro
  char filtro[20]="meo";

  printf("total: %d", t);
  //listar_filtro(guarda, t, filtro);
  //alinea e - listar filtro mesma casa
  int filtro2=91;
  //listar_filtro2(guarda, t, filtro2);
  //alinea f
  char nome_retirar[20]="Pedro";
  int auxR;
  auxR=retirar(guarda, t, nome_retirar);
  t=auxR;
  listaR(guarda, t);


  return 0;
}


entendo que a alinea g) é igual a todas as outras por isso não a fiz!

Tags :

Guião laboratorial n.º 2 – exercício 2

polícia pretende armazenar informação sobre um conjunto de criminosos. Para cada um dos criminosos, a informação a armazenar é a seguinte: nome, altura (em cm) e peso (em Kg).
a) Crie um tipo estruturado que permita guardar a informação relativa a um criminoso;
b) Declare uma tabela que permita armazenar um máximo de 100 criminosos. A tabela deve ser uma variável local da função main().
Após ter declarado a tabela, inicialize-a com os criminosos: {“Joao Ratao”, 175 cm, 120 Kg};
{“Gato das Botas”, 199 cm, 67 Kg}; {“Mancha Negra”, 150 cm, 80 Kg}; {“Etelvina Seabra”,
156 cm, 45 Kg}.
c) Desenvolva uma função que escreva no monitor a informação relativa a um criminoso. A função recebe, como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém e a posição em que se encontra a estrutura relativa ao criminoso pretendido;
d) Desenvolva uma função que procure suspeitos de um determinado crime. A função recebe,como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém, o peso aproximado e a altura aproximada do suspeito. Deve percorrer a tabela e escrever no monitor a informação relativa a criminosos cuja diferença de peso e de altura não seja superior a 10% dos valores indicados como argumento.
e) Desenvolva uma função que permita retirar da tabela a informação relativa a uma pessoa. A função recebe, como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém e o nome da pessoa a retirar. Se existir alguém com esse nome na tabela a sua estrutura deve ser eliminada. Devolve como resultado o número de elementos que ficaram na tabela após a eliminação.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//alinea b
#define TAM 100

//alinea a
struct criminoso {
char nome[20];
int alturaCM;
int pesoKg;
};

void mostra_criminoso(struct criminoso *c,int t, int v){
int i;
for(i=0; i< t; i++, c++){
  if(i==v){
  printf("nome: %s", c->nome);
  printf("\naltura: %dcm",c->alturaCM);
  printf("\npeso: %dkg",c->pesoKg);
  }
}

}
//d
void procura_criminoso(struct criminoso *p, int t, int a_procura, int p_procura){
int i;
float cimaK, baixoK, cimaA, baixoA;

  baixoK=p_procura/1.1;
  cimaK=p_procura*1.1;
  baixoA=a_procura/1.1;
  cimaA=a_procura*1.1;
  printf("\nreferencias: %.2f--%.2f kg %.2f--%.2f cms", cimaK, baixoK, cimaA, baixoA);

for(i=0; i< t; i++, p++){
  if(p->pesoKg >= baixoK && p->pesoKg <= cimaK && p->alturaCM >= baixoA && p->alturaCM <= cimaA){
  printf("\nnome: %s", p->nome);
  printf("\naltura: %dcm",p->alturaCM);
  printf("\npeso: %dkg",p->pesoKg);
  }
}
}

//alinea e

//notworking
int elemina_criminoso(struct criminoso *e, int t, char *nome){
struct criminoso *f;
int novot, i;
char aux[20];

for(i=0, f=e; i<t; i++, e++,f++){
  if(strcmp(nome, e->nome)==0){
    printf("\nexiste");
    e[i]=e[i+1];
    t=t-1;
  }
}

novot= t;
return novot;
}


void mostra_T(struct criminoso *c,int t){
int i;
printf("\n---------------------------------------------");
for(i=0; i< t; i++, c++){
  printf("\nnome: %s", c->nome);
  printf("\naltura: %dcm",c->alturaCM);
  printf("\npeso: %dkg",c->pesoKg);

}

}

int main()
{
//alinea b


struct criminoso tabela_crime[TAM] = {
                      {"Joao Ratao",      175,  120},
                      {"Gato das Botas",  199,  67},
                      {"Mancha Negra",    150,  80},
                      {"Etelvina Seabra", 156,  45}
                      };

  int t=4;
  int ver_criminoso=2;
  //mostra_criminoso(tabela_crime, t, ver_criminoso);

//alinea d

  int altura_procurar=160;
  int peso_procurar=45;
  //procura_criminoso(tabela_crime, t, altura_procurar, peso_procurar);

//aliena e
  char nome_procurar[20]="Joao Ratao";
  printf("\ntotal de elementos iniciais: %d", t);
    mostra_T(tabela_crime, t);
  t=elemina_criminoso(tabela_crime, t, nome_procurar);
  printf("\ntotal de elementos atuais: %d", t);
  mostra_T(tabela_crime, t);

  return 0;
}

esta incompleto o eliminar não percebi a atualização!!!

+ajudas: LINK

+ajudas: LINK

+ajudas: LINK

Tags :

Guião laboratorial n.º 2 – exercício 1

1. Considere que necessita de armazenar informação sobre figuras geométricas num espaço com duas dimensões.
a) Crie tipos estruturados que lhe permitam representar um ponto e um retângulo.
b) Desenvolva uma função que inicialize uma estrutura do tipo retângulo. Toda a informação necessária deve ser fornecida pelo utilizador. A função devolve a estrutura inicializada.
c) Desenvolva uma função que devolva a área de uma estrutura do tipo retângulo passada como  argumento;
d) Desenvolva uma função que verifique se uma estrutura do tipo retângulo passada como
argumento é um quadrado. Se for, a função deve devolver 1. Caso contrário, devolve 0.
e) Desenvolva uma função que receba, como argumentos, uma estrutura do tipo retângulo e um ponto e devolva 1 se o ponto estiver dentro do retângulo.
f) Desenvolva uma função que desloque um retângulo no plano. A função recebe três argumentos: um ponteiro para o retângulo o deslocar, o deslocamento ao longo do eixo xx e o deslocamento ao longo do eixo yy.
g) Declare uma tabela que permita armazenar 4 retângulos. A tabela deve ser uma variável local da função main(). Utilize a função desenvolvida na alínea b) para preencher todos os elementos da tabela.
h) Desenvolva uma função que verifique se numa tabela onde estejam armazenados vários retângulos existem dois que tenham a mesma área. A função recebe como argumentos o endereço do primeiro elemento da tabela e o número de elementos que esta contém. Como resultado, deve devolver o valor 1 se existirem dois retângulos com a mesma área (devolve 0 se todos os retângulos tiverem áreas diferentes).

 

#include <stdio.h>
#include <stdlib.h>

#define TAM 4


struct ponto{
  int oX;
  int oY;
};

typedef struct retangulo{
  struct ponto n;
  int largura;
  int altura;
} r1;

struct retangulo r;
struct ponto p;

void iniciaR(){
scanf(" %d", &r.n.oX);
scanf(" %d", &r.n.oY);
scanf(" %d", &r.largura);
scanf(" %d", &r.altura);

};

void iniciaP(){
scanf(" %d", &p.oX);
scanf(" %d", &p.oY);

};

void verdados(){
printf("\nOrigemX: %d, OrigemY: %d, Largura: %d, Altura: %d\n", r.n.oX, r.n.oY, r.largura, r.altura);
}
void verdados2(){
printf("\nPonto OrigemX: %d, Ponto OrigemY: %d\n", p.oX, p.oY);
}


int verarea(struct retangulo k){
int area;
area=k.altura*k.largura;

return area;
}
int verificaQ(struct retangulo k){

if(k.altura==k.largura){
    return 1;
}
else{
    return 0;
}

}

int verificaDentro(struct retangulo k, struct ponto pn){
if(pn.oX<(k.n.oX+k.largura) && pn.oY<(k.n.oY+k.altura) && pn.oX>=k.n.oX && pn.oY>=k.n.oY){
  return 1;
}else{
  return 0;
}
}

void deslocar(r1 *p, int ax, int ay){

  printf("\no quadrado esta na origem em %d %d", p->n.oX, p->n.oY);
  p->n.oX = p->n.oX+ax;
  p->n.oY = p->n.oY+ay;
  printf("\no quadrado foi deslocado para %d %d", p->n.oX, p->n.oY);

}
//g
void iniciaR2(struct rg *p, int d){
int i;
for(i=0;i<d;i++){
  scanf(" %d", &r.n.oX);
  scanf(" %d", &r.n.oY);
  scanf(" %d", &r.largura);
  scanf(" %d", &r.altura);
}
};

void verdados3(){
printf("\nOrigemX: %d, OrigemY: %d, Largura: %d, Altura: %d\n", r.n.oX, r.n.oY, r.largura, r.altura);
}



int main()
{
  iniciaR();
  verdados();
  printf("A area tem o valor de: %d", verarea(r));
  if(verificaQ(r)==1){
    printf("\ne quadrado\n");
  }else{
    printf("\nnao e quadrado\n");
  }
  iniciaP();
  if(verificaDentro(r, p)==1){
    printf("\nesta dentro\n");
  }else{
    printf("\nnao esta dentro\n");
  }
  //f)
  int deslocaX=2;
  int deslocaY=2;
  deslocar(&r, deslocaX, deslocaY);
  //g)
  struct retangulo rG[TAM];

  iniciaR2(rG, TAM);
  //verdados3(r1 tabela, TAM);


  return 0;
}

//incompleto

Tags : ,

Guião laboratorial n.º 1 – exercício 21

“Considere que pretende resolver um quebra-cabeças que surgiu no seu jornal. Existe um retângulo, com um determinado número de linhas e um determinado número de colunas, preenchido com caracteres alfabéticos em cada uma das suas posições. Na figura pode ver um exemplo para um quebra cabeças com 5 linhas e 6 colunas.
21
Desenvolva uma função que procure todas as ocorrências de uma determinada palavra no quebra cabeças. A palavra pode ocorrer numa linha ou numa coluna. De cada vez que a função encontrar uma ocorrência da palavra deve escrever no monitor o número da linha e da coluna em que a palavra tem início. Considerando o exemplo da figura, se a palavra a pesquisar for lua a função deveria escrever:
A palavra lua surge:
– Ao longo da coluna 0 com início na linha 1
– Ao longo da linha 3 com início na coluna 3
A função recebe como argumentos o endereço inicial da matriz de caracteres, as suas dimensões (n.º de linhas e de colunas) e um ponteiro para a palavra a pesquisar.”



Tags :