Mudanças entre as edições de "PRG29002 - Programação I - Eng.Telecom 2017-2"
Linha 604: | Linha 604: | ||
*#Implemente um programa em C que calcule a Potência dissipada em um resistor e a corrente dados valores de V e R. O mesmo programa deve ser capaz de calcular a R dados P e V e R dados V e I. Faça então um menu inicial para que o usuário possa selecionar a opção de cálculo desejada. Crie diferentes funções para opção. | *#Implemente um programa em C que calcule a Potência dissipada em um resistor e a corrente dados valores de V e R. O mesmo programa deve ser capaz de calcular a R dados P e V e R dados V e I. Faça então um menu inicial para que o usuário possa selecionar a opção de cálculo desejada. Crie diferentes funções para opção. | ||
*#Implemente um programa em C de uma calculadora de soma e subtração. Para isso, a função main deve ter um loop infinito, encerrando o programa se digitado 's'. Dentro do loop invoque uma função "imprimirMenu" de retorno void que imprime as opções do menu utilizando "1 para soma", "2 para subtração" ou "s para sair". Se o usuário digitar 1, invoque uma outra função chamada "soma" que recebe dois float obtidos dentro do próprio main e passados como parâmetros. A função deve retornar a soma destes números para que main imprima o resultado ao usuaŕio. Um processo similar deve ser feito para subtracao. | *#Implemente um programa em C de uma calculadora de soma e subtração. Para isso, a função main deve ter um loop infinito, encerrando o programa se digitado 's'. Dentro do loop invoque uma função "imprimirMenu" de retorno void que imprime as opções do menu utilizando "1 para soma", "2 para subtração" ou "s para sair". Se o usuário digitar 1, invoque uma outra função chamada "soma" que recebe dois float obtidos dentro do próprio main e passados como parâmetros. A função deve retornar a soma destes números para que main imprima o resultado ao usuaŕio. Um processo similar deve ser feito para subtracao. | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | == Vetores, strings e matrizes em C == | ||
+ | <!--{{collapse top|Vetores e matrizes em C}}--> | ||
+ | *Matrizes de qualquer dimensão são caracterizadas por terem todos os elementos pertencentes ao mesmo tipo de dado; | ||
+ | *Vetores são matrizes unidimensionais; | ||
+ | *O indexador começa sempre em zero; | ||
+ | *É importante observar que o C não controla se o programador está ou não acessando uma posição de memória válida da estrutura, cabe ao programador criar proteções; | ||
+ | *Declaração: <syntaxhighlight lang=c> | ||
+ | tipo_da_variável nome_do_vetor [tamanho]; | ||
+ | tipo_da_variável nome_da_matriz [linhas][colunas]; </syntaxhighlight> | ||
+ | *Strings são vetores de chars; | ||
+ | *Têm o seu último elemento como um '\0' | ||
+ | Declaração: <syntaxhighlight lang=c> | ||
+ | char nome_da_string [tamanho]; </syntaxhighlight> | ||
+ | *Inicialização: <syntaxhighlight lang=c> | ||
+ | float vect [6] = { 1.3, 4.5, 2.7, 4.1, 0.0, 100.1 }; | ||
+ | int matrx [3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; | ||
+ | char str [10] = { 'J', 'o', 'a', 'o', '\0' }; | ||
+ | char str [10] = "Joao"; | ||
+ | char str_vect [3][10] = { "Joao", "Maria", "Jose" }; | ||
+ | </syntaxhighlight> | ||
+ | *Inicialização sem especificação de tamanho <syntaxhighlight lang=c> | ||
+ | char mess [] = "Linguagem C: flexibilidade e poder."; | ||
+ | int matrx [][2] = { 1,2,2,4,3,6,4,8,5,10 };</syntaxhighlight> | ||
+ | <!--{{collapse bottom}}--> | ||
+ | |||
+ | {{collapse top | Gerando números pseudo-aleatórios}} | ||
+ | *Pergunta: é possivel que um computador binario utilizando apenas recursos computacionais seja puramente aleatorio? | ||
+ | |||
+ | *Existem artifícios de se criar números que variam conforme determinadas condições como sequencias variáveis associadas a data e hora atual por exemplo, a isso chamamos de números pseudo aleatórios. Para conseguir este recurso em C podemos utilizar a função rand() da stblib associada a função srand que configura uma semente de aleatoriedade a função rand, o resultado pode ser conferido no código a seguir: <syntaxhighlight lang=c> | ||
+ | #include <stdlib.h> | ||
+ | #include <time.h> | ||
+ | #include <stdio.h> | ||
+ | |||
+ | int main(void) { | ||
+ | |||
+ | srand( (unsigned)time(NULL) ); | ||
+ | printf("Numero gerado: %d\n", rand() % 10); //Gera números que variam de 0 a 9 | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | {{collapse bottom}} | ||
+ | {{collapse top | Tabela ASCII}} | ||
+ | *Os computadores armazenam todos os tipos de dados na forma numérica, incluindo letras. Para apresentar textos em tela neste caso o programa em C precisa conhecer o tipo de dado que está escrito em memória, sendo um dado do tipo caractere (ou string) ele será então tratado como uma letra. O conjunto de letras, números e símbolos imprimíveis está sintetizado na tabela ASCII. | ||
+ | **Para ver a tabela, acesse o link [http://www.ascii-code.com/ Tabela ASCII] | ||
+ | **Observe que as letras maiúsculas variam de 65 ('A') até 90 ('Z') | ||
+ | **Observe também que as letras minúsculas estão em outra faixa, variam de 97 ('a') até 122 ('z') | ||
+ | **Os números imprimíveis também tem seus representantes, variam de 48 ('0') a 57 ('9') | ||
+ | **Caracteres especiais como '$', '%', '*', '+' também estão relacionados na tabela | ||
+ | **A tabela também apresenta códigos de caracteres não imprimíveis como o 9 (TAB), 13 ('\r' presente no ENTER) | ||
+ | **Para representações de outros caracteres pode ser necessário acessar a extensão da tabela ASCII, podendo-se obter 'Ç' e caracteres acentuados | ||
+ | **A tabela que está sendo apresentada esta em acordo com o padrão ISO 8859-1 e Microsoft® Windows Latin-1, outros caracteres podem ainda ser obtidos se alterado o padrão de codificação | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | 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. | ||
+ | [https://gcc.gnu.org/onlinedocs/gcc-5.1.0/gcc/Variable-Length.html variable-lenght] | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Exercícios - C (série 2)}} | ||
+ | *#Implementar um programa em C para ler 10 números reais (float) para um vetor. Usar o comando ''while'', imprimindo os valores lidos em um segundo laço while. (id.:3.02) | ||
+ | *#Modificar o exercício para computar a média dos 10 números que estão no vetor. (id.:3.03) | ||
+ | *#Modificar o exercício anterior para computar a quantidade de números do vetor que estão acima da média. (id.:3.04) | ||
+ | *#Refazer os exercícios anteriores usando o comando for. (id.:3.05) | ||
+ | *#Implemente um algoritmo em C que solicita do usuário 10 números, após a leitura mostra ao usuários os números na ordem inversa em que foram digitados. (id.:3.09) | ||
+ | *#Teste o exemplo dado na apostila da UFMG página 46 e execute a AUTO AVALIAÇÂO sugerida na página seguinte. | ||
+ | *#Considere um vetor global de ''floats'' chamado ''vetRnd'' de tamanho 100. Construa uma função que inicia este vetor com 100 números randômicos entre 1 e 6. Imprima em tela os valores. | ||
+ | *#Implementar uma função que recebe dois vetores de inteiros como parâmetro e o tamanho dos mesmos (suponha vetores de mesmo tamanho). A função deve retornar o número de elementos iguais comparados posição por posição. O esqueleto da função deve ser como: <syntaxhighlight lang=c> | ||
+ | int compara_vetores(int ve1[],int vet2[], int tamanho) | ||
+ | { | ||
+ | int num_elementos; | ||
+ | |||
+ | return num_elementos; | ||
+ | } | ||
+ | </syntaxhighlight>Exemplo: Para os vetores x[]={1,1,3,4,5} e y[]={1,2,3,3,5} temos três elementos iguais (nas posições 0, 2 e 4). (id.:3.01) | ||
+ | *#Implemente um algoritmo em C que conta a ocorrência de cada letra (incluindo números de 0 a 9) dada uma frase. Deve ignorar se a letra foi digitada em maiúscula ou minúscula (portando somar junto). Limite 100 caracteres. | ||
+ | *#Implemente um algoritmo em C que calcula a média de notas de alunos. Para isso deve solicitar a quantidade de alunos, em seguida obter o nome de cada aluno e depois recebe 5 notas por aluno (num único scanf). Usar uma matriz de float de duas dimensões global. Deve então calcular as médias e apresentar: Nomes dos alunos que ficaram em recuperação (média <6), Nome do aluno que tirou a maior média, Obs.: Criar a função calculaMedia(). | ||
+ | *#Utilize a função rand() e gerador de semente srand() para gerar 6 números aleatórios distintos que variam de 1 a 60 e imprima esta sequencia em tela | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Exercícios - C (série 3)}} | ||
+ | *#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. | ||
+ | {{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> | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Exercícios - C (série 4)}} | ||
+ | #Implemente um programa onde no laço principal o usuário é questionado se deseja calcular a área de um triângulo ou de um retângulo, em seguida obtém a base e altura da forma geométrica desejada. De acordo com a seleção invoca uma função específica (ambas recebendo os argumentos base e altura do tipo float). De acordo com a seleção do usuário, utilize structs TRetangulo ou TTriangulo para armazenar a base, altura e área calculada (retornada da função). Imprima o resultado em tela. Lembre-se que a área do retângulo é dada pela base vezes a altura e a do triângulo pela base vezes altura sobre 2. | ||
+ | #Crie uma estrutura TUsuario com os campos UserID, senha e quantidade de tentativas. 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. Inclua na estrutura uma variavel _Bool para dizer se o usuário é administrador. Se for, este usuário pode ter acesso a um menu (que você deve desenvolver) de desbloqueio de usuário ao digitar um UserID de certo 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! Implemente 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 lugar). 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 08h36min de 20 de outubro 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)
Desenvolvendo algoritmos na forma de pseudo-código - condicionais |
---|
Exercícios para resolver em sala de aula:
|
Desenvolvendo algoritmos na forma de pseudo-código - repetição |
---|
|
Pseudo-código utilizando Portugol - repetições
Exercícios - Pseudocodigo (série 1) |
---|
Exercícios - Pseudocodigo (série 1):
|
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).
|
Exercícios - C (série 2) |
---|
|
Vetores, strings e matrizes em C
- Matrizes de qualquer dimensão são caracterizadas por terem todos os elementos pertencentes ao mesmo tipo de dado;
- Vetores são matrizes unidimensionais;
- O indexador começa sempre em zero;
- É importante observar que o C não controla se o programador está ou não acessando uma posição de memória válida da estrutura, cabe ao programador criar proteções;
- Declaração:
tipo_da_variável nome_do_vetor [tamanho]; tipo_da_variável nome_da_matriz [linhas][colunas];
- Strings são vetores de chars;
- Têm o seu último elemento como um '\0'
Declaração:
char nome_da_string [tamanho];
- Inicialização:
float vect [6] = { 1.3, 4.5, 2.7, 4.1, 0.0, 100.1 }; int matrx [3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; char str [10] = { 'J', 'o', 'a', 'o', '\0' }; char str [10] = "Joao"; char str_vect [3][10] = { "Joao", "Maria", "Jose" };
- Inicialização sem especificação de tamanho
char mess [] = "Linguagem C: flexibilidade e poder."; int matrx [][2] = { 1,2,2,4,3,6,4,8,5,10 };
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);
}
|
Exercícios - C (série 4) |
---|
|
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
Aula | Data | Horas | Conteúdo | Recursos | |
---|---|---|---|---|---|
1 | 28/7 | 2 | Sem atividades de PRG – reposição de férias – horário disponível para outras atividades letivas | Lab Redes 1 | |
2 | 1/8 | 2 | Sem atividades de PRG – reposição de férias – horário disponível para outras atividades letivas | Lab Redes 1 | |
3 | 4/8 | 2 | Aula inaugural, apresentação do professor e turma, apresentação da disciplina e introdução aos algoritmos | Lab Redes 1 ou Redes 2 | |
4 | 8/8 | 2 | Prática de fluxogramas | Lab Redes 1 | |
5 | 11/8 | 2 | Introdução ao pseudocódigo até condicionais com resolução de exercícios | Lab Redes 1 ou Redes 2 | |
6 | 15/8 | 2 | Prática: Resolução de problemas em pseudocódigo e fluxogramas (declaração de variáveis, leia e escreva, uso de condicionais e biblioteca portugol) | Lab Redes 1 | |
7 | 18/8 | 2 | Pseudocódigo: Uso de vetores e sub-rotinas | Lab Redes 1 ou Redes 2 | |
8 | 22/8 | 2 | Prática: Resolução de problemas com vetores e sub-rotinas | Lab Redes 1 | |
9 | 25/8 | 2 | Pseudocódigo e fluxogramas: Registros e revisão geral | Lab Redes 1 ou Redes 2 | |
10 | 29/8 | 2 | Pseudocódigo e fluxogramas: Exercícios de preparação para prova | Lab Redes 1 | |
11 | 1/9 | 2 | Avaliação1: Introdução a algoritmos (fluxograma e pseudocódigo) | Lab Redes 1 ou Redes 2 | |
12 | 5/9 | 2 | Prática: Correção da Avaliação | Lab Redes 1 | |
13 | 12/9 | 2 | Recuperação1? / Introdução ao C, primeiros conceitos de compilação, variáveis, controle de fluxo, entrada e saída de dados | Lab Redes 1 | |
14 | 15/9 | 2 | Continuação C, condicionais, operadores relacionais, operadores lógicos. Prática: Controle de fluxo em C, entrada e saída de dados | Lab Redes 1 ou Redes 2 | |
15 | 19/9 | 2 | Prática C | Lab Redes 1 | |
16 | 22/9 | 2 | Continuação C: estruturas de repetição | Lab Redes 1 ou Redes 2 | |
17 | 26/9 | 2 | Prática: estruturas de repetição | Lab Redes 1 | |
18 | 29/9 | 2 | Continuação C: funções | Lab Redes 1 ou Redes 2 | |
19 | 3/10 | 2 | Prática: Funções em C | Lab Redes 1 | |
20 | 6/10 | 2 | Avaliação2: C até funções | Lab Redes 1 ou Redes 2 | |
21 | 10/10 | 2 | Correção da prova | Lab Redes 1 | |
22 | 17/10 | 2 | Recuperação2? / Prática para resolução de exercícios | Lab Redes 1 | |
23 | 20/10 | 2 | Introdução a vetores e matrizes em C. | Lab Redes 1 ou Redes 2 | |
24 | 24/10 | 2 | Resolução de exercícios de vetores Prática: Resolução de exercícios de fixação de vetores. | Lab Redes 1 | |
25 | 27/10 | 2 | Structs e Unions | Lab Redes 1 ou Redes 2 | |
26 | 31/10 | 2 | Prática: Structs e unions | Lab Redes 1 | |
27 | 7/11 | 2 | Prática: Structs e unions / Compreendendo melhor a função main e exit, gerando números pseudo-aleatórios, defines e operadores e precedências | Lab Redes 1 | |
28 | 10/11 | 2 | Ponteiros | Lab Redes 1 ou Redes 2 | |
29 | 14/11 | 2 | Prática: Exercicios ponteiros | Lab Redes 1 | |
30 | 17/11 | 2 | Vetor de Ponteiros e Ponteiro Para Estruturas, typedef, recursividade, apresentação do projeto | Lab Redes 1 ou Redes 2 | |
31 | 21/11 | 2 | Prática de Ponteiros e structs | Lab Redes 1 | |
32 | 24/11 | 2 | Avaliação: C até structs e ponteiros | Lab Redes 1 ou Redes 2 | |
33 | 28/11 | 2 | Prática: Correção da Avaliação / Desenvolvimento do projeto | Lab Redes 1 | |
34 | 1/12 | 2 | Apresentação do projeto. Prática: Desenvolvimento do Projeto | Lab Redes 1 ou Redes 2 | |
35 | 5/12 | 2 | Recuperação3? / Prática: Desenvolvimento do Projeto | Lab Redes 1 | |
36 | 8/12 | 2 | Prática: Desenvolvimento do Projeto | Lab Redes 1 ou Redes 2 | |
37 | 12/12 | 2 | Avaliação4: Apresentação do projeto | Lab Redes 1 | |
38 | 15/12 | 2 | Avaliação4 (continuação): Apresentação do projeto | Lab Redes 1 ou Redes 2 | |
39 | 19/12 | 2 | Encerramento da disciplina / Recuperação4? | Lab Redes 1 | |
TOTAL | 80 |
Conceitos
Ver moodle da disciplina.