Apostila C UFU
85 pág.

Apostila C UFU


DisciplinaIntrodução à Tecnologia da Computação26 materiais156 seguidores
Pré-visualização19 páginas
Faculdade de Engenharia Elétrica e Biomédica 
 49
Matrizes de Estruturas 
 
 Para declarar uma matriz de estruturas, você deve primeiro definir uma estrutura 
e, então, declarar uma variável matriz desse tipo. Por exemplo, para declarar uma matriz 
de estruturas com 50 elementos do tipo alunos, que foi definido anteriormente, deve-se 
escrever 
 
 struct alunos informacao[50]; 
 
 Isso cria 50 conjuntos de variáveis que estão organizados como definido na 
estrutura alunos. 
 Para acessar uma determinada estrutura, deve-se indexar o nome da estrutura. 
Por exemplo, para imprimir o número de faltas do aluno 4, escreva 
 
printf(\u201c%d \u201d, informação[3].numero_de_faltas); 
 
 Como todas as outras matrizes, matrizes de estruturas começam a indexação em 
zero. 
 
Passando estruturas para funções 
 
 Até agora, todas as estruturas e matrizes vistas foram declaradas como globais. 
Mostraremos agora como passar estruturas e seus elementos para funções. 
 
 Quando você passa um elemento de uma variável estrutura para uma função, 
está, de fato, passando o valor desse elemento para a função. Veja o exemplo a seguir: 
 
struct novo 
{ 
 char x; 
 int y; 
 float z; 
 char s[10]; 
 }var; 
 
Abaixo são mostrados exemplos de cada elemento sendo passado para uma 
função: 
 
funcao1(var.x); /*passa o valor do caractere de x*/ 
funcao1(var.y); /*passa o valor inteiro de y*/ 
funcao1(var.z); /*passa o valor float de z*/ 
funcao1(var.s); /*passa o endereço da string s*/ 
funcao1(var.s[2]); /*passa o valor do caractere de s[2]*/ 
 
 
 
 
 
 
Universidade Federal De Uberlândia 
Faculdade de Engenharia Elétrica e Biomédica 
 50
 Porém, se você quiser passar o endereço de um elemento individual da estrutura, 
ponha o operador & antes do nome da estrutura. Por exemplo, escreva: 
 
funcao1(&var.x); /*passa o endereço do caractere de x*/ 
funcao1(&var.y); /*passa o endereço inteiro de y*/ 
funcao1(&var.z); /*passa o endereço float de z*/ 
funcao1(var.s); /*passa o endereço da string s*/ 
funcao1(&var.s[2]);/*passa o endereço do caractere de s[2]*/ 
 
 Quando uma estrutura é usada como um argumento para uma função, a estrutura 
inteira é passada usando o método padrão chamado por valor. 
 Quando usar uma estrutura como parâmetro, lembre-se de que o tipo de 
argumento deve coincidir com o tipo de parâmetro. Por exemplo, esse programa 
imprime os números 100 e 250, e uma constante string na tela. Definimos uma estrutura 
global e, então usamos seu nome para declarar variáveis estruturas e parâmetros, 
conforme necessário. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#include <stdio.h> 
#include <conio.h> 
void funcao1(struct estrutura param); 
void funcao2(struct estrutura param2); 
 
struct estrutura 
{ 
 int a, b; 
 char ch; 
}; 
 
void main() 
{ 
 struct estrutura arg; 
 arg.a = 100; 
 arg.b = 250; 
 arg.ch = &quot;Ola mundo&quot;; 
 funcao1(arg); 
 funcao2(arg); 
} 
 
void funcao1(struct estrutura param1) 
{ 
 printf(&quot;%d&quot;, param1.a); 
} 
 
void funcao2(struct estrutura param2) 
{ 
 printf(&quot;\n%d&quot;, param2.a); 
 printf(&quot;\n%s&quot;, param2.ch); 
 _getch(); 
} 
Universidade Federal De Uberlândia 
Faculdade de Engenharia Elétrica e Biomédica 
 51
Ponteiros para Estruturas 
 
 Na linguagem C é permitido usar ponteiros para estruturas assim como ponteiros 
para outros tipos de variáveis. 
 
 Com outros ponteiros, você declara ponteiros para estrutura colocando * na 
frente do nome da variável estrutura. Por exemplo, o código seguinte declara um 
ponteiro para dados do tipo struct. 
 
 struct alunos *ptr; 
 
 Se várias estruturas são usadas, a performance de seu programa pode ser 
reduzida a níveis inaceitáveis, a solução para esse problema é passar apenas um ponteiro 
para uma função. E também, atualmente a grande gama dos programas utilizando 
estruturas não possui tamanho definido, precisando para isso, realizar uma alocação 
dinâmica de memória. 
 Para encontrar o endereço da variável estrutura, deve-se colocar o operador & 
