Resumo – principais recursos de C/C++

Sintaxe básica da linguagem

Comentários:

Comentário ‘antigo’ (C): abre c /* fecha com */Pode ser aberto em uma linha e fechado em outra.Ex:/* este é um exemplo de comentário que ocupa duas linhas do programa */. . . . . Comentário ‘novo’ (C++): abre c //, não fechaApenas a linha corrente é comentadaEx:. . . . .// este é um comentário de uma linha. . . . .

Regras para formação de Identificadores:

Identificador é qualquer nome criado pelo programador, para nomear: variáveis, funções, estruturas, arquivos, etc.Ex: valor, salário, CalculaSaldo; (123valor -> inválido!)- Quantos caracteres quiser (mas não use mais de 32).- Comece com letra ou sublinhado (_), seguidos de letras, números ou sublinhados.IMPORTANTE: C (e C++) é sensível à caixa (case sensitive): Ex: peso Peso pEso- não podemos definir um identificador com o mesmo nome que uma palavra chave.

Palavras reservadas (ou palavras-chave):

auto static extern int long ifif do default while do . . . . .

Estrutura Básica de um Programa

// primeira função a ser executada<void ou int> main ( ){ // início da função . . . comandos . . .} // fim da função (e da execução do programa)

Exemplo:void main( ){ printf( “Hello, world!” );ou: cin >> “Hello, world!”;}

Obs: Todo comando deve ser encerrado por ;printf é uma função, note um ‘( )’ após o seu nome.

Declaração de variáveis:

Sintaxe:<tipo> nome1, nome2, ... nomen;

ex:int a;int b; ou int a, b;

ex: char letra;float salario;int idade;

Comandos básicos de E/S (entrada e saída):

saída de dados básica (em tela): cout ou printf cout: cout << <lista de strings e/ou expressões>Exemplo:

cout << “Hello, world!”;cout << “Valor da média: ” << media;

printf (“string de formatação”, lista de argumentos );Exemplo:

- printf(“Aula de C.”); // imprime Aula de C.- printf (“o número %d e par!”, 2 );- void main (){

printf( “%s está a %i milhões de milhas \n do sol”, “Vênus” , 67 );

}

Obs: %i e %s são códigos de formatação, para impressão de valores de cada tipo. \n é um código de controlo que causa uma mudança de linha.

entrada de dados básica (em teclado): cin ou scanf cin: cin >> <lista de strings e/ou expressões>Exemplo: int val1, val2; float val3;

cout << “Digite 2 valores inteiros: ”;cin >> val1 << val2;cout << “Agora 1 valor inteiro e 1 real: ”;cin >> val2 >> val3;

scanf (“códigos formatação”, lista de ponteiros );Exemplo:

printf (“Digite 2 valores inteiros: ” );scanf (“%i%i”, &val1, &val2 );printf (“Agora 1 valor inteiro e 1 real: ” );scanf (“%i%f”, &val2, &val3 );

Códigos de formatação (p/ printf e scanf):

%c caracter%i %d inteiro (decimal)%f ponto flutuante (float)%s cadeia de caracteres (string)%e float em notação científica%p ponteiro (endereço de mem.)%o octal%x hexadecimal

Caracteres de controle (printf, scanf e strings):

\n nova linha\t avanço de tabulação (tab)\b retrocesso\a alert (ou ‘beep’) – som do alto-falante\r <“enter”>\“ imprimir aspas\\ imprimir barra

Tipos de dados (para declaração de variáveis, etc):

Tipos de dados básicos, ou primitivos:Tipo bytes sinal

? faixa de valores possíveis

char 1 S -128 a 127int 2 ou 4 S -32.768 a 32.767

float 4 S 3.4e-38 a 3.4e+38double 8 S 1.7e-308 a 1.7e+308

Obs: void X X ‘ausência de tipo’ ou ‘sem valor’

Modificadores (usados p/ construir outros tipos):

Como funciona: long e short -> alteram o tamanho (bytes) unsigned e signed -> alteram a sinalização (se o tipo aceita ou não valors negativos – unsigned: não aceita)long ou long int (4 bytes)unsigned char (0 a 255)unsigned int (0 a 65.535)

Obs: o tipo int terá sempre o tamanho em bytes da palavra da máquina na qual o programa é compilado. Geralmente 16 ou 32 bits.

Inicialização de variáveis:

a combinação de uma declaração de variáveis com o operador de atribuição

