Universidade Católica de Pelotas Escola de Informática Ciência da Computação

C for Linux
por Prof. Dr. Paulo Roberto Gomes Luzzardi luzzardi@atlas.ucpel.tche.br http://infovis.ucpel.tche.br/luzzardi

Versão 2.02 (Junho/2007)

Referências Bibliográficas KERNIGHAN, Briam W. C a Linguagem de Programação Padrão ANSI, Rio de Janeiro: Campus, 1990.

Pelotas, quinta-feira, 14 de junho de 2007 (15:06)

Sumário 1. Introdução...................................................................................................................................................6 1.1 - Histórico.............................................................................................................................................6 1.2 - Evolução.............................................................................................................................................6 1.3 - Características.....................................................................................................................................6 1.4 - Utilização...........................................................................................................................................6 2. Ambiente de Programação Anjuta..............................................................................................................7 2.1 Compilador gcc.....................................................................................................................................7 2.2 Instalação do Anjuta.............................................................................................................................7 2.3 Interface do Anjuta...............................................................................................................................7 3. Estrutura de um programa em C..................................................................................................................8 3.1 - Identificadores....................................................................................................................................8 3.2 – Comentários do programador.............................................................................................................8 3.3 - Regras gerais para escrever um programa em C.................................................................................8 3.4 - Palavras reservadas.............................................................................................................................9 3.5 - Declaração de variáveis......................................................................................................................9 3.5.1 - Onde as variáveis podem ser declaradas......................................................................................9 3.5.2 - Inicialização de variáveis...........................................................................................................11 3.6 - Constantes........................................................................................................................................11 3.6.1 - Constantes hexadecimais e octais...............................................................................................11 3.6.2 - Constantes strings......................................................................................................................11 3.6.3 - Constantes especiais...................................................................................................................12 3.7 - Comandos do pré-processador do C..................................................................................................12 3.7.1 - O comando #define....................................................................................................................12 3.7.2 - O comando #include..................................................................................................................12 4. Tipos de dados..........................................................................................................................................14 4.1 - Tipos básicos....................................................................................................................................14 4.2 Modificadores de tipo.........................................................................................................................14 5. Operadores................................................................................................................................................15 5.1 - Operadores aritméticos.....................................................................................................................15 5.2 - Operadores relacionais......................................................................................................................15 5.3 - Operadores lógicos...........................................................................................................................15 5.4 - Incremento e decremento..................................................................................................................16 5.5 - Operador de atribuição......................................................................................................................16 5.6 - O operador sizeof..............................................................................................................................17 5.7 - Casts.................................................................................................................................................17 5.8 - Expressões........................................................................................................................................18 5.8.1 - Conversão de tipos em expressões..............................................................................................18 6. Funções padrões........................................................................................................................................20 6.1 – abs....................................................................................................................................................20 6.2 – fabs..................................................................................................................................................20 6.3 – asin..................................................................................................................................................20 6.4 – acos..................................................................................................................................................20 6.5 – atan..................................................................................................................................................20 6.6 – cos....................................................................................................................................................20 6.7 – sin....................................................................................................................................................21 6.8 – exp...................................................................................................................................................21 6.9 – pow..................................................................................................................................................21 6.10 – sqrt.................................................................................................................................................21 6.11 – log..................................................................................................................................................21 6.12 – atof.................................................................................................................................................21 6.13 – atoi.................................................................................................................................................21 6.14 – atol.................................................................................................................................................22 6.15 - log10...............................................................................................................................................22 6.16 – tan..................................................................................................................................................22 6.17 – rand................................................................................................................................................22 6.18 – srand..............................................................................................................................................22 6.19 – system............................................................................................................................................23 7. Comandos.................................................................................................................................................24 7.1 - Tipos de Comandos..........................................................................................................................24 7.1.1 - Seqüência..................................................................................................................................24 7.1.2 - Seleção......................................................................................................................................24

2

7.1.3 - Repetição...................................................................................................................................24 7.1.4 Atribuição....................................................................................................................................25 7.2 - Comando if.......................................................................................................................................25 7.2.1 - if encadeados.............................................................................................................................26 7.3 - O comando switch............................................................................................................................27 7.4 - Comando while................................................................................................................................29 7.5 - O comando for..................................................................................................................................31 7.6 - O loop do { } while..........................................................................................................................32 7.7 - Interrupção de loops.........................................................................................................................32 7.7.1 - O comando break.......................................................................................................................33 7.7.2 - O comando continue..................................................................................................................33 7.8 - A função exit ().................................................................................................................................33 8. Entrada e saída..........................................................................................................................................35 8.1 - Entrada e saída do console................................................................................................................35 8.2 - Entrada e saída formatada.................................................................................................................35 8.2.1 - Saída formatada (printf).............................................................................................................35 8.2.2 - Entrada formatada (scanf).........................................................................................................36 8.2.3 – Leitura de strings (fgets)............................................................................................................37 9. Controle do vídeo e teclado.......................................................................................................................38 9.1 Biblioteca “ncurses” - modo texto.......................................................................................................38 10. Lista de exercícios (comandos)...............................................................................................................39 11. Vetores, matrizes e strings.......................................................................................................................43 11.1 - Vetores...........................................................................................................................................43 11.2 – Strings............................................................................................................................................43 11.3 - Matrizes (Multidimensional)..........................................................................................................44 11.4 - Vetor de strings...............................................................................................................................44 11.5 - Inicialização de matrizes e vetores..................................................................................................45 11.6 - Inicialização de um vetor de caracteres...........................................................................................45 11.7 - Inicialização de matrizes multidimensionais...................................................................................45 11.8 - Inicialização de vetores e matrizes sem tamanho............................................................................45 11.9 - Classificação de dados ou ordenação (sort).....................................................................................46 11.10 - Lista de exercícios (vetores)..........................................................................................................48 12. Manipulação de strings...........................................................................................................................51 12.1 - strcpy..............................................................................................................................................51 12.2 - strcmp.............................................................................................................................................52 12.3 - strcat...............................................................................................................................................52 12.4 - strlen...............................................................................................................................................53 12.5 – strchr..............................................................................................................................................53 12.6 – Lista de exercícios (strings)............................................................................................................54 13. Funções definidas pelo programador.......................................................................................................56 13.1 - Valores de retorno..........................................................................................................................57 13.2 - Passagem de parâmetros por valor..................................................................................................59 13.3 - Passagem de parâmetros por referência..........................................................................................60 13.4 - Funções que devolvem valores não-inteiros....................................................................................60 13.5 - Argumentos argc e argv do main....................................................................................................61 13.6 - Recursividade.................................................................................................................................62 13.7 - Lista de exercícios (funções)...........................................................................................................63 14. Ponteiros.................................................................................................................................................69 14.1 - Variáveis ponteiros.........................................................................................................................70 14.2 - Operadores de ponteiros.................................................................................................................70 14.3 - Expressões com ponteiros...............................................................................................................70 14.3.1 - Atribuições com ponteiros.......................................................................................................70 14.3.2 - Aritmética com ponteiros.........................................................................................................70 14.3.2.1 - Incremento (++) ..............................................................................................................70 14.3.2.2 - Decremento (--)................................................................................................................72 14.3.3 - Soma (+) e subtração (-) .........................................................................................................72 14.3.4 - Comparação de ponteiros.........................................................................................................72 14.4 - Ponteiros e vetores..........................................................................................................................72 14.4.1 - Indexando um ponteiro............................................................................................................73 14.4.2 - Ponteiros e strings....................................................................................................................73 14.4.3 - Obtendo o endereço de um elemento de um vetor....................................................................74 14.4.4. Vetores de ponteiros..............................................................................................................74 14.5 - Ponteiros para ponteiros.................................................................................................................74

3

...............................................................Passando elementos da estrutura...................................5....88 16..........................Campos de bit....................Implementação de uma fila...3........................95 16..............82 15...............92 16.3 Biblioteca “conio...........................92 16...................................86 15......................12 – remove.............................1 ......................................................................118 19.....................78 15...................1 ........... Entrada e saída em disco................................................1 ....................................................................1 ...........2 – putc...........................2 – free..........................96 16.............. O especificador register.......2 ...........................................................................................................5...........h” + “clock.....................................95 16...................................................................................................fopen.........................................................2 .................................................................1 – open.......3 ...........................rewind.............................h” completa..........2 ......................2.....2...........Union..........................78 15............................1 ........................................2 ............................Operadores bit a bit................2............................2.3 .........Ponteiros para estruturas...................6 ..........................O modificador const...................................................................................O especificador extern..............1 ............................92 16.................................................................................................................................................................................95 16.93 16.................85 15.............5..................................... Listas lineares.......................95 16..................................................................................................................................................1 ...........2 .............Filas binárias......77 15................81 15............................................Lista duplamente encadeada.................1.98 17.....14...........95 16.............................5................................................................8 – fgets e fputs.........................................................................................................Referência aos elementos da estrutura...........................2 ...............................................4 ...............................................5.............................................3..................128 4 ................................O especificador auto....................85 15..............................5.......................5.2 ..............93 16.....................Filas de texto......2.................................................................120 19............................................................................................6 – tell.........................................3........3................................................93 16.........2....2................9 – fread e fwrite...................................2............................1........93 16................................Implementação de uma pilha.......................2 .....5.82 15.......................O especificador static.....................3...........................4.....................................................7 – getw e putw............95 16..................................................................................................82 15..11 – fprintf e fscanf...............117 19................................................5...............................................................................................................74 14.........4 – feof.............................................................................................................................................1 .......................1 ......1 – malloc....................................................................80 15...........................96 16.................................79 15..................................................1 Jogo de Caça-Palavras...75 14.....................................Passando estruturas inteiras..................2 – write e read...........Especificadores de classe de armazenamento..........................................................102 17..3 – unlink..........................1 ..............2.............O modificador volatile........5 Jogo da Forca...................................3..............3 .......................................5...Sistema de arquivo bufferizado .......................................................................108 19.......................................1..............3....................................................................................................................................78 15.................................................Fila de bytes (stream)................................................108 19...................81 15....................................Matrizes de estruturas....................1 ............................................................................................................5 – fclose..........................................................................................................3............................................................94 16........2 ...................74 14................2......................................................Formas abreviadas de C...5 – eof......................................................................Lista de exercícios (arquivos)....................................................................................................1.....................4 Biblioteca “conio..........................................7 ...........................................3 ..........................................typedef.................................................................................2............ creat e close........................................................................................................................................7.................................................................................................76 15................94 16.......Tipos de dados avançados..................O operador ?.................................80 15......3 .........2..................86 15.............................................................................96 16.............................................................................................Inicialização de ponteiros.................2...........3..................................................................................................................................77 15.......................................5....5 .....Estruturas...............................................................Sistema de arquivo não bufferizado...........2...................................................................................5......................................................O operador ............................95 16...................................................................................... Tipos de dados definidos pelo programador...........2 Relógio em Linux.......99 17..............................85 15.....................................1..........................................................86 15......................2.................1.................................................................97 17................1..............81 15...........3 ..................... Programas exemplos usando ncurses.................2 .............................................77 15.......1...........................Modificadores de acesso...........................................5...................................................................................................................................................81 15.......94 16............................4 ..............................4 ....92 16...............................Passando estruturas para funções.................Operadores avançados.......................6 ...........95 16...........................Alocação dinâmica de memória......................................2...1.............95 16.....................................................................81 15....................3...................................10 – fseek..................97 16......................................................104 19...............7.........3.................c”.............................................................3 ...........................3 – getc.....................4 ...........1.............................

..139 20...........................................................143 21.............5 Função de Formatação de texto...........................................................144 21....137 20.......1 Conceitos Básicos..................................2 Funções de inicialização............................................................................................................................................................................................139 20.......................................................................... Outros Comandos ...................................................... Programas escritos em C..................................1 Comandos do Pré-Processador.................................................. Biblioteca ncurses....137 20...3 Funções de entrada..................................................144 22........20..................................................................3 Declaração de constantes tipadas............................................................141 21......................4 Ponteiro para Ponteiro................................146 5 ..................................142 21.........................................................................2 Hierarquia dos operadores aritméticos.................................. relacionais...................................................................................................................142 21.....................................................................................................4 Funções de saída....................................................................................................140 20.................................... lógicos e bit a bit.............................

Utilização Permite o desenvolvimento e implementação de software básico. Permite a manipulação de bits.2 . tais como:       Sistemas Operacionais. Permite escrever programas modulares e estruturados. 1. SGBD (Sistema Gerenciador de Banco de Dados).Histórico A linguagem de programação C foi desenvolvida nos anos 70 por Dennis Ritchie em um computador DEC PDP-11 que utilizava Sistema Operacional UNIX. desenvolvida por Martin Richards.1. e baixo 1.3 . surgiu uma linguagem chamada B. bytes e endereços. Bastante portável. Compiladores.Características      Linguagem de nível médio (combina recursos de alto nível). Programas educacionais. Não é fortemente tipada.4 . Introdução 1. 1.1 .Evolução A partir de uma linguagem mais antiga chamada BCPL. 6 . inventada por Ken Thompson que influenciou o desenvolvimento da linguagem de programação C. Interpretadores. Editores (de texto e gráficos).

...... 2.... Atualiza a lista de pacotes Instala o Compilador C Instala o Compilador C++ Instala o ambiente anjuta 2.. gratuito e de código aberto.... O projeto teve início em 1984.... O projeto GNU (Gnu’s Not Unix) foi proposto por Richard Stallman em 1983. Para instalar o pacote execute os seguintes passos: $ $ $ $ apt-get apt-get apt-get apt-get update <enter> ... install gcc <enter> .. install g++ <enter> ....1 Compilador gcc O compilador gcc é o compilador C do projeto GNU.. e a proposta era desenvolver um sistema operacional completo e livre.... install anjuta <enter> ........3 Interface do Anjuta Figura 1: Ambiente de Programação Anjuta 7 .2... Ambiente de Programação Anjuta 2... similar ao Unix.2 Instalação do Anjuta Um dos ambientes de programação que podem ser utilizados no Sistema Operacional Linux é o Anjuta..

printf(“Valor: %. obrigatoriamente é chamada main(). t Retorno: Sem Retorno ------------------------------------------------------. pode ainda. inverso(n)).1 . As principais regras são:   Letras maiúsculas e minúsculas diferentes. _a. quando forem feitas manutenções no programa).Regras gerais para escrever um programa em C Um programa em C é constituído de uma ou mais funções delimitadas por chaves { }. constantes. Os caracteres seguintes devem ser letras. Regras para a criação de identificadores:     O primeiro caracter deve ser uma letra ou sublinha ( _ ). 8 são tratadas como caracteres . Em C os comentários podem ser feitos da seguinte maneira: /* Isto é um comentário de várias linhas */ // Isto é um comentário em C++ de uma linha Um comentário.3. ou seja.3 . números ou sublinhas.2 – Comentários do programador Os comentários do programador são linhas de código que não são compiladas pelo compilador. Observação: a função “inverso” é definida pelo programador (1/n). Estrutura de um programa em C 3. 27 10 Exemplos em variáveis: Exemplos em constantes: #define ESC #define ENTER Exemplos em funções: x = raiz_quadrada(y).*/ 3. servem apenas como anotações para serem lembradas mais tarde (por exemplo. funções e rótulos.2f\n”. utilizar várias linhas do programa.Identificadores São os nomes criados pelo programador para fazer referência a variáveis. char a. onde uma destas funções. Os primeiros 32 (default) caracteres são significativos. 3. O formato do texto é livre. Não é permitido a utilização de caracteres em branco (caracter espaço). Veja o exemplo abaixo: /* ---------------------------------------------------Função: STRING Parâmetros de entrada: x. y Parâmetros de saída: c. float inflacao. int num_dentes = 32.

