Linguagem C, Notas de estudo de Informática

Baixe Linguagem C e outras Notas de estudo em PDF para Informática, somente na Docsity!

• 1. INTRODUÇÃO SUMÁRIO
  • 1.1. A Origem da Linguagem C...............................................................
  • 1.2. O Ambiente Turbo C
  • 1.3. A Estrutura Básica dos Programas..................................................
  • 1.4. Tipos de Dados
    • 1.4.1. Tipos de Dados Modificados
  • 1.5. Entrada e Saída de Dados Formatada
    • 1.5.1. Formatação de Campos de Exibição......................................
  • 1.6. Operadores Aritméticos....................................................................
• 2. COMANDOS DE DECISÃO
  • 2.1. Expressões Lógicas...........................................................................
  • 2.2. Decisão Simples...............................................................................
    • 2.2.1. Operador condicional.............................................................
    • 2.2.2. Condicionais Aninhados e Encadeados
  • 2.3. Decisão Múltipla
• 3. COMANDOS DE REPETIÇÃO
  • 3.1. Expressões Compactas
    • 3.1.1. Operadores Aritméticos de Atribuição
    • 3.1.2. Incremento e Decremento
  • 3.2. Repetição com Contador...................................................................
  • 3.3. Repetição com Precondição
    • 3.3.1. Deixando rastros na Tela
  • 3.4. Repetição com Poscondição
  • 3.5. Interrompendo uma Repetição
• 4. MACROS E FUNÇÕES
  • 4.1. Preprocessamento
    • 4.1.1. A diretiva #define
    • 4.1.2. A diretiva #include................................................................
  • 4.2. Definição e Uso de Funções ii SUMÁRIO
    • 4.2.1. Funções que não Devolvem Resposta....................................
    • 4.2.2. Funções que Devolvem Resposta...........................................
  • 4.3. Classes de Armazenamento
  • 4.4. Recursividade
    • 4.4.1. Funções Recursivas
    • 4.4.2. Procedimentos Recursivos.....................................................
• 5. VETORES, STRINGS E MATRIZES
  • 5.1. Vetores
    • 5.1.1. Inicialização de Vetores.........................................................
    • 5.1.2. Parâmetros do Tipo Vetor
  • 5.2. Strings
    • 5.2.1. Inicialização de Strings
    • 5.2.2. Manipulação de Strings
  • 5.3. Matrizes
    • 5.3.1. Inicialização de Matrizes.......................................................
    • 5.3.2. Passando Matrizes a Funções
  • 5.4. Métodos de Busca
    • 5.4.1. Busca Linear
    • 5.4.2. Busca Binária
  • 5.5. Métodos de Ordenação
    • 5.5.1. Ordenação por Trocas............................................................
    • 5.5.2. Ordenação por Seleção
    • 5.5.3. Ordenação por Inserção.........................................................
• 6. ESTRUTURAS E UNIÕES.........................................................................
  • 6.1. Estruturas
    • 6.1.1. Inicialização e Aninhamento
    • 6.1.2. Vetores de Estruturas
    • 6.1.3. Ordenação e Busca em Tabelas.............................................
  • 6.2. Uniões...............................................................................................
    • 6.2.1. Uniões Etiquetadas
  • 6.3. Campos de Bits.................................................................................
    • 6.3.1. Acessando um Dispositivo de Hardware
    • 6.3.2. Economizando Espaço de Armazenamento iii
• 7. PONTEIROS............................................................................................
  • 7.1. Definição e Uso.................................................................................
    • 7.1.1. Passagem por Referência
    • 7.1.2. Ponteiros para Ponteiros.......................................................
    • 7.1.3. Aritmética de ponteiros.........................................................
  • 7.2. Ponteiros e Vetores...........................................................................
    • 7.2.1. Vetores de Strings
    • 7.2.2. Argumentos da Linha de Comando.......................................
  • 7.3. Ponteiros e Funções
    • 7.3.1. Funções que Devolvem Ponteiros..........................................
    • 7.3.2. Ponteiros para Funções
  • 7.4. Ponteiros e Estruturas
    • 7.4.1. Alocação Dinâmica de Memória
    • 7.4.2. Listas Encadeadas.................................................................
    • 7.4.3. Tratamento Recursivo de Listas