void main ( ) { int evento = 5; char corrida = ‘c’; float tempo = 27.25; printf (“ o melhor tempo da eliminatória % c”, corrida); printf (“ \ n do evento %d foi % f”, evento, tempo);}

Controlando a impressão, com printfTamanho de campos:

1

é possível estabelecer o tamanho mínimo para a impressão de um campo:

printf (“os alunos são %2d \ n”, 350); printf (“os alunos são %4d \ n”, 350); printf (“os alunos são %5d \ n”, 350);

Saída: os alunos são 350os alunos são _350os alunos são __350 (onde o _ é um espaço!)

O comando de entrada scanf:sintaxe:

scanf(“expressão de controle”, lista de argumentos)expressão: % ou %* lista: &variável

ex:void main ( ) {

int num;scanf(“%d”, &num);

}

O operador de endereço (&)

Um endereço de memória é a referência (endereço) que o computador usa para identificar e chegar até uma variável. Toda variável ocupa uma área de memória e seu endereço é igual ao endereço do primeiro byte por ela ocupado.Ex:

inteiro 2 bytesfloat 4 byteschar 1 byte

Quando usamos & precedendo o nome uma variável, estamos falando do endereço da mesma na memória.ex:

void main ( ) {int num;

num = 2;printf (“valor = %i, endereço = %p”, num, &num);

}// Saída: valor = 2, endereço = FC08 // em hexa!ex:void main ( ) {

char a ;printf (“Digite um caracter: ” );scanf ( “%c”, &a ); // lê um caracatere do tecladoprintf (“ \n %c = %d em decimal”, a, a);printf (“%o em octal, %x em hexadecimal”, a, a);

}

Funções de entrada/saída de caracteres

A função scanf obriga que a tecla <enter> seja pressionada após a entrada dos dadosA biblioteca de C oferece funções que lêem dados sem esperar <enter>

getche( ): lê um caracter do teclado ecoando-o na tela

getch( ): lê um caracter do teclado sem ecoá-lo na tela

Principais Operadores da Linguagem C

Operadores Relacionais:

Usados para comparações> maior>= maior ou igual< menor<= menor ou igual== igualdade!= diferença

Operadores Aritméticos:

Binários: = + - * / % Unário: - ex:

int a, b;

b = 3; a = b + 2;b = a * b; b = 7 % 2;

obs: Atribuição em ‘C’ é uma expressão, logo:a = 5;

a = b = 4 * a; Nota:

a = 2000; (válido)2000 = a; (inválido)

Operadores de incremento (++) e decremento (--) :

Incrementam / decrementam uma unidade de seu operandomodos distintospré – fixadopós – fixadoex: n++; (usa a variável e depois incrementa) ++n; (usa a variável depois de incrementar)

main( ) { int num = 0; printf (“ %d”, num); printf (“ %d”, num++); printf (“ %d”, num);

} Saída: 0 0 1

Operadores aritméticos de atricuição:

+=, -=, *=, /=, %=atribuir um novo valor à variável dependendo do operador e da expressão a direita

A sintaxe: x op= exp é equivalente a x = (x) op (exp)Ex: expressão o mesmo que:

i += 2; i = i + 2; h -= 3; h = h - 3; t /= 4; t = t / 4; p %= 6; p = p % 6; x *= y + 1; x = x * (y + 1);

Observe que:em C, não existe o tipo de dados “booleano”!Quando precisamos trabalhar com verdadeiro e falso, geralmente usamos valores inteiros (1 = V; 0 = F).Mas, na verdade, p/ o compilador, 0 = falso, e qualquer valor numérico diferente de 0 é considerado verdadeiro.

Blocos de comandos

Podemos agrupar 2 ou mais comandos em um bloco de comandos, colocando-os entre { e }. Esta construção é necessária, por exemplo, para associar mais de um comando a estruturas de decisão (if’s) e laços (for, while, etc.)ex:

void main ( ) { int n, soma; for ( n=1, soma=0; num <= 3; num++ ) { soma += num;

printf (“n = %d soma = %d \n”, num, soma); }}

Estruturas de Controle – Decisão

Permitem que um comando, ou conjutno de comandos, seja executado ou não, dependendo de uma condição a ser testada em tempo de execução.A linguagem C oferece os seguintes tipos de estruturas de decisão: if, if-else, switch, e o operador condicional (?:)

Estrutura de decisão simples: if

Sintaxe:if ( <expressão> )

<comando único>;ou

if( <expressão> ){

comando 1;. . . . comando n;

}

2

ex:void main ( ){

char ch;ch = getche( );if ( ch == ‘p’ )

printf (“Você pressionou a tecla p”);}

