Introdução a Linguagem C

Introdução a Linguagem de Programação C Fabiano Russo [email_address]

Breve Histórico Em 1973 Dennis Ritchie reescreveu o sistema operacional UNIX em uma linguagem de alto nível (Ling. C). Surgem diversas implementações utilizando C, porém os códigos gerados eram incompatíveis. ANSI (American National Standard Institute), em 1983 padronizou a ling. C.

C comparado a outras linguagens Devemos entender Nível Alto como sendo a capacidade da linguagem em compreender instruções escritas em “ dialetos ” próximos do inglês (Ada e Pascal, por exemplo) e Nível Baixo para aquelas linguagens que se aproximam do assembly , que é a linguagem própria da máquina , compostas por instruções binárias e outras incompreensíveis para o ser humano não treinado para este propósito. Infelizmente, quanto mais clara uma linguagem for para o humano (simplicidade >) mais obscura o será para a máquina (velocidade <).

C comparado a outras linguagens Nível Baixo Nível Médio Nível Alto Velocidade Clareza Assembler C COBOL Basic Pascal Ada Modula -2

Aplicações escritas em C Sistema Operacional: UNIX Planilhas: 1,2,3 e Excel Banco de Dados: dBase III, IV e Access ( gerenciador de base de dados). Aplicações Gráficas: Efeitos Especiais de filmes como Star Trek e Star War.

Características da Linguagem C Portabilidade entre máquinas e sistemas operacionais. Alia características de linguagens de alto e baixo nível (liberdade ao programador). Programas Estruturados. Total interação com o Sistema Operacional. Código compacto e rápido, quando comparado ao código de outras linguagem de complexidade análoga.

Características da Linguagem C C é uma linguagem compilada: lê todo o código fonte e gera o código objeto (ling. de máquina) uma única vez. Linguagens Interpretadas: lê o código fonte, traduz e executa cada vez que o programa for executado.

Detalhes Importantes Sempre que o código fonte for alterado ele deve ser novamente compilado. C é “case senitive” Deve-se listar antecipadamente todas a as variáveis utilizadas no programa.

Palavras reservadas São palavras que têm um significado especial para a linguagem. auto, break, case, if, for, while, begin, end, continue, return, const,.... C entende tais palavras apenas em letras minúsculas

Bibliotecas Conjunto de funções para realizar tarefas específicas. Biblioteca padrão C - ANSI - funções básicas. As primeiras linhas do programa indicam as bibliotecas utilizadas #include “minha_biblioteca.h” ou #include <minha_biblioteca.h>

Estrutura de um programa C /* Primeiro Programa em C */ #include <stdio.h> main() { printf(“Meu primeiro programa em C\n”); }

Estrutura de um programa C /* Primeiro Programa em C */ comentários #include <stdio.h> /* biblioteca de E/S */ main() /* função principal – inicio do programa*/ { /* marca início da função*/ printf(“Meu primeiro programa em C\n”); /* função para escrever na tela*/ } /* marca fim da função*/

Digitando um programa C Utilizar um editor qualquer: vi ou xedit Digite o programa anterior Salve com o nome p1.c

Compilando e Executando Para compilar: (verifica a sintaxe) >> cc fonte.c <ENTER> Para compilar e gerar executável: >> cc fonte.c –o nomeexec <ENTER> Executando: >> ./nomeexec <ENTER> OBS: Se o nome do executável não for informado o default é a.out

Variável Variável: “objeto” que pode assumir diversos valores; espaço de memória de um certo tipo de dado associado a um nome para referenciar seu conteúdo Main ( ) { int idade; idade = 30; printf (“ A idade é : %d”, idade); }

Nomes de Variáveis quantos caracteres quiser (32) ; comece com letras ou sublinhado: Seguidos de letras, números ou sublinhados C é sensível ao caso: peso <> Peso <> pEso não podemos definir um identificador com o mesmo nome que uma palavra chave auto static extern int long if while do ......

Declaração de Variáveis Instrução para reservar uma quantidade de memória para um certo tipo de dado, indicando o nome pelo qual a área será referenciad a >> tipo nome-da-variável; ou >> tipo nome1, nome2,...,nomen EX: char nome; int idade, num;

Tipos Básicos de Dados determinar um conjunto de valores e as possíveis operações realizadas sobre os mesmos ; informa a quantidade de memória (bytes) ; tipo bytes escala char 1 -128 a 127 int 2 -32.768 a 32.767 float 4 3.4e-38 a 3.4e+38 double 8 1.7e-308 a 1.7e+308

Diferentes tipos de inteiros Long ou Long int (4 bytes) Unsigned Char (0 a 255) Unsigned int (0 a 65.535) obs: int tem sempre o tamanho da palavra da máquina

Programa Exemplo – Tipos de Dados e Variáveis #include <stdio.h> main( ) { int soma=10; float money=2.21; char letra= ´A´; double pi=2.01E6; printf (“valor da soma = %d\n”, soma); printf (“Valor de Money = %f\n”, money); printf(“Valor de Letra = %c\n”, letra); printf(“Valor de Pi = %e\n”, pi); }

