estruturas.tex

\documentclass[apostila.tex]{subfiles}


\begin{document}

\chapter{estruturas}

Uma estrutura é uma coleção de uma ou mais variáveis agrupadas sob um único nome para facilitar a
sua manipulação. As variáveis de uma estrutura, ao contrário das variáveis de uma matriz, podem ser de
diferentes tipos de dados. Uma estrutura pode conter quaisquer tipos de dados válidos em C, inclusive
matrizes e até mesmo outras estruturas.

\section{A palavra-chave struct}


\begin{lstlisting}
struct rotulo {
	tipo campo1;
	...
	tipo campoN;
} [instância];
\end{lstlisting}

A palavra-chave struct é usada para declarar estruturas em C. Ela identifica o início de uma definição
de estrutura e é sempre seguida por um rótulo, que é o nome atribuído à estrutura. A seguir vêm os
membros da estrutura, delimitados entre chaves. Uma instância, que é uma declaração de uma variável
do tipo da estrutura, também pode ser incluída na definição.

\section{Definindo e declarando}

Existem basicamente duas maneiras de definir e declarar estruturas em C:

\begin{itemize}

	\item A primeira é colocar uma lista com um ou mais nomes de variáveis
			imediatamente após a definição da estrutura, conforme o exemplo a seguir:

\begin{lstlisting}
struct coord { // definicao de uma estrutura
	int x;
	int y;
} primeira, segunda; // declaracao de variaveis
\end{lstlisting}

estas instruções definem o tipo de estrutura coord e declaram duas estruturas (variáveis) deste
tipo, chamadas primeira e segunda.

	\item A segunda maneira é declarar variáveis da estrutura em algum outro ponto do código-fonte. Por
exemplo:
\begin{lstlisting}
struct coord { // definicao de uma estrutura
	int x;
	int y;
};

// instrucoes adicionais aqui...

// declaração de variaveis
struct coord primeira, segunda;
\end{lstlisting}

\end{itemize}


\subsection{Acessando os membros de uma estrutura}

Os membros individuais de uma estrutura podem ser usados como qualquer outra variável
respeitando-se as características do seu tipo. Para acessar os membros de uma estrutura,
utiliza-se o operador de membro de estrutura `.' entre o nome da estrutura e o nome do membro.

Exemplo:

\begin{lstlisting}
struct coord {
	int x;
	int y;
} primeira, segunda;

primeira.x = 50;
primeira.y = -30;
\end{lstlisting}

Uma das vantagens de se utilizar estruturas ao invés de variáveis individuais é a capacidade de copiar
informações entre estruturas do mesmo tipo através de uma única instrução de atribuição. Continuando
com o exemplo anterior, a instrução:

\begin{lstlisting}
segunda = primeira;
\end{lstlisting}

é equivalente a:

\begin{lstlisting}
segunda.x = primeira.x;
segunda.y = primeira.y;
\end{lstlisting}

Exemplo:

Recebe informações sobre as coordenadas dos cantos de um retângulo e calcula a sua área. Presume
que a coordenada y no canto superior esquerdo é maior que a coordenada y no canto inferior direito, que
a coordenada x do canto inferior direito é maior do que a coordenada x do canto superior esquerdo, e que
todas as coordenadas são positivas.

\begin{lstlisting}
#include <stdio.h>

struct coord{
	int x;
	int y;
};

struct retang{
	struct coord esqcima;
	struct coord dirbaixo;
};

void main ()
{
	int altura, largura;
	long area;
	struct retang quadro;

	// recebe as coordenadas
	printf("Digite a coordenada x superior esq.:\n");
	scanf("%d", &quadro.esqcima.x);

	printf("Digite a coordenada y superior esq.:\n");
	scanf("%d", &quadro.esqcima.y);

	printf("Digite a coordenada x inferior dir.:\n");
	scanf("%d", &quadro.dirbaixo.x);

	printf("Digite a coordenada y inferior dir.:\n");
	scanf("%d", &quadro.dirbaixo.y);

	// calcula o comprimento e a largura
	largura = quadro.dirbaixo.x - quadro.esqcima.x;
	altura = quadro.esqcima.y - quadro.dirbaixo.y;

	// calcula e informa a area
	area = largura * altura;
	printf("O retangulo tem uma area de %ld unidades.\n", area);
}
\end{lstlisting}

A saída será:

\begin{verbatim}
Digite a coordenada x superior esq.: 1
Digite a coordenada y superior esq.: 1
Digite a coordenada x inferior dir.: 10
Digite a coordenada y inferior dir.: 10
O retângulo tem uma área de 81 unidades.
\end{verbatim}

OBS.: Quando estruturas são passadas por referência, utilizamos o operador `\verb|->|' ao invés do operador
`.'.

exemplo:

\vspace*{\fill}

\begin{lstlisting}
// Passando argumentos por valor e por referência

struct coord{
	int x;
	int y;
};

void por valor( struct coord );
void por ref( struct coord * );

void main ()
{

	struct coord ponto;

	ponto.x = 2;
	ponto.y = 4;

	printf("Antes de chamar por valor(): x = %d, y = %d\n", ponto.x,ponto.y);

	por_valor(ponto); // chamada por valor
	printf(""nDepois de chamar por valor(): x = %d, y = %d", ponto.x,ponto.y);

	por_ref(&ponto); // chamada por referencia
	printf(""nDepois de chamar por ref(): x = %d, y = %d", ponto.x,ponto.y);
}

void por valor(struct coord ponto)
{
	ponto.x = ponto.y = 0;
}

void por ref(struct coord *ponto)
{
	ponto->x = ponto->y = 0;
}
\end{lstlisting}


A saída será:
\begin{verbatim}
Antes de chamar por valor(): x = 2, y = 4
Depois de chamar por valor(): x = 2, y = 4
Depois de chamar por ref(): x = 0, y = 0
\end{verbatim}


\section{Exercício}

Crie um pequeno banco de dados que armazenará os seguintes dados de um aluno:

\begin{itemize}
	\item código de matrícula
	\item nome
	\item telefone
	\item endereço
\end{itemize}

O programa deverá ter um menu com as seguintes opções:

\begin{itemize}
	\item inserir aluno
	\item imprimir alunos
	\item ordenar alunos
\end{itemize}

Cada aluno inserido será armazenado em um vetor de tamanho \verb|TAM_MAX| e o programa deverá
acusar erro se houver tentativa de inserção de alunos, caso o vetor esteja cheio.

No caso da função de ordenação, esta deverá ser realizada pela ordem alfabética do nome.

\end{document}