Programação Estruturada 2 - Aula 03

Programação Estruturada II
Aula 03 – Estruturas, Uniões e Enumeração
Prof. Thomás da Costa
thomasdacosta@gmail.com
Anhanguera – 2015.1

Estruturas, Uniões e Enumeração
ESTRUTURAS, UNIÕES E ENUMERAÇÃO
Prof. Thomás da Costa Programação Estruturada II

O que é:
É um conjunto de variáveis que representam características de um determinado
domínio ou de um tipo. A estrutura pode definir uma entidade e possui grande
semelhança com registros de banco de dados. O agrupamento de variáveis pode
ser de qualquer tipo, sendo denominado de membro da estrutura.
Estruturas

Exemplo:
Quais são as informações de um Aluno para a Faculdade?
- Nome
- Matrícula
- Série
- Turma
- Curso
No exemplo acima temos a estrutura Aluno que contém as informações ou as
características de um aluno. Muito semelhante a um registro de banco de dados.
Podemos dizer que em uma estrutura, estamos armazenando informações
agrupadas logicamente.
Estruturas

Mais um exemplo:
Quais as informações de um Funcionário para uma Empresa?
- Nome
- Dados Pessoais
- Data de Admissão
- Cargo
- Salário
- Setor/Área de Atuação
Estruturas
Vamos ver como fazer uma estrutura em
C/C++ !!!

Estruturas em C/C++:
Estruturas
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
};
Nome da estrutura
Palavra reservada
que identifica uma
estrutura
Membros da estrutura
Chaves definem o início
e o fim da estrutura
Termina com ponto e
vírgula

Memória:
Uma estrutura armazena vários tipos de dados e ocupa a memória de acordo com
a quantidade de membros declarados na estrutura.
Estruturas
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
};
Membro Bytes
char nome[255] 255
int ra 4
int serie 4
int turma 4
char curso[100] 100
TOTAL: 367

Uma curiosidade:
Para saber o tamanho de um tipo de dado ou variável usamos o operador sizeof.
Os tamanhos podem variar de computador, compilador e sistema operacional.
Estruturas
#include <iostream>
using namespace std;
int main()
{
cout << "Tam. do CHAR:" << sizeof(char) << endl;
cout << "Tam. do INT:" << sizeof(int) << endl;
cout << "Tam. do DOUBLE:" << sizeof(double) << endl;
cout << "Tam. do FLOAT:" << sizeof(float) << endl;
}

Estruturas
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
} aluno_anhanguera;
struct aluno aluno_tecnologia;
aluno aluno_curso;
Declarando uma variável do tipo Estrutura:
Existem 3 formas de declarar uma variável de estrutura:

Acessando membros de uma estrutura:
Para acessar um membro de uma estrutura utilizamos o operador ponto (.)
Estruturas
...
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
} aluno_anhanguera;
...
int main()
{
cout << aluno_anhanguera.nome << endl;
}
Acessando um membro
O membro “nome” da estrutura
será impresso na tela

Atribuindo valores para membros de uma função:
Estruturas
#include <iostream>
struct demonstracao
{
char caracter;
double valor1;
float valor2;
int valor3;
} demo;
int main()
{
demo.caracter = 'A';
demo.valor1 = 3.2;
demo.valor2 = 6.7;
demo.valor3 = 45;
cout << demo.caracter << endl;
cout << demo.valor1 << endl;
}
Atribuição de valores

Estruturas
#include <iostream>
#include <string.h>
struct demonstracao
{
char string[100];
int vetor_inteiro[10];
double vetor_double[5];
} demo;
int main()
{
strcpy(demo.string, "Valor da String:");
demo.vetor_inteiro[0] = 1;
demo.vetor_inteiro[2] = 2;
demo.vetor_double[4] = 5.6;
cout << demo.string << endl;
cout << demo.vetor_inteiro[0] << endl;
cout << demo.vetor_inteiro[2] << endl;
cout << demo.vetor_double[4] << endl;
}
Vetor de char usar
strcpy
Atribuição de valores
em vetores

Estruturas
#include <iostream>
#include <string.h>
struct demonstracao
{
char string[100];
char caracter;
int valor_inteiro;
double valor_double;
} demo;
int main()
{
cout << "Digite o valor da string:" << endl;
gets(demo.string);
cout << "Digite os valores:" << endl;
cin >> demo.caracter >> demo.valor_inteiro
>> demo.valor_double;
cout << "Valores digitados:" << demo.string
<< "," << demo.caracter
<< "," << demo.valor_inteiro
<< "," << demo.valor_double << endl;
}
O cin funciona da mesma forma em
um membro de uma estrutura
O gets funciona da mesma forma em
um membro de uma estrutura