Comandos básicos Instruções de E/S Entrada de Dados Processamento de dados Saída de Dados

Intruções de E/S – Scanf ( ) Leitura de dados tipados via teclado Scanf (“string de controle”, lista de argumentos); Exemplo: scanf(“%d”,&idade); OBS : Para seqüência de caracteres (%s), o caracter & não deverá ser usado.

Comandos de E/S – printf ( ) Apresentação de dados no monitor printf (“string de controle”, lista de argumentos); Exemplo: printf (“Digite a sua idade:\n”); scanf (“%d”, &idade); printf(“Sua idade é: %d”, idade);

String de controle %c  caracter %d  inteiro %e  número ou notação científica %f  ponto flutuante %o  octal %x  hexadecimal %s  string (cadeia de caracteres) %lf  double

Exemplo strings de controle #include <stdio.h> main ( ) { char a ; printf ( “digite um caracter” ); scanf ( “ % c”, &a ); printf (“ \n %c = %d em decimal”, a, a); printf (“%o em octal, %x em hexadecimal”, a, a); } Digitando m: m = 109 em decimal, 155 em octal, 6d em hexadecimal

Operador de Endereço & um endereço de memória é o nome que o computador usa para identificar uma variável toda variável ocupa uma área de memória e seu endereço é o primeiro byte por ela ocupado Ex : inteiro  2  bytes float  4 bytes char  1 byte

Operador de Endereço & Quando usamos & precedendo uma variável estamos falando do endereço desta variável na memória Ex: Main ( ) { int num; num = 2; printf (“valor = %d, endereço = %Iu”, num,&num); } Saída: valor = 2, endereço = 1230 Varia conforme memória da máquina

Caracteres Especiais \n nova linha \r enter \t tabulação (tab) \b retrocesso \” aspas \\ barra

Formatando as saídas - printf é possível estabelecer o tamanho mínimo para a impressão de um campo #include <stdio.h> main ( ) { 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 350 os alunos são 350 os alunos são 350

Formatando as saídas - printf #include <stdio.h> main ( ) { printf (“ %3.1f \n”, 3456.78); printf (“ %10.3f \n”, 3456.78); } Saída: 3456.8 3456.780

Programando – Exercício 1 Faça um programa para ler e escrever na tela o seu nome e a sua idade. #include <stdio.h> main( ) { int idade; char nome[30]; printf (“Digite o seu nome:\n”); scanf(“%s”, nome); printf (“Digite a sua idade:\n”); scanf (“%d”, &idade); printf(“A idade do(a) %s é %d”,nome, idade); }

Programando – Exercício 2 Faça um programa para ler e escrever na tela os seguintes dados: Nome Endereço Telefone Cidade Cep

Operadores Aritméticos Subtração (unário) - Decremento -- Incremento ++ Resto da divisão inteira % Divisão / Multiplicação * Adição + Ação Operador

Operadores Relacionais e Lógicos Condição “E” && Condição “OU” || Não ! Igual a == Diferente de != Menor ou igual que <= Menor que < Maior ou igual que >= Maior que > Ação Operador

Operadores - Observação Em C o resultado da comparação será ZERO se resultar em FALSO e DIFERENTE DE ZERO no caso de obtermos VERDADEIRO num teste qualquer.

Operadores - Exemplo #include <stdio.h> main ( ) { int verdadeiro, falso; verdadeiro = (15 < 20); falso = (15 == 20); printf(“Verd.= %d,Falso= %d”, verdadeiro, falso); } Saída: Verd.=1 Falso = 0

Comparações e Testes Observemos antes de mais nada que ++x é diferente de x++! Se x = 10; y = ++x; /* x=x+1; y=x; */ então x = 11 e y = 11 porém Se x = 10; y = x++; /* y=x; x=x+1 */ então x = 11 e y = 10

Programa Exemplo – Pre/Pos Incremento #include<stdio.h> main() { int cont = 0, loop; loop=++cont; printf(“Loop=%d, Cont=%d\n”, loop, cont); loop=cont++; printf(“Loop=%d, Cont=%d\n”, loop, cont); Quais são as saídas deste programa ?

Comparações e Testes Se x = 1; y = 2; printf(“%d == %d e’ %d\n”, x, y, x==y ) Qual seria a saída deste comando? resultaria em 1 == 2 0 (pois a expressão é falsa)

Comparações e Testes if (10 > 4 && !(10 < 9) || 3 <= 4) Como seria avaliado esta instrução? resultaria em Verdadeiro, pois dez é maior que quatro E dez não é menor que nove OU três é menor ou igual a quatro

Operador Sizeof Este operador retorna o tamanho da variável ou tipo que está em seu operando. Por exemplo “sizeof(char)” resultaria em 1.

Conversões de Tipos Quando forem misturadas variáveis de diferentes tipos, o compilador C converterá os operandos para o tipo de operando maior, de acordo com as regras descritas a seguir: 1-Todo char e short int é convertido para int. Todo float é convertido para double. 2-Para os demais pares de operandos valem as seguintes regras em seqüência: 2.1- Se um operando for long double, o outro também o será. 2.2- Se um operando for double, o outro também o será. 2.3- Se um operando for long, o outro também o será. 2.4- Se um operando for unsigned, o outro também o será.