antes do nome desta variável. Por exemplo: 
 
struct alunos 
{ 
 char nome[80]; 
 char numero_matricula[15]; 
 int numero_de_faltas; 
 float notas[4]; 
} informacao; 
 
struct alunos *ptr; 
 
 
então 
 
ptr = &informacao; 
 
 este código põe o endereço da estrutura informacao no ponteiro ptr. 
 
 Para acessar os elementos de uma estrutura usando um ponteiro para estrutura, 
você deve usar o operador -> (chamado operador seta). Por exemplo, isso referencia o 
campo numero_de_faltas: 
 
 ptr -> numero_de_faltas; 
 
 Este operador seta é usado no lugar do operador ponto quando se está acessando 
um elemento de estrutura através de um ponteiro para a estrutura. 
 Portanto lembre-se de usar o operador ponto para acessar elementos de 
estruturas quando estiver operando através da variável estrutura, e usar o operador seta 
quando você estiver operando através de um ponteiro para a estrutura. 
 
 
 
 
 
 
Universidade Federal De Uberlândia 
Faculdade de Engenharia Elétrica e Biomédica 
 52
Estruturas Aninhadas 
 
 Quando um elemento de uma estrutura é um elemento de outra estrutura, 
dizemos que esta é uma estrutura aninhada. Considere o exemplo abaixo: 
 
 
 Como podemos perceber, a estrutura aluno possui dois elementos. O primeiro 
elemento é a estrutura do tipo endereço, que contém outros dois elementos com dados 
do aluno relacionado ao seu endereço. O segundo elemento é nome, que é um vetor do 
tipo char. 
 
 Para acessar os elementos de uma estrutura, como sabemos, utilizamos uma 
variável estrutura. Neste caso, como há uma estrutura dentro da outra, devemos utilizar 
duas variáveis estruturas para acessar algum elemento da estrutura mais interna. O 
padrão ANSI C especifica que as estruturas podem ser aninhadas até 15 níveis. 
 
 
 
 
 
 
 
#include <stdio.h> 
#include <conio.h> 
 
struct endereco 
{ 
 char rua[80]; 
 int numero_da_casa; 
} var; 
 
struct aluno 
{ 
 char nome[80]; 
 struct endereco var; 
} info; 
 
void main() 
{ 
 printf(&quot;Nome: &quot;); 
 gets(info.nome); 
 
 printf(&quot;Rua: &quot;); 
 gets(info.var.rua); 
 
 printf(&quot;Numero da Casa: &quot;); 
 scanf(&quot;%d&quot;, &(info.var.numero_da_casa)); 
 
 printf(&quot;\n\nDados:\n&quot;); 
 printf(&quot;Nome: %s&quot;, info.nome); 
 printf(&quot;\nEndereco: %s %d&quot;, info.var.rua, 
 info.var.numero_da_casa); 
 
 _getch(); 
} 
Universidade Federal De Uberlândia 
Faculdade de Engenharia Elétrica e Biomédica 
 53
Capítulo 8 \u2013 Entrada/Saída pelo Console 
 
 Input/Output traduzindo teríamos Entrada/Saída, mais conhecido como 
simplesmente I/O ou E/S, são funções como o próprio nome já indica, funções de 
entrada e saída. O arquivo de cabeçalho dessas funções é STDIO.H, que quer dizer 
standard input/output. Podemos ter funções de I/O de diversas formas, como através do 
console, ou através de arquivos. Primeiramente vamos fala de I/O através do console. 
As funções I/O mais simples são getchar(), que lê um caractere do teclado, e putchar() 
que escreve um caractere na tela. Ambas retornam EOF se ocorrer algum erro. Vejamos 
um exemplo de função que lê caracteres do teclado e inverte a caixa deles, isto é, 
escreve maiúsculas como minúsculas ou vice-versa. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Contudo existem alguns problemas com o getchar(), como a versão de original 
de C era compatível com o UNIX, getchar() armazena em um buffer a entrada até que 
seja pressionado ENTER. Assim temos as funções getch() e getche(), que pertencem a 
biblioteca CONIO.H, embora elas não sejam definidas pelo padrão ANSI, elas são mais 
recomendadas. A função getch() espera até que uma tecla seja pressionada, e retorna 
imediatamente, e não mostra o caractere na tela. A getche() é igual a getch(), mas a 
tecla é mostrada. 
 
 Para ler e escrever strings temos as funções gets() e puts(), assim como temos as 
funções printf() e scanf(). A diferença básica é que uma chamada a gets() ou puts() 
requer bem menos tempo