Calcular volume de cilindro em C

[Clara12]

[Claudio Marques]

/*----Apenas um esqueleto de como pode ser feito o programa, ainda a escrever as opcoes do menu 5 e 6, tambem
ainda sem controles de entrada de dados errada, etc, mas é um bom norte para terminar e refinar o programa---*/

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

//struct formatando input de dados e armazenagem 
struct volume_cilindros
            {
                int id_volume, altura_cilindro, raio_cilindro;
                float volume_cilindro;
            };
            
//ponteiro para manusear lista de volume_cilindros
struct volume_cilindros *sequencia_vol_cilindros;
            
void adicionarelementolista(struct volume_cilindros *sequencia_vol_cilindros, int *tamanho_lista, int novo_id_volume,
                                int nova_altura_cilindro, int novo_raio_cilindro, float novo_volume_cilindro)
        {
            
            
            
            
            if(*tamanho_lista == 0)
                {
                    struct volume_cilindros *novalista;
                    novalista = (struct volume_cilindros*) malloc(1 * sizeof(struct volume_cilindros));
                    
                    //novos dados salvo em nova lista
                    (novalista[0]).id_volume = novo_id_volume;
                    (novalista[0]).volume_cilindro = novo_volume_cilindro;
                    (novalista[0]).altura_cilindro = nova_altura_cilindro;
                    (novalista[0]).raio_cilindro = novo_raio_cilindro;
                    
                    //inserindo dados lista original
                    (sequencia_vol_cilindros[0]).id_volume = (novalista[0]).id_volume;
                    (sequencia_vol_cilindros[0]).volume_cilindro = (novalista[0]).volume_cilindro;
                    (sequencia_vol_cilindros[0]).altura_cilindro = (novalista[0]).altura_cilindro;
                    (sequencia_vol_cilindros[0]).raio_cilindro = (novalista[0]).raio_cilindro;
                    
                    free(novalista);
                    
                }else
                    {
                        struct volume_cilindros *copialista;
                        copialista = (struct volume_cilindros*) malloc((*tamanho_lista + 1) * sizeof(struct volume_cilindros));
                    
                        //novos dados salvos em copialista    
                        (copialista[0]).id_volume = novo_id_volume;
                        (copialista[0]).volume_cilindro = novo_volume_cilindro;
                        (copialista[0]).altura_cilindro = nova_altura_cilindro;
                        (copialista[0]).raio_cilindro = novo_raio_cilindro;
                        
                    
                        //Passa os elementos da lista antiga para a nova uma posicao a frente
                        
                        int cont;
                        for(cont = 0; cont < *tamanho_lista; cont++)
                            {
                                
                                (copialista[cont + 1]).id_volume = (sequencia_vol_cilindros[cont]).id_volume;
                                (copialista[cont + 1]).volume_cilindro = (sequencia_vol_cilindros[cont]).volume_cilindro;
                                (copialista[cont + 1]).altura_cilindro = (sequencia_vol_cilindros[cont]).altura_cilindro;
                                (copialista[cont + 1]).raio_cilindro = (sequencia_vol_cilindros[cont]).raio_cilindro;
                                
                            
                            }
                        
                    
                        //salva tudo na lista original
                        for(cont = 0; cont < *tamanho_lista + 1; cont++)
                            {
                                (sequencia_vol_cilindros[cont]).id_volume = (copialista[cont]).id_volume;
                                (sequencia_vol_cilindros[cont]).volume_cilindro = (copialista[cont]).volume_cilindro;
                                (sequencia_vol_cilindros[cont]).altura_cilindro = (copialista[cont]).altura_cilindro;
                                (sequencia_vol_cilindros[cont]).raio_cilindro = (copialista[cont]).raio_cilindro;
                            }
                        
                    free(copialista);
                    
                    
                    }
            
            *tamanho_lista = *tamanho_lista + 1;
            
            
        }
        
