Conteúdo de LP

Grey

Conteúdo de LP

vetores:

Grey

3 min

Aplicações com estruturas de dados simples:

vetores:

O vetor é uma estrutura de dados indexada, que pode armazenar uma determinada quantidade de valores do mesmo tipo.

Os dados armazenados em um vetor são chamados de itens do vetor.

Para localizar a posição de um item em um vetor usamos um número inteiro denominado índice do vetor.Vantagem de utilização do vetor

Facilidade de manipular um grande conjunto de dados do mesmo tipo declarando-se apenas uma variável. Pseudocódigo:

matrizes:

registros:

Manipulação de strings;

Ao contrário de outras linguagens, C não possui operador que atue com operandos do tipo cadeia de caracteres. Qualquer manipulação de strings é feita através de funções da biblioteca padrão de C. Nesta seção, apresentaremos algumas destas funções, cujos protótipos estão no arquivo string.h.

Funções: conceito, variável global e local, retornando valores de funções;

Definição de Função Uma função nada mais é do que uma subrotina usada em um programa.

Na linguagem C, denominamos função a um conjunto de comandos que realiza uma tarefa específica em um módulo dependente de código.

A função é referenciada pelo programa principal através do nome atribuído a ela.

A utilização de funções visa modularizar um programa, o que é muito comum em programação estruturada. Desta forma podemos dividir um programa em várias partes, no qual cada função realiza uma tarefa bem definida.

Conceito, aplicações e aritmética de ponteiros;

Passagem de parâmetro por valor e por referência;

Diferença entre passagem por valor e passagem por referência

Na passagem por valor, é passada uma cópia do valor da variável. Na passagem por referência, é passada uma referência à própria variável. Isso é verdade independentemente do tipo da variável.

Prototipação ( typedef );

O comando typedef é usado para criar “sinônimo” ou um “alias” para tipos de dados existentes. Então na prática podemos dizer que estamos renomeando um tipo de dados.

A renomeação de tipos facilita a organização e o entendimento do código.

Sintaxe:

typedef <nome do tipo de dado> <novo nome>;

É importante ressaltar que o comando typedef não cria um novo tipo. Ele apenas permite que um tipo existente seja denominado de uma forma diferente, de acordo com a especificação desejada pelo programador.


          
            #include <stdio.h>
          
          
            #include <conio.h>
          
          
            int main (void)
          
          
            {
          
          
            	//redefinição do tipo float como nota
          
          
            	typedef float nota;
          
          
            	
          
          
            	//declarando as variáveis usando o tipo de dados renomeado
          
          
            	nota prova1 = 0, prova2 = 0, media = 0;
          
          
            	
          
          
            	printf ("Informe a nota da primeira prova: ");
          
          
            	scanf ("%f", &prova1);
          
          
            	
          
          
            	printf ("Informe a nota da segunda prova: ");
          
          
            	scanf ("%f", &prova2);
          
          
            	
          
          
            	media = (prova1 + prova2) / 2;
          
          
            	
          
          
            	printf ("Media do aluno: %.2f\n", media);
          
          
            	getch();
          
          
            	return 0;
          
          
            }

Alocação Dinâmica de memória;

Alocação Estática

Na alocação estática de memória, os tipos de dados tem tamanho predefinido. Neste caso, o compilador vai alocar de forma automática o espaço de memória necessário. Sendo assim, dizemos que a alocação estática é feita em tempo de compilação. Este tipo de alocação tende a desperdiçar recursos, já que nem sempre é possível determinar previamente qual é o espaço necessário para armazenar as informações. Quando não se conhece o espaço total necessário, a tendência é o programador exagerar pois é melhor superdimensionar do que faltar espaço.

Alocação Dinâmica