Obs: 1 - Os parênteses, ( e ), são obrigatórios.2 - <expressão> pode ser qualquer expressão numérica

(C não possui um tipo lógico/booleano). Apenas o valor 0 será considerado como falso. Qualquer resultado != 0 será considearado verdadeiro.ex:

void main (){

if ( getche( ) == ‘p’ ) {printf (“Você digitou p”);printf (“Pressione outra tecla!”);getche( );

}}

Obs: if’s “aninhados:Se uma estrutura if está dentro de outro if, dizemos que os dois if’s estão aninhados. Os comandos associados ao if mais interno só serão executados se a condição do if mais externo for verdadeira.ex:main ( ) {

char ch;printf (“Digite uma letra entre A e Z:”);ch = getche ( );if ( ch >= ‘A’ )

if (ch < = ‘Z’)printf (“Você acertou!”);

}

Comando IF – ELSE

comando If só executa a instrução caso a condição de teste seja verdadeira, nada fazendo se a expressão for falsacomando else executará um conjunto de instruções se a expressão de teste for falsa

Forma Geral: If (condição) instrução

else instrução

ex.:void main ( ){ if (getche ( ) == ‘p’) printf (“ você digitou p”);

else printf (“ você não digitou p”);

}

Uso de if e if-else de forma “aninhada”;

Forma Geral: If (condição 1) instruçãoelse If (condição 2)

instruçãoelse if (condicao 3) ...

ex.:void main ( ){

int número;scanf (“ % d”, &número);

If (número < 0)printf (“número menor que zero”);

else If (número < 10)printf (“ número >= e < 10”);

else If (número < 100)printf (“número >= 10 e < 100)

else

printf (“número >=100”);}

3

Estruturas de Controle – Repetição ou Iteração

A linguagem C fornece 3 tipos de laços de repetição (iteração): for (para . . . faça . . . ), while (enquanto . . . faça . . .), e do-while (faça . . . enquanto . . .).

for (para . . . faça . . .) O laço for da linguagem C é mais complexo e bem mais flexível e poderoso que os disponíveis em outras linguagens, como Pascal, por exemplo.Sintaxe:for ( <inicialização>; <teste continuidade>; <atualização> )

< comando (ou bloco de comandos) >;ex:for (num = 1; num <= 1000; num++ )

printf (“Numero = %d \n”, num );Obs: O código de inicialização, o de incremento, e a condição de continuidade podem ser expressões bem complexas, contendo inclusive chamadas a funções.Na verdade, podem conter mais de uma expressão, separadas por vírgulas:ex:

/* uso de funções nas expressões do laço */void main ( ) {

char ch; for ( ch = getch ( ); ch != ‘x’; ch = getch( ) )

printf ( “%c”, ch + 1);}

ex:/* Imprime as letras do alfabeto */ void main ( ){

char ch; int i;for ( i = 1, ch = ‘a’; ch <= ‘z’; ch++, i++ )

printf (“%d.a letra = %c \n”, i, ch);}

Obs: Caso não esteja presente nenhuma condição de teste, esta será considerada sempre sempre como se fosse verdadeira (laço “infinito”).Ex:

for ( i=1 ; ; i++ ) // loop infinito (não tem teste!)cout << “\nValor: ” << i ;

}

LAÇOS ANINHADOSQuando um laço está dentro de outro, dizemos que o laço interior está aninhado

void main ( ){

int i, J; for (i = 1; i <= 3; i++) for (J = 1; J <= 2; J++) printf (“%d%d \n”, i, J);

}

while (enquanto . . . faça . . . )Sintaxe:while ( <condição / expressão> )

comando (ou bloco);ex:while ( x <= 10 )

printf (“ %i”, x ); ouwhile ( x <= 10 ) {

printf (“ %i”, x );}Funcionamento: comando só é executado se “expressão de teste” for verdadeira (!=0). A expressão é avaliada antes da primeira iteração, e após cada após cada uma delas, até que se torne falsa (= 0).

ex: while ( x <= 10 ) ou while ( x <= 10 ) { printf (“ %i”, x ); printf (“ %i”, x );

}

do-while (faça . . . enquanto . . .)Sintaxe:do { <comandos> } while ( <expressão de teste> );ex:

erros = 0;do {

printf (“Digite uma letra:”);erros += 1;

} while ( (ch = getch ( ) ) != ‘t’ );Funcionamento: Executa os comandos internos ao menos a primeira vez e, a partir daí, enquanto for verdadeira a condição. Repare que é similar aolaço while, a diferença está no momento em que a condição é avaliada.