3. mes = 6.5 . float a. dia.h> int main (void) { int dia.4 . } 3. b. ano. char.     A função main() especifica onde o programa começa e termina de ser executado. mes. } função termina de ser executada. Programa exemplo (1): Imprimir a data no seguinte formato: [Data: dd/mm/aaaa].Declaração de variáveis Sintaxe: tipo_dado_base lista_de_variáveis.Palavras reservadas Definidas por K&R (Kernighan & Ritchie) auto break case char continue default do double if static else int struct entry long switch extern register typedef float return union for sizeof unsigned goto short while ANSI const enum signed void volatile near _ds asm Observação: As palavras reservadas não podem ser utilizadas pelo programador como nome de variáveis. constantes ou funções. Exemplo: int main (void) { int i. ano = 2006. char ch. printf("Data: %02d/%02d/%04d\n". ou seja. mes. { função começa a ser executada. // variáveis locais utilizadas somente na função main dia = 12. incluindo a função main() são chamadas de variáveis globais e podem ser acessadas em 9 . return(0). Todas as variáveis devem ser declaradas. double ou void) lista_de_variáveis: um ou mais identificadores separados por vírgula. ano).5. #include <stdio.Onde as variáveis podem ser declaradas  Definidas fora de todas as funções. Todos os comandos são terminados por ponto e vírgula. tipo_dado_base: deve ser um tipo de dado válido (int. j . 3.k.1 . não servem como identificadores. float.

expoente. Memória ROM (Read Only Memory – Memória somente de Observação: leitura).h> #include <math. Este espaço de memória é desalocado quando o espaço não é mais necessário. resultado = POT(base. resultado). float y) { float resp. Estas variáveis são alocadas dinamicamente na memória RAM. resp = exp(log(x) * y). Alocação dinâmica de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM temporariamente. #include <stdio. Definidas dentro de uma função são chamadas de variáveis locais e só podem ser acessadas dentro desta função. Depois que uma função é executada.&expoente). POT Variáveis locais: base.h é inserido dentro deste programa float POT (float base. Na declaração de parâmetros formais de uma função.h> // o arquivo stdio. scanf("%f". Programa exemplo (2): O programa realiza uma operação de potência Xy. } função POT // corpo da função POT definida pelo programador // os parâmetros x e y são variáveis locais // definição das variáveis locais // retorno da função Variáveis globais: resultado. // função que permite scanf("%f". estas variáveis são desalocadas.c -o prog2 -lm <enter> Onde: -o gera programa executável “prog2” 10 .2f\n". // protótipo da função POT // variável global // definição das variáveis locais imprimir dados na tela a entrada de dados via teclado printf("Base: "). return(0). expoente.  qualquer parte do programa. } float POT (float x. Alocação de memória:  (Reserva de espaço de memória (RAM) para alocar uma variável)  Alocação estática de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM durante toda a execução do programa. float expoente). return(resp). Este espaço de memória é desalocado somente quando o programa acaba. float resultado. Estas variáveis são alocadas estaticamente na memória RAM (Random Access Memory – Memória de acesso randômico). // função que permite printf("Expoente: "). int main (void) { float base. y Compilar por linha de comandos: $ gcc prog2. expoente). x. resp. // chamada da printf("Resposta = %7.&base). Sendo estas locais e alocadas dinamicamente na memória RAM.

Toda string deve ser finalizada pelo caracter especial ‘\0’ (chamado de NULL). colocando um sinal de igual e uma constante após o nome da variável.34e-3 "C for Linux" (forma // // // // tipo_dado_base nome_da_variável = constante_caracter tipo_dado_base nome_da_variável = constante_string tipo_dado_base nome_da_variável = constante_inteira tipo_dado_base nome_da_variável = constante_real nome_da_variável = constante. F). char s = “UCPel”. // 255 em decimal // 9 em decimal 3.-lm linka a biblioteca “math.2 .Inicialização de variáveis Em C. Uma constante octal começa com um 0 (zero).Constantes strings Uma string é um conjunto de caracteres delimitados por aspas duplas. A. Exemplos: int main (void) { int hexadecimal = 0xFF.1 . Observações:   Qualquer número octal é formado por oito números ( 0 ..45. 11 .5. 'e'. Uma string é definida como um vetor (unidimensional) de caracteres. D.9. Tipo char int float char * Exemplos de constantes 'a' 'n' '9' 1 123 2100 -234 123.6.Constantes Valores fixos que o programa não pode alterar. E. ou char s[6] = {'U'.2 . float y = 123. Qualquer número hexadecimal é formado por dezesseis números (0 . int octal = 011.h” 3. 'P'.6. 3. NULL}. int n = 0. 7 ). tipo_dado_base Exemplos: char ch = 'a'.6 . Em C não existe um tipo de dado especifico para definir uma string.Constantes hexadecimais e octais A linguaguem de programação C permite especificar constantes inteiras em hexadecimal ou octal. As constantes podem ser de qualquer tipo básico. 'C'.23 4. enquanto que uma hexadecimal começa por 0x. Exemplo: char s[6] = "UCPel". 'l'. B. é possível fornecer valores iniciais a maioria das variáveis ao mesmo tempo em que elas são declaradas. de definir uma string) 3. C..

6.O comando #include O comando #include faz o compilador incluir um arquivo-fonte dentro de outro arquivo fonte. #define identificador valor Exemplos: #define TRUE #define FALSE #define ENTER 10 #define ESC 27 3.7 .Comandos do pré-processador do C 3. 3.3 .2 .‘\0’ é igual a NULL 0 ‘U’ 1 ‘C’ 2 ‘P’ 3 ‘e’ 4 ‘l’ 5 NULL Figura 2: Vetor de caracteres Memória ocupada: 6 bytes Observação: 'a' é diferente de "a" 'a' ocupa 1 byte na memória RAM (é do tipo char) "a" ocupa 2 bytes na memória (toda string é terminada com o caracter '\0') A palavra NULL (quer dizer nulo) está definida dentro do arquivo de header (cabeçalho) stdio.7.h (standard input output).7. O compilador substitui o identificador pelo valor cada vez que aquele for encontrado no programa fonte antes da compilação do programa.h> ou // arquivo de header padrão do C !0 0 // ou #define TRUE 1 12 . ou s[i] = '\0'.Constantes especiais As constantes especiais são usadas para representar caracteres que não podem ser inseridos pelo teclado. São elas: Tabela 1: Constantes especiais Constante ‘\b’ ‘\f’ ‘\n’ ‘\r’ ‘\t’ ‘\”’ ‘\’’ ‘\o’ ‘\\’ ‘\a’ ‘\o’ ‘\x’ Significado Retrocesso Alimentação de formulário Nova linha Retorno de carro <CR> Tab horizontal Aspas duplas Aspas simples Zero Barra invertida Alerta Constante octal Constante hexadecimal 3. #define NULL 0 // s[i] == (char) NULL.1 .O comando #define O comando #define é usado para definir uma macro-substitução. #include <header .

h" // arquivo de header padrão do C (/usr/include) // arquivo de header definido pelo programador 13 .h" // arquivo de header escrito pelo programador Observações: Normalmente os arquivos de header estão localizados em “/usr/include”. Exemplos: #include <stdio.#include "header . enquanto que as bibliotecas do gcc estão no diretório “/usr/lib”.h> #include "luzzardi. E os arquivos de header do programador estão localizados em seu diretório corrente “/home/luzzardi/fontes”.

4. a faixa de valores válida e o número de bytes que cada tipo de dados ocupa na memória RAM (memória principal) ou em disco (quando armazenados na memória secundária).4E+38 -1.1 . São exibidos os tipos básicos.7E+308 Sem valor Bytes 1 4 4 8 0 4. a quantidade de bits. Os modificadores modificam a quantidade de bits e bytes dos tiposbase.7E+308 Bytes 1 1 2 2 2 4 2 2 4 4 8 14 . ou seja. alterando. Tabela 2: Tipos de dados Tipo char int float double void Bits 8 32 32 64 0 Faixa de valores -128 à 127 -2147483648 à 21474483647 -3.7E-308 à 1.2 Modificadores de tipo Os modificadores de tipo são utilizados para modificar os tipos de dados base. desta forma. Tabela dos modificadores de tipos Tabela 3: Modificadores de tipos Modificador de tipo signed unsigned long short Modificação c/sinal s/sinal longo curto Descrição Números positivos e negativos Números positivos Aumenta o número de bytes do tipo Diminui o número de bytes do tipo Tabela de tipos básicos modificados Tabela 4: Tipos de dados básicos modificados Tipo unsigned char signed char unsigned int signed int short int long int unsigned short int signed short int unsigned long int signed long int long double Bits 8 8 32 32 32 32 16 16 32 32 64 Faixa de valores 0 à 255 -128 à 127 0 à 4294967295 -2147483648 à 21474483647 -2147483648 à 21474483647 -2147483648 à 21474483647 0 à 65535 -32768 à 32767 0 à 4294967295 -2147483648 à 21474483647 -1. Tipos de dados 4. se adaptando às necessidades do programador.4E-38 à 3. a faixa de valores destes novos tipos de dados.Tipos básicos A tabela abaixo exibe os cinco (5) tipos de dados básicos que podem ser utilizados pelo programador para definir suas variáveis.7E-308 à 1.

Operadores aritméticos São operadores que realizam uma operação matemática.(menos unário) * / % + - Observação: Quando houver duas ou mais operações de mesma hierarquia.Operadores lógicos São condição.2 . Estas operações comparativas ou lógicas. Exemplo: operadores utilizados em comandos que tem mais de uma if (condição1 && condição2 || condição3) Tabela 8: Operadores lógicos 15 . Operadores São símbolos especiais que obrigam determinadas operações. Tabela 7: Operadores relacionais Operador > >= < <= == != Ação Maior que Maior ou igual a Menor que Menor ou igual Igual a Diferente de são 5.++ Ação Subtração Adição Multiplicação Divisão Resto inteiro da divisão Decremento/incremento o compilador a executar podem ser aritméticas. 5.3 . Tabela 5: Operadores aritméticos Operador aritmético + * / % -. Precedência dos operadores aritméticos (Hierarquia nas Operações) Tabela 6: Precedência dos operadores aritméticos Hierarquia 1 2 3 4 5 6 Operação Parênteses Funções ++ -.5.Operadores relacionais São operadores que permitem comparar valores. o compilador executa-as da esquerda para a direita (veja tabela completa de precedência no item 21. utilizados principalmemte em comandos que possuem condições.2).1 . 5. ou seja.

5 . x--.Operador de atribuição O operador de atribuição é o sinal de igual =. Quando precede seu operando. C efetua a operação de incremento ou decremento antes de utilizar o valor do operando. sqrt(y). // // // // y será 11 x será 11 y será 10 x será 11 x = x + 1. Observação: Os operadores (++ ou --) podem ser colocados antes ou depois do operando. 5.   ++ adiciona (1) ao operando subtrai (1) ao operando As seguintes operações são equivalentes: x++.1.&& || ! AND (e) OR (ou) NOT (não) Precedência (Hierarquia dos operadores relacionais e lógicos) Tabela 9: Precedência dos operadores relacionais e lógicos Hierarquia 1 2 3 4 5 Operação ! > >= < == != && || <= Observação: As expressões que utilizam operadores relacionais e lógicos retornam 0 (zero) para falso e !0 (não zero) para verdadeiro. expressão. 16 . C utiliza o valor do operando antes de incrementá-lo ou decrementá-lo.Incremento e decremento São operadores aritméticos que permitem realizar operações de soma e subtração de forma simplificada. Exemplo: x = 10. função(x).4 . y = x++. y = ++x. A sintaxe do operador de atribuição pode ser escrito em uma das seguintes formas: variável variável variável variável = = = = constante. x = 10. y. x x x x = = = = 3. x = x . ou seja: #define TRUE #define FALSE !0 0 5. Quando o operador vier depois do operando. variável. a + b.

printf("Ano ATUAL: "). } A linguagem de programação C permite utilizar o operador de atribuição em expressões. Para tanto deve ser utilizado uma construção chamada de cast.&ano_atual). #include <stdio.Programa exemplo (3): O programa calcula a idade de uma pessoa. Programa exemplo (5): O programa imprime na tela o resultado de uma divisão. para depois avaliar a expressão. scanf("%d".h> int main (void) { int idade.Casts É possível forçar que o resultado de uma expressão seja de um determinado tipo. variável = (tipo) expressão. if ((produto = x * y) < 0) Funcionamento: Primeiramente C atribui o valor x * y a variável produto.x. printf("x -> %d – y -> %d\n". comparar se o produto é menor (<) que zero. } 5. x = sizeof(short int). // x vale 2 // sizeof(y) é 1 // leitura do ano atual // leitura do ano de nascimento // atribuição – cálculo da idade O programa exibe a quantidade de bytes das 17 .&ano_nasceu).O operador sizeof O operador sizeof (tamanho de) retorna o tamanho (em bytes) de uma variável ou de um tipo que está em seu operando. ano_nasceu. char y.h> int main (void) { int x.ano_nasceu. scanf("%d".idade). #include <stdio. junto com operadores matemáticos. return(0).sizeof(y)). 5. relacionais. printf("Ano de NASCIMENTO: "). ou seja. return(0). printf("Sua IDADE eh %d\n". e outros (como foi mencionado acima).6 . ano_atual. Programa exemplo (4): variáveis e tipos. chamada de funções. idade = ano_atual . pode ser utilizado para "tipar" uma variável com um tipo diferente do resultado da expressão.7 . ou seja. lógicos.

y. resp = (float) x / y. C converte todos os operandos para o tipo do maior operando. // return(0).&x). // é necessário um printf("Divisao = %. 5.4. os tipos abaixo são convertidos para: char . int i.resp). funções e variáveis. printf("x = "). printf("y = "). Antes. } Observação: Em C. float f.2f\n". deve-se utilizar um cast (float) para que o tipo resultante atribuído a variável resp seja float.8. scanf("%d".h> int main (void) { int x.#include <stdio. o tipo resultante de um inteiro dividido por outro inteiro é um inteiro.Expressões Uma expressão em C é qualquer combinação válida de operadores (aritméticos. scanf("%d". logo.1 . float resp.8 . float result. double d.convertido para double Exemplo: char ch. 18 . cast (float) pois a divisão de dois inteiros resulta em um inteiro 5.convertido para int float . relacionais ou lógicos).&y). Exemplo: c = sqrt (a) + b / 3.Conversão de tipos em expressões Quando uma expressão é composta de tipos diferentes. constantes.

Figura 3: Conversão de tipos em expressões 19 .

” . “m” (math routines) . Sintaxe: float fabs (float x).3 – asin A função asin retorna o valor do arco seno..h Faixa: -pi / 2 à pi / 2 6.h 6. Funções padrões No linux é necessário incluir a biblioteca “math”.6 – cos A função cos retorna o valor do cosseno..c -o calc -lm <enter> No ambiente de programação anjuta tem que incluir em “Definições” .2 – fabs A função fabs retorna o valor real positivo – absoluto.. Prototype: math. Sintaxe: double acos (double x). A variável x deve estar em radianos.5 – atan A função atan retorna o valor do arco tangente.h Faixa: 0 à pi 6.. Sintaxe: double atan (double x). 6. Prototype: math.4 – acos A função acos retorna o valor do arco cosseno.. A variável x deve estar em radianos.h 6.1 – abs A função abs retorna o valor inteiro positivo – absoluto.. Por linha de comando fica assim: $ gcc calc.6. “Adicionar”. Sintaxe: int abs(int x)... Sintaxe: double asin (double x). A variável x deve estar em radianos. “Definições de Compilação e Link. Prototype: math.h Faixa: -pi / 2 à pi / 2 6. A variável x deve estar em radianos. “Bibliotecas” . Prototype: math.. Prototype: math. 20 ..

Prototype: math.12 – atof A função atof converte string em ponto flutuante. Sintaxe: int atoi (const char *s). Prototype: math.Sintaxe: double cos (double x).h 6.9 – pow A função pow (power) retorna o valor da potência (xy). Sintaxe: double sqrt (double x).8 – exp A função exp retorna o valor do expoente (ex). Prototype: math. Prototype: math. Prototype: math.h 6.11 – log A função log retorna o valor do logaritmo natural. Sintaxe: double sin (double x).h 6.10 – sqrt A função sqrt (square root) retorna o valor da raiz quadrada. Prototype: math. double y). Sintaxe: double atof (const char *s). Prototype: math.13 – atoi A função atoi converte uma string em inteiro. Sintaxe: double log (double x). A variável x deve estar em radianos. Sintaxe: double exp (double x).h Faixa: -1 à 1 6.h 21 . Prototype: math.h Faixa: -1 à 1 6.7 – sin A função sin retorna o valor do seno.h 6. Sintaxe: double pow (double x.h 6.

Sintaxe: long int atol (const char *s). Sintaxe: double log10 (double x). t = rand() % n. Prototype: math. Sintaxe: double tan (double x).h 6. A variável x deve estar em radianos.14 – atol A função atol converte uma string em inteiro longo. Sintaxe: void srand (unsigned int semente). void randomize(void) { srand(time(NULL)). Prototype: stdlib.6. Prototype: stdlib. Prototype: math. rand retorna um número aleatário entre 0 até Sintaxe: int rand (void). } 6.17 – rand A função 4294967295.h Faixa: 0 à 4294967295 int random(int n) { int t.15 .h 6.16 – tan A função tan retorna o valor da tangente. Prototype: math.18 – srand A função srand inicializa o gerador de números aleatórios. } Observação: A função time(NULL) retorna o tempo em segundos desde 1 de janeiro de 1970.h 6. return(t).log10 A função log10 retorna o logarítmo na base 10. // retorna um número aleatório entre 0 e n-1 22 . Não deve ser utilizado dentro de laços.h Forma de usar: srand(time(NULL)).

comandos e arquivos executáveis do Sintaxe: int system (const char *comando).6. Prototype: stdlib. // pausa Observação: ls e clear são comandos do sistema operacional Linux.19 – system A função system executa sistema operacional linux. ("ls"). 23 .h Retorna: 0 (ok) e -1 (erro) Exemplos: system system system system ("ls -l"). ("sleep 3"). ("clear").

Seleção São comandos. que no fluxo de controle do programa. que no fluxo de controle do programa. if (x < 0) x = fabs(x). são sempre executados passando a execução para a próxima instrução. permitem a repetição de uma ou mais instruções.25. printf(“Digite um valor: “). resp = valor * 1.Repetição São comandos. Comandos 7.2f\n”.1. // limpa a tela // imprime na tela // comando de atribuição // entrada de dados via teclado // atribuição é um comando de seqüência Observação: A função getchar() permite a entrada de um caracter via teclado.Tipos de Comandos 7.1 . printf(“Raiz Quadrada: %.1 .3 . este tipo de comando faz com que alguns comandos não sejam executados. // por causa da função fabs testa se o número é par ou ímpar se o valor de x for negativo 24 . &x). scanf("%f".Seqüência São comandos. ou seja.h> #include <math. ou seja. É necessário digitar <enter>. que no fluxo de controle do programa. letra = getchar(). raiz). permitem a seleção entre duas ou mais instruções. else printf("Número: ÍMPAR\n"). scanf(“%f”.h> int main (void) { float x.7. ou #include <stdio. return(0). printf("Digite um valor: "). } 7.&valor).1. 7. todos os comandos de seqüência são executados desde que eles não dependem de um comando de seleção.1. raiz. printf("Digite uma letra: "). // esta instrução só é executada raiz = sqrt(x). Exemplo: (todas as instruções abaixo são de seqüência) system(“clear”). Exemplo: if (numero % 2 == 0) // printf("Número: PAR\n").2 .

caso contrário (condição falsa. Veja exemplos abaixo if (condição) { comando 1. o comando 1 será executado. } while (tecla != ESC).Comando if O comando if é um comando de seleção que permite selecionar um comando entre dois outros comandos (comandos simples) ou dois conjuntos de comandos (comandos compostos).1. O resultado desta avaliação (teste da condição) pode ser verdadeiro ou falso. } if (condição) { comando 1.5 (Operador de atribuição).2 .h> #define ESC 27 int main (void) { char tecla. Sintaxe: if (condição) comando 1. Se a condição for avaliada como verdadeira (qualquer valor diferente de 0). Comando 1. printf("Tecla: %c . Isto é feito através da avaliação de uma condição. tecla). valor igual a zero) o comando 2 será executado. Dependendo deste resultado um dos comandos é executado e o outro não. comando 3. comando 2. } 7.Código: %d\n". // todos os comando são simples Observação: O else é opcional. } else { comando 3. O programa encerra quando o usuário digitar a tecla <esc> (escape). return(0). else comando 2. tecla = getchar().Programa Exemplo (6): O programa exibe na tela a tecla e o código (ASC II) da tecla digitada pelo usuário. ou if (condição) comando. comando 4. #include <stdio. deve-se utilizar chaves ({ }). do { printf(“Digite uma tecla: “). tecla. } // todos os comando são compostos 25 . 7. comando 2 ou comando podem ser simples ou compostos (quando há mais de um comando ligado a outro.4 Atribuição Veja item 5. comando 2.

} 7. if (num == 0) printf("Zero\n").. scanf("%d". // primeiro if // segundo if // comando 1 do primeiro if // comando simples // comando simples // comando 2 do primeiro if Primeira dúvida: O else pertence a qual if? 26 . if ((numero % 2) == 0) printf("Número é PAR\n").h> int main (void) { int numero. } Observação: Note que no comando 2 (do primeiro if) existe outro if. else printf("2"). &numero).if encadeados Um if aninhado (ou encadeado) é um comando if dentro de outro comando if ou if . Programa exemplo (8): O usuário digita um número e o programa diz se este é zero. return(0). positivo ou negativo. else if (num > 0) printf("Positivo\n").2.. #include <stdio. &num). #include <stdio. printf("Digite um número: "). printf("Digite um número: "). else printf("Negativo\n").Programa exemplo (7): O usuário digita um número e o programa diz se este é par ou ímpar. scanf("%d".1 . Exemplo: if (x) if (y) printf("1").h> int main (void) { int num. else. return(0). else printf("Número é IMPAR\n").

neste exemplo o else pertence ao segundo if. . break.O comando switch O comando switch é um comando de seleção que permite selecionar um comando entre vários outros comandos. ou seja. default: seqüência de comandos. Observação: A variável não pode ser uma string (char *) e nem real (float).h> int main (void) { chaves para anular a associação normal 27 .Funcionamento: Em C o else está ligado ao if mais próximo (mais interno). . o programa executa o comando ou bloco de comandos que estejam associados àquela constante. 7. Segunda dúvida: Como fazer para que o else (do exemplo acima) pertença ao primeiro if? Resposta: Deve-se utilizar (veja exemplo abaixo). Neste exemplo a variável dígito é inteira. Programa exemplo (9): O programa recebe um dígito de 0 à 9 e imprime na tela. Exemplo: if (x) { if (y) printf("1"). . #include <stdio. } else printf("2"). Cada um dos comandos está ligado a uma constante. O comando break é utilizado para obrigar a saída do comando switch. Isto é feito através da comparação de uma variável a um conjunto de constantes. case constante_2 : seqüência de comandos. por extenso. } O programa testa uma variável sucessivamente contra uma lista de constantes inteiras ou caracteres (int ou char). Sintaxe: switch (variável) { case constante_1 : seqüência de comandos. Depois de encontrar uma coincidência. A opção default é opcional. este dígito.3 . O comando default é executado se não houver nenhuma coincidência. break.

break. por causa disto as constantes estão entre apostrofes. break. break. case ‘3’: printf("Três\n"). case 6: printf("Seis\n"). switch (digito) { case '0': printf("Zero\n"). break. break. printf("Dígito [0 .int digito. } } Programa exemplo (10): O programa recebe um dígito de 0 à 9 e imprime na tela. break. case 9: printf("Nove\n"). case 2: printf("Dois\n"). case ‘4’: printf("Quatro\n"). break. #include <stdio. 28 . 9]: "). por extenso. break. switch (digito) { case 0: printf("Zero\n"). break. case '1': printf("Um\n"). break. &digito). break. printf("Dígito [0 . case ‘6’: printf("Seis\n")..h> int main (void) { char digito. case 5: printf("Cinco\n"). este dígito. case 8: printf("Oito\n"). break. case 3: printf("Três\n"). break. case ‘5’: printf("Cinco\n"). break. case ‘7’: printf("Sete\n"). break. default: printf("ERRO: Não é um digito\n"). case 7: printf("Sete\n").. Neste exemplo a variável dígito é caracter. 9]: "). scanf("%d". case 1: printf("Um\n"). case 4: printf("Quatro\n"). scanf("%c". &digito). break. break. case '2': printf("Dois\n"). break.

alteração e término. printf("[A]lteração\n"). antes que todos os comandos sejam executados. 29 . break. switch (opcao) { case 'i': case 'I': inclusao(). printf("[I]nclusão\n"). break. printf("[T]érmino\n"). Isto é feito através da avaliação de uma condição. Quando a condição se tornar falsa o comando while é finalizado. case '9': printf("Nove\n"). } } Programa exemplo (11): O programa constrói um menu com três funções: inclusão. break. printf("Qual a opção: "). ou seja.4 . break. default: printf("ERRO: Opção Inválida\n"). #include <stdio. opcao = getchar().h> int main (void) { char opcao.Comando while O comando while é um comando de repetição que permite executar um comando (simples) ou vários comandos (composto) diversas vezes. } } void inclusao(void) { } void alteracao(void) { } void termino(void) { } 7.case ‘8’: printf("Oito\n"). break. O teste da condição é feita no início do comando. case 'a': case 'A': alteracao(). case 't': case 'T': termino(). default: printf("ERRO: Não é um digito\n"). Enquanto a condição for verdadeira os comandos são repetidos.

Comando vazio: while (1). // inicialização da variável de controle while (i <= 10) // condição i <= 10 { printf(“i = %d\n”. Veja o exemplo abaixo: Exemplo: for (x = 1. Na condição podem ser utilizados ainda variáveis. i++). porque? Explicação: O comando printf não faz parte do comando if devido ao ponto-e-vírgula no comando for. // while não repete nenhum comando comando for não repete nenhum comando Verifique: Note que no final dos dois comandos (while e for) existe apenas um ponto-e-vírgula. caracterizando comandos vazios. funções. } // comando composto Condição: Qualquer expressão válida em C com resultado 0 (false) ou !0 (true). i <= 1000. x++) printf(“x = %d\n”. 30 . x). pois este ponto-e-vírgula (inserido acidentalmente) faz com que os comandos que seriam repetidos.Observação: Note que os comandos podem não ser executados nenhuma vez. i = i + 1. Quando a condição se tornar falsa o controle do programa passa para a próxima instrução. ou seja. basta a condição começar como falsa. O comando for termina quando a variável de controle x chega ao valor 11. x <= 10. operadores (aritméticos. // incremento } Comando: Pode ser um comando vazio. Sintaxe: while (condição) comando. isto é o sinal de comando vazio. Problema freqüente de digitação: Muitas vezes o programador insere um ponto-e-vírgula no final de um comando for ou while por engano. não são. relacionais e lógicos). // note o ponto-e-vírgula no final do comando for // é impresso x = 11 na tela. O laço while verifica a condição no início do laço. x <= 10. simples ou composto que serão repetidos. comando 2. printf(“x = %d\n”. // comando simples ou while (condição) { comando 1. Exemplo: int i = 0. a variável de controle do laço deve ser inicializado. Funcionamento do comando: O loop (laço) é repetido enquanto a condição for verdadeira. i). constantes. Isto é um grave problema. // comando for (i = 0. normalmente. os comandos while e for que teriam outros comandos não os tem. x++). Comando correto: for (x = 1. x). por causa disto.

} // inicialização: i = 1 // condição: i <= 10 // incremento: i++ Programa exemplo (14): O programa imprime na tela: #include <stdio.j = 9 i = 2 . Quando a condição se tornar falsa o comando for é finalizado.j = 8 i = 3 . i++) printf("%d\n".i). condição. incremento ou decremento) comando.5 . Programa exemplo (13): O programa imprime de 1 até 10 na tela. Incremento ou decremento: Define a maneira como a(s) variável(is) de controle do laço serão alteradas após a repetição do laço. Qualquer uma das 3 partes do comando for (inicialização. incremento) podem ser qualquer expressão válida em C. // incremento } } 7. // inicialização da variável de controle while (letra != 'Z') { printf ("Letra: %c\n". Sintaxe: for (inicialização.Programa exemplo (12): O programa imprime caracteres de ‘A’ até ‘Z’ na tela. letra++. Isto é feito através da avaliação de uma condição. A condição é sempre testada no começo do laço. separados por vírgula) que o compilador utiliza para inicializar a(s) variável(is) de controle do laço.O comando for O comando for é um comando de repetição que permite executar um comando (comando simples) ou vários comandos (comando composto) diversas vezes.h> int main (void) { char letra = 'A'.h> int main (void) { i = 1 . for (i = 1. que testa a variável de controle do laço contra algum valor para determinar quando o laço terminará. letra).j = 6 31 . Condição: É uma expressão qualquer. Enquanto a condição for verdadeira os comandos são repetidos. Inicialização: É um comando de atribuição (ou vários.j = 7 i = 4 .h> int main (void) { int i. #include <stdio. #include <stdio. condição.    O laço (for) é repetido enquanto a condição é verdadeira. i <= 10.

.Interrupção de loops 32 . // ou decremento // ou decremento 7.. Testa a condição no final. } 7.. i++.   Repete o laço enquanto a condição for verdadeira. O teste da condição é feita no final do comando.6 . while é finalizado..j = 9. Isto é feito através do teste de uma condição. } ou inicialização. #include <stdio. incremento. j.j = %d\n". } while (condição).. Quando a condição se tornar falsa o comando do . ou seja. i++. } while (i <= 10). for (i = 1.j--) printf("i = %d .7 . } O laço for é equivalente ao seguinte comando: inicialização. while é um comando de repetição que permite executar um comando (comando simples) ou vários comandos (comando composto) diversas vezes.int i.O loop do { } while O comando do . } while (condição). depois que os comandos são executados (Note que os comandos são executados pelo menos uma vez).i). Sintaxe: do { comando. i != j. i . Enquanto a condição for verdadeira os comandos são repetidos. incremento. do { printf("%d\n".j). do { comando. fazendo com que o laço seja executado pelo menos uma vez.h> int main(void) { int i = 1.. Programa exemplo (15): Imprime na tela de 1 até 10. while (condição) { comando.

O comando break Quando o programa encontra o comando break dentro de um laço. // laço eterno } 7.O comando continue O comando continue em vez de forçar o encerramento. printf("Tecla: %c\n". ou seja. do { tecla = getchar(). } while (1). quando o usuário teclar ESC // 0 é par.2 .7. 1 é impar // imprime somente números pares 33 . #include <stdio. No caso do comando for. depois.7. for (i = 0. o programa primeiro executa o incremento (ou decremento) do laço e. Programa exemplo (16): O programa imprime na tela a tecla digitada pelo usuário até que ele digite <esc>.8 .h> #define ESC 27 int main(void) { char tecla.1 . printf("Par: %d\n". #include <stdio. i). não executa o código que estiver depois do comando continue. executa o teste da condição antes de finalmente fazer o laço continuar. } } Nos laços while e do {} while um comando continue faz com que o controle do programa execute diretamente o teste da condição e depois continue o processo do laço. e o controle do programa segue para o próximo comando após o laço. Programa exemplo (17): O programa imprime na tela somente os números pares de 0 até 100. força a próxima interação do laço e "pula".7. if (tecla == ESC) // encerra o laço break.A função exit () A função exit aborta o programa em qualquer situação. ele imediatamente encerra o laço. i++) { if (i % 2) continue. tecla).h> int main(void) { int i. i < 100. 7.

34 .Modo de usar: exit(0). ou exit(!0).

2 .Saída formatada (printf) Sintaxe: printf ("string de controle".dddd e [+/-]ddd Valor com sinal na forma e ou f baseado na precisão do valor dado Mesmo que e. E. c. lista de variáveis). Se não é colocado. e pelos comandos de formatação (%c. mas com E para expoente Mesmo que g. . e.h.. String de controle: Formada pelos caracteres que a função imprime na tela. as entradas e saídas são realizadas através da utilização das funções da biblioteca padrão do C.dddd Valor com sinal da forma [-]d. d.1 . C.h. b. 8. (+) O resultado sempre começa com o sinal + ou (#) Especifica que o argumento será impresso usando uma das formas alternativas Formas alternativas:   0 x ou X É colocado zeros (0) antes do argumento É colocado 0x (ou 0X) antes do argumento 35 . Preenche o restante do campo com brancos. %d. mas com E para expoente Um caracter O caracter % é impresso Armazena o número de caracteres escritos até o momento imprime como um ponteiro Flags (Bandeiras):    (-) Alinha o resultado à esquerda. B.1 ..2. \t.8. D. alinha o resultado à direita e preenche o restante à esquerda com zeros ou brancos.Entrada e saída formatada 8.). F) Valor com sinal da forma [-]dddd. Tabela 11: Comandos de formatação Código %s %d %i %o %u %x %X %f %e %g %E %G %c %% %n %p Tipo char * int int int int int int float float float float float char nada int * ponteiro Formato String (vetor de caracteres) Inteiro decimal com sinal Inteiro decimal com sinal Inteiro octal sem sinal Inteiro decimal sem sinal Inteiro hexadecimal sem sinal (com a. espera por <enter> putchar() Escreve um caracter na tela scanf() Lê qualquer tipo de dado. Entrada e saída Em C. %f) que definem a maneira como as variáveis serão impressas e caracteres especiais (\n. espera por <enter> printf Imprime na tela qualquer tipo de dado fgets() Lê uma string do teclado (aceita espaço) puts() Escreve uma string na tela 8. %s.Entrada e saída do console As seguintes funções estão definidas em stdio. Tabela 10: Funções de entrada e saída via console Função Efeito (Entrada) getchar() Lê um caracter do teclado. f) Inteiro hexadecimal sem sinal (com A. algumas são encontradas no arquivo stdio.

h> int main(void) { char s[256] = "".50e+000 05.50e+000 +5.) que será lido pelo teclado (não deve conter mais nenhum caracter).&idade). float salario.50 5. char nome[40].50 0000005.2f +000005. 36 // ATENÇÃO: nome é igual ao &nome[0] // scanf não aceita espaços // &idade é o endereço da variável idade // &salário é o endereço da variável salário .50 +000005.50 +5.50e+000 5. } ScanSet: Funciona como uma entrada seletiva de caracteres na função “scanf”. Programa exemplo (18): O programa permite a entrada (via teclado) do nome. %c.2. Lista de variáveis: Nome da(s) variável(is) que será(ão) lida(s) pelo teclado. %s.&salario).50 +5.50e+000 +5. int x.50 +5.50 5.50e+000 +5.50e+000 05. scanf(“%d”.50 5. . String de controle: Local onde é definido o tipo de dado (%d. Veja o programa exemplo abaixo: #include <stdio.50 8..50 +5.50e+000 5. scanf("%d". #include <stdio.2e +5.&x).50e+000 +5.50e+000 +5.50e+000 5.str[256] = "".50 +000005.Especificadores de largura do campo a ser impresso (exemplos): Tabela 12: Especificadores de largura do campo Prefixo %-+#0 %-+# %-+0 %-+ %-#0 %-# %-0 %%+#0 %+# %+0 %+ %#0 %# %0 % 6d +00555 +555 +00555 +555 000555 555 000555 555 +00555 +555 +00555 +555 000555 555 000555 555 6o 01053 01053 01053 1053 001053 01053 01053 1053 01053 01053 01053 1053 001053 01053 001053 1053 8x 0x0022b 0x22b 000022b 22b 0x00022b 0x22b 0000022b 22b 0x0022b 0x22b 000022b 22b 0x00022b 0x22b 0000022b 22b 10. &f.. Observação: Deve ser passado o endereço do argumento a ser lido. scanf("%s". printf("Idade: ").50e+000 10.50 0000005. printf("Qual seu nome: "). lista de variáveis).50e+000 05.Entrada formatada (scanf) Sintaxe: scanf ("string de controle".50e+000 5. printf("Salário: ").50e+000 +5.2 . scanf("%d".h> int main(void) { int idade.50 0000005.50e+000 +5.50 0000005.50 5.50e+000 05. nome).50 +000005. idade e salário de uma pessoa.

%c. &f.s).2.scanf("%[aeiou]". s). %s.. } Modificadores de formato: char s[31].Saída na impressora (fprintf) Sintaxe: fprintf (stdprn.h> int main(void) { fprintf(stdprn. scanf("%[^A-Z]". s)."%c\n".3 – Leitura de strings (fgets) Sintaxe: fgets (char *string.15).Comprime os caracteres na impressora // stdin é a entrada padrão (teclado) // puts imprime na tela uma string fprintf(stdprn. puts(str). ."UCPel – Universidade Católica de Pelotas\n"). scanf(“%30s”. FILE *fp). str). "string de controle"."%c\n". str).12). 8. return(0).) que será lido pelo teclado (não deve conter mais nenhum caracter). 30. // Não lê caracteres maiúsculos printf("String (str): %s\n".3 . } Observação: // -------------------------. // Copia apenas 30 caracteres para “s” de A à Z 8. String de controle: Local onde é definido o tipo de dado (%d. } Observação: stdin (entrada).Salta uma página na impressora // -------------------. fgets(str. 37 . fprintf(stdprn. lista de variáveis). stdprn: Fila de impressão (standard printer) Programa exemplo (19): O programa imprime “UCPel” na impressora. // lê apenas as vogais “aeiou” printf("String (s): %s\n".. stdin).h> int main() { char str[31]. stdout (saída) e stderr (erro) são arquivos especiais que são abertos para cada programa que é executado. #include <stdio. int tam. #include <stdio. return(0). Lista de variáveis: Nome da(s) variável(is) que será(ão) lida(s) pelo teclado. printf("Digite seu nome: ").

. Por linha de comando fica assim: $ gcc palavras. dentre outras funções. posicionar o cursor... Tutorial da biblioteca ncurses: http://www. colorir texto. “Definições de Compilação e Link..9.del. Controle do vídeo e teclado 9. “Bibliotecas” .... “curses” (Screen handling and optimization routines) . “Adicionar”..c -o palavras -lcurses <enter> No ambiente de programação anjuta tem que incluir em “Definições” .ufrj.br/~pcfilho/ncurses/ncurses. pode-se ser utilizada a biblioteca “ncurses”. Figura 4: Jogo de Caça-Palavras No linux é necessário incluir a biblioteca “curses”.modo texto No linux para limpar a tela. 38 .” .htm Veja mais detalhes da biblioteca ncurses no capítulo 20. O programa exemplo 78 mostra o uso desta biblioteca através da implementação de um jogo de caça-palavras...1 Biblioteca “ncurses” .

Lista de exercícios (comandos) 10. n2.0 (inclusive) e 7.90 <enter> Total a pagar: 17.0 entre 7.0 ou acima de 9.10. PI .4 Desenvolva um programa em C que recebe via teclado: peso da carne que será vendida (em quilos) e preço por quilo. raio diâmetro = 2 . O programa deve calcular e imprimir na tela o diâmetro e o raio da circunferência (veja exemplo abaixo). n3 e n4 obtidas por um aluno em 4 avaliações.1 Escreva um programa em C que recebe dois valores via teclado: cateto adjacente (b) e cateto oposto (a) e calcula o valor da hipotenusa dado pela seguinte fórmula: Fórmula: h2 = a2 + b2 Exemplo (Tela): Cateto adjacente (b): 3 <enter> Cateto oposto (a): 4 <enter> Hipotenusa: 5 10.5 abaixo de 6. raio Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]? 10.3 Escreva um programa em C que recebe via teclado: comprimento da circunferência.73 Continua [S/N]? N <enter> comprimento da circunferência = 2 .5 <enter> Preço por Kg (R$): 9. Exemplo: Comprimento da circunferência: 36 <enter> Diâmetro: 11.00 <enter> Total a pagar: 13.0 Conceito A B C D 10. Exemplo (Tela): Peso: 3.46 Raio: 5. o valor pago ao ICMS (17%) e o lucro líquido do açougue.0 entre 6.91 Lucro líquido do açougue (R$): 14.24 Sair [S/N]? n <enter> Peso: 1. O programa deve calcular e imprimir na tela o total a pagar.15 ICMS (17%): 2.2 Escreva um programa em C que lê 4 notas via teclado: n1.5 39 .5 (inclusive) e 9.5 <enter> Preço por Kg (R$): 4. Calcule a média utilizando a seguinte fórmula: n1 + n2 * 2 + n3 * 3 + n4 Média = --------------------------7 A seguir imprima na tela a média e o conceito do aluno baseado na seguinte tabela: Média 9.

99]: 0 <enter> 40 . [2] Eqüinos ou [3] Ovinos.7 Escreva um programa em C que recebe via teclado: a data de hoje da seguinte forma: dia.00 Comissão a pagar (R$): 70.00 Continua [S/N]? s <enter> 10.5 Escreva um programa em C que recebe via teclado: tipo de animal [1] Gado. eqüinos: 7% e ovinos: 3%).21 Sair [S/N]? S <enter> 10. preço unitário do animal e quantidade de animais comprado.00 Comissão a pagar (R$): 100. mês. O programa termina quando o usuário digitar 0 (zero). Exemplo (Tela): Qual a data de hoje: Dia: 16 <enter> Mês: 6 <enter> Ano: 2003 <enter> Qual a sua idade: Anos: 41 <enter> Meses: 4 <enter> Dias: 6 <enter> Data de Nascimento: 10/02/1962 Continuar [S/N]? s <enter> 10. [2] Eqüinos ou [3] Ovinos: 1 <enter> Preço unitário do animal (R$): 200 <enter> Quantidade de animais: 10 <enter> Preço total pago (R$): 2100. [E]qüinos ou [O]vinos: g <enter> Preço unitário do animal (R$): 200 <enter> Quantidade de animais: 10 <enter> Preço total pago (R$): 2100. O programa deve calcular e imprimir a data de nascimento no seguinte formato: dd/mm/aaaa. [E]qüinos ou [O]vinos. conforme exemplo abaixo: Exemplo (Tela): Tipo de animal [1] Gado.00 Comissão a pagar (R$): 100. eqüinos . Exemplo: Número [0. O programa deve imprimir na tela este número por extenso (conforme exemplo abaixo).7% e ovinos ..99]: 23 <enter> Vinte e três Número [0.00 Continua [S/N]? s <enter> Tipo de animal [1] Gado. da seguinte forma: anos.00 Continua [S/N]? N <enter> 10.8 Escreva um programa em C que recebe via teclado um número inteiro de 0 à 99.29 Lucro líquido do açougue (R$): 11. O programa deve calcular e imprimir na tela: preço total pago e a comissão do escritório de remate (gado 5%.99]: 45 <enter> Quarenta e cinco Número [0.ICMS (17%): 2. ano e a sua idade.. meses e dias vividos. O programa deve calcular e imprimir na tela: preço total pago e a comissão do escritório de remate (gado: 5%.. [2] Eqüinos ou [3] Ovinos: 2 <enter> Preço unitário do animal (R$): 1000 <enter> Quantidade de animais: 1 <enter> Preço total pago (R$): 1070. conforme exemplo abaixo: Exemplo (Tela): Tipo de animal [G]ado.3%).6 Reescreva o programa anterior recebendo via teclado uma letra para o tipo de animal [G]ado. preço unitário do animal e quantidade de animais comprados.

o conceito do aluno (dado pela tabela abaixo) e a situação (aprovado.46 à vista: 5% 10.19 Diesel . Calcule e imprima na tela a temperatura correspondente a solicitação do usuário.10 Escreva um programa em C que recebe via teclado duas notas: nota1 e nota2.1.10.0 à 8.9 0. tipo de combustível ([A]lcool.1. O programa deve calcular e imprimir na tela: total à prazo.23 .= 5 F - 32 41 . --. Tela de execução: Quantidade de litros? 50 <enter> Tipo de combustível [A]lcool.5 Conceito: B Situação: Aprovado Sair [S/N]? s <enter> Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? 10. [G]asolina ou [D]iesel ? G <enter> Gasolina Tipo de pagamento [P]razo ou a [V]ista ? V <enter> Total à prazo (R$) : 109.2.0 7. conforme exemplos abaixo: Exemplo: Temperatura: 30 <enter> Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): F <enter> Temperatura em Fahrenheit: 86 Continua [S/N]? S <enter> Temperatura: 86 <enter> Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): C <enter> Temperatura em Celsius: 30 Continua [S/N]? n <enter> Fórmula: C 9 .9 6.0 à 5. [G]asolina ou [D]iesel) e o tipo de pagamento ([P]razo ou [V]ista).48 Desconto Total à vista (R$): 104. O programa deve imprimir na tela a média. exame ou reprovado): Conceito A B C D Nota1 + Nota2 Média = ----------------2 Média 9. O programa termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?".9 Escreva um programa em C que recebe via teclado: quantidade de litros vendidos.0 à 6.02 Continua [S/N]? N <enter> Valores: Álcool .50 Desconto (R$): 5. desconto e o total à vista.11 Escreva um programa em C que recebe via teclado uma temperatura e o tipo de conversão (converter para: [C]elsius ou [F]ahrenheit).9 Exemplo: Situação Aprovado Aprovado Exame Reprovado Nota1: 7 <enter> Nota2: 8 <enter> Média: 7.0 à 10.

1 x altura – 44. dado pela seguinte fórmula: ângulos em graus = graus + Exemplo: Graus: 45 <enter> Minutos: 45 <enter> Segundos: 45 <enter> Ângulo em Graus: 45. minutos ---------60 + segundos ---------3600 10.17 Continua [S]im ou [N]ão? N <enter> Observação: Imprimir mensagens de erro se os valores de entrada estiverem fora da faixa: ERRO: Graus fora da faixa. ERRO: Minutos fora da faixa ou ERRO: Segundos fora da faixa.10.12 Escreva um programa em C que recebe via teclado: graus (0 à 360). IDEAL ou GORDO) (conforme exemplo abaixo): Exemplo: Sexo [M]asculino ou [F]eminino: M <enter> Altura: 1.7 x altura – 58 PIF = 62. minutos (0 à 59) e segundos (0 à 59).0 Situação: GORDO Sair [S/N]? s <enter> MAGRO IDEAL GORDO -------------------|-------------------|---------------------5% pi 5% Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? PIM = 72.7 42 . altura e peso da pessoa.65 <enter> Peso: 92 <enter> Peso Ideal: 62.76 Continua [S]im ou [N]ão? S <enter> Graus: 45 <enter> Minutos: 10 <enter> Segundos: 15 <enter> Ângulo em Graus: 45. diferença de peso e situação (MAGRO.13 Escreva um programa em C que recebe via teclado: sexo ([M]asculino ou [F]eminino). O programa deve calcular e imprimir na tela: peso ideal.0 Diferença de Peso: 30. O programa deve calcular e imprimir na tela o ângulo em graus.

Vetores. x[9] número de bytes: 10 x 2 = 20 bytes (um inteiro ocupa 2 bytes) Observação: O programador deve verificar os limites do vetor. compará-los e classificá-los. ou seja.1D) é um tipo especial de matriz que possui apenas um índice. float. ou seja.Vetores Vetor (matriz de uma dimensão . int. Uma string pode armazenar qualquer tipo de caracter válido da tabela ASCII. ao mesmo tempo. Um vetor consiste em locações contíguas de memória. tipo_dos_dados Onde: tipo_dos_dados: tipo de dado de cada elemento (char. “travar” o programa. nome_do_vetor: nome da variável que irá representar o vetor número_de_elementos: número total de elementos do vetor primeiro elemento: 0 último elemento: número_de_elementos – 1 número de bytes ocupados na memória RAM: número_de_elementos x quantidade_de_bytes_de_um_elemento Exemplo: int x[10]. 11.11. permitindo. na memória RAM. o programador pode referenciar qualquer elemento do vetor. permite armazenar variáveis unidimensionais (permite representar uma tabela). ou seja. inclusive um que não existe.2 – Strings Uma string (cadeia de caracteres) é um tipo de dado que consiste de um conjunto de caracteres. // 10 elementos: x[0] à x[9] nome_do_vetor [número_de_elementos]. os elementos encontram-se em seqüência (contigüidade física). ou seja. pois o compilador C não verifica estes limites. Exemplo: Vetor unidimensional de inteiros (idades). primeiro elemento: x[0] último elemento: x[número_de_elementos – 1].1 . por exemplo. double). Isto pode causar um grave erro. 43 . Tabela 16: Exemplo de um vetor unidimensional Índice Valor 0 24 1 12 2 36 3 41 11. e o maior corresponde ao último elemento. O menor endereço corresponde ao primeiro elemento. utilizando-se um índice para diferencia-los. matrizes e strings Um vetor é uma coleção de variáveis de mesmo tipo (agregados homogêneos) que são referenciadas pelo mesmo nome. Uma vantagem na utilização de uma vetor é poder armazenar vários valores (elementos).

ASCII: Americam Standard Code for Information Interchange. não é necessário acrescentar o NULL. url: http://www. Isto é um problema se quisermos (mais tarde) acrescentar mais caracteres na variável string. onde o tamanho do índice esquerdo determina o número de strings e o tamanho do índice direito especifica o comprimento máximo de cada string. isto é feito utilizando os dois índices. não foi necessário especificar o número_de_elementos da string.Vetor de strings Para criar um vetor de strings. deve-se utilizar uma matriz bidimensional de caracteres. ou seja. nome[0]. Para acessar uma string particular deve-se especificar apenas o índice esquerdo. nome[1] ou nome[2]. totalizandom neste caso. 0 ‘U’ ‘U’ ‘U’ Tabela 17: Exemplo de um vetor de strings 1 2 3 4 5 6 ‘C’ ‘P’ ‘e’ ‘l’ NULL lixo ‘C’ ‘S’ NULL lixo lixo lixo ‘F’ ‘P’ ‘e’ ‘l’ NULL lixo 7 lixo lixo lixo 0 1 2 Cria um vetor com 3 strings com 7 caracteres + '\0' (NULL) cada uma. Observação: Note que no exemplo acima.[tamanho_n]. 44 .asciitable. como por exemplo. nome[0] -> “UCPel” nome[1] -> “UCS” nome[2] -> “UFPel” Observação: Pode-se acessar também qualquer caracter de qualquer uma das strings. Um zero é representado como (char) NULL. 11. nome[2][1] é caracter ‘F’. // matriz 2D Exemplo: float y[5][5].com Em C. O compilador C interpreta que o tamanho da string é a quantidade de caracteres da inicialização (5) mais um (1) para o NULL. pois o compilador faz isso automaticamente. char string[] = “teste”.. seis (6) elementos.4 . Note que o primeiro elemento é y[0][0] e o último elemento é y[4][4]. deve-se escrever y[3][4].Matrizes (Multidimensional) tipo_dos_dados nome_variável [tamanho_1][tamanho_2]. Para acessar o elemento 3. 4 da matriz y.3 . Observação: Na inicialização de uma constante string "teste". uma string consiste em um vetor de caracteres finalizado por um zero. pois não foi reservado espaço préviamente para estes novos caracteres. por exemplo. Exemplo: char nome[3][8]. O total de elementos é 25.. 11.

Exemplo: char s[] = "UCPel".2.6.4}. // vetor i – 1D Observação: Quando um vetor é declarado e inicializado (ao mesmo tempo) o número de elementos (neste caso 10) pode ser suprimido. // s ocupa 6 bytes Programa exemplo (23): O programa permite armazenar n nomes e idades em dois vetores.16} }. ou seja.Inicialização de vetores e matrizes sem tamanho Na inicialização de uma matriz (ou vetor).h> #define MAX 10 int main(void) { char nome[MAX][41].3. 45 .Inicialização de matrizes e vetores tipo_dos_dados nome_matriz [tam_1]. ou int i[] = {0. i = 0.5.h> #include <string. 11.2.7.7 . Exemplo: int i[10] = {0. por vírgulas que são lista_valores: lista de constantes separadas compatíveis em tipo com o tipo base da matriz. char ch. se não for especificado seu tamanho.6 .1. n.4.Inicialização de um vetor de caracteres char nome_vetor [tamanho] = "string". neste caso é opcional (veja exemplo anterior).1. então o compilador C cria uma matriz (ou vetor) grande o suficiente para conter todos os inicializadores presentes.[tam_n] = {lista_valores}.7.. int i. {2.Inicialização de matrizes multidimensionais int y[4][2] = { {1.5.8.6. y[0][0] y[0][1] y[1][0] y[1][1] = = = = 1 1 2 4 y[2][0] y[2][1] y[3][0] y[3][1] = = = = 3 9 4 16 11.5 . #include <stdio.4.9}.8. Exemplo: char str[4] = "sim". int idade[MAX].9}..11.3. {4.1}. 0 ‘s’ 1 ‘i’ 2 ‘m’ 3 NULL ou '\0' 11. {3.9}.8 .

do { ch = getchar(). nome[i]. } Programa exemplo (24): O programa realiza a soma de duas matrizes (A e B) bidimensionais.Classificação de dados ou ordenação (sort) Para exemplificar melhor as variáveis do tipo vetor.1.j. b[MAX][MAX].&m). i <= n. scanf("%d". scanf("%s". // limpa o buffer de entrada printf("Idade: "). também chamado sort (classificação de dados): 46 .%d] = %d\n". } } 11.lin.c[lin][col]). do { printf("Número de linhas (m): ").%d] = ".col++) { c[lin][col] = a[lin][col] + b[lin][col]. // entrada de um nome (somente um nome) fflush(stdin). // n de 1 à 10 for (lin = 1.col <= n. // m de 1 à 10 do { printf("Número de colunas (n): ").col.%d] = ". int col.col).lin <= m.&n).lin. // entrada de uma idade i++.lin.do { printf("Nome: ").col).lin++) for (col = 1.col++) { printf("A[%d.n.&a[lin][col]). c[MAX][MAX].lin++) for (col = 1. } printf("\n"). scanf("%d".lin. scanf("%d". gerando uma matriz resultante C. } while (n < 1 || n > MAX). scanf("%d". abaixo são mostrados dois tipos de ordenação.lin <= m. nome[i]). } while (ch != 'N' && ch != 'n' && i < MAX). printf("C[%d.h> #define MAX 10 int main(void) { int a[MAX][MAX]. #include <stdio. // número de elementos for (i = 0. printf("Continua [S/N]? "). scanf("%d". for (lin = 1. printf("Informe a ORDEM da MATRIZ: (mxn)\n"). &idade[i]).m. i++) printf("| %-41s | %d | \n".&b[lin][col]). n = i .col <= n.9 . } while (m < 1 || m > MAX). printf("B[%d. } while (ch != 'S' && ch != 's' && ch != 'N' && ch != 'n'). idade[i]).

n. // toupper: converte o caracter para maiúsculo } while (!strchr(“SN”. do { printf("Nome: "). for (i = 0. i <= n.&nome[n]). // scanf – permite a entrada de um nome printf("Continua [S/N]? "). strcpy(nome[i]. do { n++. // entrada de um nome !0 0 47 . tecla)). printf("Nome: "). i++) for (j = i+1. int i.h> #define QUANT 50 int main(void) { char nome[QUANT][41]. temp). int sort. #include <stdio. // strchr: verifica se o caracter pertence string } while (tecla != 'N' && n < QUANT). nome[i]). n++. i++) printf("Nome: %s\n". j++) if ((strcmp(nome[i]. char tecla. scanf(“%s”. j.h> #include <string. funções strcpy.nome[n]).Programa exemplo (25): O programa classifica os nomes digitados pelo usuário. } // strcmp – permite comparar strings // strcpy – permite copiar strings Observação: As próxima seção.h> #define TRUE #define FALSE #define QUANT 50 int main(void) { char nome[QUANT][40]. nome[j]). nome[i]). tecla. } printf("\nNomes ORDENADOS\n"). int i. char temp[40]. k.h> #include <string. n = -1. for (i = 0. scanf(“%40s”. strcpy(nome[j]. char temp[41]. j <= n. nome[j])) > 0) { strcpy(temp.h> #include <ctype. do { tecla = toupper(getchar()). n. i <= n-1. strcmp e strchr são discutidas na Programa exemplo (26): O programa utiliza um método de sort chamado bubble sort (método da bolha) para classificar nomes. #include <stdio. n = 0.

i <= n. printf("\nNomes ORDENADOS:\n"). tecla)). O programa deve imprimir na tela.2 Escreva um programa em C que recebe via teclado: número de idades (máximo 50) e as respectivas idades. nome[i]). temp). nome[i]).10 . for (i = 0. i++) if ((strcmp(nome[i]. o programa deve receber via teclado: idade para consulta. i++) printf("Nome: %s\n". tecla) && n < QUANT). } while (sort). strcpy(nome[i]. } k--. Logo após copie todas as letras (em ordem inversa) para outro vetor (inverso). letras ‘L’ ‘M’ inverso 0 2 ‘I’ 0 ‘D’5‘A ’7‘B Buble sort 0 Exemplo: Letra: Letra: Letra: Letra: Letra: LIMA AMIL L <enter> I <enter> M <enter> A <enter> <esc> ‘A’ ‘E’ 11. } while (!strchr(“SsNn”. nome[i+1]). // n é o número de elementos k = n. } while (strchr(“Ss”. for (i = 0. Armazene todas as letras em um vetor (letras) até que o usuário digite um ESC (código 27).Lista de exercícios (vetores) 11. Ao final imprima os dois vetores.printf(" Continua [S/N]? "). } 11. Logo após a entrada de todas as idades. sort = TRUE. i < k.10.10.1 Escreva um programa em C que recebe via teclado um conjunto de letras (máximo 20). o número de idades antes da idade de consulta e o número de idades depois da idade de consulta. do { sort = FALSE. strcpy(nome[i+1].1. do { tecla = getchar().nome[i+1])) > 0) { strcpy(temp. n = n . Exemplo: Número de idades: 6 <enter> Idade: 30 <enter> Idade: 60 <enter> Idade: 10 <enter> Idade: 50 <enter> Idade: 20 <enter> Idade: 40 <enter> Idade para consulta: 50 <enter> Antes: 3 Depois: 2 Continua [S/N]? n <enter> 48 . Armazene todas as idades em um vetor (idade).

Imprima na tela o número de alunos: aprovados (A. C. A entrada dos nomes termina quando o usuário digitar apenas <enter>.10. O programa deve imprimir na tela a posição do número no vetor ou ERRO: Número não encontrado (veja exemplos abaixo): Exemplo:Número: 50 <enter> Número: 30 <enter> Número: 20 <enter> Número: 10 <enter> Número: 40 <enter> Número: 0 <enter> Valor: 20 <enter> Posição no vetor: 2 Valor: 40 <enter> Posição no vetor: 4 Valor: 60 <enter> ERRO: Número não encontrado Valor: 0 <enter> Observação: O programa termina quando o usuário digitar 0 (zero). O programa deve imprimir na tela todos os nomes que começam com a letra especificada pelo usuário. 11.5 Escreva um programa em C que recebe via teclado “n” (máximo 50) nomes (máximo 80 letras).6 Escreva um programa em C que recebe via teclado “n” (máximo 30) nomes (máximo 40 letras) e idades. Logo após permita ao usuário consultar um número informando o seu valor.3 Escreva um programa em C que recebe via teclado um conjunto de números inteiros (máximo 50). Logo após a entrada de todos os dados o programa deve imprimir na tela todos os nomes e idades desde o mais velho até o mais novo. B.4 Escreva um programa em C que recebe via teclado "n" conceitos (A. A entrada dos dados termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Armazene todos os conceitos em um vetor (conceito).10. B e C).10. 49 . O programa termina quanto o usuário digitar <esc> na entrada da letra (conforme exemplos abaixo): Exemplo: Nome: Paulo <enter> Nome: Roberto <enter> Nome: Renato <enter> Nome: Pedro <enter> Nome: Fabio <enter> Nome: <enter> Letra: R <enter> Nome: Roberto Nome: Renato Letra: P <enter> Nome: Paulo Nome: Pedro Letra: T <enter> Letra: <esc> 11.11. Logo após a entrada de todos os nomes o programa deve permitir a entrada via teclado de uma letra. reprovados (D) e os infreqüentes (E). Armazene todos os números inteiros em um vetor até que o usuário digite 0 (zero). D e E) (máximo 25) até que o usuário digite ESC. Exemplo: Conceito: B <enter> Conceito: A <enter> Conceito: E <enter> Conceito: B <enter> Conceito: D <enter> Conceito: C <enter> Conceito: A <enter> Conceito: E <enter> Conceito: <esc> 4 Aprovado(s) 1 Reprovado(s) 3 Infreqüente (s) 11.10.

Exemplo: Nome: Ana <enter> Idade: 12 <enter> Continua [S/N]? s <enter> Nome: Beatriz <enter> Idade: 13 <enter> Continua [S/N]? s <enter> Nome: Carla <enter> Idade: 14 <enter> Continua [S/N]? N <enter> Carla 14 Beatriz 13 Ana 12 50 .

const char *origem).erro). não se pode atribuir vários valores (ao mesmo tempo) para os elementos de um vetor.h> int main(void) { char erro[] = "Arquivo não Existe\n". ou seja. strcmp.12. Prototype: string. Programa exemplo (27): Os caracteres para uma string.h Funcionamento: A string de origem é copiada para a string destino. ‘C’.h> int main(void) { char erro[20]. Sintaxe: char *strcpy (char *destino.strcpy A função strcpy (cópia de string) pré-definida do C que permite copiar uma string para outra ou inicializar uma string. ‘l’. ou s = “UCPel”. printf("ERRO FATAL: %s".h> #include <string.1 . ‘P’. strcat são necessárias pois uma string nada mais é do que um vetor de caracteres.erro). 12."Arquivo não existe\n"). Exemplo: char s[] = “UCPel”. strcpy(erro. } programas abaixo mostram como copiar // incorreto – erro GRAVE em C // correto – elemento por elemento // correto 51 . printf("ERRO FATAL: %s". } ou #include <stdio. ‘e’. NULL. Isto só pode ser feito quando o vetor é declarado e inicializado ou um de cada vez. #include <stdio. Manipulação de strings As funções strcpy. ou s[0] s[1] s[2] s[3] s[4] s[5] = = = = = = ‘U’.

s2). printf("String 1: ").h Funcionamento: destino. printf("%s\n". Sintaxe: char *strcat (char *destino.12. s1 s1 s1 s1 é é é é maior que s2 menor que s2 igual a s2 diferente de s2 resultado resultado resultado resultado > 0 < 0 == 0 != 0 Sintaxe: int strcmp (const char *s1.s2[41].3 . A string origem é copiado para o final da string Programa exemplo (29): O programa cópia e concatena caracteres a uma string resultando na palavra “Pelotas”. printf("%s\n".s2) == 0) printf("String 1 é IGUAL a String 2"). else printf("String 1 é MENOR a String 2"). const char *s2). #include <stdio. scanf(“%s”. } 12.2 .s2). else if (strcmp(s1.s2[] = "ota". const char *origem). #include <stdio.s3).s1).s1).h> int main(void) { char s1[41].s2) > 0) printf("String 1 é MAIOR a String 2").h> #include <string. char sr[15] = "".h> int main(void) { char s1[] = "Pel".h> #include <string. if (strcmp(s1. printf("%s\n". 52 . Prototype: string.h Programa exemplo (28): O programa compara duas strings. printf("String 2: "). scanf(“%s”.s3[] = "s". Prototype: string.strcat A função strcat (concatenação de duas strings) pré-definida do C que permite a concatenação de uma string no final da outra string.strcmp A função strcmp (comparação de duas strings) pré-definida do C que permite comparar duas strings.

Observação: O NULL não é contado. printf("Qual o seu nome: "). #include <stdio. a variável nome. Prototype: string. Sintaxe: int strlen (const char *s). printf("%s\n". strcat(sr.nome). #include <stdio.s3). printf("%s seu nome tem %d caracteres\n".stdin).h Programa exemplo (30): O programa imprime na tela a quantidade de caracteres de uma variável string. } 12.h> int main(void) { char nome[41].s2).4 . nome. char ch).strlen // sr = "Pel" // sr = "Pelot" // sr = "Pelotas" A função strlen (comprimento de uma string) pré-definida do C que retorna o comprimento de uma string.h> #include <string.h Programa exemplo (31): caracteres de um nome. printf("Continua [S]im ou [N]ão ?"). char ch. do { printf("Qual o seu nome: "). Prototype: string. a quantidade de caracteres que a string possui no momento.h> int main(void) { char nome[41]. strcat(sr.h> #include <string. strlen(nome)). } 12.5 – strchr A função strchr (Verifica se um caracter pertence a uma string) pré-definida do C que verifica se um caracter (chr) pertence a uma string (str).sr). Sintaxe: int strchr (const char *s. ou seja. neste caso. strlen(nome)).strcpy(sr. O programa imprime na tela o número de 53 .40. fgets(nome.s1). do { ch = getchar(). scanf(“%s”. printf("Seu nome tem %d caracteres\n".

3 Escreva um programa em C que recebe via teclado uma palavra (máximo 20 letras) e uma posição. se for o caso: Letra antecessora não existe. Logo após a entrada do nome o programa deve imprimir (EM LETRA MAIÚSCULA) o sobrenome da pessoa. } while (strchr("Ss". conforme exemplo abaixo: Exemplo: Palavra: Luzzardi <enter> Letra: z <enter> 2 letra(s) Continua [S]im ou [N]ão? S <enter> Palavra: Luzzardi <enter> Letra: w <enter> ERRO: Não existe a letra (w) na palavra (Luzzardi) Continua [S]im ou [N]ão? N <enter> Observação: O programa deve ser encerrado quando o usuário digitar “N” ou “n” na pergunta: Continua [S]im ou [N]ão?.} while (!strchr("SsNn".ch)). O programa deve imprimir.6. O programa deve imprimir na tela. conforme exemplo abaixo: Exemplo: Nome: Universidade Católica de Pelotas <enter> (3) Letras maiúsculas (26) Letras minúsculas (14) Vogais (15) Consoantes 12. conforme exemplo abaixo: Exemplo: Palavra: Universidade <enter> Posição: 7 <enter> Antecessora: s Letra: i Sucessora: d Observação: O programa deve imprimir na tela as seguintes mensagens de erro.6. Letra sucessora não existe ou Posição inválida. Logo após a entrada do nome imprima: número de letras maiúsculas. número de vogais e o número de consoantes.6. Logo após a entrada do nome e da letra imprima o número de letras que existe no nome ou ERRO: Não existe a letra (?) na palavra (?). conforme exemplos abaixo: Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter> Sobrenome: LUZZARDI Sair [S/N]? N <enter> Nome: Renato Souza <enter> 54 . 12.6 – Lista de exercícios (strings) 12. a letra (da referida posição) e a letra sucessora.2 Escreva um programa em C que recebe via teclado uma palavra (máximo 40 caracteres) e uma letra. 12. a letra antecessora.1 Escreva um programa em C que recebe via teclado um nome (máximo 256 caracteres). } 12. número de letras minúsculas.5 Escreva um programa em C que recebe via teclado um nome (máximo 60 caracteres).ch)). conforme exemplo abaixo: Exemplo:Nome: Paulo Roberto Gomes Luzzardi <enter> Luzzardi Gomes Roberto Paulo 12. as palavras do nome em ordem inversa.6.4 Escreva um programa em C que recebe via teclado um nome (máximo 80 letras).6. uma por linha. na tela.

Logo após a entrada de todos os dados imprima a string resultante ou ERRO: Fim inválido ou Início inválido.Sobrenome: SOUZA Sair [S/N]? s <enter> Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? 12. primeiro nome e demais nomes abreviados.6. Renato L. G. Logo após a entrada do nome o programa deve imprimir na tela: sobrenome.8 Escreva um programa em C que recebe via teclado uma palavra (máximo 20 caracteres). conforme exem-plos abaixo: Exemplo: Palavra: universidade <enter> Início: 7 <enter> Fim: 11 <enter> String resultante: idade Continua [S/N]? s <enter> Palavra: eletricidade <enter> Início: 7 <enter> Fim: 15 <enter> ERRO: Fim Inválido Continua [S/N]? N <enter> Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?. Sair [S/N]? s <enter> Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]? 12. Paulo R.7 Escreva um programa em C que recebe via teclado o nome de um estado (máximo 80 caracteres). Logo após a entrada do nome do estado imprima: a sigla do estado (2 letras maiúsculas). conforme exemplos abaixo: Exemplo: Estado: Rio Grande do Sul <enter> Sigla: RS Estado: são paulo <enter> Sigla: SP Estado: rio de janeiro <enter> Sigla: RJ Estado: <enter> Observação: O programa encerra quando o usuário digitar apenas <enter> na entrada do nome do estado. Sair [S/N]? N <enter> Nome: Renato Lima Souza <enter> Autor: Souza.6. 55 .6 Escreva um programa em C que recebe via teclado um nome (máximo 80 caracteres). 12. conforme exemplos abaixo: Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter> Autor: Luzzardi. início e fim.6.