Conversões de Tipos - NOTA Nota: Devemos observar que o compilador C é bastante flexível e pouco vigilante, comportando-se de maneira muito diferente de um compilador Clipper ou Pascal, sempre vigilantes com relação aos tipos das variáveis. De fato aqueles compiladores podem gerar executáveis misturando tipos, porém a ocorrência de erros de execução é quase inevitável. Ao contrário destes compiladores, os compiladores C “ajeitam” as coisas para o programa funcionar da “melhor maneira possível”, o que não significa em hipótese alguma que os resultados serão os esperados por programadores “relapsos”. Assim esta boa característica dos compiladores C, pode transformar-se numa autêntica “bomba relógio” para programas não muito bem elaborados.

Estruturas de Decisão Permitir testes para decidir ações alternativas: if if - else switch (?:) Operador Condicional

Comando if if (condição) instrução; # include <stdio.h> main ( ) { char ch; ch = getchar ( ); if (ch == ‘p’) printf (“você pressionou a tecla p”); } if (condição) { instrução1; intrução2; } #include <stdio.h> main ( ) { if (getchar()) == ‘p’ ) { printf (“ você digitou p”); printf (“ pressione outra tecla ”); getchar( ); } }

if aninhados Se um comando if está dentro do outro if, dizemos que o if interno está aninhado. #include <stdio.h> main ( ) { char ch; printf (“ digite uma letra entre A e Z”); ch = getchar ( ); if (ch >= ‘A’) if (ch < = ‘Z’) printf (“ você acertou”); } #include <stdio.h> main ( ) { char ch; printf (“ digite uma letra entre A e Z”); ch = getchar ( ); if ((ch >= ‘A’) && (ch < = ‘Z’)) printf (“ você acertou”); }

Comando if-else O comando if só executa a instrução caso a condição de teste seja verdadeira, nada fazendo se a expressão for falsa. O comando else executará uma instrução ou um conjunto de instruções se a expressão for falsa.

Comando if-else if (condição) instrução; else instrução; #include <stdio.h> main ( ) { if (getchar ( ) == ‘p’) printf (“ você digitou p”); else printf (“ você não digitou p”); }

Exemplo: Evitar-se divisões por Zero, usando recursos do comando if-else. include <stdio.h> main() { int a,b; printf(“Digite 2 números: “); scanf(“%d %d”,&a,&b); if (b) printf(“%f”,a/b); else printf(“Nao posso dividir por zero\n”); }

Comando if-else aninhados if (condição1) instrução else if (condição2) instrução else if (condição3)... #include <stdio.h> 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”); }

Como o computador decide de qual if o else pertence? EX1: if (n > 0) if (a > b){ z = a; calculafatorial(z); } else z = b; Ex1: Quando n > 0 e a < b Ex2: Quando n < 0 else é sempre associado ao if mais interno quando z = b será executado? Ex2: if (n > 0) { if (a > b) z = a; } else z = b;

Exemplo 1: Programa Adulto, Jovem ou Velho. #include <stdio.h> main() { int i; printf(“Digite sua idade: “); scanf(“%d”,&i); if (i > 70) printf(“Esta Velho!”); else if (i > 21) printf(“Adulto”); else printf(“Jovem”); }

Exemplo 2: Maior entre três números main() { int a,b,c; printf(“Digite o 1º Número: “); scanf(“%d”,&a); printf(“\nDigite o 2º Número: “); scanf(“%d”,&b); printf(“\nDigite o 3º Número: “); scanf(“%d”,&c); if (a > b) if (a > c) printf(“\nO Maior é %d”,a); else printf(“\nO Maior é %d”,c); else if (b > c) printf(“\nO Maior é %d”,b); else printf(“\nO Maior é %d”,c); } main() { int a,b,c,d; cls(); printf(“Digite o 1º Número: “); scanf(“%d”,&a); printf(“\nDigite o 2º Número: “); scanf(“%d”,&b); printf(“\nDigite o 3º Número: “); scanf(“%d”,&c); if (a > b) d = a; else d = b; if (c > d) printf(“\nO Maior é %d”,c); else printf(“\nO Maior é %d”,d); }

Exemplo 3: Dados 2 números apresente-os ordenados. main() { int a,b,t; printf(“Digite o 1º Número: “); scanf(“%d”,&a); printf(“\nDigite o 2º Número: “); scanf(“%d”,&b); if (a < b) { t = a; a = b; b = t; } printf(“\nOrdenados: %d e %d “,b,a); }

Comando ?: Forma compacta de expressar uma instrução if – else (condição) ? expressão1 : expressão2 Max = (num1 > num2) ? num1 : num2 Note: if (num1 > num2) max = num1; else max = num2; Exemplo: ABS = (num < 0) ? - num : num;

Comando Switch Forma de se substituir o comando if – else ao se executar vários testes Diversas vezes precisamos determinar se um valor encontra-se numa lista de valores. Apesar de podermos usar uma seqüência de ifs, este recurso além de não ser elegante, por vezes confunde o entendimento do programa. Vejamos uma opção melhor: o comando switch.