Resumo:
- É definida pela palavra struct
- Possuem um nome
- Representa algum domínio, tipo ou uma entidade
- Os tipos de uma estrutura são agrupadas logicamente
- Composta de membros que são tipos de variáveis (int, double, float, char)
- Seus membros são acessados utilizando o ponto (.)
- Para atribuir valores (int, double, char e etc), utilizamos o operador igual (=),
idêntico a atribuição de uma variável
- Utilizamos o strcpy para atribuir um valor para um vetor de char
- Os comandos cin e gets funcionam da mesma forma para os membros de uma
estrutura
- Vetores também são acessado da mesma forma, através de seus índices
Estruturas

Passando membros de uma estrutura como parâmetro:
Estruturas em Funções
#include <iostream>
#include <string.h>
struct aluno
{
char nome[100];
int ra;
} aluno_tecnologia;
void imprimir_aluno(char *nome, int ra);
int main()
{
cout << "Digite o nome do aluno:";
gets(aluno_tecnologia.nome);
cout << "Digite o RA do aluno:";
cin >> aluno_tecnologia.ra;
imprimir_aluno(aluno_tecnologia.nome,
aluno_tecnologia.ra);
}
void imprimir_aluno(char *nome, int ra)
{
cout << nome << endl;
cout << ra << endl;
}
Passamos os membros como
parâmetro para a função

Parâmetros por referência:
...
void troca_aluno(char *nome, int &ra);
int main()
{
...
troca_aluno(aluno_tecnologia.nome,
aluno_tecnologia.ra);
cout << aluno_tecnologia.nome;
cout << aluno_tecnologia.ra;
}
void troca_aluno(char *nome, int &ra)
{
strcpy(nome, "Novo Aluno");
ra = 123456;
}
* e o & definem
também, a passagem
por referência.
Trocando os valores
da estrutura

Estrutura como parâmetro (Por valor):
Podemos passar uma estrutura inteira como parâmetro de uma função. Os
parâmetros podem ser também por valor ou por referência
...
void imprimir_aluno(struct aluno alu);
int main()
{
...
imprimir_aluno(aluno_tecnologia);
}
void imprimir_aluno(struct aluno alu)
{
cout << alu.nome << endl;
cout << alu.ra << endl;
}
Definindo a passagem
de uma estrutura
como parâmetro
Passando a estrutura
A palavra struct não é
obrigatória na passagem
do parâmetro

Estrutura como parâmetro (Por referência):
#include <iostream>
#include <string.h>
struct aluno
{
char nome[100];
int ra;
};
void ler_aluno(struct aluno &alu);
int main()
{
struct aluno aluno_tecnologia;
ler_aluno(aluno_tecnologia);
cout << aluno_tecnologia.nome << endl;
cout << aluno_tecnologia.ra << endl;
}
void ler_aluno(struct aluno &alu)
{
cout << "Digite o nome do aluno:" << endl;
gets(alu.nome);
cout << "Digite o RA do aluno:" << endl;
cin >> alu.ra;
}
& define, a passagem por
referência.

Vetores de Estruturas:
Estruturas
#include <iostream>
#include <string.h>
struct aluno
{
char nome[100];
int ra;
};
int main()
{
struct aluno alunos[10];
cout << "Digite o nome do 1º aluno:" << endl;
gets(alunos[0].nome);
cout << "Nome do 1º aluno:"
<< alunos[0].nome << endl;
}
Declarando um vetor de
estruturasUtilizamos índices do
vetor para mostrar o
valor de um membro
da estrutura

Estruturas dentro de estruturas:
Estruturas
struct curso
{
char nome_curso[255];
};
struct aluno
{
char nome[100];
int ra;
struct curso cur;
};
int main()
{
...
cout << alu.nome << endl;
cout << alu.cur.nome_curso << endl;
}
Declarando a estrutura
curso dentro de aluno
Mostrando o nome_curso
da estrutura curso
declarada em aluno

Exemplo (Média):
Estruturas
#include <iostream>
#include <string.h>
struct aluno
{
char nome[100];
double nota_b1;
double nota_b2;
};
double media(double nota_b1, double
nota_b2);
int main()
{
struct aluno alu;
cout << "Nota B1:" << endl;
cin >> alu.nota_b1;
cout << "Nota B2:" << endl;
cin >> alu.nota_b2;
cout << "Media:" <<
media(alu.nota_b1, alu.nota_b2);
}
double media(double nota_b1, double nota_b2)
{
return (nota_b1 + nota_b2) / 2;
}

Exemplo (Aumentar Salário):
Estruturas
#include <iostream>
#include <string.h>
struct funcionario
{
char nome[255];
char cargo[255];
double salario;
int idade;
};
void aumentar_salario(double &salario,
int percen);
int main()
{
struct funcionario func;
cout << "Digite o salário:" << endl;
cin >> func.salario;
aumentar_salario(func.salario, 20);
cout << "Novo salário:" << func.salario;
}
void aumentar_salario(double &salario,
int percen)
{
double val = (percen / 100.0);
salario = salario * (1 + val);
}
Todo mundo gosta desse exemplo !!!