• 8. ARQUIVOS..............................................................................................
  • 8.1. Ponteiros de Arquivo
  • 8.2. Arquivos-Padrão...............................................................................
    • 8.2.1. Redirecionamento de E/S padrão
  • 8.3. Operações Básicas
    • 8.3.1. Abertura de Arquivo..............................................................
    • 8.3.2. Fechamento de Arquivo.........................................................
    • 8.3.3. Verificação de Final de Arquivo
  • 8.4. Modo Texto versus Modo Binário
    • 8.4.1. E/S caracter...........................................................................
    • 8.4.2. E/S Formatada
    • 8.4.3. E/S Binária............................................................................
• TABELA ASCII
• BIBLIOGRAFIA

1. INTRODUÇÃO

C é geralmente citada como uma linguagem que reúne características tais como expressividade, portabilidade e eficiência. Embora seja uma lingua- gem de uso geral, C é especialmente indicada para o desenvolvimento de software básico. Nesse capítulo apresentamos a estrutura básica dos programas em C, funções de E/S, tipos de dados e operadores.

1.1. A ORIGEM DA LINGUAGEM C

A linguagem C foi desenvolvida em 1972 , nos Laboratórios Bell, por Dennis Ritchie e implementada pela primeira vez num computador DEC PDP- 11 que usava o sistema operacional UNIX. Ela é o resultado da evolução de uma lin- guagem de programação mais antiga, denominada BCPL, desenvolvida por Martin Richards. Tendo sido desenvolvida por programadores, e para pro- gramadores, C tornou-se rapidamente uma ferramenta de programação bastante difundida entre os profissionais da área.

A popularidade da linguagem C deve-se, principalmente, ao fato dela ser uma linguagem flexível, portátil e eficiente. Sua flexibilidade lhe permite ser utilizada no desenvolvimento de diversos tipos de aplicação, desde simples jogos eletrônicos até poderosos controladores de satélites. Graças à sua por- tabilidade, os programas codificados em C podem ser executados em diver- sas plataformas, praticamente, sem nenhuma alteração. E, finalmente, sua eficiência proporciona alta velocidade de execução e economia de memória.

1.2. O AMBIENTE TURBO C

O Borland Turbo C^ é o ambiente no qual desenvolveremos nossos progra- mas. Ele é composto por um editor de textos, um compilador e um linkeditor que, juntos, nos permitem criar programas executáveis a partir de textos escritos em C. Os recursos oferecidos nesse ambiente poderão ser explorados à medida que estivermos mais familiarizados com a linguagem C. Para começar, é suficiente saber que:

• F2 salva o código-fonte do programa num arquivo com extensão .c,
• Ctrl+F9 compila, linkedita (gera arquivo .exe) e executa seu programa,
• Alt+X finaliza a execução do Turbo C.

2 1. INTRODUÇÃO

Figura 1.1 − A tela do ambiente integrado Turbo C

1.3. A ESTRUTURA BÁSICA DOS PROGRAMAS

Um programa C consiste de funções sendo que, necessariamente, uma delas deve ser denominada main. Essa é a função principal, por onde inicia-se a execução do programa, e sem ela o programa não pode ser executado.

Exemplo 1.1. Uma pessoa é obesa se seu índice de massa corpórea é supe- rior a 30 , tal índice é a razão entre seu peso e o quadrado da sua altura.

/* OBESO.C – informa se uma pessoa está ou não obesa */

#include <stdio.h> #include <conio.h> #include <math.h>

#define LIMITE 30 main() { float peso, altura, imc; clrscr(); printf(“\n Qual o seu peso e altura? ”); scanf(“%f %f”, &peso, &altura); imc = peso/pow(altura,2); printf(“\n Seu i.m.c. é %.1f”, imc); if( imc <= LIMITE ) printf(“\n Você não está obeso!”); else printf(“\n Você está obeso!”); getch(); }

Como esse programa é muito simples, ele consiste de uma única função: main. Essa função solicita os dados da pessoa, calcula o seu índice de massa corpórea e informa se ela está obesa ou não.

4 1. INTRODUÇÃO

1.4. TIPOS DE DADOS

Programas servem essencialmente para manipular dados: ao executarmos um programa, fornecemo-lhes dados e esperamos que ele faça alguma coisa com eles. Os dados podem se apresentar em duas formas distintas: como constantes ou variáveis. No programa do exemplo 1. 1 , o número 30 é um dado constante, enquanto o peso e a altura da pessoa são dados variáveis, isto é, são dados cujos valores variam de uma execução para outra. Além da distinção entre as formas em que os dados podem se apresentar, existe também uma distinção entre os tipos de dados que o computador é capaz de manipular; como, por exemplo, números, letras, palavras, etc. A linguagem C oferece cinco tipos de dados básicos:

Tipo Espaço Escala char 1 byte − 128 a + 127 int 2 bytes − 32768 a + 32767 float 4 bytes 3.4e− 38 a 3.4e+ 38 double 8 bytes 1.7e− 308 a 1.7e+ 308 void nenhum nenhuma

Em C não existe muita distinção entre a representação gráfica de um carac- ter e o seu código ASCII. Como sabemos, o computador somente é capaz de manipular números. Então, quando atribuímos um caracter a uma variável, estamos na verdade armazenando o seu código ASCII (que na tabela padrão varia de 0 a 127 ). É por este motivo que a escala de valores do tipo char varia no intervalo de – 128 a + 127. Para representar um caracter constante, basta escrevê-lo entre apóstrofos como, por exemplo, ‘A’. As variáveis do tipo int podem armazenar números maiores que as variáveis do tipo char, mas também gastam mais espaço de memória. Valores fracio- nários podem ser armazenados em variáveis do tipo float ou double, confor- me a necessidade. Já o tipo void é um tipo especial, que tem aplicação mais avançada, e seu uso será visto mais adiante. A declaração de uma variável consiste em um tipo e um identificador. O tipo determina o espaço de memória que deverá ser alocado para ela e o identifi- cador permitirá que ela seja referenciada no restante do programa.

• Todo^ identificador^ deve^ iniciar-se^ com^ letra^ (maiúscula^ ou^ minúscula)^ e^ ser composto exclusivamente por letras, dígitos e sublinhas.

1. INTRODUÇÃO 5

Exemplo 1.2. Declaração de variáveis. char tecla, opcao; int x, y, z; float comissao, desconto, salario;

1.4.1. TIPOS DE DADOS MODIFICADOS Além dos tipos básicos, C oferece também alguns tipos de dados modificados:

Tipo Espaço Escala unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a 65535 long int 4 bytes −2 147 483 648 a +2 147 483 647

O bit mais à esquerda em uma variável do tipo char ou int, denominado bit de sinal, é normalmente utilizado pelo computador para distinguir entre va- lores positivos e negativos: se esse bit é zero, então o valor é positivo; caso contrário, ele é negativo. Usando o modificador unsigned, estamos informan- do ao compilador que somente valores sem sinal serão usados e que, portan- to, não é necessário ter um bit de sinal. Com isso, podemos usar esse bit para representar valores e, conseqüentemente, a escala de valores dobra. Há também o modificador signed, que indica que os valores devem ser sinaliza- dos; mas, como este é o caso normal, raramente ele é utilizado. Se a palavra unsigned (ou signed) é usada isoladamente, o compilador assume o tipo int.

Figura 1.2 − O bit de sinal numa variável do tipo char

O modificador long faz com que o espaço de memória reservado para uma variável do tipo int seja duplicado e, conseqüentemente, aumenta a capaci- dade de armazenamento da variável. Já o modificador short, em algumas máquinas, faz com que esse espaço caia para a metade.

Exemplo 1.3. Algumas variáveis de tipos modificados. unsigned char contador; unsigned int a, b, c; long int tam_arquivo;

• Os modificadores podem prefixar apenas os tipos char e int. A única exceção feita é long float, que equivale ao tipo double e por isso é raramente utilizado

1. INTRODUÇÃO 7

Os principais caracteres de controle utilizados com a função printf( ) são:

Caracter de controle Efeito \a soa o alarme do microcomputador \b (^) o cursor retrocede uma coluna \f (^) alimenta página na impressora \n o cursor avança para uma nova linha \r (^) o cursor retrocede para a primeira coluna da linha \t (^) o cursor avança para próxima marca de tabulação \” exibe uma única aspa \’ (^) exibe um único apóstrofo \ (^) exibe uma única barra invertida

Desses caracteres, o mais usado é ‘\n’. Através dele podemos indicar quando uma nova linha deve ser utilizada ao se exibir alguma informação na tela.

Exemplo 1.5. Exibindo dados com a função printf().

#include <stdio.h> #define PI 3.