Comando Switch switch <variável> { case <constante 1> : <comandos>; [break;] case <constante 2> : <comandos>; [break;] case <constante 3> : <comandos>; [break;] [default : <comandos>;] } OBS: “ variável” deve ser uma variável do tipo inteiro ou caracter; “ break” serve para terminar a seqüência de comandos em execução, por serem opcionais, se forem suprimidos permitem que o “case” a seguir seja executado, sem haver qualquer quebra na seqüência do processamento.

Comando Switch - Ex: uma calculadora #include <stdio.h> main ( ) { char op; float num 1, num 2; printf (“ digite um n.o, um operador e um n.o”); scanf (“ %f %c %f”, &num1, &op, &num2); switch (op) { case ‘+’: printf (“ = %f”, num 1 + num 2); break: case ‘-’: printf (“ = %f”, num 1 - num 2); break; default: printf (“ operador inválido”); } }

Exercício Seguindo a idéia do exercício anterior incremente a calculadora com mais funções matemáticas. Sugestão: use funções da biblioteca matemática math.h como por exemplo: sin(x) cos(x) log(x) sqrt(x) pow(x1,x2) Para compilar a biblioteca matemática : cc p1.c -o p1 -lm

Estruturas de Repetição #include <stdio.h> main ( ) { printf (“1”); printf (“2”); : : : printf (“10”); } saída: 1 2 3 4 ... 10 Como imprimir os 1000 1 os números a partir de 1?

Estruturas de Repetição for, while, do-while repetir uma seqüência de comandos #include<stdio.h> m ain ( ) { int num; for (num = 1; num <= 1000; num++) printf (“ % d”, num); } Saída: 1 2 3 ... 1000

Comando for for (<início>;<condição>;<incremento>) <comando>; Na forma mais simples : Inicialização: expressão de atribuição sempre executada uma única vez Teste: condição que controla a execução do laço é sempre avaliada a cada execução verdadeiro  continua a execução falso  para a execução

Comando for Incremento: define como a variável de controle será alterada é sempre executada após a execução do corpo do laço Exemplo : imprimindo números pares #include<stdio.h> main ( ) { int número; for ( número = 2; número < 10; número += 2 ) printf (“ %d”, número); } Saída 2 4 6 8

Comando for Flexibilidade: qualquer expressão de um laço “for” pode conter várias instruções separadas por vírgula. for (x=0,y=0;x+y<100;++x,y=y+x) printf(“%d”,x+y); Esta instrução inicializaria x e y com zero, incrementando x de 1 em 1 e y receberia seu valor acrescido do de x. O resultado a cada iteração seria impresso desta forma: 0 (x=0 e y=0) 2 (x=1 e y=1) 5 (x=2 e y=3) 9 14 e assim sucessivamente.

Comando for - Exemplo Exemplo 1: Contagem simples com condição no teste “for”. main() { int i,j,resposta; char feito = ‘ ‘; for (i=1;i<100 && feito != ‘N’;i++) { for (j=1;j<10;j++) { printf(“Quanto e’ %d + %d? “,i,j); scanf(“%d”,&resposta); getchar(); /* limpar o buffer do teclado */ if (resposta != i+j) printf(“Errou!\n); else printf(“Acertou!\n”); } printf(“Mais? (S/N) “); scanf(“%c”,&feito); getchar(); /* limpar o buffer do teclado */ } }

Comando for – loop infinito A ausência de condições de inicialização, continuidade e terminação, causarão um processo contínuo e teoricamente infinito (veremos posteriormente a intrução break , que tem a capacidade de encerrar um processo assemelhado ao exemplificado). for(;;) printf(“Este loop rodará eternamente!\n”);

Comando for – Loop Vazio A presença do ponto e vírgula finalizando o comando, força a execução do loop sem que seja executado qualquer outro comando. for(i=0;i<10;i++);

Comando for – Loop Finito Ao contrário de outras linguagens que não permitem o término do loop a não ser quando a condição de finalização for satisfeita, a linguagem C permite que um loop seja interrompido antes de seu término normal (desestruturação) sem que exista qualquer tipo de inconveniente. O comando “break” causa essa interrupção. for(;;) { scanf(“%c”,&c); if (c == ‘A’) break; /*interrompe o que deveria ser um laço eterno*/ } printf(“Fim do Loop!”);

Comando While while <condição> <comando>; Exemplo: Contagem #include <stdio.h> main() { int i=0; while (i < 10) { printf(“%d”,i); i++; } } O loop se repete, enquanto a condição for verdadeira

Comando do - while Ao contrário das estruturas “for” e “while” que testam a condição no começo do loop, “do / while” sempre a testa no final, garantido a execução ao menos uma vez da estrutura. do { <comandos>; } while <condição>; Exemplo: Término determinado pelo usuário. #include <stdio.h> main() { int num; do { scanf(“%d”,&num); } while (num < 100); }