void removeelemento(struct volume_cilindros *sequencia_vol_cilindros, int *tamanho_lista, int posicao)
    {
        struct volume_cilindros *copialista;
        
        copialista = (struct volume_cilindros*) malloc((*tamanho_lista - 1) * sizeof(struct volume_cilindros));
        
        if(posicao == 0)
            {
                int cont;
                
                //despreza o primeiro elemento
                for(cont = 1; cont < *tamanho_lista; cont++)
                    {
                        (copialista[cont - 1]).id_volume = (sequencia_vol_cilindros[cont]).id_volume;
                        (copialista[cont - 1]).volume_cilindro = (sequencia_vol_cilindros[cont]).volume_cilindro;
                        (copialista[cont - 1]).altura_cilindro = (sequencia_vol_cilindros[cont]).altura_cilindro;
                        (copialista[cont - 1]).raio_cilindro = (sequencia_vol_cilindros[cont]).raio_cilindro;
                    }
                
                //salva na lista original    
                for(cont = 0; cont < *tamanho_lista - 1; cont++)
                    {
                        (sequencia_vol_cilindros[cont]).id_volume = (copialista[cont]).id_volume;
                        (sequencia_vol_cilindros[cont]).volume_cilindro = (copialista[cont]).volume_cilindro;
                        (sequencia_vol_cilindros[cont]).altura_cilindro = (copialista[cont]).altura_cilindro;
                        (sequencia_vol_cilindros[cont]).raio_cilindro = (copialista[cont]).raio_cilindro;
                    }
            }else
                {
                    //Passa os elementos da lista antiga para a nova ate o elemento desejado
                    int cont;
                    for(cont = 0; cont < *tamanho_lista - 1; cont++)
                        {

                            if(cont < posicao)
                                {
                                    //Faz uma copia dos elementos ate a posicao
                                    (copialista[cont]).id_volume = (sequencia_vol_cilindros[cont]).id_volume;
                                    (copialista[cont]).volume_cilindro = (sequencia_vol_cilindros[cont]).volume_cilindro;
                                    (copialista[cont]).altura_cilindro = (sequencia_vol_cilindros[cont]).altura_cilindro;
                                    (copialista[cont]).raio_cilindro = (sequencia_vol_cilindros[cont]).raio_cilindro;
                                }else if(posicao < *tamanho_lista - 1)
                                        {
                                            //Faz uma copia dos elementos apos a posicao, se ela não for a ultima 
                                            (copialista[cont]).id_volume = (sequencia_vol_cilindros[cont + 1]).id_volume;
                                            (copialista[cont]).volume_cilindro = (sequencia_vol_cilindros[cont + 1]).volume_cilindro;
                                            (copialista[cont]).altura_cilindro = (sequencia_vol_cilindros[cont+ 1]).altura_cilindro;
                                            (copialista[cont]).raio_cilindro = (sequencia_vol_cilindros[cont + 1]).raio_cilindro;
                                        }
                        }    

                    //salva lista original
                    for(cont = 0; cont < *tamanho_lista - 1; cont++)
                                {
                                    (sequencia_vol_cilindros[cont]).id_volume = (copialista[cont]).id_volume;
                                    (sequencia_vol_cilindros[cont]).volume_cilindro = (copialista[cont]).volume_cilindro;
                                    (sequencia_vol_cilindros[cont]).altura_cilindro = (copialista[cont]).altura_cilindro;
                                    (sequencia_vol_cilindros[cont]).raio_cilindro = (copialista[cont]).raio_cilindro;
                                }
                }
            
            
            free(copialista);
            *tamanho_lista = *tamanho_lista - 1;
            
    }
    