main() { double raio, perim; getch(); printf("\n Qual a medida do raio?"); scanf("%lf", &raio); perim = 2PIraio; printf("\n O perímetro da circunferência é %lf", perim); getch(); }

1.5.1. FORMATAÇÃO DE CAMPOS PARA EXIBIÇÃO

A função printf() permite que os campos de exibição sejam formatados. As formatações mais usadas são o preenchimento com zeros à esquerda, para inteiros, e a especificação do número de casas decimais, para reais.

Exemplo 1.6. Formatação de campos com printf().

int a = 678; float b = 12.3456; ... printf("\n|%5d|",a); printf("\n|%06d|",a); printf("\n|%7.3d|",b); printf("\n|%7.2d|",b); ...

8 1. INTRODUÇÃO

A saída produzida pela execução desse trecho de programa é:

| 678| |000678| | 12.346| | 12.34|

Note que valores reais são arredondados apenas quando a primeira casa decimal desprezada é igual ou superior a 5.

1.6. OPERADORES ARITMÉTICOS

C oferece operadores para as quatro operações aritméticas e também um operador para calcular o resto da divisão entre dois números inteiros.

Operador Resultado

• soma de dois números quaisquer − diferença entre dois números quaisquer ∗ produto de dois números quaisquer / quociente da divisão de dois números % resto da divisão de dois número inteiros

Destes operadores, apenas dois merecem atenção especial. Os demais funcio- nam conforme as regras usuais estabelecidas na matemática básica.

• Divisão: o operador de divisão fornece resultado inteiro apenas quando ambos os operandos são inteiros. Por exemplo, 7 / 2 ⇒ 3 e 7.0 / 2 ⇒ 3.5.
• Resto: o operador de resto somente pode ser utilizado com operandos inteiros. Por exemplo, 7 % 2 ⇒ 1 e 7.0 % 2 ⇒ erro.

Exercício 1.3. Dadas as duas notas de um aluno, informe a sua média final.

Exercício 1.4. Dados uma distância e o total de litros de combustível gasto por um automóvel para percorrê-la, informe o consumo médio.

Exercício 1.5. Dado um caracter, informe o seu código ASCII em octal, deci- mal e hexadecimal

Exercício 1.6. Dada um temperatura em graus Fahrenheit, informe o valor correspondente em graus Celsius. [Dica: C = (F – 32) ∗ (5 / 9)].

Exercício 1.7. Dadas as medidas dos catetos de um triângulo retângulo, informe a medida da hipotenusa. [Dica: para calcular a raiz quadrada use a função sqrt(), definida no arquivo math.h].

10 2. COMANDOS DE DECISÃO

Operador lógico Resultado ! x verdade se e só se x for falso x && y verdade se e só se x e y forem verdade x || y verdade se e só se x ou y for verdade

Numa expressão contendo operadores aritméticos, relacionais e lógicos, a avaliação é efetuada na seguinte ordem:

¬ primeiro avaliam-se todos os operadores aritméticos; em seguida, avaliam-se os operadores relacionais; ® só então, avaliam-se os operadores lógicos.

Exercício 2.1. Qual a saída produzida pela instrução a seguir?

printf("%d %d %d %d", !3, !0, 3+'a'>'b'+2 && !'b', 1 || !2 && 3);

2.2. DECISÃO SIMPLES

A estrutura condicional ou de decisão simples serve para escolher um entre dois comandos alternativos, conforme ilustrado na figura 1.3. Em C, a estru- tura condicional é codificada da seguinte forma:

if( condição ) comando 1 ; else comando 2 ;

e funciona, conforme ilustrado na figura 1.3, da seguinte maneira:

¬ avalia a condição, que deve ser uma expressão lógica; se a condição for verdadeira, executa apenas o comando 1 ; ® senão, executa apenas o comando 2.

Figura 1.3 − A estrutura de decisão simples

F condição

comando 1

V

...

comando 2

...

2. COMANDOS DE DECISÃO 11

Exemplo 2.2. O uso de decisão simples.

#include <stdio.h>

main() { float a, b, m; printf(“\n Informe as duas notas obtidas: ”); scanf(“%f %f”, &a, &b); m = (a+b)/2; if( m >= 7.0 ) printf(“\n Aprovado”); else printf(“\n Reprovado”); }

O programa solicita as duas notas obtidas pelo aluno, calcula sua média e, em função desse valor, decide se o aluno está ou não aprovado.

