Aula - Revisão de Conceitos

ESTRUTURA E
RECUPERAÇÃO DA
INFORMAÇÃO
(ERI)
SISTEMAS DE INFORMAÇÃO
AULA 02– Revisão e Conceitos Iniciais
Profa. Dra. Lúcia F. A. Guimarães
ESTRUTURAS
Estruturas
• ESTRUTURAS????
• São utilizadas para agrupar informações
relacionadas de tipos diferentes de dados;
• Cria-se um NOVO TIPO de dado constituído por

diferentes tipos básicos de dados.
Estruturas
• Criando uma Estrutura:

• A sintaxe para a criação de uma estrutura é:
struct nome da estrutura
{
tipo campo 1;
tipo campo 2;
....
tipo campo n;
};
Estruturas
• Exemplo:
• A uma estrutura para controlar os seguintes dados
relacionados ao estoque de um pequeno
estabelecimento comercial:
• Código;
• nome do produto;
• quantidade estocada;
• valor de compra;
• valor a ser vendido;
• Seria:
Estruturas
• Exemplo: struct produto
{
• Código; int codigo;
• nome do produto; char nome[50];
• quantidade estocada; int quantidade;
• valor de compra; float valor_compra;
• valor a ser vendido; float valor_venda;
};
Estruturas
{
};
Estruturas
{
};
Estruturas
{
};
Estruturas
• Declarando variáveis do tipo de uma estrutura

criada
• Após a declaração da estrutura é possível declarar
variáveis do tipo da estrutura com a sintaxe:
struct NOME_DA_ESTRUTURA NOME_DA_VARIÁVEL;
• Exemplo:
struct produto item;
• Observe que esta sintaxe obedece a sintaxe normal
para a declaração de variáveis em C.
Estruturas
• Acessando os campos de uma estrutura

• A sintaxe para acessar e manipular campos de
estruturas é a seguinte:
NOME_DA_ESTRUTURA.CAMPO
• Observe o código a seguir para um melhor

esclarecimento:
Estruturas
#include <stdio.h> Biblioteca básica
/* criando um novo tipo de dado "produto" */