/ * testa a capacidade de adivinhar uma letra * / #include <stdio.h> main ( ) { char ch; int tentativas; do { printf (“digite uma letra”); scanf(“%c”, ch); getchar ( ); tentativas = 1; while ( ch!= ‘t’) { printf (“%c é incorreto \n”, ch); tentativas++; printf (“tente novamente \n”); } printf (“%c é correto”, ch); printf (“acertou em %d vezes”, tentativas); printf (“continua? (s / n):”); scanf(“%c”,ch); getchar( ); } while (ch == ‘s’); }

Funções / Procedimentos Dividir uma tarefa complexa em tarefas menores, permitindo esconder detalhes de implementação Evita-se a repetição de um mesmo código Tipo Nome (lista de parâmetros) { corpo }

Procedimentos “ Funções” que não retornam valores Tipo: void #include <stdio.h> void desenha(); void desenha( ) { int i; for (i = 0; i < = 10; i++) printf (“-”); } main ( ) { desenha ( ); printf (“ usando funções”); desenha ( ); } ___________usando funcoes___________

Funções Retornam valores #include <stdio.h> int fatorial (int); 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 bloco São criadas apenas na entrada do bloco e destruídas na saída (automáticas)

Variáveis Locais void desenha ( ) { int i, j; . . . } main ( ) { int a; desenha(); a = i;  erro . . . } void desenha ( ) { int i, j; . . . . . . } void calcula ( ) { int i, j; . . . . . . } i, j em desenha são variáveis diferentes de i, j em calcula.

Variáveis Globais Variável que é declarada externamente podendo ser acessada por qualquer função #include <stdio.h> main ( ) { int i; ......... ......... desenha ( ); calcula ( ); } void desenha ( ) { int j; i = 0; . . . } void calcula ( ) { int m; i = 5; . . . }

Comando Return Causa a atribuição da expressão a função forçando o retorno imediato ao ponto de chamada da função. #include <stdio.h> main ( ) { char letra; printf (“ digite uma letra em minúsculo”); letra = minúsculo ( ); if (letra == ‘a’) printf (“ok”); } char minúsculo ( ) { char ch; scanf(“%c”, ch); if ( (ch >= ‘A’) && (ch <= ‘Z’)) return (ch + ‘a’ - ‘A’); else return (ch); }

Note pelo exemplo anterior que a função minúsculo lê um valor internamente convertendo-o para minúsculo. Como usar esta função se já temos uma letra e desejamos convertê-la para minúsculo?

Passando dados para função Passagem de parâmetro por valor - uma cópia do argumento é passada para a função O parâmetro se comporta como uma variável local

Passando dados para função main ( ) { printf (“ %c”, minúsculo (‘A’) );   parâmetro real } char minúsculo (char ch)  parâmetro formal { if (( ch >= ‘A’)&& (ch <= ‘Z’)) return (ch + ‘a’-, ‘A’); else return (ch); }

Passando dados para função - Exemplo #include <stdio.h> main ( ) { int num, b; printf (“ entre com um número > o”); scanf (“ %d”, &num ); b = abs (num); . . . printf (“ Valor absoluto de num = %d”, abs(num) ); . . . b = abs(-3); } int abs (int x) { return ( ( x < 0 ) ? -x : x ); }

Passando vários argumentos Ex 1: float área_retângulo (float largura, float altura) { return (largura * altura); } Ex 2: float potência (float base, int expoente) { int i; float resultado = 1; if (expoente == 0) return 1; f or (i = 1; i <= expoente; i++) resultado *= base return resultado; }

Usando várias funções: calcular a seguinte seqüência S(x, n) = x/1! + x 2 /2! + x 3 /3! + ... + x n / n! #include <stdio.h> float serie (float , int ); float potencia (float , int) int fat (int); main( ) { float x; int termos; printf(“entre com o numero de termos: “); scanf(“%d”, &termos); printf(“entre com o valor de X: “); scanf(“%f”, &x); printf(“O valor de série = %f “, serie(x, termos) ); }

float potencia (float base, int expoente) { int i; float resultado = 1; if (expoente == 0) return 1; for (i = 1; i <= expoente; i++) resultado *= base; return resultado; } float serie (float x, int n) { int i; float resultado = 0; for ( i = 1; i <= n; i++) resultado += potência( x, i ) / fat( i ); return resultado; }

int fat (int n) { int i, resultado = 1; for ( i = 1; i <= n; i ++) resultado *= i; return resultado; }

Vetores tipo de dado usado para representar uma coleção de variáveis de um mesmo tipo estrutura de dados homogênea unidimensional Ex: Ler a nota de 3 alunos e calcular a média int nota0, nota1, nota2; printf(“entre com a 1a. nota”); scanf(“%d”, &nota0); : : : printf(“média = %f”, (nota0 + nota1 + nota2) / 3));

Ex: Calcular a média de 300 alunos #include<stdio.h> #define N_ALUNOS 40 main( ) { int i; float notas [ N_ALUNOS ], media = 0; for ( i = 0; i < N_ALUNOS; i++ ) { printf (“entre com a nota %d”, i+1); scanf (“%f”, &notas[ i ]); media += notas [ i ]; } printf (“ Média = %f \n”, media / N_ALUNOS); for ( i = 0; i < N_ALUNOS; i++ ) { printf (“\n Nota do aluno %d = ”, i+1); printf (“%f \n”, notas[ i ]); } }

