PROGRAMAÇÃO C ( Avançado

)

ÍNDICE
INTRODUÇÃO........................................................................................................................................ 3 CONCEITO.............................................................................................................................................. 3 ESTRUTURA BÁSICA DE UM PROGRAMA C ................................................................................. 4 TIPOS BÁSICOS ..................................................................................................................................... OPERADORES ARITMÉTICOS DE ATRIBUIÇÃO........................................................................... 11 OPERADORES RELACIONAIS............................................................................................................... COMANDOS DE SELEÇÃO .................................................................................................................... O COMANDO if ........................................................................................................................................ OPERADORES LÓGICOS........................................................................................................................ O COMANDO switch ................................................................................................................................ O COMANDO break.............................................................................................................................. 16 OPERADOR CONDICIONAL TERNÁRIO ( ? : ).................................................................................... LAÇOS DE REPETIÇÕES ........................................................................................................................ Estrutura de Repetição:............................................................................................................................... Laço for ...................................................................................................................................................... O LAÇO WHILE........................................................................................................................................ Estrutura do laço while : ............................................................................................................................. WHILE X FOR........................................................................................................................................... O LAÇO do-while ...................................................................................................................................... O COMANDO continue ............................................................................................................................. A Função exit()........................................................................................................................................... FUNÇÕES / MÓDULOS / SUB-ROTINAS .......................................................................................... 24 FUNÇÕES.............................................................................................................................................. 25 VARIÁVEL GLOBAL........................................................................................................................... 26 O COMANDO return ............................................................................................................................. 26 PASSANDO DADOS PARA FUNÇÕES .............................................................................................. 27 USANDO VÁRIAS FUNÇÕES............................................................................................................. 28 RECURSIVIDADE ................................................................................................................................ 29 ARRANJOS............................................................................................................................................ 30 ARRANJOS MULTIDIMENSIONAL................................................................................................... 32 STRING.................................................................................................................................................. 34 REGISTROS E ESTRUTURAS ........................................................................................................... 37 Conjunto de Estruturas ........................................................................................................................... 39 Uniões..................................................................................................................................................... 40 Argumentos argv e argc.......................................................................................................................... 40 PONTEIROS .......................................................................................................................................... 42 Operadores.............................................................................................................................................. 42 MATRIZES E PONTEIROS.................................................................................................................. 44 Streams ................................................................................................................................................... 47 Arquivos ................................................................................................................................................. 47 Referências ............................................................................................................................................. 53

Prof.: Ciro M. Santos

 Programação C / 2005-1

Versão 0.05

Página 2

INTRODUÇÃO
O objetivo desta trabalho é introduzir os conceitos básicos essenciais para um bom habito de programar, utilizando como ferramenta de programação a linguagem de programação C. Criada por Dennis M. Ritchie e Ken Thompson no laboratório Bell em 1972, baseada na linguagem B de Ken Thompson, que era uma evolução da antiga linguagem BCPL. “B” foi nomeada como a primeira letra de BCPL e C como a segunda. Embora o termo linguagem estruturada em blocos não seja rigorosamente aplicável a C, ele é normalmente referida simplesmente como linguagem estruturada. A razão pela qual C não é, tecnicamente, uma linguagem estruturada em blocos, é que essas linguagens permitem que procedimentos e funções sejam declarados dentro de procedimentos e funções. No entanto, como C não permite a criação de funções dentro de funções, não pode ser chamada formalmente de uma linguagem estruturada em blocos. ( Schildt )

CONCEITO
O tipo de um dado determina o conjunto de valores a que uma constante pertence, ou que podem ser assumidos por uma variável, uma expressão ou gerados por uma função. Uma linguagem de programação representa um computador abstrato capaz de interpretar os termos utilizados nesta linguagem, os quais podem englobar um certo nível de abstração em relação aos objetos utilizados pela máquina física (Niklaus Wirth) Tipo Abstrato de Dados é um modelo matemático com um conjunto de operações definidas sobre o modelo. Algoritmo é um procedimento para resolver um problema matemático em um número finito de passos, que freqüentemente envolve repetição de operações. Um algoritmo é um procedimento computacional bem definido que toma alguns valores como entrada e produz alguns valores como saída. Programar é estruturar dados e construir algoritmos. Analisar um algoritmo significa predizer quais recursos o algoritmo vai demandar quando executar. Programa: Forma de comunicação entre o programador e o computador Programas são ‘traduzidos’ através de outros programas “especiais”: para a Linguagem de máquina “ binário” (compiladores e interpretadores.)

Prof.: Ciro M. Santos

 Programação C / 2005-1

Versão 0.05

Página 3

ESTRUTURA BÁSICA DE UM PROGRAMA C
  consiste em uma coleção de funções forma geral
main ( ) { } // primeira função a ser executada // início da função // fim da função

As interpretações abaixo são as mesmas, porem para uma melhor legibilidade vamos adotar a primeira definição para a estrutura de uma função.
main ( ) { } main ( ) { } main() { }

Blocos de Comandos
Blocos de comandos são simplesmente grupos de comandos relacionados que são tratados como uma unidade. Os comandos que constituem um bloco estão logicamente conectados. Um bloco começa e termina com uma chave ( { } ). Um bloco de comando geralmente pode ser interpretado como um programa completo, uma função completa, a parte verdadeira ou falsa de uma condição if-else ou o conteúdo de um laço de repetição.