struct produto
{
int codigo;
char nome[50];
Declaração do tipo de
int quantidade;
variável produto
float valor_compra;
float valor_venda;
};
Estruturas
int main()
{
printf("Preenchendo a variável \"item\"\n");
printf("Item............:");
fgets(item.nome,50,stdin);
printf("Código..........:");
scanf("%d",&item.codigo);
printf("Quantidade......:");
scanf("%d",&item.quantidade);
printf("Valor de compra.:");
scanf("%f",&item.valor_compra);
printf("Valor de revenda:");
scanf("%f",&item.valor_venda);
Estruturas
int main()
Declaração da variável "item" do
{
tipo “struct produto”
printf("Item............:");
fgets(item.nome,50,stdin);
Estruturas
int main()
{
printf("Item............:");
Comando em C para a leitura
fgets(item.nome,50,stdin); de uma string
Estruturas
int main()
{
printf("Item............:");
de um inteiro
Estruturas
int main()
{
printf("Item............:");
de um inteiro
printf("Valor de revenda:"); Comando em C para a leitura
scanf("%f",&item.valor_venda); de um ponto flutuante
Estruturas
int main()
{
printf("Item............:");
.
fgets(item nome,50,stdin); Manipulação dos campos da
estrutura através do ponto
Estruturas
printf("Exibindo os dados\n");
printf("Código..........:%2d\n",item.codigo);
printf("Item............:%s",item.nome);
Impressão das
printf("Quantidade......:%2d\n",item.quantidade); informações
printf("Valor de compra.:%.2f\n",item.valor_compra);
printf("Valor de revenda:%.2f\n",item.valor_venda);
return(0);
}
Estruturas
printf("Código..........:%2d\n",item.codigo);
printf("Item............:%s",item.nome); Formatação para
printf("Quantidade......:%2d\n",item.quantidade); impressão de um
inteiro
printf("Valor de compra.:%.2f\n",item.valor_compra);
return(0);
}
Estruturas
printf("Código..........:%d\n",item.codigo);
printf("Item............:%s",item.nome); Formatação para
printf("Quantidade......:%d\n",item.quantidade); impressão de uma
printf("Valor de compra.:%.2f\n",item.valor_compra); string
return(0);
}
Estruturas
printf("Código..........:%d\n",item.codigo); Formatação para
printf("Item............:%s",item.nome); impressão de um
printf("Quantidade......:%d\n",item.quantidade); ponto flutuante,
printf("Valor de compra.:%.2f\n",item.valor_compra); serão 2 casas após
a vírgula
printf("Valor de revenda:%.2f \n",item.valor_venda);
return(0);
}
Estruturas
• Se você implementar e executar este programa,
a saída será, por exemplo:
Observe que o
código digitado
pelo usuário foi
78439
PONTEIROS
Ponteiros
• Da mesma maneira que existem em C variáveis

do tipo
• char,
• int e
• float,
• existem variáveis do tipo ponteiro.

Ponteiros
• As variáveis do tipo ponteiro armazenam endereços

de memória.
• São utilizadas por 3 razões específicas na
programação:
• Permitem a modificação de argumentos de funções,
ou seja,
• Permitem que uma função altere valores de variáveis
não globais e não locais a ela através da referência ao
endereço de memória da variável passada como
parâmetro para a função;
Ponteiros
• São utilizadas por 3 razões específicas na

programação:
• Permitem o uso de rotinas de alocação dinâmica
de memória, ou seja,
• alocação e “desalocação” de memória em tempo
de execução conforme a necessidade do programa;
• Aumento de eficiência em determinadas rotinas.

Ponteiros
• Declaração: Indica que a
variável é
ponteiro
tipo *nome_variável;
• onde tipo é o tipo de variável apontada pela

variável ponteiro
• Exemplo:
• int *A;
• struct cadastro *aluno
Ponteiros
• As variáveis ponteiros, trabalham com dois

operadores especiais :
• * que :
• Na declaração indica que a variável é do tipo ponteiro,
ou seja, armazena um endereço de memória
• No corpo do programa, fornece o conteúdo do endereço

“apontado por”
• É o operador que acessa o objeto para o qual o ponteiro

aponta
Ponteiros
• As variáveis ponteiros, trabalham com dois

operadores especiais :
• & - que:
• Fornece o endereço da variável
• Por exemplo, quando usamos o comando

scanf("%f",&k) para ler o valor de k,
• Informamos para a função scanf o endereço da
variável k, ou seja, a que posição da memória ela está
associada.
Ponteiros
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x=2.5;
y=0.8;
ptr1=&x;
y=*ptr1;
*ptr1= 1.0;
ptr2 = ptr1;
return 0;
}
Ponteiros
#include <stdio.h>
#include <stdlib.h>
{ x e y variáveis
float x, y; reais
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x=2.5;
y=0.8;
ptr1=&x;
y=*ptr1;
*ptr1= 1.0;
ptr2 = ptr1;
return 0;
}
Ponteiros
#include <stdio.h>
#include <stdlib.h> Esquematicamente, na memória
prt1 y
{ x e y variáveis
E01 E10
float x, y; reais
float *ptr1, *ptr2;
ptr1=NULL; Ponteiros, ou
ptr2=NULL; seja, guardam o
endereço de x
x=2.5; memória de um
y=0.8; conteúdo real
E50
ptr1=&x; prt2
y=*ptr1;
*ptr1= 1.0; E80
ptr2 = ptr1;
return 0;
}
Ponteiros
#include <stdio.h>
prt1 y
∅
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL; Inicialização das
ptr2=NULL; variáveis
ponteiro. Deixa x
x=2.5; “vazio” o
y=0.8; conteúdo
E50
ptr1=&x; prt2
y=*ptr1; ∅
*ptr1= 1.0; E80
ptr2 = ptr1;
return 0;
}
Ponteiros
#include <stdio.h>
prt1 y
∅ 0.8
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x
x=2.5; 2.5
y=0.8;
E50
ptr1=&x; prt2
y=*ptr1; ∅
*ptr1= 1.0; E80
ptr2 = ptr1;
return 0;
}
Ponteiros
#include <stdio.h>
prt1 y
E50 0.8
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x
x=2.5; 2.5
y=0.8;
E50
ptr1=&x; “ptr1 aponta prt2
y=*ptr1; para x”, ou seja, ∅
*ptr1= 1.0; prt1 recebe o E80
ptr2 = ptr1; endereço de x
return 0;
}
Ponteiros
#include <stdio.h>
prt1 y
E50 2.5
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x
x=2.5; 2.5
y=0.8;
E50
ptr1=&x; “y recebe o prt2
y=*ptr1; conteúdo de ∅
*ptr1= 1.0; prt1”, ou seja, y E80
ptr2 = ptr1; vale agora 2.5
return 0;
}
Ponteiros
#include <stdio.h>
prt1 y
E50 2.5
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x
x=2.5; 1.0
y=0.8;
E50
ptr1=&x; prt2
y=*ptr1; “o conteúdo de ∅
*ptr1= 1.0; prt1 recebe 1.0”, E80
ptr2 = ptr1; ou seja, x vale
return 0; agora 1.0
}
Ponteiros
#include <stdio.h>
prt1 y
E50 2.5
{
E01 E10
float x, y;
float *ptr1, *ptr2;
ptr1=NULL;
ptr2=NULL;
x
x=2.5; 1.0
y=0.8; “ptr2 recebe o
valor de prt1”, E50
ptr1=&x; prt2
comando de
y=*ptr1; E50
atribuição
*ptr1= 1.0; normal para E80
ptr2 = ptr1; variáveis do
return 0; mesmo tipo
}
Ponteiros
• Cuidados:
• Como toda variável, todo ponteiro deve ser
inicializado
• Todo o cuidado é pouco ao alinhar os ponteiros,

