• Nenhum resultado encontrado

Revisão AB1 ED

N/A
N/A
Protected

Academic year: 2021

Share "Revisão AB1 ED"

Copied!
53
0
0

Texto

(1)

ESTRUTURAS DE DADOS

(2)

PROBLEMA

Calcule a média de n números dados e depois de

imprimir a média, devemos imprimir todos os

números dados novamente.

(3)

ARRAY :: SINTAXE

<tipo de dado> <identificador>[<quantidade

máxima de elementos>]

Exemplo:

(4)

FLOAT VALORES[1000];

v[0] = 35.5; // atribui um valor a uma posição do

array

(5)

OUTRAS FORMAS DE INICIALIZAÇÃO

int meu_array[100] = {0}; // todas as posições com

zero

int meu_array[100] = {5}; // apenas a primeira

posição é inicializada

int meu_array[100] = {5,12}; // apenas a primeira e a

segunda

(6)

SE USARMOS ARRAY COM UMA DIMENSÃO

float joao[4];

float julia[4];

float maria[4];

float ambrosio[4];

float taise[4];

MAS E SE A TURMA TIVESSE MUITOS

ALUNOS???

(7)

ARRAY BIDIMENSIONAL

<tipo de dado> <identificador>[<linhas>]

[<colunas>];

Exemplo:

float notas[5][4];

0

1

2

3

0

1

2

3

4

(8)

ATRIBUINDO

notas[0][0] = 5.5;

0

1

2

3

0

5.

5

1

2

3

4

(9)

SEGUNDA NOTA DA TAÍSE

notas[4][1] = 8.0;

0

1

2

3

0

5.5

1

2

3

4

8.

0

(10)

SCANF NA MATRIZ

notas[0][0] = 5.5 ; //atribuição fixa no código

scanf(“%f”,&notas[0][0]); // leitura do teclado

(11)

EXERCÍCIO :: FAZENDO JUNTOS

Vamos fazer um programa que lê duas matrizes de

inteiros e preenche uma terceira matriz com o

resultado da soma das duas. As matrizes possuem

dimensões N x M, onde N e M serão dados pelo

(12)

SOLUÇÃO

https://github.com/r0drigopaes/livro/blob/master/10_11.

c

(13)

TIPO

Um tipo define o conjunto de valores válidos para

aquela variável.

Exemplos:

int : números inteiros

float : números reais

char : caractere

(14)

PONTEIRO

Um tipo capaz de armazenar endereços e memória

Usado para manipular diretamente a memória

(15)

A MEMÓRIA

Código: área onde o programa

compilado reside;

Global: variáveis globais

Pilha: parâmetros de funções e

variáveis locais

(16)
(17)

DECLARAÇÃO

<tipo do conteúdo armazenado no endereço de memória> *

<identificador>;

(18)

PONTEIROS

 Ponteiros guardam endereços de memória.

 Um ponteiro também tem tipo. No C quando declaramos ponteiros nós

informamos ao compilador para que tipo de variável vamos apontá-lo.

Por exemplo, um ponteiro int aponta para um inteiro, isto é, guarda o

(19)

PONTEIROS

 Para declarar um ponteiro temos a seguinte forma geral:

tipo_do_ponteiro *nome_da_variável;

 É o asterisco (*) que faz o compilador saber que aquela variável não vai

guardar um valor mas sim um endereço para aquele tipo especificado.

 Exemplos:

int *pt;