float retornavolume(struct volume_cilindros *sequencia_vol_cilindros, int *tamanho_lista, int novo_id_volume, int *posicao)
    {
        int cont, aux;
        for(cont = 0; cont < *tamanho_lista; cont++)
            {

                //Se encontrar alguém com o id_volume procurado
                if((sequencia_vol_cilindros[cont]).id_volume == novo_id_volume)
                    {
                        printf("Encontrado na posicao %d\n", cont);
                        aux = cont;
                    }
            }
            
        return ((sequencia_vol_cilindros[aux]).volume_cilindro);
    }
    
void imprimesequencia(struct volume_cilindros *sequencia_vol_cilindros, int tamanho_lista)
    {
        int cont;
               for(cont = 0; cont < tamanho_lista ; cont++)
                   {
                       printf("\ntamanho_lista %d |", tamanho_lista);
                       printf("%d |", cont);
                    printf("%d |", (sequencia_vol_cilindros[cont]).id_volume);
                    printf("%.2f |", (sequencia_vol_cilindros[cont]).volume_cilindro);
                    printf("%d |", (sequencia_vol_cilindros[cont]).altura_cilindro);
                    printf("%d |", (sequencia_vol_cilindros[cont]).raio_cilindro);
                }
    }

int main(void)
    {
        //ponteiro para manusear lista de volume_cilindros
        struct volume_cilindros *sequencia_vol_cilindros;
        
        int tamanho_lista = 0, operador = 0, posicao;
        
        while(operador < 7 && operador >= 0)
            {
                printf("\nTamanho atual da lista: %d", tamanho_lista);
                
                printf("\nOpcoes");
                
                printf("\n1 - Insercao de elemento na lista\n");
                
                printf("\n2 - Retirada de elemento da lista na posicao N\n");
                
                printf("\n3 - Procurar um elemento na lista com o campo id_volume\n");
                
                printf("\n4 - Imprimir lista\n");
                
                printf("\n5 - Gravar lista\n");
                
                printf("\n6 - Abrir lista\n");
                
                printf("\n7 - Sair\n");
                
                fflush(stdin);
                scanf("%d", &operador);
                getchar();
                
                //variaveis para inclusao de elementos 
                int novo_id_volume, nova_altura_cilindro, novo_raio_cilindro; 
                float novo_volume_cilindro;
                
                switch(operador)
                    {
                        case 1:
                            printf("\nDigite o id_volume do novo elemnto da lista\n");
                            fflush(stdin);
                            scanf("%d", &novo_id_volume);
                            
                            printf("\nDigite a altura do cilindro em mm\n");
                            fflush(stdin);
                            scanf("%d", &nova_altura_cilindro);
                            
                            printf("\nDigite o raio do cilindro em mm\n");
                            fflush(stdin);
                            scanf("%d", &novo_raio_cilindro);
                            
                            novo_volume_cilindro = 3.1416 * (float)pow(novo_raio_cilindro, 2) * (float)nova_altura_cilindro;
                            
                            adicionarelementolista(&sequencia_vol_cilindros, &tamanho_lista, novo_id_volume,
                                nova_altura_cilindro, novo_raio_cilindro, novo_volume_cilindro);
                                
                            break;
                            
                        case 2:
                            printf("\nDigite a Posicao: ");
                            fflush(stdin);
                            scanf("%d", &posicao);
                            
                            removeelemento(&sequencia_vol_cilindros, &tamanho_lista, posicao);
                            
                            break;
                            
                        case 3:
                            printf("\nDigite o id_volume");
                            fflush(stdin);
                            scanf("%d", &novo_id_volume);
                            
                            printf("\%.2f", retornavolume(&sequencia_vol_cilindros, &tamanho_lista, 
                                novo_id_volume, &posicao));
                            break;
                                
                        case 4:
                            imprimesequencia(&sequencia_vol_cilindros, tamanho_lista);
                            
                            break;
                            
                        case 5:
                            //a desenvolver
                            break;
                            
                        case 6:
                            //a desenvolver
                            break;
                            
                        
                    }
            }
        
        
        return 0;        
        
    }