13. Funções definidas pelo programador
A linguagem de programação C permite que o programador crie e utilize suas próprias funções. Forma Geral: tipo_do_retorno nome_da_função (parâmetros) tipo_dado_base parâmetros; { tipo_dado_base variáveis; // definição corpo da função; return(); } ou tipo_do_retorno nome (tipo_dado_base parâmetros) { tipo_dado_base variáveis; corpo da função; return(); } tipo_do_retorno: Especifica o tipo de dado do retorno da função. O retorno da função é feita pelo comando return (valor). parâmetros: É uma lista, separada por vírgulas, com os nomes das variáveis (e seus tipos) que receberão os argumentos quando a função for chamada. Observação: O tipo default de uma função é int, ou seja, se não for especificado o tipo da função o compilador assume int. Função procedural: É um tipo especial de função que não possui retorno, ou seja, é simplesmente um procedimento. Uma função deste tipo é void. Exemplo: int random (int n) { int t; t = rand() % n; return(x); } Chamada da função: n = random(256);
// retorna um número aleatório entre 0 e 255

das variáveis locais

Programa exemplo (32): O programa possui uma função que calcula o inverso 1/x. #include <stdio.h>

56

float inverso (float x); int main(void) { float inv, resp;

// protótipo da função

printf("x: "); scanf("%f",&x); inv = inverso (x); // chamada printf("Inverso = %.2f\n", inv); }

da função inverso

// ----------------------------- Função definida pelo programador

float inverso (float x) { float i; i = (float) 1 / x; return(i); } ou float inverso (x) float x; { return( (float) 1 / x ); } 13.1 - Valores de retorno Todas as funções, exceto aquelas que são declaradas como sendo do tipo void, devolvem um valor. O valor é devolvido (retornado) pela função através do comando return. Normalmente são escritas três tipos de funções: a) Funções que efetuam operações com os parâmetros e retornam um valor com base nas operações. Programa exemplo (33): O programa calcula e imprime na tela o valor da potência xy. #include <stdio.h> #include <math.h> float potencia (float x, int y); int main(void) { float base,resp; int expoente; printf("Base: "); scanf("%f",&base); printf("Expoente: "); scanf("%d",&expoente); resp = potencia(base,expoente); printf("Potencia = %7.2f\n",resp); }

// chamada da função potencia

57

// ----------------------------- Função definida pelo programador float potencia (float x, int y) { float valor; valor = exp ( log (x ) * y ); return(valor); } b) Funções que manipulam informações e retornam um valor simplesmente indica o sucesso ou o fracasso da manipulação. que

Programa exemplo (34): O programa calcula e verifica o determinante de uma equação de segundo grau. #include <stdio.h> int verifica_determinante (float a, float b, float c); int main(void) { float a, b, c; int retorno; printf("a = "); scanf("%f",&a); printf("b = "); scanf("%f",&b); printf("c = "); scanf("%f",&c); retorno = verifica_determinante(a,b,c); if (retorno == 0) printf("Determinante ZERO\n"); else if (retorno > 0) printf("Determinante POSITIVO\n"); else printf("Determinante NEGATIVO\n"); } // ---------------------------- função definida pelo programador int verifica_determinante (float a, float b, float c) { float det; det = b * b - 4 * a * c; if (det == 0) return(0); else if (det > 0) return(1); else return(-1); } c) Funções que procedimentos. não retornam nenhum valor, ou seja, são puramente

58

2 . Programa exemplo (36): O programa possui uma função que desenha um retângulo na tela. #include <stdio. int main(void) { limpa_tela(). l. } } int main(void) { desenha_retangulo(1. alterações feitas nos parâmetros não terão efeito nas variáveis utilizadas para chamá-la. printf(“\n”). l++) { for (c = 1. } } 13. c <= 80. for (l = 1. l <= lf.h> void desenha_retangulo (int ci. Portanto.Passagem de parâmetros por valor Forma de chamada de uma função onde o valor do argumento é apenas copiado para o parâmetro formal da função.h> void limpa_tela (void). } Onde: ci li cf lf -> -> -> -> coluna inicial linha inicial coluna final linha final // 32 é o código do caracter espaço 59 .32). 20. int li. int lf) { int c. l++) { for (c = ci. 1. 10). l. for (l = li. l <= 25. int cf. c <= cf.Programa exemplo (35): O programa possui uma função que limpa toda a tela em modo texto. } // ---------------------------. printf("\n"). #include <stdio.função definida pelo programador void limpa_tela (void) { int c. c++) printf("#"). c++) printf("%c".

respectivamente: ci = 1. printf("b = "). b).Atenção: Os parâmetros da função recebem. a. printf("y = "). li = 1.&y).4 . Significa que as alterações feitas nos parâmetros afetarão a variável utilizada para chamar a função. int *y) { int temp. printf("a = "). float resposta. b.&x). Programa exemplo (38): O programa calcula e imprime na tela a divisão de dois valores. cf = 20 e lf = 10.&a).3 . Programa exemplo (37): O programa tem uma função que troca o valor de duas variáveis. *y = temp. tipo_do_retorno nome_da_função (tipo_dado_base parâmetros).Funções que devolvem valores não-inteiros Todas as funções que devolvem valores não-inteiros devem ter seu tipo de retorno declarado. scanf("%d". printf("x = "). #include <stdio. scanf("%d". // foi impresso na troca (&a.&b). *x = *y. a. // imagine que o usuário scanf("%d". // foi impresso na } digitou 3 digitou 4 tela a = 3 | b = 4 tela a = 4 | b = 3 /* x e y são ponteiros */ Atenção: Os parâmetros da função recebem. 13.&b).Passagem de parâmetros por referência Forma de chamada de uma função onde o endereço do argumento é passado como parâmetro. b). } int main(void) { int a. 13. y). #include <stdio. respectivamente: x -> &a e y -> &b. int main(void) { int x.h> void troca (int *x. printf("a = %d | b = %d\n". y. scanf("%d". int y). temp = *x. 60 . resposta = divisao ( x.h> float divisao (int x. // imagine que o usuário printf("a = %d | b = %d\n".

if (argc != 2) printf("Sintaxe: INVERTE <palavra>\n").2f\n". else { n = strlen(argv[1]).ponteiro para uma matriz (2D) de caracteres (vetor de strings). printf(“\n”). Execução pela linha de comandos: $ ordena dbeacgf <enter> Resultado na tela: abcdefg // este programa deve obrigatoriamente se chamar inverte.resposta). argv . char *argv[]) { int i.c // depois de compilado será gerado o executável inverte 61 .h> #include <string. for (i = n-1.contém o número de argumentos na linha de comando. n. } 13. Programa exemplo (39): O programa recebe parâmetros do Sistema Operacional (uma palavra qualquer) e imprime a palavra em sentido inverso.5 . } } Programa exemplo (40): O programa deve receber parâmetros pelo Sistema Operacional (conjunto de caracteres) e deve ordenar (coloca em ordem alfabética). int y) { return( (float) x / y ).printf("Divisão = %7. i--) printf("%c".h> int main (int argc. argv[1][i]). O programa é compilado e executado em um terminal do Sistema Operacional Linux da seguinte forma: Execução pela linha de comandos (terminal): $ inverte pelotas <enter> Resultado na tela: satolep Programa recebe: argc = 2 argv[0] = “inverte” agv[1] = “pelotas” // inverte. } // ----------------------------. imprimindo-os a seguir. i >= 0.Função definida pelo programador float divisao (int x.Argumentos argc e argv do main A função main possui dois argumentos argc e argv intrínsecos utilizados para receber parâmetros da linha de comando do DOS (Sistema Operacional em Disco).c #include <stdio. argc .

else { n_car = strlen(argv[1]). // fatorial. j++) if (argv[1][i] > argv[1][j]) { temp = argv[1][i].h> #include <string.Recursividade Uma função é recursiva. return(fat). i++) printf("%c". i++) for (j = i+1. argv[1][i] = argv[1][j].h> long int Fatorial(int n) { long int fat.h> int main (int argc.c #include <stdio. char *argv[]) { int i. int n_car. } } 13. fat = n * Fatorial(n-1). j < n_car. printf(“\n”). if (n <= 1) return(1). j. char temp. se esta.6 . } int main (void) { int n. 62 . i < n_car-1. if (argc != 2) printf("Sintaxe: ORDENA <palavra>\n"). fizer uma chamada a si própria.argv[1][i]). argv[1][j] = temp. for (i = 0.Programa recebe: argc = 2 argv[0] = “ordena” agv[1] = “dbeacgf” // ordena. i < n_car . Programa exemplo (41): Os próximos dois programas calculam o fatorial e a soma de um número recursivamente.c #include <stdio. } for (i = 0 .

printf("Soma: %d\n". fat = Fatorial(n). Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter> Seu nome tem 4 palavra(s) 63 .stdin).c #include <stdio. } while (n != 0). int main(void) { char nome[41]. A função recebe uma string (nome) e retorna o número de palavras do nome (veja exemplo abaixo): #include <stdio.7 .long int fat. return(s). printf(“Nome: “). } int main (void) { int n. s). &n). } 13. fgets(nome.h> ______________ PALAVRAS( ____________________ ). s = n + Soma(n-1). do { do { printf("n = "). } // soma. int n. if (n > 0) { s = Soma(n). } while (n < 0 || n > 19). printf("Fatorial: %d\n". scanf("%d". fat). long int s. scanf("%d".7. &n).h> long int Soma(int n) { long int s. } } while (n != 0). } while (n < 0 || n > 19).40. if (n == 1) return(1).1 Escreva em C a função PALAVRAS. do { do { printf("n = ").Lista de exercícios (funções) 13.

’#’). dia). 13. #include <stdio. A função recebe: número de caracteres (n) e caracter (ch). erro.h> _____________________ PREENCHE ( ____________________ ). else if (erro == 3) printf(“ERRO: Formato inválido\n”). int main (void) { char data[11]. mes). printf(“Mês: %d\n”. } // ##### 13. (4) formato inválido e (5) se a data estiver correta.h> 64 . scanf(“%10s”. else if (erro == 2) printf(“ERRO: Mês inválido\n”). int dia. mes. else { printf(“Dia: %d\n”. } } Valores Válidos: Dia [1. 2999] 13. if (erro == 1) printf(“ERRO: Dia inválido\n”). n caracteres ch. erro = VERIFICA_DATA(data.h> #include <string. mês e ano.7.. (3) se o ano for inválido.h> ______________ VERIFICA_DATA ( ____________________ ). data). n caracteres ch. ano. printf(“Seu nome tem %d palavra(s)\n”. &mes. A função retorna: (1) se o dia for inválido. else if (erro == 4) printf("ERRO: Ano Inválido\n"). n). Exemplo: Data Dia: Mês: Ano: [dd/mm/aaaa]: 11/07/2002 <enter> 11 07 2002 printf(“Data [dd/mm/aaaa]: “). no formato: dd/mm/aaaa) e devolve via parâmetros: dia. &ano).. } Observação: Não utilizar a função strlen do Turbo C. printf(“Ano: %d\n”.4 Escreva em C a função GERA_STRING.h> #include <stdlib. A função deve imprimir na tela.n = PALAVRAS(nome)..31] Mês [1. (2) se o mês for inválido. A função recebe via parâmetros número de caracteres (n) e caracter (ch). &dia. ano). #include <stdio. #include <stdio.7. A função recebe uma string (data.3 Escreva em C a função PREENCHE.12] Ano [2000. int main (void) { PREENCHE(5.7. A função devolve na variável s.2 Escreva em C a função VERIFICA_DATA.

6 Escreva a função: final_da_placa.___________________ GERA_STRING ( _______________ ).’#’. &x).h> #include <string. printf(“%s”. GERA_STRING(5.5 Escreva em C a função VERIFICA_QUADRANTE. printf(“Quadrante: %d\n“. printf(“Nome: “). printf(“x = “). final = final_da_placa(placa).h> int main (void) { char placa[8]. printf(“Qual a placa de seu carro [xxx9999]: “).h> ___________________ VERIFICA_QUADRANTE ( _______________ ). scanf(“%d”. } 13.s). scanf(“%7s”. s). n = VERIFICA_QUADRANTE(x. printf(“Final da Placa é: %d\n”. A função recebe uma string (nome) e retorna a quantidade de vogais da string. A função recebe uma placa de automóvel (placa) no formato: xxx9999 e retorna o último dígito da placa. #include <stdio. printf(“y = “).2.7. #include <stdio. int final. } 13. A função recebe um valor para x e um valor para y e retorna o número do quadrante (1. int main (void) { char s[10]. placa).7. y). } 13.7 Escreva a função: VOGAIS.h> int main (void) { char nome[41]. int vogais.7. &y).3 ou 4). scanf(“%d”. n). int main (void) { int x. #include <stdio. y.h> #include <string. final). n. Quadrantes | | 2o | 1o | ----------------------| 3o | 4o | | // s ficará com “#####” 65 .

minusculas.7. maiusculas). printf(“Maiúsculas: %d\n”. int main (void) { char nome[41]. getch(). &a). A função recebe uma string (nome) e devolve via parâmetros: número letras maiúsculas e o número letras minúsculas.40.stdin). printf(“Vogais: %d\n”.7. &b). scanf(“%f”. h).10 Escreva em C a função REAJUSTE. A função recebe o cateto adjacente (b) e o cateto oposto (a) e retorna o valor da hipotenusa dado pela seguinte fórmula: Fórmula: #include <stdio. printf(“Nome: “). &maiusculas. } 13.h> ______________ CONTA ( ____________________ ). scanf(“%f”. minusculas). } 13. n).9 Escreva em C a função CONTA. Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter> Maiúsculas: 4 Minúsculas: 21 Total de letras: 25 h2 = a2 + b2 clrscr(). h. n = CONTA(nome. vogais). int main (void) { float salario.h> int main (void) { float a.h> #include <string.stdin). #include <stdio. printf(“Cateto Oposto: “). sal. A função recebe o valor do salário e o índice de reajuste e retorna o salário atualizado. printf(“Minúsculas: %d\n”. printf(“Cateto Adjacente: “).h> #include <string.h> ___________________ REAJUSTE ( _______________ ). printf(“Total de letras: %d\n”. printf(“Hipotenusa: %.2f\n”. &minusculas). A função retorna o total de letras do nome (veja exemplo abaixo). indice. int n. maiusculas. b. } 13.40. Exemplo: Salário (R$): 1000 <enter> Índice de Reajuste: 10 <enter> 66 . #include <stdio. b).8 Escreva a função: HIPOTENUSA. h = HIPOTENUSA(a.7. vogais = VOGAIS(nome). fgets(nome.fgets(nome.

if (VERIFICA(n.7. &n). h). int main (void) { CENTRALIZA(”Jogo de Damas”).1f\n”. &altura). #include <stdio. area. altura printf(“Base: “). sal = REAJUSTE(salario. printf(“Hipotenusa: %. printf(“Salário Atualizado (R$): %.13 Escreva em C a função VERIFICA.7. scanf(“%f”. scanf(“%d”.h> #include <string. h. #include <stdio. } Atualizado (R$): 1100 13.h> _____________________ CENTRALIZA ( ____________________ ). resto. indice).11 Escreva em C a função CENTRALIZA. A função deve retornar também o valor da hipotenusa. scanf(“%f”. altura).7. &salario). &area). int main (void) { int n. altura área = ---------------------2 hipotenusa2 = base2 + altura2 13.h> ___________________ HIPOTENUSA ( _______________ ). 67 . } 13. else printf(“Ímpar\n”). A função recebe o valor da base e da área de um triângulo. } base . A função deve retornar se o número (n) é par (1) ou ímpar (0). &base). printf(“Índice de Reajuste: “). A função recebe um número inteiro (n). A função deve devolver na variável resto o resto inteiro da divisão.12 Escreva em C a função HIPOTENUSA. printf(“Número: “).printf(“Salário (R$): “). A função deve imprimir na tela a mensagem centralizada na tela. printf(“Altura: %. int main (void) { float base. #include <stdio. A função deve devolver na variável altura a altura do triângulo. printf(“Área do Círculo: “).1f\n”. sal). &indice). scanf(“%f”.h> ____________________ VERIFICA ( ____________________ ). area.2f\n”. A função recebe uma mensagem. &resto)) printf(“Par\n”). Salário scanf(“%f”. h = HIPOTENUSA(base.

STRCPY(t. t). } // função copia s para t -> “Liber” // insere r no final de t -> “Liberdade” // t -> “liberdade” 68 . printf(“%s\n”. STRCAT(t. resto). r). } 13.printf(“Resto Inteiro da Divisão: %d\n”.t[10].h> ____________________ STRCPY (_______________________________) ____________________ STRCAT (_______________________________) int main (void) { char s[] = “Liber”. r[] = “dade”.14 Escreva as seguintes funções: STRCPY (copia strings) e STRCAT (concatena strings) #include <stdio. s).7.