Vetores – Observações importantes em ‘C’ não existe declaração de vetor dinâmico o tamanho de um vetor tem que ser determinado em tempo de compilação Ex: int alunos; int notas [ alunos ]; : : : printf (“entre com o número de alunos”); scanf (“%d”, &alunos); NÂO É ACEITO !!!

Vetores – Observações importantes Solução: declarar um vetor que suporte um número máximo de elementos Ex: int alunos; int notas [ 70 ]; : : : printf (“entre com o número de alunos”); scanf (“%d”, &alunos);

Vetores – Observações importantes C não realiza verificação de limites em vetores nada impede o acesso além do fim do vetor faça sempre que necessário a verificação dos limites

Vetores – Obs importantes #include <stdio.h> #define TAMANHO 100 main( ) { int quantidade, media = 0; float notas [ TAMANHO ]; // quantidade deve ser  TAMANHO printf ( “quantas notas devo ler ?”); scanf(“%d”, &quantidade); for ( i = 0; i < quantidade; i++) { printf ( “entre com a nota %d”, i+1); scanf(“%d”, &notas [ i ]); } : : : for ( i = 0; i < quantidade; i++) media += notas [ i ]; : : : }

Passando um vetor para uma função #include <stdio.h> int maximum( int [] ); /* ANSI function prototype */ main( ) { int values[5], i, max; printf("Entre com 5 numeros:\n"); for( i = 0; i < 5; ++i ) scanf("%d", &values[i] ); max = maximum( values ); printf("\nValor Maximo: %d\n", max ); }

int maximum( int values[5] ) { int max_value, i; max_value = values[0]; for( i = 0; i < 5; ++i ) if( values[i] > max_value ) max_value = values[i]; return max_value; } Saída: Entre com 5 numeros: 7 23 45 9 121 Valor Maximo: 121

Matrizes em ‘C’ podemos definir um vetor em que cada posição temos um outro vetor (matriz). estrutura de dados homogênea multidimensional Note: int matéria [ 4 ] [ 40 ]; temos 4 matérias, cada uma com 40 alunos

Matrizes - Leitura 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 ]); } }

Variável String matriz do tipo char terminada pelo caractere null ‘\0’ cada caractere de um string pode ser acessado individualmente vetor de tamanho n  string de tamanho ( n-1 ) Ex: char string[10] = “exemplo” ; char string[10] = { “exemplo” }; char string[10] = { ‘e’, ‘x’, ‘e’, ‘m’, ‘p’, ‘l’, ‘o’, ‘\0’ }; printf ( “%s”, string ); printf ( “%c”, string [ 0 ] );

