introdução a linguagem de programação c. introdução linguagem c resumo histórico em 1973...

Introdução a Linguagem de Programação C

Introdução Linguagem C

Resumo 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 chaveauto 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 nome1, nome2,...,nomenEX: 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 2bytesfloat 4 byteschar 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 = 1230Varia 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

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>

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

Sex = 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.


Exercícios 2) 3)


Estruturas de Decisão Permitir testes para decidir ações

alternativas: if if - else switch (?:) Operador Condicional


Comando ifif (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);

elseprintf(“Nao posso dividir por zero\n”);

}


Comando if-else aninhados

if (condição1) instruçãoelse if

(condição2) instruçãoelse 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 < bEx2: 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”);

elseprintf(“Jovem”);

}

Exemplo 2: Maior entre três númerosmain(){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;


Exercícios 4) 5) 6)


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 Switchswitch <variável> {

case <constante 1> :<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 1os 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

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 - ExemploExemplo 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’);

}

Exercícios


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 Locaisvoid 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

S(x, n) = x/1! + x2/2! + x3/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 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 !!!



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



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 121Valor 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 - Leituraint 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 MariaBom 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 MariaBom dia Jose Maria


Funções de manipulação de strings

Strlenretorna 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 MariaTamanho = 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:MariaJoseMariaCuidado: 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);


PonteirosOutro 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.

Ponteirosint 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.


Estruturasstruct 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;


Estruturasstruct 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 gravadofp é o ponteiro devolvido por fopen

putc(‘a’, arquivo);


Arquivos - getc ( )

Ler caracteres em uma fila abertaint 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órioint 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 de programação c. introdução linguagem c resumo histórico em 1973...

Documents