Introduo a Linguagem de Programao C Andr Luiz

Introdução a Linguagem de Programação C André Luiz França Batista andreluiz@iftriangulo. edu. br http: //sites. google. com/a/iftriangulo. edu. br/andreluiz/ Instituto Federal do Triângulo Mineiro

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 Alto Nível Médio Clareza Velocidade Assembler C Basic COBOL Pascal Ada Modula -2

Aplicações escritas em C • Sistema Operacional: UNIX • Planilhas: 1, 2, 3 e Excel • Banco de Dados: d. Base 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 sensitive” • 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>

Bibliotecas • Quando uma biblioteca está no diretório de bibliotecas do compilador ela deve estar entre os símbolos de maior e menor. #include <minha_biblioteca. h> • Caso a biblioteca esteja no mesmo diretório do código fonte ela deve vir entre aspas dupla. #include “minha_biblioteca. h”

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

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 Cn”); /*função para escrever na tela*/ } /*marca fim da função*/

Digitando um programa C • Utilizar um editor qualquer • Digite o programa anterior • Salve com o nome p 1. 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 as caixas: peso <> Peso <> p. Eso • 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á referenciada >> tipo nome-da-variável; ou >> tipo nome 1, nome 2, . . . , 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 char int float double bytes 1 2 4 8 escala -128 a 127 -32. 768 a 32. 767 3. 4 e-38 a 3. 4 e+38 1. 7 e-308 a 1. 7 e+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. 01 E 6; printf (“valor da soma = %dn”, soma); printf (“Valor de Money = %fn”, money); printf(“Valor de Letra = %cn”, letra); printf(“Valor de Pi = %en”, pi); }

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

Instruçõ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); } Digitando m: m = 109 em decimal, 155 em octal, 6 d 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: #include <stdio. h> #include <stdlib. h> main () Saída: valor = 2, endereço = 1230 { int num; Varia conforme memória da máquina num = 2; printf (“Valor = %d, Endereço = %Iun”, num, &num); system(“pause”); }

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 %2 d n”, 350); printf (“os alunos são %4 d n”, 350); printf (“os alunos são %5 d n”, 350); } Saída: os alunos são 350 os alunos são 350

Formatando as saídas printf #include <stdio. h> main ( ) { printf (“ %3. 1 f n”, 3456. 78); printf (“ %10. 3 f n”, 3456. 78); } Saída: 3456. 8 3456. 780 %10. 3 f especifica que a variável será apresentada em um campo de dez caracteres com uma precisão de três dígitos após o ponto decimal.

Programando – Exercício 1 • Faça um programa para ler e escrever na tela o seu nome e a sua idade. #include <stdio. h> #include <stdlib. 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); system(“pause”); }

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 Operador + * / % Ação Adição Multiplicação Divisão Resto da divisão inteira -++ Subtração (unário) Decremento Incremento

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

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> #include <stdlib. h> main ( ) Saída: Verd. =1 Falso = 0 { int verdadeiro, falso; verdadeiro = (15 < 20); falso = (15 == 20); printf(“Verd. = %d, Falso= %d”, verdadeiro, falso); system(“pause”); }

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=%dn”, loop, cont); loop=cont++; printf(“Loop=%d, Cont=%dn”, loop, cont); Quais são as saídas deste programa ?

Comparações e Testes Se x = 1; y = 2; printf(“%d == %d e’ %dn”, 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.

#include <stdio. h> #include <stdlib. h> main () { int num; char nome 1, nome 2[10], nome 3[30]; printf("O tamanho da variavel num eh: %d. n", sizeof(num)); printf("O tamanho da variavel nome 1 eh: %d. n", sizeof(nome 1)); printf("O tamanho da variavel nome 2 eh: %d. n", sizeof(nome 2)); printf("O tamanho da variavel nome 3 eh: %d. n", sizeof(nome 3)); system("pause"); }

Tipo char • Variável do tipo char nada mais é do que um vetor de caracteres. • Vetor de caracteres = string. • Vetor de posições ordenadas.

Faça um programa que: • Receba um texto qualquer; • Receba um número inteiro (posição); • Imprima o texto todo; • Imprima o caracter da posição correspondente;

Exercícios 1) Receber um nome e imprimir as 5 primeiras letras; 2) Receber um nome e imprimir as letras que estão nas posições pares; 3) Receber um nome e imprimir as letras que estão nas posições ímpares;

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

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

Exercícios de if • Faça um programa que receba o nome de dois alunos e suas notas. • Imprimir na tela: – O nome do aluno; – A nota do aluno; – SE foi aprovado (>=60) ou reprovado (<60);