Lendo Strings scanf : lê o string até que um branco seja encontrado Ex: main ( ) { char nome[40]; printf ( “Digite seu nome: “ ); scanf ( “%s”, &nome[ 0 ] ); //scanf ( “%s”, nome ); printf ( “Bom dia %c”, nome[0] ); } Saída : Digite seu nome: Jose Maria Bom dia Jose

Lendo Strings Gets lê caracteres até encontrar ‘\n’ substitui ‘\n’ por ‘\0’ Ex: main ( ) { char nome[40]; printf ( “Digite seu nome: “ ); gets ( &nome[ 0 ] ); // ou gets(nome); printf ( “Bom dia %s”, nome ); } Saída : Digite seu nome: Jose Maria Bom dia Jose Maria

Imprimindo Strings printf puts Ex: main ( ) { char nome[40]; printf ( “Digite seu nome: “ ); gets ( &nome[ 0 ] ); puts ( “Bom dia ” ); puts ( nome ); } Saída : Digite seu nome: Jose Maria Bom dia Jose Maria

Funções de manipulação de strings Strlen retorna o tamanho do string - não conta ‘\0’ Ex: main ( ) { char nome[40]; printf ( “Digite seu nome: “ ); gets ( &nome[ 0 ] ); printf (“Tamanho = %d”, strlen(&nome[ 0 ]) ); } Saída : Digite seu nome: Jose Maria Tamanho = 10

Funções de manipulação de strings strcat ( str1, str2 ) concatena str2 ao final de str1 Ex: main ( ) { char nome[40] = “Jose”, char sobrenome[30] = “Maria”; strcat(nome, sobrenome); puts (sobrenome); puts (nome); } Saída : Maria JoseMaria Cuidado: dado str1 + str2 tem que caber em str1

Funções de manipulação de strings strcmp ( str1, str2 ) compara dois strings retornando: – negativo se str1 < str2 – 0 se str1 = str2 – positivo se str1 > str2 a comparação é feita por ordem alfabética

#include <stdio.h> main ( ) { char nome[40] = “Jose”; char sobrenome[30] = “Maria”; if ( strcmp ( nome, sobrenome ) !=0) puts ( “os strings são diferentes” ); else puts ( “os strings são identicos” ); }

Conversões podemos também converter strings e números (inteiros/fracionários) conforme desejarmos: Exemplo: Conversão de String em Número Inteiro #include <stdio.h> main() { int i; char s[10]; printf(“Digite uma sequencia de numeros com letras: “); gets(s); i = atoi(s); printf(“Numero: %d “,i); }

Ponteiros Ponteiros, como o próprio nome diz, é um tipo de variável que aponta para outra (de um tipo qualquer). Na verdade um ponteiro guarda o endereço de memória (local onde se encontra na memória) de uma variável.

Ponteiros int teste=20; int *p; p=&teste; p irá armazenar o endereço de memória da variável teste. Ou seja, p não armazena o valor 20, mas sim o endereço de teste que, este sim, armazena o valor 20. como chegar ao valor 20 usando a variável p? int teste=20; int *p; p=&teste; printf("%d\n",*p);

Ponteiros Outro exemplo: char algo[5] = { 5, 4, 3, 2, 1 }; char *c; c=&algo[2]; Colocamos em c o endereço do terceiro elemento de algo: c[0]=3, c[1]=2 e c[2]=1. Se tivéssemos feito c=&algo[3], então: c[0]=2 e c[1]=1.

Ponteiros int vet_notas[50]; int *pont_notas; pont_notas=vet_notas; Para imprimir a primeira e a décima nota de nosso vetor, temos duas opções: print ("A primeira nota é: %d", vet_notas[0]); print ("A primeira nota é: %d", *pont_notas); print ("A décima nota é: %d", vet_notas[9]); print ("A décima nota é: %d", *(pont_notas+9));

Equivalência entre vetores e ponteiros vet_notas[0]==*(pont_notas); vet_notas[1]==*(pont_notas+1); vet_notas[2]==*(pont_notas+2);

Malloc e Free Alocação dinâmica #include <stdio.h> main() { int *notas, numero, i;

Printf(“Entre com o número total de alunos\n’”); scanf(“%d”, &numero); notas=(int *)malloc(numero * sizeof(int)); for (i=0; i,numero; i++) { printf(“Digite a nota do aluno %d”, i+1); scanf(“%d”, &notas[i]); printf(“\n A nota do aluno %d é :%d: , i+1, notas[i]); } free(notas); }

Estruturas Uma estrutura é um conjunto de variáveis dentro de um mesmo nome. Em geral, uma variável é de um tipo específico, por exemplo, temos uma variável do tipo inteira e estamos fechados a nos referenciar aquele nome que lhe foi dado sempre por um número do tipo inteiro, logicamente. Já as estruturas, dentro de um mesmo nome podemos nos referenciar a uma gama de variáveis pré-definidas.

Estruturas struct molde_conta { char nome[50]; int telefone; float saldo ; }; Definido o molde, devemos agora declarar a variável que utilizará desse molde: struct molde_conta conta;

Estruturas struct molde_conta { char nome[50]; int telefone; float saldo; } conta1, conta2; equivalente a: struct molde_conta conta1, conta2;

Estrutras - Utilização do tipo Podemos fazer atribuição de structs, do tipo conta2 = conta, e os valores serão idênticos. Para contar o número de caracteres de nome dentro da estrutura conta, podemos fazer: for (i=0,conta.nome[i],++i) ; printf ("o nome tem -> %d letras \n",i);

Vetores de Estruturas struct molde_conta conta[100]; conta[1].telefone=2212324; conta[1].nome=“joao carlos”; conta[1].saldo=1245.89; conta[5].telefone=2212888; conta[5].nome=“Maria dos Santos”; conta[5].saldo=6908.79;

Arquivos - feopen( ) A função “fopen” tem duas finalidades: - abrir uma fila de bytes - ligar um arquivo em disco àquela fila FILE *fopen(char *NomeArquivo, char *modo); FILE *arquivo; if ((arquivo = fopen(“teste”,”w”)) == NULL) { puts(“Não posso abrir o Arquivo teste.\n”); exit(1); /* força o término da execução da rotina */ }

Modo Significado “ r” Abre Arquivo de Texto para Leitura “ w” Cria Arquivo de Texto para Gravação “ a” Anexa a um Arquivo de Texto “ rb” Abre Arquivo Binário para Leitura “ wb” Cria Arquivo Binário para Gravação “ ab” Anexa a um Arquivo Binário “ r+” Abre Arquivo de Texto para Leitura/Gravação “ w+” Cria Arquivo de Texto para Leitura/Gravação “ a+” Abre ou Cria Arquivo de Texto para Leitura/Gravação “ r+b” Abre Arquivo Binário para Leitura/Gravação “ w+b” Cria Arquivo Binário para Leitura/Gravação “ a+b” Abre ou Cria Arquivo Binário para Leitura/Gravação

Arquivos - putc ( ) Grava caracteres em fila previamente abertos int putc(int ch, FILE *fp); ch é o caracter a ser gravado fp é o ponteiro devolvido por fopen putc(‘a’, arquivo);

Arquivos - getc ( ) Ler caracteres em uma fila aberta int getc(FILE *arquivo); Exemplo: ch = getc(arquivo); while (ch != EOF) ch = getc(arquivo);

Arquivos - fclose ( ) Fechar as filas abertas. Caso o programa seja encerrado sem que as filas sejam fechadas, dados gravados nos buffers podem ser perdidos. int fclose(FILE *fp); fclose(arquivo);

main() { FILE *arq; char ch; if ((arq=fopen(“teste.dat”,”w”)) == NULL) { printf(“Arquivo não pode ser criado\n”); exit(1); } do{ ch=getchar(); putc(ch,arq); }while (ch!=0); fclose(arq); }

Arquivos - ferror ( ) Determina se a operação de arquivo produziu um erro. Sua forma geral será: int ferror(FILE *fp);

Arquivos - rewind( ) Reinicia o arquivo, equivale ao Reset do Pascal, ou seja apenas movimenta o ponteiro do arquivo para seu início.

Arquivos - fwrite ( ) fread ( ) Permitem que leiamos/gravemos blocos de dados, sua forma geral é a seguinte: int fread(void *buffer, int num_bytes, int cont, FILE *fp); int fwrite(void *buffer, int num_bytes, int cont, FILE *fp);

Arquivos - fwrite ( ) main() { FILE *fp; float f = 12.23; if ((fp=fopen(“teste”,”wb”)) == NULL) { printf(“Arquivo não pode ser criado\n”); exit(1); } fwrite(&f,sizeof(float(),1,fp); fclose(fp); }

Arquivos - fseek ( ) Entrada e saída com acesso aleatório int fseek(FILE *fp, long int num_bytes, int origem); fp - é o ponteiro de arquivo devolvido por fopen(). num_bytes - é um inteiro longo que representa o número de bytes desde a origem até chegar a posição corrente. OBS: Este comando é normalmente utilizado em arquivos binários.

Exemplo : Leitura de um caracter em um arquivo binário. main() { FILE *fp; if ((fp=fopen(“teste”,”rb”)) == NULL) { printf(“Arquivo não pode ser aberto\n”); exit(1); } fseek(fp,234L,0); /* L força que seja um inteiro longo */ return getc(fp); /* lê o caracter 234 */ }

carga() { FILE *fp; int i; if ((fp=fopen(“LISTA.DAT”,”rb”)) == NULL) { puts(“Falha na Abertura do Arquivo!”); return; } inicia_matriz(); for (i=0; i < 100; i++) if (fread(&matriz[i], sizeof(struct registro), 1, fp) != 1) { if (feof(fp)) { fclose(fp); return; } else { puts(“Erro de Leitura! “); fclose(fp); return; } } } Exemplo de montagem de um pequeno cadastro de nomes, endereços e salários de funcionários em arquivo.

salvar() { FILE *fp; int i; if ((fp=fopen(“LISTA.DAT”,”wb”))==NULL) { puts(“Falhou Abertura! “); return; } for (i=0;i<100;i++) if (*matriz[i].nome) if(fwrite(&matriz[i], sizeof(struct registro), 1,fp) != 1) puts(“Falha na Gravacao! “); fclose(fp); }

Vamos supor que desejamos criar um programa que escreva num arquivo cujo nome será fornecido na chamada do programa (Exemplificando: KTOD TESTE <Enter> ). Gostaríamos que o DOS criasse o arquivo TESTE guardando o conteúdo digitado durante a execução do programa.

main(argv,argc) onde argc - tem o número de argumentos contidos nas linha de comando (necessariamente maior ou igual a um, pois o próprio programa já é considerado um argumento pelo D.O.S.). argv é um ponteiro que acomodará os caracteres digitados.

Exemplo 1: Programa KTOD, que escreve caracteres num arquivo criado/aberto via D.O.S. #include “stdio.h” main(argc,argv) int argc; char *argv[]; { FILE *fp; char ch; if (arg != 2) { printf(“Digite o Nome do Arquivo\n”); exit(1); }

if ((fp=fopen(argv[1],”w”)) == NULL) { printf(“Arquivo não pode ser aberto\n”); exit(1); } do { ch = getchar(); putc(ch,fp); } while( ch != ‘$’); fclose(fp); }

Exemplo 2: Programa DTOV, que apresenta em vídeo os caracteres digitados via KTOD. #include “stdio.h” main(argc,argv) int argc; char *argv[]; { FILE *fp; char ch; if (arg != 2) { printf(“Digite o Nome do Arquivo\n”); exit(1); } if ((fp=fopen(argv[1],”r”)) == NULL) { printf(“Arquivo não pode ser aberto\n”); exit(1); } ch = getc(fp);

do { putchar(ch); ch=getc(fp); } while( ch != ‘$’); fclose(fp); }

Exemplo 3: Programa para copiar Arquivos. #include “stdio.h” main(argc,argv) int argc; char *argv[]; { FILE *in, *out; char ch; if (arg != 3) { printf(“Digite o Nome dos Arquivos\n”); exit(1); } if ((in=fopen(argv[1],”rb”)) == NULL) { printf(“Arquivo origem não existe\n”); exit(1); } if ((out=fopen(argv[2],”wb”)) == NULL) { printf(“Arquivo destino não existe\n”); exit(1); } while (! feof(in)) putc(getc(in),out); /* esta é a cópia propriamente dita */ fclose(in); fclose(out); }

Introdução a Linguagem C

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Introdução a Linguagem C (20)

Introdução a Linguagem C