Mudanças entre as edições de "PRG29002 - Programação I - Eng.Telecom 2017-1"
Linha 641: | Linha 641: | ||
*#Implemente um programa em C que solicita ao usuário digitar duas palavras, o programa analisa estas palavras e diz se são ou não anagramas (palavra formada pela alteração da ordem ou transposição de letras) ex.: “America” e “Iracema”, “Roma” e “Amor”, “Semolina” e “Is no meal” são anagramas) | *#Implemente um programa em C que solicita ao usuário digitar duas palavras, o programa analisa estas palavras e diz se são ou não anagramas (palavra formada pela alteração da ordem ou transposição de letras) ex.: “America” e “Iracema”, “Roma” e “Amor”, “Semolina” e “Is no meal” são anagramas) | ||
*#Implemente um algoritmo que dada uma frase, apresente 3 opções: tornar todas as letras em maiúsculas, tornar todas em minúsculas ou a primeira letra de cada palavra em maiúscula e demais minúsculas (limite 100 caracteres). Faça estas operações através de cálculos utilizando como base a tabela ASCII, utilize funções distintas (tudoMaiusculo(), tudoMinusculo(), primeiraMaiuscula()), utilizando o vetor de caracteres como uma variável global. | *#Implemente um algoritmo que dada uma frase, apresente 3 opções: tornar todas as letras em maiúsculas, tornar todas em minúsculas ou a primeira letra de cada palavra em maiúscula e demais minúsculas (limite 100 caracteres). Faça estas operações através de cálculos utilizando como base a tabela ASCII, utilize funções distintas (tudoMaiusculo(), tudoMinusculo(), primeiraMaiuscula()), utilizando o vetor de caracteres como uma variável global. | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | ==Tipos de dados compostos== | ||
+ | {{collapse top | Estruturas}} | ||
+ | |||
+ | ;Estruturas | ||
+ | Assim como o vetor a estrutura é um conjunto de dados, mas traz uma vantagem: a possibilidade de possuir "campos" de diferentes tipos de variáveis. Por exemplo, a struct TPessoa poderia ter os campos nome (char[40]) e idade (int). | ||
+ | |||
+ | A declaração genérica da estrutura é: | ||
+ | struct TNome_do_tipo { | ||
+ | //variável 1 | ||
+ | //variável 2 | ||
+ | //variável N | ||
+ | } nome_instancia; | ||
+ | |||
+ | *Convencionalmente damos ao tipo da estrutura um nome "TNome_do_tipo", onde "T" representa Tipo e a letra seguinte também vem em maiúscula | ||
+ | *nome_instancia representa a instancia de variável (do tipo struct) que será alocada em memória, esta declaração também pode ser um vetor "nome_instancia[10]", por exemplo | ||
+ | *Em uma declaração é necessário ao menos definir um dos parâmetros "TNome_do_tipo" ou "nome_instancia são opcionais" | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct TUsuario /* struct TUsuario é o nome do tipo que está sendo criado */ | ||
+ | { | ||
+ | char userID[20]; | ||
+ | char senha[20]; | ||
+ | } Usuario; /* aqui é definida uma variável do tipo struct TUsuario */ | ||
+ | |||
+ | struct TUsuario TabelaUsuario[20]; | ||
+ | |||
+ | main() | ||
+ | { | ||
+ | scanf("%s", Usuario.userID); | ||
+ | scanf("%s", Usuario.senha); | ||
+ | scanf("%s", TabelaUsuario[10].userID); | ||
+ | scanf("%s", TabelaUsuario[10].senha); | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Neste exemplo, foi definido um tipo (modelo) para o registro (''struct TUsuario'') e foi criada uma variável chamada ''Usuario'' a partir deste tipo. Na sequência foi criada mais uma variável (um vetor de estruturas) chamada ''TabelaUsuario''. Note que basta usar as palavras chave ''struct Usuario'' para criar novas variáveis. O tipo completo é definido uma única vez no início. | ||
+ | |||
+ | ;Exercícios | ||
+ | |||
+ | #Criar um programa que define uma ''struct'' para armazenamento do nome e das notas bimestrais de um aluno. Atualizar a estrutura usando o scanf. | ||
+ | #Alterar o programa para que ele calcule e imprima a média de cada aluno. | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | #define NUM_MAX 3 | ||
+ | |||
+ | struct TAluno { | ||
+ | char nome[30]; | ||
+ | char matricula[11]; | ||
+ | float b1,b2,b3,b4; | ||
+ | } Turma[NUM_MAX]; | ||
+ | |||
+ | void print_aluno(struct TAluno aux) | ||
+ | { | ||
+ | printf("Nome -> %s\n", aux.nome); | ||
+ | printf("Matrícula -> %s\n", aux.matricula); | ||
+ | printf("Bimestre 1 -> %f\n", aux.b1); | ||
+ | printf("Bimestre 2 -> %f\n", aux.b2); | ||
+ | printf("Bimestre 3 -> %f\n", aux.b3); | ||
+ | printf("Bimestre 4 -> %f\n", aux.b4); | ||
+ | } | ||
+ | |||
+ | main() | ||
+ | { | ||
+ | int i; | ||
+ | |||
+ | for(i=0;i<NUM_MAX;i++) { | ||
+ | printf("Entre com o nome do aluno\n"); | ||
+ | scanf("%s", Turma[i].nome); | ||
+ | printf("Entre com a matrícula do aluno\n"); | ||
+ | scanf("%s", Turma[i].matricula); | ||
+ | printf("Entre com a nota do bimestre 1\n"); | ||
+ | scanf("%f", &Turma[i].b1); | ||
+ | printf("Entre com a nota do bimestre 2\n"); | ||
+ | scanf("%f", &Turma[i].b2); | ||
+ | printf("Entre com a nota do bimestre 3\n"); | ||
+ | scanf("%f", &Turma[i].b3); | ||
+ | printf("Entre com a nota do bimestre 4\n"); | ||
+ | scanf("%f", &Turma[i].b4); | ||
+ | } | ||
+ | for(i=0;i<NUM_MAX;i++) { | ||
+ | printf("=========== Aluno %d ============\n", i); | ||
+ | print_aluno(Turma[i]); | ||
+ | } | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ;Copiando Estruturas | ||
+ | |||
+ | O exemplo a seguir demonstra como se pode copiar uma variável ''struct'' para outra do mesmo tipo. | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct THoras{ | ||
+ | int hora; | ||
+ | int minuto; | ||
+ | int segundo; | ||
+ | }; | ||
+ | |||
+ | struct THoras Ontem = {2,10,57}; | ||
+ | |||
+ | void main() | ||
+ | { | ||
+ | struct THoras Hoje; | ||
+ | Hoje = Ontem; | ||
+ | |||
+ | printf("Hora hoje = %d, Minuto hoje = %d e Segundo hoje %d\n", Hoje.hora, Hoje.minuto, Hoje.segundo); | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ;Estruturas dentro de estruturas | ||
+ | |||
+ | Vamos ver um exemplo com estruturas definidas dentro de estruturas: | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct TEndereco{ | ||
+ | char rua[50]; | ||
+ | char numero[10]; | ||
+ | }; | ||
+ | |||
+ | struct TCidadao{ | ||
+ | char nome[50]; | ||
+ | char cpf[20]; | ||
+ | struct TEndereco endereco; | ||
+ | int num_filhos; | ||
+ | }; | ||
+ | |||
+ | void main() | ||
+ | { | ||
+ | struct TCidadao Cidadao; | ||
+ | |||
+ | printf("Entre com o nome\n"); | ||
+ | scanf ("%s",Cidadao.nome); | ||
+ | |||
+ | printf("Entre com o cpf\n"); | ||
+ | scanf ("%s",Cidadao.cpf); | ||
+ | |||
+ | printf("Entre a rua\n"); | ||
+ | scanf ("%s",Cidadao.endereco.rua); | ||
+ | |||
+ | printf("Entre a numero\n"); | ||
+ | scanf ("%s",Cidadao.endereco.numero); | ||
+ | |||
+ | printf("Entre com o número de filhos\n"); | ||
+ | scanf ("%d",&Cidadao.num_filhos); | ||
+ | |||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ;Iniciando structs na definição | ||
+ | |||
+ | Como toda variável, é possível dar valores para uma variável do tipo struct definida no programa: | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct TEndereco { | ||
+ | char rua[50]; | ||
+ | int numero; | ||
+ | }; | ||
+ | |||
+ | struct TCidadao{ | ||
+ | char nome[50]; | ||
+ | char cpf[20]; | ||
+ | struct TEndereco endereco; | ||
+ | }; | ||
+ | |||
+ | int main(void) | ||
+ | { | ||
+ | //Inicializando com parâmetros em sequencia (ordem tem que ser respeitada) | ||
+ | struct TCidadao CidadaoMaria = {"Maria","42342342234",{"Rua AlfaBeta",145}}; | ||
+ | //Inicializando com parâmetros via campo (não é necessário respeitar qualquer ordem) | ||
+ | struct TCidadao CidadaoJose = {.cpf = "1234567890", .endereco.numero = 541,.nome = "Jose",.endereco.rua = "Rua GamaDelta"}; | ||
+ | |||
+ | printf("Rua do cidadao %s = %s\n", CidadaoMaria.nome, CidadaoMaria.endereco.rua); | ||
+ | printf("Rua do cidadao %s = %s\n", CidadaoJose.nome, CidadaoJose.endereco.rua); | ||
+ | |||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
+ | |||
+ | ;Passando estruturas como parâmetro e retornando estruturas | ||
+ | |||
+ | Se não for usado o operador "&" , um parâmetro que é estrutura será passado por cópia. Não apresentaremos agora a passagem por endereço pois necessita do conceita de ponteiro. | ||
+ | Observe o exercício abaixo. | ||
+ | |||
+ | <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct TEndereco{ | ||
+ | char rua[50]; | ||
+ | char numero[10]; | ||
+ | }; | ||
+ | |||
+ | struct TCidadao{ | ||
+ | char nome[50]; | ||
+ | char cpf[20]; | ||
+ | struct TEndereco endereco; | ||
+ | int num_filhos; | ||
+ | }; | ||
+ | |||
+ | void print_struct (struct TCidadao aux) | ||
+ | { | ||
+ | printf("nome=%s cpf=%s\n", aux.nome, aux.cpf); | ||
+ | printf("endereço inicial do aux %p\n", &aux); | ||
+ | } | ||
+ | |||
+ | void main() | ||
+ | { | ||
+ | struct TCidadao Cidadao; | ||
+ | |||
+ | printf("Entre com o nome\n"); | ||
+ | scanf ("%s",Cidadao.nome); | ||
+ | |||
+ | printf("Entre com o cpf\n"); | ||
+ | scanf ("%s",Cidadao.cpf); | ||
+ | |||
+ | printf("Entre a rua\n"); | ||
+ | scanf ("%s",Cidadao.endereco.rua); | ||
+ | |||
+ | printf("Entre a numero\n"); | ||
+ | scanf ("%s",Cidadao.endereco.numero); | ||
+ | |||
+ | printf("Entre com o número de filhos\n"); | ||
+ | scanf ("%d",&Cidadao.num_filhos); | ||
+ | |||
+ | print_struct(Cidadao); | ||
+ | |||
+ | printf("endereço inicial do Cidadao %p\n", &Cidadao); | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | ;Exercícios: | ||
+ | |||
+ | #Implementar um contador de acesso que permita bloquear o usuário após 3 tentativas seguidas. Note que caso o usuário acerte a senha, este contador deverá ser zerado. | ||
+ | #Implementar uma funcionalidade do administrador para desbloquear o usuário bloqueado. | ||
+ | #No programa de controle de senha inserir um campo na estrutura do usuário de forma a acomodar uma mensagem de boas vindas particularizada para cada usuário. A mensagem "DEFAULT" é Bom dia! | ||
+ | #Implementar na função administrar a inserção da mensagem no exercício anterior. | ||
+ | #Na solução acima criar uma função que procura usuário na tabela (já que este código é utilizado em mais do que um luga). A função deve receber o UserID a ser procurado e deve retornar um inteiro correspondente ao índice do usuário encontrado ou -1 se não for encontrado. | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Unions}} | ||
+ | Union é um recurso do C que permite declarar um conjunto de dados que irá ocupar um mesmo espaço. É bastante empregado quando se deseja economizar espaço ou não se tem certeza sobre qual tipo de dado deve ser armazenado para determinada instancia. No exemplo a seguir é criada uma struct chamada TProduto e dentro destra estrutura há uma área de detalhamento do produto que é de uso genérico, para alguns produtos há campos específicos para preenchimento e outros não se tem ao certo os detalhes, portanto fica um campo de uso geral. <syntaxhighlight lang=c> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | struct TRoupeiro{ | ||
+ | char cor[20]; | ||
+ | int volume; | ||
+ | float peso; | ||
+ | }; | ||
+ | |||
+ | struct TProduto{ | ||
+ | int id; | ||
+ | char nome[20]; | ||
+ | union { | ||
+ | struct TRoupeiro roupeiro; | ||
+ | char descricao_generica[sizeof(int)+sizeof(float)+20]; | ||
+ | }; | ||
+ | }; | ||
+ | |||
+ | int main(void) | ||
+ | { | ||
+ | struct TProduto vaso_decorativo = { | ||
+ | .id = 2,.nome = "Vaso decorativo 1", | ||
+ | .descricao_generica = "em vidro - peça única" | ||
+ | }; | ||
+ | |||
+ | struct TProduto guarda_roupas_solteiro = { | ||
+ | .id = 1,.nome = "Roupeiro 3 portas", | ||
+ | .roupeiro.cor = "CZ", .roupeiro.volume = 304,.roupeiro.peso = 50.0 | ||
+ | |||
+ | }; | ||
+ | printf("nome = %s, \ndescrição = %s, \ncor = %s, \nvolume = %d, \npeso = %f\n\n\n", | ||
+ | guarda_roupas_solteiro.nome, | ||
+ | guarda_roupas_solteiro.descricao_generica, | ||
+ | guarda_roupas_solteiro.roupeiro.cor, | ||
+ | guarda_roupas_solteiro.roupeiro.volume, | ||
+ | guarda_roupas_solteiro.roupeiro.peso | ||
+ | ); | ||
+ | printf("nome = %s, \ndescrição = %s, \ncor = %s, \nvolume = %d, \npeso = %f\n\n\n", | ||
+ | vaso_decorativo.nome, | ||
+ | vaso_decorativo.descricao_generica, | ||
+ | vaso_decorativo.roupeiro.cor, | ||
+ | vaso_decorativo.roupeiro.volume, | ||
+ | vaso_decorativo.roupeiro.peso | ||
+ | ); | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | *Observe que a union é feita de duas entre uma struct e um vetor de caracteres. O autor neste código criou este vetor baseado no tamanho que ocupa a struct aproveitando todo o espaço já alocado, porém o C não exige que os dados ocupem o mesmo espaço, neste caso a alocação ocorrerá em relação a maior estrutura. | ||
+ | *Observe que ao imprimir os valores da instancia "guarda_roupas" o "descricao_generica" apesar de não ter sido formalmente preenchido, foi indiretamente preenchido quando no caso "roupeiro.cor" recebeu um valor. Como este valor foi "Cinza" o C escreveu um "\0" no final da string "roupeiro.cor" que acabou também servindo como final da string "descricao_generica", por isso neste print ambos os campos apresentam o mesmo valor. Porém observe também que os valores de "volume" e "peso" estão perfeitamente preservados. | ||
+ | *Agora foi interessante o cado da instancia "vaso_decorativo", ela foi descrita pelo campo "descricao_generica" e apenas para fins didáticos o autor imprimiu o que teria dentro de "roupeiro.cor", "roupeiro.volume" e "roupeiro.peso". Neste caso cairam valores oriundos da constante "em vidro - peça única" que não passam de sujeira neste contexto. | ||
{{collapse bottom}} | {{collapse bottom}} | ||
Edição das 13h47min de 2 de maio de 2017
Dados importantes
- Professor da Disciplina: Cleber Jorge Amaral
- Email: cleber.amaral@ifsc.edu.br
- Atendimento paralelo: terças e quintas das 12:00 as 13:00 na Sala Multimeios de Tele (ao lado da reprografia)
- Agenda do professor: Ver página
Dados da Disciplina
- Ementa da disciplina na wiki: Engenharia de Telecomunicações 2ª Fase
- Página no moodle: moodle
- Monitoria: Programa_de_monitoria_dos_cursos_superiores_de_Telecomunicações
Algoritmos utilizando fluxograma
Introdução aos algoritmos utilizando fluxograma
Introdução aos algoritmos utilizando fluxograma |
---|
|
Desenvolvendo algoritmos na forma de fluxogramas
Desenvolvendo algoritmos na forma de fluxogramas |
---|
Exercícios para resolver em sala de aula:
|
Pseudo-código
Pseudo-código utilizando Portugol - Introdução e condicionais
- Slides sobre pseudocódigo disponibilizados no moodle.
Ver exemplos de códigos Portugol dentro do software portugol (menu Arquivo->Abrir exemplo)
Pseudo-código utilizando Portugol - repetições
Exercícios - Pseudocodigo (série 1) |
---|
Exercícios - Pseudocodigo (série 1):
|
Exercícios - Pseudocodigo (série 2) |
---|
Exercícios - Pseudocpodigo (série 2):
Exercícios complementares:
|
Pseudo-código utilizando Portugol - sub-rotinas e registros
Exercícios - Pseudocodigo (série 3) |
---|
Exercícios - Pseudocodigo (série 3):
Parte da implementação do problema das funções trigonométricas
|
Programação em C (ANSI)
Programação em C (ANSI) - Introdução ao C
Introdução ao C e funções de saída e entrada de dados |
---|
|
Programação em C (ANSI) - Controle de fluxo em C
Programação em C (ANSI) - Condicionais
Condicionais em C |
---|
|
Exercícios - C (série 0) |
---|
|
Programação em C (ANSI) - Repetições
Estruturas de repetição em C |
---|
|
Exercícios - C (série 1) |
---|
|
Funções
Funções |
---|
|
A função main |
---|
O programa inicia pela primeira instrução contida na função main() e também se encerra na última instrução. O retorno padrão da função main é um int que representa um código de erros reconhecidos por muitos sistemas operacionais. Se o programa terminou sua execução corretamente o retorno deverá ser 0 (zero). int main(void)
{
//Programa
return 0;
}
|
O método exit() |
---|
Uma alternativa a terminação do programa chegando ao fim da função main é a função exit da biblioteca <stdlib.h>. Para esta função deve-se passar um argumento inteiro que tem o mesmo significado do código de retorno da função main, portanto exit(0) representa uma terminação normal, alternativamente exit(EXIT_SUCCESS). Para representar uma terminação anormal pode-se utilizar exit(EXIT_FAILURE) ou exit(1).
|
Vetores, strings e matrizes em C
Vetores e matrizes em C |
---|
char nome_da_string [tamanho];
|
Gerando números pseudo-aleatórios |
---|
|
Tabela ASCII |
---|
|
Vetor de tamanho variável |
---|
O vetor de tamanho variável (variable lenght array) é um recurso do C que permite que o tamanho do vetor seja definido em tempo de execução. Na prática o C irá alocar uma quantidade de memória que não precisa estar definida antes da execução. variable-lenght |
Exercícios - C (série 2) |
---|
|
Exercícios - C (série 3) |
---|
|
Tipos de dados compostos
Estruturas |
---|
Assim como o vetor a estrutura é um conjunto de dados, mas traz uma vantagem: a possibilidade de possuir "campos" de diferentes tipos de variáveis. Por exemplo, a struct TPessoa poderia ter os campos nome (char[40]) e idade (int). A declaração genérica da estrutura é: struct TNome_do_tipo { //variável 1 //variável 2 //variável N } nome_instancia;
#include <stdio.h>
struct TUsuario /* struct TUsuario é o nome do tipo que está sendo criado */
{
char userID[20];
char senha[20];
} Usuario; /* aqui é definida uma variável do tipo struct TUsuario */
struct TUsuario TabelaUsuario[20];
main()
{
scanf("%s", Usuario.userID);
scanf("%s", Usuario.senha);
scanf("%s", TabelaUsuario[10].userID);
scanf("%s", TabelaUsuario[10].senha);
}
Neste exemplo, foi definido um tipo (modelo) para o registro (struct TUsuario) e foi criada uma variável chamada Usuario a partir deste tipo. Na sequência foi criada mais uma variável (um vetor de estruturas) chamada TabelaUsuario. Note que basta usar as palavras chave struct Usuario para criar novas variáveis. O tipo completo é definido uma única vez no início.
#include <stdio.h>
#define NUM_MAX 3
struct TAluno {
char nome[30];
char matricula[11];
float b1,b2,b3,b4;
} Turma[NUM_MAX];
void print_aluno(struct TAluno aux)
{
printf("Nome -> %s\n", aux.nome);
printf("Matrícula -> %s\n", aux.matricula);
printf("Bimestre 1 -> %f\n", aux.b1);
printf("Bimestre 2 -> %f\n", aux.b2);
printf("Bimestre 3 -> %f\n", aux.b3);
printf("Bimestre 4 -> %f\n", aux.b4);
}
main()
{
int i;
for(i=0;i<NUM_MAX;i++) {
printf("Entre com o nome do aluno\n");
scanf("%s", Turma[i].nome);
printf("Entre com a matrícula do aluno\n");
scanf("%s", Turma[i].matricula);
printf("Entre com a nota do bimestre 1\n");
scanf("%f", &Turma[i].b1);
printf("Entre com a nota do bimestre 2\n");
scanf("%f", &Turma[i].b2);
printf("Entre com a nota do bimestre 3\n");
scanf("%f", &Turma[i].b3);
printf("Entre com a nota do bimestre 4\n");
scanf("%f", &Turma[i].b4);
}
for(i=0;i<NUM_MAX;i++) {
printf("=========== Aluno %d ============\n", i);
print_aluno(Turma[i]);
}
}
O exemplo a seguir demonstra como se pode copiar uma variável struct para outra do mesmo tipo. #include <stdio.h>
struct THoras{
int hora;
int minuto;
int segundo;
};
struct THoras Ontem = {2,10,57};
void main()
{
struct THoras Hoje;
Hoje = Ontem;
printf("Hora hoje = %d, Minuto hoje = %d e Segundo hoje %d\n", Hoje.hora, Hoje.minuto, Hoje.segundo);
}
Vamos ver um exemplo com estruturas definidas dentro de estruturas: #include <stdio.h>
struct TEndereco{
char rua[50];
char numero[10];
};
struct TCidadao{
char nome[50];
char cpf[20];
struct TEndereco endereco;
int num_filhos;
};
void main()
{
struct TCidadao Cidadao;
printf("Entre com o nome\n");
scanf ("%s",Cidadao.nome);
printf("Entre com o cpf\n");
scanf ("%s",Cidadao.cpf);
printf("Entre a rua\n");
scanf ("%s",Cidadao.endereco.rua);
printf("Entre a numero\n");
scanf ("%s",Cidadao.endereco.numero);
printf("Entre com o número de filhos\n");
scanf ("%d",&Cidadao.num_filhos);
}
Como toda variável, é possível dar valores para uma variável do tipo struct definida no programa: #include <stdio.h>
struct TEndereco {
char rua[50];
int numero;
};
struct TCidadao{
char nome[50];
char cpf[20];
struct TEndereco endereco;
};
int main(void)
{
//Inicializando com parâmetros em sequencia (ordem tem que ser respeitada)
struct TCidadao CidadaoMaria = {"Maria","42342342234",{"Rua AlfaBeta",145}};
//Inicializando com parâmetros via campo (não é necessário respeitar qualquer ordem)
struct TCidadao CidadaoJose = {.cpf = "1234567890", .endereco.numero = 541,.nome = "Jose",.endereco.rua = "Rua GamaDelta"};
printf("Rua do cidadao %s = %s\n", CidadaoMaria.nome, CidadaoMaria.endereco.rua);
printf("Rua do cidadao %s = %s\n", CidadaoJose.nome, CidadaoJose.endereco.rua);
}
Se não for usado o operador "&" , um parâmetro que é estrutura será passado por cópia. Não apresentaremos agora a passagem por endereço pois necessita do conceita de ponteiro. Observe o exercício abaixo. #include <stdio.h>
struct TEndereco{
char rua[50];
char numero[10];
};
struct TCidadao{
char nome[50];
char cpf[20];
struct TEndereco endereco;
int num_filhos;
};
void print_struct (struct TCidadao aux)
{
printf("nome=%s cpf=%s\n", aux.nome, aux.cpf);
printf("endereço inicial do aux %p\n", &aux);
}
void main()
{
struct TCidadao Cidadao;
printf("Entre com o nome\n");
scanf ("%s",Cidadao.nome);
printf("Entre com o cpf\n");
scanf ("%s",Cidadao.cpf);
printf("Entre a rua\n");
scanf ("%s",Cidadao.endereco.rua);
printf("Entre a numero\n");
scanf ("%s",Cidadao.endereco.numero);
printf("Entre com o número de filhos\n");
scanf ("%d",&Cidadao.num_filhos);
print_struct(Cidadao);
printf("endereço inicial do Cidadao %p\n", &Cidadao);
}
|
Unions |
---|
Union é um recurso do C que permite declarar um conjunto de dados que irá ocupar um mesmo espaço. É bastante empregado quando se deseja economizar espaço ou não se tem certeza sobre qual tipo de dado deve ser armazenado para determinada instancia. No exemplo a seguir é criada uma struct chamada TProduto e dentro destra estrutura há uma área de detalhamento do produto que é de uso genérico, para alguns produtos há campos específicos para preenchimento e outros não se tem ao certo os detalhes, portanto fica um campo de uso geral.
#include <stdio.h>
struct TRoupeiro{
char cor[20];
int volume;
float peso;
};
struct TProduto{
int id;
char nome[20];
union {
struct TRoupeiro roupeiro;
char descricao_generica[sizeof(int)+sizeof(float)+20];
};
};
int main(void)
{
struct TProduto vaso_decorativo = {
.id = 2,.nome = "Vaso decorativo 1",
.descricao_generica = "em vidro - peça única"
};
struct TProduto guarda_roupas_solteiro = {
.id = 1,.nome = "Roupeiro 3 portas",
.roupeiro.cor = "CZ", .roupeiro.volume = 304,.roupeiro.peso = 50.0
};
printf("nome = %s, \ndescrição = %s, \ncor = %s, \nvolume = %d, \npeso = %f\n\n\n",
guarda_roupas_solteiro.nome,
guarda_roupas_solteiro.descricao_generica,
guarda_roupas_solteiro.roupeiro.cor,
guarda_roupas_solteiro.roupeiro.volume,
guarda_roupas_solteiro.roupeiro.peso
);
printf("nome = %s, \ndescrição = %s, \ncor = %s, \nvolume = %d, \npeso = %f\n\n\n",
vaso_decorativo.nome,
vaso_decorativo.descricao_generica,
vaso_decorativo.roupeiro.cor,
vaso_decorativo.roupeiro.volume,
vaso_decorativo.roupeiro.peso
);
}
|
Referências
Referências bibliográficas |
---|
|
Ferramentas úteis |
---|
|
Plano de aula
Cronograma | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
Conceitos
Ver moodle da disciplina.