Resposta do exercício anterior #include <stdio. h> #include <stdlib. h> main() { char nome 1[30], nome 2[30]; int nota 1, nota 2; printf("Digite o nome do aluno: "); gets(nome 1); printf("n. Digite o nome do aluno: "); gets(nome 2); printf("Digite o valor da nota: "); scanf("%d", &nota 1); printf("Digite o valor da nota: "); scanf("%d", &nota 2); if(nota 1>=60) printf("nome: %s foi aprovadon", nome 1); if(nota 1<60) printf("nome: %s foi reprovadon", nome 1); if(nota 2>=60) printf("nome: %s foi aprovadon", nome 2); if(nota 2<60) printf("nome: %s foi reprovadon", nome 2); system("pause");

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 zeron”); }

Comando if-else aninhados if (condição 1) instrução else if (condição 2) instrução else if (condição 3). . . #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 ³ 0 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? • else é sempre associado ao if mais interno • quando z = b será executado? EX 1: if (n > 0) if (a > b){ z = a; calculafatorial(z); } else z = b; Ex 2: if (n > 0) { if (a > b) z = a; } else z = b; Ex 1: Quando n > 0 e a < b Ex 2: Quando n < 0

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(“n. Digite o 2º Número: “); scanf(“%d”, &b); printf(“n. Digite o 3º Número: “); scanf(“%d”, &c); if (a > b) if (a > c) printf(“n. O Maior é %d”, a); else printf(“n. O Maior é %d”, c); else if (b > c) printf(“n. O Maior é %d”, b); else printf(“n. O Maior é %d”, c); } main() { int a, b, c, d; cls(); printf(“Digite o 1º Número: “); scanf(“%d”, &a); printf(“n. Digite o 2º Número: “); scanf(“%d”, &b); printf(“n. Digite o 3º Número: “); scanf(“%d”, &c); if (a > b) d = a; else d = b; if (c > d) printf(“n. O Maior é %d”, c); else printf(“n. O Maior é %d”, d); }

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

Comando ? : • Forma compacta de expressar uma instrução if – else • (condição) ? valor. SEverd : valor. SEfalso • Max = (num 1 > num 2) ? num 1 : num 2 • Note: if (num 1 > num 2) max = num 1; else max = num 2; • Outro exemplo: ABS = (num < 0) ? -num : num;

Comando ? if (num. Mensagens > 0) { printf ("Você tem %d mensage%s", num. Mensagens, (num. Mensagens > 1) ? "ns" : "m"); }

Exercícios

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 <stdlib. h> #include <stdio. h> main() { char op; float num 1, num 2; printf("Digite um numero, um operador e outro numero: n"); scanf("%f %c %f", &num 1, &op, &num 2); switch(op) { case '+': printf(" = %3. 2 fn", num 1 + num 2); break; case '-': printf(" = %3. 2 fn", num 1 - num 2); break; default: printf("0 perador invalido. n"); } system("pause"); }

Exercício • Seguindo a ideia 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(x 1, x 2)

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

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

Comando 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> Saída 2 4 6 8 main ( ) { int número; for ( número = 2; número < 10; número += 2 ) printf (“ %d”, número); }

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 #include <stdio. h> #include <stdlib. h> main() { int i, j, resposta; char feito = ' '; for (i=1; i<100 && feito != 'N'; i++) { for (j=1; j<10; j++) { printf("Quanto eh %d + %d? ", i, j); scanf("%d", &resposta); getchar(); // limpar o buffer do teclado if (resposta != i+j) printf("Errou!n"); else printf("Acertou!n"); } //fim do for (j=1; j<10; j++) printf("Mais 10 operacoes? Pressione (N) para encerrar. "); scanf("%c", &feito); feito= toupper(feito); /* traduz de minusculo para maiusculo */ getchar(); // limpar o buffer do teclado } //fim do for (i=1; i<100 && feito != 'N'; i++) system("pause"); }

Comando for – loop infinito for(; ; ) printf(“Este loop rodará eternamente!n”); • 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).

Comando for – Loop Vazio for(i=0; i<10; i++); • 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.

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. Exemplo: Término determinado pelo usuário. do { <comandos>; } while <condição>; #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’); }

Resumo de estruturas de repetição for (início; final; passo) { <comandos>; } while (condição) { <comandos>; } for (i=0; i<10; i++) { printf(“Número: ”); printf(“%d n”, i); } while (opcao == 1) { printf(“Opção? ”); scanf(“%d”, &opcao); getchar(); }