Estruturas de Controle – Desvios

break

O comando break causa a saída imediata de um laço. Pode ser usado em qualquer uma das estruturas de laço do C, e na estrutura switch. Caso esteja dentro de um laço interno em 2 ou mais laços aninhados, causará apenas a saída deste laço mais interno (o mais próximo que contém o comando).ex:main ( ) {

int num;while (1) {

printf ( “\n Digite um número natural: ”);scanf (“%d”, &num);if ( num < 0 ) break;printf (“ 2 * %d = %d”, num, 2 * num);

}}

continue

O comando continue pode ser usado dentro de um laço e, quando executado, força uma nova e imediata avaliação da condição do laço - ignorando todos os demais comandos que estiverem abaixo (até o final do laço).ex:main ( ) {

int n;n = 1;while ( n != -100 ) {

printf(“Digite um num. natural (-100 termina): ”);scanf (“%d”, &n);if ( n < 0 ) continue;printf (“ 2 * %d = %d”, n, 2 * n );

}}

No caso de while e do-while, o comando continue fará com que o controle vá direto para o teste condicional. No caso de um laço for, primeiramente será executada a expressão de incremento, depois será feito o teste de continuidade do laço.Obs: Trata-se de um comando que deve ser usado com cerimônia, pois fere alguns princípios da programação estruturada e pode dificultar a manutenção de programas.

OPERADORES LÓGICOS&& (e), II (ou), ! (not)

ex:(1 II 2)(x && y)(a > 10) && (x < 10)! (x > 0)

(10 <= a) && (a <= 100)

Cuidado: (10 <= a <= 100) == ( (10 <= a) <= 100 )

EXEMPLOS:If (10 < a) && (a < 100) / * 10 < a < 100 * /If (10 < a) II (a == -1)

O comando de seleção (switch):

Forma de substituir o comando If - else ao se executar vários testesSimilar ao If - else com maior flexibilidade e formato limpo

4

Sintaxe:switch ( <expressão> ) {

case constante 1:<comandos . . . > // opcionalbreak; // opcional

case constante 2:<comandos . . . >break;

[ default:<comandos> ]

}

==> Funções em C

Em linguagens de programação, de modo geral, há 2 tipos de subrotinas: procedimentos e funções. Funções são subrotinas que, ao final de sua execução, retornam algum valor (simples ou composto) para a rotina que chamou-a (que, por sua vez, pode ser o programa principal ou alguma outra subrotina). Procedimentos são subrotinas que simplesmente executam uma série de comandos e não retornam nenhum valor.Obs: Em C não há o conceito de procedimento, apenas de funções (ou seja, toda subrotina, a princípio, retorna algum valor). Declaração de funções - sintaxe:<tipo retorno> <nome função> ( [<lista de parâmetros>] ){ [ declaração de variáveis locais ] < comandos . . . > [ return < expressão de tipo retorno > ; ]}Obs: <lista de parâmetros> = <declaração de var1.>, <declaração de var2.>, etc.ex:float media ( int a, int b ) {

float tmp; tmp = ( a + b ) / 2.0 ; return ( tmp ); // ou return tmp ;}// Exemplos de chamadas e uso da função:void main ( ){

int v1, v2; float m;v1 = 10; v2 = 7;m = media( v1, v2 ); // chamada à funçãoprintf (“Media de %i e %i = %f ”, v1, v2, m );

// ou printf (“Media de %i e %i = %f ”, media(v1,v2) );// outras chamadas possíveis:m = media( val1 – 3 , 5 );m = media( 5+4 , 7 );

}

desenha ( ); printf (“ usando funções”); desenha ( );}void desenha( )

{ int i; for (i = 0; i < = 10; i++)

printf (“-”);}

ex:int fatorial (int n){ int i, resultado = 1;

for ( i = 1; i <= n; i ++)resultado *= i;

return resultado;}

Main ( ){ printf (“ o fatorial de 4 = %d”, fatorial(4) );

printf (“ o fatorial de 3 = %d”, fatorial(3) );}

VARIÁVEIS LOCAIS

Variáveis declaradas dentro de uma função são denominadas locais e somente podem ser usadas dentro do próprio blocoSão criadas apenas na entrada do bloco e destruídas na saída (automáticas)Ex:

void desenha ( ){ int i, j; . . . . . .}

VARIÁVEL GLOBAL

Variável que é declarada externamente podendo ser acessada por qualquer funçãoEx:

int i;

void desenha ( ){ int j; i = 0; . . . }

void calcula ( ){ int m; i = 5; . . . }

O COMANDO RETURN

Causa a atribuição da expressão a função,Forçando o retorno imediato ao ponto de chamada da funçãoEx.:

char minúsculo ( ){ char ch;

ch = getche( ); If ( (ch >= ‘A’) && (ch <= ‘Z’)) return (ch + ‘a’ - ‘A’); else return (ch);}

Passando dados para funções

Passagem de parâmetro por valor - uma cópia do argumento é passada para a funçãoparâmetro se comporta como uma variável localEx:void minúsculo (char ch){ if ( ( ch >= ‘A’) (ch <= ‘Z’) ) return (ch + ‘a’-, ‘A’); else return (ch);}

void main ( ) { printf (“ %c”, minúsculo (‘A’) );}

PASSANDO VÁRIOS ARGUMENTOS

5

Frequentemente uma função necessita de mais de uma informação para produzir um resultadoPodemos passar para a função mais de um argumento

Ex 1:float área_retângulo (float largura, float altura){ return (largura * altura);}

==> Arranjos (‘arrays’): vetores e matrizes:

Estrutura de dados usado para representar uma coleção (agregado) de valores de um mesmo tipo de dados (estrutura homogênea).- Caso unidimensional: chamado de VETOR- Casos 2, 3 e N-dimensional: chamados de MATRIZESInformalmente:“arranjo é uma série de variáveis do mesmo tipo referenciadas por um único nome”cada variável é diferenciada por um índiceEx:

int nota [ 4 ];

Vetor de inteiros (nota [ 0 ], nota [ 1 ], nota [ 2 ], nota[ 3 ])

Obs: tamanho n índice 0 a (n - 1)

Inicializando Arranjos

Dado um arranjo podemos inicializá-lo:int notas [ 5 ] = { 0, 0, 0, 0, 0 } notas [0] = 0; notas [1] = 0 ... notas [4] = 0;for ( i = 0 ; i < 5; i++) scanf (“%d”, &notas [ i ] );

Trabalhando com um número desconhecido de elementos

em ‘C’ não existe declaração de arranjo dinâmicotamanho de um arranjo tem que ser determinado em tempo de compilaçãoSolução: declarar um arranjo que suporte um número máximo de elementos

#define TAM 50 // diretiva de compilação define

void main( ){

int quantidade, media = 0;float notas[TAM]; // define o tamanho indiretament

// quantidade deve ser <= TAMprintf ( “quantas notas devo ler ?”);scanf(“%d”, &quantidade);

for ( i = 0; i < quantidade; i++) {printf (“Informe a nota %i:”, i+1);scanf(“%f”, &notas[ i ] );

}: : :

for ( i = 0; i < quantidade; i++) media += notas [ i ] ;: : :

}

Verificando limites

C não realiza verificação de limites em arranjosnada impede o acesso além do fim do arranjo

RESULTADOS IMPREVISÍVEISfaça sempre que necessário a verificação dos limitesEx: #define TAM 100

int notas [ TAM ], quantidade; : : :do { printf ( “quantas notas devo ler ?”);

scanf(“%d”, &quantidade);} while ( quantidade > TAM );

Dimensionando um arranjo

é possível inicializar um arranjo sem que se defina a sua dimensãoindica-se os inicializadores, o compilador fixará a dimensão do arranjo Ex:

int notas[ ] = { 0, 0, 1, 3 }=

int notas[ 4 ] = { 0, 0, 1, 3 }

Obs: Você não pode inicializar o i-ésimo elemento seminicializar todos os anteriores

Arranjo Multidimensional

em ‘C’ podemos definir um vetor em que cada posição temos um outro vetor (matriz). Note: int matéria [ 4 ] [ 40 ];interpretação:temos 4 matérias, cada uma com 40 alunosAgora temos:

int i, j, matéria [ 4 ] [ 40 ]; for ( i = 0 ; i < 4; i++ ) {

printf (“entre com as notas da matéria %d”, i+1);

for ( j = 0; j < 40; j++) {printf (“entre com a nota do aluno %d”, j+1);scanf (“%d”, &materia [ i ] [ j ]);

}}

Inicializando Matrizes

dado:#define linhas 3#define colunas 4

int nota [ linhas ] [ colunas ];

podemos:int nota [ 3 ] [ 4 ] = { {0, 0, 0, 0}, ..., {0, 0, 0, 0 } }notas [ 0 ][ 0 ] = 0; ... nota [ 0 ] [ 3 ] = 0;