devemos sempre ter em mente o que está sendo
apontado por um ponteiro em uma dada linha do
código
Ponteiros
#include <stdio.h>
y
2
{
E10
float *x, y; “conteúdo de x
recebe 3”,
x=NULL; COMO??? Se não
y=2; existe endereço
alocado para
*x=3; x???? x
∅
system("cls");
E50
printf("\n\n %f %f \n", y,*x);
system("PAUSE");
return 0;
}
Ponteiros
• Uma solução para o erro seria:
Esquematicamente, na memória
#include <stdio.h>
#include <stdlib.h> y
2
int main(int argc, char *argv[]) E10
{
float *x, y;
x=NULL;
y=2; x
E10
x=&y;
E50
*x=3;
system("PAUSE");
return 0;
}
Ponteiros
• Uma solução para o erro seria:
#include <stdio.h>
#include <stdlib.h> y
3
int main(int argc, char *argv[]) E10
{
float *x, y;
x=NULL;
y=2; x
E10
x=&y;
E50
*x=3;
system("PAUSE");
return 0;
}
Unindo os dois
conceitos.......
Estruturas e Ponteiros
#include <stdio.h>
#include <stdlib.h>
struct teste
{
int a;
float b;
};
int main()
{
struct teste x,*y;
x.a=5;
x.b=6.2;
y=&x;
printf("y.a= %d, y.b = %.2f", y->a,y->b);
}
#include <stdio.h>
#include <stdlib.h>
struct teste
{ ESTRUTURA teste COM UM
int a; CAMPO DEFINIDO COMO
float b; INTEIRO E OUTRO CAMPO
}; PONTO FLUTUANTE
int main()
{
struct teste x,*y;
x.a=5;
x.b=6.2;
y=&x;
}
#include <stdio.h>
x é uma x
struct teste variável do tipo a b
{ estrutura teste
int a; *y é um E10
float b;
ponteiro de
};
uma variável do
int main() tipo estrutura
{ teste
struct teste x,*y;
x.a=5;
x.b=6.2;
y
y=&x;
E50
}
#include <stdio.h>
x
struct teste
a b
{
5 6.2
int a;
E10
float b;
};
int main() Atribuição

de valores
{
para a
struct teste x,*y; variável x
x.a=5; do tipo
x.b=6.2; teste y
y=&x;
E50
}
#include <stdio.h>
x
struct teste
a b
{
5 6.2
int a;
E10
float b;
}; y recebe o
endereço
int main() variável x do
{ tipo teste.
struct teste x,*y; Ou seja, y
x.a=5; aponta para
x.b=6.2; x
y
y=&x;
E10
E50
}
#include <stdio.h>
x
struct teste
a b
{
5 6.2
int a;
Impressão dos valores que E10
float b;
estão armazenados no
};
endereço contido na variável y
int main()
{
struct teste x,*y;
x.a=5;
x.b=6.2;
y
y=&x;
E10
E50
}
#include <stdio.h>
x
struct teste
a b
{
5 6.2
int a;
Observe que a manipulação E10
float b;
não é mais usando ponto(.) e
};
sim ->
int main()
{
struct teste x,*y;
x.a=5;
x.b=6.2;
y
y=&x;
E10
E50
}
Alocação Dinâmica.......
Alocação Dinâmica
• Alocação Dinâmica
• A alocação dinâmica permite ao programador
criar variáveis em tempo de execução, ou seja,
• Alocar memória para novas variáveis quando o