char *temp, *pt2;

 Ponteiros não inicializados apontam para um lugar indefinido.  Os ponteiros devem ser inicializados (apontado para algum lugar

(20)

PONTEIROS

 Para atribuir um valor a um ponteiro recém-criado poderíamos igualá-lo

a um valor de memória.

 Mas, como saber a posição na memória de uma variável do nosso

programa?

 Podemos então deixar que o compilador faça este trabalho por nós. Para

saber o endereço de uma variável basta usar o operador &. Veja o exemplo:

int count=10; int*pt;

(21)

PONTEIROS

 Para alterar o valor de uma variável apontado por um ponteiro, basta

usar o operador *.

 Resumindo:

*pt: o conteúdo da posição de memória apontado por pt; &count: o endereço onde armazena a variável count.

int count=10; int*pt;

pt = &count; *pt = 12;

OBS: Apesar do símbolo ser o mesmo, o operador * (multiplicação) não é o mesmo

operador que o * (referência de ponteiros). Para começar o primeiro é binário, e o segundo é unário pré-fixado.

(22)

PONTEIROS

EXEMPLO 1

#include <stdio.h>

void main (){

int num, valor; int*p;

num = 55;

p = &num; /* Pega o endereco de num */ valor = *p;

/* Valor e igualado a num de uma maneira indireta */ printf ("\n\n%d\n", valor);

printf ("Endereco para onde o ponteiro aponta: %p\n", p); printf ("Valor da variavel apontada: %d\n", *p);

(23)

PONTEIROS – EXEMPLO2

#include <stdio.h>

void main (){ int num, *p;

num = 55;

p = &num; /* Pega o endereco de num */ printf ("\n Valor inicial: %d\n", num);

*p = 100; /* Muda o valor de num de uma maneira indireta */ printf ("\n Valor final: %d\n", num);

(24)

OPERAÇÕES ARITMÉTICAS COM PONTEIROS

 p1 = p2; p1 aponte para o mesmo lugar que p2;

 *p1 = *p2; a variável apontada por p1 tenha o mesmo

conteúdo da variável apontada por p2;

 p++; passa a apontar para o próximo valor do mesmo tipo

para o qual o ponteiro aponta. Isto é, se temos um ponteiro para um inteiro e o incrementamos ele passa a apontar para o próximo inteiro;

 p--; funciona semelhantemente;

 (*p)++; incrementar o conteúdo da variável apontada pelo

(25)

OPERAÇÕES ARITMÉTICAS COM PONTEIROS

 p = p+15; ou p+=15; incrementar um ponteiro de 15;

 *(p +15); usar o conteúdo do ponteiro 15 posições adiante;  == e != para saber se dois ponteiros são iguais ou diferentes;

 >, <, >= e <= estamos comparando qual ponteiro aponta para uma

posição mais alta na memória. Então uma comparação entre ponteiros pode nos dizer qual dos dois está "mais adiante" na memória.

Há entretanto operações que você não pode efetuar num ponteiro. Você não pode dividir ou multiplicar ponteiros, adicionar dois ponteiros, adicionar ou subtrair floats ou

(26)

PONTEIROS E VETORES

 Há uma diferença entre o nome de um vetor e um ponteiro que deve ser

frisada: um ponteiro é uma variável, mas o nome de um vetor não é uma variável. Isto significa, que não se consegue alterar o endereço que é apontado pelo "nome do vetor".

/* as operações abaixo são válidas */

int vetor[10]; int *ponteiro, i;

ponteiro = &i;

/* as operações a seguir são inválidas */

vetor = vetor + 2; /* ERRADO: vetor não e' variável */ vetor++; /* ERRADO: vetor não e' variável */

vetor = ponteiro; /* ERRADO: vetor não e' variável */ /* as operações abaixo são válidas */

ponteiro = vetor; /* CERTO: ponteiro e' variável */ ponteiro = vetor+2; /* CERTO: ponteiro e' variável */

(27)

PONTEIROS E VETORES

Exemplo

Podemos ver que p[2] equivale a *(p+2)

#include <stdio.h> voidmain () { int matrx [10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int *p; p = matrx;

printf ("O terceiro elemento do vetor e: %d",p[2]); }

(28)

VETOR DE STRINGS

Cada elemento do vetor é um ponteiro para

um caracter.

Declaração:

char *arstr[] = {“Joao”, “Maria”, “Antonio”,

“Zacarias”, “Carlos”};

arstr é um vetor de ponteiros para char,

(29)

VETOR DE STRINGS

Comparando vetor de string com matriz de char

char *as[]=

{“Joao”,“Maria”,“Antonio”,“Zacarias”,“Carlos”};

char ma[5][10]=

(30)

CUIDADO COM STRINGS

E comum esquecer de alocar uma área para

armazenamento de caracteres

void main() {

char *pc; char str[] = “Um string”;

strcpy(pc, str); /* erro! pc indeterminado */ ...

(31)

CUIDADO!!!

O principal cuidado ao se usar um ponteiro

deve ser:

saiba sempre para onde o ponteiro está

apontando.

void main () /* Errado -Nao Execute */ {

int x, *p; x = 13; *p = x; }

(32)
(33)

QUIZ

void exemplo2() {

int firstvalue, secondvalue; int * mypointer; mypointer = &firstvalue; *mypointer = 10; mypointer = &secondvalue; *mypointer = 20; printf("%d\n", firstvalue); printf("%d\n", secondvalue); }

(34)
(35)
(36)
(37)

ALOCAÇÃO DE MEMÓRIA

Alocação Estática

 Espaço de memória é reservado previamente;

Área de Tamanho FIXO e de Endereço FIXO (estática);Declarado e reservado em tempo de compilação

Exemplo: variáveis globais - declaradas fora do main/funções

Alocação Dinâmica:

 Espaço de memória é alocado em tempo de execução

usando as funções “calloc” e “malloc” (dinâmica);

 Áreas de Tamanho VARIÁVEL e de Endereço VARIÁVEL são

criadas (reserva memória) e destruídas (libera memória);

Acesso usualmente através de Endereços e Ponteiros

(38)

No padrão C ANSI existem 4 funções para alocações dinâmica

pertencentes a biblioteca

stdlib.h

. São elas malloc(), calloc(),

realloc() e free(). Sendo que as mais utilizadas são as funções

malloc() e free()

.

malloc() aloca memória

malloc() aloca memória

free() libera memória

free() libera memória

(39)

A alocação dinâmica é muito utilizada em problemas de

estrutura de dados como por exemplo,

listas encadeadas,

pilhas, filas, arvores binárias e grafos

.

ALOCAÇÃO

DINÂMICA

DE

(40)

MALLOC()

A sintaxe da função malloc() é dada por:

numero_de_bytes

é o número de bytes da memória que você

quer alocar.

O tipo

size_t

é definido em

stdlib.h

como sendo um inteiro

sem sinal.

O interessante é que esta função retorna um ponteiro do tipo

void podendo assim ser atribuído a qualquer tipo de ponteiro.

void *malloc(size_t numero_de_bytes);

(41)

MALLOC()

O fragmento de código mostrado abaixo aloca 1000 bytes de

memória:

Em alguns compiladores o código acima retornará um erro de

(42)

MALLOC()

Para garantir portabilidade é interessante então efetuar o

cast

para o tipo de ponteiro que você deseja

:

Após a atribuição,

p

aponta para o

primeiro

dos 1000 bytes de

(43)

MALLOC()

O próximo exemplo aloca espaço para 50 inteiros.

(44)

MALLOC()

Como o

heap

não é infinito, sempre que alocar memória, você

deve testar o valor devolvido por malloc(), antes de usar o

ponteiro, para estar certo de que não é nulo.

Usar um ponteiro nulo quase certamente travará o

(45)

FREE()

A função

free()

é o oposto de malloc(), visto que ela

devolve

memória previamente alocada ao sistema

.

Uma vez que a memória tenha sido liberada, ela pode ser

realocada por uma nova chamada a malloc().

Aqui, pont é um

ponteiro para a memória alocada

anteriormente por malloc()

.

É muito importante

que você

nunca use

free() com um argumento inválido

, isso destruiria a

lista de memória livre.

void free(void *pont)

(46)

ESTRUTURA DE DADOS

(47)
(48)
(49)
(50)
(51)

EXEMPLOS

#include <stdio.h> #include <stdlib.h> double Tabela[10]; main () { int i;

for (i=0; i < 10; i++) { printf("Dado %d = ",i); scanf ("%lf",&(Tabela[i])); } printf("\nDados Lidos:\n"); for (i=0; i < 10; i++)

printf("Dado %d = %.2lf \n",i, Tabela[i]); system(“pause”); } #include <stdio.h>

#include <stdlib.h> /* Inclui a lib do "calloc" */ double *Tabela; /* Cria somente o

ponteiro (não aloca)*/ main () { int i; Tabela=(double*)calloc(10,sizeof(double ));

for (i=0; i < 10; i++) { printf("Dado %d = ",i); scanf ("%lf",&(Tabela[i])); }

printf("\nDados Lidos:\n"); for (i=0; i < 10; i++)

printf("Dado %d = %.2lf \n",i, Tabela[i]);

system(“pause”); }

(52)

#include <stdio.h>

float* alocaVetor(int n)

{

float* V = (float*)calloc(n, sizeof(float));

if(V == NULL){

puts("Erro aloc. vetor");

exit(0);

}

return V;

}

(53)

int main() {

int i, n;

float soma=0, *A;

printf("Quantidade de numeros: "); scanf("%d",&n);

while(n<=0){

printf("Erro!\nDigite um numero positivo: "); scanf("%d",&n);

}

A = alocaVetor(n); /*Cria o vetor A dinamicamente: */ puts("Digite os numeros: ");

for(i=0;i<n;i++){ /*Preenche o vetor criado: */

scanf("%f",&A[i]); soma += A[i]; }

printf("Num. maiores que a media (%.2f):\n", soma/n); for(i=0; i<n; i++)

if (A[i]>soma/n)

printf("%.2f\n", A[i]); free(A); //Desaloca o vetor return 0;

Referências

Documentos relacionados

Exercício Completo de Mobilização: Esse tipo de exercício abrange os mesmos aspectos do exercício funcional, somando-se a mobilização de membros da Equipe Tática de Resposta (TRT)

NR AÇÃO AÇÃO VALOR PREVISTO ATUALIZADO EMPENHADO NA AÇÃO % EMP.. Micros

A bolsa concedida ficará vinculada à linha de pesquisa do supervisor do candidato por 1 (um) ano, renovável por mais 1 (um) ano, caso sejam atendidas pelo

A metodologia dessa seção consiste na utilização do software de elementos finitos Abaqus para analisar a capacidade residual de estruturas tubulares esbeltas sujeitas a

Em relação à gordura relativa, nota-se que tanto as mulheres como os homens acima de dezoito anos estão acima dos valores recomendados para a saúde que são de 15 e 25%

Na publicação da CE, com os guias de procedimentos para radiografia em pediatria, há a recomendação de que, para exames de tórax AP/PA, o valor da tensão deve estar entre 60 e 65

programa e pela relevância que o software tem dentro do universo acadêmico e de normas brasileiras que endossam seu uso para resolução de modelos computacionais

As variáveis analisadas no experimento foram índice de velocidade de emergência, altura das plantas, diâmetro do caule, relação altura/diâmetro do caule, área foliar,