: : : nota [ 2 ] [ 0 ] = 0; ... nota [ 2 ] [ 3 ] = 0;//usar laços for

for ( i = 0; i < linhas; i++ ) for ( j = 0; j < colunas; j++ ) nota [ i ] [ j ] = 0;

Constantes de Cadeia de Caracteres

Uma constante string é uma sequência de caracter delimitada por aspas duplas.Ex:

printf ( “Isto e um teste” );

printf ( “%s”, “Isto e um teste” ); Cadeias de caracteres (“STRINGs”):

A linguagem C não possui um “tipo”, ou mecanismo de dados específico para armazenar cadeias de caracteres! Para isso, utiliza-se vetores de char.Ex: char nome[30]; // vetor de 30 char

Logo, uma “string” em C é simplesmente um vetor do tipo char, terminada pelo caractere null (código 0, da tablea ASCII, representado em programas C pela sequencia ‘\0’).

Cada caractere de um string pode ser acessado individualmente:Ex:

char string[10] = “exemplo” ;char string[10] = {“exemplo”} ;char string[10] = { ‘e’, ‘x’, ‘e’, ‘m’, ‘p’, ‘l’, ‘o’, ‘\0’ };

Obs: vetor de tamanho n = string de tamanho ( n - 1 )

6

Lendo Strings

- scanf lê o string até que um branco seja encontrado

- gets lê caracteres até encontrar ‘\n’ substitui ‘\n’ por ‘\0’

Imprimindo Strings:printf ou puts

complemento de gets:Ex:

{ printf ( “Digite seu nome: “ );gets ( &nome[ 0 ] );puts ( “Bom dia ” ); puts ( nome );

}Lembre-se:Obs: Sempre que uma função espera receber um apontador, podemos passar: o endereço da primeira posição do vetor / matriz. o próprio ‘nome’ do vetor / matriz. (desde que o tipo seja o mesmo)ex: char nome[40];

gets( &nome[0] ); equivale a gets( nome );puts( &nome[0] ); equivale a puts( nome );

Principais funções de manipulação de cadeias:

strlen – string length: retorna o comprimento efetivo da string (não conta o ‘\0’). ex: tam = strlen( string1 );

strcpy – (string copy) – copia o conteúdo de uma string (variável ou constante) em outra (que deve ser uma var.) ex: strcpy( str1, str2 ); ou strcpy( str1, “Hello");

strcmp – string compare: compara 2 strings (variáveis ou constantes). ex: strcmp( str1, “Fim” );ex: strcmp( str1, str2 );// compara str1 e str1 e retorna um valor:

< 0 , se str1 < str2= 0 , se str1 = str2> 0 , se str1 > str2

Obs: a comparação é por ordem alfabética (lexicográfica).

strcat – string concat: concatena str2 ao final de str1 ex: strcat( str1, str2 ); ou strcat( str1, “fim” );Obs: A soma dos tam. de str1 e str2 deve caber em str1.

Structs (estruturas, ou registros em C):

Struct é o nome dado aos registros em C. Registro (record, em Pascal), é um mecanismo de estruturação de dados de agregação e heterogêneo (campos de diferentes tipos).Declaração:

struct <nome struct> - este nome é opcional!{ <tipo1> <nome campo 1>; . . . . . . . . . <tipo n> <nome campo n>;};

Exemplo:struct ponto {

float x;float y; // poderia ser: float x, y;

} p1, p2, origem;// declara 2 variáveis no formato struct ponto

--> Usando as variáveis struct declaradas:p1.x = 2.0; p1.y = 1.5;p2.x = 3.0; p2.y = -1.0;

origem = 0.0; origem = 0.0;Obs: pode-se copiar uma struct em outra:

Ex: p2 = p1; // copia cada campo de p1 em p2(desde que possuam o mesmo formato de campos).

Outros exemplos:struct func { int matric; char nome[30]; } f1, f2; // f1 e f2 são 2 var. com o formato func.ou struct func f3, f4;

Criando vetores de structs:Exemplo:

struct ponto3D {float x, y, z; // ponto no espaço 3D

};// declara um vetor de até 50 pontos 3Dstruct ponto3D Poliedro[50];Usando:

Poliedro[0].x = 0.0;Poliedro[0].x = 0.0;Poliedro[0].x = 0.0;Poliedro[1].x = 1.0;Poliedro[1].x = 2.0;Poliedro[1].x = 0.0;. . . . . . . .

7