programa está sendo executado, proporcionando
uma melhor utilização da memória da máquina,
• Biblioteca padrão “stdlib.h”
• contém uma série de funções pré-definidas para
tratar alocação dinâmica de memória
• Função “malloc”:
• Recebe como parâmetro o número de bytes que se
deseja alocar
• Retorna um ponteiro genérico para o endereço

inicial da área de
• A memória alocada, se houver espaço livre:

Exemplo: alocação dinâmica de um vetor de inteiros
com 10 elementos
int *v;
v = (int *) malloc(10*sizeof(int));
com 10 elementos
int *v;
Retorna o endereço da
área alocada para
armazenar valores inteiros
com 10 elementos
int *v;
Ponteiro de inteiro
Retorna o endereço da
recebe endereço
área alocada para
inicial do espaço
armazenar valores inteiros
alocado
int *v;
v
E50
• Função “malloc”: E20
int *v;
v
E20
Reserva espaço de
E50
memória da área
livre
e atribui endereço à
variável
#include <stdio.h>
struct teste
{ y
int a;
float b; E10
};
int main()
{
struct teste *y;
y = (struct teste *)malloc(1*sizeof(struct
teste));
y->a=5;
y->b=6.2;
printf("\n\n\ty->a= %d, y->b = %.2f\n\n\t",
y->a,y->b);
}
#include <stdio.h>
struct teste
{ y
int a; E50
float b; E10
};
int main()
{
struct teste *y;
a b
teste));
E50
y->a=5;
y->b=6.2;
y->a,y->b);
}
#include <stdio.h>
struct teste
{ y
int a; E50
float b; E10
};
int main()
{
struct teste *y;
a b
5
teste));
E50
y->a=5;
y->b=6.2;
y->a,y->b);
}
#include <stdio.h>
struct teste
{ y
int a; E50
float b; E10
};
int main()
{
struct teste *y;
a b
5 6.2
teste));
E50
y->a=5;
y->b=6.2;
y->a,y->b);
}
#include <stdio.h>
struct teste
{ y
int a; E50
float b; E10
};
int main()
{
struct teste *y;
a b
5 6.2
teste));
E50
y->a=5;
y->b=6.2;
y->a,y->b);
}
MODULARIZAÇÃO.......
Modularização
• Modularização:
• Técnica aplicada na programação estruturada;
• Ferramenta para a elaboração de programas visando,
os aspectos de
• confiabilidade,
• legibilidade,
• manutenção e flexibilidade, etc.
• Processo que aborda os aspectos da decomposição de

algoritmos em módulos.
Modularização
• Vantagens
• Independência do módulo
• permite uma manutenção mais simples e evita efeitos
colaterais no restante do algoritmo;
• A construção do módulo pode ser realizada em época

diferente do restante do algoritmo;
• Testes e correções podem ser realizados separadamente;
• Um módulo pode ser utilizado em outros algoritmos que

requeiram o mesmo processamento por ele executado.
Modularização
• Cada módulo pode definir as próprias estruturas

de dados e variáveis, suficientes e necessárias
apenas para atingir o objetivo final do módulo.
• Todo módulo é constituído por uma sequência

de comandos que operam sobre um conjunto de
variáveis,
• que podem ser globais ou locais.
Modularização
• Variáveis globais
• Entidades que podem ser usadas em módulos internos a outro
módulo do algoritmo onde foram declaradas.
• Variáveis locais
• Entidades que só podem ser usadas no módulo do algoritmo
onde foram declaradas.
• Estas variáveis não possuem nenhum significado fora deste
módulo
• A comunicação entre módulos deverá ser feita através de
vínculos, utilizando-se objetos (variáveis) globais ou
passagem de parâmetros.
Modularização
• Subprogramas (Procedimentos e/ou funções )

• São módulos hierarquicamente subordinados a um
algoritmo (geralmente, módulo principal)
• Da mesma forma um procedimento ou uma função
pode conter outros procedimentos e funções
aninhadas
• São criados através das suas declarações em um
algoritmo e;
• Para serem executadas, necessitam de ativação por
um comando de chamada.
Modularização
• Subprogramas (Procedimentos e/ou funções )