Pode ser que um dos comandos alternativos, ou ambos, seja composto por mais de uma instrução. Por exemplo, se o programa anterior tivesse que exibir Aprovado em azul e Reprovado em vermelho, então cada alternativa seria composta por duas instruções: uma para selecionar a cor e a outra para exibir a situação do aluno. Nesse caso, teríamos que usar blocos, agrupando as instruções em cada alternativa dentro de um par de chaves.

Exemplo 2.3. O uso de blocos de instruções.

#include <stdio.h> #include <conio.h>

main() { float a, b, m; clrscr(); printf(“\n Informe as duas notas obtidas: ”); scanf(“%f %f”, &a, &b); m = (a+b)/2; if( m >= 7.0 ) { textcolor(BLUE); cprintf(“\n Aprovado”); } else { textcolor(RED); cprintf(“\n Reprovado”); } getch(); }

A função textcolor() seleciona a cor do texto e a função cprintf(), cuja sintaxe é idêntica à da printf( ), exibe o texto na cor selecionada. Essas funções, as- sim como as constantes BLUE e RED, estão declaradas no arquivo conio.h.

2. COMANDOS DE DECISÃO 13

2.2.1. OPERADOR CONDICIONAL

C oferece também um operador que proporciona uma forma mais compacta de se representar decisões simples. O operador condicional, cuja sintaxe é condição? expressão 1 : expressão 2 , funciona da seguinte maneira: ¬ avalia a condição; se ela for verdadeira, o resultado final é o valor da expressão 1 ; ® senão, o resultado final é o valor da expressão 2.

Exemplo 2.5. O uso do operador condicional. ... abs = n>0? n : -n; ... A instrução acima atribui à variável abs o valor absoluto da variável n. A expressão n> 0 é avaliada: se for verdadeira, abs recebe o próprio valor de n; caso contrário, abs recebe o valor de n com o sinal invertido.

Exemplo 2.6. O uso do operador condicional como argumento de função. #include <stdio.h> main() { int x, y; printf("\nInforme dois valores: "); scanf("%d %d", &x, &y); printf("\n Máximo = %d", x>y? x : y); } A instrução acima seleciona e exibe o máximo entre dois valores x e y. Note que não seria possível usar um if-else como argumento na função printf().

Exercício 2.5. Seja e uma variável contendo o número de erros detectados num certo processo. Codifique uma instrução capaz de exibir saídas como: 1 erro detectado. 5 erros detectados. Exercício 2.6. Codifique uma instrução para exibir valores lógicos como true e false. Para o valor 0 deve aparecer false e para qualquer outro, true.

Uma vantagem no uso do operador condicional é que, sendo um operador, podemos utilizá-lo em qualquer contexto em que uma expressão é permitida.

14 2. COMANDOS DE DECISÃO

2.2.2. CONDICIONAIS ANINHADOS E ENCADEADOS

Como vimos, a estrutura condicional serve para selecionar e executar um entre dois comandos alternativos. É possível que, algumas vezes, um destes comandos alternativos (ou ambos) sejam também condicionais. Nesse caso, dizemos que o primeiro condicional é o principal e o outro está aninhado ou encadeado, conforme indicado a seguir:

if( condição ) /* principal / if ... / aninhado / else if ... / encadeado */

Para exemplificar o uso desses condicionais, vamos considerar o seguinte problema: “Dados três números verificar se eles podem representar as medidas dos lados de um triângulo e, se puderem, classificar o triângulo em equilátero, isósceles ou escaleno”.

Para codificar o programa, devemos lembrar das seguintes definições:

• Para que três números representem os lados de um triângulo é neces- sário que cada um deles seja menor que a soma dos outros dois.
• Um triângulo é equilátero se tem os três lados iguais, isósceles se tem apenas dois lados iguais e escaleno se tem todos os lados distintos.

Exemplo 2.7. O uso de condicionais aninhados e encadeados.

#include <stdio.h> #include <conio.h>

main() { float a, b, c; clrscr(); printf(“\nInforme três números: “); scanf(“%f %f %f”, &a, &b, &c); if( a<b+c && b<a+c && c<a+b ) { printf(“\nÉ um triângulo: ”); if( a==b && b==c ) printf(“equilátero”); else if( a==b || a==c || b==c ) printf(“isósceles”); else printf(“escaleno”); } else printf(“\nNão é um triângulo”); getch(); }