a memória da tela.sizeof(p)).: %c\n".. Ponteiros Um ponteiro é uma variável que contém um endereço de memória..: %d\n". printf(“Sizeof de p: %d\n”. como por exemplo. 69 .14. *p)..h> int main(void) { char x = 65. printf("Caracter . O endereço pode ser a localização de uma ou mais variáveis na memória RAM ou qualquer outro endereço da memória RAM..&p). char *p. *p). } // // // // // // p recebe *p valor caracter endereço endereço ponteiro o endereço de x (&x) é 65 'A' de x do ponteiro p ocupa 4 bytes Figura 6: Endereçamento de um ponteiro Resumo: x -> 65 &x -> 100 p -> &x -> 100 *p -> 65 &p -> 200 Observação: Um ponteiro no Linux ocupa 4 bytes na memória RAM. printf("Endereço de p: %p\n". printf("Endereço de x: %p\n". Figura 5: Representação de um ponteiro na memória Exemplo: #include <stdio. p = &x. printf("Valor de x. p)..

#include <stdio. nome_da_ponteiro: nome da variável que representa o ponteiro. int *p1.Atribuições com ponteiros Pode-se atribuir o valor (endereço) de um ponteiro para outro ponteiro. p1).2 . 70 . Logo: variável = *ponteiro.3. *p1).1 .h> int main (void) { int x = 7.2. p1 = &x. O tipo de dados do ponteiro define para que tipos de variáveis o ponteiro pode apontar e qual o tamanho ocupado na memória por estas variáveis. 14.Aritmética com ponteiros 14. *p1).3. * .Operadores de ponteiros & .endereço de memória do operando.2 . 14.conteúdo de p1) &x). printf("%p\n".Expressões com ponteiros 14. tipo_dado_base: qualquer tipo básico válido em C.1 . Observação: Como C sabe quantos bytes copiar para a variável apontada pelo ponteiro? Resposta: O tipo_dado_base do ponteiro determina o tipo de dado que o ponteiro está apontando. p2 = p1. Exemplo: ponteiro = &variável. printf("%d\n".Incremento (++) // // // // // // // p1 recebe o endereço de x p2 recebe o endereço de x impresso endereço de x impresso endereço de x impresso endereço de x impresso valor de x (conteúdo de p1) impresso caracter 7 (Bell . Programa exemplo (42): O programa mostra atribuições utilizando dois ponteiros.1 .3 .Variáveis ponteiros Definição: tipo_dado_base *nome_do_ponteiro. printf("%c\n". *p2.conteúdo do endereço apontado pelo ponteiro. } 14. printf("%p\n".3. p2).14. printf("%p\n".

5. 67. *p). 71. 70. 9 }. i. 1. 73. Exemplo: p++. i <= 9. i <= 9. 6. Isto é feito através da aritmética de ponteiros. Isto é feito através da aritmética de ponteiros. 7. 68. char *p. p++. for (i = 0. 66. #include <stdio. int i. int i.h> int main (void) { char x [10] = { 65. 8. 2.h> int main(void) { int x [10] = { 0. p = &x[0]. i++) { printf("Endereço: %p | Valor: x [%d] = %d\n". 4. 69. i. 74 }. for (i = 0. (*p)++. p = &x [0]. /* ponteiro aponta para o próximo elemento */ /* conteúdo do ponteiro é incrementado */ Programa exemplo (43): O programa mostra um ponteiro apontando para os elementos de um vetor. #include <stdio. 3.*p. *p). } } Resultado na tela: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: 0xbfb70886 0xbfb70887 0xbfb70888 0xbfb70889 0xbfb7088a 0xbfb7088b 0xbfb7088c 0xbfb7088d 0xbfb7088e 0xbfb7088f | | | | | | | | | | Valor: Valor: Valor: Valor: Valor: Valor: Valor: Valor: Valor: Valor: x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] = = = = = = = = = = A B C D E F G H I J Programa exemplo (44): O programa mostra um ponteiro apontando para os elementos de um vetor. 72. i++) { printf("Endereço: %p | Valor: x [%d] = %c\n". p. } } Resultado na Tela: Endereço: 0xbfc258c0 | Valor: x[0] = 0 Endereço: 0xbfc258c4 | Valor: x[1] = 1 71 . p++. p.Faz com que o ponteiro aponte para a localização de memória do próximo elemento de seu tipo_dado_base.

// ponteiro aponta para o elemento anterior // conteúdo do ponteiro é incrementado 14. 5. após aquele que o ponteiro estava apontando no momento. 3.Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: Endereço: 0xbfc258c8 0xbfc258cc 0xbfc258c0 0xbfc258d0 0xbfc258d4 0xbfc258d8 0xbfc258dc 0xbfc258e4 | | | | | | | | Valor: Valor: Valor: Valor: Valor: Valor: Valor: Valor: x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] = = = = = = = = 2 3 4 5 6 7 8 9 14. Observação: ponteiros. : } Para acessar o quinto (50) elemento podemos escrever: x[4]. 72 // é igual a p = x dois ponteiros através utilizando os .3. 2. 7.Soma (+) e subtração (-) Exemplo: p = p + 9. Exemplo: if (p < q) printf("Endereço de p é menor do que q\n"). Exemplo: #include <stdio. 9 }. 14. 6.3. int *p.Ponteiros e vetores Em C. Exemplo: p--. ou *(p+4). p = &x[0]. 8.Decremento (--) Faz com que o ponteiro aponte para a localização do elemento anterior.2. Somente pode-se somar e subtrair números inteiros a 14.Comparação de ponteiros É possível comparar operadores relacionais. (*p)++.4 .h> int main (void) { int x[10] = { 0.2 . o nome de um vetor sem índice é o endereço do primeiro elementos da matriz. Faz com que o ponteiro p aponte para o nono (90) elemento do tipo_dado_base.4 .3. 1. 4.3 .

Observação: Aritmética de ponteiros indexação de vetores e matrizes. 14.4.1 - Indexando um ponteiro Exemplo: #include <stdio.h> int main (void) { int x[5] = { 0, 1, 2, 3, 4} int *p,t; p = x; for (t = 0; t <= 4; t++) printf("%d\n", p[t]); } 14.4.2 - Ponteiros e strings

pode

ser

mais

rápida

que

a

// igual a p = &x[0]

Como o nome de um vetor sem índice é um ponteiro que aponta para o primeiro elemento do vetor, quando utiliza-se funções que recebem strings como parâmetros, estas recebem apenas um ponteiro para a string e não o valor real da string em si, ou seja, sempre a passagem de parâmetro de uma string é por referência. Programa exemplo (45): O programa compara duas strings. #include <stdio.h> int compare (char *s1, char *s2); int main (void) { char s1[41], s2[41]; printf("String 1: "); fgets(s1,40,stdin); printf("String 2: "); fgets(s2,40,stdin); if (compare (s1,s2) == 0) printf("s1 é igual a s2\n"); else printf("s1 é diferente de s2\n"); } int compare (char *s1, char *s2) { while (*s1) // quando if (*s1-*s2) return (*s1-*s2); else { s1++; s2++; } return ('\0'); }

// s1 igual s2 == 0

o *s1 for igual '\0' termina o laço

73

14.4.3 - Obtendo o endereço de um elemento de um vetor p = &x[2]; 14.4.4. Vetores de ponteiros Declaração de um vetor de ponteiros de inteiros de tamanho 10. int *x[10]; Atribuição do endereço de uma variável ao terceiro elemento da matriz de ponteiros:
x[2] = &variável; Logo: Para obter o valor da variável, utiliza-se: *x[2];

14.5 - Ponteiros para ponteiros Uma matriz de ponteiros é igual a ponteiros. Um ponteiro para um ponteiro é múltipla. apontar ponteiros para uma forma de indireção

Programa exemplo (46): O programa utiliza uma variável ponteiro para ponteiro. #include <stdio.h> int main (void) { int x; int *p; int **t; x = 10; p = &x; t = &p; printf("%d\n", **t); } 14.6 - Inicialização de ponteiros Após declarar um ponteiro, e antes de haver uma atribuição de um valor inicial, o ponteiro terá um endereço desconhecido (lixo), ou seja, nunca se deve utilizar um ponteiro antes de atribuir-lhe um valor (endereço). Pode-se inicializar seguinte forma: Exemplo: int main (void) { char *p = "Paola"; char *erro = "Falta de memória\n"; 14.7 - Alocação dinâmica de memória Permite alocar e liberar uma área de memória para variáveis durante a execução de um programa. Qualquer outro tipo de variável, um ponteiro para caracteres (string) da

// imprime o valor de x

74

que não seja um ponteiro, deve ser alocada estaticamente, ou seja, a variável não pode ocupar mais espaço do que foi declarado. Exemplo: int x [10];
// um inteiro ocupa 2 bytes // logo 10 inteiros ocupam 20 bytes na memória RAM durante toda a execução do programa

14.7.1 – malloc A função malloc (memory allocation) permite alocar uma porção de memória dinamicamente. Sintaxe: void *malloc (int número_de_bytes); Prototype: stdlib.h A função malloc reserva espaço na memória RAM (aloca) a quantidade de bytes especificada pelo parâmetro da função (número_de_bytes), devolvendo um ponteiro do tipo void* apontando para o primeiro byte alocado. O tipo void* representa um ponteiro sem tipo que deve ser “tipado” de acordo com o tipo de dado base do ponteiro. Isto pode ser feito utilizando-se um cast. Quando não houver memória suficiente para alocar o ponteiro, a função malloc devolve um ponteiro nulo (NULL). Exemplo: #include <stdio.h> #include <stdlib.h> int main (void) { int *p, n; printf(“Quantidade de elementos: “); scanf(“%d”,&n); p = (int *) malloc( n * sizeof (int) ); if (p == NULL) // ou if (!p) printf("ERRO FATAL: Falta de memória\n"); else { printf("Ok, memória alocada\n"); printf("Endereço reservado: %p\n”, p); printf("Quantidade de elementos alocados: %d\n”, n); printf("Quantidade de bytes alocados: %d\n”, n * sizeof(int)); free(p); // veja item 14.7.2 } }
Resultado do Programa: Quantidade de elementos: 5 Ok, memória alocada Endereço reservado: 0x804a008 Quantidade de elementos alocados: 5 Quantidade de bytes alocados: 20

75

for (t = 0.h> int main(void) { int *p. Prototype: stdlib. p = (int *) malloc( 40 * sizeof (int) ). } } 76 . if (!p) printf("Erro Fatal: Falta de memória\n"). *(p+t)). 40 inteiros. t <= 39. ou seja.h> #include <stdlib.14. #include <stdio.++t) *(p+t) = t. free(p). ++t) printf("%d\n".h A malloc.2 – free A função free (livre) alocada pela função malloc. else { for (t = 0. função free libera a área de memória alocada pela função permite liberar a porção de memória Programa exemplo (47): O ponteiro p aponta para uma região da memória com 80 bytes reservados (alocados). t <= 39. Sintaxe: void free (void *p).7. t.