Exercícios de estruturas de repetição • Faça um programa que receba um nome e imprima o nome invertido. Ex. : informática acitámrofni • Faça um programa que receba dois números inteiros e gere os números inteiros que estão no intervalo compreendido por eles. • Altere o programa anterior para mostrar no final a soma dos números.

Exercícios de estruturas de repetição • Faça um programa que peça dois números, base e expoente, calcule e mostre o primeiro número elevado ao segundo número. Não utilize a função de potência da linguagem. • A série de Fibonacci é formada pela seqüência 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, . . . Faça um programa capaz de gerar a série até o n−ésimo termo.

Variável String • matriz do tipo char terminada pelo caractere null ‘’ • 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’, ‘’ }; printf ( “%s”, string ); printf ( “%c”, string [ 0 ] );

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

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

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

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

Funções de manipulação de strings • strcat ( str 1, str 2 ) concatena str 2 ao final de str 1 Ex: main ( ) { char nome[40] = “Jose”, char sobrenome[30] = “Maria”; strcat(nome, sobrenome); puts (nome); }

Funções de manipulação de strings • strncat ( str 1, str 2, n ) concatena ‘n’ letras de str 2 ao final de str 1 Ex: main ( ) { char nome[40] = “Jose”, char sobrenome[30] = “Maria. Antonia. Da. Silva”; strncat(nome, sobrenome, 5); puts (sobrenome); puts (nome); }

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

/* strcmp exemplo */ #include <stdio. h> #include <string. h> #include <stdlib. h> main () { char meu. Nome[] = “Andre"; char opcao. Nome[10]; do { printf (“Qual eh o meu nome? "); gets (opcao. Nome); } while (strcmp (meu. Nome, opcao. Nome) != 0); puts (“Resposta correta! "); printf("%d", strcmp (meu. Nome, opcao. Nome)); system("pause"); }

Funções de manipulação de strings • strcpy • Copia o contéudo de uma string char str 1[]=“Exemplo de texto"; char str 2[40]; char str 3[40]; //copia o contéudo de str 1 para dentro de str 2 strcpy (str 2, str 1); //copia o texto entre aspas para dentro de str 3 strcpy (str 3, “Texto copiado");

Funções de manipulação de strings • strncpy • Copia alguns caracteres de uma string char str 1[]=“Exemplo de texto"; char str 2[40]; //copia as 5 primeiras letras de str 1 para dentro de str 2 strcnpy (str 2, str 1, 5);

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); }

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 ______usando funcoes______ • “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 ( ); }

Retornam valores Funções #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; for (i = 1; i <= expoente; i++) resultado *= base return resultado; }

Usando várias funções: calcular a seguinte seqüência 2 S(x, n) = x/1! + x /2! + x 3/3! + . . . + xn/ 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 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; } 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; }

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 nota 0, nota 1, nota 2; printf(“entre com a 1 a. nota”); scanf(“%d”, &nota 0); : : : printf(“média = %f”, (nota 0 + nota 1 + nota 2) / 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

#include <stdio. h> Vetores – Obs #define TAMANHO 100 importantes 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("n. Valor Maximo: %dn", max ); }

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

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

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; printf("%dn", *p); • 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?

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 alunosn’”); 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;

Estruturas struct molde_conta { char nome[50]; int telefone; float saldo; } conta 1, conta 2; equivalente a: struct molde_conta 1, conta 2;

Estrutras - Utilização do tipo • Podemos fazer atribuição de structs, do tipo conta 2 = 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[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 *Nome. Arquivo, 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 criadon”); 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 criadon”); 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 aberton”); exit(1); } fseek(fp, 234 L, 0); /* L força que seja um inteiro longo */ return getc(fp); /* lê o caracter 234 */ }

carga() Exemplo de montagem de um pequeno { cadastro de nomes, endereços e salários FILE *fp; de funcionários em arquivo. 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; } } }

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 Arquivon”); exit(1); }

if ((fp=fopen(argv[1], ”w”)) == NULL) { printf(“Arquivo não pode ser aberton”); 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 Arquivon”); exit(1); } if ((fp=fopen(argv[1], ”r”)) == NULL) { printf(“Arquivo não pode ser aberton”); 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 Arquivosn”); exit(1); } if ((in=fopen(argv[1], ”rb”)) == NULL) { printf(“Arquivo origem não existen”); exit(1); } if ((out=fopen(argv[2], ”wb”)) == NULL) { printf(“Arquivo destino não existen”); exit(1); } while (! feof(in)) putc(getc(in), out); /* esta é a cópia propriamente dita */ fclose(in); fclose(out); }