• A declaração de um procedimento ou função é
constituído de:
• Cabeçalho
• A identifica contendo seu nome e uma lista de
parâmetros formais,
• Corpo
• Contém declarações locais e os comandos.
Modularização
• Exemplo Simples de um programa com um
procedimento Cabeçalho e corpo do
procedimento soma
void soma(int num, int num1, int *valor)
{
*valor=num+num1;
}
int main( )
{
Chamada int a, b, resultado_soma;
do printf("\n\n\tDIGITE O PRIMEIRO VALOR:"); scanf("%d",&a);
procedim
ento
printf("\n\n\tDIGITE O SEGUNDO VALOR:"); scanf("%d",&b) ;
soma soma(a,b,&resultado_soma);
printf("\n\n\tO RESULTADO OBTIDO FOI:\n\n");
printf("\t%2d + %2d = %2d\n\n",a,b,resultado_soma);
system("PAUSE");
return 0;
}
Modularização
• Outro exemplo Simples de um programa com um
procedimento PROTÓTIO do procedimento soma
void soma(int num, int num1, int *valor) ;
int main( )
{
int a, b, resultado_soma;
printf("\n\n\tDIGITE O PRIMEIRO VALOR:"); scanf("%d",&a);
soma(a,b,&resultado_soma);
system("PAUSE");
return 0; Cabeçalho e corpo do procedimento
} soma
{
*valor=num+num1;
}
Modularização
• Passagem de Parâmetros
• Há duas formas básicas pelas quais um subprograma
pode acessar os dados que deve processar:
• pelo acesso direto a variáveis não locais
• declaradas em outro local, mas visível no subprograma
(variáveis globais)
• ou pela passagem de parâmetros

• Os dados são acessados por nomes locais no subprograma.
• A passagem de parâmetro é mais flexível do que o acesso
direto as variáveis não locais.
Modularização
• Relação entre os parâmetros na chamada de um módulo

{
*valor=num+num1;
} “a” corresponderá a num
no procedimento
int main( )
{
system("PAUSE");
return 0;
}
Modularização
• Passagem por Valor:
• O valor do parâmetro real é usado para inicializar o
parâmetro formal correspondente
• O parâmetro real é preservado

Modularização
• No Exemplo dado anteriormente
{
*valor=num+num1;
} Passagem por Valor
int main( )
{
system("PAUSE");
return 0;
}
Modularização
• Passagem por Referência:
• Transmite um caminho de acesso,
• Normalmente um endereço de memória, para o
subprograma chamado
• Proporcionando assim, o caminho de acesso à célula
que armazena o parâmetro real
• O parâmetro real pode ser alterado

Modularização
• No Exemplo dado anteriormente
{
*valor=num+num1;
} Passagem por Referência
int main( )
{
system("PAUSE");
return 0;
}

Aula - Revisão de Conceitos

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aula - Revisão de Conceitos

Enviado por

Direitos autorais:

Formatos disponíveis

ESTRUTURA E

• Cria-se um NOVO TIPO de dado constituído por

• Criando uma Estrutura:

• Declarando variáveis do tipo de uma estrutura

• Acessando os campos de uma estrutura

• Observe o código a seguir para um melhor

/* criando um novo tipo de dado "produto" */

• Da mesma maneira que existem em C variáveis

• existem variáveis do tipo ponteiro.

• As variáveis do tipo ponteiro armazenam endereços

• São utilizadas por 3 razões específicas na

• Aumento de eficiência em determinadas rotinas.

• onde tipo é o tipo de variável apontada pela

• As variáveis ponteiros, trabalham com dois

• No corpo do programa, fornece o conteúdo do endereço

• É o operador que acessa o objeto para o qual o ponteiro

• As variáveis ponteiros, trabalham com dois

• Por exemplo, quando usamos o comando

• Todo o cuidado é pouco ao alinhar os ponteiros,

int main() Atribuição

• Alocar memória para novas variáveis quando o

• Retorna um ponteiro genérico para o endereço

• A memória alocada, se houver espaço livre:

• Processo que aborda os aspectos da decomposição de

• A construção do módulo pode ser realizada em época

• Testes e correções podem ser realizados separadamente;

• Um módulo pode ser utilizado em outros algoritmos que

• Cada módulo pode definir as próprias estruturas

• Todo módulo é constituído por uma sequência

• Subprogramas (Procedimentos e/ou funções )

• Subprogramas (Procedimentos e/ou funções )

• ou pela passagem de parâmetros

• Relação entre os parâmetros na chamada de um módulo

• O parâmetro real é preservado

• Proporcionando assim, o caminho de acesso à célula

que armazena o parâmetro real

• O parâmetro real pode ser alterado

Você também pode gostar