A FUNÇÃO main ( )
A função main() deve existir em algum lugar do programa e marca o ponto de início da execução do programa. As chaves limitam o corpo da função.  Toda instrução deve ser encerrada por ponto e vírgula ( ; ) Comentários Comandos ( “ /* */ ” “ // “ )     Informação acrescentada ao código para facilitar sua compreensão É ignorado pelo compilador (não faz parte do código objeto) Comentário de Bloco, começa com ( /* ) terminando com ( */ ) Comentários de linha // , começa com ( // ) terminando no final da linha.

A FUNÇÃO printf ( )
A função printf() é uma das funções de I/O ( entrada e saída) que é usada em C. Ela não faz parte da definição da linguagem, mas todos os ambientes de programação que suportam a linguagem de programação C tem uma versão da função printf() definida em suas bibliotecas.   Função de E / S ( definida no cabeçalho padrão de entrada e saída stdio.h ) Uma função pode receber uma informação (argumento)
 Programação C / 2005-1
Versão 0.05 Página 4

Prof.: Ciro M. Santos

Sintaxe:
printf (“expressão de controle”,lista de argumentos);

main ( ) { int x = 2; // declaração de variáveis local a função printf (" O número %d",x); //printf recebe a informação x e //imprime-a na tela como forma de saída. }

OBS.: ( %d ) código de formatação utilizado pela função printf() na impressão dos dados.
Outras utilizações de printf main ( ) { printf ("\r %s está a %d km de Caratinga \n \r ou a %d metros”, “Ipatinga”, 98, 98000); }

Saída: Ipatinga está a 98 km de Caratinga ou a 98000 metros. \ n : é um caractere de controle que indica uma mudança de linha. \ r : é um caractere de controle que indica retorno do cursor ( <enter> ).
main ( ) { printf("a letra %c",’a’ ); //a letra b sera interpretadas como char. printf (" vem antes de %c", ‘b’); }

Saída: a letra a vem antes de b

CARACTERES DE CONTROLE
Código
\n

\r \t \b \“ \ ###BOT_TEXT###

Descrição nova linha retorno do cursor (enter) tabulação ( tab ) retrocesso ( backspace ) aspas Barra Nulo

CÓDIGO DE FORMATAÇÃO
Código %c %x %d %e %f %o %s %u Descrição car c caractere Hexadecimal Decimal Notação científica ponto flutuante Octal cadeia de caracteres (string) Decimal sem sinal
 Programação C / 2005-1
Versão 0.05 Página 5

Prof.: Ciro M. Santos

  um “objeto” que pode assumir diferentes valores es . CONSTANTES E VARIÁVEIS Constantes Constantes referem-se a valores fixos que o programa não pode alterar. Ex: ‘c’. 350). \ n". 8.78).1f printf (" %10.78). 3456. “primeiro programa” Variáveis Uma variável é uma posição nomeada de memória.: Ciro M. Prof. printf (" os alunos são %5d \ n".8 3456. espaço de memória de um certo tipo de dado associado a um nome para referenciar seu conteúdo. que é usada para guardar um valor que pode ser modificado pelo programa. 350).780 \ n".”3456. 350). Santos  Programação C / 2005-1 Versão 0.3f } Saída: 3456.EXPLORANDO A FUNÇÃO printf Tamanho de campos:  É possível estabelecer o tamanho mínimo para a impressão de um campo main ( ) { printf (" os alunos são %2d \ n".05 Página 6 . printf (" os alunos são %4d \ n". } Saída: os alunos são 350 os alunos são 350 os alunos são 350 3 5 3 0 5 3 0 5 0 main ( ) { printf (" %3.  “Objeto” que tem valor fixo e inalterável .

indicando o nome pela qual a área será referenciada (int..05 Página 7 . Ex. // declaração da variável. evento. Idade = 30. main ( ) { int evento = 5.). O Tipo é uma instrução utilizada para reservar uma quantidade de memória para um certo tipo de dado. printf ("O melhor tempo da eliminatória %c". Comece com letras ou sublinhado: seguidos de letras.: int char.25. Declaração de variáveis em um programa na sua forma mais simples:   tipo nome-da-variável. char. idade). int int. printf ("\n do evento %d foi % f".INICIALIZANDO VARIÁVEIS  /* */ A combinação de uma declaração de variáveis com o operador de atribuição. int for. números ou sublinhados ‘'C'’ é sensível ao caso: => peso ¹ Peso ¹ PESO ¹ pESo Não podemos definir um identificador com o mesmo nome que uma palavra chave. tempo).. Santos  Programação C / 2005-1 Versão 0. // inicializando a variável printf (" A idade mínima é : %d".corrida). nome2. } Saída: O melhor tempo da eliminatória A do evento 5 foi 27. . float tempo = 27.. } Saída: A idade mínima é : 30 NOMES DE VARIÁVEIS     Quantos caracteres quiser (até 32). O programa abaixo faz a demonstração de alguns códigos de formatação. tipo nome1.25 main ( ) { int idade.. nomeN. int while.: Ciro M. float. Prof. char corrida = ‘A’.

7e-308 a 1. //o programa escreverá na tela scanf("%d". // saída do programa.7e+308 sem valor tipo char int float double void Modificadores de tipos long int unsigned char unsigned int ( 4 bytes) ( 0 a 255 ) ( 0 a 65.h ) Complemento de printf( ) Sintaxe scanf( “expressão de controle ”.lista de argumentos) expressão de controle : % lista de argumentos : &variável main ( ) { int num.   Função de E / S ( Biblioteca : stdio. Santos  Programação C / 2005-1 Versão 0.4e-38 a 3. printf(" numero digitado foi %d ". &num). mas todos os ambientes de programação que suporta a linguagem de programação C tem uma versão da função scanf() definida em suas bibliotecas.: Ciro M. A FUNÇÃO scanf( ) A função scanf() é uma das funções de I/O ( entrada e saída) que é usada em C.768 a 32.num).: int tem sempre o tamanho da palavra da máquina.05 Página 8 .4e+38 1. Informa a quantidade de memória (bytes).535 ) Obs.TIPOS BÁSICOS   Determina um conjunto de valores e as possíveis operações realizadas sobre os mesmos. } Prof. Bytes 1 2 4 8 0 escala -128 a 127 -32. printf("Digite um número\n").767 3. Ela não faz parte da definição da linguagem.

scanf ( “ % c”. printf(" Digite uma letra\n"). endereço = %u". a.letra). endereço = 1230 CÓDIGO DE FORMATAÇÃO scanf( ) Código %c %d %e %f %o %x %u %s %lf Descrição Caracter Inteiro Número ou notação científica Ponto flutuante Octal Hexadecimal Decimal sem sinal ( endereço de memória) String (cadeia de caracteres) Double /* O programa abaixo relaciona um caracter com o seu valor decimal da tabela ASCII. */ main ( ) { char letra. printf (“ \n %c = %d em decimal”. num = 2. Santos a. num. printf (“%o em octal.OBS. } O OPERADOR DE ENDEREÇO (&)   O nome da variável é associado a um endereço de memória pelo computador Toda variável ocupa uma área de memória e seu endereço é identificado pelo primeiro byte por ela ocupado com o deslocamento do tamanho da variável Quando usamos & precedendo uma variável. scanf ("%c". estamos falando do endereço da mesma na memória main ( ) { int num. Página 9  Programação C / 2005-1 Versão 0. printf ( “digite um caracter” ). : Logo que o usuário atender à mensagem o número será lido pela função scanf(). /* A única diferença do programa abaixo é que uma letra será lida pelo scanf(). } Saída valor = 2. a). a). &letra). printf(" A letra digitada foi %c". sendo que o operador & indicará o endereço de memória da variável indicada. // %d valor decimal e %u é um endereço de memória da variável. &a ).05 . } Prof. printf (" valor = %d. seu valor octal e hexadecimal. &num).: Ciro M. */ main ( ) { char a . %x em hexadecimal”.

divisor. } Saída: entre com 2 números 10 4 o resto da divisão inteira de 10 por 4 = 2   O % como resto da divisão só aceita números inteiros.05 Página 10 . } OPERDORES ARITMÉTICOS   binários: unário: = + * / % main ( ) { int resto. dividendo). Prof. printf(" Digite um caracter: " ) . // impressão do caracter na tela. printf(“por %d = %d”. // % resto da divisão entre dois num.fixado (--x) pós -fixado (x++) ex. printf(“o resto da divisão inteira de %d”. Escreve um caracter na tela a partir da posição atual do cursor. printf(“entre com 2 números”). OPERADORES DE INCREMENTO E DECREMENTO Incrementam / decrementam uma unidade de seu operando. Santos  Programação C / 2005-1 Versão 0.h> /* Função usando getchar e putchar */ void main ( void ) { char ch. após a digitação do caracter. dividendo.: Ciro M. sem a obrigatoriedade de pressionar < enter >. 155 em octal. &divisor). // o caracter está sendo lido do teclado. ou seja.: int n. resto). n = 0. scanf(“ %d %d” .  #include <stdio. resto = dividendo % divisor.   pré . 6d em hexadecimal LENDO E ESCREVENDO CARACTERES getchar( )  putchar() Lê um caracter do teclado. &dividendo. ch = getchar( ).Digitando m: m = 109 em decimal. divisor. putchar(ch).

\n". printf (“ %d %d %d \n”.: (avaliação feita à esquerda) main ( ) { int n. num). i = 3.: ++.  n=0. : i tem valor 3 que somado com 1 no primeiro parêntese será 4 e incrementado no segundo continuará com o valor 4. Saída: 0 1 1 2 PRECEDÊNCIA ++ -* / % + . ++num). n++).(binário) = Ou seja: x = 3 * a++ . num++).b y = 3 * --a .n++.: Ciro M. } num). ++num). saída: 5 6 5 Ex.  Neste caso a variável será primeiramente incrementada. \n". printf (" %d \n".b z = a * b++ = (3 * (a++)) . ++n.só podem ser usados com variáveis inteiras.05 Página 11 . n). n = 1. n + 1. É como se fosse 1 + 0 = 1. n = i * (i + 1) + (++i). num++). logo 3*(4) + (4) = 24. \n".b = a * (b ++) Obs. inicialmente a variável terá valor zero e depois será pós-fixada em 1.num).: n = 5. %d %d %d %d \n". CUIDADO COM printf( ) Ex. Santos  Programação C / 2005-1 Versão 0. n. Saída: n = 24 Prof. printf (" %d \n". n = 0. Saída: 0 0 1 2 main ( ) { int num = printf (" printf (" printf (" printf (" } 0. main( ) { int num = 0.b = (3 * (--a)) . printf (" %d \n". -. printf ("n = %d".num). } OBS. printf (" %d \n".

-=.OPERADORES ARITMÉTICOS DE ATRIBUIÇÃO   +=. falso). /=.h.3. = %d. *=. printf (“Verd. verdadeiro = true.05 Página 12 .*/ #define true = 1 #define false = 0 /* Para que este programa funcione devemos usar a biblioteca stdio. Prof. Valor diferente de zero (0) é verdadeiro. Santos  Programação C / 2005-1 Versão 0. */ main ( ) { int verdadeiro. A sintaxe: x op = exp é equivalente a x = (x) op (exp) Ex. %=. } Saída: Verd. verdadeiro = (15 < 20). 0  falso. = 1 falso = 0 /* Definição de verdadeiro ou falso para um programa. falso. falso = (15 == 20). falso = false. → x = x * (y + 1) x *= y + 1 → t = t / 4 t /= 4 → p = p % 6 p %= 6 → h = h . falso. Quando usamos o comando define estamos definindo que a variável terá um valor que por sua vez será constante. verdadeiro. main ( ) { int verdadeiro.: Ciro M.: i += 2 → i = i + 2. falso = %d”. Atribuir um novo valor à variável dependendo do operador e da expressão a direita. h -= 3  OPERADORES RELACIONAIS  Usados para comparações Operador > >= < <= == !=    Descrição Maior Maior ou igual Menor Menor ou igual Igualdade Diferença Em C não existe o tipo "booleano".

} printf (“Verd. { Prof.05 Página 13 .else. if (ch == ‘p’) // compara o caracter digitado coma letra p. = %d. if. ch = getchar ( ). } MÚLTIPLAS INSTRUÇÕES Estrutura: if } ( condição ) comando 1. falso = %d”. // obtém o caracter digitado. verdadeiro. falso). comando 2. if . Isto é alcançado através dos comandos de decisões disponíveis na linguagem de programação. Santos  Programação C / 2005-1 Versão 0. main ( ) { char ch.++ . printf (" você pressionou a tecla %c ".   Permitir testes com uma variável para decidir qual bloco de comando será executado.* / % + < > <= >= == != && | | = += -= *= /= %= Aritméticos Relacionais Lógico Atribuição COMANDOS DE SELEÇÃO No desenvolvimento de um programa muitas vezes se faz necessário o conhecimento de uma resposta para podermos decidir qual bloco de comando deve ser executado. Saída: Verd.: Ciro M. switch e Operador Condicional Ternário ( ? : ).ch). O COMANDO if Estrutura : if ( condição ) instrução. = 1 falso = 0 Precedência: ! .

*/ main ( ) { char ch.else ANINHADOS Estrutura: if( condição1 ) instrução else if( condição2 ) instrução else if (condicao3) .. Estrutura: if( condição ) { instrução1.: Ciro M. instrução2. //As duas condições têm que ser verdadeiras. if (ch >= ‘A’) //faz o primeiro teste. printf (“ digite uma letra entre A e Z”). // condição // verdadeira } else { instrução3 // condição instrução4 // falso } main ( ) { if (getchar ( ) == ‘c’) printf (" Você digitou c "). } if . nada será feito se a expressão for falsa. //obtém o próximo caracter a ser considerado. if (ch < = ‘Z’) printf (“você digitou uma letra maiúscula”) } /* Aprimorando o programa anterior. se for verdadeiro faz o segundo.05 Página 14 .else   Comando if só executa as instruções que fazem parte do primeiro bloco. else printf (" Você não digitou c"). dizemos que o if interno está aninhado main ( ) { char ch. if (( ch >= 'A')&&(ch <= ' Z')) // && operador lógico and. printf (" Digite uma letra entre A e Z: ").if ANINHADOS  Se um comando if está dentro de outro if. ch = getche ( ). ch = getche ( ). // tem que ser satisfeita. Prof. Comando else executará um bloco de instruções se a expressão de teste for falsa. printf (" Você acertou\n"). caso a condição de teste seja verdadeira. } O COMANDO if .. Santos  Programação C / 2005-1 Versão 0.

scanf (" %d". OPERADORES LÓGICOS  ( && .&numero). if ( numero < 0 ) printf (" número menor que zero\n"). Santos  Programação C / 2005-1 Versão 0.: Ciro M. b.05 Página 15 . descartando assim a possibilidade de relacionamento com o segundo if. printf("Digite um número \n"). }  else é sempre associado ao if mais interno (mais próximo) Note a diferença: /* Neste bloco o comando else está associado ao primeiro if. else if ( numero < 100) printf (" número ³ 10 e < 100 \n") else printf ("“número ³ 100”\n").main ( ) { int numero. pois o if foi fechado antes de else. | |. */ if (n > 0) if (a > z = }else z = { b) a.: (1 || 2) (x && y) (a > 10) && (x < 10) !( x > 0) (10 < = a) && (a < = 100) EXEMPLOS:  if (10 < a) && (a < 100) / * 10 < a < 100 * / Prof. else if ( numero < 10) printf ("“número ³ 0 e < 10\n"). ! ) Comando && || ! Descrição and ( e ) ou ( ou ) not ( não ) Ex.

printf (" Número de dígitos %d".else ao se executar vários testes. car). Santos  Programação C / 2005-1 Versão 0.   if (nota = = 1)  if ( nota ) if (nota = = 0)  if ( !nota ) O COMANDO switch Construções if-else facilitam a escrita de programas que devem escolher uma entre duas alternativas. } Para se formular um pergunta podemos utilizar o unário ! Isto é possível porque na linguagem C ZERO é falso e qualquer valor positivo é verdadeiro. Algumas vezes. } printf ("“Número de caracteres %d". scanf (" % d". int car = 0. Similar ao if . else if ((numero > 0) && (numero printf (" Número > 0 e < else if (( numero >= 10) && printf (" Número > else printf (" Número > } < 10) ) 10"). dig). = 100" ). elas não são de maneira nenhuma elegantes. Prof. C oferece a construção switch. O código pode ficar difícil de ser seguido e confundir até mesmo seu autor num momento futuro. if ( ( c >= ‘0’)&&( c < = ‘9’) ) dig++. Contando caracteres e dígitos de uma frase: main ( ) { char c. &numero). entretanto. o programa necessita escolher uma entre várias alternativas.05 Página 16 . printf("Digite um número:").else com maior flexibilidade e formato limpo.   Forma de substituir o comando if . while ( ( c = getchar ( ) ) != ‘\r’ ) { car++. if( numero < 0 ) printf (" Número menor que zero").: Ciro M.main ( ) { int numero. ( numero < 100) ) = 10 e < 100"). Para estes casos. printf ("Digite uma frase e encerre-a com <enter>\n" ). dig = 0. Embora construções else-if possam executar testes de vários modos.

Você deve usá-lo juntamente com o comando switch.  Causa a saída imediata do bloco em que se encontra. switch ( op ) { case '+ ': printf ("= %f". default: printf ( " Operador inválido"). while ( 1 ) { printf (" Digite um n. break.&op. Santos  Programação C / 2005-1 Versão 0. num 1 + num 2).&num1.num 2). num 1 . break. instruções } /* No programa abaixo o break é usado para forçar uma saída imediata do case ao qual pertence. O comando break pode ser usado em qualquer estrutura C. Quando um break é encontrado em um switch. Prof. case constante2: instruções break. break: case '-':: printf ("= %f". default: //será executado se a opção digitada for inválida.&num2). ( switch ou laço ). } } } O COMANDO break O comando break é um dos comandos de desvio em C. float num 1. */ main ( ) { char op. a segunda opção será executada sem que seja solicitada.ESTRUTURA SWITCH: switch ( expressão ) { case constante1: instruções.: Ciro M. um operador e um n”). obviamente). num 2. Se não colocarmos o break. Quando estiver presente em laços aninhados afetará somente o laço que o contém (e os internos.05 Página 17 . // O break é usado para forçar a saída do case. a execução do programa salta para a linha de código seguinte ao comando switch. scanf ( "%f %c %f ".

} LAÇOS DE REPETIÇÕES Comando de repetições permitem que um conjunto de instruções ( bloco de instruções) seja executado até que ocorra uma certa condição.. Solução 2: Prof. max = num2. resultado. Santos  Programação C / 2005-1 Versão 0.resultado). ( Condição ) ? valor para caso verdadeiro : valor para caso falso . printf (" O valor absoluto do número é :".. ( "2"). : : ("1000").  Os dois exemplos são equivalentes. max = (num1 > num2) ? num1 : num2. : 10 "). scanf ("%d". Saída: 1 2 3 4 . resutado = abs ( ( num < 0 ) ? -num: num ). Note: if else (num1 > num2) max = num1.. printf ("Digite um número \n").&num).. 2 " ). Exemplo: main( ) { int num. Essa condição pode ser predefinida ( como no laço for) ou como o final aberto ( como nos laços while e do-while ) main ( ) { printf printf : printf } (" (" : (" 1 " ).05 Página 18 . 10 Como imprimir os 1000 primeiros números a partir de 1? Solução 1: main ( ) { printf printf : printf } ( "1").: Ciro M.O OPERADOR CONDICIONAL TERNÁRIO (? : )  Forma composta de expressar uma instrução if – else Estrutura.

verdadeiro  continua a execução falso  para a execução  Incremento OU Decremento: define como a variável de controle será alterada para que o laço seja finalizado é sempre executada após execução do corpo do laço Laço for Estrutura: for(inicialização . a inicialização é. i++) printf ("%d". Santos  Programação C / 2005-1 Versão 0. incremento/decremento ) instrução. for (i = 1. O Incremento/Decremento define como a variável de controle do laço varia cada vez que o laço é repetido. O teste é uma expressão relacional que determina quando o laço acaba. // corpo do laço } { O laço for permite muitas variações. while. //Nesta linha ocorre a predefinição do //laço. número).05 Página 19 . um comando de atribuição que é usado para colocar um valor na variável de controle do laço. geralmente. número < 10.  Teste: condição que controla a execução do laço. teste . printf (" %d". é sempre avaliada a cada execução.main ( ) { int i. i < 1000. sempre executada uma única vez.i).: Ciro M. sendo que a condição //de parada é i > 1000. } número += 2 ) Saída: 2 4 6 8 Prof. }  for. for ( número = 2. IMPRIMINDO NÚMEROS PARES main ( ) { int número. Entretanto. do-while Estrutura de Repetição:  Inicialização: expressão de atribuição.

.i++) printf ("%d letra = %c ascii = %d \n". for (i = 1. x++. */ main ( ){ char ch. ch <= ‘z’. ) Reescrevendo o exemplo anterior: Prof. (x + y) <= 100. b = c e assim sucessivamente. permanecendo apenas os ( . Santos  Programação C / 2005-1 Versão 0. ch++. y. main ( ) { int x. /* Neste laço for os caracteres digitados são lidos. int i. printf ("%c". y = 0.ch. } Frase digitada : analise do problema em questão Saída: b o b m j t f ! e p ! q s p c m f n b ! f n ! r v f t u b p OBS. y++) printf ("%d". ch + 1). */ main ( ) { char ch.ch=getch()) // A função getch() lê o caracter do teclado e não imprime na tela.FLEXIBILIDADE Qualquer expressão de um laço for pode conter várias instruções separadas por vírgula. ch!= ‘x’.: Ciro M. x + y). ao mesmo tempo que são testados verificando se são diferentes de x e incrementados no printf  ch + 1.: Qualquer uma das 3 expressões pode ser omitida. de forma que a = b. } Ex.: /* imprime as letras do alfabeto.i. OBS. 0 1 2 3 4 5 letra = a ascii = 97 letra = b ascii = 98 letra = c ascii = 99 letra = d ascii = 100 letra = e ascii = 101 letra = f ascii = 102 : : : 25 letra = z ascii = 122 Note o uso de funções nas expressões do laço. for (x = 0. ch = ‘a’. printf( " Digite uma frase\n").: Os caracteres digitados foram somados com um ( 1 ). for (ch = getchar( ). }  Saída: ascii = número da letra correspondente na tabela ASCII.05 Página 20 .ch).

for (i = 1. if ( i == 100 ) break. } Prof. for ( . i < 100 .main ( ) { char ch. } main ( ) { int i=0. j++) printf ("%d %d \n". i ). i ).. . printf (" %c". (ch = getchar ( ). i < 100. } Saída: 0 1 2 3 4.05 Página 21 .. j. i++. ) printf (“\n estou } em loop infinito”). i++ ) printf ("%d".: Ciro M. Santos  Programação C / 2005-1 Versão 0. i.)!=‘x’. for ( . i ). for ( . printf(" Digite uma frase\n"). i++) for (j = 1. main ( ) { int i. } CUIDADO Se a expressão de teste não estiver presente é considerada sempre verdadeira. . } LAÇOS ANINHADOS  Quando um laço está dentro de outro. i <= 3. i++. main ( ) { for ( . ch + 1). j). ){ printf (" %d". for ( i = 0. dizemos que o laço interior está aninhado main ( ) { int i.99 main ( ) { int i. j < = 2. ){ printf (" %d".

printf ( " Digite uma frase: \n"). sendo conhecido o inicio e o fim do laço. */ main ( ) { int cont = 0. cont). while:  não se sabe a princípio o número de iterações.  número de repetições é fixo. A expressão de teste pode ser qualquer expressão. inc / dec } Onde a instrução pode ser uma instrução simples ou um bloco de instruções. cont++.: O corpo de um while pode ter:    uma única instrução. Santos . while (getchar( ) != ‘\r’) //Os caracteres serão lidos até //que < enter > seja pressionado. Quando a expressão de teste for falsa. }  Programação C / 2005-1 Versão 0. /* Contar o número de caracteres de uma frase até que <enter> seja digitado.: Obs.num++). //saída do programa e inc da variável } Ex. printf("%d". num = 0.  o laço pode terminar inesperadamente. sendo considerado verdadeiro qualquer valor diferente de zero.: Ciro M.   “Instrução” só é executada se “expressão de teste” for verdadeira ( != 0 ) Expressão é sempre avaliada até que se torne falsa ( = 0) main ( ) { int num. várias instruções entre chaves e nenhuma instrução.05 Página 22 Prof. WHILE X FOR for:  Geralmente este laço é muito estável. o controle do programa passa para a linha após o código do laço. while (num < 3) //enquanto o num for menor que 3 o laço se repetirá. printf ("“\n O número de caracteres é %d".O LAÇO WHILE Estrutura do laço while : Inicio while ( expressão de teste ) { instrução.  Muito útil para controle de vetor e matriz. O laço se repete quando a condição for verdeira.

printf (" Acertou em %d vezes\n". c). tentativas++. }while( getchar( )== ‘s’). c). char continua = s. continua = getche( ). } } /* A função getche() lê o caracter do teclado e permite que seja impresso na tela. scanf (" %d". vezes). vezes = 1. Executa o laço (pelo menos uma vez) mesmo que a condição seja falsa. / * O programa abaixo testa a capacidade de adivinhar uma letra */ main ( ) { char ch. Similar ao laço while ( a diferença está no momento em que a condição é avaliada ). int tentativas. } printf (" \n Acertou em %d tentativa(s) ". } Prof. Whiles dentro de um laço while ( laço aninhado ) main ( ) { int num. printf(" Tente novamente \n" ). Estrutura: inicio do { instrução. scanf ("%d". printf ( " Tente novamente \n"”).". printf (" \n Joga novamente? (s / n):”" ). printf ("Continua? (s / n):"”). }while(expressão de teste). Evita duplicação de código. inc/dec . while ( (ch = getchar ( ) ) != ‘t’) { printf (“"%c é incorreto \n”". vezes++. */ O LAÇO do-while     Cria um ciclo repetitivo até que a expressão seja falsa (zero). Santos  Programação C / 2005-1 Versão 0.’ while (continua == s ) { printf ("\n Digite um número entre 1 e 1000" ). &num). do { printf (" Digite uma letra”\n").: Ciro M.05 Página 23 . while (num != 50) { printf ("%d incorreto. &num). } printf (" %c é correto". tentativas). num). tentativas = 1.

podendo ser qualquer tipo válido. printf(“ %u”. pois dificulta a legibilidade de um programa. /* O programa abaixo relaciona os comandos: continue. O tipo-de-retorno especifica o tipo do valor que o comando retorn da função devolve. if ( i == 15 ) exit(1). for(i = 0. Se nenhum tipo é especificado.h> void main( void) { int i. A lista de parâmetros é uma lista de nomes de variáveis separados por vírgula e seuss tipos associados que recebem os valores dos argumentos quando a função é chamada. */ #include <stdio. forçando um retorno ao sistema operacional. i++) { if ( i < 4 ) continue. Quando a função não tem parâmetro. i). Santos  Programação C / 2005-1 Versão 0. o compilador cria armazenamento permanente para ela.: Ciro M. continue força que ocorra a próxima iteração do laço. } } FUNÇÕES / MÓDULOS / SUB-ROTINAS Funções são os blocos de construção de C.O COMANDO continue O comando continue trabalha de uma forma um pouco parecida com a do comando break. break e exit( ). Deve-se evitar o comando Continue. pulando qualquer código intermediário ou imediatamente abaixo. Essa função provoca uma terminação imediata do programa inteiro.05 Página 24 . Variáveis Locais static Quando o modificador static é aplicado a uma variável local ( ou declarada dentro de uma função ). i < 100. Em vez de forçar a terminação. if ( i == 20 ) break. Prof. o compilador assume que a função devolve um resultado inteiro. os parênteses ainda são necessários. A Função exit() A função exit() está definida na biblioteca padrão do C.

{ corpo da função } EM C UM PROCEDIMENTO É FEITO ATRAVÉS DE UMA FUNÇÃO SEM RETORNO “Funções” que não retornam valores void desenha( ) { int i. fatorial(3) ).Variáveis Globais static Aplicar o especificado static a uma variável global informa ao compilador para criar uma variável global que é reconhecida apenas no arquivo no qual a mesma foi declarada. return resultado. } Prof. printf (“ \n usando funções”). for (i = 0. Santos  Programação C / 2005-1 Versão 0.. permitindo esconder detalhes de implementação Evita-se a repetição de um mesmo código Estrutura: tipo_de_retorno nome(lista de parâmetros ex. var2 . ) tipo var1. */ int fatorial (int n){ int i. fatorial(4) ). resultado = 1. i < = 10. i ++) resultado *= i. } main ( ) { printf (“ o fatorial de 4 = %d”. tipo var2. desenha ( ).: Ciro M. rotinas em outros arquivos não podem reconhecê-la.    Funções : abstrações de expressões ( Modulo ) Dividir uma tarefa complexa em tarefas menores. // resultado = resultado * i... tipo var2.05 Página 25 . for ( i = 1. printf (“ o fatorial de 3 = %d”. desenha(). muito embora a variável seja global. i <= n. Isso significa que. tipo var1.) { corpo da função } tipo_de_retorno nome (lista de parâmetros ex. } i++) main ( ) { desenha ( ). printf (“ usando funções”). } FUNÇÕES /* A função abaixo calcula o fatorial de um número retornando o resultado. var1. printf (“-”).

i = 0. i = 5. void desenha ( ) int j. .‘A’). Forçando o retorno imediato ao ponto de chamada da função Exemplo /* Esta função retorna um caracter.VARIÁVEIS LOCAIS   Ex. . . . ch = getchar( ). */ char minúsculo ( ) { char ch.: Ciro M. . . .: 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 (automaticamente) void desenha ( ) { int a. desenha(). . else return (ch). i. .05 Página 26 . } Prof. . Santos  Programação C / 2005-1 Versão 0.  erro . } { O COMANDO return   Causa a atribuição da expressão a função. . . . a = i. if ( (ch >= ‘A’) && (ch <= ‘Z’)) return (ch + ‘a’ . } main ( ) { int a. . } VARIÁVEL GLOBAL  Variável que é declarada externamente podendo ser acessada por qualquer função int i. } void calcula ( ) { int m.

. printf ("%d". minúsculo (‘A’) ). } main ( ) { int num. b = abs (num).05 Página 27 .. printf (" Entre com um número "). } Prof.. b = abs(-3).uma cópia do argumento é passada para a função parâmetro se comporta como uma variável local Valor Absoluto /* Retornando o valor absoluta de um número */ int abs (int x) { return ( ( x < 0 ) ? -x : x ). else return (ch).b). printf (" Valor absoluto de num = %d".. Santos  Programação C / 2005-1 Versão 0. } PASSANDO DADOS PARA FUNÇÕES   Ex.: char minúsculo (char ch)  parâmetro formal { If (( ch >= ‘A’) (ch <= ‘Z’)) return (ch + ‘a’ . b.main ( ) { char letra.: Ciro M. parâmetro real } Exemplo. b ). } main ( ) { printf (“ %c”. Passagem de parâmetro por valor . letra = minúsculo ( ). &num ). scanf (" %d". ‘A’). printf (“ digite uma letra em minúsculo”). if (letra == ‘a’) // if (minúsculo( ) == ‘a’) printf (“ok”).

termos)).. + xn/ n! Solução: int fat(int n) { int i. } USANDO VÁRIAS FUNÇÕES Calcular a seguinte seqüência: S(x. for ( i = 1. for (i = 1. void main( ) { float x. float resultado = 1.PASSANDO VÁRIOS ARGUMENTOS   Freqüentemente uma função necessita de mais de uma informação para produzir um resultado Podemos passar para a função mais de um argumento Ex. int expoente) { int i. int expoente) { int i.05 Página 28 . scanf("%d". for (i = 1. printf(" Entre com o valor de X: ").x). } Prof. resultado *= i. &termos). if (expoente == 0) return 1. 1: float area_retangulo (float largura. float return (largura * altura). scanf(" %f”" . n) = x/1! + x2/2! + x3/3! + . printf(" O valor de série = %f". } / fat( i ). float resultado = 0. If (expoente == 0) return 1. Santos  Programação C / 2005-1 Versão 0. i <= expoente. return resultado. //x é o valor da base . i <= n. } float serie (float x. } altura){ Ex. for ( i = 1. i++) resultado *= base return resultado. i++) resultado *= base.: Ciro M. printf(" Entre com o numero de termos: "). int n) { int i. i <= expoente. int termos. } i ++) float potência (float base. 2: float potência (float base. i++) resultado += potência( x. float resultado = 1. return resultado.. resultado = 1. serie(x. i <= n. i ) return resultado.

05 Página 29 . A função é recursiva se um comando no corpo da função chama a própria função..: Ciro M. }  O exemplo abaixo demonstra uma recorrência que também é recursiva. sabendo a solução para um problema pequeno. Vários problemas já são recursivos naturalmente. isto nos informa que a tarefa de resolver a sequência foi dividida em problemas menores dentro das funções. sendo resolvida de forma mais simplificada. else return fat(n-1) * n. int fat( int n ) { if (n == 1) return 1. Note: Uma mesma função pode ser chamada várias vezes para resolver diversos problemas..... O problema do fatorial também pode ser utilizado para demonstrar a recursividade como segue: fat(0) = 1 fat(n) = n (fat(n-1)) para n > 0 0! = 1 1! = 1 * 0! 2! = 2 * 1! 3! = 3 * 2! 4! = 4 * 3! 5! = 5 * 4! . algumas vezes. o ato de recursividade é transformar um problema grande em um problema pequeno para que o mesmo seja resolvido através da solução do problema pequeno. chamado de definição circular.. Recursão é o processo de definir algo em termos de si mesmo e é.OBS. A idéia por trás da recursividade está em pegar um problema inicialmente grande. Santos  Programação C / 2005-1 Versão 0. t(1) = 1 t(n) = 2 t(n-1) + 3n + 1 t(1) = 1 t(2) = 2 * t(1) + 3 * 2 + 1 t(3) = 2 * t(2) + 3 * 3 + 1 t(4) = 2 * t(3) + 3 * 4 + 1 .: No programa acima relacionado vemos a dependência entre as funções. RECURSIVIDADE A Recursividade é o ato da função chamar a si mesma com a finalidade de resolver determinado problema. Então percebemos que a função facilita nosso trabalho. para n > 1 int t( int n ) { if (n == 1) Prof.

&j).  Programação C / 2005-1 Versão 0. (nota0 + nota1 + nota2) / 3)). main() { } int j. : : : printf(“média = %f”. 1.: Ciro M. printf("“Digite um numero: "). Ex. Um elemento específico em uma matriz é acessado por meio de índice.: Ler a nota de 3 alunos e calcular a média int nota0.: tamanho n  índice 0 a (n . também conhecido como Vetor ou várias dimensões. else return 2* t(n-1) + (3 * n) + 1. 3 ) Inicializando Arranjos  Considere uma variável inteira numero  Podemos inicializar a variável numero:  int numero = 0. Em C.  Vetor de inteiros nota [ 0 ].} return 1. scanf("%d". printf(" A série de = %d e’ %d". todos os arranjos consistem em posições contínuas na memória. Santos .j . ARRANJOS Um Arranjo é uma coleção de variáveis do mesmo tipo que é referenciado por um nome comum.05 Página 30 Prof.j .1) ou ( 0 .  Arranjos:   Unidimensional (VETOR) N-dimensional (MATRIZ)  Informalmente:  Cada variável é diferenciada por um índice int nota [ 4 ]. 2. ou matriz. nota1. nota [ 1 ]. Um conjunto pode ser composto de uma dimensão. f t(j)). t( j)). ao último elemento. nota [ 2 ]. nota[ 3 ] Obs. nota2. &notai ). scanf(“%d”. printf(“entre com a i nota”). O endereço mais baixo corresponde ao primeiro elemento e o mais alto. printf(" O fatorial de = %d e’ %d ".

para que a numeração das notas não inicie com zero (0). notas[1] = 0 . &notas [ i ] ). i++ ) notas [ i ] = 0.. notas [0] = 50. podemos inicializá-lo:     int notas[5] = {0.0} int notas[] = {0} notas[0] = 0..0. */ /* Calcula a média das notas dos alunos.nota n. scanf (" %d ". &notas[ i ]).: Ciro M. } Obs. */ float media( ) { float media. */ void inicializa() for ( i = 0. Santos  Programação C / 2005-1 Versão 0. Ex. i < N_ALUNOS... evitando resultados indesejados.: Dado int notas [10] podemos fazer:    notas [9] = 5.. for ( i = 0 . i++) { notas[i] = 0. scanf ("%d".0. i < 5. i < N_ALUNOS. #define N_ALUNOS 40 int i. as demais posições do vetor contêm “lixo” Programa utilizado para cálculo da média de no máximo 40 alunos. colocando nestas posições o zero (0). float notas[N_ALUNOS]. */ void limpeza( ) { for ( i = 0. %f ".  numero = 0. printf (" scanf (" } } { i < N_ALUNOS.0. &numero). i+1).. i++ ) { media += notas [ i ]. } return (media / N_ALUNOS).: nota 1. for ( i = 0. } /* Inicializa o vetor com os números digitados pelo usuário. nota 2. /* i+1. Prof. i++ ) { Entre com a nota %d ".05 Página 31 . // ou printf(" Digite uma nota para inicialização"). /* Removendo os conteúdos inválidos das posições indicadas de memória. notas [4] = 0.  Dado um arranjo int notas[5].

i++) { printf ("Entre com a nota %d". media = 0. i < quantidade. &quantidade).  Solução: declarar um arranjo que suporte um número máximo de elementos. media()).&notas[i]). float notas [ TAMANHO ]. scanf("%d". #define TAMANHO 100 main( ) { int quantidade. // quantidade deve ser TAMANHO printf (" Quantas notas devo ler ?”"). i++) media += notas [ i ]. } : : : for ( i = 0.  tamanho de um arranjo tem que ser determinado em tempo de compilação. Prof. i < quantidade.: Ciro M. Nada impede o acesso além do fim do arranjo faça sempre que necessário a verificação dos limites ARRANJOS MULTIDIMENSIONAL Um arranjo multidimensional consiste em um arranjo de linhas e colunas. for ( i = 0.05 Página 32 . inicializa(). notas[i] ).i+1). i++ ) { printf (" %d". imprime(). } : : : RESULTADOS IMPREVISÍVEIS   C não realiza verificação de limites em arranjos. Santos  Programação C / 2005-1 Versão 0. } /* PROGRAMA PRINCIPAL */ main( ) { limpeza(). scanf("%d". printf ("\n Média = %f } \n". #define coluna 4. 0 1 5 9 1 2 6 10 2 3 7 11 3 4 8 12 #define linha 3.} void imprime() { for ( i = 0. i < N_ALUNOS.

i++ ) { printf (“linha = %d”. . . scanf (“%d”. j++) { printf (“coluna = %d”.0}} nota[0][0] = 0.. Prof.0.0. Uma outra forma de inicilizá-las de maneira mais eficiente é usando laços for : for(i = 0. Uma das maneiras de inicializá-las..{0..    int nota[3][4] = {{0. j++ ) nota[i][j] = 0.  interpretação :  temos 3 linha e 4 colunas. nota[0][3] = 0. . j+1).i+1). Santos  Programação C / 2005-1 Versão 0.int matéria [ linha ] [ coluna ].0}.. matéria[i][j]).  temos 3 vetores de tamanho 4  Agora temos : int i. for ( i = 0 .05 Página 33 . nota[2][3] = 0. for (j = 0. } } Inicializando Matrizes dado: #define linhas 3 #define colunas 4 int nota [linhas][colunas]. j. j < coluna... i < linha.0. i++ ) for(j = 0. matéria [ linha ] [ coluna ].i < linhas..: Ciro M. : : : nota[2][0] = 0.0. j < colunas.

 é uma seqüência de caracteres delimitada por aspas duplas. Variável String   matriz do tipo char terminada pelo caractere null ‘###BOT_TEXT###. } Saída: Digite seu nome: Ciro Gomes Bom dia Ciro  Prof..: Ciro M. Este tipo é definido através da utilização de um vetor de caractere.'x'. printf(“Bom dia %s”. &nome[0]). printf ( "%s". Lendo Strings  scanf ()  lê o string até que um espaço em branco seja encontrado. main ( ) { char nome[40]. Ex. com um caractere especial “ ###BOT_TEXT### nulo “ indicando o final deste vetor. printf("%s".'p'. for( i = 0.'o'. cada caractere de um string pode ser acessado individualmente.: printf("Isto é um teste"). printf(“Digite seu nome: “).'e'. Santos  Programação C / 2005-1 Versão 0.: char string[10] = "exemplo".nome ). OBS. você precisa declarar matrizes de caracteres como sendo um caractere mais longo e de maior string necessária.STRING A linguagem de programação C não existe um tipo de dados string. i++) printf ( "%c".'###BOT_TEXT###'}. scanf(“%s”. Ex. Um valor nulo é especificado como “###BOT_TEXT###” e geralmente é zero. i < 10. char string[10] = {"exemplo"}.'m'.'l'.”Isto é um teste”).05 Página 34 . char string[10] = {'e'. Por esta razão. string [i]). string ).:  visto pelo compilador: “" Isto é um teste###BOT_TEXT###"”  '###BOT_TEXT###'’ ( null ) = '0'’  ‘'###BOT_TEXT###'’indica para as funções o fim de um string.

: Ciro M. puts ( nome ). gets(&nome[0]) = gets(nome) scanf("%s".nome[0]) puts(&nome[0]) = puts(nome) Prof.. printf ( “Digite seu nome: “ ).   gets() lê caracteres até encontrar ‘'\n'. } Saída: Digite seu nome: Ciro Gomes Bom dia Ciro Gomes Lembre-se  Sempre que uma função espera receber um apontador podemos passar:  o endereço da primeira posição do vetor/matriz  o próprio vetor/matriz Exemplo: Observe as equivalências. Exemplo: main ( ) { char nome[40].nome).: main ( ) { char nome[40]. printf ("Bom dia %s !". nome[0]) = scanf("%s". } Saída: Digite seu nome: Ciro Gomes Bom dia Ciro Gomes! Imprimindo Strings  printf()  puts()   complemento de gets() puts() imprime uma única string por vez e cada string impressa por ele termina com um caracter de nova linha ( \n ). Ex. puts ( “Bom dia ” ). gets ( &nome[ 0 ] ).05 Página 35 . gets(&nome[0]).’ substitui ‘'\n'’ '###BOT_TEXT###'. Santos  Programação C / 2005-1 Versão 0. printf("Digite seu nome \n").  é a função ideal para ler um string. char nome[40].

: Ciro M. sobrenome[30] ="Gomes".&nome[0]). printf ("Tamanho = %d".sobrenome). printf (" %s \n".nome). printf ("%s\n". Ex.s2) Copia s2 em s1. strcmp(s1.não conta '###BOT_TEXT###'. strlen(nome) ). strcpy(s1.s2) Retorna 0 se s1 e s2 são iguais. gets (&nome[0]). printf (" %s \n".s2) Retorna um ponteiro para a primeira ocorrência de s2 em s1. strncmp(s1. puts (nome). } Saída: Ciro Gomes Prof. gets ( nome ). menor que 0 se s1 < s2. o tamanho de s1 teem que ser suficiente para ele e para s2.: main ( ) { char nome[40].s2) Concatena s2 no final de s1.s2. strchr(s1. } Saída: Digite seu nome: Ciro Gomes Tamanho = 10  strcat(s1.s2)  concatena s2 ao final de s1.  strlen(s1)  retorna o tamanho do string . s1.: ch = 1 caracter. porém a comparação é feita a partir de n em s1.main ( ) { char nome[40]. &nome[3]). OBS. Procura uma letra em uma palavra.ch) Retorna um ponteiro para a primeira ocorrência de ch em s1. printf ("Digite seu nome: "). } FUNÇÕES DE MANIPULAÇÃO DE STRINGS Função Descrição strlen(s1) Retorna o tamanho de s1. strcat(nome.05 Página 36 . strstr(s1. Procura uma palavra em uma frase. ou seja. s2 e n são strings.: main ( ) { char nome[40]="Ciro ". strcat(s1. Santos  Programação C / 2005-1 Versão 0. maior que 0 se s1 > s2. printf ("Digite seu nome:" ).n) igual strcmp. Ex.  dado s1 + s2 tem que caber em s1 + ###BOT_TEXT###.

/* Mostrando o uso de Estrutura. strcmp ( s1. As variáveis que compreendem a estrutura são chamadas membros ou atributos da estrutura. Santos  Programação C / 2005-1 Versão 0. mas de tipos diferentes. sobrenome[30] = "Gomes". Endereço.  0 se s1 = s2. Uma estrutura é uma coleção de variáveis referenciadas por um nome. int idade. int idade. s2 )  Compara dois strings retornando:  negativo se s1 < s2. char CPF[15]. CPF. char cidade[15]. Estrutura .: Ciro M. char endereço[30]. char endereço[30].  positivo se s1 > s2. // var_estrutura é do tipo nome-estrutura. }. char cidade[15].  a comparação é feita por ordem alfabética . struct nome_estrutura { char nome[30]. um aluno pode ser identificado pelo Nome.sobrenome )) puts ("Os strings são diferentes" ).05 Página 37 . Uma definição de estrutura forma um modelo que pode ser usado para criar variáveis de estruturas. Identidade. fornecendo uma maneira conveniente de se ter informações relacionadas agrupadas.. }var_estrutura . char CPF[15]. Prof. etc. main ( ) { char nome[40] = "Ciro". precisa-se de atributos que identifique um aluno. OUTRA FORMA DE DECLARAÇÃO DE ESTRTURA struct nome_estrutura { char nome[30]. } REGISTROS E ESTRUTURAS Registros são conjunto de dados logicamente relacionados. Uma ficha de cadastro de aluno. */ // Definindo o tipo de dado. if (strcmp(nome. else puts (" Os strings são idênticos " ). criando uma variável do tipo estrutura struct nome_estrutura var_estrutura.

idade).&var_estrutura. puts(var_estrutura. Nome_estrutura identifica essa estrutura de dados e Var_estrutura é a variável do tipo Nome_estrutura.ende. puts(var_estrutura. printf("\n Digite idade"). fflush(stdin).: Ciro M. printf("\n Digite nome do bairro"). gets(var_estrutura. " operador de estrutura faz a conexão entre o nome da estrutura e o nome do membro.numero). printf("%d".numero). puts(var_estrutura. gets(var_estrutura.var_estrutura. int idade.&var_estrutura.ende. printf("\n Digite numero da casa").h> struct tipo_endereco { char rua[20]. puts(var_estrutura. gets(var_estrutura.cpf). char CPF[15]. }.var_estrutura. printf("\n Digite nome da rua"). /* " . Santos  Programação C / 2005-1 Versão 0. printf("%d".ende. } var_estrutura .ende. } Prof. //ende é uma var do tipo tipo_endereço. #include <stdio.bairro).: var_estrutura. fflush(stdin).rua). char cidade[15]. struct nome_estrutura { char nome[30]. // imprimir as informações. printf("Digite numero do CPF").idade). Ex.nome.ende.rua). scanf("%d".ende. gets(var_estrutura.nome). char bairro[20]. int numero.Note que a declaração termina com um ponto e virgula( .cpf). struct tipo_endereco ende .05 Página 38 .bairro). char CEP[9]. scanf("%d". ).nome). char estado [2].   nome da estrutura nome do membro da estrutura */ void main( void ) { // ler as informações printf("\n Digite seu nome").

}. Para declarar um vetor de estruturas com 500 elementos do tipo nome_estrutura. printf("\n Digite numero da casa").cpf).: Ciro M. printf("\n Digite idade"). i < lim. você deve primeiro definir uma estrutura e. for(i=0.ende. char estado [2]. Para declarar um vetor de estruturas.cpf). gets(var_estrutura[i]. /* No programa abaixo teremos um laço for que será responsável pela repetição de todas as informações contidas neste bloco. i++) { puts(var_estrutura[i].bairro). puts(var_estrutura[i]. printf("\n Digite nome do bairro").var_estrutura[i].h> #define lim 2 struct tipo_endereco { char rua[20]. struct nome_estrutura regs[500] #include <stdio.ende. } } Prof.rua).i < lim.i++) { // ler as informações printf("\n Digite seu nome").rua). gets(var_estrutura[i]. }var_estrutura[lim]. printf("Digite numero do CPF"). struct nome_estrutura { char nome[30]. gets(var_estrutura[i]. char bairro[20]. char CEP[9]. printf("\n Digite nome da rua"). char CPF[15]. char cidade[15]. Santos  Programação C / 2005-1 Versão 0. fflush(stdin).ende. scanf("%d".numero).&var_estrutura[i]. struct tipo_endereco int idade.Conjunto de Estruturas Talvez o uso mais comum de estruturas seja em vetor de estruturas. printf("%d". int numero. ende. scanf("%d". */ void main( void ) { int i.nome).idade). puts(var_estrutura[i]. gets(var_estrutura[i].ende. então declarar uma variável vetor desse tipo. puts(var_estrutura[i].numero).bairro).var_estrutura[i].&var_estrutura[i]. for( i = 0. printf("%d". fflush(stdin).05 Página 39 .nome).ende.idade).ende. } // imprimir as informações.

resolveremos nosso problema. Exemplo: union data { int dia.argv[0].sizeof(d)).mes). pois o próprio programa já é considerado um argumento pelo O. d.d. d.d.05 Página 40 .Uniões Imaginemos um caso onde tenhamos um programa muito grande em que precisaremos executá-lo sem que possamos fazer qualquer redução em suas estruturas. /* O número mínimo de argumentos que o programa abaixo aceitára será dois: 1 é o próprio programa executável e o outro é o arquivo solicitado. int mes. char **argv ) { int x. // a função atoi tranforma um caracter em inteiro para multiplicar por 5. printf(" Comando = %s Valor = %d". #include <stdio. exit(1).x).h> void main(int argc. } Argumentos argv e argc   argc : Tem o número de argumentos contidos nas linha de comando ( necessariamente maior ou igual a um. argv : É um ponteiro que acomodará os caracteres digitados. Caso pudermos usar o mesmo local de memória para armazenarmos duas variáveis distintas. printf(“%d\n”. if ( argc != 2 ) { printf("\n Este comando reg tem 2 parâmetro:").). Santos  Programação C / 2005-1 Versão 0. printf(“%d\n”.S.: Ciro M.h> #include <stdlib. } Prof. } x = atoi(argv[1]) * 5. printf(“%d\n”. int ano.dia = 30.mes = 3. main() { union data d. } .dia).

printf(“ Digite seu nome \n”). Prof.nome \n”). #include “stdio. Santos  Programação C / 2005-1 Versão 0.h” main( int argc. } Exemplo 2: Este programa recebe 2 parametro o nome e uma senha. if (arg != 2) { printf(“Digite o Nome do Arquivo e a senha \n”). exit(1). } if ( !strcmp(“spep”.: Ciro M. } esle { printf(“ Senha INCORRETA \n”). printf(“ Você esta autorizado a utilizar este programa \n”). printf(“ Você NÃO esta autorizado a utilizar este sist\n”).argv[1]) { printf(“ Senha correta \n”).Exemplo 1: Este programa recebe 2 parâmetro de linha de comando um nome e um valor e escreve na tela o nome e o valor multiplicado por 5.05 Página 41 . scanf(“%s”.nome) printf(“ Obrigado %s por utilizar nosso sistema “. char *argv ) { char nome[10]. exit(1). exit(1).

segundo: Eles são usados para suportar as rotinas de alocação dinâmica de C.. /* 100 */ } Prof. isto é. de mesmo símbolo.. Se uma variável contém o endereço de outra. Santos  Programação C / 2005-1 Versão 0. Atribui o endereço de uma variável para um ponteiro.: Ciro M. val. * ( asterisco ) que acessa o conteúdo de uma variável. val = *pont. cont. são variáveis que contém um endereço de memória. e terceiro: O uso de ponteiros pode aumentar a eficiência de certas rotinas Ponteiros são endereços. então a primeira (o ponteiro) aponta para a segunda. Exemplos . printf(“%d”.05 Página 42 .. cujo endereço é o valor do ponteiro. Devolve o valor endereçado pelo ponteiro. cont = 100. Há três razões para isso: Primeiro: Os ponteiro fornecem os meios pelos quais as funções podem modificar seus argumentos. “ pt ” o “ponteiro” aponta para o “inteiro” x Operadores & ( i comercial ) que fornece o endereço de determinada variável. pont = &cont. main() { int *pont.val).PONTEIROS O correto entendimento e uso de ponteiro é crítico para uma programação bem sucedida em C.. Não confundir com o operador aritmético de multiplicação de mesmo símbolo. Não confundir com o operador lógico de operações de baixo nível.

05 Página 43 . a endereço 100 x endereços 101 / 102    q++  q “ apontará ” para o endereço 101 p++  p “ apontará ” para o endereço 103 incrementa um tipo (*p)++  incrementa o conteúdo do endereço apontado por p. px = &x. char a.*p. int *p. pk = &k. *pk = i. p = &a.. Prof. pi = &i. *pi. y. pois recebe o conteúdo de x . *pk.main() { char a. *p = b. k). sendo que seu resultado depende do tipo de variável apontada pelo ponteiro.x. /* y vale 100. } /* c */ main() { int x. k. a.CONCEITOS DE ENDEREÇOS Aritmética de Ponteiros São válidas as operações de soma e subtração. se q = &a. através do ponteiro py */ printf(“%d %d”. } #include “stdio. printf(“para k = *pi.a).h” main() { int i. i = 2. Supondo que . puts(“Qual será o valor de k? “). y ).. k = *pi.*py.: Ciro M. p = &x. /* px tem o endereco de x */ py = px... } PONTEIROS . printf(“%c”. temos k= %d\n”.b. temos k= %d\n”. k = 0. printf(“para *pk = i. b = ‘c’. /* py tem o endereco de x */ y = *py. e ainda que . x = 100. char *q.*px. Santos  Programação C / 2005-1 Versão 0. x.k).

i++) printf(“%d %d %d \n ”. main() { int i. ( pc = c ) #2345 float f.. O acesso aos elementos da matriz é mais rápido quando feito através de endereços do que seria caso fosse executado pela maneira convencional... conforme visto a seguir: Prof.vet[5]. ( pf = f ) #2350 Supondo ainda que pi. ponteiros permitem apenas as operações de soma e subtração. 50}. Supondo que: int i. pc e pf apontem para i. passamos para a função chamada o endereço desta variável (passagem de parâmetro por referência). *pf. Se pc = pc + 1. c e f que estariam com os seguintes endereços: 2340.. *pc. vet. i++) { printf(“Digite o %d elemento”. matriz nada mais é que um conjunto de variáveis do mesmo tipo. i<4. p[i].*p.*(p+i)). Quando somente precisamos do valor da variável e não pretendemos alterá-lo na rotina (passagem de parâmetro por valor). 40. MATRIZES E PONTEIROS Em C você pode indexar um ponteiro como se este fosse uma matriz! Exemplo .&vet[i]). porém expressões que envolvam cálculos para se obter um elemento específico da matriz devem ser feitas preferencialmente pelo método convencional. então pi valerá 2342 . ( pi = i ) #2340 char c. então pc valerá 2346. i++) printf(“%d %d \n ”. 20.*p. i<5.Este conceito é particularmente importante no que se refere a matrizes pois como se sabe.: Ciro M. main() int p = for } { i..vet[i]. Velocidade . dispostas seqüencialmente em memória.vet[] = { 10. scanf(“%d”.vet[i]. passamos diretamente a variável. pf = pf + 5. pi = pi + 1. pois variáveis caracteres possuem apenas 1 byte. pois expressões complexas envolvendo ponteiros são processadas em velocidade semelhante àquelas feitas pelo modo convencional. 30.. *(p+i)). pois variáveis inteiras ocupam 2 bytes. for (i=0.i). for (i=0. 2345 e 2350. (i=0. } p = vet. então pf valerá 2370 . *pi. Por conterem endereços.05 Página 44 . Santos  Programação C / 2005-1 Versão 0. flutuante ocupam quatro bytes. } Passagem de Variáveis ou Valores através Funções Quando desejamos que uma função altere o valor de uma variável da função que a chamou. que apresenta a vantagem de ser mais facilmente compreendido. i<5. pois variáveis pt.

swap(int *a.Passagem por Valor (a mantém seu valor) int soma( int z) { int x = 5.&a).b). scanf(“%d”.a. swap(&a.r. } main() { int a. Prof. b = 20. } { main() { int a. printf(“Digite um valor: “). return(x).r).b. printf(“%d.05 Página 45 . Santos  Programação C / 2005-1 Versão 0. } Passagem por Referência (a muda seu valor) int soma( int *z) int x=5. printf(“A = %d } { e B = %d “.a. r = soma(&a). r = soma(a).&a). scanf(“%d”. e %d”. *z = 0. } main() { int a.r. return(x). int *b) int t. e %d”. &b). *a = *b. } Uso de ponteiros em funções.r). x = x + *z. z = 0. x = x + z. printf(“Digite um valor: “).: Ciro M. printf(“%d. a = 100. t = *a.a. *b = t.

y = 5.h> int *retorno() { int x..05 Página 46 ./* procedimento utilizando parâmetro ( POR REFERENCIA ) */ void func100r ( int *x) { *x = *x + 100. } #include <stdio. %d ". #include <stdio. *ptx.. int *mult. int *min) { *mult = a * b. printf(" \n Mult %d MIN %d ". } void main ( void ) { int n. *min = ( a < b)? a: b. Santos  Programação C / 2005-1 Versão 0. } Função que retorna um ponteiro . } main() { int *pt. %d MIN.n). func100r(&n). pty = &ry.*pt). printf(" \n Mult. x = 3.ry). return(&x).: Ciro M. *pty). pty. ptx = &rx. x .y. pty). *pt = 100. pt = retorno(). printf(“ Valor do ponteiro “. *ptx. *pt = 100. } void multMIN(int a. printf(“Valor do ponteiro“. int b. } Prof. x = 3. y = 5..ry.y.rx. pt = &x.*pt).h> main() { int *pt. multMIN(x.. &ry). ptx.x. /* procedimente utilizando parametro ( POR REFERENCIA ) */ n = 50. multMIN(x.y. printf(" \n Valor de func100r() = %d".rx. &rx.

o sistema de I/O de C provê um nível de abstração entre o programados e o dispositivo utilizado. Uma vez o arquivo aberto. incluindo terminais. acionadores de disco e acionadores de fita. isto é. Streams Binárias Uma stream binária é uma seqüência de bytes com uma correspondência de um para um. O sistema de arquivo de C é projetado para trabalhar com uma ampla variedade de dispositivos. Essa abstração é chamada de stream e o dispositivo real é chamado de arquivo. não ocorrendo nenhuma tradução de caracteres. O padrão C ANSI define um conjunto completo de funções de I/O que pode ser utilizada para ler e escrever qualquer tipo de dado. Streams de Texto Uma stream de texto é uma seqüência de caracteres. Todas as operações de I/O ocorrem mediante chamadas a funções da biblioteca C padrão.05 Página 47 . Você associa uma stream com um arquivo específico realizando uma operação de abertura. um arquivo pode ser qualquer coisa. Santos  Programação C / 2005-1 Versão 0. Arquivos Em C.Arquivos A linguagem C não contém nenhum comando de I/O. informações podem ser trocadas entre ele e o seu programa. Funções para manipulação de arquivo: Nome fclose() feof() ferror() fopen() fprint() fscanf() ftell() fseek() getc() outc() remove() fread() frwrite() rewind() Descrição Fecha uma fila Devolve se fim de fila Devolve Verdadeiro se um erro tiver ocorrido Abre uma fila Saída Entrada Retorna a distancia inicio/fim a posição atual do arquivo Procura um byte especificado na fila Lê um caracter na fila Grava um caracter na fila Apaga o arquivo ler uma quantidade de registro em um arquivo binário Escreve uma quantidade de registro em um arquivo binário Reposiciona o ponteiro do Arquivo em seu início Prof. independente do dispositivo real que é acessado. desde um arquivo de disco até um terminal ou uma impressor.: Ciro M. O padrão C ANSI permite que uma stream de texto seja organizada em linhas terminadas por um caractere de nova linha.Entradas e Saídas em Dispositivos . o caracteres e nova linha é opcional. Streams O sistema de I/O do C fornece uma interface consistente ao programador C.

Santos  Programação C / 2005-1 Versão 0. ler().Tabela códigos para abertura de arquivos: Código “r” “w” “a” “rb” “wb” “ab” “r+” “w+” “a+” “r+b” “w+b” “a+b” “rt” “wt” “at” “r+t” “w+t” “a+t” Descrição Abre Arquivo de Texto para Leitura Cria Arquivo de Texto para Gravação Anexa a um Arquivo de Texto Abre Arquivo Binário para Leitura Cria Arquivo Binário para Gravação Anexa a um Arquivo Binário Abre Arquivo de Texto para Leitura/Gravação Cria Arquivo de Texto para Leitura/Gravação Abre ou Cria Arquivo de Texto para Leitura/Gravação Abre Arquivo Binário para Leitura/Gravação Cria Arquivo Binário para Leitura/Gravação Abre ou Cria Arquivo Binário para Leitura/Gravação Idem a “r” Idem a “w” Idem a “a” Idem a “r+” Idem a “w+” Idem a “a+” Funções Básicas para Manipulação de Arquivo Texto: Função fclose() feof() fopen() getc() putc() “r” “w” Descrição Fecha uma fila Devolve se fim de fila Abre uma fila Lê um caracter na fila Grava um caracter na fila Abre Arquivo de Texto para Leitura Cria Arquivo de Texto para Gravação #include <stdio. } void escreve ( void ) { if ( ( fp = fopen("c:\saida.fp). exit(1).05 Página 48 . fclose(fp).' ) putc(ch. exit(1).h> char ch. } Prof. fclose(fp)."r")) == NULL ) { puts("não foi possível abrir o arquivo para leitura").ch).txt". } while ( (ch = getc(fp)) != EOF ) printf("%2c".txt". void ler ( void ) { if ( ( fp = fopen("c:\saida. } void main ( ) { escreve(). } while ( (ch = getchar()) != '.: Ciro M."w")) == NULL ) { puts("não foi possível abrir o arquivo para escrita").

"rb")) == NULL ) { fputs("nao foi possivel abrir o arquivo para escrita". printf("\n Numero = %d Valor = %5. } fclose(fp). if ( ( fp = fopen("sb2.Funções Básicas para Manipulação de Arquivo Binário: Função fclose() feof() fopen() fprintf() fscanf() fread() fwrite() “wb” “ab” Descrição Fecha uma fila Devolve se fim de fila Abre uma fila Escreve um registro em um arquivo binário tipos básicos ( int.i. } void ler2( void ) { float valor. } void main ( ) { escreva2(). if ( ( fp = fopen("sb2. exit(1).i++) { printf("\nDigite o salario do aluno"). } fclose(fp).dat". int i. ler2().. } Prof.&valor).i<5."wb")) == NULL ) { puts("nao foi possivel abrir o arquivo para escrita"). void escreva2( void ) { int i.. Santos  Programação C / 2005-1 Versão 0. } while ( !feof(fp) ) { fscanf(fb2.: Ciro M. exit(1).valor).i. scanf("%f".) Ler um registro em um arquivo binário tipos básicos ( int char.&valor). } for (i=0.h> FILE *fp.valor). float valor..stdin).2f"."%d %f ". ler uma quantidade de registro em um arquivo binário Escreve uma quantidade de registro em um arquivo binário Cria Arquivo Binário para Gravação Anexa a um Arquivo Binário #include <stdio.&i. char. ."%d %f ".05 Página 49 . .dat". fprintf(fp.

Santos  Programação C / 2005-1 Versão 0. FILE *fpb. puts("Digite a idade do aluno").fpb)) != NULL ) { puts(alu.#include <stdio. fwrite(&alu.h> struct aluno { int código.txt". FILE *fp.idade). scanf("%d". }.i<2.: Ciro M. gets(alu.nome). exit(1). if ( ( fpb = fopen("c:\saidab.sizeof(alu). char nome[10]. int idade. fflush(stdin).1.05 Página 50 .nome).codigo. exit(1). } void main ( ) { escreveBinario(). struct aluno alu. scanf("%d".fpb). void lerBinario( void ) { if ( ( fpb = fopen("c:\saidab.alu.sizeof(alu). } while ( (fread(&alu."rb")) == NULL ) { puts("não foi possível abrir o arquivo para escrita"). lerBinario().&alu. puts("Digite o nome do aluno"). } fclose(fp).codigo).&alu. printf("Código = %d Idade = %d". } for (i=0.alu.i++) { puts("Digite o codigo do aluno"). } void escreveBinario( void ) { int i."wb")) == NULL ) { puts("não foi possível abrir o arquivo para escrita"). } fclose(fp).1. } Prof.txt".idade).

h” main(int argc. } if ((in = fopen(argv[1]."w").#include “stdio. argc[1]). } Prof. if ( (arq = fopen(argc[1]. exit(1).c e executado e recebe um parametro que sera interpretado destro do programa. fclose(out). #include <stdio."\n arquivo %s criando ". if (arg != 3) { printf(“Digite o Nome dos Arquivos\n”). if ( argv > 1 ) { if ( argv == 3 ) { remove(argc[1]). exit(1).arq).”wb”)) == NULL) { printf(“Arquivo destino não existe\n”).50. fprintf(arq.str)."r")) == 0 ) printf("\n Remocao do aq %s sucesso".out). argc[1]). argc[1]).05 Página 51 .”rb”)) == NULL) { printf(“Arquivo origem não existe\n”). char ch. char **argc) { char str[50]. Santos  Programação C / 2005-1 Versão 0. } } } else printf(" parametros incorreto entre novamente"). } // este programa remove. } else { arq = fopen(argc[1]. } if ((out = fopen(argv[2]. printf(" conteudo : %s ". if ( arq ) { fgets(str. argc[2]). } else { arq = fopen(argc[1]. exit(1). /* esta é a cópia propriamente dita */ fclose(in). char *argv) { FILE *in. argc[1]). *out. fclose(arq)."r"). void main ( int argv. printf("\n Opcao %s para remover arquivo". } while (! feof(in)) putc(getc(in).: Ciro M. printf(" arquivo %s aberto com sucesso ". printf("\n arquivo %s criando com sucesso ".h> FILE *arq.

void ler (int M[MAX][MAX]. v. y. char **argc ) { int M[MAX][MAX]. int lim. M[i][j]). &argc[1]). } } int main ( int argv. } Prof. j++) { M[i][j] = 0. j < lim. imprime(M.h> #define MAX 10 FILE *fp. } void imprime ( int M[MAX][MAX]. &a). fclose(fp). } printf(“\n %s”. for ( j=0. j. i < lim. Santos  Programação C / 2005-1 Versão 0.&v.: Ciro M. a. j. j < lim.&x. &lim. ler(M. for ( i=0. &y). “%d %d \n”. } fscanf(fp. i++) { for ( j=0. M[y-1][x-1] = 1. exit(1). i++) { printf(“\n”). } *lim = v. printf(“\n %s”. i++) { fscanf(fp. i < a. for ( i=0.05 Página 52 . if ( ( fp = fopen(*arquivo. int lim ) { int i. x.”r”) ) == NULL ) { printf(“\n Arquivo não foi encontrado”). int *lim. #include <stdio.argc[1]). j++) { printf(“%3d”.*arquivo). char **arquivo) { int i. “%d %d \n”. exit(1). for ( i=0.Programa para leitura de nome de arquivo atraves de uma função que r ecebe este nome por referencia. printf(“\n digite o nome do programa e o nome do arquivo ”). i. return 1. lim ). i < lim. if ( argv != 2 ) { printf(“\n parametros incorretos”). M[x-1][y-1] = 1.

McGraw-Hill 1989.. Algoritmos e Estruturas de Dados. Data Structure in Pascal.Vol.Vol. Data Structure. Data Strutures Using C. I Editora McGraw Hill Mizraghi V. C Completo e Total. R.Referências [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] Mizraghi V. Yedidyah. Algorithms in C: Fundamentals. Langsam. John Hopcroft Data Structure and Algorithms Editora Addison-Wesleyn Publishing Company Ziniani. Moshe J.: Ciro M. Searching Weiss M. DataStructure and Algorithm Analysis in C Horowitz Ellis. Aho. N. Herbert. Fundamentals. Editora Pioneiro Sedgewick. V. Sorting. Treinamento em Linguagem C .. Aaron M. Niklaus. Prof... Santos  Programação C / 2005-1 Versão 0. Projeto de Algoritmos com implementação Pascal e C.05 Página 53 .. PHB Tenenbaum. II Editora McGraw Hill Schildt. Treinamento em Linguagem C . Augenstein. Allen. 3 Edição Editora Makron Books Alfred V. Sahni Sartaj. Wirth. V.