Cada linha é finalizada por um caracter '\n'. tal como: '\n' ser convertida em CR (13) + LF (10).Filas de texto Uma fila de texto é uma seqüência de caracteres organizada em linhas. é definido apenas pelo UNIX chamado sistema de arquivos não-bufferizado (nãoformatado ou de baixo nível). são elas: Tabela 18: Filas de texto Fila stdin stdout stderr stdprn stdaux Função da fila Entrada padrão (standard input) Saída padrão (standard output) Erro padrão (standard error) Saída para impressora (standard printer) Saída auxiliar (standard auxiliary) 15. independente do dispositivo real.cursor) LF – Line Feed (avanço de linha) CR + LF = <enter> Exemplo de um arquivo texto: ABC\n ABCDEF\n \n ABCDEFGH\n EOF Observações: EOF – End Of File (fim do arquivo).Fila de bytes (stream) A fila de bytes é um dispositivo lógico de entrada ou saída de dados. definido pelo padrão ANSI e UNIX chamado sistema de arquivo bufferizado (formatado ou de alto nível) e o segundo. Dessa forma. CR – Carriage Return (retorno do carro .1. pode não haver correspondência de 1 para 1 entre os caracteres que o computador escreve (lê) e aqueles no dispositivo externo. 15.1 . Todo arquivo texto possui um nome. 77 .1 .15. O primeiro. C utiliza 5 filas de texto pré-definidas. Entrada e saída em disco Existem dois sistemas de arquivo definidos em C. Um arquivo (dispositivo externo) deve ser associado a uma fila de bytes. Pode ocorrer certas traduções de caracteres.

2.1.h nome_arquivo: Deve ser uma string que contenha: "drive:\path\nome_do_arquivo". float. modo: É uma abaixo). char *modo). Portanto nenhuma tradução de caracteres ocorrerá.2 .h”. O ponteiro do arquivo identifica um determinado arquivo em disco e é usado pela fila associada a ele para direcionar cada uma das funções de entrada e saída bufferizada para o lugar em que elas operam.15. Sintaxe: FILE *fopen (char *nome_arquivo. Prototype: stdio.. int.h> int main(void) { FILE *fp.1 . como por exemplo: char. Figura 7: Representação de um arquivo 15. ponteiros.Filas binárias Uma fila binária possui correspondência unívoca (1 para 1) com os bytes do dispositivo externo. Um arquivo binário pode conter tipos de dados diferentes. Exemplo: #include <stdio. Um ponteiro de arquivo é uma variável de ponteiro do tipo FILE *. O tipo FILE é prédefinido em “stdio.Sistema de arquivo bufferizado A ligação comum que mantém unido o sistema de entrada e saída bufferizado é um ponteiro que aponta para o arquivo. strings. string que contém as características desejadas (veja tabela Observação: t (text: arquivo texto) e b (binary: arquivo binário) 78 . etc.2 ...fopen A função fopen (file open) permite abrir um arquivo ligando-o a uma fila de bytes. 15. vetores.

fp = fopen("teste. . FILE *fp)."r")) == NULL) printf("Erro Fatal: Impossível abrir o arquivo\n").dat".dat". ou seja. fopen devolverá um ponteiro nulo.2 – putc A função putc é utilizada para gravar caracteres em um arquivo. arquivo aberto\n"). if (fp == NULL) printf("Erro Fatal: Impossível criar o arquivo\n”)."w")..h ch é o caracter a ser gravado fp é o ponteiro do arquivo aberto pela função fopen() 79 . Prototype: stdio.2. else { printf("Ok.h> int main (void) { FILE *fp. . se (fp == NULL) erro. arquivo criado com sucesso\n").Tabela 19: Modo de abertura de arquivos Modo “r” “w” “a” “rb” “”wb” “ab” “r+” “w+” “a+” “r+b” “w+b” “a+b” “rt” “wt” “at” “r+t” “w+t” “a+t” Significado Abre um arquivo-texto para leitura Cria um arquivo-texto para gravação Anexa a um arquivo-texto Abre um arquivo binário para leitura Cria um arquivo binário para gravação Anexa a um arquivo binário Abre um arquivo-texto para leitura/gravação Cria um arquivo-texto para leitura/gravação Abre ou cria um arquivo-texto para leitura/gravação Abre um arquivo binário para leitura/gravação Cria um arquivo binário para leitura/gravação Abre um arquivo binário para leitura/gravação Abre um arquivo texto para leitura Cria um arquivo texto para gravação Anexa a um arquivo texto Abre um arquivo-texto para leitura/gravação Cria um arquivo-texto para leitura/gravação Abre ou cria um arquivo-texto para leitura/gravação Observação: Se ocorrer ERRO na abertura de um arquivo.h> int main (void) { FILE *fp.. else { printf("Ok. Exemplos: #include <stdio. 15.. Sintaxe: int putc (int ch.. ou #include <stdio. if ((fp = fopen("teste.

h fp é o ponteiro do arquivo aberto por fopen() 15. numerando-as. v++. i). Sintaxe: int getc (FILE *fp). Sintaxe: int feof (FILE *fp). else { i = v = 1.h> int main (int argc. #include <stdio. Devolve 0 se não chegou ao fim do arquivo. Prototype: stdio. A cada parada é informado o nome do arquivo texto que está sendo listado e o número de bytes listados.End of File (Fim de Arquivo) 15.2. i). Prototype: stdio. else if ((fp = fopen(argv[1].c" são exibidos na tela com as linhas numeradas.Observação: Se uma gravação for bem sucedida putc() caracter gravado."r")) == NULL) printf("ERRO: Arquivo [%s] não EXISTE\n"). if (ch == '\n') { i++. printf("\n%d: ".4 – feof A função feof (file end of file) determina se o fim de arquivo foi encontrado. caso contrário devolverá um EOF. unsigned int i. EOF . do { ch = getc(fp). char *argv[]) { FILE *fp. char ch. 80 . printf("%d: ". Ao preencher toda a tela ocorre uma pausa. Observação: Este programa deve ser compilado e executado terminal de texto do sistema operacional da seguinte forma: $ lista lista.h Programa exemplo (48): O programa lista na tela todas as linhas de um arquivo texto. if (argc != 2) printf("Sintaxe: LISTA <nome do arquivo>").c <enter> em um Funcionamento: Todas as linhas do programa fonte "lista.3 – getc devolverá o A função getc é utilizada para ler caracteres de um arquivo.2. v.

Prototype: stdio. 81 . Prototype: stdio.h 15. Prototype: stdio. Prototype: stdio. Função: Leitura de strings (fgets) Sintaxe: char *fgets (char *str. FILE *fp).} else printf("%c".2. Antes de fechar o arquivo os dados (que ainda estavam no buffer) são gravados.2. 15.h Observação: Retorna 0 se a operação foi bem sucedida.v). fclose(fp). Sintaxe: void rewind (FILE *fp).h Função: Gravação de inteiros (putw) Sintaxe: int putw (int x. FILE *fp).8 – fgets e fputs As funções fgets e fputs são utilizadas para ler e gravar strings.rewind A função rewind estabelece o localizador de posição do arquivo para o início do arquivo especificado. } while (!feof(fp)). printf("[%s] Byte(s): %d\n".h Observação: A função fgets lê uma string do arquivo especificado até que leia ou um '\n' ou (comprimento . Função: Leitura de inteiros (getw) Sintaxe: int getw (FILE *fp). Sintaxe: int fclose (FILE *fp). int comprimento.2.h Função: Gravação de strings (fputs) Sintaxe: char *fputs (char *str. FILE *fp).1) caracteres. argv[1].6 .5 – fclose A função fclose (file close) é utilizada para fechar um arquivo aberto. inteiros em um arquivo.9 – fread e fwrite para ler e gravar. Prototype: stdio.h 15. ch). 15.2.2.7 – getw e putw As funções getw e putw são utilizadas respectivamente. } } 15. Prototype: stdio.

c. fp: É o ponteiro para o arquivo. cont: Determina quantos blocos (cada um com comprimento de num_bytes) serão lidos ou gravados.h Função: Leitura de dados formatados (fscanf) Sintaxe: int fscanf (FILE *fp.h Exemplos: A seguir. normalmente uma struct.2. lista. Sintaxe: int fseek (FILE *fp.c.h Função: Gravação de blocos (fwrite) Sintaxe: int fwrite (void *buffer.12 – remove A função remove apaga do disco o arquivo especificado.2. num_bytes: Especifica a quantidade de bytes a serem lidos ou gravados. Prototype: stdio. Prototype: stdio. exceto pelo fato de que elas operam com arquivos em disco.h num_bytes: É o número de bytes desde origem até chegar a posição desejada. int cont. são listados três programas: cria. FILE *fp). os quais possuem como registro.2. 82 . FILE *fp). Prototype: stdio. uma palavra com no máximo 40 caracteres.c. ou seja. char *formato.h buffer: É um ponteiro para a região da memória ou o endereço de uma variável que receberá os dados lidos do arquivo pela função fread ou que será gravada no arquivo pela função fwrite. char *formato. lista argumentos). int cont. permite selecionar a posição para efetuar operações de leitura e gravação aleatórias. 15. Prototype: stdio. long int num_bytes. lista argumentos). Prototype: stdio. Prototype: stdio. Tabela 20: Origem em arquivos Origem Identificador Início do arquivo SEEK_SET Posição corrente SEEK_CUR Fim do arquivo SEEK_END 15.11 – fprintf e fscanf As funções fprintf e fscanf se comportam exatamente como printf e scanf. Sintaxe: int remove (char *nome_arquivo). consulta.10 – fseek A função fseek é utilizada para ajustar o localizador de posição do arquivo. int num_bytes. para ler e gravar Função: Leitura de blocos (fread) Sintaxe: int fread (void *buffer. Função: Gravação de dados formatados (fprintf) Sintaxe: int fprintf (FILE *fp.As funções fread e fwrite são utilizadas blocos de dados. int num_bytes.h 15. int origem).

printf("Nome do arquivo: "). } while (!strchr("SsNn". char nome_do_arquivo[14]. char ch. char reg[40]. fp).h> int main (void) { FILE *fp. // grava o registro n++. else { n = 0. do { ch = getchar(). } while (strchr("Ss".h> #include <string."w+b")) == NULL) printf("Erro Fatal: Problema no disco\n")."r+b")) != NULL) { printf("ERRO: Arquivo já existe\n"). scanf(“%13s”.c #include <stdio. } } Programa exemplo (50): O programa permite abrir o arquivo de palavras e exibe-os na tela. ch)). 83 . fclose(fp). ch)). 1. n). nome_do_arquivo). char reg[40].Programa exemplo (49): O programa permite criar um arquivo de palavras permitindo a gravação destas palavras. // cria. // scanf não aceita espaços fwrite(reg.c #include <stdio. nome_do_arquivo). } else if ((fp = fopen(nome_do_arquivo. fclose(fp). unsigned int n. scanf(“%13s”. // lista.h> int main (void) { FILE *fp. unsigned int n. char nome_do_arquivo[14]. if ((fp = fopen(nome_do_arquivo. reg). sizeof(reg). printf("Continua [S]im ou [N]ão ?"). do { printf("%d: Palavra: ". printf("Nome do arquivo: "). scanf("%s".

fclose(fp). ok = fread(reg. o número do registro para ser calculado a posição deste registro no arquivo. fread(reg. reg). do { ch = getchar(). while (!feof(fp)) { printf("%d: Palavra: %s\n". ao usuário. posicao = n * sizeof(reg). } while (!strchr("SsNn". sizeof(reg). } while (strchr("Ss". n. Logo após o registro é exibido na tela. n++. char reg[40]. &n). printf("Nome do arquivo: "). posicao. fp). if ((fp = fopen(nome_do_arquivo. SEEK_SET). Para tanto é solicitado. long int posicao. char ch.c #include <stdio. } } 84 . nome_do_arquivo). fread(reg. } } Programa exemplo (51): O programa permite consultar o arquivo de palavras. sizeof(reg). else printf("ERRO: Registro NÃO existe\n"). char nome_do_arquivo[14]. 1.h> int main (void) { FILE *fp."r+b")) == NULL) printf("ERRO: Arquivo não EXISTE\n").ch)). scanf("%d". 1. // consulta. 1.ok. scanf(“%13s”. else { do { printf("Número do registro: "). else { n = 0. sizeof(reg).if ((fp = fopen(nome_do_arquivo.h> #include <string. n. fp). unsigned int n. if (ok) printf("%d: Palavra: %s\n". printf("Continua [S/N] ? ")."rb")) == NULL) printf("ERRO: Arquivo não EXISTE\n"). } fclose(fp). fseek(fp. reg). fp).ch)).

1 – open. (O acesso se relaciona ao Ambiente UNIX) A função creat cria um arquivo para operações de leitura e gravação. será devolvido um inteiro positivo. Prototype: stdio.3. Um valor de retorno -1 (EOF) significa que open não pode abrir o arquivo. creat e close A função open permite abrir/criar um arquivo em disco.h 15.h e fcntl.2 – write e read A função write grava tantos caracteres quantos forem o tamanho do buffer apontado pelo ponteiro buf para o arquivo em disco especificado por fd. ou seja. Função: Cria um arquivo (creat) Sintaxe: int creat (const char *nomearquivo. o sistema de baixo nível (sistema nãobufferizado) não utiliza ponteiros de arquivo do tipo FILE. Força a criação se o arquivo existe Acesso somente para leitura Acesso somente para escrita Acesso para leitura e escrita A função close fecha um arquivo. 15. Função: Abre um arquivo (open) Sintaxe: int open (char *nomearquivo. Prototype: stdio.h e fcntl. Prototype: stdio. se não for capaz de fechar o arquivo.15.3 . mas sim descritores de arquivos chamados handles do tipo int. Devolve -1 (EOF). Função: Fecha um arquivo (close) Sintaxe: int close (int fd). int modo).Sistema de arquivo não bufferizado Ao contrário do sistema de entrada e saída de alto nível (sistema bufferizado). int acesso).3.h Tabela 21: Tipos de acessos em arquivos Acesso O_RDONLY O_WRONLY O_RDWR O_CREAT O_TRUNC O_EXCL O_APPEND O_TEXT O_BINARY Efeito Apenas leitura Apenas gravação Leitura e gravação Cria e abre Abre com "truncation" Abre exclusiva Abre para incluir no fim Translação CR para LF Sem translação Observação: Se a função open obtiver sucesso (na abertura do arquivo). uma variável inteira. 85 .h Tabela 22: Modos de acessos em arquivos Modo O_CREAT O_TRUNC O_APPEND O_EXCL O_RDONLY O_WRONLY O_RDWR Efeito Criar um arquivo se ele não existe Truncar o arquivo se ele existe Anexar no fim antes de cada gravação Excluir.

86 .h Programa exemplo (52): O programa permite criar um arquivo de palavras permitindo a gravação destas palavras.h> int main (void) { int fd.h> #include <fcntl. Sintaxe: int int eof (int fd). Prototype: stdio. SEEK_END (fim) 15. (0) não é fim de arquivo ou (-1) erro. SEEK_CUR (corrente).6 – tell A função tell devolve a posição corrente do descritor.h A função ponteiro buf.c #include <stdio.Função: Grava caracteres no arquivo (write) Sintaxe: int write (int fd.3. Prototype: stdio. int origem).h> #include <string. int tamanho).h fd: descritor do arquivo num_bytes: número de bytes desde a origem até a nova posição origem: SEEK_SET (início). read copia os dados lidos no buffer apontado pelo Função: Lê caracteres do arquivo (read) Sintaxe: int read (int fd. char reg[40]. Prototype: stdio.3. // criar.4 – lseek A função lseek devolve o número de bytes (num_bytes) se obtiver sucesso. Prototype: stdio. Sintaxe: long int tell (int fd). Sintaxe: long int lseek (int fd.3 – unlink A função unlink elimina um arquivo do disco (retorno: 0 sucesso ou 1 erro).h 15.5 – eof A função eof (end of file) devolve: (1) fim de arquivo. void *buf. Prototype: stdio.h 15. Prototype: stdio. Sintaxe: int unlink (const char *nomearquivo).3. void *buf. long int num_bytes.h 15. int tamanho).3.

do { ch = getchar(). } while (error). reg). do { printf("%d: Palavra: ". scanf("%s". do { error = read(fd.. int error. else { n = 0. printf("Nome do arquivo: "). unsigned int n. n. else { n = 0.h> #include <fcntl. } while (strchr("Ss".ch)). scanf(“%13s”. n). char ch."r")) == EOF) if ((fd = creat(nome_do_arquivo. n++.c #include <stdio..char nome_do_arquivo[14].ch)). reg. char reg[40]. // listar. char nome_do_arquivo[14]. n++. sizeof(reg)). write(fd. printf("Nome do Arquivo: "). if ((fd = open(nome_do_arquivo. nome_do_arquivo).O_RDONLY.\n"). } } Programa exemplo (53): O programa permite abrir o arquivo de palavras e exibe-os na tela. 87 . } else { printf("ERRO: Arquivo já EXISTE\n"). } while (!strchr("SsNn". // error = 0 – fim do arquivo close(fd).h> int main (void) { int fd. printf("%d: Palavra: %s\n". sizeof(reg)). reg). scanf(“%13s”. reg. unsigned int n."r")) == EOF) printf("ERRO: Arquivo NÃO existe . printf("Continua [S]im ou [N]ão ?").O_RDWR)) == EOF) printf("Erro Fatal: Problema no disco\n"). if ((fd = open(nome_do_arquivo. close(fd). nome_do_arquivo).O_RDONLY. close(fd).

h> #include <string. printf("Continua [S]im ou [N]ão ? "). write(fd.c #include <stdio. char ch. SEEK_SET).Lista de exercícios (arquivos) 15. char nome_do_arquivo[14]. SEEK_SET). Logo após o registro é exibido na tela e é solicitada a nova palavra. nome_do_arquivo). sizeof(reg))) { printf("%d: Palavra: %s\n". else { do { printf("Registro: "). sizeof(reg)). scanf(“%s”. printf("Nome do arquivo: "). scanf("%d". reg)."w")) == EOF) printf("ERRO: Arquivo NÃO existe . } } 15. close(fd). O programa deve imprimir na tela o número de bytes (caracteres) e o número de linhas do arquivo ou ERRO: Arquivo não existe. if ((fd = open(nome_do_arquivo. lseek(fd.h> int main (void) { int fd. posicao = n * sizeof(reg). o número do registro para ser calculado a posição deste registro no arquivo. scanf(“%s”. long int posicao. Para tanto é solicitado.\n"). ao usuário.h> #include <fcntl. n. reg.ch))..1 Escreva um programa em C que recebe via teclado o nome de um arquivo texto. 88 . do { ch = getchar().O_RDWR. reg).n). if (read(fd. } while (!strchr("SsNn".4 . } } Programa exemplo (54): O programa permite alterar o arquivo de palavras.. unsigned int n. } while (strchr("Ss".4. lseek(fd. } else printf("ERRO: Registro não existe\n"). char reg[40]. reg. &n). // alterar. posicao.ch)). posicao. printf("NOVA PALAVRA: ").printf(“%d palavra(s)\n”.

4 Escreva um programa em C que recebe via teclado o nome do arquivo texto fonte e o nome do arquivo texto destino.C <enter> Número de linha: 7 <enter> 7: int i.2 Escreva um programa em C que recebe via teclado o nome de um arquivo texto.C <enter> Palavra: if <enter> 23: if (fp == NULL) 33: if (ch == '\n') 89 .Exemplo: Nome do arquivo texto: LISTA.3 Escreva um programa em C que recebe via teclado o nome de dois arquivos texto (origem e destino). O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número da linha.C <enter> Arquivo destino: LISTA.4. O programa deve converter o arquivo fonte para maiúsculo ou minúsculo (conforme escolha do usuário) gerando o arquivo texto destino. Exemplo: Arquivo origem: LISTA.TMP <enter> [+] Maiúsculo ou [-] Minúsculo: + <enter> (1234) Bytes convertidos 15. Número de linha: 70 <enter> ERRO: Linha não existe Número de linha: 0 <enter> ou ERRO: Arquivo não existe 15.4. O programa deve copiar o conteúdo do arquivo origem para o arquivo destino.4.4.C <enter> Arquivo destino: LISTA. O programa deve imprimir todas as linhas que possuem esta palavra. j. Exemplo: Nome do arquivo texto: LISTA.tmp <enter> (20345) Bytes copiados 15. k.5 Escreva um programa em C que recebe via teclado o nome de um arquivo texto e uma palavra.C <enter> (12345) Bytes (44) Linhas ou ERRO: Arquivo não existe 15. Exemplo: Nome do arquivo texto: PALAVRA. O programa deve imprimir a linha especificada ou ERRO: Linha não existe. Exemplo: Arquivo fonte: LISTA.

DAT <enter> Nome: Beatriz <enter> Nome: Eva <enter> Nome: Debora <enter> Nome: Carla <enter> Nome: Fatima <enter> Nome: Ana <enter> Nome: <enter> 15.37: 41: 59: 65: 69: if if if if if (compara(linha.6 Escreva um programa em C que recebe via teclado o nome de um arquivo texto.8 Escreva um programa em C (ler.4. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número inicial e número final. 9: long int bytes = 0.palavra)) (ch != '\n') (linha[i] == palavra[0]) (linha[k] != palavra[j]) (achei) 15. j.c) que recebe via teclado o nome de um arquivo binário. O programa termina quando o usuário digitar <enter> na entrada do nome.DAT <enter> Nome: Beatriz Nome: Eva Nome: Debora Nome: Carla Nome: Fatima Nome: Ana 15. 8: char tecla. Exemplo: Nome do arquivo binário: NOMES.C <enter> Número inicial: 7 <enter> Número final: 9 <enter> 7: int i. ordenar e gravar novamente os nomes no mesmo arquivo.c".4. ou Número inicial: 70 <enter> Número final: 90 <enter> ERRO: Linhas não existem 15. k.4. O programa deve permitir ao usuário inserir nomes (máximo 30 caracteres) neste arquivo via teclado.9 Escreva um programa em C (sort. O programa deve imprimir desde a linha inicial até a linha final ou ERRO: Linhas não existem. O programa deve ler.c) que recebe via teclado o nome de um arquivo binário. Exemplo: Nome do arquivo binário: NOMES. 90 .4.7 Escreva um programa em C (grava.c) que recebe via teclado o nome de um arquivo binário. Exemplo: Nome do arquivo texto: LISTA. O programa deve ler e imprimir na tela todos os nomes armazenados no arquivo pelo programa "grava.

Exemplo: Nome do arquivo binário: DADOS.4.12 Escreva um programa em C (conta. idade e sexo) armazenados no arquivo pelo programa "salva.4. O programa deve permitir ao usuário inserir nome (máximo 30 caracteres). arquivo ordenado Observação: Utilize o programa anterior (ler.c) para ver os nomes ordenados. O programa deve verificar a quantidade de homens e a quantidade de mulheres no aquivo criado pelo programa "salva. O programa deve ler e imprimir na tela todos os dados (nome.c) que recebe via teclado o nome de um arquivo binário.4.DAT <enter> (2) Homens (1) Mulheres 91 .Exemplo: Nome do arquivo binário: NOMES. 15. Exemplo: Nome do arquivo binário: DADOS.DAT <enter> Ok.c) que recebe via teclado o nome de um arquivo binário.DAT <enter> Nome: Paulo Roberto Idade: 41 Sexo: MASCULINO Nome: Renato Luis Idade: 38 Sexo: MASCULINO Nome: Ana Maria Idade: 44 Sexo: FEMININO 15.c) que recebe via teclado o nome de um arquivo binário.DAT <enter> Nome: Paulo Roberto <enter> Idade: 41 <enter> Sexo [M/F]: m <enter> Nome: Renato Luis <enter> Idade: 38 <enter> Sexo [M/F]: m <enter> Nome: Ana Maria <enter> Idade: 44 <enter> Sexo [M/F]: f <enter> Nome: <enter> 15. Exemplo: Nome do arquivo binário: DADOS.c" (veja exemplo abaixo).c". O programa termina quando o usuário digitar <enter> na entrada do nome. idade e sexo ([M]asculino ou [F]eminino) neste arquivo via teclado.10 Escreva um programa em C (salva.11 Escreva um programa em C (list.

mas não ambos. Acesso ao primeiro elemento da estrutura: strcpy(cliente[0].Referência aos elementos da estrutura // lista_de_variáveis Para fazer referência aos elementos individuais de uma estrutura deve-se utilizar o operador “. fornecedor.2 .00.salario = 1500. struct nome_da_estrutura { tipo nome_variável.1 . tipo nome_variável.1 . uma variável possui um conjunto de valores (que podem ser de tipos iguais ou diferentes – agregados heterogêneos). uma estrutura (struct) é uma coleção de campos que fazem referência a uma variável.00. } cliente. Exemplo: struct reg_cliente cliente[100]. ou seja.“Paulo”). int idade. 92 .nome_campo Exemplo: cliente. .nome. Cria-se um array (vetor) para guardar 100 ocorrências de cliente. cliente[99].16.idade = 41.idade = 18. cliente[0]. que as vezes é chamado de operador de seleção.1. 16.1. Tipos de dados definidos pelo programador 16.nome. Uma estrutura propicia uma maneira conveniente de manter-se juntas informações relacionadas. . 16.Estruturas Em C. Na definição de uma estrutura pode-se omitir o nome_da_estrutura ou a lista_de_variáveis deste tipo. Acesso ao último elemento da estrutura: strcpy(cliente[99]. nome_variável_estrutura.” (ponto). struct reg_cliente { // nome_da_estrutura char nome[30].“Renato”).Matrizes de estruturas É possível criar matrizes de estruturas. cliente[99].salario = 500.idade = 37. . float salario. } lista_de_variáveis. cliente[0].

Passando elementos da estrutura Desta forma.Passando estruturas para funções 16.1.1 . function (arg). // parm é o parâmetro tipo estrutura O tipo do argumento deve coincidir com o tipo do // arg é o argumento 16. parm. arg.idade). Observação: parâmetro.b. }. Neste caso p é um ponteiro para a estrutura reg_cliente.b). } cliente.a = 1000. char ch.b = 500.3 . void function (struct TIPO parm).16.ch). arg.a).3. int main (void) { struct TIPO arg. struct reg_cliente *p. parm.Ponteiros para estruturas C permite que ponteiros apontem para estruturas da mesma maneira como permite ponteiros para qualquer outro tipo de variável. // o ponteiro p aponta para a variável cliente 93 . é passado apenas uma cópia do valor para a função. printf("%d".h> struct TIPO { int a.2 . 16.1. Exemplo: #include <stdio.Passando estruturas inteiras É possível passar uma estrutura(struct) inteira para uma função.ch = ‘A’. } void function { printf("%d". float salario. Exemplo: struct reg_cliente { char nome[30].1.4 . arg. p = &cliente. Chamada da função: função (cliente. } (struct TIPO parm) parm.1. printf("%c".3. int idade.

16. struct nome_tipo_estrutura { tipo nome_1: comprimento. Observação: Exemplo: struct dispositivo { unsigned ativo: 1.Campos de bit C possui um método inerente de acesso a um único bit em um byte. pois codigo_disp ocupa 8 bits. Realmente não se cria uma nova classe de dados. }. os outros 5 bits ficam desocupados.typedef C permite que o programador defina explicitamente novos nomes de tipos de dados utilizando a palavra reservada typedef. } codigo_disp. typedef tipo_base novo_nome_de_tipo.3 . unsigned pronto: 1. tipo nome_2: comprimento.4 .2 . Exemplo: typedef float real. }. um novo nome para um tipo existente. Exemplo: union u_type { int i.. 16.Union Em C. mas sim. unsigned erro: 1. 1 byte. . typedef unsigned char byte. 16. ou p->idade = 21. char ch. Um campo de bit é apenas um tipo especial de estrutura que define o comprimento em bits que cada elemento terá. que podem ser de tipos diferentes (int ou char). Este é baseado na estrutura. ou seja.idade = 21. Neste caso a variável i e ch ocupam a mesma localização da memória. uma union (união) é uma localização de memória que é utilizada por várias variáveis diferentes.Para acessar um elemento de cliente através do ponteiro p devese escrever das seguintes formas: (*p). Um campo de bit deve ser do tipo int. tipo nome_3: comprimento.. Esta estrutura define três variáveis de um bit cada. 94 . unsigned int ou signed int.

O modificador const Durante a execução.2. C permite que seja aplicado vários modificadores de tipo aos tipos de dados básicos.5 .real salario.2 . 16. porque não são conhecidas fora de suas funções.2 .5. 16. 16.1.O especificador static As variáveis static são variáveis permanentes dentro de suas próprias funções. (Por default as variáveis locais são auto). mas mantém seus valores entre as chamadas.Especificadores de classe de armazenamento 16. O especificador register Se aplica apenas as variáveis int ou char.5.5. 16.O especificador extern O especificador extern diz ao compilador que os tipos de dados e nomes de variáveis que se seguem já foram declarados em um outro lugar (por exemplo.O especificador auto O especificador auto é utilizado para declarar variáveis locais.1 . 16. o programa não poderá alterar uma variável declarada com o modificador const.Modificadores de acesso 16. Exemplo: const float versao = 3. onde as variáveis normais são armazenadas normalmente.1.2.O modificador volatile Utiliza-se o modificador volatile para dizer ao C que o valor de uma variável pode ser alterado sem uma especificação explícita do programa. Observação: Só pode ser utilizado em variáveis locais.5. Exemplo: volatile int clock. e não na memória.5.3 .2.1 . outro programa fonte).1 . exceto dar a variável um valor inicial.5. 16.2.4. É próprio para variáveis de loop's (laços). modificador_tipo tipo_básico lista_variáveis. São diferentes das variáveis globais.5. pois torna o laço mais rápido. 16.Tipos de dados avançados byte n_dentes.2 .5. 95 . O especificador register faz com que o compilador mantenha o valor das variáveis declaradas dentro dos registradores da CPU.30.

c = b << 1. printf("b = ")..O operador ? Pode-se utilizar o operador ? para substituir comandos if .a). b = a >> 1.a) : printf("Maior (b) -> %d\n".Operadores avançados 16. printf("c = %d\n".&b). Exemplo: #include <stdio.1 ...c).b).5. ajuste ou troca de bits reais por um byte ou palavra (podem ser de tipos char ou int).5. else que tenham a seguinte forma geral: if (condição) comando_1.h> int main (void) { int a. printf("a = %d\n".5.16..&a). Tabela 23: Operadores bit a bit Operador & | ^ ~ >> << Ação And Or Or exclusivo (XOr) Complemento de um (Not) Deslocar para a direita (shift) Deslocar para a esquerda (shift) Deslocamento (shift): variável >> número de deslocamentos. A principal restrição do operador ? é que os comandos do if . printf("b = %d\n". b. Exemplo: #include <stdio. Forma geral: condição ? comando_1: comando_2.b). c.3. b. scanf("%d". else devem ser comando simples não podendo serem comandos compostos.3 .3.h> int main (void) { int a = 128. } 16. else comando_2. printf("a = "). } // a = 128 // b = 64 // c = 128 binário -> 10000000 binário -> 0100000 binário -> 1000000 96 . a > b ? printf("Maior (a) -> %d\n". scanf("%d".Operadores bit a bit Se referem ao teste.2 .

x += 7. porque a vírgula tem precedência mais baixa que o operador de atribuição. Pode-se utilizar a vírgula para juntar várias expressões. Exemplo: x = x + 10. y + 1). Esta forma aritméticos de C. 16.4 . a expressão do lado direito ficará sendo o valor de toda expressão separada por vírgula.Formas abreviadas de C C tem abreviações especiais que simplificam a codificação de um certo tipo de comando de atribuição. Primeiramente é atribuído o valor 3 a y e depois atribuído o valor 4 a x. variável operador= constante.5. Forma normal: Forma abreviada: abreviada funcionará com todos os operadores variável = variável operador constante.3 . Exemplo: x = (y = 3.5. Assim. -> pode ser escrito como -> x += 10. x = x + 7. 97 .16. Os parênteses são necessários.3.3.O operador . O compilador sempre avalia o lado esquerdo da vírgula como void.

Ao contrário de um vetor. Listas lineares As listas lineares encadeadas (filas e pilhas alocadas dinamicamente) permitem alocação indeterminada de elementos em uma estrutura de dados. As listas podem ser organizadas como: pilhas ou filas. ou seja. apenas numa direção. do primeiro ao último elemento. Os elementos são alocados na memória RAM dinamicamente. 98 . b) Segundo: É que a informação do número de elementos da lista é obtido somente por uma varredura completa na lista. uma lista encadeada é alocada dinamicamente. Para resolver estes dois problemas pode-se utilizar um descritor da seguinte maneira: As vantagens de um descritor são:   Conhecer o número de elementos da lista linear sem ter que percorrê-la. Figura 18: Representação de uma lista encadeada Dois problemas existem em uma lista encadeada: a) Primeiro: É que as listas são percorridas seqüencialmente. Acessar o último elemento facilitando a inserção ou remoção no final da lista. LIFO (Last Input First Output). Uma lista encadeada tem por característica um elo de ligação entre um elemento e outro. que os elementos são alocados em posições diferentes (aleatórias) na memória. As listas lineares encadeadas possuem um header (cabeça) que armazena o primeiro elemento da lista. tendo como característica básica. o último na pilha é o primeiro a sair dela. ou seja.17. Pilha: Estrutura dos dados é feita Forma de acesso: elemento a entrar linear organizada de forma que a entrada e a saída na mesma extremidade. onde os elementos são alocados estaticamente e em posições contíguas na memória RAM.

int consulta_pilha (struct PILHA p.h> #include <stdlib. }. Quando o número digitado for igual à zero (0).Entrada de Dados S . todos os números da pilha são listados. 2 e 3 17. a saída. 2 e 3 Saída: 1.Fila: Estrutura linear organizada em forma que a entrada dos dados é feita por uma extremidade da lista linear e. int *info).h> #define SUCESSO #define FALTA_DE_MEMORIA #define PILHA_VAZIA struct NODO { int info. 2 e 1 Funcionamento desta fila: Entrada: 1. o primeiro elemento a entrar na fila é o primeiro a sair da fila. void cria_pilha (struct PILHA *p). ou seja. struct NODO *elo. E .Saída de Dados Figura 19: Representação de uma fila e uma pilha Funcionamento desta pilha: Entrada: 1. int pop (struct PILHA *p. int push (struct PILHA *p. struct PILHA { struct NODO *topo. void imprime_erro (int erro).c #include <stdio. int valor). Forma de acesso: FIFO (First Input First Output). // pilha.h> #include <string.1 . void destroi_pilha (struct PILHA *p). }. 2 e 3 Saída: 3. é feita na outra extremidade. int *info). 1 2 3 // informação // elo para o próximo elemento 99 .Implementação de uma pilha Programa exemplo (55): O programa permite inserir números inteiros em uma pilha.

// ------------------------------------ cria_pilha void cria_pilha (struct PILHA *p) { p->topo = NULL; } // ------------------------------------ push int push (struct PILHA *p, int valor) { struct NODO *t; t = (struct NODO *) malloc(sizeof(struct NODO)); if (t == NULL) return(FALTA_DE_MEMORIA); else { t->info = valor; t->elo = p->topo; if (p->topo == NULL) t->elo = NULL; p->topo = t; return(SUCESSO); } } // ------------------------------------ pop int pop (struct PILHA *p, int *info) { struct NODO *t; if (p->topo == NULL) return(PILHA_VAZIA); else { t = p->topo; *info = t->info; p->topo = t->elo; free(t); return(SUCESSO); } } // ------------------------------------ consulta_pilha int consulta_pilha (struct PILHA p, int *info) { struct NODO *t; if (p.topo == NULL) return(PILHA_VAZIA); else { t = p.topo; *info = t->info; return(SUCESSO); } } // ------------------------------------ imprime_erro void imprime_erro (int erro) { switch (erro) { case FALTA_DE_MEMORIA: printf("ERRO: Falta de memória, tecle algo\n"); break; case PILHA_VAZIA: printf("ERRO: Pilha vazia, tecle algo\n"); break; } } // ------------------------------------ destroi_pilha void destroi_pilha (struct PILHA *p)

100

{ struct NODO *t; t = p->topo; if (p->topo != NULL) while (p->topo != NULL) { t = p->topo->elo; printf("Info: %d\n", p->topo->info); free(p->topo); p->topo = t; } printf("Ok, Dados Destruidos\n"); p->topo = NULL; } // ------------------------------------ main int main (void) { struct PILHA p; int valor, erro; char ch; cria_pilha(&p); do { printf("[P]ush, P[O]p, [C]onsultar ou [F]im ?"); do { ch = toupper(getchar()); } while (!strchr("POCF", ch)); if (ch == 'P') { printf("Valor: "); scanf("%d", &valor); } switch (ch) { case 'P': erro = push(&p, valor); if (erro != SUCESSO) imprime_erro(erro); break; case 'O': erro = pop(&p,&valor); if (erro != SUCESSO) imprime_erro(erro); else printf("Informação Excluída: %d\n",valor); break; case 'C': erro = consulta_pilha(p, &valor); if (erro != SUCESSO) imprime_erro(erro); else printf("Valor: %d\n", valor); break; } } while (ch != 'F'); destroi_pilha(&p); }

17.2 - Implementação de uma fila Programa exemplo (56): O programa permite inserir números inteiros em uma fila. Quando o número digitado for igual à zero (0), todos os números da fila são listados.
// fila.c #include <stdio.h> #include <stdlib.h> #include <string.h> #define SUCESSO #define FALTA_DE_MEMORIA #define FILA_VAZIA struct NODO { int info; 1 2 3 // informação

101

struct NODO *elo; // elo para o próximo elemento }; struct FILA { struct NODO *primeiro; int tamanho; struct NODO *ultimo; }; void cria_fila (struct FILA *f); int incluir_fila (struct FILA *f, int valor); int excluir_fila (struct FILA *f); int consultar_fila (struct FILA f, int *j); void imprime_erro (int erro); // ------------------------------------ cria_fila void cria_fila (struct FILA *f) { f->primeiro = NULL; f->tamanho = 0; f->ultimo = NULL; } // ------------------------------------ incluir_fila int incluir_fila (struct FILA *f, int valor) { struct NODO *t; t = (struct NODO *) malloc(sizeof(struct NODO)); if (t == NULL) return(FALTA_DE_MEMORIA); else { t->info = valor; t->elo = NULL; if (f->ultimo != NULL) f->ultimo->elo = t; f->ultimo = t; if (f->primeiro == NULL) f->primeiro = t; f->tamanho = f->tamanho + 1; return(SUCESSO); } } // ------------------------------------ excluir_fila int excluir_fila (struct FILA *f) { struct NODO *t; if (f->primeiro == NULL) return(FILA_VAZIA); else { t = f->primeiro; printf("Elemento Excluido: %d\n",t->info); f->primeiro = t->elo; f->tamanho = f->tamanho - 1; free(t); if (f->primeiro == NULL) f->ultimo = NULL; return(SUCESSO); } } // ------------------------------------ consultar_fila int consultar_fila (struct FILA f, int *j) { struct NODO *t; if (f.primeiro == NULL) return(FILA_VAZIA); else {

102

imprime_erro void imprime_erro (int erro) { switch (erro) { case FALTA_DE_MEMORIA: printf("\nERRO: Falta de memória.main int main (void) { struct FILA f. if (erro != SUCESSO) imprime_erro(erro). break. break. case FILA_VAZIA: printf("\nERRO: Fila vazia. f->primeiro = t->elo. } // -----------------------------------. } // -----------------------------------. valor). if (ch == 'I') { printf("Valor: ").primeiro. } 103 . if (erro != SUCESSO) imprime_erro(erro). cria_fila(f). Dados Destruidos\n"). *j = t->info. free(f->primeiro). } } while (ch != 'F'). case 'E': erro = excluir_fila(&f).destroi_fila void destroi_fila (struct FILA *f) { struct NODO *t. } printf("Ok. [E]xcluir. else printf("Valor: %d\n". if (erro != SUCESSO) imprime_erro(erro). do { printf("[I]ncluir. char ch. do { ch = toupper(getchar()). [C]onsultar ou [F]im ?"). printf("Info: %d\n". } while (!strchr("IECF". break. } } // -----------------------------------. break. if (f->tamanho > 0) while (f->primeiro != NULL) { t = f->primeiro. erro. tecle algo\n").} t = f. &valor). } switch (ch) { case 'I': erro = incluir_fila(&f. &valor). valor). case 'C': erro = consultar_fila(f. int valor. t->info). cria_fila(&f). scanf("%d". return(SUCESSO). ch)). destroi_fila(&f). break. tecle algo\n").

exibir_lista_direita (struct DESCRITOR d). }.h> <ctype. op)). insere_direita (struct DESCRITOR *d. struct ELEMENTO { // -----------------------------------. struct DESCRITOR { struct ELEMENTO *primeiro. int n.n). } while (!strchr("ED". case 'D': insere_direita(&d. exibir_lista_esquerda (struct DESCRITOR d).3 . inicializa_descritor(&d). int n). struct ELEMENTO *posterior. do { op = toupper(getchar()). switch (op) { case 'E': insere_esquerda(&d. Programa exemplo (57): O programa permite inserir números inteiros em uma lista duplamente encadeada.17. if (n != 0) { printf("Inserir a [E]squerda ou [D]ireita ?"). scanf("%d". struct ELEMENTO *ultimo. do { printf("Número [0-Sair]: ").h> struct ELEMENTO *anterior. pois este tipo de lista pode ser percorrida em duas direções (para a direita e para a esquerda). int n.c #include #include #include #include <stdio.main int main (void) { struct DESCRITOR d. &n). int n).h> <stdlib. }.h> <string. insere_esquerda (struct DESCRITOR *d. A exibição dos elementos da lista pode ser feita pela esquerda ou direita. A inserção pode ser pela esquerda ou a direita. int dado.n). 104 . void void void void void inicializa_descritor (struct DESCRITOR *d). // dupla.Lista duplamente encadeada Uma lista duplamente encadeada possui um elo para o elemento anterior e um elo para o elemento posterior. char op. Possui uma vantagem sobre a lista encadeada. break.

do { op = toupper(getchar()). p->dado = n. p->anterior = NULL. } } } while (n != 0). case 'D': exibir_lista_direita(d). int n) { struct ELEMENTO *p. } // -----------------------------------. break. d->ultimo = NULL. } else { q = d->primeiro. p = (struct ELEMENTO *) malloc(sizeof(struct ELEMENTO)). d->n = 1. d->ultimo = p. d->primeiro = p.*q. d->primeiro = p. op)). p->dado = n. break. p->posterior = NULL. } } } 105 . } // -----------------------------------. switch (op) { case 'E': exibir_lista_esquerda(d). d->n = d->n + 1. do { printf("Listar: [E]squerda. d->n = 0. else { if (d->n == 0) { p->anterior = NULL. if (p == NULL) printf("ERRO: Falta de Memória\n").insere_esquerda void insere_esquerda (struct DESCRITOR *d.break. p->posterior = q. } while (!strchr("EDF". } } while (op != 'F').inicializa_descritor void inicializa_descritor (struct DESCRITOR *d) { d->primeiro = NULL. [D]ireita ou [F]im?"). q->anterior = p.

p = p->posterior. p->dado). } // -----------------------------------.exibir_lista_direita void exibir_lista_direita (struct DESCRITOR d) { struct ELEMENTO *p. p = (struct ELEMENTO *) malloc(sizeof(struct ELEMENTO)).ultimo. p->dado = n. } } } // -----------------------------------. d->primeiro = p. d->n = d->n + 1. int n) { struct ELEMENTO *p. q->posterior = p. p->dado = n. p = d. } printf("Valor: %d\n". p = p->anterior.// -----------------------------------.insere_direita void insere_direita (struct DESCRITOR *d. 106 . d->ultimo = p. else { if (d->n == 0) { p->anterior = NULL. d->n = 1.primeiro. p = d. p->dado). while (p->anterior != NULL) { printf("Valor: %d\n". d->ultimo = p. p->dado). p->posterior = NULL.*q. if (p == NULL) printf("ERRO: Falta de memória\n"). } else { q = d->ultimo. while (p->posterior != NULL) { printf("Valor: %d\n".exibir_lista_esquerda void exibir_lista_esquerda (struct DESCRITOR d) { struct ELEMENTO *p. p->posterior = NULL. p->anterior = q.

O formato do relógio deve ser hh:mm:ss. 107 .1 Escreva um programa em C que exibe um relógio na tela. 18. p->dado). Lista de exercícios gerais 18.2 Escreva um programa em C que exibe a data na tela. O formato da data deve ser dd:mm:aaaa.} printf("Valor: %d\n". } 18.

definicoes #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define ESC ENTER UP DOWN LEFT RIGHT 27 13 259 258 260 261 COLOR_GREEN COLOR_GREEN COLOR_BLUE COLOR_YELLOW COLOR_RED COLOR_BLUE COLOR_RED COLOR_WHITE COLOR_RED COLOR_YELLOW COLOR_YELLOW COLOR_CYAN COR_TEXTO COR_PALAVRA COR_PALAVRAS COR_TELA COR_XIS COR_ACERTO COR_FINAL COR_RECORDE COR_TEMPO COR_NOME COR_RELOGIO COR_PARABENS // --------------------------------------------------------.includes #include #include #include #include #include #include <string.h> <curses. int *s).Anjuta) // Autor: Paulo Roberto Gomes Luzzardi // Data: 15/06/2006 // --------------------------------------------------------. void apaga_linha(int c. void troca(int *x. int *y). de // palavras. void novo_recorde(char *s. int *m. int seg).prototypes void tela(void). int l). int n. void tempo(int c. int l. void final(int min. int posicao_palavra(int pos). int procura_palavra(char *s).19. int min.h> <stdlib.h> <ctype.c (Kubuntu .h> // biblioteca ncurses // --------------------------------------------------------. 108 . void sorteia_palavras(int n).h> <time. void STRING(int c. void exibe_palavras_sorteadas(void). char *s). int l.1 Jogo de Caça-Palavras O jogo de caça-palavras abaixo demonstra a utilização biblioteca “ncurses” específica para terminal em modo texto. void exibe_palavras(void). void relogio(int *h. Programas exemplos usando ncurses 19.h> <signal. int n). int seg).

void flushall(void).gotoxy void gotoxy(int c.flushall void flushall(void) { getchar().randomize 109 . int l) { move(l-1.0)). // saída em cores if (has_colors()) { start_color().COLOR_BLACK).COLOR_WHITE. } // --------------------------------------------------------.COLOR_RED.COLOR_BLACK). // inicializa a biblioteca curses keypad(stdscr. init_pair(1. int l). } // --------------------------------------------------------.COLOR_CYAN. int RANDOM(int inic. j = inic + (int) ((faixa+1.COLOR_YELLOW.clrscr void clrscr(void) { clear(). void clrscr(void).// --------------------------------------------------------.COLOR_BLACK). system("clear").COLOR_BLUE. init_pair(6.COLOR_MAGENTA. // mapeamento do teclado (void) nonl().prototypes void inicializa_janelas(void).COLOR_BLACK). init_pair(5.COLOR_BLACK).RANDOM int RANDOM(int inic. } } // --------------------------------------------------------. void gotoxy(int c.COLOR_GREEN. } // --------------------------------------------------------. } // --------------------------------------------------------.COLOR_BLACK). void finaliza_janelas(void). } // --------------------------------------------------------. init_pair(3. refresh().finaliza_janelas void finaliza_janelas(void) { endwin(). // não espera por \n (void) echo(). init_pair(2. attrset(COLOR_PAIR(A_BOLD)). // não converte NL em CR/NL (void) cbreak(). init_pair(4.inicializa_janelas void inicializa_janelas(void) { initscr(). refresh(). // --------------------------------------------------------. void randomize(void).0) * rand() / (RAND_MAX + 1. void textcolorlight(int cor).c-1). float faixa) { int j. TRUE).COLOR_BLACK). init_pair(7. float faixa). void textcolor(int cor). return(j).

char *nome_arquivo = "recorde.w.troquei. int l1.acertou[NPAL].void randomize(void) { srand((unsigned int)time((time_t *)NULL))."cereja".si = 0.c2. if (sa < 0) sa = sa + 60."carambola"."banana".pal"."marmelo"}. } dados. char sit[NPAL].si. } // --------------------------------------------------------.textcolorlight void textcolorlight(int cor) { attrset(COLOR_PAIR(cor)+A_BOLD). relogio(&hi.incrementa = FALSE. exibe_palavras().k.sa.linha[21]."caju".&mt.variaveis FILE *fp. sa = st . randomize(). } textcolor(COR_TEMPO)."kiwi"."acerola". int hi = 0. do { relogio(&ht. char s[10]. int ht. "morango".&st). "pessego". ma = 0. int minutos. int click = TRUE."pera".x. sorteia_palavras(PSORT)."abacate".palavra[10]. tela().y."pitanga". int segundos."caqui". inicializa_janelas()."tangerina". } // --------------------------------------------------------. #define NPAL 24 #define PSORT 8 char frutas[NPAL][10] = {"abacaxi". unsigned short letras[21][61]. int ma.mt. clrscr().main int main(void) { int tecla."lima". exibe_palavras_sorteadas(). incrementa = FALSE.l2.textcolor void textcolor(int cor) { attrset(COLOR_PAIR(cor))."bergamota". int l = 12.i."laranja".st."amora". // --------------------------------------------------------."figo".c = 40. int temp[NPAL]."goiaba".c1.&mi.j.recorde.mi = 0. if (sa == 58) incrementa = TRUE.22)."nectarina". } // --------------------------------------------------------. 110 ."pomelo". gotoxy(30. if (sa == 0 && incrementa) { ma++.t.&si)."ameixa".acertos = 0. struct { char nome[31]. textcolor(COR_TEXTO).

y = procura_palavra(palavra).t++) { palavra[x] = letras[l][t]. c1 = c. textcolor(COR_XIS).l-4). j = strlen(frutas[y]).l). gotoxy(30.s). click = TRUE. textcolor(COR_RELOGIO).l).l). acertos++. w = posicao_palavra(y). if (c2 < c1) { troca(&c1.8+w). x++. } s[k] = (char) NULL. if (tecla != UP && tecla != DOWN && tecla != LEFT && tecla != RIGHT) { textcolor(COR_TEXTO). printw("(%2d) Linha". printw("Tempo Gasto: %02d:%02d\n". gotoxy(c.8+w). printw("%c".i++) { s[k] = frutas[y][i]. textcolorlight(COR_PALAVRA).22).acertos). 111 .c-19). for (i = 0. gotoxy(1.4).l). gotoxy(1. textcolor(COR_TELA).i < j. textcolor(COR_TEXTO).printw("Tempo Gasto: %02d:%02d\n". textcolorlight(COR_PALAVRA). textcolor(COR_TEXTO). textcolor(COR_TEMPO). click = FALSE. letras[l][c1+i] = s[k]. gotoxy(c1. tecla = getch(). if (y != -1) { k = 0. } palavra[x] = (char) NULL. gotoxy(1. gotoxy(c.1).frutas[y]). tempo(56. textcolor(COR_TEXTO). } x = 0. printw("(%2d) Coluna".3). printw("%s".letras[l][c]). } if (tecla == ENTER) { if (click) { l1 = l.ma. printw("%s". gotoxy(c. for (t = c1.sa). gotoxy(5. printw("x").ma.letras[l][c]).sa). troquei = TRUE. gotoxy(2. } else { l2 = l. printw("(%2d) Acertos". textcolor(COR_ACERTO). c2 = c. printw("%c".5).&c2).t <= c2. if (l1 == l2) { troquei = FALSE. k++.

printw("%c".3). printw("%c".231).l < NPAL.l++) for (c = 20. if (acertos == PSORT) final(ma. tempo(56. gotoxy(20. gotoxy(20.tela void tela(void) { int c. gotoxy(2. break.199). textcolor(COR_TELA). for (l = 0.fp).l1). finaliza_janelas().} } switch (tecla) { case UP: l--."r+b").4). if (c < 20) c = 60.c++) letras[l][c] = RANDOM(97. break. return(1).l <= 20. case DOWN: l++. gotoxy(c1. printw("-> Use as setas para procurar palavras <-". 112 .letras[l1][c1]).3). for (l = 5. } } // --------------------------------------------------------.25). gotoxy(c2. gotoxy(32. printw("%s".1). if (l > 20) l = 5.acertos). } else { letras[l2][c2] = tolower(letras[l2][c2]).letras[l2][c2]).recorde.22).24). refresh().5). gotoxy(20. if (fp != NULL) { fread(&recorde. break. printw("Tempo: ").1).sa). case RIGHT: c++.l2).1. } else if (!troquei) { letras[l1][c1] = tolower(letras[l1][c1]). if (c > 60) c = 20. textcolor(COR_NOME). break. printw("[ESC] Abandona").l. textcolor(COR_RECORDE). fp = fopen(nome_arquivo.l++) temp[l] = -1. if (l < 5) l = 20. gotoxy(33. } } while (tecla != 27). case LEFT: c--. printw("CA%cA PALAVRAS".4). printw("Recordista: "). gotoxy(27. } gotoxy(2.sizeof(recorde).nome).c <= 60. printw("%2d".

30). linha[l] = l. } } while (i <= n). for (i = 0.x.i <= 20. } } // --------------------------------------------------------. textcolor(COR_TEXTO).z++) { letras[l][z] = frutas[j][x]. int c. if (y > 60) c = c . c = RANDOM(20. } // --------------------------------------------------------. for (l = 5. } for (i = 0.} printw("%02d:%02d".recorde.minutos. printw("%c". x++.i++) { sit[i] = 'N'.t. y = c + t.segundos).l.l = 8.15).sorteia_palavras void sorteia_palavras(int n) { int i.i++) linha[i] = -1.c++) { gotoxy(c.l). } sit[j] = 'S'.15). fclose(fp).exibe_palavras_sorteadas void exibe_palavras_sorteadas(void) { int t.j.t++) if (temp[t] != -1) { 113 . i = 1.h = 0. l = RANDOM(5. } linha[l] = l. h++.t < NPAL. for (z = c. do { j = RANDOM(0.y. x = 0. } // -------------------------------------------------------.l <= 20. acertou[i] = TRUE.l. if (l >= 20) l = 5.i < NPAL.NPAL-1).t. l = RANDOM(5.exibe_palavras void exibe_palavras(void) { int c.c <= 60.recorde.z. i++.z < c+t. if (sit[j] == 'N') { t = strlen(frutas[j]). for (t = 0.l++) for (c = 20.letras[l][c]). while (linha[l] != -1) { l++. temp[h] = j. textcolorlight(COR_PALAVRAS).

i < n.t++) { n = strlen(frutas[t]). for (i = 0.segundos_atual.l)."w+b"). novo_recorde(dados.minutos = min.22). } 114 . STRING(37.30.segundos). printw("Qual o seu Nome: ______________________________"). j = 0.nome). return(t).1.minutos = min.segundos = seg.nome.22. gotoxy(20. if (i == 0 && acertou[t]) { acertou[t] = FALSE.t < NPAL.nome.dados. printw("[ ] %s". STRING(37. fwrite(&dados. gotoxy(20."r+b"). } } return(-1). dados. for (i = 0.i < n. char r[10].} gotoxy(1. int c. int seg) { char tecla.minutos.minutos. segundos_atual = seg + min * 60. dados.frutas[temp[t]]).22.segundos = seg. n = strlen(s). l++. if (segundos_atual < segundos_recorde) { textcolor(COR_RECORDE).i.final void final(int min.nome). novo_recorde(dados.segundos + recorde.i.sizeof(dados). // --------------------------------------------------------.s).fp). fclose(fp).fp).i++) s[i] = toupper(s[i]). } // --------------------------------------------------------.dados. i = (int) strcmp(r. fp = fopen(nome_arquivo.segundos). dados.1.minutos * 60. j++.j. int segundos_recorde.i++) { r[j] = toupper(frutas[t][i]). fclose(fp). dados.dados. fwrite(&dados.dados. for (t = 0. } r[j] = (char) NULL. } textcolor(COR_TEXTO). if (fp != NULL) { textcolor(COR_RECORDE).sizeof(dados).22).l.n.dados. if (fp == NULL) { fp = fopen(nome_arquivo.procura_palavra int procura_palavra(char *s) { int t.30.dados. printw("Qual o seu Nome: ______________________________"). } } else { segundos_recorde = recorde.

gotoxy(24. system("clear").3. int min. printw("Tecle [ENTER] para finalizar").x. do { tecla = getch().tempo void tempo(int c.l++) for (c = 20. strcpy(s.41). int l) { time_t now. gotoxy(20.relogio void relogio(int *h. gotoxy(27.min.s). printw(" -> Winner").4).30). } // --------------------------------------------------------.novo_recorde void novo_recorde(char *s. int *s) { time_t now. int i. textcolorlight(COR_PARABENS).3).22). *y = t.24. printw("NOVO RECORDE.22).l).seg).50).i++). apaga_linha(32. gotoxy(27.c <= 60. printw("Recordista: "). int *y) { int t. gotoxy(20.22.temp[5]. apaga_linha(20. time(&now). endwin().22.24).s). gotoxy(30. gotoxy(c.seg). // pausa } textcolor(COR_TEXTO). printf("TEMPO GASTO [%02d:%02d]". time(&now). printw("Tempo: "). } // --------------------------------------------------------. textcolor(COR_NOME). gotoxy(32. for (l = 5. exit(1).ctime(&now)). PARAB%cNS".l <= 20. printw("%02d:%02d". int seg) { textcolor(COR_RECORDE). t = *x.4). char st[30].c++) { gotoxy(c. } // --------------------------------------------------------.troca void troca(int *x. printw("%s".} textcolorlight(COR_FINAL).3).min. 115 . *x = *y.50). int *m. } while (tecla != ENTER && tecla != ESC). apaga_linha(20. char s[30].i <= 900000. apaga_linha(20. for (i = 0.201). printw("%s". } // --------------------------------------------------------.l).

apaga_linha void apaga_linha(int c. int n. x = 0.} strcpy(st. 116 . for (i = 0. i++. printw(" "). x++.l). return(-1). x = 0. int n) { int i. for (i = 17. gotoxy(c. c++. printw("%c". s[i] = (char) NULL. int i = 0. s[i] = (char) NULL. if ((tecla >= 'A' && tecla <= 'Z') || (tecla >= 'a' && tecla <= 'z') || tecla == 32) { gotoxy(c. } temp[x] = (char) NULL. gotoxy(c.i++) { temp[x] = st[i]. c--.l). for (i = 11. } // --------------------------------------------------------. x++. *s = atoi(temp). int l.posicao_palavra int posicao_palavra(int pos) { int i. *h = atoi(temp). s[i] = tecla.i <= 12. for (i = 14. } } while (tecla != ENTER && i < n). *m = atoi(temp).STRING void STRING(int c. } // --------------------------------------------------------. } temp[x] = (char) NULL.l).i++) if (temp[i] == pos) return(i).l).ctime(&now)). do { gotoxy(c. gotoxy(c.i <= 15.i <= 18.i++) { temp[x] = st[i]. // --------------------------------------------------------. } if (tecla == 127 && i >= 1) { i--. char *s) { char tecla. tecla = getch(). printw(" ").i < PSORT. x = 0.tecla). int l.i++) { temp[x] = st[i].l). } temp[x] = (char) NULL. x++.

ano. tm_mday. tm_yday. tm_year.11] ano (desde 1900) [0. tm_hour.h> #include <stdlib. (long) tempo). printf("Data em segundos: %ld\n".6] dia do ano (desde 1 Janeiro) [0.h> #define ESC 27 int main(void) { time_t tempo. tm_wday. tm_isdst. tm_min. // relogio.h> #include <time.i <= n. Protótipo da função: time_t time(time_t *t). data. hora. struct tm *data..i++) printw(" "). etc).. struct tm { int int int int int int int int int }. char tecla.59] hours [0..365] informação sobre mudança da hora A função time() obtém a informação do operacional Linux e retorna no formato time_t. tm_mon.s.. tm_sec. } 19..31] mês (meses desde Janeiro) [0.gotoxy(c. Sintaxe da função: struct tm localtime(time_t *t).c #include <stdio.h” possui dois tipos de dados que suportam informação temporal: time_t: possui a informação de calendário (data + hora) num único número que representa um instante de tempo.m.59] minutos [0. mês..23] dia do mês [1.. // // // // // // // // // segundos [0. a utilização da biblioteca A biblioteca “time.2 Relógio em Linux O seguinte programa demonstra “time.h” exibindo um relógio na tela.l). do { time(&tempo).. Este número representa o total de segundos que passaram desde as zero horas de 1 de Janeiro de 1970 (a data zero para os sistemas UNIX). for (i = 1. int h.] dia da semana (desde Domingo) [0. struct tm: é usado para representar um instante de tempo no formato dividido por classes (dia. relógio do sistema A função localtime() obtém a informação do relógio do sistema operacional Linux no formato struct tm. 117 .

m).h> <time. h = data->tm_hour.h” + “clock. textcolorlight e kbhit.[ENTER] . int random(int n). printf(" Minutos: %d\n".3 Biblioteca “conio. } while (tecla != ESC). printf(" Segundos: %d\n". void endconio(void). } 19. int random(int n). int kbhit(void). data->tm_mon+1). printf("Horario Atual:\n"). void randomize(void). void delay(int espera). 118 . // conio. data->tm_year+1900).Abandona . printf(" Horas: %d\n".data = localtime(&tempo). void gotoxy(int c.h> <signal. printf(" Mes: %d\n". gotoxy. randomize. void clrscr(void).Atualiza: "). textcolor.h> <sys/select. void flushall(void). tecla = getchar(). printf("Data de Hoje\n"). int l). int l).h”. void textcolor(int cor).c” Abaixo é mostrado uma biblioteca que simula as principais funções da biblioteca “conio. void flushall(void). printf(" Dia: %d\n". printf(" Ano: %d\n". void textcolorlight(int cor). data->tm_mday). delay. s = data->tm_sec.cores #define #define #define #define #define #define #define #define BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE COLOR_BLACK COLOR_RED COLOR_GREEN COLOR_YELLOW COLOR_BLUE COLOR_MAGENTA COLOR_CYAN COLOR_WRITE // --------------------------------------------------------. random. tais como: clrscr. Protótipos da Funções desta biblioteca: void clrscr(void). void randomize(void). void textcolor(int cor).h> // --------------------------------------------------------. flushall.h // -----------------------------. void delay(int espera).prototypes void initconio(void). void textcolorlight(int cor).includes #include #include #include #include <curses.s). m = data->tm_min. void gotoxy(int c. printf("[ESC] .h).

} // --------------------------------------------------------. init_pair(2.clrscr void clrscr(void) { clear(). init_pair(4. (void) cbreak().COLOR_BLACK). } } // --------------------------------------------------------. init_pair(3. 119 .gotoxy void gotoxy(int c.COLOR_MAGENTA.c-1). init_pair(1. (void) nonl().COLOR_BLACK).COLOR_WHITE.COLOR_BLACK).COLOR_BLACK). system("clear"). } // --------------------------------------------------------.endconio void endconio(void) { endwin(). } // --------------------------------------------------------.COLOR_GREEN.initconio void initconio(void) { initscr().flushall void flushall(void) { getchar().delay void delay(int espera) { clock_t t. refresh(). init_pair(6.int kbhit(void). } // --------------------------------------------------------. refresh(). init_pair(7. t = rand() % n.COLOR_CYAN. TRUE). (void) echo(). int l) { move(l-1.COLOR_BLACK). keypad(stdscr. } // --------------------------------------------------------.COLOR_BLACK). attrset(COLOR_PAIR(A_BOLD)). // --------------------------------------------------------.COLOR_BLACK). return(t).COLOR_BLUE.COLOR_RED. if (has_colors()) { start_color().random int random(int n) { int t.COLOR_YELLOW. init_pair(5. } // ---------------------------------------------------------.randomize void randomize(void) { srand((unsigned int)time((time_t *)NULL)).

h” completa Abaixo é mostrado uma biblioteca funções da biblioteca “conio. FD_ZERO(&read_fd). // função obrigatória } 19. } Programa Principal: clock. s = data->tm_sec.m.h" #include <time.kbhit int kbhit(void) { struct timeval tv.h> // --------------------------------------------------------.c // clock.includes #include <stdio.m. return(0). } // --------------------------------------------------------.t = clock() + espera.&tv) == -1) return(0). textcolor(BLUE). m = data->tm_min. int h. gotoxy(1. data = localtime(&tempo). do { time(&tempo). char tecla. FD_SET(0. tv. fd_set read_fd. tv.1).h> #include "conio. while (clock() <= t).&read_fd)) return(1).textcolor void textcolor(int cor) { attrset(COLOR_PAIR(cor)).NULL. // função obrigatória clrscr().main int main(void) { time_t tempo.4 Biblioteca “conio.s). printw("Hora: %02d:%02d:%02d".h. if (FD_ISSET(0. } // --------------------------------------------------------.tv_usec=0. struct tm *data. h = data->tm_hour.textcolorlight void textcolorlight(int cor) { attrset(COLOR_PAIR(cor)+A_BOLD). } while (!kbhit()). if (select(1. initconio().h”.NULL.c // --------------------------------------------------------.s.tv_sec=0. que simula as principais 120 . endconio(). &read_fd. } // --------------------------------------------------------.&read_fd).

enum COLORS {BLACK. char char char char char char char char char char char winleft. int right. BLUE. int kbhit(void). Biblioteca: conio. char color_warning. screenwidth. .h> int directvideo.. void doneconio(void). LIGHTCYAN.h> <pwd. int bottom). LIGHTRED. C80. BROWN. int cscanf(const char *format. void normvideo(void).h #include #include #include #include #include #include <stdarg. WHITE}. currmode. void window(int left. void cputs(char *str). char *cgets(char *str). MAGENTA. curx. CYAN. int putch(int c).h // conio.h> <curses. int wherey(void). attribute. normattr. void nocursor(void). int top.h> <unistd. void cursor(void).h> <string. void lowvideo(void). BW40=0. int cprintf(char *format. void textbackground(int color).Protótipos das Funções desta biblioteca: void initconio(void).). cury. struct text_info { unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned }. void textmode(int unused_mode). #define BLINK 128 121 . MONO=7. YELLOW. LIGHTBLUE. BW80. void highvideo(void). LIGHTMAGENTA. C4350=64}. DARKGRAY. screenheight. void gettextinfo(struct text_info *r).. winright. int y). winbottom. void insline(void). GREEN. int getche(void). enum text_modes {LASTMODE=-1. void clreol(void). int wherex(void).. void delline(void). LIGHTGREEN. LIGHTGRAY. void gotoxy(int x. int key(void). RED. WINDOW *conio_scr. C40.h> <stdio.. void textattr(int attribute). wintop. void textcolor(int color). .). void clrscr(void).

lowvideo(void). cputs(char *str). unsigned value).bgc. gotoxy(int x.0). if (((color&127)==15) | ((color&127)==7)) txtattr=COLOR_PAIR(0). int y). textattr(int attribute). window(int left. unsigned value). gettextinfo(struct text_info *r). outp(unsigned port. clrscr(void).. cscanf(const char *format. int bottom).. inp(unsigned port). normvideo(void).void initconio(void). case 7 : return COLOR_WHITE. case 2 : return COLOR_GREEN.. case 6 : return COLOR_YELLOW.). case 1 : return COLOR_BLUE. key(void). int directvideo. delline(void). int right. else txtattr|=A_NORMAL. textbackground(int color). kbhit(void). inpd(unsigned port). getche(void). if ((color&128)==128) txtattr=A_BLINK. textcolor(int color). void doneconio(void). highvideo(void). if ((color&15)>7) txtattr|=A_STANDOUT. WINDOW *conio_scr. . outpd(unsigned port. char color_warning=1.oldattr. . cprintf(char *format. if (((color&127)==127) | ((color&127)==119)) 122 .). case 4 : return COLOR_RED. unsigned unsigned unsigned unsigned unsigned unsigned void void void void void void void void void void void void void void void clreol(void). case 5 : return COLOR_MAGENTA. else txtattr=A_NORMAL. txtattr|=COLOR_PAIR((1+(color&7)+(color&112)) >> 1). textmode(int unused_mode). outpw(unsigned port. case 3 : return COLOR_CYAN. void cursor(void).. int top. wherey(void). int colortab(int a) { switch(a) { case 0 : return COLOR_BLACK. void nocursor(void). inpw(unsigned port). } } void docolor (int color) { wattrset(conio_scr. static int txtattr. static int fgc. int int int int int int int int wherex(void). static int initialized=0. char *cgets(char *str). insline(void). putch(int c).unsigned value).

123 . conio_scr=newwin(0. raw().0)."Atenção: Problema com a cor\n"). meta(conio_scr. return value.TRUE).%1\n" : : "a" (val).NULL). if (!has_colors() & (color_warning>-1)) fprintf(stderr. } static inline void outportw (unsigned short int port. } static inline int inportw (int port) { unsigned short value. } static inline void outportd (unsigned short int port.&dummy2. return value. unsigned int val) { __asm__ volatile ( "outw %0. "d" (port) ).y. start_color().%0" : "=a" (value) : "d" ((unsigned short) port)). return value.&dummy1. __asm__ volatile ("inw %1.%1\n" : : "a" (val).TRUE). __asm__ volatile ("inb %1.txtattr). noecho(). } static inline int inportd (int port) { unsigned int value.COLOR_PAIR(1+(color&7)+((color&112)>>1))). } static inline int inport (int port) { unsigned char value. } static inline void outport (unsigned short int port. unsigned char val) { __asm__ volatile ( "outb %0. wattron(conio_scr.%0" : "=a" (value) : "d" ((unsigned short)port)). oldattr=wattr_get(stdscr. "d" (port) ).0. "d" (port) ).0. idlok(conio_scr. short dummy2. attr_t dummy1. unsigned int val) { __asm__ volatile ( "outl %0. initialized=1. wattron(conio_scr.%0" : "=a" (value) : "d" ((unsigned short)port)). __asm__ volatile ("inl %1.%1\n" : : "a" (val). keypad(conio_scr. } void initconio (void) { int x.txtattr=COLOR_PAIR(8).TRUE). initscr(). nonl().

&strng[2]. while (strng[i] != 0) i++.NULL). wrefresh(conio_scr). char buffer[BUFSIZ]. colortab(y)).. wrefresh(conio_scr). colortab(x). } void doneconio (void) { endwin().. unsigned char i = 2. } int cprintf (char *format.&dummy2.str. wrefresh(conio_scr). if (initialized==0) initconio(). } void clreol (void) { if (initialized == 0) initconio(). wmove(conio_scr. } void clrscr (void) { if (initialized == 0) initconio(). va_start(argp. for (y=0. if (initialized == 0) initconio(). waddstr(conio_scr.(int) strng[0]).. textcolor(7)..scrollok(conio_scr. bgc=0.&dummy1. echo(). strng[1] = i. textbackground(0). . return(i).y++) for (x=0.2. . vsprintf(buffer. return(&str[2]).y<=7.buffer). strncpy(strng. ) { int i. strcpy(str. wclrtoeol(conio_scr).1). } char *cgets (char *str) { char strng[257]. 124 . wgetnstr(conio_scr. i = i . va_end(argp).strng).x<=7. va_list argp.0).str). noecho().TRUE). } void cputs (char *str) { if (initialized == 0) initconio(). txtattr=wattr_get(conio_scr.x++) init_pair((8*y)+x+1.0.format. } int cscanf (const char *format.format). wrefresh(conio_scr).) { int i. wclear(conio_scr). i = waddstr(conio_scr.argp).

char buffer[BUFSIZ]; va_list argp; if (initialized == 0) initconio(); echo(); if (wgetstr(conio_scr,buffer) == ERR) return(-1); va_start(argp,format); i = vsscanf(buffer,format,argp); va_end(argp); noecho(); return(i); } void delline (void) { if (initialized == 0) initconio(); wdeleteln(conio_scr); wrefresh(conio_scr); } void cursor(void) { curs_set(1); } void nocursor(void) { curs_set(0); } int key(void) { int i; if (initialized == 0) initconio(); i=wgetch(conio_scr); if (i == -1) i = 0; return i; } int getche (void) { int i; if (initialized == 0) initconio(); echo(); i = wgetch(conio_scr); if (i == -1) i=0; noecho(); return(i); } void gettextinfo(struct text_info *inforec) { attr_t dummy1; short dummy2; unsigned char xp,yp; unsigned char x1,x2,y1,y2; unsigned char cols,lines; unsigned char dattr,dnattr,a; if (initialized == 0) initconio(); getyx(conio_scr,yp,xp); getbegyx(conio_scr,y1,x1); getmaxyx(conio_scr,y2,x2); dattr = (bgc*16)+fgc; a = wattr_get(conio_scr,&dummy1,&dummy2,NULL); if (a == (a & A_BLINK)) dattr=dattr+128; dnattr = oldattr;

125

inforec->winleft = x1 + 1; inforec->wintop = y1 + 1; if (x1==0) x2--; if (y1==0) y2--; inforec->winright = x1 + x2 + 1; inforec->winbottom = y1 + y2 + 1; inforec->curx = xp + 1; inforec->cury = yp + 1; inforec->screenheight = y2 + 1; inforec->screenwidth = x2 + 1; inforec->currmode = 3; inforec->normattr = dnattr; inforec->attribute=dattr; } void gotoxy (int x, int y) { if (initialized == 0) initconio(); y--; x--; wmove(conio_scr,y,x); wrefresh(conio_scr); } void highvideo (void) { if (initialized == 0) initconio(); textcolor(15); textbackground(0); } void insline (void) { if (initialized == 0) initconio(); winsertln(conio_scr); wrefresh(conio_scr); } int kbhit (void) { int i; if (initialized == 0) initconio(); nodelay(conio_scr,TRUE); i = wgetch(conio_scr); nodelay(conio_scr,FALSE); if (i == -1) i = 0; return(i); } void lowvideo (void) { if (initialized == 0) initconio(); textbackground(0); textcolor(8); } void normvideo (void) { if (initialized == 0) initconio(); wattrset(conio_scr,oldattr); } int putch (int c) { if (initialized == 0) initconio(); if (waddch(conio_scr,c) != ERR) {

126

wrefresh(conio_scr); return(c); } return(0); } void textattr (int attr) { if (initialized == 0) initconio(); docolor(attr); } void textbackground (int color) { if (initialized == 0) initconio(); bgc = color; color = (bgc * 16) + fgc; docolor(color); } void textcolor (int color) { if (initialized == 0) initconio(); fgc = color; color = (bgc * 16) + fgc; docolor(color); } void textmode (int mode) { if (initialized == 0) initconio(); } int wherex (void) { int y; int x; if (initialized == 0) initconio(); getyx(conio_scr,y,x); x++; return(x); } int wherey (void) { int y; int x; if (initialized == 0) initconio(); getyx(conio_scr,y,x); y++; return(y); } void window (int left,int top,int right,int bottom) { int nlines,ncols; if (initialized == 0) initconio(); delwin(conio_scr); top--; left--; right--; bottom--; nlines = bottom - top; ncols = right - left; if (top == 0) nlines++; if (left == 0) ncols++;

127

c // cores.TRUE). 128 . conio_scr = newwin(nlines. idlok(conio_scr.ncols. scrollok(conio_scr.cor++) { textcolor(cor).5 Jogo da Forca O jogo da forca demonstra também a utilização de biblioteca “ncurses” específica para terminal em modo texto.TRUE).10). keypad(conio_scr. meta(conio_scr.c #include <stdio.left). getche(). gotoxy(10. doneconio(). cprintf("Universidade Católica de Pelotas"). } Programa: cores. nocursor().TRUE).TRUE). // função obrigatória clrscr(). for (cor = 1. // função obrigatória } 19. } cursor(). wrefresh(conio_scr).if ((nlines<1) | (ncols<1)) return.h> #include "conio.cor <= 15.h" int main(void) { int cor.top. initconio().

h> <curses.h> // --------------------------------------------------------. int n. int *s). int l).h> <time.c (Kubuntu . int l. int *y). int l. char *s). apaga_linha(int c. 129 .// forca. STRING(int c. int *m.Anjuta) // Autor: Paulo Roberto Gomes Luzzardi // Data: 17/06/2006 // --------------------------------------------------------. int seg). int n). tempo(int c.prototypes void void void void void void void void tela(void).definicoes #define ESC #define ENTER #define SPACE 27 13 32 #define LEFT 260 #define RIGHT 261 #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define BLACK RED GREEN BROWN BLUE MAGENTA CYAN WHITE COR_TEXTO COR_TELA COR_TEMPO COR_RELOGIO COR_WINNER COR_LETRAS COR_SELECAO COR_TITULO COR_STATUS COLOR_BLACK COLOR_BLUE COLOR_GREEN COLOR_YELLOW COLOR_BLUE COLOR_MAGENTA COLOR_CYAN COLOR_WHITE GREEN BROWN RED BROWN CYAN BLUE RED MAGENTA WHITE // --------------------------------------------------------. relogio(int *h. troca(int *x.includes #include #include #include #include <string. boneco(int erro).h> <stdlib. final(int min.

(void) cbreak().COLOR_CYAN. } // --------------------------------------------------------.Random int Random(int n) { int t. init_pair(1. } // --------------------------------------------------------.// --------------------------------------------------------. } // --------------------------------------------------------. system("clear").COLOR_BLACK).COLOR_BLACK). } } // --------------------------------------------------------. return(t).gotoxy void gotoxy(int c. void textcolorlight(int cor). void flushall(void).clrscr void clrscr(void) { clear().COLOR_YELLOW. int l) { move(l-1. refresh(). void randomize(void). void textcolor(int cor). t = rand() % n. init_pair(7. init_pair(5.inicializa_janelas void inicializa_janelas(void) { initscr(). } // --------------------------------------------------------. int Random(int n).COLOR_BLACK). init_pair(3. init_pair(6. init_pair(4. } // --------------------------------------------------------. void clrscr(void).COLOR_WHITE.COLOR_GREEN. (void) echo().COLOR_RED.c-1). (void) nonl().COLOR_MAGENTA. init_pair(2. attrset(COLOR_PAIR(A_BOLD)). int l).randomize 130 .COLOR_BLACK). // --------------------------------------------------------.finaliza_janelas void finaliza_janelas(void) { endwin().COLOR_BLACK).COLOR_BLACK). TRUE). void gotoxy(int c.COLOR_BLACK).flushall void flushall(void) { getchar(). keypad(stdscr. if (has_colors()) { start_color(). void finaliza_janelas(void). refresh().COLOR_BLUE.prototypes void inicializa_janelas(void).

} // --------------------------------------------------------. time(&now).ctime(&now)). char s[30]. int *s) { time_t now.textcolor void textcolor(int cor) { attrset(COLOR_PAIR(cor)). printw("%s".x. x++. time(&now).i++) { temp[x] = st[i].l). char st[30]. } temp[x] = (char) NULL. for (i = 17. strcpy(st. int *m. x = 0. for (i = 11. int i. for (i = 14. } temp[x] = (char) NULL.i <= 18. #define NPAL 30 #define PSORT 8 #define NTIPOS 4 131 .tempo void tempo(int c. } // --------------------------------------------------------. *s = atoi(temp). } // --------------------------------------------------------.i++) { temp[x] = st[i]. strcpy(s. textcolor(COR_RELOGIO). } // --------------------------------------------------------. } // --------------------------------------------------------. x = 0.temp[5]. x = 0.textcolorlight void textcolorlight(int cor) { attrset(COLOR_PAIR(cor)+A_BOLD).void randomize(void) { srand((unsigned int)time((time_t *)NULL)).i <= 12. *m = atoi(temp).variaveis unsigned short letras[21][61].i <= 15.ctime(&now)). x++. int l) { time_t now. x++. } temp[x] = (char) NULL. gotoxy(c.relogio void relogio(int *h.i++) { temp[x] = st[i].s). *h = atoi(temp).

i <= 25. "tangerina". c = 16. break. "mongolia". acertos. "israel". "lima". "cereja". "corrola". col. relogio(&hi. "rivera". "peru". paises[j]). erros = 0. "caju". randomize(). "alemanha". "russia". textcolor(WHITE). "chuy". "montenegro". k."nectarina". case 1: strcpy(palavra. st. m."Carros". getmaxyx(stdscr."egito"."jabuticaba"}. "honda". "idea". "formigueiro". "nissan". "amora". carros[j]). "civic"}. textcolorlight(GREEN). "subaru". "gol". "peuget". "gramado". 132 .col). ch. "inglaterra". "palio". "laranja". "carambola". "iraqui". "alegrete". j. inicializa_janelas(). "bmw". "palestina"."damasco"."australia". "cacequi". "china". "agudo". "banana".row. "pitanga". "citroen". "parati". sai. "omega". "uruguaiana". char frutas[NPAL][11] = {"abacaxi". clrscr(). j = Random(NPAL). sa. l. "fusca". case 2: strcpy(palavra. "acerola". frutas[j]). incrementa = FALSE. si. ma = 0. "buzios". mi. m = Random(NTIPOS).char nomes[NTIPOS][10] = {"Cidades". int ht. gotoxy(1. "elba". i. "toyota". "fiat"."candiota". "tapes". "piratini". "chile". "morango". int c. "dodge".&mi. "tibet". "mostarda".1). "dakota". "sportage". "parati"."chiapeta". textcolor(COR_TEXTO). "marau". "figo". // tamanho do terminal do { ch = 'A'. "caqui"."manga". lin. char cidades[NPAL][11] = {"pelotas". char carros[NPAL][11] = {"mercedes"."Países"."congo"}. "caxias"."jaca". "frontier". printw(“| row: %d | col: %d |”. "erechin"."cidreira"}. "marmelo". "corcel". "suecia". "ameixa". n. sai = FALSE. gotoxy(60. row. } textcolor(GREEN). erros.1). total = 0. printw("Tipo: "). "uva". col). break."casca". case 3: strcpy(palavra. "golf". "saveiro". "chui". vetor[26]. "cuba". "portugal". int row. "goiaba". incrementa. total. "pomelo". "ford". "escocia". "abacate". for (i = 0. "nepal". "uruguai". "itaqui". int ma. "kombi". "nectarina".&si). acertos = 0. acertou. int hi. "pera". "canela".i++) vetor[i] = '*'."cassino". "noruega". "guatemala". "framboesa". char palavra[10]. mt. break. "argentina". "bergamota". switch (m) { case 0: strcpy(palavra. "espanha". "torres". cidades[j]). "renaut". char s[10]. // --------------------------------------------------------. int tecla."Frutas"}. "vectra". "livramento". "cachoerinha"."jamaica". "servia". char paises[NPAL][11] = {"brasil". "ka". tela()."cristal". "kiwi". hi = mi = si = 0. click = TRUE.24). l = 20. "candiota".main int main(void) { int click. "bolivia". "grecia". break. gotoxy(7.

lin).5).&mt. 133 .sa).i < n. switch (tecla) { case LEFT: c-=2. if (c > 66) { c = 16. if (sa == 58) incrementa = TRUE. textcolor(COR_RELOGIO). if (c < 16) { c = 66. ch = 'Z'. tempo(56. printw("%c".1). if (tecla == ESC) sai = TRUE.nomes[m]). } break. if (sa < 0) sa = sa + 60. gotoxy(c.i++) printw("_ ").printw("%s". gotoxy(20. gotoxy(30. case ENTER: case SPACE: textcolor(COR_LETRAS). for (i = 0.i < n. case RIGHT: c+=2. printw("Acertos: ").65.acertos). acertou = FALSE. gotoxy(10. textcolor(COR_SELECAO).sa). incrementa = FALSE.l).si. do { relogio(&ht. if (!acertou && vetor[k] == '*') acertos++. k = ch .10).ch).l).ch). for (i = 0.4). tecla = getch(). ch--.4). if (sa == 0 && incrementa) { ma++.22). printw("Tempo Gasto: %02d:%02d\n". textcolor(COR_TEMPO). } textcolor(COR_TEMPO). textcolorlight(COR_STATUS).ch).22). gotoxy(10. } break. gotoxy(1.ma. ch = 'A'. printf("PALAVRA: "). printw("Caracter: [%c]". printw("%d". textcolorlight(BROWN). printw(" Erros: ").ma. gotoxy(30. printw("%c". col = 29. printw("Tempo Gasto: %02d:%02d\n".5). gotoxy(c. gotoxy(34. textcolorlight(GREEN). lin = 10. printw("%d". ch++. gotoxy(1. sa = st . n = strlen(palavra).erros).18).i++) { if (toupper(palavra[i]) == ch) { gotoxy(col.&st).

textcolor(COR_WINNER). } // --------------------------------------------------------. acertou = TRUE. vetor[k] = '#'. gotoxy(2. if (total == n) { textcolor(COR_WINNER). tempo(56. total++. finaliza_janelas(). gotoxy(16.10).tecla) && tecla != ESC). gotoxy(34. printw(" O"). printw("%s". printw("A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"). do { tecla = getch(). } boneco(erros). printw("(Winner)"). sai = TRUE.14). do { tecla = getch().199). sai = TRUE.tela void tela(void) { textcolor(COR_TITULO).palavra). vetor[k] = '#'.10). } } while (!sai).tecla) && tecla != ESC).24).24).} if (erros == 5) { textcolorlight(RED). lin = 10. printw("Jogar Novamente [S/n]? ").1). switch (erro) { case 1: gotoxy(col. break.20).boneco void boneco(int erro) { int col = 60. } // --------------------------------------------------------.lin+1). } break. printw("Jogar Novamente [S/n]? "). gotoxy(30. 134 . printw("[ESC] Abandona"). case 3: gotoxy(col.22). refresh(). break. } col = col + 2. } if (!acertou && vetor[k] == '*') { erros++.lin+1).tecla) && tecla != ESC). printw("(Looser)"). printw("/|"). printw("Jogo da Forca". gotoxy(33. return(1). } while (strchr("Ss". gotoxy(50. } while(!strchr("SsNn". case 2: gotoxy(col. gotoxy(50.1). gotoxy(30. } while(!strchr("SsNn".lin). textcolorlight(COR_LETRAS).

case 5: gotoxy(col. break. } } 135 .printw("/|\\"). break.lin+2). case 4: gotoxy(col. break. printw("/").lin+2). printw("/ \\").

“curses” (Screen handling and optimization routines) . Retorno: OK (sucesso) ou ERR (erro) #include <curses. // inicializa a biblioteca ncurses 136 . Por linha de comando fica assim: $ gcc palavras. “Adicionar”. A primeira função a ser utilizada. A última função deve ser endwin().. A biblioteca disponibiliza o número de linhas da janela stdscr em LINES e o número de colunas em COLS..20.). “Bibliotecas” ..c -o palavras -lcurses <enter> No ambiente de programação anjuta tem que incluir em “Definições” . Retorno: nada Função: endwin() Uso: finaliza a biblioteca ncurses Sintaxe: int endwin(void). Retorno: OK (sucesso) ou ERR (erro) Função: printw() Uso: imprime no terminal Sintaxe: int printw(char *format. Declaração de uma janela: WINDOW *win...        A biblioteca ncurses permite a manipulação de janelas em um terminal em modo texto. Para atualizar a janela stdscr utiliza-se a função refresh..1 Conceitos Básicos No linux é necessário incluir a biblioteca “curses” para criar programas que executem em terminais em modo texto.h> int main(void) { initscr(). É uma biblioteca que permite construir uma interface textual em terminais Linux em modo texto. Janelas são definidas como ponteiros para o tipo WINDOW. Retorno: OK (sucesso) Função: refresh() Uso: atualiza a janela Sintaxe: int refresh(void).. . Função: initscr() Uso: inicializa a biblioteca ncurses Sintaxe: WINDOW *initscr(void).. A janela padrão é chamada stdscr.. obrigatoriamente é a função initscr(). para programa escritos em linguagem de programação C. “Definições de Compilação e Link..” ... Biblioteca ncurses 20.

). initscr().h> int main(void) { int row.col). } Função: move() Uso: move o cursor para a posição (lin.row. getmaxyx(stdscr. . col) Sintaxe: int move(int lin. clear(). refresh(). "| LINES: %d | COLS: %d | ". bool buffer).18. Retorno: OK (sucesso) ou ERR (erro) Observação: buffer = TRUE -> habilita as teclas especiais buffer = FALSE -> desabilita as teclas especiais Função: clear() Uso: limpa a janela no terminal Sintaxe: int clear(void). int col). 1.. endwin(). fazendo com que toques das teclas fiquem disponíveis para o programa curses assim que realizados.6. } Função: getmaxyx() Uso: verificar o número de linhas e colunas do terminal Sintaxe: void getmaxyx(WINDOW *win. char *format. endwin().row. col. refresh(). "| row: %d | col: %d | ". mvprintw(2. Sintaxe: int cbreak(void). col). int col.7). Retorno: OK (sucesso) #include <curses. mvprintw(1.. // finaliza a biblioteca ncurses 137 .LINES. COLS). Retorno: nada Função: mvprintw() Uso: imprime no terminal Sintaxe: int mvprintw(int lin. Retorno: OK (sucesso) ou ERR (erro) move(10. refresh(). getchar().2006). int col). getchar(). Retorno: OK (sucesso) Função: cbreak Uso: Desabilita o cache de teclado. printw(“Jogo da Forca”). 1. int row. Retorno: OK (sucesso) ou ERR (erro) Função: keypad() Uso: Habilita ou desabilita a leitura de teclas especiais do teclado Sintaxe: int keypad(WINDOW *win.printw("Biblioteca ncurses\n"). printw("Data: %02d/%02d/%02d\n".

TRUE). em noecho() as teclas digitadas não aparecem na tela. No modo delay espera até que uma tecla seja pressionada Função: nonl() Uso: Desabilita a conversão da tecla enter em '\n' ao ler o teclado Sintaxe: int nonl(void). Retorno: OK (sucesso) ou ERR (erro) Observação: buffer = TRUE -> habilita o modo nodelay buffer = FALSE -> desabilita o modo nodelay 20. keypad(): Habilita a leitura das teclas enter. retorna o caracter imediatamente (se nenhuma tecla foi pressionada.FALSE). Retorno: OK (sucesso) ou ERR (erro) Função: noecho() Uso: Desabilita o eco de teclas pressionadas para a tela (na aparece na tela as teclas digitadas) Sintaxe: int noecho(void). 20. em que qualquer toque de tecla é enviado ao programa imediatamente (em vez de esperar um enter) Sintaxe: int nodelay(WINDOW *win. retorna ERR).2 Funções de inicialização initscr(): primeira função obrigatória é a função. echo() ou noecho(): com echo() as teclas digitadas aparecem no terminal. caso contrário. Retorno: OK (sucesso) ou ERR (erro) Função: nodelay() Uso: Habilita ou desabilita o modo nodelay. curs_set(): utilizado para definir o tipo de cursor: (0)cursor invisível (1)cursor visível (2)cursor muito visível. Habilitar: keypad(stdscr.3 Funções de entrada Existem três tipos de funções de entrada na biblioteca ncurses:    getch(): Lê um caracter scanw(): Lê uma string formatada getstr(): Lê strings getch(): lê um caracter do teclado 138 . esc. Desabilitar: keypad(stdscr.Função: getch() Uso: Lê um caractere no teclado Sintaxe: int getch(void). Retorno: caracter ou ERR (erro) Observação: Em modo nodelay. setas. bool buffer). F1. cbreak(): desabilita a propriedade do terminal em ficar esperando o usuário digitar enter.

). int x). cbreak(). mvwscanw(WINDOW *win. se esta função estiver ativa. int y.. chtype ch). mvwgetnstr(WINDOW *. chtype ch). echochar(chtype ch). a leitura dos caracteres só começa quando a tecla enter ser pressionada noecho(). int y. mvwgetch(WINDOW *win. char *str)... Estas funções permitem ler um único caractere do terminal.). int n). getstr(): Lê string via teclado int int int int int int int int getstr(char *str). mvwaddch(WINDOW *win. int x.). char *str. mvgetstr(int y. char *fmt [. char *str)..int int int int getch(void). int x.. int n)... int x. int y. char *fmt [. mvgetch(int y. mvscanw(int y. wgetnstr(WINDOW *win.. wscanw(WINDOW *win. int n). 139 . char *str).. int x.. int x... mvwprintw(WINDOW *win. int x). os caracteres digitados não aparecerão na tela scanw(): Lê uma string formatada int int int int scanw(char *fmt [. mvaddch(int y. 20. arg] . int x. mvgetnstr(int y. int x.). int n). int y. wgetch(WINDOW *win).. wprintw(WINDOW *win. arg] .. arg] . arg] . wgetstr(WINDOW *win. arg] . int x. int n). int x. int x. wechochar(WINDOW *win. chtype ch). arg] . getnstr(char *str.). char *str. arg] . mvprintw(int y.). char *fmt [.).. int addnstr(const char *str. Elas dependem das funções: cbreak e noecho. char *fmt [. arg] . printw(): Imprime uma string na tela int int int int printw(char *fmt [. mvwgetstr(WINDOW *win. char *fmt [. chtype ch). int y.). char *fmt [.. int y. addstr(): Imprime uma string na tela int addstr(const char *str). waddch(WINDOW *win.4 Funções de saída Existem três tipos de funções de saída na biblioteca ncurses:    addch(): imprime caracteres com atributos printw(): imprime strings formatadas addstr(): imprime strings addch(): Imprime um caracter na tela int int int int int int addch(chtype ch). char *str.

const char *str). const char *str). int n). int x. attroff(A_BOLD). 2006”).int int int int int int waddstr(WINDOW *win. const char *str. attron(A_BLINK). negrito ou sublinhado. texto branco (inverso do normal) Piscante Brilho parcial Negrito Modo protegido Modo invisível Alterna os caracteres Máscara de bit para extrair um caracter 140 .5 Função de Formatação de texto A função attron permite formatar um texto através de algumas características como: itálico. attron(A_BLINK). int y. printw(“C for Linux. mvwaddnstr(WINDOW *win. by Luzzardi. Outra forma de formatação: addch('A' | A_BOLD | A_UNDERLINE). mvaddnstr(int y. mvwaddstr(WINDOW *win. waddnstr(WINDOW *win. int n). const char *str). int x. mvaddstr(int y. 20. int n). Formatação A_NORMAL A_STANDOUT A_UNDERLINE A_REVERSE A_BLINK A_DIM A_BOLD A_PROTECT A_INVIS A_ALTCHARSET A_CHARTEXT Efeito Nenhuma formatação Melhor modo de iluminação Sublinhado Fundo preto. int x. const char *str. int y. int x. Forma de usar: attron(A_BOLD). const char *str.

Outros Comandos 21.21.h” Definição de Macro-Substituição: #define <identificador> <valor> #define #define ou #define #define true !0 false 0 TRUE !0 FALSE 0 Condições para Compilação: #if <condição> #else #endif ou #ifdef <macro> #else #endif Exemplo: #include <stdio. que são executados antes do programa fonte ser Inclusão de Arquivos de Header (cabeçalhos de funções): #include <header.h> ou #include “header_usuário.1 Comandos do Pré-Processador Comandos compilado.h> #define EXISTE_DEFINE 100 // existe ou não #define SELECT 1 // selecione antes de compilar #if (SELECT == 1) #define c 10 #define l 10 #else #define c 20 #define l 20 #endif #ifdef EXISTE_DEFINE #define x 100 #else #define x 200 #endif 141 .

relacionais. } Resultado do Programa quando: #define EXISTE_DEFINE 100 // existe ou não #define SELECT 1 // selecione antes de compilar c = 10 l = 10 x = 100 Resultado do Programa quando: // #define EXISTE_DEFINE 100 #define SELECT 2 c = 20 l = 20 x = 200 21. printf("x = %d\n".l).c).x). printf("l = %d\n". lógicos e bit a bit Operador () [] ++ -(tipo) * & ~ ! * / % + >> << > >= <= < `== != & Operação parênteses conchetes incremento decremento cast conteúdo do ponteiro endereço de memória unário (-7) complemento de um não multiplicação divisão resto inteiro da divisão adição subtração deslocamento para direita deslocamento para esquerda maior que maior ou igual menor ou igual menor igual diferente and bit a bit Forma de Avaliação esquerda para direita esquerda para direita direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita esquerda para direita // não existe esta linha 142 .int main(void) { printf("c = %d\n".2 Hierarquia dos operadores aritméticos.

printf("Valor de (n) = %d\n". q = &p. printf("Endereço de (&n) = %p\n\n".Operador ^ | && || `= += -= *= /= %= >>= <<= &= ^= |= Operação ou exclusivo bit a bit ou inclusive bit a bit e (and) ou (or) atribuição atribuição (adição) atribuição (subtração) atribuição (multiplicação) atribuição (divisão) atribuição (resto inteiro divisão) atribuição (deslocamento direita) atribuição (deslocamento esquerda) atribuição (and) atribuição (ou exclusivo) atribuição (ou inclusive) Forma de Avaliação esquerda para direita esquerda para direita esquerda para direita esquerda para direita direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda direita para esquerda 21.&n). o primeiro ponteiro contém o endereço do segundo. float x[max]. Quando é definido um ponteiro para ponteiro.3 Declaração de constantes tipadas A linguagem C.*p).4 Ponteiro para Ponteiro Um ponteiro para um ponteiro é uma forma de dupla indireçao. const int max = 7. printf("Endereco do Ponteiro (&p) = %p\n\n". Um ponteiro comum (int *p) tem em seu valor é o endereço de uma variável. printf("Ponteiro (p) = %p\n". padrão ANSI.c # include <stdio. 21. permite criar constantes tipadas. 143 . que também aponta para a variável do primeiro ponteiro. int main(void) { const double pi = 3. // pointer.1416. p = &n.**q. int *p.p).n).&p). printf("Conteudo do Ponteiro (*p) = %d\n".h> int main(void) { int n = 7.

q). Resultado do Programa: Valor de (n) = 7 Endereço de (&n) = 0xbfef6384 Ponteiro (p) = 0xbfef6384 Conteudo do Ponteiro (*p) = 7 Endereco do Ponteiro (&p) = 0xbfef6380 Ponteiro Conteudo Conteudo Endereco (q) = 0xbfef6380 do Ponteiro (*q) = 0xbfef6384 do Ponteiro (**q) = 7 do Ponteiro (&q) = 0xbfef637c 144 .printf("Ponteiro printf("Conteudo printf("Conteudo printf("Endereco } (q) = %p\n".**q). do Ponteiro (**q) = %d\n". do Ponteiro (*q) = %p\n".&q).*q). do Ponteiro (&q) = %p\n\n".

145 .

return(1). calculadora. printf("Digite um valor: "). op = getchar(). scanf("%f".resp).h> int main(void) { float x. printf("Digite outro valor: ").2f\n".c. if (op == '+') resp = x + y. } else { printf("ERRO: Operador Inválido\n"). else if (op == '*') resp = x * y. else { printf("ERRO: Divisão por Zero\n").c #include <stdio. else if (op == '-') resp = x . simula uma calculadora com quatro operações: [+] [-] [*] [/] // calc.y.&x). simula uma calculadora com 10 operações: [+] Adição [-] Subtração [*] Multiplicação 146 Adição Subtração Multiplicação Divisão .resp. Programas escritos em C O programa abaixo.h> #include <stdlib. } O programa exemplo abaixo. printf("Operador [+-*/]: ").22. int erro = 0. else if (op == '/') if (y != 0) resp = x / y. return(2).y. char op. return(0).&y).c. } printf("Resposta: %. calc. scanf("%f". getchar().

printf("Digite um valor: "). if (strchr("+-*/Pp". printf("[*] Multiplicação\n"). else if (op == '-') resp = x . printf("[T] Tangente\n"). resp. scanf("%f". op = getchar().c #include #include #include #include <stdio. int erro = 0. printf("[/] Divisão\n"). printf("[+] Adição\n").op)) { printf("Digite outro valor: "). printf("[P] Potência\n").[/] [R] [P] [I] [S] [C] [T] Divisão Raiz Quadrada Potência Inverso Seno Cosseno Tangente // calculadora.&y). // apaga enter do buffer de teclado printf("Operadores:\n"). else if (op == '*') resp = x * y.h> <stdlib. printf("[I] Inverso\n"). } if (op == '+') resp = x + y. char op. printf("Qual a sua Opção? "). getchar(). printf("[-] Subtração\n").y.h> <math.h> #define PI 4*atan(1) int main(void) { float x. printf("[S] Seno\n"). else if (op == '/') if (y != 0) resp = x / y. else if (op == 'R' || op == 'r') 147 . scanf("%f". rads. printf("[R] Raiz Quadrada\n").&x). y. else erro = 1.h> <string. printf("[C] Cosseno\n").

else if (erro == 3) printf("ERRO: Tangente Infinita\n").c.0. terça.0. sábado ou domingo) de uma determinada data.br/planetario/cent_pesq_calc. return(1). else erro = 2.0. sexta. else erro = 1. } O programa abaixo. exibe o dia da semana (segunda. juliano.rj. } else if (op == 'C' || op == 'c') { rads = x * PI / 180. } else if (op == 'T' || op == 't') if (x == 90. return(0). quinta. quarta.resp).0 || x == 270.gov. else if (erro == 1) printf("ERRO: Divisão por Zero\n").0) erro = 3. resp = sin(rads). else if (erro == 2) printf("ERRO: Raiz Negativa\n"). } else { printf("ERRO: Operador Inválido\n"). else { rads = x * PI / 180.4f\n". Como calcular: http://www. resp = cos(rads).if (x >= 0) resp = sqrt(x).htm 148 . resp = tan(rads). Para tanto. é utilizado o Cálculo do Dia Juliano.rio. } if (erro == 0) printf("Resposta: %. else if (op == 'S' || op == 's') { rads = x * PI / 180. else if (op == 'P' || op == 'p') resp = pow(x.y). else if (op == 'I' || op == 'i') if (x != 0) resp = 1 / x.

break.Programa Principal int main(void) { int dia. E = (long int) resp.c // --------------------------..&mes).1. else { printf("Ano [1583]: "). B = A / 4.&ano). } A = ano / 100. dj = D + E + dia + C . case 4: printf("Sexta-Feira\n"). resp = 30. C = 2 .31]: "). dj. break.12]: "). break. break. long int D.25 * (ano + 4716). E. D = (long int) resp. ano. if (ano < 1583) printf("ERRO FATAL: Ano Inválido\n"). mes. break. printf("Dia [1. if (dia < 1 || dia > 31) printf("ERRO FATAL: Dia Inválido\n"). resto = dj % 7.6001 * (mes + 1).A + B. if (mes < 1 || mes > 31) printf("ERRO FATAL: Mês Inválido\n"). B. else { if (mes < 3) { ano = ano . scanf("%d". int A. scanf("%d"..&dia). case 2: printf("Quarta-Feira\n"). scanf("%d". else { printf("Mes [1. switch (resto) { case 0: printf("Segunda-Feira\n"). mes = mes + 12.1524.Prototypes #include <stdio. case 1: printf("Terça-Feira\n"). C. 149 .h> #include <stdlib.h> // --------------------------.// juliano. resto. case 3: printf("Quinta-Feira\n"). resp = 365. float resp.

valor = valor + digit1 * 2. n.case 5: printf("Sábado\n"). printf("Cpf [99999999999]: "). fator = fator * 11.c #include <stdio. } } } } } O programa abaixo. Como calcular: http://www. valor = valor . } if (n == 10) { n = n . digit2. n = strlen(cpf). cpf[n] = (char) NULL.c.48) * (10 . break. fator = valor / 11. case 6: printf("Domingo\n"). fator = fator * 11. if (n != 11 && n != 9) { printf("Formato: 9 ou 11 d¡gitos numéricos\n").fator. valor = valor . int digit1. fator = valor / 11.geocities. break.Programa Principal int main(void) { char cpf[15].i < 9.fator.48) * (11 .h> // -------------------------------.1. scanf("%s".cpf). for (i = 0.i++) valor = valor + (cpf[i] . cpf.h> #include <string. int valor = 0. t.i).com/CapeCanaveral/4274/cgcancpf. } for (i = 0. return. if (valor < 2) digit1 = 0. 150 . int i.i++) valor = valor + (cpf[i] . permite verificar se um determinado CPF é válido ou inválido. final. calculando e exibindo os dígitos verificadores do CPF digitado.htm // cpf.i). valor = 0. else digit1 = 11 – valor.i < 9. fator.h> #include <stdlib.

linha.cpf[i]). if (t == 3) { t = 0. if (final >= 10) printf("%d\n".i++) printf("%c". for (i = 9. } Os programas abaixo. clrscr: limpa a tela em modo texto. t = t + 1.i++) { printf("%c".c #include <stdio.final). for (i = 0. getche: lê e mostra um caracter na tela sem enter. if (n == 11) { printf("Cpf Digitado: "). textcolor e textbackcolor. printf(".").i <= 7. // conio. else printf("%02d\n". printf("\n"). getche. kbhit: verifique se a tecla enter é presionada ou não. 151 .cpf[i]). delay: permite fazer uma pausa em milisegundos. getch: lê e não mostra um caracter na tela sem enter. textbackcolor: altera a cor de fundo. else printf("Status: CPF Inválido\n"). gotoxy: posiciona o cursor na coluna. mostram uma forma alternativa de utilizar algumas funções do arquivo de header conio. getch.h: clrscr. kbhit. clrscr(). } } printf("%c-". printf("Dígito Verificador: ").h" #define ESC 27 int main(void) { int tecla.h> #include "conio. final = digit1 * 10 + digit2. conio. textcolor: altera a cor do texto.final).i <= 10.48 && digit2 == cpf[10] . else digit2 = 11 – valor.h.48) printf("Status: CPF Válido\n").c e conio. dekay. } if (digit1 == cpf[9] .if (valor < 2) digit2 = 0. gotoxy.cpf[8]).

tecla = getche().h> #include <sys/time. printf("Código: %d -> Caracter: %c\n". textbackcolor(GREEN). tecla). newt. int l) { printf("\033[%d. newt. c).%df". } // conio. tecla. gotoxy(10.função: clrscr void clrscr(void) { printf("\x1B[2J").função: gotoxy void gotoxy(int c. } // ---------------------------. } while (tecla != ESC).c_lflag &= ~(ICANON | ECHO).h> #include <unistd.5). } // --------------------------. 152 .h> #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define #define BLACK RED GREEN BROWN BLUE MAGENTA CYAN DARKGRAY SUBLINHA black red green brown blue magenta cyan darkgray sublinha 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 // ---------------------------. gotoxy(10.7).l. tcgetattr(STDIN_FILENO. &oldt).do { textcolor(BLUE).h #include <termios. int ch. newt = oldt. printf("Tecla: ").função: getch int getch(void) { struct termios oldt. // troque por tecla = getch().

int ch. &newt).tv_usec=0. return(0). if (FD_ISSET(0.&read_fd). TCSANOW. fd_set read_fd.tv_sec=0.função: getche int getche(void) { struct termios oldt. tcsetattr(STDIN_FILENO. &newt). newt. NULL. return(ch). return(ch). while (clock() <= t).função: kbhit int kbhit(void) { struct timeval tv. &oldt). tv. ch = getchar().&read_fd)) return(1). &oldt). ch = getchar(). newt = oldt.c_lflag &= ~(ICANON | ECHO). TCSANOW. break. } // --------------------------. } // --------------------------. newt.função: delay void delay(int espera) { clock_t t. FD_ZERO(&read_fd). &oldt). &read_fd. putchar(ch). tcsetattr(STDIN_FILENO. tcsetattr(STDIN_FILENO. &tv) == -1) return(0). t = clock() + espera. 153 .tcsetattr(STDIN_FILENO. tcgetattr(STDIN_FILENO.função: textcolor void textcolor(int cor) { switch (cor) { case BLACK: printf("\033[30m"). TCSANOW. } // ---------------------------. FD_SET(0. case RED: printf("\033[31m"). tv. TCSANOW. if (select(1. NULL. } // --------------------------.

c exibe as cores disponíveis funções textcolor e textbackcolor da biblioteca de texto: conio. // cores. } } O programa abaixo. case MAGENTA: printf("\033[35m"). case BROWN: printf("\033[43m").h> #include "conio. case MAGENTA: printf("\033[45m"). printf("Black\n"). break. case DARKGRAY: printf("\033[47m"). case BLUE: printf("\033[44m"). break. break.h" int main(void) { textcolor(BLACK). break. } } // --------------------------. break. break. break. textcolor(BROWN). textcolor(GREEN). break. break. textcolor(RED).break. case BLUE: printf("\033[34m"). break. break. case GREEN: printf("\033[32m"). printf("Red\n"). nas 154 . break. break.h. break. case SUBLINHA: printf("\033[38m"). break. cores. printf("Green\n").função: textbackcolor void textbackcolor(int cor) { switch (cor) { case BLACK: printf("\033[40m"). case RED: printf("\033[41m").c #include <stdio. case BROWN: printf("\033[33m"). case CYAN: printf("\033[36m"). case DARKGRAY: printf("\033[37m"). case GREEN: printf("\033[42m"). case CYAN: printf("\033[46m").

textbackcolor(DARKGRAY).printf("Brown\n"). printf("\nBrown"). printf("\nGreen"). printf("\nBlue"). printf("Blue\n"). getchar(). textbackcolor(BLACK). printf("Cyan\n"). textcolor(CYAN). textbackcolor(RED). printf("\nCyan"). } 155 . textcolor(DARKGRAY). textbackcolor(BLUE). textcolor(BLUE). textbackcolor(MAGENTA). textbackcolor(BROWN). printf("\nMagenta"). textbackcolor(GREEN). printf("Sunlinha\n"). printf("\nBlack"). printf("\nDarkGray"). textcolor(SUBLINHA). printf("Magenta\n"). textcolor(MAGENTA). printf("\nRed"). textbackcolor(CYAN). printf("DarkGray\n").