Na alocação dinâmica podemos alocar espaços durante a execução de um programa, ou seja, a alocação dinâmica é feita em tempo de execução. Isto é bem interessante do ponto de vista do programador, pois permite que o espaço em memória seja alocado apenas quando necessário. Além disso, a alocação dinâmica permite aumentar ou até diminuir a quantidade de memória alocada.


          
            #include <stdio.h>
          
          
            #include <stdlib.h> //necessário para usar as funções malloc() e free()
          
          
            #include <stdlib.h>
          
          
            int main(void)
          
          
            {
          
          
              int i,j,n_linhas,n_colunas;
          
          
              
          
          
              //matrizes dinâmicas de duas dimensões portanto vamos necessitar um ponteiro para a linha
          
          
              //e outro ponteiro apontando para coluna
          
          
              
          
          
              int **matriz1,**matriz2,**matriz_soma; 
          
          
              FILE *ptrArq;
          
          
              
          
          
              //Abrindo o arquivo
          
          
              ptrArq = fopen("ArqMatrizes.txt", "r");
          
          
              
          
          
              //Verificando se a abertura do arquivo foi bem sucedida
          
          
              if (ptrArq == NULL)
          
          
              {
          
          
                printf("Erro ao abrir o arquivo!\n");
          
          
                printf("Saindo do programa...\n");
          
          
                system("pause");
          
          
                exit(1);//abortando o programa
          
          
              }
          
          
              
          
          
              // Leitura das dimensões da matriz a partir dos valores do arquivo
          
          
              fscanf(ptrArq,"%d %d",&n_linhas,&n_colunas);
          
          
              
          
          
              // Alocar a memória necessária para as matrizes  
          
          
              //----------------- Alocando a matriz1 ---------------
          
          
              
          
          
              // alocar a quantidade de linhas
          
          
              matriz1 = (int **)calloc(n_linhas,sizeof(int *)); 
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
               // alocar a quantidade de colunas de cada linha
          
          
                matriz1[i] = (int *)calloc(n_colunas,sizeof(int));
          
          
              }
          
          
                
          
          
              //----------------- Alocando a matriz2 ---------------
          
          
              matriz2 = (int **)calloc(n_linhas,sizeof(int *));
          
          
              
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                matriz2[i] = (int *)calloc(n_colunas,sizeof(int));
          
          
              }
          
          
                
          
          
               
          
          
              // ------- Ler os valores para as matrizes a partir do arquivo texto ------   
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                  fscanf(ptrArq,"%d",&matriz1[i][j]);//ler um inteiro do arquivo e armazenar na matriz1
          
          
              }      
          
          
              }
          
          
                
          
          
                  
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                  fscanf(ptrArq,"%d",&matriz2[i][j]);//ler um inteiro do arquivo e armazenar na matriz2
          
          
              }     
          
          
              }
          
          
                  
          
          
              fclose(ptrArq);//Fechar o arquivo
          
          
                  
          
          
              // --------------- Mostrar as matrizes lidas ---------------------
          
          
              printf("Matrizes lidas do arquivo:\n");
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                  printf("%2d ",matriz1[i][j]);
          
          
              }      
          
          
                
          
          
              printf("       ");  //Espaçamento entre as duas matrizes
          
          
                
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                    printf("%2d ",matriz2[i][j]);
          
          
              }           
          
          
                printf("\n");
          
          
              }
          
          
              
          
          
              // Alocar memoria para matriz soma
          
          
              matriz_soma = (int **)calloc(n_linhas,sizeof(int *));
          
          
              
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                matriz_soma[i] = (int *)calloc(n_colunas,sizeof(int));
          
          
              }
          
          
                
          
          
                
          
          
              // Calcular matriz soma
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                   matriz_soma[i][j] = matriz1[i][j] + matriz2[i][j];
          
          
              }     
          
          
              }    
          
          
                  
          
          
              // Mostrar matriz soma
          
          
              printf("\nMatriz soma:\n");
          
          
              for (i = 0; i < n_linhas; i++)
          
          
              {
          
          
                for (j = 0; j < n_colunas; j++)
          
          
                {
          
          
                   printf("%3d ",matriz_soma[i][j]);  
          
          
              }     
          
          
                printf("\n");
          
          
              }        
          
          
              
          
          
              //liberando a memória da matriz1 
          
          
              //para matrizes a liberação da memória ocorre na ordem inversa da alocação
          
          
                for (i=0; i < n_linhas; i++)
          
          
              {
          
          
                free (matriz1[i]) ;
          
          
              }     
          
          
              free (matriz1) ;
          
          
              //liberando a memória da matriz2 
          
          
              for (i=0; i < n_linhas; i++)
          
          
                 free (matriz2[i]) ;
          
          
              free (matriz2) ;
          
          
              //liberando a memória da matriz_soma
          
          
              for (i=0; i < n_linhas; i++)
          
          
                 free (matriz_soma[i]) ;
          
          
              free (matriz_soma);
          
          
              
          
          
              printf("\n");     
          
          
              system("pause"); 
          
          
              return 0;
          
          
            }

Manipulação de arquivos.

As operações de entrada e saída do C, incluindo as relacionadas a arquivos, encontram-se na

biblioteca stdio.h. Essa biblioteca também define várias macros, dentre elas NULL e EOF, que definem um ponteiro nulo e o fim de arquivo, respectivamente. Além disso, é nela que está definido o tipo FILE.

Na Tabela 1 são listadas as principais funções relacionadas a manipulação de arquivos existentes na biblioteca stdio.h

Learn

Support

More Options