O que é:
É um tipo de estrutura, aonde os membros compartilham a mesma posição de
memória, criando código portável independente de máquina. Em sua forma geral,
as uniões possuem algumas características das estruturas.
Uniões

Como funciona:
- As uniões utilizam o mesmo espaço de memória para todas as variáveis
- Quando declaradas, o compilador cria um espaço de memória grande o
suficiente para guardar o maior tipo de variável
- Como o espaço é compartilhado entre os membros da união, precisamos nos
preocupar com as informações que estão sendo gravadas
- As uniões possuem algumas características das estruturas
- A forma de acessar os membros e atribuir valores em um união, são iguais aos
mostrados em estruturas
Uniões
Vamos ver como fazer uma união
em C/C++ !!!

Uniões em C/C++:
Uniões
Nome da união
Palavra reservada
que identifica uma
união Membros da união
e o fim da união
Termina com ponto e
vírgula
union valor
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
};

Memória:
A união tem o tamanho do maior membro declarado, diferente da estrutura que
possui o tamanho equivalente a soma de todos os membros. No exemplo abaixo a
união possui 8 bytes.
Uniões
union valor
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
};
Membro Bytes
int valor_1 4
float valor_2 4
double valor_3 8
char valor_4 1
TOTAL: 8

Exemplo:
Uniões
#include <iostream>
union valor_union
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
} valor;
void imprimir();
int main()
{
cin >> valor.valor_1;
imprimir();
imprimir();
imprimir();
imprimir();
}
void imprimir()
{
cout << "Valores:" << endl;
cout << valor.valor_1 << endl;
}

O que é:
É um tipo de dado, que possui um conjunto de números inteiros constantes, que
definem os possíveis valores válidos para a enumeração. Muito semelhante a um
vetor de inteiro.
Enumeração

Vamos pensar:
Quais são as nossas despesas mensais?
- Aluguel
- Faculdade
- Celular
- Internet
- Conta de Água
- Conta de Luz
- Carro
Essas informações definem uma enumeração chamada despesas. Podemos criar
um programa, que efetue o cálculo das despesas mensais, de acordo com o salário
digitado do usuário.
Essa enumeração define um tipo ou uma faixa de tipos constantes que podemos
utilizar no nosso programa.
Enumeração

Vamos pensar:
Quais são as cores de uma caixa de lápis de cor?
- Azul
- Vermelho
- Amarelo
- Verde
- Preto
- Branco
- Laranja
Essas informações definem uma enumeração chamada cores.
Enumeração
Vamos ver como fazer uma enumeração em C/C++ !!!

Enumerações em C/C++:
Enumeração
Nome do enum
Palavra reservada
que identifica um
enum
Valores inteiros de um enum
e o fim do enum
Termina com ponto e
vírgula
enum despesas
{
ALUGUEL,
FACULDADE,
CELULAR,
INTERNET,
CONTA_AGUA,
CONTA_LUZ
};

Exemplo:
Enumeração
#include <iostream>
enum despesas
{
ALUGUEL,
FACULDADE
};
int main()
{
int valor;
cout << "Digite o tipo da despesa:" << endl;
cin >> valor;
switch (valor) {
case ALUGUEL: {
cout << "Aluguel";
break;
}
case FACULDADE: {
cout << "Faculdade";
break;
}
default: {
cout << "Não encontrado";
break;
}
}
}
No enum os valores dos membros
começam com 0 e segue a sequência
numérica

Exemplo:
Vamos modificar o programa feito no laboratório para utilizar enumeração.
(Exercício 4 do nível básico).
Enumeração
...
enum opcoes
{
INCLUIR = 1,
LISTAR = 2,
SAIR = 0
};
...
if (opcao == INCLUIR)
{
cout << "Digite o produto:" << endl;
cin >> produto;
incluir_produto(produto);
}
if (opcao == LISTAR)
listar_produto();
if (opcao == SAIR)
break;
system("cls");
...
Podemos atribuir valores fixos
para o enum

Definição:
Quando precisamos definir novos nomes a determinados tipos de dados,
utilizamos o operador typedef. Não criamos um novo tipo de variável, somente
um “apelido” para um tipo existente.
Tipos definidos pelo Usuário
#include <iostream>
#include <strings.h>
typedef char valores[100];
int main()
{
valores val;
strcpy(val, "Programação Estruturada II");
cout << "Tipo do usuário:" << val;
}

Obrigado !!!

Programação Estruturada 2 - Aula 03

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (6)

Similar a Programação Estruturada 2 - Aula 03

Similar a Programação Estruturada 2 - Aula 03 (20)

Más de thomasdacosta

Más de thomasdacosta (20)

Programação Estruturada 2 - Aula 03