Capa

ndice>> Ir para o ndice >>

Porque aprender a linguagem c

Em uma era onde o software est cada vez mas presente no nosso dia a dia importante ter algumas bases de programao, para isso importante ter um bom material com explicaes claras e exemplos, e o livro Programar em C se presta bem ao exerccio. Mas porque C e no Java ou Basic, ou ainda Perl? Linguagens como o Java ou Perl so linguagens a base de bytecode interpretado por uma mquina virtual sendo assim no um cdigo interpretado diretamente pelo processador. Ao contrrio de muitas linguagens de programao, o C permite ao programador enderear a memria de maneira muito parecida como seria feito em Assembly. Linguagens como o Java ou o Perl fornecem mecanismos que permitem que o programador faa o seu trabalho sem se ter de preocupar com a atribuio de memria ou com apontadores. Geralmente isso bom, uma vez que bastante trabalhoso lidar com a alocao de memria quando escrevemos aplicaes com algoritmos de alto nvel. No entanto, quando lidamos com tarefas de baixo-nvel como aquelas que um ncleo (kernel) tem obrigao de desempenhar, como a de copiar um conjunto de bytes para uma placa de rede, torna-se altamente necessrio um acesso directo memria algo que no possvel fazer com Java. C pode ser diretamente compilado em cdigo de mquina, e por isso rpido e eficiente. Alm disso, C permite personalizar como implementar cada coisa bsico, como alocao de memria, permitindo adaptaes para melhorar desempenho. Vale lembrar os softwares interpretadores de script ou bytecode, como Java e Python, so escritos em linguagens como C e C++. Ser uma surpresa que C seja uma linguagem to popular? Como num efeito domin, a prxima gerao de programas segue a tendncia dos seus ancestrais. Sistemas operacionais desenvolvidos em C sempre tm bibliotecas de sistema desenvolvidas em C. Essas bibliotecas so usadas para criar bibliotecas de programa (como Xlib, OpenGL ou GTK), e seus desenvolvedores geralmente decidem usar a mesma linguagem das bibliotecas de sistema. Desenvolvedores de aplicao usam bibliotecas de programa para desenvolver processadores de texto, jogos, tocadores de mdia, etc. Muitos vo decidir trabalhar com a mesma linguagem que a biblioteca foi escrita. E assim o processo continua... C uma das linguagens de programao mais populares para se escrever sistemas operacionais, como o Microsoft Windows, o Mac OS X e o GNU/Linux. Sistemas operacionais comunicam-se diretamente com o hardware; no h nenhuma camada mais baixa para mediar seus pedidos. Originalmente, os sistemas operacionais eram escritos na linguagem Assembly, o que resultava em um cdigo muito rpido e eficiente. Entretanto, escrever um sistema operacional em Assembly um processo tedioso (lento), e produz um cdigo que funcionar somente em uma arquitetura de CPU, tal como o x86 ou ARM. Escrever um sistema operacional em uma linguagem de alto nvel, tal como C, possibilita que os programadores readaptem o sistema operacional a vrias arquiteturas sem precisar reescrever todo o cdigo. O ncleo (kernel) Linux um exemplo de sistema operacional escrito em C, com apenas algumas sees do cdigo escritas em Assembly, para poder executar instrues que s existem em uma ou outra arquitetura e para algumas otimizaes.

Obtido em "http://pt.wikibooks.org/w/index.php?title=Programar_em_C/Imprimir&oldid=223086" Categorias:

Livros com verso para impresso Livro/Programar em C Esboos de Informtica !Tarefas pendentes Esta pgina foi modificada pela ltima vez (s) 14h53min de 7 de julho de 2011. Este texto disponibilizado nos termos da licena Creative Commons Atribuio-Compartilhamento pela mesma Licena 3.0 Unported; pode estar sujeito a condies adicionais. Consulte as Condies de Uso para mais detalhes.

Programar em C/Imprimir
Origem: Wikilivros, livros abertos por um mundo aberto. < Programar em C

ndice

1 Por que aprender a linguagem C 2 Histria da Linguagem C o 2.1 Histria 2.1.1 Desenvolvimentos iniciais 2.1.2 C de K&R 2.1.3 C ANSI e C ISO 2.1.4 C99 2.1.5 Resumo em ingls 3 Pr-requisitos o 3.1 Editor o 3.2 Compilador o 3.3 Ligador ou linker o 3.4 Obtendo um compilador 3.4.1 Para Windows ou DOS 3.4.2 Para Linux/Unix-like o 3.5 Links externos 4 Utilizando um compilador o 4.1 Compiladores: viso geral o 4.2 gcc o 4.3 Visual C++ 5 Noes de compilao o 5.1 Compilao o 5.2 Etapas da compilao 6 Um programa em C o 6.1 Um programa em C 7 Conceitos bsicos o 7.1 Estrutura bsica 7.1.1 Escopo o 7.2 Introduo s funes o 7.3 Expresses o 7.4 Comentrios 8 Variveis o 8.1 Variveis o 8.2 Declarando variveis o 8.3 Atribuindo valores o 8.4 Exemplo de erro o 8.5 Nomes de variveis o 8.6 Tipos de variveis 8.6.1 Modificadores de tipo

8.6.1.1 Tamanho: short e long 8.6.2 Converter um tipo de varivel 8.6.2.1 Sinal: signed e unsigned o 8.7 Literais o 8.8 Notas de rodap 9 Entrada e sada simples o 9.1 Entrada e sada simples o 9.2 puts() e putchar() o 9.3 printf() 9.3.1 Especificaes de formato 9.3.1.1 Opes 9.3.1.2 Largura do campo 9.3.1.3 Preciso 9.3.1.4 Tamanho da varivel 9.3.2 Sequncias de escape 9.3.2.1 Representao octal e hexadecimal o 9.4 scanf() 9.4.1 Valor de retorno o 9.5 gets() e getchar() o 9.6 sprintf() e sscanf() 10 Operaes matemticas (Bsico) o 10.1 Operaes matemticas 10.1.1 Abreviaes 11 Operaes matemticas (Avanado) o 11.1 Funes Trigonomtricas 11.1.1 As funes acos e asin 11.1.2 As funes atan e atan2 11.1.3 As funes cos, sin e tan o 11.2 Funes Hiperblicas o 11.3 Funes Exponencial e Logaritmo 11.3.1 A funo exp 11.3.2 As funes frexp, ldexp e modf 11.3.3 As funes log e log10 o 11.4 Funes pow e sqrt 11.4.1 As funes pow 11.4.2 As funes sqrt o 11.5 Funes de Arredondamento para Nmeros Inteiros, Valores Absolutos e Resto da Diviso 11.5.1 As funes ceil e floor 11.5.2 As funes fabs 11.5.3 As funes fmod o 11.6 Ligaes externas 12 Controle de fluxo o 12.1 Controle de fluxo o 12.2 Expresses de condio o 12.3 Testes 12.3.1 if 12.3.2 switch 12.3.3 Operador ternrio "?:" o 12.4 Loops

12.4.1 while 12.4.1.1 Loops infinitos 12.4.2 do ... while 12.4.3 for 12.4.4 break e continue o 12.5 Saltos incondicionais: goto o 12.6 Terminando o programa 13 Funes o 13.1 O que funo o 13.2 Definindo uma funo 13.2.1 Valor de retorno 13.2.2 Parmetros 13.2.3 Chamadas de funes o 13.3 Dois exemplos o 13.4 Prottipo ou Declarao de funo o 13.5 Variveis locais versus globais o 13.6 Passagem de parmetros por valor e por referncia o 13.7 void o 13.8 Recursividade o 13.9 inline 14 Pr-processador o 14.1 O pr-processador o 14.2 Diretivas de compilao 14.2.1 #include 14.2.2 #define 14.2.3 #undef 14.2.4 #ifdef e #ifndef 14.2.5 #if 14.2.6 #else 14.2.7 #elif o 14.3 Usos comuns das diretivas o 14.4 Concatenao 15 Bibliotecas o 15.1 Bibliotecas o 15.2 O arquivo-cabealho o 15.3 Compilao da biblioteca 15.3.1 No GCC 15.3.2 No MS Visual C++ o 15.4 Compilao do programa 16 Entrada e sada em arquivos o 16.1 Trabalhando com arquivos o 16.2 Abrindo e fechando um arquivo 16.2.1 Exemplo 16.2.2 Arquivos pr-definidos o 16.3 Escrevendo em arquivos 16.3.1 fwrite o 16.4 Lendo de arquivos 16.4.1 fgetc 16.4.1.1 Exemplo 16.4.2 fgets

16.4.3 fscanf 16.4.4 fread o 16.5 Outras funes 17 Exerccios Finais 18 Vetores o 18.1 Vetores 18.1.1 Abreviando as declaraes 18.1.2 Exemplo de Aplicao de Vetores o 18.2 Vetores multidimensionais (matrizes) o 18.3 Argumentos na funo main 18.3.1 Exemplo de uso de parmetros na funo main 19 Strings o 19.1 Strings o 19.2 Funes da biblioteca padro 19.2.1 strlen 19.2.2 strcpy 19.2.3 strcat 19.2.4 strcmp 19.2.5 strrchr 19.2.6 memcpy 19.2.7 memset 19.2.8 sprintf 20 Ponteiros o 20.1 Bsico 20.1.1 O que um ponteiro? 20.1.2 Declarando e acessando ponteiros 20.1.3 Ponteiro e NULL 20.1.4 Mais operaes com ponteiros o 20.2 Intermedirio 20.2.1 Ponteiro de estrutura 20.2.2 Ponteiros como parmetros de funes 20.2.3 Ponteiros e vetores 20.2.4 Indexao estranha de ponteiros 20.2.5 Comparando endereos o 20.3 Avanado 20.3.1 Ponteiros para ponteiros 20.3.2 Passando vetores como argumentos de funes 20.3.3 Ponteiros para funes 21 Passagem de Parametros 22 Tipos de dados definidos pelo usurio o 22.1 Tipos de dados definidos pelo usurio o 22.2 Estruturas 22.2.1 Definindo o tipo 22.2.2 Declarando 22.2.3 Inicializador designado 22.2.4 Acessando 22.2.5 Vetores de estruturas 22.2.6 Atribuio e cpia 22.2.7 Passando para funes o 22.3 Unies

22.4 Enumeraes 22.4.1 Uso o 22.5 Campo de bits 23 Enumerao o 23.1 Enumerations (enum) o 23.2 Criando um novo tipo de dados 24 Unio o 24.1 Unions o 24.2 Declarao o 24.3 Unions com estruturas o 24.4 Anonymous unions estruturas com unions 25 Estruturas o 25.1 Structures o 25.2 Declarar uma estrutura o 25.3 Matrizes de estruturas o 25.4 Declarar instncias (objetos) da estrutura o 25.5 Acessar as variveis membro das estruturas o 25.6 Iniciar uma estrutura o 25.7 Ponteiros para estruturas o 25.8 Passando estruturas com argumento do funes o 25.9 Estruturas aninhadas 26 Mais sobre variveis o 26.1 typedef o 26.2 sizeof o 26.3 Converso de tipos 26.3.1 Casting: converso manual o 26.4 Atributos das variveis 26.4.1 const 26.4.2 volatile 26.4.3 extern 26.4.4 static 26.4.5 register 27 Gerenciamento de memria o 27.1 Alocao dinmica 27.1.1 malloc e free 27.1.2 calloc 27.1.3 realloc 27.1.4 Alocao Dinmica de Vetores 27.1.5 Alocao Dinmica de Matrizes 28 Sockets o 28.1 Abstraes o 28.2 Funes da biblioteca padro o 28.3 Famlias de endereo o 28.4 Estruturas de endereo 29 Makefiles o 29.1 Makefile 29.1.1 Sintaxe de criao do arquivo 29.1.1.1 Regras complementarias 29.1.1.2 Definir Variveis 29.1.1.3 Variveis Personalizadas

29.1.1.4 Variveis internas 29.1.1.5 As regras de interferncia 29.1.1.6 Sub Makefiles 29.1.1.7 Make install 30 Lista de palavras reservadas 31 Seqncias de escape 32 Lista de funes 33 Lista de bibliotecas o 33.1 Ligaes externas 34 Dicas de programao em C o 34.1 Convenes tipogrficas o 34.2 A funo printf a melhor amiga de um programador o 34.3 Tecle 1 para rodar 35 Listas encadeadas o 35.1 Primitivas o 35.2 Lista encadeada linear o 35.3 Iniciar uma lista o 35.4 Insero 35.4.1 Insero no incio 35.4.2 Insero no fim o 35.5 Remoo 35.5.1 Remoo no incio 35.5.2 Remoo no fim o 35.6 Exibio 35.6.1 Do fim para a raiz 35.6.2 Da raiz para o fim 36 Pilha o 36.1 Pilha o 36.2 Construo do prottipo de um elemento da lista. o 36.3 Inicializao o 36.4 Inserir um elemento na pilha(push) o 36.5 Retirar um elemento da pilha (pop) o 36.6 Imprimir os elementos da pilha 37 rvores binrias o 37.1 Arvore binria o 37.2 Struct o 37.3 Iniciar o 37.4 Insero o 37.5 Remoo 37.5.1 Em ordem 37.5.2 Pr-ordem 37.5.3 Ps-ordem o 37.6 Contar ns o 37.7 Contar folhas o 37.8 Altura da rvore o 37.9 Estrutura Completa 38 Algoritmos de ordenao 39 Insertion sort 40 Selection sort 41 Bubble sort

41.1 Cdigo da Funo 41.2 Cdigo da Funo Melhorado 42 Algoritmo de alocao o 42.1 first fist o 42.2 best fit o 42.3 worst fit o 42.4 Next Fit o 42.5 Buddy System 43 Estudo o 43.1 Funes 43.1.1 Ponteiros para Funes o 43.2 Abrindo e Fechando um Arquivo 43.2.1 fopen 43.2.2 fclose 43.2.3 feof 43.2.4 putc 43.2.5 fgets 43.2.6 fputs 43.2.7 ferror e perror 43.2.8 fread 43.2.9 fwrite 43.2.10 fseek 43.2.11 rewind 43.2.12 remove 43.2.13 fprintf 43.2.14 fscanf o 43.3 Alocao Dinmica 43.3.1 malloc 43.3.2 calloc 43.3.3 realloc 43.3.4 free 44 Constantes o 44.1 Constantes o 44.2 DEFINED CONSTANTS (#DEFINE) o 44.3 Declared constants (const) 45 Condicionais o 45.1 Branching - Funo IF o 45.2 Branching - Switch o 45.3 Loops 45.3.1 While 45.3.2 do while 45.3.3 for 45.3.4 O Comando break 45.3.5 O Comando continue 45.3.6 O Comando goto o 45.4 Terminando o programa o 45.5 Operador vrgula ( , ) o 45.6 Operador condicional ? o 45.7 Incrementar/decrementar o 45.8 Exerccios

o o

46 Lista de autores o 46.1 Lista de autores 47 Capa 48 Porque aprender a linguagem c

Por que aprender a linguagem C

Em uma era onde o software est cada vez mas presente no nosso dia a dia importante ter algumas bases de programao, para isso importante ter um bom material com explicaes claras e exemplos, e o livro Programar em C se presta bem ao exerccio. Mas porque C e no Java ou Basic, ou ainda Perl? Linguagens como o Java ou Perl so linguagens a base de bytecode interpretado por uma mquina virtual sendo assim no um cdigo interpretado diretamente pelo processador. Ao contrrio de muitas linguagens de programao, o C permite ao programador enderear a memria de maneira muito parecida como seria feito em Assembly. Linguagens como o Java ou o Perl fornecem mecanismos que permitem que o programador faa o seu trabalho sem se ter de preocupar com a atribuio de memria ou com apontadores. Geralmente isso bom, uma vez que bastante trabalhoso lidar com a alocao de memria quando escrevemos aplicaes com algoritmos de alto nvel. No entanto, quando lidamos com tarefas de baixo-nvel como aquelas que um ncleo (kernel) tem obrigao de desempenhar, como a de copiar um conjunto de bytes para uma placa de rede, torna-se altamente necessrio um acesso directo memria algo que no possvel fazer com Java. C pode ser diretamente compilado em cdigo de mquina, e por isso rpido e eficiente. Alm disso, C permite personalizar como implementar cada coisa bsico, como alocao de memria, permitindo adaptaes para melhorar desempenho. Vale lembrar os softwares interpretadores de script ou bytecode, como Java e Python, so escritos em linguagens como C e C++. Ser uma surpresa que C seja uma linguagem to popular? Como num efeito domin, a prxima gerao de programas segue a tendncia dos seus ancestrais. Sistemas operacionais desenvolvidos em C sempre tm bibliotecas de sistema desenvolvidas em C. Essas bibliotecas so usadas para criar bibliotecas de programa (como Xlib, OpenGL ou GTK), e seus desenvolvedores geralmente decidem usar a mesma linguagem das bibliotecas de sistema. Desenvolvedores de aplicao usam bibliotecas de programa para desenvolver processadores de texto, jogos, tocadores de mdia, etc. Muitos vo decidir trabalhar com a mesma linguagem que a biblioteca foi escrita. E assim o processo continua... C uma das linguagens de programao mais populares para se escrever sistemas operacionais, como o Microsoft Windows, o Mac OS X e o GNU/Linux. Sistemas operacionais comunicam-se diretamente com o hardware; no h nenhuma camada mais baixa para mediar seus pedidos. Originalmente, os sistemas operacionais eram escritos na linguagem Assembly, o que resultava em um cdigo muito rpido e eficiente. Entretanto, escrever um sistema operacional em Assembly um processo tedioso (lento), e produz um cdigo que funcionar somente em uma arquitetura de CPU, tal como o x86 ou ARM. Escrever um sistema operacional em uma linguagem de alto

nvel, tal como C, possibilita que os programadores readaptem o sistema operacional a vrias arquiteturas sem precisar reescrever todo o cdigo. O ncleo (kernel) Linux um exemplo de sistema operacional escrito em C, com apenas algumas sees do cdigo escritas em Assembly, para poder executar instrues que s existem em uma ou outra arquitetura e para algumas otimizaes.

Histria da Linguagem C

Este mdulo encontra-se em processo de traduo. A sua ajuda bem vinda.

Histria
Desenvolvimentos iniciais

Kenneth Thompson ( esquerda) e Dennis Ritchie ( direita), os criadores da linguagem C O desenvolvimento inicial da linguagem C ocorreu nos laboratrios Bell da AT&T entre 1969 e 1973. Segundo Ritchie, o periodo mais criativo ocorreu em 1972. Deu-se o nome "C" linguagem porque muitas das suas caractersticas derivaram de uma linguagem de programao anterior chamada "B". H vrios relatos que se referem origem do nome "B": Ken Thompson d crdito linguagem de programao BCPL, mas ele tambm criou uma outra linguagem de programao chamada 'Bon, em honra da sua mulher Bonnie. Por volta de 1973, a linguagem C tinha se tornado suficientemente poderosa para que grande parte do ncleo de UNIX, originalmente escrito na linguagem de programao PDP-11/20 Assembly, fosse reescrito em C. Este foi um dos primeiros ncleos de sistema operativo que foi implementado numa linguagem sem ser o Assembly, sendo exemplos anteriores o sistema Multics (escrito em PL/I) e TRIPOS (escrito em BCPL).

C de K&R

Em 1978, Ritchie e Kernighan publicaram a primeira edio do livro The C Programming Language. Esse livro, conhecido pelos programadores de C como "K&R", serviu durante muitos anos como uma especificao informal da linguagem. A verso da linguagem C que ele descreve usualmente referida como "C de K&R". (A segunda edio do livro cobre o posterior padro ANSI C, descrito abaixo.) K&R introduziram as seguintes caractersticas na linguagem:

Tipos de dados struct Tipos de dados long int Tipos de dados unsigned int O operador =+ foi alterado para +=, e assim sucessivamente (a anlise lxica do compilador confundia o operador =+. Por exemplo, i =+ 10 e i = +10).

C de K&R frequentemente considerado a parte mais bsica da linguagem cujo suporte deve ser assegurado por um compilador C. Durante muitos anos, mesmo aps a introduo do padro C ANSI, ele era considerado o "menor denominador comum" em que programadores de C se apoiavam quando uma portabilidade mxima era desejada, j que nem todos os compiladores eram actualizados para suportar na ntegra o padro C ANSI, e o cdigo C de K&R razoavelmente bem escrito tambm vlido em relao ao C ANSI. Nos anos que se seguiram publicao do C K&R, algumas caractersticas "nooficiais" foram adicionadas linguagem, suportadas por compiladores da AT&T e de outros vendedores. Estas incluam:

Funes void e tipos de dados void * Funes que retornam tipos struct ou union Campos de nome struct num espao de nome separado para cada tipo struct Atribuio a tipos de dados struct Qualificadores const para criar um objecto s de leitura Uma biblioteca-padro que incorpora grande parte da funcionalidade implementada por vrios vendedores Enumeraes O tipo de ponto-flutuante de preciso simples

C ANSI e C ISO
Durante os finais da dcada de 1970, a linguagem C comeou a substituir a linguagem BASIC como a linguagem de programao de microcomputadores mais usada. Durante a dcada de 1980, foi adotada para uso no PC IBM, e a sua popularidade comeou a aumentar significativamente. Ao mesmo tempo, Bjarne Stroustrup, juntamente com outros nos laboratrios Bell, comeou a trabalhar num projeto onde se adicionavam construes de linguagens de programao orientada por objetos linguagem C. A linguagem que eles produziram, chamada C++, nos dias de hoje a linguagem de programao de aplicaes mais comum no sistema operativo Windows da companhia Microsoft; C permanece mais popular no mundo UNIX. Em 1983, o Instituto Norte-Americano de Padres (ANSI) formou um comit, X3j11, para estabelecer uma especificao do padro da linguagem C. Aps um processo longo e rduo, o padro foi completo em 1989 e ratificado como ANSI X3.159-1989

"Programming Language C". Esta verso da linguagem frequentemente referida como C ANSI. Em 1990, o padro C ANSI, aps sofrer umas modificaes menores, foi adotado pela Organizao Internacional de Padres (ISO) como ISO/IEC 9899:1990. Um dos objetivos do processo de padronizao C ANSI foi o de produzir um sobreconjunto do C K&R, incorporando muitas das caractersticas no-oficiais subsequentemente introduzidas. Entretanto, muitos programas tinham sido escritos e que no compilavam em certas plataformas, ou com um certo compilador, devido ao uso de bibliotecas de funes no-padro e ao fato de alguns compiladores no aderirem ao C ANSI.

C99
Aps o processo ANSI de padronizao, as especificaes da linguagem C permaneceram relativamente estticas por algum tempo, enquanto que a linguagem C++ continuou a evoluir. (Em 1995, a Normative Ammendment 1 criou uma verso nova da linguagem C mas esta verso raramente tida em conta.) Contudo, o padro foi submetido a uma reviso nos finais da dcada de 1990, levando publicao da norma ISO 9899:1999 em 1999. Este padro geralmente referido como "C99". O padro foi adoptado como um padro ANSI em Maro de 2000. As novas caractersticas do C99 incluem:

Funes em linha Levantamento de restries sobre a localizao da declarao de variveis (como em C++) Adio de vrios tipos de dados novos, incluindo o long long int (para minimizar a dor da transio de 32-bits para 64-bits), um tipo de dados boolean explicito e um tipo complex que representa nmeros complexos Disposies de dados de comprimento varivel Suporte oficial para comentrios de uma linha iniciados por //, emprestados da linguagem C++ Vrias funes de biblioteca novas, tais como snprintf() Vrios ficheiros-cabealho novos, tais como stdint.h

O interesse em suportar as caractersticas novas de C99 parece depender muito das entidades. Apesar do GCC e vrios outros compiladores suportarem grande parte das novas caractersticas do C99, os compiladores mantidos pela Microsoft e pela Borland no, e estas duas companhias no parecem estar muito interessadas adicionar tais funcionalidades, ignorando por completo as normas internacionais.

Resumo em ingls
Em 1947, trs cientistas do Laboratrio Telefonia Bell, William Shockley, Walter Brattain, e John Bardeen criaram o transistor.A computao moderna teve incio. Em 1956 no MIT o primeiro computador completamente baseado em transistores foi concluido, the TX-0. Em 1958 na Texas Instruments, Jack Kilby construiu o primeiro circuito integrado. Mas mesmo antes do primeiro circuito integrado existir, a primeira linguagem de alto nvel j tinha sido escrita.

Em 1954 Fortran, a Formula Translator, foi escrito. Comeou como Fortran I em 1956. Fortran veio a ser Algol 58, o Algorithmic Language, em 1958. Algol 58 veio a ser Algol 60 em 1960. Algol 60 veio a ser CPL, o Combined Programming Language, em 1963. CPL veio a ser BCPL, Basic CPL, em 1967. BCPL veio a ser B em 1969. B veio a ser C em 1971. B foi a primeira lngua da linhagem C diretamente, tendo sido criado no Bell Labs por Ken Thompson. B era uma linguagem interpretada, utilizada no incio, em verses internas do sistema operacional UNIX. Thompson e Dennis Ritchie, tambm da Bell Labs, melhorou B, chamando-NB; novas prorrogaes para NB criaram C, uma linguagem compilada. A maioria dos UNIX foi reescrito em NB e C, o que levou a um sistema operacional mais porttil. B foi, naturalmente, o nome de BCPL e C foi o seu sucessor lgico. A portabilidade do UNIX foi a razo principal para a popularidade inicial de ambos, UNIX e C; rather than creating a new operating system for each new machine, system programmers could simply write the few system dependent parts required for the machine, and write a C compiler for the new system; and since most of the system utilities were written in C, it simply made sense to also write new utilities in the language.

Pr-requisitos
pr-requisito para um bom aprendizado de qualquer linguagem de programao conceitos sobre lgica de programao. Alm disso, para programar em C, voc precisa de um editor de textos e um compilador, discutidos a seguir.

Editor
Para editar o cdigo de um programa, apenas necessrio um editor de textos, qualquer um, at mesmo o Bloco de Notas do Windows. No entanto, h diversos editores que apresentam recursos que facilitam a edio de programas, como: destaque/colorao de sintaxe, complementao de cdigo, formatao (indentao) automtica, ajuda integrada, comandos integrados para compilar etc. Entre todos eles podemos destacar o Vim e o Emacs, ambos com verses para Windows, Linux e Mac OS. Em sistemas GNU/Linux, a maioria dos editores de texto j possuem recursos para facilitar a edio de programas em C. Principalmente, devido ao fato da maioria deles (dos programas) e boa parte do sistema terem sido programados utilizando C ou C++. Entretanto, o editor apenas edita o cdigo. Para transforma-lo em linguagem de mquina e o executar, precisaremos de um compilador.

Compilador
O cdigo em linguagem C consiste em instrues que o computador dever seguir. O compilador realiza o trabalho de traduzir essas instrues para linguagem de mquina, de forma a poderem ser executadas pelo computador.

Ligador ou linker
A ligao de arquivos consiste na construo de uma imagem memria que contm partes de cdigo compilados separadamente. Em outras palavras ele une os arquivos objetos e as bibliotecas (estticas, dinmicas) para formar uma nova biblioteca ou um executvel.

Obtendo um compilador
Existem diversos compiladores disponveis: Para Windows ou DOS

MinGW (antigo mingw32): uma espcie de gcc para Windows. o compilador includo com o Dev-C++, da Bloodshed. O Dev-C++ um IDE (sigla em ingls para Ambiente Integrado de Desenvolvimento) que facilita a edio e compilao de programas. Tem traduo para Portugus do Brasil. Borland C++: a Borland disponibilizou um compilador gratuito que funciona em linha de comando, como alternativa ao IDE comercial. DJGPP: porte do gcc para DOS. Tambm funciona no Windows, mas se o objetivo for rodar no Windows, recomenda-se o uso do mingw, que pode usufruir de todos os recursos do Windows. Microsoft Visual C++: compilador comercial da Microsoft, que tambm tem um IDE. O Framework .NET, gratuito, tambm inclui o compilador (em linha de comando) do Visual C++. DEV-C++: ambiente de desenvolvimento integrado livre que utiliza os compiladores do projeto GNU para compilar programas para o sistema operacional Microsoft Windows.

Para Linux/Unix-like

gcc: um conjunto de compiladores oficiais do projeto GNU, de cdigo aberto. Costumam vir instalados na maioria das distribuies GNU/Linux e est disponvel para diversas plataformas, principalmente para as baseadas em sistemas do tipo unix. GNU linker: o ligador do projeto GNU o nome do programa "ld" e faz parte do pacote GNU Binary Utilities.

Links externos

CodeBlocks: pgina para download do CodeBlocks, uma IDE para C ao estilo do Dev-C++, porm, mais nova. Dev-C++: pgina para download do Dev-C++. DJGPP: pgina oficial, com informaes e links para download. GCC: pgina oficial do compilador para diversas plataformas.

Utilizando um compilador
Compiladores: viso geral
Um compilador , geralmente, um programa de modo texto, que deve ser operado diretamente da linha de comando, sem nenhuma interface grfica. Essa uma das razes pelas quais muitas pessoas preferem usar IDEs. No entanto, saber um pouco sobre como usar o compilador pela linha de comando pode vir a ser til, por exemplo quando voc no tiver um IDE disposio. No nenhum bicho-de-sete-cabeas, e a sintaxe da maioria dos compiladores semelhante. Para executar o compilador, voc precisa abrir um terminal (ou "prompt de comando", como costuma ser chamado no Windows, ou ainda console). lgico que se voc estiver em um sistema sem ambiente grfico (como o DOS), voc no precisa fazer isso. O Windows s tem um terminal nativo, que o interpretador de comandos dele (cmd.exe ou command.com). Pacotes como o Cygwin e o MSys (do mesmo projeto que o MinGW) incluem terminais alternativos que funcionam basicamente maneira do Linux. No Linux, alm dos terminais de modo texto, h vrios emuladores de terminal, entre os quais esto o XTerm, o Konsole (KDE) e o Terminal do Gnome. O uso de todos eles idntico.

gcc
Com o gcc, compilador da GNU utilizado principalmente no sistema operacional linux ou de tipo unix, voc pode executar a compilao e a montagem separadamente ou com um nico comando. Se voc tem vrios arquivos-fonte, mais recomendvel executar as duas etapas separadamente: se voc atualizar apenas um arquivo, s precisar recompilar o que atualizou e depois remontar. No entanto, se voc est desenvolvendo um projeto grande, recomendvel usar ferramentas de automao do processo de compilao, como o make. Resumo:
gcc [OPES] nome_do_arquivo

Aqui so listadas algumas das opes do gcc:

-c:

Compila o cdigo fonte mais no faz as ligaes a sada um arquivo objeto. -o: serve para dar um nome ao arquivo de sada. -O2: ativa otimizao no nvel 2 -g: salva os smbolos de depurao (o que permite usar um depurador) -Wall: ativa todos os avisos do compilador -pedantic: ativa os avisos necessrios para que o cdigo esteja estritamente de acordo com os padres

Para compilar o arquivo "programa.c", gerando o cdigo-objeto "programa.o":

gcc [OPES] -c programa.c

Para gerar o executvel "programa binario" bin ou "programa.exe" no Windows/DOS a partir do cdigo-objeto:
gcc [OPES] -o programa[.bin] programa.o

Para gerar o executvel diretamente a partir do arquivo-fonte:

gcc [OPES] -o programa[.bin] programa.c

Visual C++
Este mdulo precisa ser revisado por algum que conhea o assunto (discuta).

Em alguma verso no especificada do Visual C++, para compilar o arquivo "programa.c", gerando o cdigo-objeto "programa.obj":
cl /c programa.c

Para gerar o executvel "programa.exe" a partir do cdigo-objeto:

link /out:programa.exe programa.obj

Para gerar o executvel a partir do arquivo-fonte:

cl programa.c

Noes de compilao

Esta pgina um esboo de informtica. Ampliando-a voc ajudar a melhorar o Wikilivros.

Compilao
Todo o cdigo em linguagem C que escrevermos deve ser salvo em um arquivo, em formato texto, com a extenso ".c". Esse cdigo no tem significado nenhum para a unidade de processamento; para que o processador possa executar nosso programa, este deve ser traduzido para a linguagem de mquina. Essa traduo se chama compilao e feita pelo programa denominado compilador. O compilador l todo o cdigo e cria um arquivo executvel, em linguagem de mquina, especfica para uma arquitetura de processadores e para um tipo de sistema operacional, o que significa que um programa compilado no Windows, por exemplo, no rodar nativamente no Linux se simplesmente copiarmos o executvel. Devemos, para isso, recompilar o cdigo-fonte do programa. No Windows, os arquivos executveis so aqueles com extenso ".exe". No Linux, os executveis so simplesmente arquivos com o atributo "executvel".

Etapas da compilao
O processo que chamamos corriqueiramente de compilao na verdade um conjunto de etapas:

o preprocessamento, etapa em que o pr-processador (programa s vezes acoplado ao compilador) l o cdigo-fonte e faz algumas substituies para que o programa possa ser compilado. Em C, o preprocessador tem diversos usos: compilao condicional (por exemplo, usar trechos diferentes do cdigo para sistemas operacionais diferentes), macros, substituio de smbolos e incluso de arquivos externos que declaram funes e variveis. a verificao sinttica, que procura por eventuais erros nos cdigos dos programas: parnteses no fechados, falta de ponto-e-vrgula no final da instruo, etc. Todos esses problemas so alertados e causam a interrupo da compilao. a compilao propriamente dita, que transforma o cdigo preprocessado em um programa-objeto, que est em linguagem de mquina porm no pronto para ser executado. a linkedio (linking, em ingls) dos programas-objeto e bibliotecas necessrias em um nico executvel, feita pelo linkeditor (linker). Em C, pode-se distribuir um programa em vrios arquivos-fonte, o que ajuda na organizao e permite compilar apenas a parte do programa correspondente quando necessrio realizar alguma mudana. Na montagem, todas as partes constituintes do programa so deslocadas e/ou cortadas conforme necessrio para que tenhamos um programa executvel.

Um programa em C
Um programa em C
comum que o primeiro programa escrito em uma linguagem de programao seja um programa que escreve "Hello world!" ("Ol mundo!"). Apresentamos o cdigo e, a seguir, analisaremos cada uma de suas linhas. No se preocupe se no entender ainda alguns aspectos, tudo ser abordado detalhadamente mais adiante. Note que o nmero das linhas dado apenas para facilitar a referncia; se for copiar o cdigo, lembre-se de tirar os nmeros de linha.
1. 2. 3. 4. 5. 6. 7. /* o meu primeiro programa */ #include <stdio.h> int main() { printf ("Ol, mundo!"); return (0); }

Salvando o cdigo acima em um arquivo com a extenso ".c" e seguindo as instrues de compilao do do captulo de utilizao de compilador, voc dever ver como resultado um "Ol, mundo!" na tela. A seguir vamos a anlise do cdigo. A primeira linha um comentrio, que para o compilador no tem nenhum significado. Qualquer texto que esteja entre as marcaes /* e */, podendo inclusive ocupar vrias linhas, ser considerado como comentrio e ser completamente ignorado pelo compilador. muito til como documentao, explicando o que as prximas linhas de cdigo fazem. A linha 2 pede que seja inserido o contedo do arquivo stdio.h (que est num lugar j conhecido pelo compilador). Esse arquivo contm referncias a diversas funes de entrada e sada de dados (stdio abreviao de Standard Input/Output, ou Entrada e Sada Padronizadas), de modo que voc precisar dele em praticamente todos os programas ele o meio de quase toda comunicao com o teclado, com a tela e com arquivos.[1] Os programas em C so organizados em funes todo cdigo em C deve fazer parte de uma funo. Em particular, todo programa deve ter uma funo chamada main, pela qual ser iniciada a execuo do programa. A funo definida, no nosso exemplo, na linha 3, e delimitada pelas chaves { }. A palavra-chave int significa que a funo devolve um valor inteiro (voc pode pensar nesse valor exatamente como o valor de uma funo em matemtica). Na linha 5, executamos a funo printf, que imprime na tela os parmetros que lhe foram passados no nosso exemplo, passamos a seqncia de caracteres "Ol,

mundo!" como parmetro. Essa uma das funes definidas em um cabealho da biblioteca C, o arquivo stdio.h. Note o ponto-e-vrgula no final da linha: todas as instrues em C devem terminar com um ponto-e-vrgula. (Essa uma causa muito comum de erros de compilao). Na linha 6, dizemos que a funo main deve devolver (ou retornar) o valor 0 e terminar sua execuo. (Esse o valor inteiro que dissemos que amos retornar na linha 3.) O padro da linguagem C diz que a funo main deve devolver um valor inteiro, e esse valor diz se o programa foi executado com sucesso ou no. O valor zero indica que o programa foi finalizado sem nenhum erro, e valores diferentes de zero podem indicar diferentes erros. Voc no precisar se preocupar com isso no incio do seu estudo em C o valor devolvido por um programa geralmente usado em scripts, quando (por exemplo) um comando s pode ser executado se o anterior tiver ocorrido com sucesso.

1. Esse comando uma diretiva do pr-processador; voc aprender mais sobre esses comandos na seo Pr-processador.

Conceitos bsicos
Voc j viu um programa bsico em C. Antes de comear a se dedicar ao estudo de C, bom que voc compreenda alguns termos e alguns aspectos da linguagem, o que facilitar sua compreenso dos captulos seguintes. A seguir, formalizaremos alguns aspectos da estrutura bsica da linguagem.

Estrutura bsica

Um programa em C basicamente estruturado em blocos de cdigo. Blocos nada mais so que conjuntos de instrues, e devem ser delimitados com chaves ({ ... }). Um bloco tambm pode conter outros blocos. Uma instruo geralmente corresponde a uma ao executada, e deve sempre terminar com ponto-e-vrgula (;). O compilador ignora espaos, tabulaes e quebras de linha no meio do cdigo; esses caracteres so chamados genericamente de espao em branco (whitespace). Ou seja, os trs trechos a seguir so equivalentes:

printf("Ol mundo");return 0; printf ("Ol mundo"); return 0; printf( "Ol mundo" ); return

0 ;

No entanto, voc achar muito mais fcil de ler um estilo de cdigo mais parecido com o segundo exemplo. Costuma-se usar (mas no abusar de) espaos e tabulaes para organizar o cdigo.

A linguagem sensvel utilizao de maisculas e minsculas. Por exemplo, se voc escrevesse Printf no lugar de printf, ocorreria um erro, pois o nome da funo totalmente em minsculas.

Escopo
Geralmente, em programao, no queremos que outras funes usem as variveis que estamos manipulando no momento. O conceito de escopo est justamente relacionado a isso. Escopo o nvel em que um dado pode ser acessado; em C h dois nveis: local e global. Uma varivel global pode ser acessada por qualquer parte do programa; variveis locais podem ser acessadas apenas dentro do bloco onde foram declaradas (ou nos seus sub-blocos), mas no fora dele (ou nos blocos que o contm). Isso possibilita que voc declare vrias variveis com o mesmo nome mas em blocos diferentes. Veja um exemplo:
int a; { int a; int b; } { int b; }

As duas variveis chamadas b so diferentes e s podem ser acessadas dentro do prprio bloco. A primeira varivel a global, mas s pode ser acessada no segundo bloco, pois a varivel local a no primeiro bloco oculta a varivel global de mesmo nome. Note que isso possvel em C, e tome cuidado para no cometer erros por causa disso.

Introduo s funes
Funes so muito usadas, no s em C, mas em linguagens de programao em geral. Uma funo basicamente um bloco de cdigo que realiza uma certa tarefa. Quando queremos realizar aquela tarefa, simplesmente fazemos uma chamada de funo para a funo correspondente. Uma funo pode precisar que o programador d certos dados para realizar a tarefa; esses dados so chamados argumentos. A funo tambm pode retornar um valor, que pode indicar se a tarefa foi realizada com sucesso, por exemplo; esse valor o valor de retorno. Podemos fazer uma analogia com as funes matemticas: as variveis independentes so os argumentos e o valor numrico da funo o valor de retorno. Em C, para chamar uma funo, devemos escrever o seu nome, seguido da lista de argumentos (separados por vrgula) entre parnteses, mesmo que no haja nenhum

argumento. Lembre que a chamada de funo tambm uma instruo, portanto devemos escrever o ponto-e-vrgula no final. Alguns exemplos de chamadas de funes:
funcao(arg1, arg2, arg3); funcao();

Se quisermos saber o valor de retorno de uma funo, podemos armazen-lo numa varivel. Variveis sero introduzidas logo adiante, mas a sintaxe muito fcil de aprender:
valor_de_retorno = funcao(arg1, arg2);

Vejamos um exemplo completo:

//quadrado.c //calcula o quadrado de um nmero #include<stdio.h> int square( int num1 ) { return num1 * num1; } int main(){ int number; int result; printf("\nDigite um numero: "); scanf("%d", &number); result = square(number); printf("O Quadrado de %d eh: %d", number, result); return 0; }

Em C, todo o cdigo (exceto as declaraes de variveis e funes) deve estar dentro de funes. Todo programa deve ter pelo menos uma funo, a funo main, que por onde comea a execuo do programa.

Expresses
Um conceito muito importante em programao o de expresso. Expresses so conjuntos de valores, variveis, operadores e chamadas de funes que so avaliados ou interpretados para resultar num certo valor, que chamado o valor da expresso. Por exemplo:
3 * 4 + 9 uma expresso de valor 21; a + 3 * b uma expresso equivalente expresso matemtica a + 3b; foo() uma expresso cujo valor o valor de retorno da funo foo.

Comentrios

Muitas vezes bastante til colocar comentrios no cdigo, por exemplo para esclarecer o que uma funo faz, ou qual a utilidade de um argumento, etc. A maioria das linguagens de programao permite comentrios; em C, eles podem aparecer de duas maneiras:
/* Comentrios que podem ocupar vrias linhas. */

e
// Comentrios de uma linha s, que englobam // tudo desde as duas barras at o final da linha.

Tudo que estiver entre as marcas /* e */ ou entre // ser ignorado pelo compilador. Note que os comentrios de uma linha s (iniciados por //) foram incorporados ao padro da linguagem apenas em 1999, e portanto alguns compiladores podem no os suportar. As verses mais recentes do GCC no tero problema em suportar esse tipo de comentrio.

Variveis
Variveis
Em um programa, existe a necessidade de se guardar valores na memria, e isso feito atravs de variveis, que podem ser definidas simplificadamente como nomes que se referem a lugares na memria onde so guardados valores. Em C, para utilizar uma varivel, ela deve ser primeiramente declarada, ou seja, devemos requisitar o espao necessrio para essa varivel. Aps reservar um espao na memria, o computador ir associar a ele o nome da varivel. Se voc no declarar uma varivel e tentar utiliz-la, o compilador ir avis-lo disso e no continuar a compilao.

Declarando variveis
Genericamente, para declarar uma varivel, usamos a seguinte instruo:
tipo_da_varivel nome_da_varivel;

Por exemplo, para declarar uma varivel do tipo int com o nome a, podemos escrever
int a;

sempre necessrio indicar o tipo da varivel, pois cada tipo tem um tamanho diferente, ou seja, ocupa mais ou menos espao na memria do computador. Mais adiante introduziremos os tipos de varivel.

Atribuindo valores
Se quisermos associar um valor a uma varivel, usamos o operador = (igual):
a = 5;

Nesse caso, estamos pedindo que o computador guarde o valor 5 no espao alocado varivel a. possvel tambm atribuir um valor a uma varivel ao mesmo tempo que ela declarada, o que chamado de inicializar a varivel. Por exemplo:
int a = 5;

possvel tambm declarar mais de uma varivel de um mesmo tipo em uma nica instruo, separando os nomes por vrgulas. Tambm possvel inicializar as variveis dessa maneira:
int a, b, c, d; int e = 5, f = 6; int g, h = 2, i = 7, j;

Exemplo de erro
a = 25;

Mesmo sabendo que um exemplo de erro, escreva o cdigo acima em um arquivo .c e tente compilar para se familiarizar com as mensagens de erro do compilador, assim voc saber o que fazer quando elas ocorrerem. No exemplo acima no foi declarada a varivel a, ao tentar compilar o compilador informa que o smbolo a no foi definido.

Nomes de variveis

Os nomes de variveis devem ser nicos: no podemos ter duas variveis com o mesmo nome! O C, assim como muitas outras linguagens de programao, sensvel utilizao de maisculas e minsculas(case sensitive). Portanto, o cdigo a seguir seria vlido e geraria trs variveis diferentes:

int nome; int NOME; int Nome;

Em nomes de variveis, podemos usar letras maisculas ou minsculas (de A a Z, sem acentos), nmeros e o caractere sublinhado (_), mas o primeiro caractere deve ser uma letra ou o sublinhado. Algumas palavras no podem ser usadas para nomes de variveis por serem palavras reservadas (palavras que tm significado especial na linguagem).

O padro C atual especifica que nomes de at 31 caracteres devem ser aceitos. Alguns compiladores podem at aceitar nomes maiores que isso, mas no considere isso uma regra e no use nomes to longos.

Tipos de variveis
At agora voc s viu as variveis do tipo int, que servem para guardar nmeros inteiros. A linguagem C tem 4 tipos fundamentais. So eles:
int, para nmeros inteiros entre -2147483647 e 2147483647, utiliza 4 bytes; char, para caracteres individuais do padro ASCII, utiliza 1 byte; -38 38 float, para reais entre (aproximadamente) 10 e 10 , utiliza 4 bytes, preciso

de 7 dgitos; -4932 double, para reais entre (aproximadamente) 10 e 104932, utiliza 8 bytes, preciso de 15 dgitos; bool, para indicar true (verdadeiro) ou false (falso), utiliza 1 byte; Presente apenas no padro C99 em diante.

Os tipos float e double servem para guardar nmeros de ponto flutuante, ou seja, nmeros reais, como 3,1415 (pi), -2,3333, 0,00015, 6,02 1023. A diferena entre os dois , alm do intervalo de dados, a preciso. Geralmente, o tipo float guarda dados (com sinal positivo ou negativo) de 3,4E-38 a 3,4E+38 (alm do zero). J double suporta nmeros to pequenos quanto 1,7E-308 e no mximo 1,7E+308. Tambm existem outros tipos, como short (ou short int), que serve para inteiros menores, long (ou long int) para inteiros maiores. Qualquer tipo inteiro pode ser precedido por unsigned (o signed para COM negativos), para cortar os nmeros negativos, permitindo maior capacidade de armazenamento de nmeros positivos. Alguns compiladores aceitam o long long, para aumentar ainda mais o tamanho da varivel, alguns desses s aceitam para o tipo int, outros tambm para o tipo double. Convm ver a tabela de tipos.
Tipo Num de bits 8 8 8 16 16 16 16 16 16 32 32 32 32 64 80 Formato para leitura com scanf Intervalo Inicio Fim %c -128 127 %c 0 255 %c -128 127 %i -32.768 32.767 %u 0 65.535 %i -32.768 32.767 %hi -32.768 32.767 %hu 0 65.535 %hi -32.768 32.767 %li -2.147.483.648 2.147.483.647 %li -2.147.483.648 2.147.483.647 %lu 0 4.294.967.295 %f 3,4E-38 3.4E+38 %lf 1,7E-308 1,7E+308 %Lf 3,4E-4932 3,4E+4932

char unsigned char signed char int unsigned int signed int short int unsigned short int signed short int long int signed long int unsigned long int float double long double

Modificadores de tipo

Podemos alterar a maneira como os dados so guardados com os modificadores de tipo. Voc pode modificar os tipos de duas maneiras. Tamanho: short e long Voc pode modificar o tamanho de uma varivel usando os modificadores de tipo, que so dois: short e long. Note que float e char no podem ser modificados em tamanho.
short

diminui o espao necessrio para guardar a varivel (diminuindo tambm a gama de valores que esta pode assumir). S pode ser usado com int. long aumenta o espao tomado pela varivel, e portanto aumenta seu valor mximo e/ou sua preciso. Pode ser usado com int e double. O padro C de 1999 adicionou um terceiro modificador, suportado pelos compiladores mais recentes, inclusive o gcc: long long, que aumentaria ainda mais a capacidade da varivel. Alguns deles suportam esse modificador apenas para o tipo int, e outros suportam tambm para double.

Uma observao necessria: segundo o padro, no existe nenhuma garantia de que uma varivel short int menor que uma varivel int, nem que long int maior que int. Apenas garantido que int no maior que long nem menor que short. De fato, nos sistemas x86 de 32 bits (ou seja, a maioria dos computadores pessoais atualmente), o tamanho de int igual ao de long. Geralmente, int ser o tamanho nativo do processador ou seja, 32 bits num processador de 32 bits, 16 bits num processador de 16 bits etc.

Converter um tipo de varivel

A converso de uma varivel consiste em converter o tipo de uma varivel em um outro. Imagine que voc esteja trabalhando com uma varivel do tipo float e por alguma razo queira eliminar os nmeros que esto depois da virgula. Esta operao pode ser realizada de duas maneiras. Converses do tipo implcita: Consiste em uma modificao do tipo de varivel que feita automaticamente pelo compilador. Ex:
int x; x = 7.123;

Converses do tipo explcita: Tambm chamada de operao cast, consiste em forar a modificaao do tipo de varivel usando o operador cast "( )". Ex:
int y; y = (int)7.123;

Veja um exemplo da converso de tipo inteiro em caracteres. Aqui convertemos um numero decimal em um caracte ASCII.

#include <stdio.h> int main(void) { int y = 65; char x; x = (char) y; printf("O numero inteiro: %d \n O caracter: %c \n\n", y, x); }

Sinal: signed e unsigned Existe outro tipo de modificador, que define se o nmero vai ser guardado com sinal ou no. So os modificadores signed e unsigned, suportados pelos tipos inteiros apenas.
signed

diz que o nmero deve ser guardado com sinal, ou seja, sero permitidos valores positivos e negativos. Esse o padro, portanto esse modificador no muito usado. unsigned diz que o nmero deve ser guardado sem sinal. Com isso, o valor mximo da varivel aumenta, j que no teremos mais valores negativos. Por exemplo, com uma varivel char podemos guardar valores de -128 a 127, mas com uma varivel unsigned char pode guardar valores de 0 a 255.

Para usar esses modificadores, devemos coloc-los antes do nome do tipo da varivel, sendo que o modificador de sinal deve vir antes do modificador de tamanho caso ambos sejam usados. Por exemplo:
unsigned char c; short int valor; unsigned long int resultado; long double preco; Nota: Voc pode abreviar short int

e long int para simplesmente short e long,

respectivamente.

Literais
Em programao, um literal uma notao que representa um valor constante. Exemplos de literais em C so 415, 19.52, 'C', "Joo". Esses exemplos representam os quatro tipos de literais em C: literais de inteiros, literais de reais, literais de caracteres e literais de strings. S com esses exemplos j possvel deduzir como se usam os literais; mas importante fazer algumas observaes:

Literais de inteiros podem ser especificados nas bases decimal, octal ou hexadecimal. Se o literal for prefixado com "0x" ou "0X", ele ser interpretado como hexadecimal; se o prefixo for apenas "0", ser interpretado como octal; ou se no houver prefixo, ser interpretado como decimal. Literais de reais podem ser especificados na forma decimal (144.57) ou em notao cientfica (1.4457e+2). Lembre-se que o separador decimal o ponto e no a vrgula, como seria usual.

Literais de caracteres devem vir entre aspas simples (') e conter a representao de apenas um caractere1. Usos vlidos seriam: 'c', '\n', '\x1b', '\033'. Se voc quiser usar a aspa simples como caractere, preceda-a com uma barra invertida: '\''. Literais de strings devem vir entre aspas duplas ("). Para usar aspas duplas dentro de strings, preceda-as com barra invertida: "Ele disse \"Ol\".". Note que um literal de string adiciona o caractere nulo (\0) ao final da string, pois ele , em C, a maneira de delimitar o final de uma string.

Notas de rodap
1. Na verdade, segundo o padro C, literais de caracteres podem conter a representao de mais um caractere, mas o uso deles seria para representar nmeros e no seqncias de caracteres; um aspecto pouco utilizado da linguagem C.

Entrada e sada simples

Entrada e sada simples
Se voc pensar bem, perceber que um computador praticamente intil se no tiver nenhuma maneira de interagir com o usurio. Por exemplo, se voc abrir um processador de texto, nada ir acontecer at que voc abra um arquivo ou digite algum texto no teclado. Mas, da mesma maneira, necessrio que o computador fornea informao tambm: como voc poderia saber se uma tarefa foi concluda? As trocas de informao entre o computador e o usurio so chamadas entrada e sada (input e output, em ingls). Entrada a informao fornecida a um programa; sada a informao fornecida pelo programa. comum referir-se aos dois termos simultaneamente: entrada/sada ou E/S (I/O, em ingls). Frequentemente so usados os termos "sada padro" (standard output, stdout) e "entrada padro" (standard input, stdin). Eles se referem, na maioria das vezes, ao monitor e ao teclado, que so os meios bsicos de interao com o usurio. No entanto, os sistemas operacionais permitem redirecionar a sada e a entrada de programas para outros dispositivos ou arquivos. As funes de entrada e sada na linguagem C trabalham com fluxos (streams, em ingls) de dados, que so uma forma de abstrao de dados de maneira sequencial. Assim, toda entrada e sada feita da mesma maneira, com as mesmas funes, no importando o dispositivo com o qual estamos nos comunicando (teclado, terminal, arquivo, etc.). As mesmas funes que descrevem o acesso aos arquivos podem ser utilizadas para se acessar um terminal de vdeo. Em C, as funes da biblioteca padro para entrada e sada esto declaradas no cabealho stdio.h. Uma delas j foi introduzida em sees anteriores: printf(). A seguir daremos mais detalhes sobre essa funo e introduziremos outras.

puts()

e putchar()

puts significa "put string" (colocar string), utilizado para "colocar" uma string na sada de dados. putchar significa "put char" (colocar caractere), utilizado para "colocar" um caractere na sada de dados. So as funes mais simples do cabealho stdio.h. Ambas enviam (ou "imprimem") sada padro os caracteres fornecidos a elas; putchar() manda apenas um caractere, e puts() manda uma sequncia de caracteres (ou string). Exemplo:
puts ("Esta uma demonstrao da funo puts."); putchar ('Z');

Note que junto com a funo puts devemos usar literais de string (com aspas duplas), e com putchar devemos usar literais de caractere (com aspas simples). Se voc tentasse compilar algo como putchar ("T"), o compilador daria uma mensagem de erro. Lembre-se que "T" diferente de 'T'. Podemos tambm colocar caracteres especiais, como a tabulao (\t) e a quebra de linha (\n):
puts ("Primeira linha\nSegunda linha\te um grande espao"); putchar ('\n'); // apenas envia uma quebra de linha

Este cdigo resultaria em algo parecido com:

Primeira linha Segunda linha e um grande espao

Observe que a funo puts() sempre coloca uma quebra de linha aps imprimir a string. J com as funes putchar() e printf() (vista a seguir), isso no ocorre. O cdigo abaixo, por exemplo:
putchar('c'); putchar('h'); putchar('\n'); puts("String."); puts("Outra string.");

imprimiria algo parecido com isto:

ch String. Outra string.

Observe que os caracteres 'c' e 'h' so exibidos na mesma linha, pois no foi inserida uma quebra de linha entre eles. J as strings "String." e "Outra string." so exibidas em linhas diferentes, pois a funo puts() insere uma quebra de linha aps cada string, mesmo que no haja um caractere '\n' nas literais de string do cdigo. Os outros caracteres especiais so introduzidos adiante.

Note que o argumento deve ser uma sequncia de caracteres. Se voc tentar, por exemplo, imprimir o nmero 42 desta maneira:
puts(42);

Na verdade o que o compilador tentar fazer imprimir a sequncia de caracteres que comea na posio 42 da memria (provavelmente ele ir alert-lo sobre isso se voc tentar compilar esse cdigo). Se voc tentar executar esse cdigo, provavelmente ocorrer uma falha de segmentao (erro que ocorre quando um programa tenta acessar memria que no lhe pertence). A maneira correta de imprimir o nmero 42 seria coloc-lo entre aspas duplas:
puts("42"); printf()

printf vem de "print formatted" (imprimir formatado). primeira vista, a funo printf() pode parecer idntica puts(). No entanto, ela muito mais poderosa. Ela permite facilmente imprimir valores que no so sequncias de caracteres, alm de poder formatar os dados e juntar vrias sequncias de caracteres. Por isso, a funo printf() muito mais usada que a puts(). Ela pode ser usada exatamente como a funo puts(), se fornecermos a ela apenas uma sequncia de caracteres:
printf("Este um programa em C");

Mas e se precisarmos imprimir o contedo de uma varivel? A funo printf tambm pode fazer isso! Voc deve, obviamente, especificar onde o valor da varivel deve ser impresso. Isso feito atravs da especificao de formato %d, caso a varivel seja do tipo int (sequncias para outros tipos sero dadas adiante). Voc tambm precisar, logicamente, especificar qual varivel imprimir. Isso feito dando-se mais um argumento funo printf(). O cdigo dever ficar assim:
int teste; teste = 42; printf ("A varivel 'teste' contm o nmero %d.", teste);

Tendo colocado isso no seu programa, voc dever ver na tela:

A varivel 'teste' contm o nmero 42.

Vamos supor que voc queira imprimir um nmero no inteiro. Voc teria que trocar "%d" por %f. Exemplo:
float pi; pi = 3.1415; printf ("O valor de pi %f.", pi);

O cdigo acima ir retornar:

O valor de pi 3.1415.

Voc pode imprimir quantos valores quiser, bastando para isso colocar mais argumentos e mais especificaes de formato, lembrando de colocar na ordem certa. Alguns compiladores, como o gcc, mostram um aviso caso o nmero de argumentos seja diferente do nmero de especificaes de formato, o que provavelmente causaria resultados indesejados. A sintaxe geral da funo printf() :
printf ("string de formatao", arg1, arg2, ...);

Suponha que voc tem um programa que soma dois valores. Para mostrar o resultado da conta, voc poderia fazer isso:
int a, b, c; ... // leitura dos dados c = a + b; // c o resultado da soma printf ("%d + %d = %d", a, b, c);

O que resultaria em, para a = 5 e b = 9:

5 + 9 = 14

A seguir mostramos os especificadores de formato para vrios tipos de dados.

Especificaes de formato
A documentao mais tcnica os chama de "especificadores de converso", pois o que ocorre na maioria das vezes , de fato, a converso de um valor numrico em uma sequncia de caracteres que representa aquele valor. Mas o nome "formato" no deixa de estar correto, pois eles especificam em que formato (inteiro, real etc.) est o argumento correspondente. Cdigo
%d %u %o %x %X %f

%e %E %g

Converso/Formato do argumento Nmero decimal inteiro (int). Tambm pode ser usado %i como equivalente a %d. Nmero decimal natural (unsigned int), ou seja, sem sinal. Nmero inteiro representado na base octal. Exemplo: 41367 (corresponde ao decimal 17143). Nmero inteiro representado na base hexadecimal. Exemplo: 42f7 (corresponde ao decimal 17143). Se usarmos %X, as letras sero maisculas: 42F7. Hexadecimal com letras maisculas Nmero decimal de ponto flutuante. No caso da funo printf, devido s converses implcitas da linguagem C, serve tanto para float como para double. No caso da funo scanf, %f serve para float e %lf serve para double. Nmero em notao cientfica, por exemplo 5.97e-12. Podemos usar %E para exibir o E maisculo (5.97E-12). Nmero em notao cientfica com o "e"maisculo Escolhe automaticamente o mais apropriado entre %f e %e. Novamente, podemos usar %G para escolher entre %f e %E.

%p

Ponteiro: exibe o endereo de memria do ponteiro em notao hexadecimal. Caractere: imprime o caractere que tem o cdigo ASCII correspondente ao %c valor dado. %s Sequncia de caracteres (string, em ingls). %% Imprime um % Observao Se voc quiser imprimir um sinal de porcentagem, use %%. Exemplo:
printf("O lucro para o ltimo ms foi de 20%%.");

Numa sequncia de controle, possvel tambm indicar a largura do campo, o nmero de casas decimais, o tamanho da varivel e algumas opes adicionais. O formato geral :
%[opes][largura do campo][.preciso][tamanho da varivel]tipo de dado

A nica parte obrigatria o tipo de dado. Todas as outras podem ser omitidas. Opes As opes so parmetros opcionais que alteram a formatao. Voc pode especificar zero ou mais delas, colocando-as logo aps o sinal de porcentagem:
0:

o tamanho do campo deve ser preenchido com zeros esquerda quando necessrio, se o parmetro correspondente for numrico. - (hfen): o valor resultante deve ser alinhado esquerda dentro do campo (o padro alinhar direita). (espao): no caso de formatos que admitem sinal negativo e positivo, deixa um espao em branco esquerda de nmeros positivos. +: o sinal do nmero ser sempre mostrado, mesmo que seja positivo. ' (aspa simples/apstrofe): nmeros decimais devem ser exibidos com separador de milhares caso as configuraes regionais o especifiquem. Essa opo normalmente s funciona nos sistemas Unix.

Largura do campo Como o prprio nome j diz, especifica qual a largura mnima do campo. Se o valor no ocupar toda a largura do campo, este ser preenchido com espaos ou zeros. Por exemplo, podemos imprimir um cdigo de at 5 dgitos preenchido com zeros, de maneira que os valores 1, 27, 409 e 55192 apaream como 00001, 00027, 00409 e 55192. A largura deve ser especificada logo aps as opes, se presentes, e pode ser um nmero que especifica a largura ou um asterisco, que diz que a largura ser especificada pelo prximo argumento (ou seja, o argumento anterior ao valor a ser impresso). Neste exemplo, o campo ter largura igual ao valor de num e o valor impresso ser 300:
printf ("%*d", num, 300);

O campo impresso de acordo com as seguintes regras:

Se o valor for mais largo que o campo, este ser expandido para poder conter o valor. O valor nunca ser cortado. Se o valor for menor que o campo, a largura do campo ser preenchida com espaos ou zeros. Os zeros so especificados pela opo 0, que precede a largura. O alinhamento padro direita. Para se alinhar um nmero esquerda usa-se a opo - (hfen ou sinal de menos) antes da largura do campo.

Por exemplo, compare as trs maneiras de exibir o nmero 15:

printf ("%5d", 15); printf ("%05d", 15); printf ("%-5d", 15); // exibe " 15" // exibe "00015" // exibe "15 "

E alguns outros exemplos:

printf ("%-10s", "Jos"); printf ("%10s", "Jos"); printf ("%4s", "Jos"); // exibe "Jos " // exibe " Jos" // exibe "Jos"

Preciso A preciso pode ter quatro significados diferentes:

Se a converso solicitada for inteira (d, i, o, u, x, X): o nmero mnimo de dgitos a exibir (ser preenchido com zeros se necessrio). Se a converso for real (a, A, e, E, f, F): o nmero de casas decimais a exibir. O valor ser arredondado se a preciso especificada no formato for menor que a do argumento. Se a converso for em notao cientfica (g, G): o nmero de algarismos significativos. O valor ser arredondado se o nmero de algarismos significativos pedido for maior que o do argumento. Se a converso for de uma sequncia de caracteres (s): o nmero mximo de caracteres a exibir.

Assim como a largura do campo, a preciso pode ser especificada diretamente por um nmero ou com um asterisco, mas deve ser precedida por um ponto. Alguns exemplos:
printf printf printf printf ("%.5d", ("%.5f", ("%.5g", ("%.5s", 314); // exibe "00314" 2.4); // exibe "2.40000" 23456789012345); // exibe "2.3457e+13" "Bom dia"); // exibe "Bom d"

claro que podemos combinar a largura com a preciso. Por exemplo, %10.4f indica um campo de nmero real de comprimento total dez e com 4 casas decimais. Note que, na largura do campo, o valor inteiro levado em conta, inclusive o ponto decimal, e no apenas a parte inteira. Por exemplo, essa formatao aplicada ao nmero 3.45 ir resultar nisto:
" 3.4500"

Tamanho da varivel importante ressaltar que quando so usados modificadores de tamanho de tipos, a maneira como os dados so armazenados pode tornar-se diferente. Assim, devemos informar funo printf() precisamente qual o tipo da varivel cujo valor desejamos exibir. A funo printf() admite cinco principais modificadores de tamanho de varivel:
hh:

indica que a converso inteira corresponde a uma varivel char. Por exemplo, poderamos usar o formato %hhd para exibir uma varivel do tipo char na base decimal. h: indica que a converso inteira corresponde a uma varivel short. l: indica que a converso inteira corresponde a uma varivel long. ll: indica que a converso inteira corresponde a uma varivel long long. L: indica que a converso de nmero real corresponde a uma varivel long double.

Quando o tipo da varivel no tem modificadores de tamanho (long ou short), no se usa nenhum modificador de tamanho da varivel na funo printf().

Sequncias de escape
Sequncias de escape so combinaes de caracteres que tm significado especial, e so sempre iniciadas por uma barra invertida (\). Voc pode us-las em qualquer literal de caractere ou string. Por exemplo, a string "linha 1\nlinha 2" equivale a:
linha 1 linha 2

pois a sequncia \n indica uma quebra de linha. Como foi citado anteriormente, a funo printf(), diferentemente de puts(), no imprime automaticamente uma quebra de linha no final da string. O cdigo abaixo, por exemplo:
printf("string 1"); printf("string 2");

Imprimiria isto:
string 1string 2

Isso pode ser til, pois s vezes desejvel permanecer na mesma linha. A seguir apresentamos a tabela com as sequncias de escape suportadas pela linguagem C: Sequncia
\n \t \b \r

Significado Quebra de linha (line feed ou LF) Tabulao horizontal Retrocede o cursor em um caractere (backspace) Retorno de carro (carriage return ou CR): volta o cursor para o comeo da

\a \f \v \" \' \\ \0 \N \xN

linha sem mudar de linha Emite um sinal sonoro Alimentao de formulrio (form feed ou FF) Tabulao vertical (em impressoras) Aspa dupla Aspa simples Barra invertida Caractere nulo (caractere de valor zero, usado como terminador de strings) O caractere cuja representao octal N (dgitos de 0 a 7) O caractere cuja representao hexadecimal N (dgitos de 0 a 9 e de A a F)

Representao octal e hexadecimal Tambm possvel trocar uma sequncia de escape pelo seu valor em octal ou hexadecimal. Voc pode, por exemplo, trocar o caractere "\n" pelo valor octal "\12" ou hexadecimal "\x0A". Vejamos mais alguns exemplos.
Hexadecimal \x00 \x0A \x0D \x07 \x08 \x0B scanf() Octal \00 \12 \15 \07 \10 \13 Caracter \0 \n \r \a \b \v

A funo scanf() l dados da entrada padro (teclado) e os guarda em variveis do programa. Assim como para printf(), usamos uma string de formatao para especificar como sero lidos os dados. A sintaxe de scanf() esta:
scanf ("string de formatao", &arg1, &arg2, ...);

Como voc pode ver, a sintaxe quase igual de printf(), com exceo do E comercial (&). Voc entender melhor o seu uso nas sees seguintes, mas adiantamos que ele um operador que retorna o endereo de uma varivel. Isso necessrio pois a funo scanf() deve modificar as variveis, e quando no usamos o operador de endereo, passamos apenas o valor de uma varivel para a funo. Isso ser explicado melhor no captulo sobre ponteiros. O fato de scanf receber endereos de variveis (em vez de seus valores) tambm explica por que ele precisa ser informado da diferena entre %f (float) e %lf (double) enquanto que o printf no precisa. Um exemplo bsico da utilizao de scanf() este:
int a; scanf ("%d", &a);

O que este exemplo faz declarar uma varivel e aguardar o usurio digitar algo. Os dados s sero processados quando o usurio apertar Enter. Depois disso, os caracteres digitados pelo usurio sero convertidos para um valor inteiro e esse inteiro ser

guardado no endereo que corresponde varivel a. Se o valor digitado no puder ser convertido (porque o usurio no digitou nenhum algarismo vlido), a varivel no ser modificada. Assim como na funo printf(), podemos receber quantos valores quisermos, bastando usar vrios especificadores de converso:
int a; char b; float c; scanf ("%d %c %f", &a,&b,&c);

Dessa maneira, se o usurio digitar 120 z 17.63, teremos a igual a 120, b igual ao caractere 'z' e c igual ao nmero 17,63. Se o usurio tentar digitar mais de um espao entre os dados ou simplesmente nenhum espao, ainda assim o programa obter os dados certos. Por exemplo, 120z17.63 tambm dar o mesmo resultado. Agora uma questo um pouco mais difcil: vamos supor que especificamos um formato inteiro e o usurio digitou um nmero real, como por exemplo 12.5. O que dever acontecer?
#include <stdio.h> int main () { int a; printf ("Digite um nmero: "); scanf ("%d", &a); printf ("\nO nmero digitado foi %d", a); return (0); }

Se voc testar com o valor 12.5, vai ver que o programa retornar o nmero 12, pois a funo scanf() apenas interpreta os caracteres vlidos para aquele formato. Os especificadores de converso so praticamente os mesmos que os da funo printf(), com algumas mudanas. A maioria deles pula espaos em branco, exceto dois.
%i

no mais sinnimo de %d. O que %i faz interpretar o valor digitado como hexadecimal, se iniciar-se por 0x ou 0X; como octal, se iniciar-se por 0; ou como decimal, caso nenhuma dessas condies seja verificada.
%a, %e/%E %lf %s

e %g so sinnimos de %f.

deve ser usado para variveis do tipo double.

l uma sequncia de caracteres no-brancos (qualquer caractere exceto espao, tabulao, quebra de linha etc.), ou seja, uma palavra.
%c

l uma sequncia de caracteres, sem ignorar espaos. O padro ler um caractere, se no for especificada a largura do campo.

%[...]

l uma sequncia de caracteres, sem ignorar espaos, especificando entre colchetes quais caracteres devem ser aceitos, ou, se o primeiro caractere dentro dos colchetes for um acento circunflexo (^), quais no devem ser aceitos. Alm disso, se colocarmos um trao entre dois caracteres, todos os caracteres entre os dois sero includos no padro. Por exemplo, se quisermos incluir qualquer letra minscula, poderimos escrever %[a-z]; se quisssemos tambm incluir as maisculas, colocaramos %[a-zA-Z]. A leitura pra quando for encontrado um caractere que no coincide com o padro especificado.

J os modificadores funcionam de maneira bastante diferente:

O modificador * (asterisco) especifica que o valor atual deve ser lido da maneira especificada, mas no ser guardado em nenhuma varivel, e portanto no deve haver um ponteiro correspondente a esse valor. Por exemplo, poderimos ter um programa que espera ler uma palavra e depois um nmero, mas no importa qual palavra . Nesse caso usaramos o modificador *: scanf ("%*s %d", &numero). O programa leria a palavra e guardaria o nmero na varivel numero. Como na funo printf(), existe o especificador de largura do campo, que deve aparecer antes do especificador de converso, mas em scanf() ele especifica a largura mxima. Se a largura mxima foi definida como n, scanf() pular para o prximo campo se j tiver lido n caracteres. Por exemplo, scanf ("%4d", &num) ler um nmero de at quatro algarismos. Se o usurio digitar mais, o excedente ser no ser lido por essa chamada, mas poder ser lido por uma prxima chamada a scanf.

Mais detalhes sobre os especificadores de converso e os modificadores podem ser encontrados na documentao da biblioteca padro.

Valor de retorno
A funco scanf() retorna o nmero de converses realizadas com sucesso. Isso til pois, se o valor contido numa varivel aps a chamada de scanf() for igual ao valor anterior, no possvel saber se o valor digitado foi o mesmo que j havia ou se no foi feita a converso. Para obter esse nmero de converses realizadas, voc deve guardar o resultado numa varivel do tipo int. Veja como proceder:
int a, b; int num; num = scanf("%d%d", &a, &b);

Este exemplo l dois nmeros inteiros e os guarda nas variveis a e b. O nmero de converses realizadas guardado na varivel num. Se aps o scanf, num for diferente de 2, sinal de que o usurio digitou algo incompatvel com o formato desejado. Note que aqui introduzimos um conceito novo: o valor de retorno de uma funo. Ele pode ser obtido simplesmente associando o valor de uma varivel chamada da funo. Ele ser detalhado na seo Funes, mas j possvel compreender um pouco sua utilizao.

gets()

e getchar()

gets() e getchar(), assim como scanf(), lem da entrada padro. Assim como puts() e putchar(), no suportam formatao. Como o nome sugere, getchar() l apenas um caractere, e gets() l uma string at o final da linha ou at que no haja mais dados para ler, e adiciona o terminador de string "\0".

A sintaxe das funes :

gets(ponteiro_para_string); char c; c = getchar();

No entanto, existe um problema com a funo gets(). Veja o exemplo a seguir:

#include <stdio.h> int main() { char buffer[10]; printf("Entre com o seu nome: "); gets(buffer); printf("O nome : %s", buffer); return 0; }

A notao char buffer[10], que ainda no foi introduzida (e ser detalhada na seo Vetores (arrays)), pede que seja reservado um espao para 10 caracteres para a string buffer. Portanto, se usurio digitar mais de 9 caracteres (pois o terminador de string adicionado ao que o usurio digitou), os caracteres excedentes adicionais sero colocados na rea de memria subsequente ocupada pela varivel, escrevendo uma regio de memria que no est reservada string. Este efeito conhecido como "estouro de buffer" e pode causar problemas imprevisveis. Por isso, no se deve usar a funo gets(); mais tarde introduziremos a funo fgets(), que no apresenta esse problema e que deve ser usada no lugar de gets().
sprintf() sprintf

e sscanf()

e sscanf so semelhantes a printf e scanf. Porm, ao invs de escreverem na sada padro ou lerem da entrada padro, escrevem ou lem em uma string. A nica mudana nos argumentos a necessidade de especificar a string que deve ser lida ou atribuda no incio. Veja os exemplos para entender melhor.
#include <stdio.h> int main() { int i; char string1[30]; printf("Entre um valor inteiro: "); scanf("%d", &i); sprintf(string1, "Valor de i = %d", i); puts(string1);

return 0; }

Nesse exemplo, a mensagem que queramos exibir na tela foi primeiramente salva em uma string, e depois essa string foi enviada para a tela. Se voc olhar bem, se voc tivesse alocado um valor menor para string1, tambm ocorreria um estouro de buffer. Para evitar esse problema, existe a funo snprintf, que tem mais um argumento: o tamanho da string (deve ser colocado depois da string onde a mensagem ser gravada).
#include <stdio.h> int main() { int i, j, k; char string1[] = "10 20 30"; sscanf(string1, "%d %d %d", &i, &j, &k); printf("Valores lidos: %d, %d, %d", i, j, k); return 0; }

Nesse exemplo, usamos a funo sscanf para interpretar os valores contidos na string e guard-los nas variveis numricas.

Operaes matemticas (Bsico)

Operaes matemticas
Em C, fazer operaes matemticas simples bastante fcil e intuitivo. Por exemplo, se quisermos que uma varivel contenha o resultado da conta 123 + 912, fazemos assim:
var = 123 + 912;

Os operadores aritmticos bsicos so 5: + (adio), - (subtrao), * (multiplicao), / (diviso) e % (resto de diviso inteira). Outro exemplo:
int a = 15; int b = 72; int c = a * b;

/* c valer 1572 */

Podemos usar mais de um operador na mesma expresso. A precedncia igual usada na matemtica comum:
a = 2 + 4 * 10; a = 2 + 40 / 2 + 5; */ /* retornar 42, o mesmo que (2 + (4 * 10)) */ /* retornar 27, o mesmo que (2 + (40 / 2) + 5)

Voc pode usar parnteses, como em expresses matemticas normais:

a = (2 + 4) * 10; a = (2 + 40) / (2 + 5); /* retornar 60 */ /* retornar 6 */

Note que uma operao entre nmeros inteiros sempre retornar um nmero inteiro. Isso evidente para a adio, subtrao e multiplicao. Mas em uma diviso de inteiros, por exemplo 3/2, a expresso retornar apenas a parte inteira do resultado, ou seja, 1. Se quisermos um resultado no-inteiro, um dos operandos deve ser no-inteiro. Nesse exemplo, poderamos usar 3.0/2 ou 3/2.0, ou mesmo 3./2 ou (1.0 * 3)/2, pois, em C, uma operao envolvendo um nmero no-inteiro sempre ter como resultado um nmero real. Note que em C o separador decimal o ponto e no a vrgula. O seguinte exemplo poderia surpreender, pois o programa dir que o valor de f continua sendo 3.
#include <stdio.h> int main() { int i = 5; int j = 2; float f = 3.0; f = f + j / i; printf("O valor de f %f", f); return 0; }

Mas, segundo a precedncia dos operadores, j / i deveria ser calculado primeiro, e como ambos os valores so do tipo inteiro, o valor dessa expresso zero. importante que voc grave um arquivo .c com o cdigo acima e execute usando o compilador para ver o funcionamento com os prprios olhos.

Abreviaes
Alguns tipos de atribuies so bastante comuns, e por isso foram criadas abreviaes. Por exemplo, muito comum incrementar em uma unidade o valor de uma varivel (em loops, por exemplo). Em vez de escrever var = var + 1, podemos escrever simplesmente var++. Da mesma maneira, existe o operador de decremento, que decrementa em uma unidade o valor da varivel: var-- (equivalente a var = var 1). Os operadores de decremento e incremento tambm podem ser utilizados antes do nome da varivel. Isso significa que estas duas instrues so equivalentes:
var++; ++var;

Agora vamos supor que voc use em seu programa uma varivel que aumenta de 10 em 10 unidades. claro que usar var++ dez vezes no abreviaria nada. Em vez disso, existe a abreviao var += 10.

Genericamente, para qualquer dos cinco operadores aritmticos op, vale a abreviao:
var = var op num; var op= num;

Ou seja, os seguintes pares so equivalentes:

x x x x *= /= -= %= 12; 10; 2; 11; x x x x = = = = x x x x * / % 12; 10; 2; 11;

Este exemplo clarifica o uso dos operadores de incremento:

#include <stdio.h> int main() { int a, b; a = b = 5; printf("%d\n", printf("%d\n", printf("%d\n", printf("%d\n", return 0; }

++a + 5); a); b++ + 5); b);

O resultado que voc deve obter ao executar o exemplo :

11 6 10 6

Esse resultado mostra que ++var e var++ no so a mesma coisa se usados como uma expresso. Quando usamos os operadores na forma prefixal (antes do nome da varivel), o valor retornado depois de ser incrementado; na forma sufixal, o valor retornado e depois incrementado. O mesmo vale para o operador de decremento. E o que aconteceria se voc escrevesse algo como o seguinte?
printf("%d\n", a / ++a);

A resposta : no sabemos. Segundo o padro C, o resultado disso indefinido (o que significa que pode variar de um compilador para outro). No existe uma regra sobre avaliar primeiro o numerador ou o denominador de uma frao. Ou seja, no use uma varivel mais de uma vez numa expresso se usar operadores que a modificam. Talvez voc tenha achado estranha a linha:
a = b = 5;

Isso possvel porque atribuies so feitas da direita para a esquerda e uma instruo de atribuio tambm uma expresso que retorna o valor atribudo. Ou seja, a

expresso b = 5 retornou o valor 5, que foi usado pela atribuio a = (b = 5), equivalente a a = 5.

Operaes matemticas (Avanado)

O cabealho <math.h> contm prottipos de algumas funes na rea de matemtica. Na verso de 1990 do padro ISO, somente a verso double das funes foram especficadas; na verso de 1999 foram adicionadas as verses float e long double. As funes podem ser agrupadas nas seguintes categorias: 1. 2. 3. 4. 5. Funes Trigonomtricas Funes Hiperblicas Funes Exponencial e Logaritmo Funes pow e sqrt Funes de Arredondamento para Nmeros Inteiros, Valores Absolutos e Resto da Diviso

Funes Trigonomtricas
As funes acos e asin
A funo acos retorna o arco-cosseno dos seus argumentos em radianos, e a funo asin retorna o arco-seno dos seus argumentos em radianos. Todas as funes esperam por argumentos que estejam no intervalo [-1,+1]. O arco-cosseno retorna valores no intervalo [0,]; o arco-seno retorna valores no intervalo [-/2,+/2].
#include <math.h> float asinf(float x); /* C99 */ float acosf(float x); /* C99 */ double asin(double x); double acos(double x); long double asinl(long double x); /* C99 */ long double acosl(long double x); /* C99 */

As funes atan e atan2

As funes atan retornam o arco-tangente dos arguments em radianos, e a funo atan2 retorna o arco-tangente de y/x em radianos. As funes atan retornam o valor no intervalo [-/2,+/2] (a razo pelo que /2 est incluido no intervalo porque os valores decimais pode representar o infinito, e atan() = /2); as funes atan2 retornam o valor no intervalo [-,+]. Para a funo atan2, um "domain error" pode ocorrer se os dois argumentos forem zero.
#include <math.h> float atanf(float x); /* C99 */ float atan2f(float y, float x); /* C99 */ double atan(double x); double atan2(double y, double x); long double atanl(long double x); /* C99 */ long double atan2l(long double y, long double x); /* C99 */

As funes cos, sin e tan

As funes cos, sin, e tan retornam o coseno, seno, e tangente do argumento, expresso em radianos.
#include <math.h> float cosf(float x); /* C99 */ float sinf(float x); /* C99 */ float tanf(float x); /* C99 */ double cos(double x); double sin(double x); double tan(double x); long double cosl(long double x); /* C99 */ long double sinl(long double x); /* C99 */ long double tanl(long double x); /* C99 */

Funes Hiperblicas
As funes cosh, sinh and tanh computam o coseno hiperblico, o seno hiperblico e a tangente hiperblica respectivamente. Para as funes de seno e coseno hiperblico, um erro de ...

#include <math.h> float coshf(float x); /* C99 */ float sinhf(float x); /* C99 */ float tanhf(float x); /* C99 */ double cosh(double x); double sinh(double x); double tanh(double x); long double coshl(long double x); /* C99 */ long double sinhl(long double x); /* C99 */ long double tanhl(long double x); /* C99 */

Funes Exponencial e Logaritmo

A funo exp
As funes exp computam a funo exponencial de x (ex). Um "range error" ocorre se o valor de x muito grande.
#include <math.h> float expf(float x); /* C99 */ double exp(double x); long double expl(long double x); /* C99 */

As funes frexp, ldexp e modf

As funes frexp dividem um nmero real numa frao normalizada e um nmero inteiro mltiplo de 2. As funes guardam o nmero inteiro no objeto apontado por ex.

As funes frexp retornam o valor x de forma que x tem o valor [1/2, 1) ou zero, e value igual a x vezes 2 elevado a *ex. Se value for zero, as duas partes do resultado seram zero. As funes ldexp multiplicam um nmero real por um nmero inteiro mltiplo de 2 e retornam o resultado. Um "range error" pode ocorrer. As funes modf divide o argumento value entre um parte inteira e uma frao, cada uma tem o mesmo sinal do argumento. As funes guardam o parte inteira no objeto apontado por *iptr e retornam o frao.
#include <math.h> float frexpf(float value, int *ex); /* C99 */ double frexp(double value, int *ex); long double frexpl(long double value, int *ex); /* C99 */ float ldexpf(float x, int ex); /* C99 */ double ldexp(double x, int ex); long double ldexpl(long double x, int ex); /* C99 */ float modff(float value, float *iptr); /* C99 */ double modf(double value, double *iptr); long double modfl(long double value, long double *iptr); /* C99 */

As funes log e log10

As funes log computam o logaritmo natural do argumento e retornam o resultado. Um "domain error" ocorre se o argumento for negativo. Um "range error" pode ocorrer se o argumento for zero. As funs log10 computam o logaritmo comum (base-10) do argumento e retornam o resultado. Um "domain error" ocorre se o argumento for negativo. Um "range error" ocorre se o argumento for zero.
#include <math.h> float logf(float x); /* C99 */ double log(double x); long double logl(long double x); /* C99 */ float log10f(float x); /* C99 */ double log10(double x); long double log10l(long double x); /* C99 */

Funes pow e sqrt

As funes pow
As funes pow computam x elevado a y e retornam o resultado. Um "domain error" ocorre se x for negativo e y no for um nmero inteiro. Um "domain error" ocorre se o resultado no puder ser representado quando x zero e y menor ou igual a zero. Um "range error" pode ocorrer.
#include <math.h> float powf(float x, float y); /* C99 */ double pow(double x, double y); long double powl(long double x, long double y); /* C99 */

As funes sqrt
As funes sqrt computam a raiz positiva de x e retornam o resultado. Um "domain error" ocorre se o argumento for negativo.
#include <math.h> float sqrtf(float x); /* C99 */ double sqrt(double x); long double sqrtl(long double x); /* C99 */

Funes de Arredondamento para Nmeros Inteiros, Valores Absolutos e Resto da Diviso

As funes ceil e floor
As funes ceil computam o menor nmero inteiro que no seja menor que x e retornam o resultado; as funes floor computam o maior nmero inteiro que no seja maior que x e retornam o resultado.
#include <math.h> float ceilf(float x); /* C99 */ double ceil(double x); long double ceill(long double x); /* C99 */ float floorf(float x); /* C99 */ double floor(double x); long double floorl(long double x); /* C99 */

As funes fabs
As funes fabs computam o valor absoluto do nmero real x e retornam o resultado.
#include <math.h> float fabsf(float x); /* C99 */ double fabs(double x); long double fabsl(long double x); /* C99 */

As funes fmod
As funes fmod computam o resto de x/y e retornam o valor x - i * y, pra algum nmero inteiro i onde, se y for um nmero diferente de zero, o resultado tem o mesmo sinal de x e magnitude menor que a magnitude de y. Se y for zero, dependendo da implementao da funo, ocorrer um "domain error" ou a funo fmod retornar zero.
#include <math.h> float fmodf(float x, float y); /* C99 */ double fmod(double x, double y); long double fmodl(long double x, long double y); /* C99 */

Ligaes externas

Biblioteca de referncia C++ (C++ Reference Library) - cmath (math.h)

Controle de fluxo
Controle de fluxo
Dificilmente um programa em C ir executar sempre as mesmas instrues, na mesma ordem, independentemente do que tenha acontecido anteriormente ou do valor que foi fornecido. muito comum que algum queira que um pedao de cdigo s seja executado se uma certa condio for verdadeira; tambm comum querer que um pedao de cdigo seja repetido vrias vezes, de tal maneira que simplesmente copiar o cdigo no resolveria o problema ou seria trabalhoso demais. Para casos como esses, existem as estruturas de controle de fluxo. Em C, existem vrias instrues relacionadas ao controle de fluxo:
if, que executa um bloco apenas se uma condio for verdadeira; switch, que executa um bloco de acordo com o valor de uma expresso

ou

varivel; for, que executa um bloco repetidas vezes enquanto uma condio for verdadeira, executando uma instruo (geralmente de incremento ou decremento de uma varivel) aps cada execuo; while, que executa um bloco enquanto uma condio for verdadeira; do, semelhante ao while, mas a condio avaliada aps a execuo (e no antes); goto, que simplesmente pula para um lugar pr-definido.

Porm, antes de entrar no estudo dessas estruturas, voc deve saber como escrever uma condio. o que explicamos a seguir.

Expresses de condio
Uma expresso de condio uma expresso normal em C que, quando avaliada, ser interpretada como verdadeira ou falsa. Em C, na verdade, esse valor um valor inteiro que sendo 0 (zero) significa falso, sendo qualquer outro nmero significa verdadeiro. Geralmente em expresses condicionais usamos os operadores relacionais, ou seja, que avaliam a relao entre seus dois operandos. Existem seis deles: Operador
> >= < <= == !=

Significado maior que maior ou igual a menor que menor ou igual a igual a diferente de

Todos esses operadores so binrios, ou seja, trabalham com dois valores ou operandos. Esses operadores sempre comparam o valor da esquerda com o da direita, ou seja, a expresso a > b significa "a maior que b". Note que para saber se dois nmeros so iguais devemos usar dois sinais de igual. Um erro muito comum esquecer de um deles, transformando a comparao numa atribuio por exemplo:
if (x = 1) ...

O que acontece aqui que a varivel x recebe o valor 1, de modo que a expresso entre parnteses tambm ter o valor 1 tornando a condio sempre verdadeira. Similarmente, se usssemos o nmero zero, a expresso sempre seria falsa. Portanto, sempre tome cuidado com esse tipo de comparao. A maneira certa de comparar com um nmero :
if (x == 1) ...

Tambm comum que combinemos condies. Por exemplo, podemos querer que um nmero seja menor que 10 ou maior que 50. Como o operador "ou" "||", escreveramos: n < 10 || n > 50. A seguir voc v os operadores lgicos: Operador Significado || ou (OR) && e (AND) ! no (NOT) Algumas explicaes sobre os operadores lgicos:

O operador "no" unrio, ou seja, uma operao que envolve apenas um valor. O que ele faz inverter o valor de seu operando: retorna falso se a expresso for verdadeira e vice-versa. Deve-se usar parnteses ao negar uma expresso: !(x > 6), por exemplo. O operador "ou" retorna "verdadeiro" se pelo menos um dos operandos for verdadeiro; retorna "falso" apenas se ambos forem falsos. O operador "e" retorna "verdadeiro" apenas se ambos os seus operandos forem verdadeiros.

Observao Se voc quer saber se um nmero est entre outros dois, a sintaxe matemtica (10 < n < 50) no funcionar. Se voc usar esse cdigo, na verdade primeiramente ser avaliada a expresso 10 < n, que poder resultar em 0 ou 1. Portanto, a expresso equivale a (0 ou 1) < 50, o que sempre verdadeiro. A comparao correta envolveria o operador "e" (&&): 10 < n && n < 50.

Pelo fato de todo valor diferente de zero ser avaliado como verdadeiro e zero como falso, existem as seguintes equivalncias (apenas quando estas expresses so usadas como condies):
(x == 0) equivale a (!x) (x != 0) equivale a (x)

Testes
Testes so estruturas de controle que executam certos blocos de cdigo apenas se uma certa condio for verdadeira. Existem trs estruturas desse tipo em C:
if

O teste if avalia uma condio e, se ela for verdadeira, executa um bloco de cdigo. A sintaxe correspondente a isso :
if (condio) { ... /* bloco a ser executado se a condio for verdadeira */ }

Mas tambm podemos especificar um bloco a ser executado caso a condio for falsa. Nesse caso, escrevemos:
if (condio) { ... /* bloco a ser executado se a condio for verdadeira */ } else { ... /* bloco a ser executado se a condio for falsa */ }

As chaves podem ser omitidas caso haja apenas uma instruo no bloco. Por exemplo:
if (x == 5) printf ("x igual a 5.\n");

Perceba que, se esquecermos as chaves, o compilador no dever dar nenhum erro; no entanto, tudo que exceder a primeira instruo ser executado incondicionalmente, mesmo que esteja na mesma linha! No exemplo a seguir, a frase "x igual a 5" seria exibida mesmo que o nmero no fosse 5!
if (x == 5) j++; printf ("x igual a 5.\n");

Podemos avaliar diversas condies com os testes if, bastando para isso colocar um novo teste no bloco else. Tambm possvel aninhar blocos if, ou seja, colocar um dentro de outro:
if (x > 9) { printf ("x maior que 9.\n"); } else if (x >= 5) { printf ("x maior ou igual a 5, mas no maior que 9.\n");

} else { if (x == 0) { printf ("x igual a zero.\n"); } else { printf ("x no-nulo e menor que 5.\n"); } } switch

O teste switch compara uma expresso com diversos valores que podem estar associados a blocos de cdigos diferentes, e executa o bloco de cdigo correspondente ao valor encontrado. Voc tambm pode especificar um bloco que deve ser executado caso nenhum dos outros valores seja encontrado: o bloco default ("padro" em ingls).
switch (expresso) { case valor1: instrues; break; case valor2: instrues; break; ... default: instrues; }

Note que no teste switch no precisamos usar chaves em volta dos blocos, a menos que declaremos variveis neles. Um exemplo da utilizao de switch seria a criao de um menu:
int opcao; printf ("[1] Cadastrar cliente\n" "[2] Procurar cliente\n" "[3] Inserir pedido\n" "[0] Sair\n\n" "Digite sua escolha: "); scanf ("%d", &opcao); switch (opcao) { case 1: cadastra_cliente(); break; case 2: procura_cliente(); break; case 3: insere_pedido(); break; case 0: return 0; default: printf ("Opo invlida!\n"); }

A instruo break indica que deve-se continuar a execuo aps o final do bloco switch (pulando o que estiver no meio). Se ela no fosse usada, para um certo valor encontrado, seriam executadas tambm as instrues de todos os valores abaixo dele. Em alguns casos, podemos omitir intencionalmente a instruo break. Por exemplo, no exemplo acima, no colocamos uma instruo break para o valor zero, pois quando retornamos de uma funo (return 0) o bloco switch j abandonado. Tambm podemos querer que uma instruo seja executada para mais de um valor. Vamos supor que no nosso menu as duas primeiras opes fossem "Cadastrar pessoa fsica" e "Cadastrar pessoa jurdica", e tvessemos uma funo que faz o cadastro diferentemente dependendo do valor da varivel pessoa_fisica. Poderamos fazer um cdigo assim:
switch (opcao) { case 1: /* pessoa fsica */ pessoa_fisica = 1; case 2: cadastra(); break; ... }

Nesse caso, para qualquer uma das duas opes seria executada a funo cadastra, mas se selecionarmos "pessoa fsica" a varivel ser atribuda antes.

Operador ternrio "?:"

O operador ternrio ?: uma alternativa abreviada da estrutura if/else. Ele avalia uma expresso e retorna um certo valor se ela for verdadeira, ou outro valor se ela for falsa. Sua sintaxe :
condio ? valorSeVerdadeira : valorSeFalsa

Note que, ao contrrio de if, ao usarmos o operador condicional ?: precisamos sempre prover tanto o valor para o caso de a condio ser falsa quanto o valor para o caso de ela ser verdadeira. O operador condicional pode ser usado em situaes como essa:
int horaAbertura = (diaSemana == DOMINGO) ? 11 : 9; printf ("Abrimos s %d horas", horaAbertura);

Ou seja, se o dia da semana for domingo, a varivel horaAbertura ser definida para 11; caso contrrio, ser definida para 9. Outro exemplo:
if (numMensagens > 0) { printf ("Voc tem %d mensage%s", numMensagens, (numMensagens > 1) ? "ns" : "m"); }

Neste caso, o programa utilizaria "mensagens" caso houvesse mais de uma mensagem, e "mensagem" caso houvesse apenas uma mensagem.

Loops
Loops so conjuntos de instrues que devem ser executadas repetidas vezes, enquanto uma condio for verdadeira. Em C h 3 tipos de loops: while, do ... while e for.
while

O loop while testa uma condio; se ela for verdadeira, o bloco correspondente executado e o teste repetido. Se for falsa, a execuo continua logo aps o bloco. A sintaxe de while :
while (condio) { ... }

Por exemplo:
while (a < b) { printf ("%d menor que %d", a, b); a++; }

Este cdigo seria executado at que a fosse igual a b; se a fosse igual ou maior que b, nada seria executado. Por exemplo, para b = 10 e a < 10, a ltima mensagem que o usurio veria "9 menor que 10". Repare que o loop while como fosse um if, ou seja, o bloco executado se a condio for verdadeira. A diferena que ao final da execuo, o while executado novamente, mas o if no. No loop while (assim como nos loops do e for) tambm podemos usar a sintaxe abreviada para apenas uma instruo:
while (a < b) a++;

Loops infinitos Voc pode fazer loops infinitos com while, usando uma condio que sempre verdadeira, como "1 == 1" ou simplesmente "1" (que, como qualquer valor no-nulo, considerado "verdadeiro"):
while (1) { ... }

Voc pode sair de um loop infinito ou no com a instruo break, que voc j viu no teste switch e ser explicada mais abaixo.
do

... while

O loop "do ... while" exactamente igual ao "while" exceto por um aspecto: a condio testada depois do bloco, o que significa que o bloco executado pelo menos uma vez. A estrutura do ... while executa o bloco, testa a condio e, se esta for verdadeira, volta para o bloco de cdigo. Sua sintaxe :
do { ... } while (condio);

Note que, ao contrrio das outras estruturas de controle, necessrio colocar um ponto-e-vrgula aps a condio.
do { printf ("%d\n", a); a++; } while (a < b);

Um exemplo de utilizao de do ... while em um menu. Pediramos que o usurio escolhesse uma opo at que ele escolhesse uma opo vlida:
#include <stdio.h> int main () { int i; do { printf ("Escolha a fruta pelo nmero:\n\n"); printf ("\t(1) Mamo\n"); printf ("\t(2) Abacaxi\n"); printf ("\t(3) Laranja\n\n"); scanf("%d", &i); } while (i < 1 || i > 3); switch (i) { case 1: printf ("Voc escolheu mamo.\n"); break; case 2: printf ("Voc escolheu abacaxi.\n"); break; case 3: printf ("Voc escolheu laranja.\n"); break; } return 0; } for

O loop for nada mais que uma abreviao do loop while, que permite que alguma inicializao seja feita antes do loop e que um incremento (ou alguma outra ao) seja feita aps cada execuo sem incluir o cdigo dentro do bloco. A sua forma geral
for (inicializao; condio; incremento) { instrues;

E equivale a
inicializao; while (condio) { instrues; incremento; }

Um exemplo do uso de for:

for (a = 1; a < 10; a++) { if(a == 1) puts ("Numero de voltas previstas 9."); printf("Numero de loop ou volta : %i ", a ); printf("Valor de a : %i ", a ); }

Nesse exemplo, primeiro definimos o valor de a como 1; depois, o cdigo (...) repetido enquanto a for menor que dez, incrementando em uma unidade o valor de a aps cada execuo do cdigo. Analisando essas condies, voc podera perceber que o cdigo ser executado nove vezes: na primeira execuo, temos a = 1; aps a nona execuo, a igual a 10, e portanto o bloco no ser mais repetido. Tambm podemos dar mais de uma instruo de inicializao ou de incremento (separadas por vrgula), alm de poder usar naturalmente condies compostas com o uso dos operadores lgicos:
for (a = 1, b = 1; a < 10 && (b / a) < 20; a++, b *= 2) { ... }

Nesse exemplo, "a" e "b" so inicializados com o valor 1. A cada loop, o valor de "a" incrementado em uma unidade e o de "b" dobrado. Isso ocorre enquanto "a" for menor que 10 e a razo entre "b" e "a" for menor que 20. Se voc construir uma tabela com os valores de cada varivel a cada loop (ou colocar algum contador dentro do loop), ver que ocorrem oito execues. Assim como while, o loop for testa a condio; se a condio for verdadeira ele executa o bloco, faz o incremento e volta a testar a condio. Ele repete essas operaes at que a condio seja falsa. Podemos omitir qualquer um dos elementos do for se desejarmos. Se omitirmos a inicializao e o incremento, o comportamento ser exatamente igual ao de while. Se omitirmos a condio, ficaremos com um loop infinito:
for (inicializao; ; incremento) { ... }

Podemos tambm omitir o bloco de cdigo, se nos interessar apenas fazer incrementos ou se quisermos esperar por alguma situao que estabelecida por uma funo externa;

nesse caso, usamos o ponto-e-vrgula aps os parnteses de for. Isso tambm valido para o loop while:
for (inicializao; condio; incremento) ; while (condio) ;

Por exemplo, suponha que temos uma biblioteca grfica que tem uma funo chamada graphicsReady(), que indica se podemos executar operaes grficas. Este cdigo executaria a funo repetidas vezes at que ela retornasse "verdadeiro" e ento pudssemos continuar com o programa:
while (!graphicsReady()) ; break

e continue

Voc j viu break sendo usado para sair do teste switch; no entanto, ele funciona tambm nos loops while, do e for. Nos trs casos, ele sai do ltimo loop iniciado (mesmo que haja mais de um). Por exemplo:
while (1) { if (a > b) break; a++; }

break sempre faz com que a execuo do programa continue na primeira instruo seguinte ao loop ou bloco. A instruo continue parecida com break, porm ao execut-la saltamos para a prxima iterao loop ao invs de termin-lo. Usar continue equivale a chegar ao final do bloco; os incrementos so realizados (se estivermos em um loop for) e a condio reavaliada (qualquer que seja o loop atual).
#include <stdio.h> int main() { int opcao = 0; while (opcao != 5) { printf("Escolha uma opo entre 1 e 5: "); scanf("%d", &opcao); /* se a opo for invlida, volta ao incio do loop */ if (opcao > 5 || opcao < 1) continue; switch (opcao) { case 1: printf("\n --> Primeira opcao.."); break; case 2: printf("\n --> Segunda opcao.."); break; case 3: printf("\n --> Terceira opcao..");

break; case 4: printf("\n --> Quarta opcao.."); break; case 5: printf("\n --> Abandonando.."); break; } } return 0; }

Esse exemplo recebe uma opo do usurio. Se ele digitar uma opo invlida (ou seja, no for um nmero de 1 a 5), a instruo continue voltar ao comeo do loop e o programa pedir novamente a entrada do usurio. Se ele digitar uma opo vlida, o programa seguir normalmente.

Saltos incondicionais: goto

O goto uma instruo que salta incondicionalmente para um local especfico no programa. Esse local identificado por um rtulo. A sintaxe da instruo goto :
goto nome_do_rtulo;

Os nomes de rtulo so identificadores sufixados por dois-pontos (:), no comeo de uma linha (podendo ser precedidos por espaos). Por exemplo:
nome_do_rtulo: ... goto nome_do_rtulo;

Muitos programadores evitam usar o goto pois a maioria dos saltos pode ser feita de maneira mais clara com outras estruturas da linguagem C. Na maioria das aplicaes usuais, pode-se substituir o goto por testes, loops e chamadas de funes.

Terminando o programa
O programa pode ser terminado imediatamente usando a funo exit:
void exit (int codigo_de_retorno);

Para utiliz-la deve-se colocar um include para o arquivo de cabealho stdlib.h. Esta funo aborta a execuo do programa. Pode ser chamada de qualquer ponto no programa e faz com que o programa termine e retorne, para o sistema operacional, o cdigo_de_retorno. A conveno mais usada que um programa retorne zero no caso de um trmino normal e retorne um nmero no nulo no caso de ter ocorrido um problema.
#include <stdio.h> #include <stdlib.h> /* Para a funo exit() */

int main (void) { FILE *fp; ... fp=fopen ("exemplo.bin","wb"); if (!fp) { printf ("Erro na abertura do arquivo. Fim de programa."); exit (1); } ... return 0; }

Funes
Este mdulo precisa ser revisado por algum que conhea o assunto (discuta).

O que funo
Uma funo um pedao de cdigo que faz alguma tarefa especfica e pode ser chamado de qualquer parte do programa quantas vezes desejarmos. Utilizamos funes para obter:

Clareza do cdigo: separando pedaos de cdigo da funo main(), podemos entender mais facilmente o que cada parte do cdigo faz. Alm disso, para procurarmos por uma certa ao feita pelo programa, basta buscar a funo correspondente. Isso torna muito mais fcil o ato de procurar por erros. Reutilizao: muitas vezes queremos executar uma certa tarefa vrias vezes ao longo do programa. Repetir todo o cdigo para essa operao muito trabalhoso, e torna mais difcil a manuteno do cdigo: se acharmos um erro nesse cdigo, teremos que corrig-lo em todas as repeties do cdigo. Chamar uma funo diversas vezes contorna esses dois problemas. Independncia: uma funo relativamente independente do cdigo que a chamou. Uma funo pode modificar variveis globais ou ponteiros, mas limitando-se aos dados fornecidos pela chamada de funo.

A idia de uma funo permitir voc encapsular uma operao, dando a ela um nome, ento chamar a funo de vrias partes do seu programa simplesmente usando o seu nome. Estando corretamente projetado e estruturado o programa, em uma situao ideal, dever ser possvel modificar as funes sem efeito no resto do programa.

Definindo uma funo

Uma funo pode necessitar de alguns dados para que possa realizar alguma ao baseada neles. Esses dados so chamados parmetros da funo. Alm disso, a funo pode retornar um certo valor, que chamado valor de retorno. Os parmetros (e seus tipos) devem ser especificados explicitamente, assim como o tipo do valor de retorno. A forma geral da definio de uma funo :
[tipo de retorno da funo] [nome da funo] (1 parmetro, 2 parmetro, ) { //cdigo }

Para o nome da funo e dos parmetros valem as mesmas regras que foram dadas para os nomes de variveis. No podemos usar o mesmo nome para funes diferentes em um programa. Todas as funes devem ser definidas antes da funo main, ou deve ser feito o prottipo da funo, que veremos mais adiante. O cdigo deve estar obrigatoriamente dentro das chaves e funciona como qualquer outro bloco.

Valor de retorno
Freqentemente, uma funo faz algum tipo de processamento ou clculo e precisa retornar o resultado desse procedimento. Em C, isso se chama valor de retorno e pode ser feito com a instruo return. Para poder retornar um valor, precisamos especificar seu tipo (char, int, float, double e variaes). Para efetivamente retornar um valor, usamos a instruo return seguida do valor de retorno, que pode ou no vir entre parnteses. Um exemplo bem simples de funo que retorna um valor inteiro:
int tres() { return 3; }

// poderia tambm ser return (3);

O tipo de retorno, alm dos tipos normais de variveis (char, int, float, double e suas variaes), pode ser o tipo especial void, que na verdade significa que no h valor de retorno. Nota Muitos livros dizem que a funo main tem tipo de retorno void, o que no est correto. Segundo o padro da linguagem C, a funo main deve ter retorno do tipo int. Compiladores como o gcc daro mensagens de erro caso a funo main() no seja definida corretamente.

Parmetros
Como j foi dito, um parmetro um valor que fornecido funo quando ela chamada. comum tambm chamar os parmetros de argumentos, embora argumento esteja associado ao valor de um parmetro.

Os parmetros de uma funo podem ser acessados da mesma maneira que variveis locais. Eles na verdade funcionam exatamente como variveis locais, e modificar um argumento no modifica o valor original no contexto da chamada de funo, pois, ao dar um argumento numa chamada de funo, ele copiado como uma varivel local da funo. A nica maneira de modificar o valor de um parmetro usar ponteiros, que sero introduzidos mais adiante. Para declarar a presena de parmetros, usamos uma lista de parmetros entre parnteses, com os parmetros separados por vrgulas. Cada declarao de parmetro feita de maneira semelhante declarao de variveis: a forma geral tipo nome. Por exemplo:
int funcao (int a, int b) float funcao (float preco, int quantidade) double funcao (double angulo)

Para especificar que a funo no usa nenhum parmetro, a lista de parmetros deve conter apenas a palavra-chave void. No entanto, ela freqentemente omitida nesses casos. Portanto, voc poderia escrever qualquer uma destas duas linhas:
void funcao (void) void funcao ()

Note que os nomes dos parmetros so usados apenas na prpria funo (para distinguir os argumentos); eles no tm nenhuma relao com as variveis usadas para chamar a funo.

Chamadas de funes
Para executar uma funo, fazemos uma chamada de funo, que uma instruo composta pelo nome da funo, seguido pela lista de argumentos entre parnteses:
nome_da_funo (arg1, arg2, ...);

Os argumentos podem ser qualquer tipo de expresso: podem ser variveis, valores constantes, expresses matemticas ou at mesmo outras chamadas de funo. Lembre que voc deve sempre dar o mesmo nmero de argumentos que a funo pede. Alm disso, embora algumas converses de tipo sejam feitas automaticamente pelo compilador, voc deve atender aos tipos de argumentos. Note que o valor dos argumentos copiado para a funo, de maneira que as variveis originais ficam inalteradas mesmo que na funo tentemos alter-las. A isso chamamos passagem de argumentos por valor (ao contrrio de por referncia). Veremos como modificar as variveis originais na seo Ponteiros. A prpria chamada de funo tambm uma expresso cujo valor o valor de retorno da funo, bastando coloc-la no lado direito de um sinal de igual para guardar o valor numa varivel. Por exemplo, se a funo "quadrado" retorna o quadrado de um nmero inteiro, podemos fazer assim para calcular o quadrado de 11 na varivel x:

int x = quadrado (11);

Dois exemplos
#include <stdio.h> int quadrado (int x) { return (x * x); } void saudacao (void) { printf ("Ol!\n"); } void despedida (void) { printf ("Fim do programa.\n"); } int main () { int numero, resultado; saudacao (); printf ("Digite um nmero inteiro: "); scanf ("%d", &numero); resultado = quadrado (numero); printf ("O quadrado de %d %d.\n", numero, resultado); despedida (); return 0; }

Voc veria na tela, ao executar o programa:

Ol! Digite um nmero inteiro: 42 O quadrado de 42 1764. Fim do programa.

Repare que, ao chegar na chamada de uma funo, o programa passa o controle para essa funo e, aps seu trmino, devolve o controle para a instruo seguinte na funo original. Mais um exemplo, com uma funo de 3 argumentos:
#include <stdio.h> /* Multiplica 3 numeros */ void mult (float a, float b, float c) { printf ("%f",a*b*c); } int main () {

float x, y; x = 23.5; y = 12.9; mult (x, y, 3.87); return 0; }

Prottipo ou Declarao de funo

Quando um programa C est sendo compilado e uma chamada de funo encontrada, o compilador precisa saber o tipo de retorno e os parmetros da funo, para que ele possa manipul-los corretamente. O compilador s tem como saber isso se a funo j tiver sido definida. Portanto, se tentarmos chamar uma funo que est definida abaixo da linha onde estamos fazendo a chamada, ou mesmo em outro arquivo, o compilador dar uma mensagem de erro, pois no conseguiu reconhecer a funo.
//Exemplo de erro de chamada de funo int main() { int a = 1; int b = 2; soma(a,b); // erro: a funo est definida abaixo desta linha! } void soma(int a, int b) { printf("%d", a+b); }

Nesses casos, podemos declarar uma funo antes de defini-la. Isso facilita o trabalho de usar diversas funes: voc no precisar se importar com a ordem em que elas aparecem nos arquivos. A declarao de funo (tambm chamada de prottipo de funo) nada mais que a definio da funo sem o bloco de cdigo. Como uma instruo, ela deve ser seguida de um ponto-e-vrgula. Portanto, para declarar a funo:
int quadrado (int x) { return (x * x); }

escreveramos:
int quadrado (int x);

Numa declarao, tambm podemos omitir os nomes dos parmetros, j que estes so ignorados por quem chama a funo:
int quadrado (int);

Poderamos, por exemplo, reorganizar o incio do programa-exemplo dado um pouco acima, o que permitiria colocar as funes em qualquer ordem mesmo que houvesse interdependncia entre elas:

#include <stdio.h> int quadrado (int x); void saudacao (void); void despedida (void); // seguem as funes do programa

Note que a definio da funo no deve contradizer a declarao da mesma funo. Se isso ocorrer, uma mensagem de erro ser dada pelo compilador.

Variveis locais versus globais

Quando declaramos as variveis, ns podemos faz-lo

Dentro de uma funo Fora de todas as funes inclusive a main().

As primeiras so as designadas como locais: s tm validade dentro do bloco no qual so declaradas. As ltimas so as globais, elas esto vigentes em qualquer uma das funes. Quando uma funo tem uma varivel local com o mesmo nome de uma varivel global a funo dar preferncia varivel local. Daqui conclui-se e bem que, podemos ter variveis com o mesmo nome, o que contradiz o que ns dissemos no capitulo das variveis. Ento reformulamos: Apenas na situao em que temos 2 variveis locais que colocada a restrio de termos nomes diferentes caso contrrio no conseguiramos distinguir uma da outra. "largo" e "alto" so variveis internas fazem parte de "minhaFuncion()".
/*espanhol para incultos :)*/ <== Comentrios da funo void minhaFuncion() { double largo = 5; double alto = 6; }

As variveis largo e alto no esto definidas aqui abaixo, isto quer dizer que elas nao tem nem um valor. E no podemos usar os valores definido dentro da "minhaFuncion", pois no h nenhuma instruo que defina que valor usar. Lembre-se: O computador no vai adivinhar qual valor usar. Deve-se definir cada instruo.
void calcular() /*No houve definio de valor entre parenteses*/ { long surface = largo * alto; /*Error bip bip valor nao definido*/ return(surface);

Nesse exemplo abaixo, poderemos usar o valor das variveis externas dentro de todas as funes. Exemplo:
#include <stdio.h> /*Variavel externa*/ long largo = 10; long alto = 20; void minhaFuncion() { /*variavel interna*/ long somma = largo + alto ; } long calcular() { long surface = largo * alto; /*Aqui ele pode enxegar a varivel "externa" (global)*/ } int main(void) { long reslt = calcular(); printf("A surface e:%ld\n",reslt); return 0 ; }

Curiosidade: A palavra reservada "auto" serve para dizer que uma varivel local, mas intil pois as variveis declaradas dentro de um bloco j so consideradas locais.

Passagem de parmetros por valor e por referncia

O que ns temos feito quando chamamos uma funo a dita chamada por valor. Quer dizer, quando chamamos uma funo e passamos parmetros para a funo prottipo e depois para a funo definio, o valor dos argumentos passados so copiados para os parmetros da funo. Estes existem independentemente das variveis que foram passadas. Eles tomam apenas uma cpia do valor passado, e se esse valor for alterado o valor dos argumentos passados no so alterados. Ou seja, no so alterados os valores dos parmetros fora da funo. Este tipo de chamada de funo denominado chamada (ou passagem de parmetros) por valor. Dito de outra maneira. Passamos a varivel a, ela entra na definio da funo como copia de a e entra como varivel b. Se a varivel b for alterada no decorrer da funo, o valor de a no alterado.
#include <stdio.h> float quadrado(float num); //prottipo da funo quadrado() int main () { float num, res; //declaro 2 variveis: num , res printf("Entre com um numero: "); scanf("%f", &num); //associo o valor inserido varivel num

res = quadrado(num); //chamo a funo quadrado e passo o parmetro num printf("\n\nO numero original e: %f\n", num); printf("e seu quadrado vale: %f\n", res); getchar(); return 0; } float quadrado (float num) //descrio da funo quadrado { return num * num; //retorna num ao quadrado }

Quando a funo main() executada, ela chega a meio e v uma chamada para a funo quadrado() e onde passado o parmetro "num". Ela j estava a espera, pois "viu" o prottipo. Ela ento vai executar a funo que est depois da funo do main(). E o que acontece que o "num", vai ficar com o dobro do valor. Esse valor do main() vai entrar novamente no main(). E associado varivel "res". Depois temos a impresso da varivel "num" e "res". Ora o que acontece que o valor do "num" fica igual ao valor antes de entrar na funo. Fazemos a mesma coisa agora com a varivel "a" e "b", e vemos que agora a funo a alterada. Resumindo, o valor varivel quando entra numa outra funo no alterado (na passagem por valor). Quando o valor do parmetro alterado denominamos chamada (ou passagem) por referncia. O C no faz chamadas por referncia. Mas podemos simular isto com outra arma do C que so os ponteiros, que sero melhor explicados mais adiante.

void
Como dissemos, uma funo retorna um valor. E pode receber parmetros. O void utilizado da seguinte forma:
void funo(void) { //codigo }

No exemplo acima, a palavra void define que:

no vai receber parmetros; e no vai retornar qualquer valor.

Ou melhor, void uma explicitao do programador que aquela funo no vai receber ou retornar nenhum valor. O valor da funo ignorado, mas a funo realmente retorna um valor, por isso para que o resultado no seja interpretado como um erro e bom declarar void. Nota No se pode utilizar void na funo principal main, apesar de existirem exemplos com void em algumas bibliografias. Infelizmente, alguns compiladores aceitam void main(). O main() especial e tem de retornar um int.

Uma execuo bem sucedida do programa costuma retornar 0 (zero) e, em caso de erro, retorna 1 (um).

Recursividade
Uma funo pode chamar a si prpria. Uma funo assim chamada funo recursiva. H vrias operaes matemticas recursivas, das quais exemplos bem conhecidos so a seqncia de Fibonacci e o fatorial. Daremos o exemplo do clculo do fatorial de um nmero, definido como o produto de todos os nmeros naturais (no nulos) menores ou iguais a ele por exemplo, 5! (l-se "cinco fatorial") igual a . Ateno conveno . Uma maneira de definir o algoritmo de fatorial :

E a implementao correspondente seria esta:

#include <stdio.h> #include <stdlib.h> int fat(int n) { if (n) return n*fat(n-1); else return 1; } int main() { int n; printf("\n\nDigite um valor para n: "); scanf("%d", &n); printf("\nO fatorial de %d e' %d", n, fat(n)); system ("pause"); return 0; }

inline
Uma funo inline, em vez de ser chamada, ser movida para o local de chamada no momento da compilao. Se fizermos um paralelismo com as directivas de compilao, como #define, ela vai substituir cada chamada da funo pela prpria funo, como fosse uma macro. Mas isto s tem vantagens para cdigos pequenos e para quem necessite muito da velocidade no processamento. Alguns compiladores j fazem isto automaticamente.

Para tornar uma funo inline basta preceder a declarao da funo com o nome inline.
inline [tipo_de_retorno] [nome_da_funo] (argumentos) { //cdigo }

Pr-processador
O pr-processador
O pr-processador C um programa que examina o programa fonte escrito em C e executa certas modificaes nele, baseado nas diretivas de compilao (ou diretivas do pr-processador). As diretivas de compilao so comandos que no so compilados, sendo dirigidos ao pr-processador, executado pelo compilador antes da execuo do processo de compilao propriamente dito. Portanto, o pr-processador modifica o programa fonte, que ainda no estaria pronto para ser entregue ao compilador. Todas as directivas de compilao so iniciadas pelo caractere # (sharp). As diretivas podem ser colocadas em qualquer parte do programa, mas no podem ser colocadas na mesma linha que outra diretiva ou instruo. As principais diretivas de compilao so:

#include #define #undef #ifdef #ifndef #if #else #elif #endif

Diretivas de compilao
#include

A diretiva #include diz ao pr-processador para incluir naquele ponto um arquivo especificado. Sua sintaxe :
#include "nome_do_arquivo"

ou
#include <nome_do_arquivo>

A diferena entre se usar "" e <> somente a ordem de procura nos directrios pelo arquivo especificado. Se voc quiser informar o nome do arquivo com o caminho completo, ou se o arquivo estiver no directrio de trabalho, use "arquivo". Se o arquivo estiver nos caminhos de procura pr-especificados do compilador, isto , se ele for um arquivo do prprio sistema (como o caso de arquivos como stdio.h, string.h, etc...), use <arquivo>.
#define

A diretiva #define tem duas utilidades. Uma delas apenas definir um smbolo que pode ser testado mais tarde. Outra definir uma constante ou ainda uma macro com parmetros. As trs maneiras de usar a diretiva so:
#define nome_do_smbolo #define nome_da_constante valor_da_constante #define nome_da_macro(parmetros) expresso_de_substituio

Toda vez que o pr-processador encontrar nome_da_constante no cdigo a ser compilado, ele deve substitu-lo por valor_da_constante. Toda vez que o pr-processador encontrar nome_da_macro(parmetros), ele deve substituir por expresso_de_substituio, tambm substituindo os parmetros encontrados na expresso de substituio; funciona mais ou menos como uma funo. Veja o exemplo para entender melhor.

Exemplo 1:
#include <stdio.h> #define PI #define VERSAO 3.1416 "2.02"

int main () { printf ("Programa verso %s\n", VERSAO); printf ("O numero pi vale: %f\n", PI); return 0; }

Exemplo 2:
#define max(A, B) ((A > B) ? (A) : (B)) #define min(A, B) ((A < B) ? (A) : (B)) ... x = max(i, j); y = min(t, r);

Aqui, a linha de cdigo: x = max(i, j); ser substituda pela linha: x = ((i) > (j) ? (i) : (j));. Ou seja, atribuiremos a x o maior valor entre i ou j. Quando voc utiliza a diretiva #define, nunca deve haver espaos em branco no identificador (o nome da macro). Por exemplo, a macro #define PRINT (i) printf(" %d \n", i) no funcionar correctamente porque existe um espao em branco entre PRINT e (i).

#undef
A diretiva #undef tem a seguinte forma geral:
#undef nome_da_macro

Ela faz com que a macro que a segue seja apagada da tabela interna que guarda as macros. O compilador passa a partir deste ponto a no conhecer mais esta macro.
#ifdef

e #ifndef

O pr-processador tambm tem estruturas condicionais. No entanto, como as diretivas so processadas antes de tudo, s podemos usar como condies expresses que envolvam constantes e smbolos do pr-processador. A estrutura ifdef a mais simples delas:
#ifdef nome_do_smbolo cdigo ... #endif

O cdigo entre as duas diretivas s ser compilado se o smbolo (ou constante) nome_do_smbolo j tiver sido definido. H tambm a estrutura ifndef, que executa o cdigo se o smbolo no tiver sido definido. Lembre que o smbolo deve ter sido definido atravs da diretiva #define.
#if

A diretiva #if tem a seguinte forma geral:

#if expresso cdigo ... #endif

A sequncia de declaraes ser compilada apenas se a expresso fornecida for verdadeira. muito importande ressaltar que a expresso fornecida no pode conter nenhuma varivel, apenas valores constantes e smbolos do pr-processador.
#else

A diretiva #else funciona como na estrutura de bloco if (condio) {...} else {...}:
#if expresso /* ou #ifndef expresso */ cdigo /* ser executado se a expresso for verdadeira */ #else cdigo /* ser executado se a expresso for falsa */ #endif

Um exemplo:

#define WINDOWS ... /* cdigo */ ... #ifdef WINDOWS #define CABECALHO "windows_io.h" #else #define CABECALHO "unix_io.h" #endif #include CABECALHO #elif

A diretiva #elif serve para implementar uma estrutura do tipo if (condio) {...} else if (condio) {...}. Sua forma geral :
#if expresso_1 cdigo #elif expresso_2 cdigo #elif expresso_3 cdigo . . . #elif expresso_n cdigo #endif

Podemos tambm misturar diretivas #elif com #else; obviamente, s devemos usar uma diretiva #else e ela deve ser a ltima (antes de #endif).

Usos comuns das diretivas

Um uso muito comum das diretivas de compilao em arquivos-cabealho, que s precisam/devem ser includos uma vez. Muitas vezes inclumos indiretamente um arquivo vrias vezes, pois muitos cabealhos dependem de outros cabealhos. Para evitar problemas, costuma-se envolver o arquivo inteiro com um bloco condicional que s ser compilado se o arquivo j no tiver includo. Para isso usamos um smbolo baseado no nome do arquivo. Por exemplo, se nosso arquivo se chama "cabecalho.h", comum usar um smbolo com o nome CABECALHO_H:
#ifndef CABECALHO_H #define CABECALHO_H . . . #endif

Se o arquivo ainda no tiver sido includo, ao chegar na primeira linha do arquivo, o pr-processador no encontrar o smbolo CABECALHO_H, e continuar a ler o arquivo, o que lhe far definir o smbolo. Se tentarmos incluir novamente o arquivo, o prprocessador pular todo o contedo pois o smbolo j foi definido.

Concatenao
O preprocessador C oferece duas possibilidades para manipular uma cadeia de caracteres . A primeira usando o operador # que permite substituir a grafia de um parmetro .
#include<stdio.h> int main (void) { /* mad equivale a "mad" */ #define String(mad) #mad printf ( String( Estou aqui ) "\n" ); }

A segunda usando o operador ## que serve para concatenar vrios parmetros . Ex: ban##ana igual a banana .
#include<stdio.h> int main (void) { int teste = 1000 ; #define CONCAT(x, y) x##y /* igual a "tes" + "te" */ printf (" %i \n", CONCAT ( tes, te ) ); }

Bibliotecas
Bibliotecas
Bibliotecas so conjuntos de funes que foram feitas por algum e que podem ser usadas por outros programas sem que nos preocupemos com o cdigo dessas funes. Alm da vantagem de organizar o cdigo, bibliotecas tambm tm a vantagem de poderem ser utilizadas em vrios programas sem necessidade de copiar grandes trechos de cdigo; basta dizer ao compilador que queremos adicionar aquela biblioteca ao executvel. Por exemplo, vamos tentar criar a nossa prpria biblioteca, com duas funes: uma para gerar nmeros (pseudo-)aleatrios e uma para calcular o valor de pagamento de uma amortizao com juros compostos. Tambm incluiremos uma funo para gerar um

nmero inicial a partir da hora atual, o que far com que as seqncias de nmeros no sejam sempre as mesmas. Chamaremos a biblioteca de teste1.
#include <math.h> #include <time.h> int rand_seed = 10; /* Gerador de nmeros pseudo-aleatrios */ int rand () { rand_seed = rand_seed * 1103515245 + 12345; return (unsigned int) (rand_seed / 65536) % 32768; } void init_seed () { rand_seed = time (NULL); } /* Clculo do valor de cada pagamento de uma amortizao * Dados: vp = valor presente; * n = nmero de pagamentos; * i = taxa de juros (em formato decimal) */ double vf (double vp, int n, double i) { return (vp * i * pow (1 + i, n - 1) / (pow (1 + i, n) - 1)); }

As linhas acima so o arquivo do cdigo da nossa biblioteca. Abaixo est o cdigo de um programa que testar essa biblioteca. Lembre-se de que os dois trechos devem estar em arquivos separados.
#include <stdio.h> int main() { int r1, r2, n_pgtos; double a_vista, juros, v_pgto; r1 = rand (); r2 = rand (); printf ("Nmeros aleatrios: %d, %d\n\n", r1, r2); printf (" Valor vista: "); scanf ("%lf", &a_vista); printf ("Nmero de pagamentos: "); scanf ("%d", &n_pgtos); printf (" Taxa de juros: "); scanf ("%lf", &juros); juros /= 100; /* converte a porcentagem em nmero */ v_pgto = vf (a_vista, n_pgtos, juros); printf ("Valor de cada pagamento: %lf\n", v_pgto);

return 0; }

Algo que voc deve ter notado que nesse arquivo no demos nenhuma informao sobre as funes vf e rand nele usadas. Realmente, se voc tentar compilar o cdigo como est, o compilador dar um aviso; mas ao tentar criar o executvel, o montador no poder continuar pois no recebeu nenhuma informao sobre onde as funes esto. Para isso, precisamos realizar trs passos adicionais antes de compilar o programa teste: 1. Fazer um arquivo-cabealho com informaes sobre as funes. Esse arquivo ser incluido com a diretiva #include, da mesma maneira que cabealhos padro como "stdio.h" ou "math.h". 2. Compilar a biblioteca separadamente. 3. Instruir o compilador/montador a procurar pela biblioteca ao compilar o programa teste.

O arquivo-cabealho
Esta pgina somente um esboo. Ampliando-a voc ajudar a melhorar o Wikilivros.

Arquivos-cabealho so arquivos que contm informaes que servem para o compilador reconhecer funes "VER : convenes para chamadas a funes ou calling convention", macros, tipos de dados e variveis que no esto no arquivo sendo compilado. Esses arquivos costumam ter a extenso ".h" o caso, por exemplo, dos cabealhos padro stdio.h e math.h. A letra H usada pois a inicial de header (cabealho em ingls). Em uma biblioteca, os cabealhos contm, os prottipos das funes disponibilizadas pela biblioteca e, quando necessrio, sobre os tipos de estruturas usados. Bibliotecas mais complexas costumam dividir essas funes entre vrios arquivos. Para fazer nosso prprio cabealho, precisamos colocar as declaraes das funes disponveis na biblioteca:
int rand (); void init_seed (); double vf (double, int, double);

Se voc se lembra da ltima lio, poder sugerir que coloquemos algumas linhas a mais:
#ifndef _TESTE1_H #define _TESTE1_H int rand (); void init_seed ();

double vf (double, int, double); #endif

Agora, sempre que precisarmos usar a biblioteca teste1, basta incluir o arquivo teste1.h no incio do nosso programa:
#include "teste1.h"

Note que se o cabealho estiver instalado nos diretrios padro do compilador ou do sistema, voc deve trocar as aspas pelos sinais de menor/maior (< ... >).

Compilao da biblioteca
Tendo salvo o cdigo da biblioteca no arquivo teste1.c, voc deve compilar a biblioteca.

No GCC

Compile o arquivo-fonte normalmente, mas sem gerar o executvel:

gcc -c teste1.c -o libteste1.o

Crie o arquivo da biblioteca com o comando ar. Voc ainda no o conhece, mas a sintaxe simples: basta digitar ar rv, seguido do nome do arquivo da biblioteca e depois dos nomes dos arquivos-objeto a serem includos (separados por espaos). No GCC, as bibliotecas estticas costumam ter o nome "libnome.a".

ar rv libteste1.a libteste1.o

No MS Visual C++
No Visual C++, o nome padro das bibliotecas "nome.lib", assim como em vrios outros compiladores para Windows. Nele, os comandos correspondentes aos dois passos acima so:
cl /c teste1.c lib /out:teste1.lib teste1.obj

Compilao do programa
Aps criar o arquivo objeto libteste1.o com o comando ( gcc -c teste1.c -o libteste1.o ) e a biblioteca esttica com o comando "ar" , voc deve instruir o compilador com as opes de edio de links para poder inclu-la no seu programa:
gcc

No GCC:
main.c -L. -l libteste1.a -o main.bin -lm

Note as opes que voc no conhecia: -L e -l . A primeira indica em que diretrio deve ser procurada a biblioteca; o ponto indica o diretrio atual. Se essa opo for omitida, o compilador procurar apenas nos diretrios padro. A segunda uma opo do editor de links indicando uma biblioteca a ser includa; o compilador procurar pelo arquivo adicionando o prefixo lib e a extenso .a, da a necessidade de dar o nome "libteste1.a" biblioteca. Mais bibliotecas podem ser includas como a -lm que neste caso serve para chamar a biblioteca math do math.h, sem este comando ele poder apresentar um erro na hora da compilao.

No Visual C++:

link /out:main.exe main.obj teste1.lib

Note que nesse caso simplesmente especificamos os arquivos que devem ser montados. O diretrio de procura pode ser especificado pela opo /libpath:diretrio.

Entrada e sada em arquivos

Trabalhando com arquivos
J vimos como podemos receber e enviar dados para usurio atravs do teclado e da tela; agora veremos tambm como ler e gravar dados em arquivos, o que alis muito importante ou at essencial em muitas aplicaes. Assim como as funes de entrada/sada padro (teclado e tela), as funes de entrada/sada em arquivos esto declaradas no cabealho stdio.h que significa "STanDard Input-Output". Alis, as funes para manipulao de arquivos so muito semelhantes s usadas para entrada/sada padro. Como j dissemos na seo sobre a entrada e sada padres, a manipulao de arquivos tambm se d por meio de fluxos (streams). Na manipulao de um arquivo, h basicamente trs etapas que precisam ser realizadas: 1. abrir o arquivo; 2. ler e/ou gravar os dados desejados; 3. fechar o arquivo. Em C, todas as operaes realizadas com arquivos envolvem seu identificador de fluxo, que uma varivel do tipo FILE * (sobre o qual no cabe agora falar). Para declarar um identificador de fluxo, faa como se fosse uma varivel normal:
FILE *fp; // no se esquea do asterisco!

Abrindo e fechando um arquivo

No surpreendentemente, a primeira coisa que se deve fazer para manipular um arquivo abri-lo. Para isso, usamos a funo fopen(). Sua sintaxe :

FILE *fopen (char *nome_do_arquivo, char *modo_de_acesso);

O nome do arquivo deve ser uma string ou com o caminho completo (por exemplo, /usr/share/appname/app.conf ou C:\Documentos\nomes.txt) ou o caminho em relao ao diretrio atual (nomes.txt, ../app.conf) do arquivo que se deseja abrir ou criar. O modo de acesso uma string que contm uma seqncia de caracteres que dizem se o arquivo ser aberto para gravao ou leitura. Depois de aberto o arquivo, voc s poder executar os tipos de ao previstos pelo modo de acesso: no poder ler de um arquivo que foi aberto somente para escrita, por exemplo. Os modos de acesso esto descritos na tabela a seguir. Significado Abre o arquivo somente para leitura. O arquivo deve existir. (O r vem do ingls read, ler) Abre o arquivo para leitura e escrita. O arquivo deve existir. Abre o arquivo somente para escrita no incio do arquivo. Apagar o contedo do arquivo se ele j existir, criar um arquivo novo se no existir. (O w vem do ingls write, escrever) Abre o arquivo para escrita e leitura, apagando o contedo pr-existente. Abre o arquivo para escrita no final do arquivo. No apaga o contedo prexistente. (O a vem do ingls append, adicionar, apender) Abre o arquivo para escrita no final do arquivo e leitura.

Modo r r+ w w+ a a+

Em ambientes DOS/Windows, ao ler arquivos binrios (por exemplo, programas executveis ou certos tipos de arquivos de dados), deve-se adicionar o caractere "b" ao final da string de modo (por exemplo, "wb" ou "r+b") para que o arquivo seja lido/gravado corretamente. Isso necessrio porque no modo texto (o padro quando no adicionado o b) ocorrem algumas tradues de caracteres (por exemplo, a terminao de linha "\r\n" substituda apenas por "\n" na leitura) que poderiam afetar a leitura/gravao dos arquivos binrios (indevidamente inserindo ou suprimindo caracteres).

O valor de retorno da funo fopen() muito importante! Ele o identificador do fluxo que voc abriu e s com ele que voc conseguir ler e escrever no arquivo aberto. Se houver um erro na abertura/criao do arquivo, a funo retornar o valor NULL. O erro geralmente acontece por duas razes: o O arquivo no existe, caso tenha sido requisitado para leitura. o O usurio atual no tem permisso para abrir o arquivo com o modo de acesso pedido. Por exemplo, o arquivo somente-leitura, ou est bloqueado para gravao por outro programa, ou pertence a outro usurio e no tem permisso para ser lido por outros.

Ao terminar de usar um arquivo, voc deve fech-lo. Isso feito pela funo fclose():

int fclose (FILE *fluxo);

O nico argumento o identificador do fluxo (retornado por fopen). O valor de retorno indica o sucesso da operao com o valor zero.

Exemplo
Um pequeno exemplo apenas para ilustrar a abertura e fechamento de arquivos:
#include <stdio.h> int main() { FILE *fp; fp = fopen ("README", "w"); if (fp == NULL) { printf ("Houve um erro ao abrir o arquivo.\n"); return 1; } printf ("Arquivo README criado com sucesso.\n"); fclose (fp); return 0; }

Arquivos pr-definidos
Na biblioteca padro do C, existem alguns fluxos pr-definidos que no precisam (nem devem) ser abertos nem fechados:

stdin: dispositivo de entrada padro (geralmente o teclado) stdout: dispositivo de sada padro (geralmente o vdeo) stderr: dispositivo de sada de erro padro (geralmente o vdeo) stdaux: dispositivo de sada auxiliar (em muitos sistemas, associado porta serial) stdprn: dispositivo de impresso padro (em muitos sistemas, associado porta paralela)

Escrevendo em arquivos
Para escrever em arquivos, h quatro funes, das quais trs so anlogas s usadas para sada padro: Sada padro Arquivos Explicao putchar fputc Imprime apenas um caractere. puts fputs Imprime uma string diretamente, sem nenhuma formatao. printf fprintf Imprime uma string formatada. N/A fwrite Grava dados binrios para um arquivo. A seguir apresentamos os prottipos dessas funes:

void fputc (int caractere, FILE *fluxo); void fputs (char *string, FILE *fluxo); void fprintf (FILE *fluxo, char *formatao, ...); int fwrite (void *dados, int tamanho_do_elemento, int num_elementos, FILE *fluxo);

Sintaxe quase igual de printf(); s necessrio adicionar o identificador de fluxo no incio.

fwrite

Essa funo envolve os conceitos de ponteiro e vetor, que s sero abordados mais tarde.

Lendo de arquivos
Novamente, h quatro funes, das quais trs se assemelham s usadas para a sada padro: Sada padro Arquivos Explicao getchar fgetc Recebe apenas um caractere. gets fgets L uma string (geralmente uma linha inteira). scanf fscanf Recebe uma string formatada. N/A fread L dados binrios de um arquivo.

int fgetc (FILE *fluxo); void fgets (char *string, int tamanho, FILE *fluxo); void fscanf (FILE *fluxo, char *formatao, ...); int fread (void *dados, int tamanho_do_elemento, int num_elementos, FILE *fluxo);

Este mdulo tem a seguinte tarefa pendente: criar exemplos de uso das funes

fgetc

Est funo requer como parmetro o indicador de fluxo do arquivo, retorna um caractere do arquivo ou EOF, caso ocorra um erro ou o final do arquivo seja atingido, podendo ser verificado respectivamente por ferror e feof.

Exemplo
#include <stdio.h> #include <stdlib.h> int main() { FILE *fl; int c; if((fl = fopen("caminho/do/arquivo", "r")) == NULL) { perror("Erro: fopen"); exit(EXIT_FAILURE); } while((c = fgetc(fl)) != EOF) printf("Caractere lido: %c\n", c); if((c == EOF) && (feof(fl) == 0) && (ferror(fl) != 0)) perror("Erro: fgetc"); fclose(fl); return EXIT_SUCCESS; }

fgets

Ao chamar a funo fgets(), voc deve fornecer o ponteiro para a string onde os dados lidos devem ser guardados, alm do tamanho mximo dos dados a serem lidos (para que a memria reservada string no seja ultrapassada).

fscanf

Sintaxe quase igual de scanf(); s necessrio adicionar o identificador de fluxo no incio.

fread

Essa funo envolve os conceitos de ponteiro e vetor, que s sero abordados mais tarde.

Outras funes
Funo Explicao feof Detecta se o final do arquivo j foi atingido Verifica se a ltima operao de leitura ou escrita do fluxo foi executada com ferror sucesso

fseek Movimenta o indicador de posio dentro do arquivo de um fluxo especificado rewind Volta para o comeo do arquivo de um fluxo remove Remove um arquivo especificado

Esta pgina um esboo de informtica. Ampliando-a voc ajudar a melhorar o Wikilivros.

Exerccios Finais
Esta pgina foi marcada para eliminao rpida e ser eliminada assim que um administrador confirmar a validade da marcao conforme as polticas. Razo: Pgina movida Observador: Abacaxi (Discusso) 17h47min de 3 de maio de 2013 (UTC)

Vetores
Vetores
Vetores, tambm chamados arrays (do ingls) ou arranjo ou ainda matrizes, so uma maneira de armazenar vrios dados num mesmo nome de varivel atravs do uso de ndices numricos. Em C, vetores devem sempre conter dados do mesmo tipo de varivel. Declaramos vetores de maneira muito semelhante declarao de variveis normais. A nica diferena que depois do nome da varivel deve ser informada a quantidade de elementos do vetor. Para declarar um vetor chamado vetor, com cinco elementos inteiros, escrevemos:
int vetor[5];

Note que a quantidade de elementos de um vetor no pode ser alterada depois que o vetor for declarado. Para criar vetores de tamanho dinmico, podemos usar ponteiros, que sero abordados mais adiante. Da mesma maneira que podemos inicializar uma varivel junto com sua declarao, podemos usar as chaves ({}) para inicializar um array.
int vetor[5] = {17, 42, 9, 33, 12};

Para fazer referncia a um valor de um elemento contido em um vetor, usamos a notao vetor[ndice], que serve tanto para obter quanto para definir o valor de um

elemento especfico, dada sua posio. Note que os elementos so numerados a comear do zero, e, portanto, se o nmero de elementos , o ndice ou posio do ltimo elemento ser .
vetor[0] = 3; int x = vetor[2]; int y = vetor[5]; // ERRO!

Repare em que a ltima linha contm um erro: ela referencia um elemento do vetor que no existe. No entanto, o compilador no se recusar a compilar esse cdigo; dar apenas um aviso. Se essa linha for executada, a varivel y receber um valor que no tem nada a ver com o vetor.

Abreviando as declaraes
Ao inicializar um vetor com vrios valores, pode ser trabalhoso contar todos os valores para colocar o tamanho do vetor na declarao. Por isso, em C podemos omitir o nmero de elementos quando os valores so inicializados; o tamanho do vetor ser o nmero de valores inicializados. Por exemplo, as duas notaes abaixo so equivalentes:
int valores[5] = {1, 2, 3, 4, 5}; int valores[] = {1, 2, 3, 4, 5};

Exemplo de Aplicao de Vetores

O cdigo abaixo de um programa que recebe 5 nmeros inteiros e informa qual destes maior.
#include <stdio.h> #include <stdlib.h> #include <conio.h> int main(void) { int vetor[5]; int x, y; printf ("digite 5 numeros\n"); for (y = 0; y < 5; y++) /*Este laco faz o scan de cada elemento do vetor*/ { scanf("%d", &vetor[y] ); } y = 1; x = vetor[0]; while (y < 5) /*Este laco compara cada elemento do vetor*/ { if (vetor[y] > x) { x = vetor[y]; } y++; }

printf("\n O maior numero que voce digitou foi %d .\n",x); getch (); return 0; }

Vetores multidimensionais (matrizes)

Podemos declarar ainda mais variveis
tipo_da_varivel nome_da_varivel [altura][largura];

Ateno que:

ndice mais direita varia mais rapidamente que o ndice esquerda. No esquecer os ndices variam de zero ao valor declarado menos um.

Podemos ter ainda conjunto de variveis multidimensionais.

tipo_da_varivel nome_da_varivel [tam1][tam2] ... [tamN];

onde a iniciao :
tipo_da_varivel nome_da_varivel [tam1][tam2] ... [tamN] = {lista_de_valores}; float vect [6] = { 1.3, 4.5, 2.7, 4.1, 0.0, 100.1 }; int matrx [3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; char str [10] = { 'J', 'o', 'a', 'o', '\0' }; char str [10] = "Joao"; char str_vect [3][10] = { "Joao", "Maria", "Jose" };

Podemos, em alguns casos, inicializar matrizes das quais no sabemos o tamanho a priori. O compilador C vai, neste caso verificar o tamanho do que voc declarou e considerar como sendo o tamanho da matriz. Isto ocorre na hora da compilao e no poder mais ser mudado durante o programa

Argumentos na funo main

Na seo Funes, dissemos que a funo main() aceita dois argumentos, mas no falamos mais pois um deles envolve o conceito de vetores. Agora iremos falar mais sobre eles. Os dois argumentos de main() indicam os argumentos dados para o programa na linha de comando, na forma de um vetor de strings.

Exemplo de uso de parmetros na funo main

// somaComArgcArgv.c #include<stdio.h> #include<stdlib.h>

int main(int argc, char *argv[]) { int result; if ( argc != 3 ) { printf("Digite soma <valor1> <valor2>\n"); return 0; } // fim if ( argc != 3 ) result = atoi(argv[1]) + atoi(argv[2]); printf("\nO resultado da soma de %s e %s eh: %d\n", argv[1], argv[2], result); }

Strings

Esta pgina um esboo de informtica. Ampliando-a voc ajudar a melhorar o Wikilivros.

Strings
Strings (Ingls) so cadeias ou seqncias ordenadas de caracteres. Na verdade j trabalhamos com strings neste livro, mas preferimos deixar maiores explicaes para um momento em que j tivesse sido introduzido o conceito de vetor. A linguagem C, ao contrrio de outras linguagens de programao, no possui um tipo de dados correspondente s strings; no lugar, usam-se vetores (e ponteiros, como veremos mais adiante). Em C, strings so vetores de caracteres terminados pelo caractere nulo ('\0'). Por exemplo:
char nome[] = {'P', 'e', 'd', 'r', 'o', '\0'};

No entanto, escrever strings dessa maneira muito trabalhoso; por isso, foi criada uma notao abreviada que equivale notao acima e elimina a necessidade de colocar o caractere terminador:
char nome[] = "Pedro";

Assim como nos vetores, podemos acessar e modificar elementos individuais de uma string. Podemos tambm diminuir o tamanho de uma string: uma vez que a nica marcao do tamanho o terminador \0, colocar um terminador em outro local determinar o novo final da string. No entanto, aumentar o tamanho da string mais difcil; isso ficar para outra seo.

Ateno ao usar-se acentos numa string. Como existem diferentes formas de codificar caracteres acentuados, o tratamento de uma string do tipo:
char nome[] = "Joo";

pode ser diferente de uma mquina para outra. Neste captulo no sero tratados acentos, este assunto ser abordado mais adiante.

Funes da biblioteca padro

A biblioteca padro fornece vrias funes teis para manipular strings. A seguir mostraremos algumas delas. Para us-las, voc deve incluir o cabealho string.h no incio dos seus arquivos.

strlen
strlen

retorna o tamanho, em caracteres, de uma string dada. Na verdade o strlen() procura o terminador de string e calcula a distncia dele ao incio da string. Por exemplo:
char nome[15] = "Maria da Silva"; int s = strlen (nome); // s conter o valor 14

/*TL'*/

strcpy
strcpy

copia o contedo de uma string para outra e coloca um terminador de string. Sua sintaxe strcpy (destino, origem).
char nome[] = "Clarice Lispector"; char nome2[] = "Oswald de Andrade"; strcpy (nome, nome2); // agora nome conter "Oswald de Andrade"

Tome cuidado com strcpy(), pois se a string a ser copiada for maior que a string de destino, provavelmente voc gravar dados em lugares indesejados um problema conhecido como estouro de buffer. Para evitar esse problema, use a funo strncpy, que recebe um terceiro argumento que corresponde ao nmero mximo de caracteres a serem copiados:
char msg[] = "Bom dia!"; char nome[] = "Maria da Silva"; strncpy (msg, nome, strlen(msg)); // agora msg conter "Maria da"

strcat

strcat

concatena duas strings, adicionando o contedo da segunda ao final da primeira, alm do terminador (\0). Note que a primeira string deve ter espao suficiente para conter a segunda, para que no ocorra um "estouro de buffer". Por exemplo:
char nome[50] = "Maria"; char sobrenome[] = " da Silva"; strcat (nome, sobrenome); // agora nome contm "Maria da Silva"

Analogamente funo strncpy, existe tambm a funo strncat, onde o nmero mximo de caracteres a serem copiados o terceiro argumento.

strcmp
Se voc tentar criar duas strings com o mesmo contedo e compar-las como faria como nmeros, ver que elas "no so iguais". Isso ocorre porque, na verdade, o que est sendo comparado so os endereos de memria onde esto guardadas as strings. Para comparar o contedo de duas strings, voc deve usar a funo strcmp (ou suas variantes):

int strcmp (char *s1, char *s2);

O valor de retorno :

menor que zero se s1 for menor que s2; igual a zero se s1 e s2 so iguais; maior que zero se s1 for maior que s2.

Costuma parecer estranho dizer que uma string menor ou maior que outra; na verdade essa comparao entre a primeira letra que difere nas duas strings. Assim, se tivermos s1 = "abc" e s2 = "abd", diremos que s2 maior que s1, pois na primeira posio em que as duas strings diferem, a letra em s2 "maior". importante notar que a comparao feita por strcmp distingue maisculas de minsculas. Isto , as strings "ABC" e "abc" no so iguais para essa funo. As variantes mais usadas de strcmp so:
strncmp

- compara apenas os n primeiros caracteres das duas strings, sendo n um terceiro argumento. stricmp - compara duas strings sem distino entre maisculas e minsculas. A sintaxe igual de strcmp. Essa funo no faz parte da biblioteca padro, mas comumente encontrada como extenso particular de vrias delas.

strrchr
strrchr

Retorna um ponteiro sobre a ultima ocorrncia de c de uma string apontada por s se no retorna NULL . Sua sintaxe strrchr(const char *s, int c);. Exemplo:

char path[50] = "/teste/string"; char *p = strrchr(path, '/'); *p++; printf("Resultado: %s \n", p );

memcpy
Sintaxe:
#include <string.h> void *memcpy (void *dest, const void *srce, size_t n);

Descrio: Copiar um bloco de n octetos de srce para dest. Ateno:Se as regies de srce e dest se sobreporem o comportamento da funo imprevisvel. Valor de retorno : memcpy retorna o valor de dest . Ex:
#include <stdio.h> #include <string.h> int main() { int tab[2][5] = { { 1, 2, 3, 4, 5, {11, 12, 13, 14, 15} }; int temp[2][5]; memcpy(temp, tab, sizeof(tab)); puts("Resultado:\n"); printf("temp[1][4] = %d\n", temp[1][4]); return 0; }

memset
Sintaxe:
#include <string.h> void *memset (void *buffer, int c, size_t n);

Descrio: memset inicializa n octetos do buffer com o inteiro c. Valor de retorno : O valor do buffer. Ex:
#include <stdio.h> #include <string.h>

int main() { char buf[] = "W.I.K.I."; printf("Buf antes 'memset': %s\n", buf); memset(buf, '*', strlen(buf)); printf("Buf depois 'memset': %s\n", buf); return 0; }

sprintf
Descrio: A diferena entre printf e sprintf e que printf retorna o resultado para a sada padro (tela), enquanto sprintf retorna o resultado em uma varivel. Isto muito conveniente, porque voc pode simplesmente digitar a frase que voc quer ter e sprintf lida com a prpria converso e coloca o resultado na string que voc deseja. Sintaxe:
#include <stdio.h> int sprintf(char *s, const char *formato, ...);

Ex:
#include <stdio.h> #include <string.h> int main() { char var[256]; char sobrenome[] = "Simpson"; char nome[] = "Homer"; int idade = 30; sprintf(var, "%s %s tem %d anos",sobrenome, nome, idade); printf ("Resultado : %s\n", var); return 0; }

Ponteiros
Poderamos escrever um livro inteiro sobre ponteiros, pois o contedo demasiadamente extenso. Por esse motivo este assunto foi dividido em bsico, intermedirio e avanado, assim o leitor poder fazer seus estudos conforme suas necessidades. recomendvel para quem est vendo programao pela primeira vez aqui que no se preocupe com o avanado sobre ponteiros por enquanto.

Bsico
O que um ponteiro?
Um ponteiro simplesmente uma varivel que armazena o endereo de outra varivel. Um exemplo : O que o ponteiro de um relgio? o que aponta para as horas, minutos ou segundos. Um ponteiro aponta para algo. Em programao, temos as variveis armazenadas na memria, e um ponteiro aponta para um endereo de memria. Imagine as variveis como documentos, a memria do computador como pastas para guardar os documentos, e o ponteiro como atalhos para as pastas. No se desespere caso no consiga entender num primeiro momento, o conceito fica mais claro com a prtica.

Declarando e acessando ponteiros

Um ponteiro, como qualquer varivel, deve ter um tipo, que o tipo da varivel para a qual ele aponta. Para declarar um ponteiro, especificamos o tipo da varivel para a qual ele aponta e seu nome precedido por asterisco:
int ponteiro */ int *ponteiro ; ; /* declara uma varivel comum do tipo inteiro /* declara um ponteiro para um inteiro */

Tome cuidado ao declarar vrios ponteiros em uma linha, pois o asterisco deve vir antes de cada nome de varivel. Note os trs exemplos:
int p, q, r; // estamos a declarar trs variveis comuns int *p, q, r; // cuidado! apenas p ser um ponteiro! int *p, *q, *r; // agora sim temos trs ponteiros

Esquema de um ponteiro Para acessar o endereo de uma varivel, utilizamos o operador & (E comercial), chamado "operador de referncia" ou "operador de endereo". Como o nome sugere, ele retorna o endereo na memria de seu operando. Ele unrio e deve ser escrito antes do seu operando. Por exemplo, se uma varivel nome foi guardada no endereo de memria 1000, a expresso &nome valer 1000. Com isso, fica claro o esquema ao lado: a varivel a contm o valor 1234 e o ponteiro p contem o endereo de a (&a).

Para atribuir um valor ao ponteiro, usamos apenas seu nome de varivel. Esse valor deve ser um endereo de memria, portanto obtido com o operador &:
int a; int *p; p = &a;

Claro que tambm podemos inicializar um ponteiro:

int *p = &a;

Nos dois casos, o ponteiro p ir apontar para a varivel a. Mas, como o ponteiro contm um endereo, podemos tambm atribuir um valor varivel guardada nesse endereo, ou seja, varivel apontada pelo ponteiro. Para isso, usamos o operador * (asterisco), que basicamente significa "o valor apontado por". Ex:
int a ; int *p = &a ; *p = 20 ;

Para ver o resultado :

printf (" a :%i\n", a); printf ("*p :%i\n", *p);

Cuidado! Voc nunca deve usar um ponteiro sem antes inicializ-lo; esse um erro comum. Inicialmente, um ponteiro pode apontar para qualquer lugar da memria do computador. Ou seja, ao tentar ler ou gravar o valor apontado por ele, voc estar manipulando um lugar desconhecido na memria!
int *p; *p = 9;

Nesse exemplo, estamos a manipular um lugar desconhecido da memria! Se voc tentar compilar esse cdigo, o compilador dever dar uma mensagem de aviso; durante a execuo, provavelmente ocorrer uma falha de segmentao (erro que ocorre quando um programa tenta acessar a memria alheia). Um exemplo mais elaborado:
#include <stdio.h> int main() { int i = 10 ; int *p ; p = &i ; *p = 5 ; printf ("%d\t%d\t%p\n", i, *p, p); return 0;

Primeiramente declaramos a varivel i, com valor 10, e o ponteiro p, que apontar para o endereo de i. Depois, guardamos o valor 5 no endereo apontado por p. Se voc executar esse exemplo, ver algo parecido com:
5 5 0022FF74

claro que os valores de i e de *p sero iguais, j que p aponta para i. O terceiro valor o endereo de memria onde est i (e, consequentemente, o prprio valor de p), e ser diferente em cada sistema. Cuidado! Os operadores unrios & e * no podem ser confundidos com os operadores binrios AND bit a bit e multiplicao, respectivamente.

Ponteiro e NULL
Uma falha de segmentao ou em ingls (segmentation fault) ocorre quando um programa tenta acessar um endereo na memria que est reservado ou que no existe.Nos sistemas Unix quando acontece este tipo de erro o sinal SIGSEGV enviado ao programa indicando uma falha de segmentao. Aqui o ponteiro contem null, definido com o endereo (0x00000000) que causa uma falha de segmentao .
/*Endereo invalido*/ #define null ( (char*) 0 ) int main(void){ int a = 5; int *p = null; *p = a; }

Esse programa termina anormalmente. Voc esta tentando colocar o valor 5 em um endereo invlido. Para que isso no acontea o ponteiro deve ser inicializado com um endereo valido. Exemplo :
#include <stdio.h> #include <errno.h> #include <stddef.h> int main(void){ int a = 5; int *p = NULL; p = &a; /* A operao no permitida */

if(p == NULL) return -EPERM ; else{ printf("Endereo a disposio:%p\n", p ); *p = a; /* Pode colocar 5 */ } }

NULL est definido dentro do cabealho stddef.h . Aqui voc no espera que o programa acabe com algum tipo de mgica, se NULL igual ao valor do ponteiro isso significa que no foi encontrado nem um endereo acessvel, ento voc para. Caso contrario voc estar executando uma operao que no permitida. Ou colocar 5 em (0x00000000) .

Mais operaes com ponteiros

Suponhamos dois ponteiros inicializados p1 e p2. Podemos fazer dois tipos de atribuio entre eles:
p1 = p2;

Esse primeiro exemplo far com que p1 aponte para o mesmo lugar que p2. Ou seja, usar p1 ser equivalente a usar p2 aps essa atribuio.
*p1 = *p2;

Nesse segundo caso, estamos a igualar os valores apontados pelos dois ponteiros: alteraremos o valor apontado por p1 para o valor apontado por p2. Agora vamos dar mais alguns exemplos com o ponteiro p:
p++;

Aqui estamos a incrementar o ponteiro. Quando incrementamos um ponteiro ele passa a apontar para o prximo valor do mesmo tipo em relao ao valor para o qual o ponteiro aponta. Isto , se temos um ponteiro para um inteiro e o incrementamos, ele passa a apontar para o prximo inteiro. Note que o incremento no ocorre byte-abyte!
(*p)++;

Aqui, colocamos *p entre parnteses para especificar que queremos alterar o valor apontado por p. Ou seja, aqui iremos incrementar o contedo da varivel apontada pelo ponteiro p.
*p++

Neste caso, o efeito no to claro quanto nos outros exemplos. A precedncia do operador ++ sobre o operador * faz com que a expresso seja equivalente a (*p)++. O valor atual de p retornado ao operador *, e o valor de p incrementado. Ou seja, obtemos o valor atual do ponteiro e j o fazemos apontar para o prximo valor.

x = *(p + 15);

Esta linha atribui a uma varivel x o contedo do dcimo-quinto inteiro adiante daquele apontado por p. Por exemplo, suponhamos que tivssemos uma srie de variveis i0, i1, i2, i15 e que p apontasse para i0. Nossa varivel x receberia o valor de i15. Tente acompanhar este exemplo dos dois tipos de atribuio de ponteiros:
int *a, *b, c = 4, d = 2; a = &c; // a apontar para c b = &d; // b apontar para d *b = 8; // altero o valor existente na variavel d *a = *b; // copio o valor de d (apontado por b) // para c (apontado por a) *a = 1; // altero o valor da varivel c b = a; // b aponta para o mesmo lugar que a, // ou seja, para c *b = 0; // altero o valor de c

Intermedirio
Ponteiro de estrutura
Para comear e deixar mais claro definimos uma estrutura simples com dois campos.
struct { int i; double f; } minha_estrutura;

O passo seguinte definir um ponteiro para essa estrutura.

struct minha_estrutura *p_minha_estrutura;

A partir do ponteiro podemos ter acesso a um campo da estrutura usando um seletor ">" (uma flecha).
p_minha_estrutura-> i = 1; p_minha_estrutura-> f = 1.2;

O mesmo resultado pode ser optido da seguinte forma.

(*p_minha_estrutura).i = 1; (*p_minha_estrutura).f = 1.2;

O operador cast tambm e bastante utilizado para estruturar reas de estoque temporrios (buffer). Os tipos dentro da estrutura devem ser o mesmo do arranjo para evitar problemas de alinhamento. A seguir um pequeno exemplo:
#include <stdio.h> typedef struct estruturar{

char a ; char b ; }; int main() { char buffer[2] = {17, 4}; estruturar *p; p = (struct estruturar*) &buffer; printf("a: %i b: %i", p->a,p->b); getchar(); return 0; }

Ponteiros como parmetros de funes

Comecemos por uma situao-problema: eu tenho 2 variveis e quero trocar o valor delas. Vamos comear com um algoritmo simples, dentro da funo main():
#include <stdio.h> int main() { int a = 5, b = 10, temp; printf ("%d %d\n", a, b); temp = a; a = b; b = temp; printf ("%d %d\n", a, b); return 0; }

Esse exemplo funcionar exatamente como esperado: primeiramente ele imprimir "5 10" e depois ele imprimir "10 5". Mas e se quisermos trocar vrias vezes o valor de duas variveis? muito mais conveniente criar uma funo que faa isso. Vamos fazer uma tentativa de implementao da funo swap (troca, em ingls):
#include <stdio.h> void swap(int i, int j) { int temp; temp = i; i = j; j = temp; } int main() { int a, b; a = 5;

b = 10; printf ("%d %d\n", a, b); swap (a, b); printf ("%d %d\n", a, b); return 0; }

No entanto, o que queremos no ir acontecer. Voc ver que o programa imprime duas vezes "5 10". Por que isso acontece? Lembre-se do escopo das variveis: as variveis a e b so locais funo main(), e quando as passamos como argumentos para swap(), seus valores so copiados e passam a ser chamados de i e j; a troca ocorre entre i e j, de modo que quando voltamos funo main() nada mudou. Ento como poderamos fazer isso? Como so retornados dois valores, no podemos usar o valor de retorno de uma funo. Mas existe uma alternativa: os ponteiros!
#include <stdio.h> void swap (int *i, int *j) { int temp; temp = *i; *i = *j; *j = temp; } int main () { int a, b; a = 5; b = 10; printf ("\n\nEles valem %d, %d\n", a, b); swap (&a, &b); printf ("\n\nEles agora valem %d, %d\n", a, b); return 0; }

Neste exemplo, definimos a funo swap() como uma funo que toma como argumentos dois ponteiros para inteiros; a funo faz a troca entre os valores apontados pelos ponteiros. J na funo main(), passamos os endereos das variveis para a funo swap(), de modo que a funo swap() possa modificar variveis locais de outra funo. O nico possvel inconveniente que, quando usarmos a funo, teremos de lembrar de colocar um & na frente das variveis que estivermos passando para a funo. Se voc pensar bem, j vimos uma funo em que passamos os argumentos precedidos de &: a funo scanf()! Por que fazemos isso? simples: chamamos a funo scanf() para que ela ponha nas nossas variveis valores digitados pelo usurio. Ora, essas variveis so locais, e portanto s podem ser alteradas por outras funes atravs de ponteiros! Quando uma funo recebe como parmetros os endereos e no os valores das variveis, dizemos que estamos a fazer uma chamada por referncia; o caso desse ltimo exemplo. Quando passamos diretamente os valores das variveis para uma funo, dizemos que uma chamada por valor; foi o caso do segundo exemplo.

Ponteiros e vetores
Em C, os elementos de um vetor so sempre guardados sequencialmente, a uma distncia fixa um do outro. Com isso, possvel facilmente passar de um elemento a outro, percorrendo sempre uma mesma distncia para frente ou para trs na memria. Dessa maneira, podemos usar ponteiros e a aritmtica de ponteiros para percorrer vetores. Na verdade, vetores so ponteiros um uso particular dos ponteiros. Acompanhe o exemplo a seguir.
#include <stdio.h> int main () { int i; int vetorTeste[3] = {4, 7, 1}; int *ptr = vetorTeste; printf("%p\n", vetorTeste); printf("%p\n", ptr); printf("%p\n", &ptr); for (i = 0; i < 3; i++) { printf("O endereo do ndice %d do vetor %p\n", i, &ptr[i]); printf("O valor do ndice %d do vetor %d\n", i, ptr[i]); } return 0; }

Comeamos declarando um vetor com trs elementos; depois, criamos um ponteiro para esse vetor. Mas repare que no colocamos o operador de endereo em vetorTeste; fazemos isso porque um vetor j representa um endereo, como voc pode verificar pelo resultado da primeira chamada a printf(). Como voc j viu anteriormente neste captulo, podemos usar a sintaxe *(ptr + 1) para acessar o inteiro seguinte ao apontado pelo ponteiro ptr. Mas, se o ponteiro aponta para o vetor, o prximo inteiro na memria ser o prximo elemento do vetor! De fato, em C as duas formas *(ptr + n) e ptr[n] so equivalentes. No necessrio criar um ponteiro para usar essa sintaxe; como j vimos, o vetor em si j um ponteiro, de modo que qualquer operao com ptr ser feita igualmente com vetorTeste. Todas as formas abaixo de acessar o segundo elemento do vetor so equivalentes:
vetorTeste[1]; *(vetorTeste + 1); ptr[1]; *(ptr + 1)

Veja mais este exemplo:

#include <stdio.h>

int main() { int numbers[5]; int *p; int n; p = numbers; *p = 10; p++; *p = 20; p = &numbers[2]; *p = 30; p = numbers + 3; *p = 40; p = numbers; *(p + 4) = 50; for (n = 0; n < 5; n++) cout << numbers[n] << ", "; return 0; }

Ele resume as vrias formas de acessar elementos de um vetor usando ponteiros.

Indexao estranha de ponteiros

o C permite fazer um tipo indexao de um vetor quando uma varivel controla seu ndice. O seguinte cdigo vlido e funciona: Observe a indexao vetor[i].
#include <stdio.h> int main () { int i; int vetor[10]; for (i = 0; i < 10; i++) { printf ("Digite um valor para a posicao %d do vetor: ", i + 1); scanf ("%d", &vetor[i]); //isso equivalente a fazer *(x + i) } for (i = 0; i < 10; i++) printf ("%d\n", vetor[i]); return (0); }

Essa indexao, apesar de estranha, funciona corretamente e sem aviso na compilao. Ela prtica, mas, para os iniciantes, pode parecer complicada. s treinar para entender.

Comparando endereos
Como os endereos so nmeros, eles tambm podem ser comparados entre si. Veja o exemplo a seguir, com efeito equivalente ao primeiro exemplo da seo anterior:
#include <stdio.h>

int main() { int vetorTeste[3] = {4, 7, 1}; int *ptr = vetorTeste; int i = 0; while (ptr <= &vetorTeste[2]) { printf("O endereo do ndice %d do vetor %p\n", i, ptr); printf("O valor do ndice %d do vetor %d\n", i, *ptr); ptr++; i++; } return 0; }

Esse programa incrementa o ponteiro enquanto esse endereo for igual (ou menor) ao endereo do ltimo elemento do vetor (lembre-se que os ndices do vetor so 0, 1 e 2).

Avanado
Este mdulo precisa ser revisado por algum que conhea o assunto (discuta).

Este mdulo tem a seguinte tarefa pendente: mover o que de C++ para o livro de C++

Ponteiros para ponteiros

Acompanhe este exemplo:
char a; char *b; char **c; a = b = c = **c 'z'; &a; &b; = 'M';

#include <stdlib.h> #include<stdio.h> int int int int int vInt = 10; *pInt = &vInt; **pInt2 = &pInt; ***pInt3 = &pInt2; x=0;

int main(void){ printf("+-----------------+\n"); printf("| vInt |\n"); printf("+-----------------+\n"); printf("|%17d|\n",vInt);

printf("|%17p|<-+\n",&vInt); printf("+-----------------+ |\n"); printf("| pInt | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt); printf("|%17p|<-+\n",&pInt); printf("|%17d| |\n",*pInt); printf("+-----------------+ |\n"); printf("| pInt2 | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt2); printf("|%17p|<-+\n",&pInt2); printf("|%17d| |\n",**pInt2); printf("+-----------------+ |\n"); printf("| pInt3 | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt3); printf("|%17p|\n",&pInt3); printf("|%17d|\n",***pInt3); printf("+-----------------+\n"); ***pInt3 = 76; printf("+-----------------+\n"); printf("| vInt |\n"); printf("+-----------------+\n"); printf("|%17d|\n",vInt); printf("|%17p|<-+\n",&vInt); printf("+-----------------+ |\n"); printf("| pInt | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt); printf("|%17p|<-+\n",&pInt); printf("|%17d| |\n",*pInt); printf("+-----------------+ |\n"); printf("| pInt2 | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt2); printf("|%17p|<-+\n",&pInt2); printf("|%17d| |\n",**pInt2); printf("+-----------------+ |\n"); printf("| pInt3 | |\n"); printf("+-----------------+ |\n"); printf("|%17p|--+\n",pInt3); printf("|%17p|\n",&pInt3); printf("|%17d|\n",***pInt3); printf("+-----------------+\n"); // importante ressaltar que o valor de vInt foi modificado pois a indireo mltipla a modoficou. printf("+---------------------------------------------------------------+"); printf("| PROGRAMA FEITO POR : DANIEL CAMPOS DINIZ dinizdc@gmail.com |\n"); printf("+---------------------------------------------------------------+"); return 0; }

Perceba que temos dois "nveis": c aponta para b, e b aponta para a. Assim, para acessar a usando o ponteiro c, necessrio usar duas vezes o operador *: uma para obter o valor de b (cujo endereo est guardado em c), e a outra para obter o valor de a, apontado por b. Uma aplicao de ponteiros para ponteiros est nas strings, j que strings so vetores, que por sua vez so ponteiros. Um vetor de strings seria justamente um ponteiro para um ponteiro.

Este mdulo tem a seguinte tarefa pendente: Criar cdigo exemplo sobre ponteiro para ponteiro

Passando vetores como argumentos de funes

Os ponteiros podem ser passados como argumentos de funes. Parmetro ponteiro passando um array.
#include <stdio.h> void atribuiValores(int[], int); void mostraValores(int[], int); int main() { int vetorTeste[3]; // crio um vetor sem atribuir valores atribuiValores(vetorTeste, 3); mostraValores(vetorTeste, 3); return 0; } void atribuiValores(int valores[], int num) { for (int i = 0; i < num; i++) { printf("Insira valor #%d: ", i + 1); scanf("%d", &valores[i]); } } void mostraValores(int valores[], int num) { for (int i = 0; i < num; i++) { printf("Valor #%d: %d\n", i + 1, valores[i]); } }

Repare que passamos dois parmetros para as funes:

1. O "nome" do vetor, que representa o seu endereo na memria. (Temos 3 maneiras para passar o endereo do vetor: diretamente pelo seu "nome", via um ponteiro ou pelo endereo do primeiro elemento.) 2. Uma constante, que representa o nmero de elementos do vetor. Isso importante pois o C no guarda informaes sobre o tamanho dos vetores; voc no deve tentar alterar ou acessar valores que no pertencem ao vetor. claro que devemos passar o endereo do vetor (por "referncia"), pois os seus valores so alterados pela funo atribuiValores. De nada adiantaria passar o vetor por valor, pois o valor s seria alterado localmente na funo (como j vimos no caso de troca do valor de duas variveis). Por causa dessa equivalncia entre vetores e ponteiros, podemos fazer uma pequena alterao no prottipo (tanto na declarao quanto na definio) das funes atribuiValores e mostraValores, sem precisar alterar o cdigo interno dessas funes ou a chamada a elas dentro da funo main ? trocando
void atribuiValores(int[], int); void mostraValores(int[], int);

por
void atribuiValores(int*, int); void mostraValores(int*, int);

Para o compilador, voc no fez mudana alguma, justamente por conta dessa equivalncia. Em ambos os casos, foi passado o endereo do vetor para as funes.

Ponteiros para funes

Os ponteiros para funes servem, geralmente, para passar uma funo como argumento de uma outra funo. Neste exemplo
#include <stdio.h> int soma(int a, int b) { return (a + b); } int operacao(int x, int y, int (*func)(int,int)) { int g; g = (*func)(x, y); return (g); } int main () { int m; m = operacao(7, 5, soma); printf("%d\n", m); return 0; }

Veja que criamos uma funo que retorna a soma dos dois inteiros a ela fornecidos; no entanto, ela no chamada diretamente. Ela chamada pela funo operacao, atravs de um ponteiro. A funo main passa a funo soma como argumento para operacao, e a funo operacao chama essa funo que lhe foi dada como argumento. Note bem o terceiro argumento da funo operacao: ele um ponteiro para uma funo. Nesse caso, ele foi declarado como um ponteiro para uma funo que toma dois inteiros como argumentos e retorna outro inteiro. O * indica que estamos declarando um ponteiro, e no uma funo. Os parnteses em torno de *func so essenciais, pois sem eles o compilador entenderia o argumento como uma funo que retorna um ponteiro para um inteiro. A forma geral para declarar um ponteiro para uma funo :
tipo_retorno (*nome_do_ponteiro)(lista de argumentos)

Para chamar a funo apontada pelo ponteiro, h duas sintaxes. A sintaxe original
(*nome_do_ponteiro)(argumentos);

Se ptr um ponteiro para uma funo, faz bastante sentido que a funo em si seja chamada por *ptr. No entanto, a sintaxe mais moderna permite que ponteiros para funes sejam chamados exatamente da mesma maneira que funes:
nome_do_ponteiro(argumentos);

Por fim, para inicializar um ponteiro para funo, no precisamos usar o operador de endereo (ele j est implcito). Por isso, quando chamamos a funo operacao, no precisamos escrever &soma. Veja mais um exemplo na verdade, uma extenso do exemplo anterior:
#include <stdio.h> int soma(int a, int b) { return (a+b); } int subtracao(int a, int b) { return (a-b); } int (*menos)(int, int) = subtracao; int operacao(int x, int y, int (*func)(int,int)) { int g; g = func(x, y); return (g); } int main()

{ int m, n; m = operacao(7, 5, soma); n = operacao(20, m, menos); printf("%d\n", n); return 0; }

Aqui, criamos mais uma funo, subtracao, alm de criar um outro ponteiro para ela (uma espcie de "atalho"), menos. Na funo main, referimo-nos funo de subtrao atravs desse atalho. Veja tambm que aqui usamos a sintaxe moderna para a chamada de ponteiros de funes, ao contrrio do exemplo anterior.

Passagem de Parametros
Esta pgina foi marcada para eliminao rpida e ser eliminada assim que um administrador confirmar a validade da marcao conforme as polticas. Razo: Redirecionamento sem necessidade Observador: Abacaxi (Discusso) 00h20min de 25 de maio de 2013 (UTC)

Tipos de dados definidos pelo usurio

Tipos de dados definidos pelo usurio
Muitas vezes necessrio manipular dados complexos que seriam difceis de representar usando apenas os tipos primitivos (char, int, double, float). Para isso, h, em C, trs tipos de dados que podem ser definidos pelo usurio:

estruturas (struct); unies (union); enumeraes (enum).

As estruturas e unies so compostas por vrias variveis (escolhidas pelo programador), por isso so ditos definidos pelo usurio. J as enumeraes so, resumidamente, tipos cujos valores devem pertencer a um conjunto definido pelo programador.

Estruturas
Uma estrutura (ou struct) um tipo de dados resultante do agrupamento de vrias variveis nomeadas, no necessariamente similares, numa s; essas variveis so

chamadas membros da estrutura. Para declarar uma estrutura, usamos a palavra-chave struct, seguida do nome que se deseja dar estrutura (ao tipo de dados) e de um bloco contendo as declaraes dos membros. Veja um exemplo:
struct mystruct { int a, b, c; double d, e, f; char string[25]; };

Este exemplo cria um tipo de dados denominado mystruct, contendo sete membros (a, b, c, d, e, f, string). Note que o nome mystruct o nome do tipo de dados, no de uma varivel desse tipo. Um exemplo simples de aplicao de estruturas seria uma ficha pessoal que tenha nome, telefone e endereo; a ficha seria uma estrutura. Ou, mais amplamente, uma estrutura seria uma representao de qualquer tipo de dado definido por mais de uma varivel. Por exemplo, o tipo FILE* na verdade um ponteiro para uma estrutura que contm alguns dados que o sistema usa para controlar o acesso ao fluxo/arquivo. No necessrio, para a maioria dos programadores, conhecer a estrutura do tipo FILE.

Definindo o tipo
A definio de um tipo de estrutura feita com a palavra-chave struct, seguida do nome a ser dado ao tipo e de um bloco contendo as declaraes dos elementos da estrutura:
struct nome_do_tipo { tipo_elem a; tipo_elem b, c; ... };

muito importante incluir o ponto-e-vrgula ao final do bloco!

Declarando
Para declarar uma varivel de um tipo j definido, fornecemos o nome do tipo, incluindo a palavra-chave struct:
struct nome_do_tipo variavel;

Tambm possvel condensar a definio do tipo e a declarao em um passo, substituindo o nome do tipo pela definio, sem o ponto-e-vrgula:
struct mystruct { int a, b, c; double d, e, f;

char string[25]; } variavel;

Tambm possvel inicializar uma estrutura usando as chaves {} para envolver os elementos da estrutura, separados por vrgulas. Os elementos devem estar na ordem em que foram declarados, mas no obrigatrio inicializar todos; no entanto, para inicializar um elemento, todos os anteriores devem ser inicializados tambm. Por exemplo, poderamos declarar valores iniciais para a varivel acima da seguinte maneira:
struct mystruct variavel = {4, 6, 5, 3.14, 2.718, 0.95, "Teste"}; struct mystruct v2 = {9, 5, 7};

Inicializador designado
Para quem usa o C99 com o compilador GNU. Durante a inicializao de um estrutura possvel especificar o nome do campo com '.nome_do_campo =' antes do valor. Exemplo:
struct mystruct v2 = {.a=9,.b=5,.c=7};

Acessando
Para acessar e modificar os membros de uma estrutura, usamos o operador de seleo. (ponto). esquerda do ponto deve estar o nome da varivel (estrutura) e direita, o nome do membro. Podemos usar os membros como variveis normais, inclusive passando-os para funes como argumentos:
variavel.a = 5; variavel.f = 6.17; strcpy (variavel.string, "Bom dia"); printf ("%d %f %s\n", variavel.a, variavel.f, variavel.string);

Vetores de estruturas
Sendo as estruturas como qualquer outro tipo de dados, podemos criar vetores de estruturas. Por exemplo, suponha algum programa que funcione como um servidor e permita at 10 usurios conectados simultaneamente. Poderamos guardar as informaes desses usurios num vetor de 10 estruturas:
struct info_usuario { int id; char nome[20]; long endereco_ip; time_t hora_conexao; }; struct info_usuario usuarios[10];

E, por exemplo, para obter o horrio em que o 2 usurio usurio se conectou, poderamos escrever usuarios[1].hora_conexao.

Atribuio e cpia

Podemos facilmente copiar todos os campos de uma estrutura para outra, fazendo uma atribuio simples como a de inteiros:
struct int int }; ... struct struct b = a; // agora o ponto b tambm tem coordenadas (2, 3) ponto { x; y; ponto a = {2, 3}; ponto b = {5, 8};

No entanto, devemos ter cuidado se a estrutura contiver campos ponteiros, pois, nesses casos, o que ser copiado o endereo de memria (e no o contedo daquele endereo). Por exemplo, se tivermos uma estrutura que comporta um inteiro e uma string, uma cpia sua conter o mesmo inteiro e um ponteiro para a mesma string, o que significa que alteraes na string da cpia sero refletidas tambm no original!

Passando para funes

J vimos acima que podemos normalmente passar membros de uma estrutura como argumentos de funes. Tambm possvel passar estruturas inteiras como argumentos:
#include <stdio.h> struct ponto { int x; int y; }; void imprime_ponto (struct ponto p) { printf ("(%d, %d)\n", p.x, p.y); } int main () { struct ponto a = {3, 7}; imprime_ponto (a); return 0; }

No entanto, h dois possveis problemas nisso:

Alteraes nos membros da estrutura s tero efeito dentro da funo chamada, mas no na funo que a chamou. Isso ocorre pois a estrutura passada por valor (e no por referncia). Quando a estrutura contiver muitos elementos, a passagem por valor tornar-se- um processo de cpia de muitos dados. Por isso, de costume passar estruturas por referncia (como ponteiros), mesmo que a estrutura em questo seja pequena.

Unies
Unies so parecidas com estruturas, mas h uma diferena fundamental: nas unies, todos os elementos ocupam o mesmo espao de memria. Por isso, s possvel acessar um elemento por vez, j que uma mudana em um elemento causar mudana em todos os outros. A definio e a declarao de unies igual das estruturas, trocando a palavra struct por union. H principalmente dois usos para as unies:

economia de espao, j que guardam-se vrias variveis no mesmo espao; representao de uma informao de mais de uma maneira. Um exemplo disso so os endereos IP, que na biblioteca de sockets podem ser representados como um grupo de 4 octetos (char) ou como um nico valor inteiro (int). Isso feito com uma unio parecida com esta:
union ip_address { int s_long; char s_byte[4]; };

Dessa maneira, o endereo pode ser facilmente representado de maneira humanamente legvel (com 4 octetos), sem dificultar o processamento interno (com o valor inteiro).

Enumeraes
Enumerao (enum) ou tipo enumerado um tipo de dados que tem como conjunto de valores possveis um conjunto finito de identificadores (nomes) determinados pelo programador. Em C, cada identificador em uma enumerao corresponde a um inteiro. Enumeraes so definidas de maneira similar s estruturas e unies, com algumas diferenas. A palavra chave usada enum.
enum nome_enumerao { IDENTIFICADOR_1, IDENTIFICADOR_2, ... IDENTIFICADOR_n };

Note as diferenas: no h ponto-e-vrgula no final ou no meio das declaraes (mas ainda h no final do bloco), e no h declarao de tipos. Com essa declarao, ao IDENTIFICADOR_1 ser atribuido o valor 0, ao IDENTIFICADOR_2 ser atribudo o valor 1, e assim por diante. Podemos tambm explicitar os valores que quisermos colocando um sinal de igual e o valor desejado aps o identificador.

Caso no haja valor determinado para o primeiro identificador, ele ser zero. Para os demais identificadores, o padro seguir a ordem dos nmeros, a partir do valor do identificador anterior. Podemos misturar identificadores de valor determinado com identificadores de valor implcito, bastando seguir a regra acima.

Por exemplo:
enum cores { VERMELHO, AZUL = 5, VERDE, AMARELO, MARROM = 10 }; /* /* /* /* /* 0 */ 5 */ 6 */ 7 */ 10 */

Uso
Da mesma maneira que criamos uma varivel de um tipo struct ou union, podemos criar variveis de um tipo enumerado (enum):
enum cores cor_fundo;

Para atribuir valores a uma varivel enumerada, podemos usar como valor tanto o identificador quanto o valor correspondente. Seriam equivalentes, portanto:
cor_fundo = VERDE; cor_fundo = 6;

Na verdade, variveis enumeradas agem de maneira quase igual aos inteiros; possvel, assim, atribuir valores que no correspondem a nenhum dos identificadores.

Campo de bits
Na linguagem c o campo de bits (bitfields) uma estrutura um pouco estranha , em vez de usar variveis com tipos diferentes os campos so formados com as partes de um inteiro. O tamanho de um campo de bits no pode ser maior que o tipo usado , aqui um short .
typedef struct { unsigned campo_1: campo_2: campo_3: campo_4: campo_5: }BIT_FIELD_1;

short 6, /* Tamanho 6 bit */ 6, 1, 1, 2;

Essa estrutura esta formada por um tipo que tem o tamanho de um short esse mesmo tipo ser divido em pores menores. No exemplo acima os campos tem os tamanhos

6,6,1,1,2 igual a 16 bits que o tamanho de um unsigned short . Para acessar os campos usamos o mesmo mtodo que usamos com estruturas normais .
BIT_FIELD_1 meu_campo; meu_campo.campo_1 = 16; meu_campo.campo_4 = 0;

Enumerao
Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Enumerations (enum)
Aqui vamos retornar a um tpico antigo. Enumerations so um outro mtodo de definir constantes. Recordam-se? Tnhamos o: 1. #define 2. const int a = 1; 3. enumerations.

Criando um novo tipo de dados

As enumerations definem um nova tipo de varivel e limita desde logo os valores.
enum colors {black, blue, green, cyan, red, purple, yellow, white};

A maneira mais simples de interpretar uma enumeration imagina-la como uma matriz de apenas uma linha. Temos o nome da linha de temos as vrias clulas na linha. Cada constante enumerada (muitas vezes chamado de enumerator) tem um valor inteiro (caso no seja especificado ele comea em zero) Exemplo: black blue green cyan purple yellow white 0 1 2 3 4 5 6

Mas podemos definir o valor tipo

enum forma {quadrado=5, rectangulo,triangulo=27, circulo, elipse}

ficaramos com a nossa linha do tipo: Quadrado Rectngulo Triangulo Circulo Elipse 5 6 27 28 29 reparem nos valores dos nmeros. A vantagem em termos enumeraes que se uma varivel declarada tipo enumerao, tem um tipo nico e os seus valores esto limitados e podero ser verificados durante a compilao. tal como as estruturas criar tipos de variveis.
#include <stdio.h> /*Definindo o cabealho*/ enum cores { AZUL = 1, VERDE, BRANCO, }; /*Aqui um ponto virgula*/ /*typedef transformamos 2 palavras em uma -> tipo_cores*/ typedef enum cores tipo_cores ; /*A funo default da lib ou glibc*/ int main(void) { /*Agora usando o nosso novo tipo * Aqui sem typedef teramos que colocar enum cores */ tipo_cores cor = VERDE ; if(cor == 1) { printf("Cor azul \n"); } if(cor == 2) { printf("Cor verde \n"); } /* printf no ser executado */ if(cor == 3 ) { printf("Cor branco \n"); } return 0 ; /*De um enter depois de } para evitar warning */ }

Aqui podemos ver um exemplo com uma funo "mostrarRes()" e um switch: Em este exemplo uma constante e definida e o valor das outra ser definido automaticamente.
#include <stdio.h>

#include <stdlib.h> void mostrarRes(int quem); /*Aqui os valores Italia = 4 e Brasil = 5 so incrementados automaticamente*/ enum { ARGENTINA = 3, ITALIA, BRASIL }; int main(void) { /*Colocamos 5 se voc for Argentino coloque 3 */ int n = BRASIL ; mostrarRes(n); } void mostrarRes(int quem) { switch(quem) { case BRASIL ); break; case ARGENTINA : printf("Argentina um dia quem sabe\n") ; break; case ITALIA ; break; default : printf("Se estou vivo teve erro do sistema xx \n") ; } printf("The end , hasta la vista\n \n"); /*De um enter depois de } para evitar warning */ } : printf("Foi sorte\n")

: printf( "Brasil invencvel como de costume\n"

Unio
Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Unions
As unions so muito parecidas com as estruturas, estas guardam variveis de vrios tipos, e portanto guardam cada varivel de acordo com a seu tipo, ie, se tivermos uma varivel membro que um int e outro float, ela guarda exatamente de acordo com esse tipo. O que se passa aqui que vai guardar as variveis todas com um nico tipo, que aquele que ocupa mais espao dentro dos tipos das variveis membro, ou seja, se

tivermos uma varivel membro int e outra float , a union vai guardar estas variveis como fossem as duas float.

Declarao
union mytypes_t { int i; float f; } mytypes;

Unions com estruturas

Neste exemplo temos unions e estruturas misturados.
union mix_t { long l; struct { short hi; short lo; } s; char c[4]; } mix;

mytypes_t long l Struct Char C[4] mix Repare que a estrutura no tem nome

Anonymous unions estruturas com unions

// estrutura usando "regular union" struct { char title[50]; char author[50]; union { float dollars; int yens; } price; } book; // estrutura usando "anonymous union" struct { char title[50]; char author[50]; union { float dollars; int yens; }; } book;

Se declararmos uma unio sem nome, ela vai ficar annima e poderemos acessar seus membros diretamente atravs dos nomes dos membros.
// Uso regular book.price.dollars book.price.yens // Uso anonimo book.dollars book.yens

Estruturas
Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Structures
As stuctures permitem com que possamos ter variveis de vrios tipos aglomerados sob o mesmo nome. E esse mesmo nome vai passar a ser um novo tipo de dados tal como o int ou float. Mas o uso disto que podemos ter valores que tenham alguma relao lgica, por exemplo guardar um int de idade e um string de nome. Isto pode ser atributos de uma pessoa. Ou seja podemos empacotar vrias variveis de vrios tipos com o objetivo de representar o mundo real e dar um nome a essas variveis todas. Ao fazer isto crimos um tipo de dados da mesma forma como fazemos em relao ao int ou ao float.

Declarar uma estrutura

A sintaxe :
struct <identificador> { <tipo> campo_um ; <tipo> campo_dois ; };

Aqui o tipo struct indica que vamos criar uma estrutura. O nome ou identificador pode ser alunos, famlia, etc . (tm de ser vlidos identifiers) No esquecer o ponto e vrgula ; no fim da declarao. Campo_um e Campo_dois so variveis membro member variables ou campo da estrutura. Assim criamos novos tipos de dados. Primeiro mtodo:
struct minha_estrutura {

int variavel_um; int campo_dois; char fruta[40]; } ;

Aqui o identificador do tipo "struct" "minha_estrutura" dentro dessa estrutura temos trs campos o ultimo "fruta" Agora podemos usar esse tipo "struct" para definir variveis.
struct minha_estrutura nova_estructura;

Para ter acesso aos membros definidos dentro da estrutura utilizamos um operador de seleao de membro "."(um ponto).
nova_estrutura.fruta[0];

Nos d o primeiro caracter da palavra contida dentro do membro "fruta". Para inicializar um campo da estrutura o processo o mesmo que usamos com as variveis.
nova_estrutura.campo_dois = 100;

Matrizes de estruturas
Uma estrutura como qualquer outro tipo de dado no C. Podemos, portanto, criar matrizes de estruturas. Vamos ver como ficaria a declarao de um vetor de 100 fichas pessoais:
struct minha_estrutura fichas [100];

Poderamos ento acessar um campo dando um ndice do vetor fichas:

fichas[12].variavel_um;

Declarar instncias (objetos) da estrutura

Podemos declarar os objetos de duas formas:

Ao mesmo tempo que declaramos a estrutura

struct product { int weight; float price; } apple, banana, melon;

Ou como uma varivel normal

struct product { ..

} int main() { struct product apple, banana, melon; }

E at podemos declarar um array delas

Person p[20];

Pergunta: como que feito exatamente os objetos? Para cada objeto vo ser feito uma cpia dos elementos da estrutura. Agora isso significa que os objetos so distintos entre si em termos de reserva de memria? ie, medida que enumero os objetos vo ser reservado para cada objeto o tamanho x de bytes? ou somam-se todos os objetos e reserva-se para todos os objetos de uma forma seguida? Penso que deve ser a 1 opo. Se tivermos apenas um objeto (ou varivel da estrutura) no necessrio darmos o nome da estrutura
struct { char item[40]; // name of item double cost; // cost double retail; // retail price int on_hand; // amount on hand int lead_time; // number of days before resupply } temp;

Acessar as variveis membro das estruturas

Agora queremos dar valores a cada uma das pessoas, queremos dar o nome e a altura, para isso faramos;
strcpy(p1.name, "Tiago"); p1.altura =1.9;

A forma genrica :
structure-varname.member-name

ou seja
[objecto_estrutura][member_estrutura]

Exemplo
#include <stdio.h> const int MAX = 3; struct Person { char name[100];

int height; }; int main () { Person p[MAX]; for (int x = 0; x < MAX; x++) { printf("Enter person's name: "); getline(cin, p[x].name); printf("Enter height in meters: "); scanf("%d\n", &p[x].height); } printf("Outputting person data\n"); printf("======================\n"); for (int x = 0; x < MAX; x++){ printf("Person #%d's name is %s and height is %d.\n", x + 1, p[x].name, p[x].height); } return 0; }

Iniciar uma estrutura

Podemos iniciar uma estrutura usando uma lista de iniciao, que seria algo como:
Person p1 = {"Jeff Kent", 72};

isto basicamente igual a arrays, apenas com a diferena de termos tipos diferentes. Logo a ordem vai interessar, por exemplo se escrevssemos
Person p1 = {72, "Jeff Kent"}; compilao //no iria funcionar- erro de

Ponteiros para estruturas

struct movies_t { string title; int year; }; movies_t amovie; movies_t * pmovie;

Ns crimos algo
movies_t amovie * pmovie title year

Vejamos que temos um ponteiro como instncia.

// pointers to structures #include <stdio.h>

struct movies_t { char title[100]; int year; }; int main () { string mystr; movies_t amovie; movies_t *pmovie; pmovie = &amovie;

//atribumos valor ao ponteiro //operador ->

printf("Enter title: "); fgets(pmovie->title, 100, stdin); printf("Enter year: "; scanf("%d", &pmovie->year);

printf("\nYou have entered:\n"); printf("%s (%d)\n", pmovie->title, pmovie->year); //operador -> return 0; }

Como j devem ter deduzido o operador -> ser muito similar a pmovie->title equivalente a (*pmovie).title Mas olhem que diferente a:
*pmovie.title que equivalente a *(pmovie.title)

Passando estruturas com argumento do funes

A estrutura passada como ponteiro.
#include <stdio.h> struct Person { string name; int height; }; void setValues(Person*); void getValues(const Person*); int main () { Person p1; setValues(&p1); printf("Outputting person data\n"); printf("======================\n"); getValues(&p1); return 0; } void setValues(Person* pers) { printf("Enter person's name: ");

fgets(pers.name, 100, stdin); printf("Enter height in inches: "); scanf("%d", &pers.height); } void getValues(const Person* pers) { printf("Person's name is %s and height is %d.", pers.name, pers.height); }

Estruturas aninhadas
A ideia ter uma estrutura dentro de outra estrutura.
#include <stdio.h> struct Date //estrutura chamada de date { int day; int month; int year; }; struct Person { char name[100]; int height; Date bDay; //temos uma nova varivel, mas notem o tipo }; void setValues(Person*); void getValues(const Person*); int main () { Person p1; setValues(&p1); printf("Outputting person data\n"); printf("======================\n"); getValues(&p1); return 0; } void setValues(Person* pers) { printf("Enter person's name: "); fgets(pers.name, 100, stdin); printf("Enter height in inches: "); scanf("%d", &pers.height); printf("Enter day, month and year of birthday separated by spaces: "); scanf("%d %d %d\n", &pers.bDay.day, &pers.bDay.month, &pers.bDay.year ); } void getValues(const Person* pers) { printf("Person's name: %s\n", pers.name); printf("Person's height in inches is: %d\n", pers.height);

printf("Person's birthday in dd/mm/yyyy format is: %d/%d/%d\n", pers.bDay.day, pers.bDay.month, pers.bDay.year ); }

Reparem que a estrutura Date tem de ser declarada antes da estrutura Person, pois caso contrrio o compilador no entenderia o tipo declarado na estrutura Person.

Pergunta: Por que no podemos acrescentar mais membros (campos) nas estruturas? Porque elas so compiladas estaticamente com posio de memria j alocada e tipo j conhecido em tempo de compilao Pergunta: Ao invs de termos apenas variveis nas estruturas, poderamos ter tambm funes? Sim, como ponteiros para funes.

Mais sobre variveis

Este mdulo precisa ser revisado por algum que conhea o assunto (discuta).

typedef
A instruo typedef serve para definir um novo nome para um certo tipo de dados intrnseco da linguagem ou definido pelo usurio. Por exemplo, se fizssemos a seguinte declarao:
typedef unsigned int uint;

poderamos declarar variveis inteiras sem sinal (unsigned int) da seguinte maneira:
uint numero; // equivalente a "unsigned int numero;"

Como exemplo vamos dar o nome de inteiro para o tipo int:

typedef int inteiro;

Como se v, typedef cria uma espcie de "apelido" para um tipo de dados, permitindo que esse tipo seja referenciado atravs desse apelido em vez de seu identificador normal. Um dos usos mais comuns de typedef abreviar a declarao de tipos complexos, como structs ou estruturas. Veja este exemplo:

struct pessoa { char nome[40]; int idade; }; struct pessoa joao;

Observe que, para declarar a varivel joao, precisamos escrever a palavra struct. Podemos usar typedef para abreviar essa escrita:
typedef struct _pessoa { char nome[40]; int idade; } Pessoa; Pessoa joao;

Um "apelido" de tipo utilizado com bastante frequncia, embora no costumemos dar por isso: o tipo FILE, usado nas funes de entrada/sada de arquivos.
typedef struct _iobuf { char* _ptr; int _cnt; char* _base; int _flag; int _file; int _charbuf; int _bufsiz; char* _tmpfname; } FILE;

Ento, quando declaramos algo como

FILE *fp;

na verdade estamos a declarar um ponteiro para uma estrutura, que ser preenchida mais tarde pela funo fopen. Ateno! Voc no deve tentar manipular uma estrutura do tipo FILE; sua composio foi apresentada apenas como exemplo ou ilustrao.

sizeof
O operador sizeof usado para se saber o tamanho de variveis ou de tipos. Ele retorna o tamanho do tipo ou varivel em bytes como uma contante. Devemos us-lo para garantir portabilidade. Por exemplo, o tamanho de um inteiro pode depender do sistema para o qual se est compilando. O sizeof um operador porque ele substitudo pelo tamanho do tipo ou varivel no momento da compilao. Ele no uma funo. O sizeof admite duas formas:
sizeof nome_da_varivel sizeof (nome_do_tipo)

Se quisermos ento saber o tamanho de um float fazemos sizeof(float). Se declararmos a varivel f como float e quisermos saber o seu tamanho faremos sizeof f. O operador sizeof tambm funciona com estruturas, unies e enumeraes. Outra aplicao importante do operador sizeof para se saber o tamanho de tipos definidos pelo usurio. Seria, por exemplo, uma tarefa um tanto complicada a de alocar a memria para um ponteiro para a estrutura ficha_pessoal, criada na primeira pgina desta aula, se no fosse o uso de sizeof. Veja o exemplo:
typedef struct { const char *nome; const char *sobrenome; int idade; } Pessoa; int main(void) { Pessoa *joaquim; joaquim = malloc(sizeof(Pessoa)); joaquim->nome = "Joaquim"; joaquim->sobrenome = "Silva"; joaquim->idade = 15; }

Outro exemplo:
#include <string.h> #include <stdio.h> int main(void) { char *nome; nome = malloc(sizeof(char) * 10); sprintf(nome, "wikibooks"); printf("Site: http://pt.%s.org/", nome); /* Imprime: Site: http://pt.wikibooks.org/ */ }

A sentena abaixo NO funciona, pois sizeof substitudo pelo tamanho de um tipo em tempo de compilao.
const char *FRASE; FRASE = "Wikibooks eh legal"; printf("Eu acho que o tamanho da string FRASE %d", sizeof(FRASE));

Converso de tipos
As atribuies no C tem o seguinte formato:
destino=origem;

Se o destino e a origem so de tipos diferentes o compilador faz uma converso entre os tipos. Mas nem todas as converses so possveis. O primeiro ponto a ser ressaltado que o valor de origem convertido para o valor de destino antes de ser atribudo e no o contrrio. Em C, cada tipo bsico ocupa uma determinada poro de bits na memria, logo, a converso entre tipos nem sempre algo nativo da linguagem, por assim dizer. H funes como atol e atof que convertem string em inteiro longo (long int) e string em double, respectivamente. Mas em muitos casos possvel usar o casting. importante lembrar que quando convertemos um tipo numrico para outro, ns nunca ganhamos preciso. Ns podemos perder preciso ou no mximo manter a preciso anterior. Isto pode ser entendido de uma outra forma. Quando convertemos um nmero no estamos introduzindo no sistema nenhuma informao adicional. Isto implica que nunca vamos ganhar preciso. Abaixo vemos uma tabela de converses numricas com perda de preciso, para um compilador com palavra de 16 bits:
De Para Informao Perdida unsigned char char Valores maiores que 127 so alterados short int char Os 8 bits de mais alta ordem int char Os 8 bits de mais alta ordem long int char Os 24 bits de mais alta ordem long int short int Os 16 bits de mais alta ordem long int int Os 16 bits de mais alta ordem float int Preciso - resultado arredondado double float Preciso - resultado arredondado long double double Preciso - resultado arredondado

Casting: converso manual

Se declararmos a = 10/3, sabemos que o resultado 3,333, ou seja a diviso de dois nmeros inteiros d um nmero real. Porm o resultado em C ser o inteiro 3. Isso acontece, porque as constantes so do tipo inteiro e operaes com inteiros tem resultado inteiro. O mesmo ocorreria em a = b/c se b e c forem inteiros. Se declararmos:
int a;

O resultado ser 3. Mesmo que declarssemos:

float a;

o resultado continua a ser 3 mas desta vez, 3,0000. Para fazer diviso que resulte nmero real, necessrio fazer cast para um tipo de ponto flutuante:

a = (float)10/3 a = 10/(float)3

Nesse caso, o 10 ou o 3 convertido para float. O outro nmero continua como inteiro, mas ao entrar na diviso com um float, ele convertido automaticamente para float. A diviso feita e depois atribuda varivel a. Em poucas palavras, casting colocar um tipo entre parnteses antes da atribuio de uma varivel. A forma geral para cast :
(tipo)varivel (tipo)(expresso) variavel_destino = (tipo)variavel_origem;

Mas existem umas converses automticas:

int f(void) { float f_var; double d_var; long double l_d_var; f_var = 1; d_var = 1; l_d_var = 1; d_var = d_var + f_var; /*o float convertido em double*/ l_d_var = d_var + f_var; /*o float e o double convertidos em long double*/ return l_d_var; }

Repare que a converso feita de menor para o maior. possvel fazer a converso ao contrrio de um tipo com mais bits para um com menos bits e isso truncar. Nesse caso, o cast explcito necessrio. Assim, um nmero float: 43.023 ao ser convertido para int dever ser "cortado", ficando inteiro: 43. Se converter long para short, os bits mais significativos so perdidos na converso. O operador cast tambm e bastante utilizado para estruturar reas de estoque temporrios (buffer). A seguir um pequeno exemplo:
#include <stdio.h> typedef struct estruturar{ char a ; char b ; }; int main() { char buffer[2] = {17, 4}; estruturar *p; p = (struct estruturar*) &buffer; char* x = (char*)malloc(10); printf("a: %i b: %i", p->a,p->b); getchar(); return 0; }

Atributos das variveis

Estes modificadores, como o prprio nome indica, mudam a maneira com a qual a varivel acessada e modificada. Alguns dos exemplos usam conceitos que s sero abordados nas sees seguintes, ento voc pode deixar esta seo para depois se assim o desejar.

const
O modificador const faz com que a varivel no possa ser modificada no programa. Como o nome j sugere til para se declarar constantes. Poderamos ter, por exemplo:
const float PI = 3.1415;

Podemos ver pelo exemplo que as variveis com o modificador const podem ser inicializadas. Mas PI no poderia ser alterado em qualquer outra parte do programa. Se o programador tentar modificar PI o compilador gerar um erro de compilao. Outro uso de const, alis muito comum que o outro, evitar que um parmetro de uma funo seja alterado pela funo. Isto muito til no caso de um ponteiro, pois o contedo de um ponteiro pode ser alterado por uma funo. Para proteger o ponteiro contra alteraes, basta declarar o parmetro como const.
#include <stdio.h> int sqr (const int *num); int main(void) { int a = 10; int b; b = sqr(&a); } int sqr (const int *num) { return ((*num)*(*num)); }

No exemplo, num est protegido contra alteraes. Isto quer dizer que, se tentssemos fazer
*num = 10;

dentro da funo sqr(), o compilador daria uma mensagem de erro.

volatile
O modificador volatile diz ao compilador que a varivel em questo pode ser alterada sem que este seja avisado. Isto evita "bugs" que poderiam ocorrer se o compilador tentasse fazer uma otimizao no cdigo que no segura quando a memria modificada externamente.

Digamos que, por exemplo, tenhamos uma varivel que o BIOS do computador altera de minuto em minuto (um relgio, por exemplo). Seria importante que declarssemos esta varivel como volatile. Um uso importante de variveis volatile em aplicaes com vrias threads (linhas de execuo), onde a memria compartilhada por vrios pedaos de cdigo que so executados simultaneamente.

extern
O modificador extern diz ao compilador que a varivel indicada foi declarada em outro arquivo que no podemos incluir diretamente, por exemplo o cdigo de uma biblioteca padro. Isso importante pois, se no colocarmos o modificador extern, o compilador ir declarar uma nova varivel com o nome especificado, "ocultando" a varivel que realmente desejamos usar. E se simplesmente no declarssemos a varivel, j sabemos que o compilador no saberia o tamanho da varivel. Quando o compilador encontra o modificador extern, ele marca a varivel como no resolvida, e o montador se encarregar de substituir o endereo correto da varivel.
extern float sum; extern int count; float returnSum (void) { count++; return sum; }

Neste exemplo, o compilador ir saber que count e sum esto sendo usados no arquivo mas que foram declarados em outro. Uma varivel externa frequentemente usada a varivel errno (declarada no arquivocabealho errno.h), que indica o ltimo cdigo de erro encontrado na execuo de uma funo da biblioteca padro ou do sistema.

static
O funcionamento das variveis declaradas como static depende de se estas so globais ou locais.

Variveis globais static funcionam como variveis globais dentro de um mdulo, ou seja, so variveis globais que no so (e nem podem ser) conhecidas em outros mdulos (arquivos). Isto util se quisermos isolar pedaos de um programa para evitar mudanas acidentais em variveis globais. Isso um tipo de encapsulamento que , simplificadamente, o ato de no permitir que uma varivel seja modificada diretamente, mas apenas por meio de uma funo. Variveis locais estticas so variveis cujo valor mantido de uma chamada da funo para a outra. Veja o exemplo:

int count (void)

{ static int num = 0; num++; return num; }

A funo count() retorna o nmero de vezes que ela j foi chamada. Veja que a varivel local int inicializada. Esta inicializao s vale para a primeira vez que a funo chamada pois num deve manter o seu valor de uma chamada para a outra. O que a funo faz incrementar num a cada chamada e retornar o seu valor. A melhor maneira de se entender esta varivel local static implementando. Veja por si mesmo, executando seu prprio programa que use este conceito.

register
O computador pode guardar dados na memria (RAM) e nos registradores internos do processador. As variveis (assim como o programa como um todo) costumam ser armazenadas na memria. O modificador register diz ao compilador que a varivel em questo deve ser, se possvel, guardada em um registrador da CPU. Vamos agora ressaltar vrios pontos importantes:

Porque usar register? Variveis nos registradores da CPU vo ser acessadas em um tempo muito menor pois os registradores so muito mais rpidos que a memria. No entanto, a maioria dos compiladores otimizantes atuais usa registradores da CPU para variveis, ento o uso de register freqentemente desnecessrio. Em que tipo de varivel podemos usar o register? Antes da criao do padro ANSI C, register aplicava-se apenas aos tipos int e char, mas o padro atual permite o uso de register para qualquer um dos quatro tipos fundamentais. claro que seqncias de caracteres, arrays e estruturas tambm no podem ser guardadas nos registradores da CPU por serem grandes demais. register um pedido que o programador faz ao compilador. Este no precisa ser atendido necessariamente, e alguns compiladores at ignoram o modificador register, o que permitido pelo padro C. register no pode ser usado em variveis globais, pois isto implicaria em um registrador da CPU ficar o tempo todo ocupado por essa varivel.

Um exemplo do uso do register dado a seguir:

int main (void) { register int count; for (count = 0; count < 10; count++) { ... } return 0; }

O loop acima, em compiladores que no guardam variveis em registradores por padro, deve ser executado mais rapidamente do que seria se no usssemos o register. Este o

uso mais recomendvel para o register: uma varivel que ser usada muitas vezes em seguida.

Esta pgina um esboo de informtica. Ampliando-a voc ajudar a melhorar o Wikilivros.

Gerenciamento de memria
Alocao dinmica
Todos os dados de um programa so armazenados na memria do computador; muito comum necessitar reservar um certo espao na memria para poder guardar dados mais tarde. Por exemplo, poderamos reservar um espao de 1000 bytes para guardar uma string que o usurio viesse a digitar, declarando um vetor de 1000 caracteres. E se quisssemos reservar um espao que s conhecido no tempo de execuo do programa? E se o espao fosse muito grande, de modo que declarar vetores de tal tamanho seria inconveniente (pois, entre outras coisas, aumenta sem necessidade o tamanho do executvel)? Para solucionar esse problema, existe a alocao dinmica de memria, que como o nome sugere, uma maneira de alocar memria medida que o programa vai sendo executado. As quatro funes relacionadas com a alocao dinmica sero descritas a seguir.
malloc

e free

Essas duas funes so as mais bsicas para o gerenciamento de memria. malloc responsvel pela alocao de um pedao de memria, e free responsvel por liberar esse pedao de memria. Para alocar um espao na memria, precisamos fornecer funo malloc o nmero de bytes desejados. Para isso, precisaremos usar o operador sizeof, introduzido na seo anterior. Veja um exemplo.
#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { /* ponteiro para memria que ser alocada */ int *p; int i; /* alocar 10 elementos inteiros, ou seja, ( sizeof (int) * 10 ) */ p = (int *) malloc ( sizeof (int) * 10); if ( p == NULL ) {

printf ("Erro: No foi possivel alocar memria\n"); exit(1); } for(i = 0; i < 10; i++) { p[i] = i * 2; printf ("%d\n", p[i]); } /* libera a memria alocada por malloc */ free (p); return 0; }

importante notar que a funo malloc retorna um ponteiro NULL caso no consiga alocar memria.

calloc
Sintaxe:
#include <stdlib.h> void *calloc(size_t nelem, size_t elsize);

Descrio: A funo calloc reserva um bloco com o tamanho (nelem x elsize) octetos consecutivos. O bloco reservado inicializado a 0.

Valor de retorno : Se a operao foi um sucesso, calloc retorna um ponteiro sobre o inicio do bloco reservado. Se no houver espao suficiente ou se nelem ou elsize valem 0 ,calloc retorna NULL . Ex:
#include <stdio.h> #include <stdlib.h> int main() { int *str = NULL; str = (char *) calloc(10, sizeof(int)); printf("%d\n", str[9]); free(str); return 0; }

realloc
Sintaxe:

#include <stdlib.h> void *realloc(void *ptr, size_t size);

Descrio: A funo realloc ajusta o tamanho de um bloco a size octetos consecutivos. Argumentos: ptr: Aponta para um bloco criado por malloc, calloc ou realloc.Se o ponteiro NULL realloc equivale a malloc. size: Tamanho do novo bloco em octetos. Valor de retorno : Se a funo terminar normalmente ela retorna o endereo do novo bloco.Pode acontecer que o endereo mude com relao ao endereo usado em argumento, nesse caso o conteudo do bloco transferido para o novo bloco e a regio antiga e liberada automaticamente. Se faltar lugar na memria ou size for igual a 0 realloc retorna NULL . Ex:
#include <stdio.h> #include <string.h> #include <stdlib.h> int main() { char *str1=NULL, *str2=NULL; str1 = (char *) malloc(11); strcpy(str1, "ABCDEFGHIJ"); str2 = (char *) realloc(str2, 20); printf("Endereo de str1 : %p\n", str1); printf("Endereo de str2 : %p\n", str2); str1 = (char *) realloc(str1, 100); printf("Novo endereo de str1 : %p\n", str1); printf("Conteudo de str1 : %s\n", str1); free(str1); free(str2); return 0; }

Alocao Dinmica de Vetores

A alocao dinmica de vetores utiliza os conceitos aprendidos na aula sobre ponteiros e as funes de alocao dinmica apresentados. Um exemplo de implementao para vetor real fornecido a seguir:
#include <stdio.h> #include <stdlib.h> float *Alocar_vetor_real (int n) {

float *v; /* ponteiro para o vetor */ if (n < 1) { /* verifica parametros recebidos */ printf ("** Erro: Parametro invalido **\n"); return (NULL); } v = calloc (n, sizeof(float)); /* aloca o vetor */ if (v == NULL) { printf ("** Erro: Memoria Insuficiente **"); return (NULL); } return (v); /* retorna o ponteiro para o vetor */ } float *Liberar_vetor_real (float *v) { if (v == NULL) return (NULL); free(v); /* libera o vetor */ return (NULL); /* retorna o ponteiro */ } int main (void) { float *p; int a; ... /* outros comandos, inclusive a inicializacao de a */ p = Alocar_vetor_real (a); ... p[] normalmente */ p = Liberar_vetor_real (p); } /* outros comandos, utilizando

Alocao Dinmica de Matrizes

A alocao dinmica de memria para matrizes realizada da mesma forma que para vetores, com a diferena que teremos um ponteiro apontando para outro ponteiro que aponta para o valor final, ou seja um ponteiro para ponteiro, o que denominado indireo mltipla. A indireo mltipla pode ser levada a qualquer dimenso desejada, mas raramente necessrio mais de um ponteiro para um ponteiro. Um exemplo de implementao para matriz real bidimensional fornecido a seguir. A estrutura de dados utilizada neste exemplo composta por um vetor de ponteiros (correspondendo ao primeiro ndice da matriz), sendo que cada ponteiro aponta para o incio de uma linha da matriz. Em cada linha existe um vetor alocado dinamicamente, como descrito anteriormente (compondo o segundo ndice da matriz).
#include <stdio.h> #include <stdlib.h> float **Alocar_matriz_real (int m, int n) { float **v; */

/* ponteiro para a matriz

int */

i;

/* variavel auxiliar

if (m < 1 || n < 1) { /* verifica parametros recebidos */ printf ("** Erro: Parametro invalido **\n"); return (NULL); } /* aloca as linhas da matriz */ v = calloc (m, sizeof(float *)); /*Um vetor de m ponteiros para float */ if (v == NULL) { printf ("** Erro: Memoria Insuficiente **"); return (NULL); } for ( i = 0; i < m; i++ ) /* aloca as colunas da matriz */ { v[i] = calloc (n, sizeof(float)); /* m vetores de n floats */ if (v[i] == NULL) { printf ("** Erro: Memoria Insuficiente **"); return (NULL); } } return (v); /* retorna o ponteiro para a matriz */ } float **Liberar_matriz_real (int m, int n, float **v) { int i; /* variavel auxiliar */ if (v == NULL) return (NULL); if (m < 1 || n < 1) { /* verifica parametros recebidos */ printf ("** Erro: Parametro invalido **\n"); return (v); } for (i=0; i<m; i++) free (v[i]); /* libera as linhas da matriz */ free (v); /* libera a matriz (vetor de ponteiros) */ return (NULL); /* retorna um ponteiro nulo */ } int main (void) { float **mat; /* matriz a ser alocada */ int l, c; /* numero de linhas e colunas da matriz */ int i, j; ... /* outros comandos, inclusive inicializacao para l e c */ mat = Alocar_matriz_real (l, c); for (i = 0; i < l; i++) for ( j = 0; j < c; j++) mat[i][j] = i+j; ... /* outros comandos utilizando mat[][] normalmente */ mat = Liberar_matriz_real (l, c, mat);

... }

Sockets
Abstraes
A verso Unix BSD 4.1c de 1982 para VAX foi a primeira a incluir TCP/IP no kernel do sistema operacional, oferecendo ao mesmo tempo uma interface de programao como abstrao para esses protocolos. Os soquetes ou sockets so uma API (Application Program Interface) isso quer dizer uma interface entre os programas e a camada de transporte. Exemplo: TCP, UDP. Os soquetes podem usar outros protocolos como AppleTalk, Xrox XNS, etc. A API de sockets foi desenvolvida para a linguagem C e so uma das principais API para sistemas do tipo UNIX. O Windows possui uma interface similar conhecida com o nome de Winsock.

Funes da biblioteca padro

int accept(int, struct sockaddr *restrict, socklen_t *restrict); int bind(int, const struct sockaddr *, socklen_t); int connect(int, const struct sockaddr *, socklen_t); int getpeername(int, struct sockaddr *restrict, socklen_t *restrict); int getsockname(int, struct sockaddr *restrict, socklen_t *restrict); int getsockopt(int, int, int, void *restrict, socklen_t *restrict); int listen(int, int); ssize_t recv(int, void *, size_t, int); ssize_t recvfrom(int, void *restrict, size_t, int, struct sockaddr *restrict, socklen_t *restrict); ssize_t recvmsg(int, struct msghdr *, int); ssize_t send(int, const void *, size_t, int); ssize_t sendmsg(int, const struct msghdr *, int); ssize_t sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t); int setsockopt(int, int, int, const void *, socklen_t); int shutdown(int, int); int socket(int, int, int); int sockatmark(int); int socketpair(int, int, int, int[2]);

Famlias de endereo
Existem varias famlias de endereo e cada uma corresponde a um protocolo em particular. As famlias mais usadas so : AF_UNIX: Protocolo interno do UNIX AF_INET: Protocolo Internet AF_NS : Protocolo de Xerox NS

Estruturas de endereo
Varias chamada ao sistema de redes do unix precisam apontar para uma estrutura de endereo de socket. A definio dessas estruturas esta definida dentro do cabealho <sys/socket.h>.
struct sockaddr { u_short sa_family ; char sa_data[14] ; } ;

sa_family: Famlia de endereo leva o valor AF_xxx . sa_data: endereo especifico de protocolo . Para a famlia internet as estrutura esto definidas dentro do cabealho <netinet/in.h>.
struct in_addr { u_long s_addr ; } ;

struct sockaddr_in { short sin_family ; u_short sin_port ; struct in_addr sin_addr ; char sin_zero[8] ; } ;

Makefiles
Makefile
O makefile um arquivo utilizado por um programa chamado make ou em outros sistemas operativos ,gmake, nmake, tmake, etc. Ele pode variar de um sistema a outro pois no faz parte de nenhuma normalizao . O texto contido em um makefile usado para a compilao, ligao, montagem de arquivos de um projeto entre outros. Vantagens do uso. Evita a compilao de arquivos desnecessrios. Por exemplo, se seu programa utiliza 120 bibliotecas e voc altera apenas uma, o makefile descobre (comparando as datas de alterao dos arquivos fontes com as dos arquivos anteriormente compilados) qual arquivo foi alterado e compila apenas a biblioteca necessria. As explicaes a seguir so para o utilitrio GNU make. Ento vamos para a apresentao do Makefile atravs da compilao de um pequeno projeto em linguagem C.

Criar uma pasta com esses 4 arquivos :

teste.c ,teste.h , main.c, Makefile.

De um nome para a pasta Projeto.

/*================ teste.c ======================*/ #include <stdio.h> #include <stdlib.h> /*Uma funao makeTeste()*/ void makeTeste(void){ printf("O Makefile super Legal\n"); }

Aqui escrevemos o header :

/*======================= teste.h ===============*/ /*================== Cabealho ou header ========*/ #ifndef _H_TESTE #define _H_TESTE /* A nossa funo */ void makeTeste(void); /* De um enter depois de endif*/ /*Para evitar warning*/ #endif

Agora a funo main :

/*====================== main.c =================*/ #include <stdio.h> #include <stdlib.h> #include "teste.h" /* Aqui main ;( */ int main(void){ makeTeste(); return (0); }

Para compilar fazemos um arquivo Makefile minimal.

#Para escrever comentrios ## ############################# Makefile ########################## all: teste teste: teste.o main.o # O compilador faz a ligao entre os dois objetos gcc -o teste teste.o main.o #-----> Distancia com o boto TAB ### e no com espaos teste.o: teste.c gcc -o teste.o -c teste.c -W -Wall -ansi -pedantic main.o: main.c teste.h gcc -o main.o -c main.c -W -Wall -ansi -pedantic clean: rm -rf *.o mrproper: clean rm -rf teste

Para no ter erros os espaos devem ser feito com a tecla TAB. E compilar s ir dentro da pasta "Projeto" apertar F4 escrever make e apertar enter. Uma vez compilado podemos modificar teste.c . Se teste.c foi modificado ento make modifica teste.o e se no deixa teste.o como esta.

all : o nome das regras a serem executadas. teste: teste.c .Pode ser interpretado com arquivo_de_destino: arquivo_de_origem. clean: Apaga os arquivos intermedirios.Se voc escrever no console make clean

ele apaga os arquivos objeto da pasta.

mrproper: Apaga tudo o que deve ser modificado.No console escreva make mrproper

Sintaxe de criao do arquivo

O makefile funciona de acordo com regras, a sintaxe de uma regra :
regra: dependncias Apertar o boto TAB comando comando ...

Regras complementarias

all : o nome das regras a serem executadas. clean: Apaga os arquivos intermedirios. mrproper: Apaga tudo o que deve ser modificado.

Definir Variveis As variveis servem para facilitar o trabalho. Em vez de mudar varias linhas mudamos s o valor da varivel. Deve ser por isso que se chama varivel, no? Definimos da forma seguinte.
NOME=VALOR E para utilizar esta varivel colocamos entre $() . Ento ela vai ficar assim $(NOME)

Vamos para o exemplo com o nosso Makefile. Colocamos em vez de :

NOME SRC E em vez de VALOR main.c . E para poder usar $(SRC)

Ser que na pratica funciona?. Vamos ver..

#Para escrever comentrios ##

############################# Makefile ########################## #Definimos a varivel SRC=main.c all: teste teste: teste.o main.o gcc -o teste teste.o main.o #-----> Distancia com o botao TAB ### e nao com espaos teste.o: teste.c gcc -o teste.o -c teste.c -W -Wall -ansi -pedantic # #Coloquei $(SRC) em todos os lugares aonde estava main.c main.o: $(SRC) teste.h gcc -o main.o -c $(SRC) -W -Wall -ansi -pedantic clean: rm -rf *.o mrproper: clean rm -rf teste

Todos os lugares do cdigo que contem o CONTEDO da varivel so modificados colocando no lugar respectivo o NOME da varivel. Variveis Personalizadas

CC=gcc .Definimos CC para nomes de compiladores de C ou C++ .Aqui o gcc. CFLAGS=-W -Wall -ansi -pedantic .Serve para definir opes passadas ao compilador.

Para o c++ o NOME e CXXFLAGS .

LDFLAGS e utilizado para editar as opes de links. EXEC=teste .EXEC define o NOME do futuro programa executvel. OBJ=teste.o main.o . Para cada arquivo.c um arquivo OBJETO e criado com a extenso ".o" arquivo.o .

Ento e s olhar na sua pasta todos os arquivos com a extenso ".c" e colocar na varivel OBJ com a extenso".o" .

Outra maneira e mesma coisa. OBJ agora e igual a main.o teste.o

SRC = main.c teste.c OBJ= $(SRC:.c=.o)

E super manero a tua idia camarada. Mais tenho 200 arquivos.c e no quero olhar o nome de todos um por um. o Tem outra idia?? o Poderamos utilizar *c mais no podemos utilizar este caracter joker na definio de uma varivel. o Ento vamos utilizar o comando " wildcard " ele permite a utilizao de caracteres joker na definio de variveis. Fica assim.

SRC= $(wildcard *.c) OBJ= $(SRC:.c=.o)

Observao se quiser fazer aparecer uma mensagem durante a compilao escreva @echo "Minha mensagem" . E mais tem um monte de mensagens e fica muito feio Tem outra idia??.. O pessoal vamos parando ;) no sou uma maquina de idias. Para deixar as mensagens em modo silencioso coloque "@" no comeo do comando. Fica assim

@$(CC) -o $@ $^

Variveis internas
$@ $< $^ $? $* Nome da regra. Nome da primeira dependncia Lista de dependncias Lista de dependncias mais recentes que a regra. Nome do arquivo sem sufixo

As regras de interferncia No disse nada antes porque estvamos no estado principiantes "noob". So regras genricas chamadas por default.

.c.o : .Ela significa fazer um arquivo.o a partir de um arquivo.c . %.o: %.c .A mesma coisa. A linha teste.o: teste.c pode ser modificada com essa regra. .PHONY: .Preste bem ateno. Esta regra permite de evitar conflitos. o Por exemplo "clean:" e uma regra sem nem uma dependncia no temos nada na pasta que se chame clean. o Agora vamos colocar na pasta um arquivo chamado clean. Se voc tentar apagar os "arquivos.o" escrevendo "make clean" no vai acontecer nada porque make diz que clean no foi modificado. o Para evitar esse problema usamos a regra .PHONY : . Fica assim. o .PHONY: clean mrproper o .PHONY: diz que clean e mrproper devem ser executados mesmo se arquivos com esses nomes existem.

Agora vamos modificar mais uma vez o nosso Makefile com tudo o que sabemos sobre variveis.
#Para escrever comentrios ## ############################# Makefile ########################## #Definimos a varivel CC=gcc CFLAGS=-W -Wall -ansi -pedantic EXEC=teste OBJ=teste.o main.o all: $(EXEC) @echo "Vou comear a compilao" #No coloquei a varivel OBJ para que possam entender as variveis internas. #Se entenderam podem colocar $(OBJ) no lugar de teste.o main.o teste: teste.o main.o # $@ = teste:

# $^ = teste.o main.o $(CC) -o $@ $^ # teste.o:teste.c %.o: %.c $(CC) -o $@ -c $< $(CFLAGS) main.o: main.c teste.h $(CC) -o $@ -c $< $(CFLAGS) .PHONY: clean mrproper clean: rm -rf *.o @echo "Compilaao prontinha" mrproper: clean rm -rf $(EXEC)

Po legal ;) parece at trabalho de gente grande.

Sub Makefiles Ler tudo isso s para compilar um programa?? O sub-makefile e lanado por meio de um "Makefile principal" vamos simplificar para o Patro Makefile. Aonde estvamos??...Ah sim, para que serve?? O Makefile Principal executa os sub-makesfiles de outras pastas. Como ele faz??
Usamos uma varivel pre-definida $(MAKE).

Bao ao trabalho.. Crie dentro da pasta "Projetos" outra pasta com o nome "submake".Dentro da pasta sub-make crie um arquivo Makefile e um arquivo submake.c Dentro da pasta sub-make coloque este Makefile.
##################Pasta:sub-make ## Makefile ################### CC=gcc CFLAGS=-W -Wall -ansi -pedantic EXEC=teste2 SRC= $(wildcard *.c) OBJ= $(SRC:.c=.o) all: $(EXEC) @echo "compilando sub-makefile" @echo "sub-makefile compilado" teste2: $(OBJ) @$(CC) -o $@ $^ .PHONY: clean mrproper clean: @rm -rf *.o mrproper: clean @rm -rf $(EXEC)

Agora vamos escrever o arquivo submake.c .

#include <stdio.h> #include <stdlib.h> /* Informao

* Nao utilizem este cdigo para fazer um kernel */ int main(void) { printf("Sou o binrio que est em sub-make"); printf("Finalmente em fim vivo graas ao Patro Makefiles ;)"); return (0); }

Agora retorne na pasta "Projeto" vamos modificar o Makefile . Vamos colocar a seguinte linha:
@cd sub-make && $(MAKE)

Explicando: "@" silencioso "cd" para abrir a pasta sub-make "&&" e executar make "$(MAKE)" Vamos fazer a mesma coisa para "clean:" e "mrproper:" ento ao executar "make clean" no console ele vai executar o mesmo comando no sub-makefile.

########################## O Makefile principal ##########################" CC=gcc CFLAGS=-W -Wall -ansi -pedantic EXEC=teste SRC= $(wildcard *.c) OBJ= $(SRC:.c=.o) all: $(EXEC) @echo "Compilando Projeto" @echo "O patro foi compilado" #A linha que vai compilar sub-make @cd sub-make && $(MAKE) teste: $(OBJ) @$(CC) -o $@ $^ %.o: %.c @$(CC) -o $@ -c $< $(CFLAGS) main.o: main.c teste.h @$(CC) -o $@ -c $< $(CFLAGS) .PHONY: clean mrproper clean: @rm -rf *.o *~ # E a mesma coisa que dar um F4 dentro da pasta sub-make # e escrever make clean @cd sub-make && $(MAKE) $@ mrproper: clean @rm -rf $(EXEC) #modificamos aqui tambm @cd sub-make && $(MAKE) $@

No esquea de dar TAB em todas as linhas que esto em baixo dos ":" dois pontinhos. OK agora s dar um F4 dentro da pasta projetos e voc tem trs comandos a disposio.

make make clean make mrproper

Make install

Automatizando a instalao do programa com a regra install: .

install: .Coloca o binrio ou executvel em uma determinada pasta, como por exemplo /bin ou /usr/bin no Linux. Pode ser em qualquer outra, utilizando o comando "mv" ou "cp" para mover ou copiar. Crie uma pasta bin dentro de "Projetos". Devem saber que no devem colocar nada intil que venha da internet na pasta raiz do linux. Vamos fazer duas variveis: o prefix=/caminho/ate onde/esta/Projetos o bindir=$(prefix)/bin .Igual a /caminho ate/Projetos/dentro de Projetos a pasta bin . o E adicionarmos a regra install:all com seus comandos.

Modificando o make principal.

########################## O Makefile principal ##########################" #Coloque o caminho at Projeto aqui prefix=/home/USER/Projeto bindir=$(prefix)/bin CC=gcc CFLAGS=-W -Wall -ansi -pedantic EXEC=teste SRC= $(wildcard *.c) OBJ= $(SRC:.c=.o) all: $(EXEC) @echo "Compilando Projeto" @echo "O patrao foi compilado" #A linha que vai compilar sub-make @cd sub-make && $(MAKE) teste: $(OBJ) @$(CC) -o $@ $^ %.o: %.c @$(CC) -o $@ -c $< $(CFLAGS) main.o: main.c teste.h @$(CC) -o $@ -c $< $(CFLAGS) #Entao depois e so executar make e depois make install install:all @mv $(EXEC) $(bindir)/ .PHONY: clean mrproper clean: @rm -rf *.o *~ # E a mesma coisa que dar um F4 dentro da pasta sub-make # e escrever make clean @cd sub-make && $(MAKE) $@ mrproper: clean @cd bin && rm -rf $(EXEC) #modificamos aqui tambem @cd sub-make && $(MAKE) $@

Ento quando voc digitar no console "make" depois "make install" ele vai colocar o binario que esta em "Projetos" dentro de "bin". Se voc quiser colocar o binario que esta na pasta "sub-make" na pasta "bin"

Copiar e colar no makefile da "sub-make" as variaveis "prefix" e "bindir"e a regra install:com seu comando. E no "Makefile principal" em baixo de "install:" coloque esta linha @cd submake && $(MAKE) $@ Aqui eu modifiquei o "mrproper" porque agora os binarios que devem ser apagados com "make mrproper" esto em "bin". Vou deixar voces modificarem o "mrproper" do "sub-makefile" como pessoas adultas e responsaveis ;) Valeu galera.

Os comandos no console so:

make make install make clean make mrproper .Para apagar os binarios.

Lista de palavras reservadas

A linguagem C possui um total de 32 palavras conforme definido pelo padro ANSI, que so elas:
auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

importante lembrar que todas as palavras reservadas so escritas em minsculo e no podem ser utilizadas para outro propsito. Alguns compiladores incluem outras palavras reservadas como, asm, cdecl, far, fortran, huge, interrupt, near, pascal, typeof.

Seqncias de escape
O C tem vrias seqncias de escape. Elas servem geralmente para inserir um caractere especial numa String. Algumas dessas seqncias so:

\a - Alarm, Alarme = Toca o alarme sonoro do sistema \b - Back space, Retrocesso = Apaga o caractere esquerda do cursor \n - NewLine, Nova linha = Pula uma linha \t - Tabulao horizontal = Equivale dar um TAB na string \r - Carriage Return, Retorno do Carro = Volta para o incio da linha.

\t - Horz. Tab, Tabulao Harizontal = Salta frente conforme seus ajustes de tabulao \0 - Null, Nulo = Caractere nulo ou zero geralmente estabelecido como fim de string

Lista de funes
Aqui esto as vrias funes presentes em C separadas por cabealho:

stdio.h
o o o o o o o o o o o o o o o o

printf scanf vsnprintf sprintf vprintf fprintf fscanf feof fflush calloc malloc system gets fgets puts fputs

stdlib.h atoi atof atol itoa string.h o strcmp o stricmp o strlen o strstr o strcat o strcpy o strncpy o strncat o strchr o strrev signal.h iso10646.h time.h math.h o tan o sin o cos
o o o o

o o o o o o

atan asin acos pow sqrt abs

Lista de bibliotecas
Cabealhos de bibliotecas padro ANSI C (C89)/ISO C (C90):
assert.h ctype.h errno.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h

Cabealhos adicionados no ISO C (C94/C95):

iso646.h wchar.h wctype.h

Cabealhos adicionados no ISO C (C99) (suportados somente em compiladores mais novos):

complex.h fenv.h inttypes.h stdbool.h stdint.h tgmath.h

Ligaes externas

The Open Group Base Specifications Issue 7 (english) Biblioteca C (english)

Dicas de programao em C
Convenes tipogrficas
Uma das melhores maneiras de obter um cdigo claro e usando identificadores coerentes. Por exemplo bom poder identificar rapidamente as variveis em funo de suas propriedades . Veja abaixo algumas delas.
- ponteiro - tabela esttica(static array) prefixos identificadores p_ a_ ou sa_

- tabela dinmica (dynamic array) - cadeia de caracteres(string)

da_ s_

Em um cdigo com a varivel "p_exemplo" podemos deduzir rapidamente que estamos usando um ponteiro .

A funo printf a melhor amiga de um programador

Um programador novato tende a ver apenas duas aplicaes para o printf: 1. Solicitar entrada para o usurio do programa. 2. Imprimir o resultado do programa. O fato que um programador pode aplicar o printf a fim de saber o que ocorre durante a execuo de programa. Isto permite, dentre outras coisas, detectar erros. Por exemplo, suponha um programa no qual vrias funes e rotinas so executadas. Algo como:
int main(int argc, char *argv[]) { ... funcao1(...); funcao2(...); funcao3(...); funcao4(...); ... return 0; }

Digamos que o programa tenha sido compilado com sucesso, mas ocorra algum erro durante sua execuo. Podemos usar o printf para detectar o erro da seguinte maneira:
int main(int argc, char *argv[]) { ... printf("iniciando funcao1"); funcao1(...); printf("completa funo1, iniciando funcao2"); funcao2(...); printf("completa funo2, iniciando funcao3"); funcao3(...); printf("completa funo3, iniciando funcao4"); funcao4(...); printf("completa funo4"); ... return 0; }

Isto permite o programador determinar at que ponto o programa roda antes de dar erro, facilitando muito a deteco deste. Outro exemplo de como o printf til na deteco de problemas. Suponha um programa cheio de laos aninhados. Tal como:

for(...) { while(...) { ... for(...) { ... } } }

Caso durante a execuo o programa entre em um loop infinito, uma forma de detectar em qual dos laos est o problema :
for(...) { printf("Teste 1"); while(...) { printf("Teste 2"); ... for(...) { printf("Teste 3"); ... } } }

A impresso que se repetir eternamente aquela dentro do lao problemtico. Um ltimo exemplo de deteco de problemas por meio do printf. Suponha que a resposta dada por um programa no a esperada, que a resposta consiste na impresso de uma varivel x, a qual recebe diversas atribuies ao longo do programa. Podemos identificar o erro dando um printf em x aps cada uma de suas atribuies:
x=... printf("primeira atribuicao de x eh %tipo", x); ... x=... printf("segunda atribuicao de x eh %tipo", x); ... x=... printf("terceira atribuicao de x eh %tipo", x); ... printf("A resposta eh %tipo", x);

Caso o valor de x dependa do valor de outras variveis que no so impressas, imprimilas pode ajudar na deteco do problema. Para uso como debug, a linguagem C apresenta duas macros que quando utilizadas junto com o printf so timos recursos.

__FILE__ = nome do arquivo. __LINE__ = numero da linha de execuo.

O Compilador gcc ainda dispe de uma outra macro bastante util:

__PRETTY_FUNCTION__ = nome da funo atual.

... printf("%d:%s:%s\n", __LINE__, __FILE__, __PRETTY_FUNCTION__); ...

O trecho acima vai te dar uma saida para debug muito util com o seguinte conteudo:
Exemplo: 3:hello.c:main

Tecle 1 para rodar

Existem duas formas de manter um programa rodando enquanto o usurio desejar: 1. Conter a maior parte do programa dentro de um lao. 2. Usar o comando goto(lembre-se que o comando goto no de uso aconselhado para a programao estruturada). Alguns exemplos: Com while:
int main(int argc, char *argv[]) { int rodando=1; while(rodando==1)/*Este laco mantem o programa rodando enquanto o usuario desejar*/ { ... printf("\nDigite 1 para continuar rodando o programa."); printf("\nDigite qualquer outro numero para encerrar o programa. "); scanf("%d", &rodando); } return 0; }

Com do...while
int main(int argc, char *argv[]) { short int rodando; do /*Este laco mantem o programa rodando enquanto o usuario desejar*/ { ... printf("\nDigite 1 para manter o programa rodando. "); scanf("%d", &rodando); }while(rodando==1); return 0; }

Com o goto
int main(int argc, char *argv[]) { MARCA: ... FIM: int y; printf("Tecle 1 para continuar rodando o programa. Tecle 0 para encerrar o programa\n"); scanf("%d",&y); if(y==1) { goto MARCA; } if(y!=1 && y!=0) { goto FIM; } return 0; }

Listas encadeadas
Listas encadeadas so estruturas de dados lineares e dinmicas, a grande vantagem que elas possuem em relao ao uso de vetor o fato de terem tamanho mximo relativamente infinito (o tamanho mximo o da memria do computador), ao mesmo tempo que podem ter o tamanho mnimo de 1 elemento evitando o desperdcio de memria.

Primitivas
No existe nenhuma normalizao quanto as primitivas usadas para a manipulao de uma lista. Abaixo voc pode ver uma lista com algumas delas .

Colocar o ndice sobre o primeiro elemento da lista. Colocar o ndice sobre o ltimo elemento da lista . Colocar o ndice sobre o elemento que segue o elemento atual . Colocar o ndice sobre o elemento que precede o elemento atual . Verificar se a lista est vazia : Se a lista estiver vazia retorna verdadeiro, se no, falso. Verificar se o primeiro elemento : Retorna verdadeiro se o elemento atual o primeiro, se no, falso. Verificar se o ltimo elemento : Retorna verdadeiro se o elemento atual o ltimo, se no, falso. Verificar o nmero de elementos da lista : Retorna o nmero de elementos da lista. Adicionar um elemento no incio : Adicionar um elemento antes do primeiro elemento da lista .

Adicionar um elemento no fim : Adicionar um elemento depois do ltimo elemento da lista . Insero : Inserir um elemento antes do elemento atual . Troca : Trocar o elemento atual . Remoo : Remover o elemento atual . Listar todos os elementos da lista .

Lista encadeada linear

Cada n ou elemento de uma lista encadeada ir possuir guardar o valor do n e o endereo do prximo n. Em uma lista encadeada linear o ultimo elemento aponta para NULL .
struct No{ char *p_dados; struct No *p_prox; };

Iniciar uma lista

A funo abaixo demonstra como iniciar uma lista criando o espao da raiz na memria.
void criar_Lista(struct No **p_Raiz){ *p_Raiz = NULL; }

Insero
Existem 3 tipos de insero em uma lista, pode-se inserir no comeo, no final ou entre dois elementos da lista.

Insero no incio
int inserir_No_Inicio(struct No **p_Raiz, char *p_String){ struct No *p_Novo; /** Alocao dinmica da memoria */ if((p_Novo = (struct No *) malloc(sizeof(struct No))) == NULL ){ puts( "Falta Memoria\n"); return -1 ; } p_Novo->p_dados = p_String; p_Novo->p_prox = *p_Raiz; *p_Raiz = p_Novo; }

Mordedores de fronha...

Insero no fim
int inserir_No_Fim(struct No **p_Raiz, char *p_String){ struct No *p_Novo;

if(( p_Novo = (struct No *) malloc(sizeof(struct No))) == NULL ){ puts( "Falta Memoria\n"); return -1 ; } p_Novo->p_dados = p_String; p_Novo->p_prox = NULL; if(*p_Raiz == *p_Raiz = else{ struct No e_atual = NULL) p_Novo; *e_atual; *p_Raiz; /*@ Elemento atual*/ /*@ Primeiro elemento*/

while(e_atual->p_prox != NULL){ e_atual = e_atual->p_prox; } e_atual->p_prox = p_Novo; } }

Remoo
Assim como na insero tambm existem 3 tipos de remoo, no incio, no fim ou entre dois elementos da lista.

Remoo no incio
void remover_No_Inicio(struct No **p_Raiz){ if(*p_Raiz == NULL) printf("\nA lista ja esta vazia\n"); else{ struct No *p_atual; p_atual = *p_Raiz; *p_Raiz = (*p_Raiz)->p_prox; free(p_atual); } }

Remoo no fim
void remover_No_Fim(struct No **p_Raiz){ if(*p_Raiz == NULL) printf("\nA lista ja esta vazia"); else{ struct No *p_atual, *p_anterior ; p_atual = *p_Raiz; while(p_atual->p_prox != NULL){ p_anterior = p_atual ; p_atual = p_atual->p_prox; } p_anterior->p_prox = NULL; free(p_atual); } }

mordedores de fronha

Exibio

Do fim para a raiz

void mostrar_Do_Fim_Para_Raiz(struct No *p_Raiz){ if(p_Raiz == NULL) printf("\nLista vazia"); else{ struct No *p_Atual_Corredor, *p_Atual_Fim; p_Atual_Corredor = p_Raiz; p_Atual_Fim = p_Raiz; while(p_Atual_Fim->p_prox != NULL){ //ir para o ultimo elemento p_Atual_Fim = p_Atual_Fim->p_prox; } while(p_Atual_Corredor != p_Atual_Fim){ if(p_Atual_Corredor->p_prox == p_Atual_Fim){ printf(" <- %s", p_Atual_Fim->p_dados); p_Atual_Fim = p_Atual_Corredor; p_Atual_Corredor = p_Raiz; } else p_Atual_Corredor = p_Atual_Corredor->p_prox; } printf(" <- %s", p_Atual_Fim->p_dados); } }

Da raiz para o fim

void mostrar_Da_Raiz_Para_Fim(struct No *p_Raiz){ if(p_Raiz == NULL) printf("\nLista vazia"); else{ struct No *p_atual; p_atual = *p_Raiz; while(p_atual != NULL){ printf("%s", p_atual->p_dados); p_atual = p_atual->p_prox; } } }

Pilha
Pilha
Pilha ou stack uma lista linear em que todas as inseres e remoes de elemento s podem ser feitos em uma extremidade chamada topo.As pilhas tambm so chamadas de estruturas LIFO (Last In First Out) ou seja o ltimo elemento inserido o primeiro removido.

Construo do prottipo de um elemento da lista.

typedef struct Elemento_da_lista{ char *dados; struct Elemento_da_lista *proximo; }Elemento;

typedef struct Localizar{ Elemento *inicio; int tamanho; } Pilha;

Inicializao
void iniciar (Pilha *monte){ monte->inicio = NULL; monte->tamanho = 0; }

Inserir um elemento na pilha(push)

Algoritmo: Declarao do elemento(s) a ser inserido. Alocao da memria para o novo elemento Inicializar o campo de dados. Preencher o ponteiro inicio com o primeiro elemento Colocar em dia o tamanho da pilha.
int empilhar(Pilha * monte, char *dados){ Elemento *novo_elemento; if ((novo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL) return -1; if ((novo_elemento->dados = (char *) malloc (50 * sizeof (char))) == NULL) return -1; strcpy (novo_elemento->dados, dados); novo_elemento->proximo = monte->inicio; monte->inicio = novo_elemento; monte->tamanho++; }

Retirar um elemento da pilha (pop)

int desempilhar (Pilha *monte){ Elemento *p_elemento; if (monte->tamanho == 0) return -1; p_elemento = monte->inicio; monte->inicio = monte->inicio->proximo; free (p_elemento->dados); free (p_elemento); monte->tamanho--; return 0; }

Imprimir os elementos da pilha

void mostrar(Pilha * monte){ Elemento *atual;

int i; atual = monte->inicio; for(i=0;i<monte->tamanho;++i){ printf("\t\t%s\n", atual->dados); atual = atual->proximo; } }

rvores binrias
Arvore binria
Uma arvore binria uma estrutura de dados que pode ser representada como uma hierarquia onde cada elemento chamado de n . O n inicial ou o primeiro elemento chamado de raiz. Em uma arvore binria um elemento pode ter um mximo de dois filhos no nvel inferior denominados como sub-rvore esquerda e sub-rvore direita.Um n sem filhos chamado de folha . A profundidade de um n a distncia deste n at a raiz e a distancia entre a folha mais distante e a raiz a altura da arvore.Um conjunto de ns com a mesma profundidade denominado, nvel da rvore.

Struct
typedef struct No{ int numero; struct No *esquerda; struct No *direita; }No;

Iniciar
void criarArvore(No **pRaiz){ *pRaiz = NULL; }

Insero
void inserir(No **pRaiz, int numero){ if(*pRaiz == NULL){ *pRaiz = (No *) malloc(sizeof(No)); (*pRaiz)->esquerda = NULL; (*pRaiz)->direita = NULL; (*pRaiz)->numero = numero; }else{ if(numero < (*pRaiz)->numero) inserir(&(*pRaiz)->esquerda, numero); if(numero > (*pRaiz)->numero) inserir(&(*pRaiz)->direita, numero); } }

Remoo

No *MaiorDireita(No **no){ if((*no)->direita != NULL) return MaiorDireita(&(*no)->direita); else{ No *aux = *no; if((*no)->esquerda != NULL) // se nao houver essa verificacao, esse n vai perder todos os seus filhos da esquerda! *no = (*no)->esquerda; else *no = NULL; return aux; } } No *MenorEsquerda(No **no){ if((*no)->esquerda != NULL) return MenorEsquerda(&(*no)->esquerda); else{ No *aux = *no; if((*no)->direita != NULL) // se nao houver essa verificacao, esse n vai perder todos os seus filhos da direita! *no = (*no)->direita; else *no = NULL; return aux; } } void remover(No **pRaiz, int numero){ if(*pRaiz == NULL){ // esta verificacao serve para caso o numero nao exista na arvore. printf("Numero nao existe na arvore!"); getch(); return; } if(numero < (*pRaiz)->numero) remover(&(*pRaiz)->esquerda, numero); else if(numero > (*pRaiz)->numero) remover(&(*pRaiz)->direita, numero); else{ // se nao eh menor nem maior, logo, eh o numero que estou procurando! :) No *pAux = *pRaiz; // quem programar no Embarcadero vai ter que declarar o pAux no inicio do void! :[ if (((*pRaiz)->esquerda == NULL) && ((*pRaiz)->direita == NULL)){ // se nao houver filhos... free(pAux); (*pRaiz) = NULL; } else{ // so tem o filho da direita if ((*pRaiz)->esquerda == NULL){ (*pRaiz) = (*pRaiz)->direita; pAux->direita = NULL; free(pAux); pAux = NULL; } else{ //so tem filho da esquerda if ((*pRaiz)->direita == NULL){ (*pRaiz) = (*pRaiz)->esquerda; pAux->esquerda = NULL free(pAux); pAux = NULL; }

else{ //Escolhi fazer o maior filho direito da subarvore esquerda. pAux = MaiorDireita(&(*pRaiz)->esquerda); //se vc quiser usar o Menor da esquerda, so o que mudaria seria isso: pAux->esquerda = (*pRaiz)->esquerda; // pAux = MenorEsquerda(&(*pRaiz)->direita); pAux->direita = (*pRaiz)->direita; (*pRaiz)->esquerda = (*pRaiz)->direita = NULL; free((*pRaiz)); *pRaiz = pAux; pAux = NULL; } } } } }

Em ordem
void exibirEmOrdem(No *pRaiz){ if(pRaiz != NULL){ exibirEmOrdem(pRaiz->esquerda); printf("\n%i", pRaiz->numero); exibirEmOrdem(pRaiz->direita); } }

Pr-ordem
void exibirPreOrdem(No *pRaiz){ if(pRaiz != NULL){ printf("\n%i", pRaiz->numero); exibirPreOrdem(pRaiz->esquerda); exibirPreOrdem(pRaiz->direita); } }

Ps-ordem
void exibirPosOrdem(No *pRaiz){ if(pRaiz != NULL){ exibirPosOrdem(pRaiz->esquerda); exibirPosOrdem(pRaiz->direita); printf("\n%i", pRaiz->numero); } }

Contar ns
int contarNos(No *pRaiz){ if(pRaiz == NULL) return 0; else return 1 + contarNos(pRaiz->esquerda) + contarNos(pRaiz>direita); }

Contar folhas

int contarFolhas(No *pRaiz){ if(pRaiz == NULL) return 0; if(pRaiz->esquerda == NULL && pRaiz->direita == NULL) return 1; return contarFolhas(pRaiz->esquerda) + contarFolhas(raiz->direita); }

Altura da rvore
int maior(int a, int b){ if(a > b) return a; else return b; }

int altura(No *pRaiz){ if((pRaiz == NULL) || (pRaiz->esquerda == NULL && pRaiz->direita == NULL)) return 0; else return 1 + maior(altura(pRaiz->esquerda), altura(pRaiz>direita)); }

Estrutura Completa
# include <iostream> # include <queue> # include <stl_queue.h> using namespace std; class No { public : int valor; No *direito, *esquerdo; No (); No (int); }; No :: No () { this->direito = this->esquerdo = NULL; } No :: No(int valor) { this->valor = valor; this->direito = this->esquerdo = NULL; } class ArvoreBinaria { protected : No *raiz; int Busca (No*, int); void PreOrdem (No*); void EmOrdem (No*); void PosOrdem (No*); int remove (No*,int);

public

void percursoEmLargura(No *); int Altura (No*); int Nivel (No*, int, int); : ArvoreBinaria (); int Altura (); int Nivel (int); bool Vazio (); int Busca (int); void insere (int); int remove (int); void percursoEmLargura(); No* noMaior(No*); void PreOrdem (); void EmOrdem (); void PosOrdem ();

}; No* ArvoreBinaria :: noMaior(No *raiz){ No *temp=NULL; temp = raiz; if(temp->direito== NULL){ raiz = raiz->esquerdo; return temp; } else return noMaior(raiz->direito); } int ArvoreBinaria :: Nivel(No *inicio, int valor, int nivel) { if (!inicio) return -1; else { if (valor == inicio->valor) return nivel; else { ++nivel; if (valor < inicio->valor) nivel = Nivel (inicio->esquerdo, valor, nivel); else if (valor > inicio->valor) nivel = Nivel (inicio->direito, valor, nivel); } return nivel; } } void ArvoreBinaria :: percursoEmLargura(No *inicio){ No *temp = NULL; queue *auxFila = NULL; if(inicio != NULL){ // !inicio auxFila->push(inicio); while(auxFila->empty() != true){ temp = auxFila->pop(); if(temp->esquerdo != NULL) auxFila->push(temp->esquerdo); if(temp->direito != NULL) auxFila->push(temp->direito); cout << temp->valor<< endl;

} } } void ArvoreBinaria :: percursoEmLargura() { return percursoEmLargura (this->raiz); } int ArvoreBinaria :: Nivel(int valor) { return Nivel (this->raiz, valor, 0); } int ArvoreBinaria ::Altura(No *inicio) { if (!inicio) return -1; else { int alturaesquerda, alturadireita; alturaesquerda = Altura (inicio->esquerdo); alturadireita = Altura (inicio->direito); if (alturaesquerda < alturadireita) return alturadireita + 1; else return alturaesquerda + 1; } } int ArvoreBinaria :: Altura() { return Altura (this->raiz)+1; } int ArvoreBinaria :: Busca (No *inicio, int valor) { while (inicio != NULL) { if (valor == inicio->valor) return inicio->valor; else if (valor < inicio->valor) inicio = inicio->esquerdo; else inicio = inicio->direito; } return 0; } void ArvoreBinaria :: PreOrdem (No *inicio) { if (inicio != NULL) { this->PreOrdem (inicio->esquerdo); cout << inicio->valor << " "; this->PreOrdem (inicio->direito); } } void ArvoreBinaria :: EmOrdem (No *inicio) { if (inicio != NULL) { cout << inicio->valor << " "; this->EmOrdem (inicio->esquerdo); this->EmOrdem (inicio->direito); } } void ArvoreBinaria :: PosOrdem (No *inicio) {

if (inicio != NULL) { this->PosOrdem (inicio->esquerdo); this->PosOrdem (inicio->direito); cout << inicio->valor << " "; } } ArvoreBinaria :: ArvoreBinaria () { this->raiz = NULL; } bool ArvoreBinaria :: Vazio () { return this->raiz == NULL; } void ArvoreBinaria :: insere (int valor) { No *tmp = this->raiz; No *ant = NULL; while (tmp != NULL) { ant = tmp; if (tmp->valor < valor) { tmp = tmp->direito; } else { tmp = tmp->esquerdo; } } if (this->Vazio()) { this->raiz = new No (valor); } else if (ant->valor < valor) { ant->direito = new No (valor); } else { ant->esquerdo = new No (valor); } } int ArvoreBinaria :: remove (No *raiz, int valor){ No *temp = NULL; if(raiz == NULL) return 1; if(valor == raiz->valor){ temp = raiz; if(raiz->esquerdo == NULL) raiz = raiz->direito; else if(raiz->direito == NULL) raiz = raiz->esquerdo; else{ temp = noMaior(raiz->esquerdo); raiz->valor = temp->valor; } delete temp; return 0; } else if(valor < raiz->valor) return remove(raiz->esquerdo, valor);

else return remove(raiz->direito, valor); } int ArvoreBinaria :: remove (int valor){ return remove (this->raiz, valor); } int ArvoreBinaria :: Busca (int valor){ return Busca (this->raiz, valor); } void ArvoreBinaria :: PreOrdem () { PreOrdem (this->raiz); } void ArvoreBinaria :: EmOrdem () { EmOrdem (this->raiz); } void ArvoreBinaria :: PosOrdem () { PosOrdem (this->raiz); }

Algoritmos de ordenao Insertion sort

void insertion_sort(int tabela[], int largura) { int i, memoria, contador; bool marcador; for(i=1; i<largura; i++) { memoria = tabela[i]; contador = i-1; do { marcador = false; if(tabela[contador] > memoria) { tabela[contador+1] = tabela[contador]; contador--; marcador = true; } if(contador < 0) marcador = false; } while(marcador); } tabela[contador+1] = memoria;

Selection sort

void selectionSort( int vetorDesordenado[], int tamanhoVetor ) //Funao selection recebendo vetor e tamanho { int i, j, posicaoValorMinimo; for (i = 0; i < ( tamanhoVetor - 1 ); i++) //Loop para percorrer o vetor { posicaoValorMinimo = i; //O valor minimo de posiao do vetor a ser percorrido e 0 for (j = ( i + 1 ); j < tamanhoVetor; j++)//Percorreremos o vetor da posiao 1 ate o tamanho estimado { if( vetorDesordenado[j] < vetorDesordenado[posicaoValorMinimo] ) //Se a posiao que vamos verificar for menos que a posiao que temos em maos { posicaoValorMinimo = j;//A variavel 'j' recebe esse valor } } if ( i != posicaoValorMinimo ) { trocarPosicaoValores( &vetorDesordenado[i], &vetorDesordenado[posicaoValorMinimo] );//vamos chamar uma outra funao para trocar as posioes de lugares } } } void trocarPosicaoValores( int *posicaoA, int *posicaoB )//Funao para trocar as posioes que estamos olhando { int temporario; temporario = *posicaoA; *posicaoA = *posicaoB; *posicaoB = temporario; }

Bubble sort
O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de ordenao dos mais simples. A ideia percorrer o vetor diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da sequncia. Essa movimentao lembra a forma como as bolhas em um tanque de gua procuram seu prprio nvel, e disso vem o nome do algoritmo. No melhor caso, o algoritmo executa operaes relevantes, onde n representa o nmero de elementos do vetor. No pior caso, so feitas operaes. A complexidade desse algoritmo de Ordem quadrtica. Por isso, ele no recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados.

Cdigo da Funo
void BubbleSort(int vetor[], int tamanho) {

int aux, i, j; for(j=tamanho-1; j>=1; j--) { for(i=0; i<j; i++) { if(vetor[i]>vetor[i+1]) { aux=vetor[i]; vetor[i]=vetor[i+1]; vetor[i+1]=aux; } } } }

Cdigo da Funo Melhorado

Termina a execuo quando nenhuma troca realizada aps uma passada pelo vetor.
void BubbleSort(int vetor[], int tamanho) { int memoria, troca, i, j; troca=1; /*A varivel "troca" ser a verificao da troca em cada passada*/ for(j=tamanho-1; (j>=1) && (troca==1); j--) { troca=0; /*Se o valor continuar 0 na prxima passada quer dizer que no houve troca e a funo encerrada.*/ for(i=0; i<j; i++) { if(vetor[i]>vetor[i+1]) { memoria=vetor[i]; vetor[i]=vetor[i+1]; vetor[i+1]=memoria; troca=1; /*Se houve troca, "troca" recebe 1 para continuar rodando.*/ } } } }

Algoritmo de alocao
first fist best fit worst fit
O algoritmo worst fit aloca o bloco de memria na regio que tem o maior espao livre.

Est tcnica por procurar ocupar primeiro as parties maiores termina por deixar espaos livres que poderiam ser utilizados para que outros blocos de outros programas as utilizassem, diminuindo e/ou retardando a fragmentao.

Next Fit Buddy System

Esta pgina somente um esboo. Ampliando-a voc ajudar a melhorar o Wikilivros.

Estudo
Este mdulo tem a seguinte tarefa pendente: Fazer a fuso do contedo que est aqui nos mdulos do livro de maneira organizada. Favor no adicionar contedo nesta pgina e sim nos mdulos do livro

Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Funes
Como dissemos no incio, as funes no so mais do que pedaos de cdigo que estava na funo main() e que resolvemos tirar para fora do main e demos um nome. Isto tem duas vantagens: Uma primeira porque temos blocos mais pequenos de cdigo e permite uma melhor leitura e deteco de erros. Por outro lado permite utilizar vrias vezes ao longo do bloco do main, apenas chamando. S temos que cumprir com alguns requisitos: necessitamos de dizer que tipo de retorno vai ter e que parmetros vo receber. Os parmetros so as variveis que colocamos dentro das (). Isto facilita porque podemos necessitar do resultado de uma funo para executar uma outra. A ideia de uma funo est, naturalmente, permitir voc encapsular um ideia ou operao, dando um nome a ela, ento chamar que operao de vrias partes do resto de seu programa simplesmente usando o seu nome. Estando corretamente projetado e estruturado os programas, dever ser possvel a mudana do caminho que uma funo faz seu trabalho (como espera-se que o trabalho em si prprio no muda) sem efeito no resto do programa.

Exemplo: imaginemos que tnhamos um cdigo do tipo

#include <stdio.h> #include <stdlib.h> int main () { printf ("Ola!\n "); printf ("Eu estou vivo!\n"); system (pause); return 0; }

aqui a nossa funo main () vai imprimir apenas duas frases! mas agora imaginemos que o nosso cdigo comeava a ter muitas e muitas linhas e necessitvamos de colocar vrias vezes o printf ("Ola!\n "); ento o que que fazamos? crivamos uma funo. tirvamos para fora do main e escrevamos da seguinte maneira:
#include <stdio.h> #include <stdlib.h> int mensagem () /* Funo simples: s imprime Ol! */ { printf ("Ola!\n "); return 0; } int main () { mensagem(); printf ("Eu estou vivo!\n"); system (pause); return 0; }

Ou seja crimos uma funo sem argumentos. repare que so as chavetas () que dizem que aquilo uma funo. Vamos agora pegar num exemplo melhor 2 Exemplo criao de funo com 1 argumento
#include <stdio.h> #include <stdlib.h> int square (int x) /* Calcula o quadrado de x */ { printf ("O quadrado e %d\n\n ",(x*x)); return 0; } int main (){ int num; printf ("Entre com um numero: "); scanf ("%d",&num); square(num); system (pause); return 0; }

Repare no seguinte: quando chamamos a funo square() no main estamos a colocar a varivel do main! esse valor do num copiado e vai entrar como input da funo square. realizado as linhas de cdigo da funo square e quando estas terminarem voltamos para o main.

3 Exemplo criao de funo com 3 argumento

#include <stdio.h> #include <stdlib.h> int mult (float a, float b,float c) { printf ("%f",a*b*c); return 0; } int main () { float x,y; x=23.5; y=12.9; mult (x,y,3.87); system (pause); return 0; } /* Multiplica 3 numeros */

Neste exemplo temos inputs que podem ser constantes, por isso no necessrio serem variveis. mas convm dizer o seguinte: 1. Em primeiro lugar temos de satisfazer aos requisitos da funo quanto ao tipo e quantidade de argumentos quando a chamamos. Apesar de existirem algumas converses de tipo, que o C faz automaticamente, importante ficar atento. 2. Em segundo lugar, no importante o nome da varivel que se passa como argumento, ou seja, a varivel num, ao ser passada como argumento para square() copiada para a varivel x. Dentro de square() trabalha-se apenas com x. Se mudarmos o valor de x dentro de square() o valor de num na funo main() permanece inalterado 3. Repare que, neste caso, os argumentos so separados por vrgula e que deve-se explicitar o tipo de cada um dos argumentos, um a um. Note, tambm, que os argumentos passados para a funo no necessitam ser todos variveis porque mesmo sendo constantes sero copiados para a varivel de entrada da funo. 4. h ainda um outro requisito, que a funo main aquela que primeiro executada, e sequencial. Agora no sei bem porqu, mas as funes extras tm de ser enumeradas antes do main(). tal como os headers. Penso que porque o compilador tem de saber que tipo de retorno vai ter. Da surgiram os prottipos.

Ponteiros para Funes

O C permite que acessemos variveis e funes atravs de ponteiros! Podemos ento fazer coisas como, por exemplo, passar uma funo como argumento para outra funo. Um ponteiro para uma funo tem a seguinte declarao:
tipo_de_retorno (*nome_do_ponteiro)();

ou
tipo_de_retorno (*nome_do_ponteiro)(declarao_de_parmetros);

Repare nos parnteses que devem ser colocados obrigatoriamente. Se declaramos:

tipo_de_retorno * nome(declarao_de_parmetros);

Estaramos, na realidade, declarando uma funo que retornaria um ponteiro para o tipo especificado. Porm, no obrigatrio se declarar os parmetros da funo. Veja um exemplo do uso de ponteiros para funes:
#include <stdio.h> #include <string.h> void PrintString (char *str, int (*func)(const char *)); int main (void) { char String [20]="Curso de C."; int (*p)(const char *); /* Declaracao do ponteiro para funo Funcao apontada e' inteira e recebe como parametro uma string constante */ p=puts; /* O ponteiro p passa a apontar para a funo puts que tem o seguinte prototipo: int puts(const char *) */ PrintString (String, p); /* O ponteiro passado como parametro para PrintString */ return 0; } void PrintString (char *str, int (*func)(const char *)) { (*func)(str); /* chamada a funo atravs do ponteiro para funo */ func(str); /* maneira tambm vlida de se fazer a chamada a funo puts atravs do ponteiro para funo func */ }

Veja que fizemos a atribuio de puts a p simplesmente usando:

p = puts;

Disto, conclumos que o nome de uma funo (sem os parnteses) , na realidade, o endereo daquela funo! Note, tambm, as duas formas alternativas de se chamar uma funo atravs de um ponteiro. No programa acima, fizemos esta chamada por: (*func)(str); e func(str); Estas formas so equivalentes entre si. Alm disto, no programa, a funo PrintString() usa uma funo qualquer func para imprimir a string na tela. O programador pode ento fornecer no s a string mas tambm a funo que ser usada para imprim-la. No main() vemos como podemos atribuir, ao ponteiro para funes p, o endereo da funo puts() do C. Em sntese, ao declarar um ponteiro para funo, podemos atribuir a este ponteiro o endereo de uma funo e podemos tambm chamar a funo apontada atravs dele. No podemos fazer algumas coisas que fazamos com ponteiros "normais", como, por exemplo, incrementar ou decrementar um ponteiro para funo.

Abrindo e Fechando um Arquivo

Arquivos pr-definidos:

stdin: dispositivo de entrada padro (geralmente o teclado) stdout: dispositivo de sada padro (geralmente o vdeo) stderr: dispositivo de sada de erro padro (geralmente o vdeo) stdaux: dispositivo de sada auxiliar (em muitos sistemas, associado porta serial) stdprn: dispositivo de impresso padro (em muitos sistemas, associado porta paralela)

O sistema de entrada e sada do ANSI C composto por uma srie de funes, cujos prottipos esto reunidos em stdio.h . Todas estas funes trabalham com o conceito de "ponteiro de arquivo". Este no um tipo propriamente dito, mas uma definio usando o comando typedef. Esta definio tambm est no arquivo stdio.h. Podemos declarar um ponteiro de arquivo da seguinte maneira:
FILE *p;

p ser ento um ponteiro para um arquivo. usando este tipo de ponteiro que vamos poder manipular arquivos no C. pelo o que eu estou a perceber o nome FILE tipo um int ou um float ou ainda um typedef 1. 2. 3. 4. 5. 6. fopen - opens a text file fclose - closes a text file feof - detects end-of-file marker in a file fgets - reads a string from a file fputs - prints a string to a file ferror e perror

7. fread 8. fwrite 9. fseek 10. rewind 11. remove 12. fprintf - prints formatted output to a file 13. fscanf - reads formatted input from a file 14. fputc - prints a character to a file 15. fgetc - reads a character from a file

fopen
Esta a funo de abertura de arquivos. Seu prottipo :
FILE *fopen (char *nome_do_arquivo,char *modo);

O nome_do_arquivo determina qual arquivo dever ser aberto. Este nome deve ser vlido no sistema operacional que estiver sendo utilizado. O modo de abertura diz funo fopen() que tipo de uso voc vai fazer do arquivo. A tabela abaixo mostra os valores de modo vlidos: Modo Significado

"r"- read Abre um arquivo texto para leitura. O arquivo deve existir antes de ser aberto. "w"-write Abrir um arquivo texto para gravao. Se o arquivo no existir, ele ser criado. Se j existir, o contedo anterior ser destrudo. "a"-append Abrir um arquivo texto para gravao. Os dados sero adicionados no fim do arquivo ("append"), se ele j existir, ou um novo arquivo ser criado, no caso de arquivo no existente anteriormente. "r+" Abre um arquivo texto para leitura e gravao. O arquivo deve existir e pode ser modificado. "w+" Cria um arquivo texto para leitura e gravao. Se o arquivo existir, o contedo anterior ser destrudo. Se no existir, ser criado. "a+" Abre um arquivo texto para gravao e leitura. Os dados sero adicionados no fim do arquivo se ele j existir, ou um novo arquivo ser criado, no caso de arquivo no existente anteriormente. "rb" Abre um arquivo binrio para leitura. Igual ao modo "r" anterior, s que o arquivo binrio. "wb" Cria um arquivo binrio para escrita, como no modo "w" anterior, s que o arquivo binrio. "ab" Acrescenta dados binrios no fim do arquivo, como no modo "a" anterior, s que o arquivo binrio. "r+b" Abre um arquivo binrio para leitura e escrita. O mesmo que "r+" acima, s que o arquivo binrio. "w+b" Cria um arquivo binrio para leitura e escrita. O mesmo que "w+" acima, s que o arquivo binrio. "a+b" Acrescenta dados ou cria uma arquivo binrio para leitura e escrita. O mesmo que "a+" acima, s que o arquivo binrio.

Poderamos ento, para abrir um arquivo binrio para escrita, escrever:

FILE *fp; /* Declarao da estrutura*/ fp=fopen ("exemplo.bin","wb"); /* o arquivo se chama exemplo.bin e est localizado no diretrio corrente */ if (!fp) printf ("Erro na abertura do arquivo.");

A condio !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro a funo fopen() retorna um ponteiro nullo (NULL). Uma vez aberto um arquivo, vamos poder ler ou escrever nele utilizando as funes que sero apresentadas nas prximas pginas.

Exemplo:
#include <stdio.h> #define MAX 10 int main() { FILE *f; /* est criado um ponteiro para o arquivo */ int x; f=fopen("out","w"); /*a funo abre o file out no modo w*/ if (!f) return 1; for(x=1; x<=MAX; x++) fprintf(f,"%d\n",x); /*a a funo printf para file da fprintf */ fclose(f); return 0; }

Vai abrir um file chamado de out e escrever os nmeros de 1 a 10. Depois fecha o file. Repare que abrir um arquivo no modo w destrutivo, ou seja, se o arquivo no existe ele vai ser criado, mas se existe um outro ficheiro o novo ficheiro fica no seu lugar. O comando fopen retorna um ponteiro para o arquivo que guardado na varivel f. se no possvel abrir o arquivo o f fica com o valor null. Exemplo 2:
#include <stdio.h> #include <stdlib.h> int main() { FILE *f; char s[1000]; f=fopen("infile","r"); em modo r*/ if (!f) return 1; while (fgets(s,1000,f)!=NULL) zero,ie, at o enter*/

/*abre o file chamado infile /* no caso de abrir mal*/ /* enquando for diferente de

printf("%s",s); fclose(f); system (pause); return 0; }

/*fgets em vez do fscanf*/

para ler o file infile mas agora no modo r- de read. Repare que utilizamos o fgets em vez do fscanf porque este requere que o texto esteja perfeitamente formatado. o fgets ainda tem a vantagem de acrescentar um 1n em cada linha que l. ele vai ler at encontar o eof-end of file marker. no exemplo ele vai ler 1000 caracteres

fclose
Acabamos de usar um arquivo que abrimos, devemos fech-lo. Para tanto usa-se a funo
fclose(): int fclose (FILE *fp);

O ponteiro fp passado funo fclose() determina o arquivo a ser fechado. A funo retorna zero no caso de sucesso. Fechar um arquivo faz com que qualquer caracter que tenha permanecido no "buffer" associado ao fluxo de sada seja gravado. Mas, o que este "buffer"? Quando voc envia caracteres para serem gravados em um arquivo, estes caracteres so armazenados temporariamente em uma rea de memria (o "buffer") em vez de serem escritos em disco imediatamente. Quando o "buffer" estiver cheio, seu contedo escrito no disco de uma vez. A razo para se fazer isto tem a ver com a eficincia nas leituras e gravaes de arquivos. Se, para cada caracter que fossemos gravar, tivssemos que posicionar a cabea de gravao em um ponto especfico do disco, apenas para gravar aquele caracter, as gravaes seriam muito lentas. Assim estas gravaes s sero efetuadas quando houver um volume razovel de informaes a serem gravadas ou quando o arquivo for fechado. A funo exit () fecha todos os arquivos que um programa tiver aberto.

feof
EOF ("End of file") indica o fim de um arquivo. s vezes, necessrio verificar se um arquivo chegou ao fim. Para isto podemos usar a funo feof(). Ela retorna no-zero se o arquivo chegou ao EOF, caso contrrio retorna zero. Seu prottipo :
int feof (FILE *fp);

Outra forma de se verificar se o final do arquivo foi atingido comparar o caractere lido por getc com EOF. O programa a seguir abre um arquivo j existente e o l, caracter por caracter, at que o final do arquivo seja atingido. Os caracteres lidos so apresentados na tela:
#include <stdio.h> #include <stdlib.h>

int main() { FILE *fp; char c; fp = fopen("arquivo.txt","r"); /* Arquivo ASCII, para leitura */ if(!fp) { printf( "Erro na abertura do arquivo"); exit(0); } while((c = getc(fp) ) != EOF) /* Enquanto no chegar ao final do arquivo */ printf("%c", c); /* imprime o caracter lido */ fclose(fp); return 0; }

Verifique o exemplo.
#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { FILE *p; char c, str[30], frase[80] = "Este e um arquivo chamado: "; int i; printf("\n\n Entre com um nome para o arquivo:\n"); gets(str); /* Le um nome para o arquivo a ser aberto: */ if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do arquivo..*/ { printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); /* o programa aborta automaticamente */ } strcat(frase, str); for (i=0; frase[i]; i++) putc(frase[i],p); fclose(p); /* Se nao houve erro,imprime no arquivo e o fecha ...*/ p = fopen(str,"r"); /* Abre novamente para leitura */ c = getc(p); /* Le o primeiro caracter */ while (!feof(p)) /* Enquanto no se chegar no final do arquivo */ { printf("%c",c); /* Imprime o caracter na tela */ c = getc(p); /* Le um novo caracter no arquivo */ } fclose(p); /* Fecha o arquivo */ }

putc
A funo putc a primeira funo de escrita de arquivo que veremos. Seu prottipo :

int putc (int ch, FILE *fp);

Escreve um caractere no arquivo.O programa a seguir l uma string do teclado e escreve-a, caractere por caractere em um arquivo em disco (o arquivo arquivo.txt, que ser aberto no diretrio corrente).
#include <stdio.h> #include <stdlib.h> int main() { FILE *fp; char string[100]; int i; fp = fopen("arquivo.txt","w"); /* Arquivo ASCII, para escrita */ if(!fp) { printf( "Erro na abertura do arquivo"); exit(0); } printf("Entre com a string a ser gravada no arquivo:"); gets(string); for(i=0; string[i]; i++) putc(string[i], fp); /* Grava a string, caractere a caractere */ fclose(fp); system ("pause"); return 0; }

Depois de executar este programa, verifique o contedo do arquivo arquivo.txt (voc pode usar qualquer editor de textos). Voc ver que a string que voc digitou est armazenada nele.

fgets
Para se ler uma string num arquivo podemos usar fgets() cujo prottipo :
char *fgets (char *str, int tamanho,FILE *fp);

A funo recebe 3 argumentos: a string a ser lida, o limite mximo de caracteres a serem lidos e o ponteiro para FILE, que est associado ao arquivo de onde a string ser lida. A funo l a string at que um caracter de nova linha seja lido ou tamanho-1 caracteres tenham sido lidos. Se o caracter de nova linha ('\n') for lido, ele far parte da string, o que no acontecia com gets. A funo fgets semelhante funo gets(), porm, alm dela poder fazer a leitura a partir de um arquivo de dados e incluir o caracter de nova linha na string, ela ainda especifica o tamanho mximo da string de entrada. Como vimos, a funo gets no tinha este controle, o que poderia acarretar erros de "estouro de buffer". Portanto, levando em conta que o ponteiro fp pode ser substitudo por stdin, como vimos acima, uma alternativa ao uso de gets usar a seguinte construo:
fgets (str, tamanho, stdin);

fputs
Prottipo:
char *fputs (char *str,FILE *fp);

Escreve uma string num arquivo.

ferror e perror
Prottipo de ferror:
int ferror (FILE *fp);

A funo retorna zero, se nenhum erro ocorreu e um nmero diferente de zero se algum erro ocorreu durante o acesso ao arquivo. se torna muito til quando queremos verificar se cada acesso a um arquivo teve sucesso, de modo que consigamos garantir a integridade dos nossos dados. Na maioria dos casos, se um arquivo pode ser aberto, ele pode ser lido ou gravado. Porm, existem situaes em que isto no ocorre. Por exemplo, pode acabar o espao em disco enquanto gravamos, ou o disco pode estar com problemas e no conseguimos ler, etc. Uma funo que pode ser usada em conjunto com ferror() a funo perror() (print error), cujo argumento uma string que normalmente indica em que parte do programa o problema ocorreu.
#include <stdio.h> #include <stdlib.h> int main() { FILE *pf; char string[100]; if((pf = fopen("arquivo.txt","w")) ==NULL) { printf("\nNao consigo abrir o arquivo ! "); exit(1); } do { printf("\nDigite uma nova string. Para terminar, digite <enter>: "); gets(string); fputs(string, pf); putc('\n', pf); if(ferror(pf)) { perror("Erro na gravacao"); fclose(pf); exit(1); } }while (strlen(string) > 0); fclose(pf); }

fread
Podemos escrever e ler blocos de dados. Para tanto, temos as funes fread() e fwrite(). O prottipo de fread() :
unsigned fread (void *buffer, int numero_de_bytes, int count, FILE *fp);

O buffer a regio de memria na qual sero armazenados os dados lidos. O nmero de bytes o tamanho da unidade a ser lida. count indica quantas unidades devem ser lidas. Isto significa que o nmero total de bytes lidos :
numero_de_bytes*count

A funo retorna o nmero de unidades efetivamente lidas. Este nmero pode ser menor que count quando o fim do arquivo for encontrado ou ocorrer algum erro. Quando o arquivo for aberto para dados binrios, fread pode ler qualquer tipo de dados.

fwrite
A funo fwrite() funciona como a sua companheira fread(), porm escrevendo no arquivo. Seu prottipo :
unsigned fwrite(void *buffer,int numero_de_bytes,int count,FILE *fp);

A funo retorna o nmero de itens escritos. Este valor ser igual a count a menos que ocorra algum erro. O exemplo abaixo ilustra o uso de fwrite e fread para gravar e posteriormente ler uma varivel float em um arquivo binrio.
#include <stdio.h> #include <stdlib.h> int main() { FILE *pf; float pi = 3.1415; float pilido; if((pf = fopen("arquivo.bin", "wb")) == NULL) /* Abre arquivo binrio para escrita */ { printf("Erro na abertura do arquivo"); exit(1); } if(fwrite(&pi, sizeof(float), 1,pf) != 1) /* Escreve a varivel pi */ printf("Erro na escrita do arquivo"); fclose(pf); /* Fecha o arquivo */ if((pf = fopen("arquivo.bin", "rb")) == NULL) /* Abre o arquivo novamente para leitura */ { printf("Erro na abertura do arquivo"); exit(1); }

if(fread(&pilido, sizeof(float), 1,pf) != 1) /* Le em pilido o valor da varivel armazenada anteriormente */ printf("Erro na leitura do arquivo"); printf("\nO valor de PI, lido do arquivo e': %f", pilido); fclose(pf); return 0; }

Note-se o uso do operador sizeof, que retorna o tamanho em bytes da varivel ou do tipo de dados.

fseek
Para se fazer procuras e acessos randmicos em arquivos usa-se a funo fseek(). Esta move a posio corrente de leitura ou escrita no arquivo de um valor especificado, a partir de um ponto especificado. Seu prottipo :
int fseek (FILE *fp,long numbytes,int origem);

O parmetro origem determina a partir de onde os numbytes de movimentao sero contados. Os valores possveis so definidos por macros em stdio.h e so:
Nome SEEK_SET SEEK_CUR SEEK_END Valor 0 1 2 Significado Incio do arquivo Ponto corrente no arquivo Fim do arquivo

Tendo-se definido a partir de onde ir se contar, numbytes determina quantos bytes de deslocamento sero dados na posio atual.

rewind
A funo rewind() de prottipo
void rewind (FILE *fp);

retorna a posio corrente do arquivo para o incio.

remove
Prottipo:
int remove (char *nome_do_arquivo);

Apaga um arquivo especificado. O exerccio da pgina anterior poderia ser reescrito usando-se, por exemplo, fgets() e fputs(), ou fwrite() e fread(). A seguir apresentamos uma segunda verso que se usa das funes fgets() e fputs(), e que acrescenta algumas inovaes.
#include <stdio.h> #include <string.h> #include <stdlib.h>

int main() { FILE *p; char str[30], frase[] = "Este e um arquivo chamado: ", resposta[80]; int i; printf("\n\n Entre com um nome para o arquivo:\n"); /* Le um nome para o arquivo a ser aberto: */ fgets(str,29,stdin); /* Usa fgets como se fosse gets */ for(i=0; str[i]; i++) if(str[i]=='\n') str[i]=0; /* Elimina o \n da string lida */ if (!(p = fopen(str,"w"))) /* Caso ocorra algum erro na abertura do arquivo..*/ { /* o programa aborta automaticamente */ printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); } /* Se nao houve erro, imprime no arquivo, e o fecha ...*/ fputs(frase, p); fputs(str,p); fclose(p); p = fopen(str,"r"); /* abre novamente e le */ fgets(resposta, 79, p); printf("\n\n%s\n", resposta); fclose(p); /* Fecha o arquivo */ remove(str); /* Apaga o arquivo */ return 0; }

fprintf
A funo fprintf() funciona como a funo printf(). A diferena que a sada de fprintf() um arquivo e no a tela do computador. Prottipo:
int fprintf (FILE *fp,char *str,...);

Como j poderamos esperar, a nica diferena do prottipo de fprintf() para o de printf() a especificao do arquivo destino atravs do ponteiro de arquivo.

fscanf
A funo fscanf() funciona como a funo scanf(). A diferena que fscanf() l de um arquivo e no do teclado do computador. Prottipo:
int fscanf (FILE *fp,char *str,...);

Como j poderamos esperar, a nica diferena do prottipo de fscanf() para o de scanf() a especificao do arquivo destino atravs do ponteiro de arquivo.

Talvez a forma mais simples de escrever o programa da pgina 97 seja usando fprintf () e fscanf(). Fica assim:
#include <stdio.h> #include <stdlib.h> int main() { FILE *p; char str[80],c; printf("\n\n Entre com um nome para o arquivo:\n"); /* nome para o arquivo a ser aberto: */ gets(str); if (!(p = fopen(str,"w"))) /* ocorra algum erro na abertura do arquivo..*/ { /* programa aborta automaticamente */ printf("Erro! Impossivel abrir o arquivo!\n"); exit(1); } fprintf(p,"Este e um arquivo chamado:\n%s\n", str); fclose(p); /* houve erro, imprime no arquivo, fecha ...*/ p = fopen(str,"r"); /* abre novamente para a leitura */ while (!feof(p)) { fscanf(p,"%c",&c); printf("%c",c); } fclose(p); return 0; }

Le um Caso o

Se nao

Alocao Dinmica
A alocao dinmica permite ao programador alocar memria para variveis quando o programa est sendo executado. Assim, poderemos definir, por exemplo, um vetor ou uma matriz cujo tamanho descobriremos em tempo de execuo. O padro C ANSI define apenas 4 funes para o sistema de alocao dinmica, disponveis na biblioteca stdlib.h: No entanto, existem diversas outras funes que so amplamente utilizadas, mas dependentes do ambiente e compilador. Neste curso sero abordadas somente estas funes padronizadas. Pelo que eu percebi de dados dinmicos utilizar uma memria que dinmica, ie, quando utilizamos um programa utilizada essa memria e depois quando chamamos outro programa a mesma memria que utilizou o programa anterior agora utilizada para o novo programa. mas ressalve que os dados importantes do resultado do programa anterior so gravados. isto basicamente a historia de memria ram e rom.

malloc
A funo malloc() serve para alocar memria e tem o seguinte prottipo:

void *malloc (unsigned int num);

A funo toma o nmero de bytes que queremos alocar (num), aloca na memria e retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser atribudo a qualquer tipo de ponteiro. Se no houver memria suficiente para alocar a memria requisitada a funo malloc() retorna um ponteiro nulo. Veja um exemplo de alocao dinmica com malloc():

#include <stdio.h> #include <stdlib.h> /* Para usar malloc() */ main (void) { int *p; int a; int i; ... /* Determina o valor de a em algum lugar */ p=malloc(a*sizeof(int)); /* Aloca a nmeros inteiros p pode agora ser tratado como um vetor com a posicoes */ if (!p) { printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado como um vetor com a posicoes */ p[i] = i*i; ... return 0; }

No exemplo acima, alocada memria suficiente para se armazenar a nmeros inteiros. O operador sizeof() retorna o nmero de bytes de um inteiro. Ele util para se saber o tamanho de tipos. O ponteiro void* que malloc() retorna convertido para um int* pelo cast e atribudo a p. A declarao seguinte testa se a operao foi bem sucedida. Se no tiver sido, p ter um valor nulo, o que far com que !p retorne verdadeiro. Se a operao tiver sido bem sucedida, podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando-o de p[0] a p[(a-1)]. Os programas utilizam muito esta funo que reserva um bloco de memria que podemos utilizar vontade para o nosso programa e quando o bloco de cdigo executado ele reciclado pelo sistema operacional.
int main() { int *p; p = malloc(sizeof(int)); if (p == 0) { printf("ERROR: Out of memory\n"); return 1;

} *p = 5; printf("&d\n", *p); free(p); return 0; }

Vamos comear por tentar explicar esta linha de cdigo.

p = malloc(sizeof(int));

A funo malloc pegunta ao Heap (pretence ao sistema operacional) existe memria disponvel para um bloco de memria deste tamanho? e que tamnaho esse? esse valor depreendido pela funo sizeof(int). Como um int est a pedir 4 bytes. Assim a funo malloc retorna 0 se no consegue obter o tal espao de memria e 1 se consegue. Se consegue ento aloca um ponteiro para a varivel p. A seguinte linha de cdigo mostra o valor a ns pela tela qual o valor retornado pela funo malloc, se consegui arranjar o espao de memoria ou no. Vamos ver agora um exemplo;
int main() { int *p, *q; p = malloc(sizeof(int)); q = p; *p = 10; printf("%d\n", *q); *q = 20; printf("%d\n", *q); }

Outro exemplo
int main() { int *p, *q; p = malloc(sizeof(int)); malloc(4) */ q = malloc(sizeof(int)); *p = 10; *q = 20; *p = *q; printf("%d\n", *p); }

/*podemos simplificar por

p =

o compilador aceita *p=*q porque so ambos int. o compilador aceita tambm p=q porque ambos so ponteiros e apontam para o mesmo tipo.

Podemos simplificar p = malloc(sizeof(int)); por p = malloc(4); mas como temos sistemas operacionais de 16,32, 64 bits a primeira declarao torna as coisas mais portveis.

Repare que utilizamos o typecasting (int *) que fora a converso do ponteiro retornado do malloc que seja um ponteiro para um int.

calloc
A funo calloc() tambm serve para alocar memria, mas possui um prottipo um pouco diferente:
void *calloc (unsigned int num, unsigned int size);

A funao aloca uma quantidade de memria igual a num * size, isto , aloca memria suficiente para um vetor de num objetos de tamanho size. Retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser atribudo a qualquer tipo de ponteiro. Se no houver memria suficiente para alocar a memria requisitada a funo calloc() retorna um ponteiro nulo. Veja um exemplo de alocao dinmica com calloc():
#include <stdio.h> #include <stdlib.h> /* Para usar calloc() */

int main (void) { int *p; int a; int i; ... /* Determina o valor de a em algum lugar */ p=calloc(a,sizeof(int)); /* Aloca a nmeros inteiros p pode agora ser tratado como um vetor com a posicoes */ if (!p) { printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado como um vetor com a posicoes */ p[i] = i*i; ... return 0; }

No exemplo acima, alocada memria suficiente para se colocar a nmeros inteiros. O operador sizeof() retorna o nmero de bytes de um inteiro. Ele util para se saber o tamanho de tipos. O ponteiro void * que calloc() retorna convertido para um int * pelo cast e atribudo a p. A declarao seguinte testa se a operao foi bem sucedida. Se no tiver sido, p ter um valor nulo, o que far com que !p retorne verdadeiro. Se a operao tiver sido bem sucedida, podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando-o de p[0] a p[(a-1)].

realloc
A funo realloc() serve para realocar memria e tem o seguinte prottipo:

void *realloc (void *ptr, unsigned int num);

A funao modifica o tamanho da memria previamente alocada apontada por *ptr para aquele especificado por num. O valor de num pode ser maior ou menor que o original. Um ponteiro para o bloco devolvido porque realloc() pode precisar mover o bloco para aumentar seu tamanho. Se isso ocorrer, o contedo do bloco antigo copiado no novo bloco, e nenhuma informao perdida. Se ptr for nulo, aloca size bytes e devolve um ponteiro; se size zero, a memria apontada por ptr liberada. Se no houver memria suficiente para a alocao, um ponteiro nulo devolvido e o bloco original deixado inalterado.
#include <stdio.h> #include <stdlib.h> /* Para usar malloc() e realloc*/

int main (void){ int *p; int a; int i; ... /* Determina o valor de a em algum lugar */ a = 30; p=malloc(a*sizeof(int)); /* Aloca a nmeros inteiros p pode agora ser tratado como um vetor com a posicoes */ if (!p) { printf ("** Erro: Memoria Insuficiente **"); exit; } for (i=0; i<a ; i++) /* p pode ser tratado como um vetor com a posicoes */ p[i] = i*i; /* O tamanho de p deve ser modificado, por algum motivo ... */ a = 100; p = realloc (p, a*sizeof(int)); for (i=0; i<a ; i++) /* p pode ser tratado como um vetor com a posicoes */ p[i] = a*i*(i-6); ... return 0; }

free
Quando alocamos memria dinamicamente necessrio que ns a liberemos quando ela no for mais necessria. Para isto existe a funo free() cujo prottipo :
void free (void *p);

Basta ento passar para free() o ponteiro que aponta para o incio da memria alocada. Mas voc pode se perguntar: como que o programa vai saber quantos bytes devem ser liberados? Ele sabe pois quando voc alocou a memria, ele guardou o nmero de bytes alocados numa "tabela de alocao" interna. Vamos reescrever o exemplo usado para a funo malloc() usando o free() tambm agora:

#include <stdio.h> #include <stdlib.h>

/* Para usar malloc e free */

int main (void) { int *p; int a; ... p=malloc(a*sizeof(int)); if (!p) { printf ("** Erro: Memoria Insuficiente **"); exit; } ... free(p); ... return 0; }

Constantes
Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Constantes
Em um captulo anterior abordamos as variveis e agora vamos abordar constantes. A razo que as coisas esto mais maduras e uma pessoa sabe muito bem o que uma constante. Que simplesmente um valor que no se altera durante a execuo do programa. A questo de no se alterar durante a escrita do programa realmente a razo deste captulo. Devemos separar as guas entre uma constante e um literal. O literal o prprio valor. Existem 3 maneiras para criar constantes: 1. #define 2. [const] [tipo da varivel][nome da varivel] 3. enumerations Esta ltima vamos deixar para mais tarde, pois so uma boa introduo para as classes.

DEFINED CONSTANTS (#DEFINE)

#define PI 3.14159265 #define NEWLINE "\n"

Se colocarmos estas linhas no header, o que vai acontecer o seguinte: O prprocessador ir verificar o nosso cdigo fonte e sempre que encontrar a diretiva #define ir, literalmente, substituir cada ocorrncia do identificador no cdigo fonte pelo valor definido.

A vantagem disto que:

Podemos ter um identificador ao nosso gosto, e sempre que necessitarmos do valor escrevemos o identificador, em vez do valor, at porque se o valor fosse complicado poderamos enganar-nos a escrever. Claro que nos poderamos enganar tambm a escrever o identificador, da a escolhermos um nome familiar. E se necessitarmos de alterar o valor, alteramos apenas 1 vez, em vez de todas as vezes onde apareceria o valor.

O formato geral :
#define identificador valor

Repare que a diretiva de preprocessador no tem o ;- ponto e vrgula no fim! O que normal para diretivas de Preprocessador. O que que acontece se tivermos o ; no fim? Ser que encontrei um bug? se eu colocar o ; no #define NEWLINE '\n'; no acontece nada. Vale lembrar que cada #define preprocessador, ou seja, no pode ser alterado dentro do programa durante sua execuo.
// defined constants: calculate circumference #include <stdio.h> #define PI 3.14159 #define NEWLINE "\n" int main (){ double r=5.0; double circle; circle = 2 * PI * r; printf("%f", circle); printf("%s", NEWLINE ); return 0; } // radius // utilizamos o Pi e no 3.

Declared constants (const)

Ns podemos transformar uma varivel numa constante do gnero:

const int tamanho = 100; const char tabul = '\t'; const int codigo = 12440;

Com o prefixo "const", dizemos que a varivel no poder alterar o seu valor. Repare que se fosse uma varivel eu poderia ter:
int a=5;

e logo a seguir dizer

a=6;

e o valor do a ficava com o valor de 6; Agora com o prefixo const eu no poderei alterar o valor, porque constante constante, no pode mudar o valor. Esta maneira bem melhor do que a anterior para declarar constantes, primeiro porque aqui temos a informao do tipo de varivel, em segundo porque podemos fazer este const int a; como uma funo local e no global.

Condicionais
Esta pgina precisa ser reciclada (discuta). Ao melhor-la, voc estar ajudando o Wikilivros.

Aqui vamos criar funes que nos permitam alterar a leitura de execuo do cdigo. Ou seja, j dissemos que a leitura de execuo do cdigo de cima para baixo (l a primeira linha de cdigo executa, l a 2 linha --- executa,..e por a adiante) O que agora vamos fazer e criar mecanismos para alterar esse leitura sequencial e permitir:

Execuo de cdigo sujeito a condio Repetio de execuo de cdigo sujeito a condio Saltar linhas de cdigo

Branching - Funo IF
A funo if s executada se a expresso relacional for true=1. A sintax :
if (Boolean value) statement;

Reparar que s temos o ponto e virgula no final do statement.

Exemplificando:
#include <iostream> using namespace std; int main(void) { int num; cout << "entre com um nmero inteiro: ";

cin >> num; if ( num % 2 == 0 ) cout << "o nmero par" << endl; /* O comando system utilizar um argumento difetente conforme o compilador. Retire o comentrio daquela que parecer funcionar no compilador corrente */ // system (pause); // system ("PAUSE"); // cin.get() // Outra opo utiliza cin.get() ao invs de system ("PAUSE") return 0; }

No exemplo se colocarmos um valor impar o programa acaba, se colocarmos um valor par ele apresenta a frase o nmero par. Repare no operador de igualdade ==. Como o operador aritmtico tem uma precedncia superior em relao aos operadores relacionais primeiro feita a conta num%2. Erro: Um erro bastante comum colocar o ponto e virgula antes do statement como j avisei. Mas isto no vai dar um erro de compilao mas sim um erro lgico. Isto aceite porque permitido ter nenhum statement. Erro: Outro erro tambm bastante comum trocar o = por ==, ou seja querem fazer a comparao em vez de atribuio! Depois ainda temos o ponto se tivermos 2 statements depois do if, s o primeiro que afectado pela avaliao do valor boolean. Ou seja o 2 statement como estivesse fora do if. Para colocarmos vrios (+de 2) afectados pela avaliao do if temos de os colocar em grupo com {}. Pergunta: no tem realmente sentido a sintax do c++ permitir a questo do ponto e vrgula, para funes de controlo de execuo de cdigo. Deveria dar logo erro de compilao. Mas penso que isto se deve por termos mais operadores para alm do if.

IF-ELSE No exemplo anterior no acontecia nada se inserssemos um valor impar. Podemos remendar isso se utilizarmos o if-else
if (relational expression) conditional statement; else conditional statement;

Remendando o exemplo anterior ficamos com

#include <iostream> using namespace std; int main(void) { int num; cout << "Enter a whole number: "; cin >> num;

if ( num % 2 == 0 ) cout << "The number is even" << endl; else cout << "The number is odd" << endl; return 0; }

No utilizar o ; a seguir ao else Aqui tambm costuma acontecer um erro bem comum que
if ( num % 2 == 0 ) cout << "The number is even" << endl; else ( num % 2 == 1 ) cout << "The number is odd" << endl;

O problema est no else que no deve ter a expresso relacional

If - ELSE IF - Else
#include <iostream> using namespace std; int main(void) { int testScore; cout << "Entre com um valor (0 a 100): "; cin >> testScore; if (testScore >= 90 ) cout << "o valor A" << endl; else if (testScore >= 80 ) cout << " o valor B" << endl; else if (testScore >= 70 ) cout << " o valor C" << endl; else if (testScore >= 60 ) cout << " o valor D" << endl; else cout << " o valor F" << endl; return 0; }

Notar que o ultimo apenas else e no else if Mas h ainda aqui 1 pormenor importante. Se inserirmos 87, deveria dar B e ainda C e D, pois para ambos cumprida a relao de comparao. o que se passa que quando uma das hipteses realizada, os outros elses so ignorados. Portanto se alterssemos o else-if do C para antes do B teramos o resultado C. portanto aqui temos a questo da ordenao do cdigo

o programa comea a testar as condies comeando pela primeira at achar uma condio que seja verdadeira, se no encontrar nenhuma temos o else final (que o defaut) mas ela opcional!

IF-ELSE dentro de IF-ELSE

if (age >= 18) if(citizen == true) cout << "You are eligible to vote"; else cout << "You are not eligible to vote"; else cout << "You are not eligible to vote";

Chama-se a IF dentro de IF ou NESTED IF ou ainda em portugus IF ANINHADO

Branching - Switch
O switch muito parecido com o if-else. Apenas a sintaxe e construo diferente
#include <iostream> using namespace std; int main(void) { char grade; cout << "Enter your grade (A to F): cin >> grade; switch (grade) { case 'A': cout << "Your average endl; break; case 'B': cout << "Your average break; case 'C': cout << "Your average break; case 'D': cout << "Your average break; default: cout << "Your average } return 0; }

";

must be between 90 - 100"<<

must be between 80 - 89"<< endl; must be between 70 - 79"<< endl; must be between 60 - 69"<< endl; must be below 60" << endl;

Cada um dos casos tem de ser uma constante (no pode alterar durante a vida do programa), neste exemplo A, B, O defaut serve para a condio de todas as avaliaes dos casos anteriores der falsa. ( tipo o else) O break serve para terminar o switch, caso contrrio se num dado case fosse verdadeiro, iria executar todos os statementes mesmo de outros cases at terminar o switch. Aqui para cada caso no necessitamos de {} se tivermos mais do que 2 statements. o if-else mais forte do que o switch por que permite fazer coisas como:

if (apples == oranges) do this; else if (sales >= 5000) do that;

Para alm do ponto j dito de os casos serem obrigatoriamente constants, no switch Tambm posso utilizar operadores lgicos no switch

switch (age >= 18 && citizen == true) { case true: cout << "You are eligible to vote"; break; case false: cout << "You are not eligible to vote"; }

Loops
While
#include <iostream> using namespace std; int main(void) { int num = 1; while (num <= 10) { cout << num << " "; num++; } return 0; }

Notar que colocamos o incremento dentro do bloco caso contrrio tnhamos um loop infinito. Notar que se quisermos podemos ter o incremento e a condio ao mesmo tempo while (num++ < 10) Mas neste caso quem que tem maior precedncia o ++ postfix ou o <.? (Vem primeiro a comparao.)

do while
Aqui a diferena que o teste da condio feita depois dos statements, o que significa que os statements so executados pelo menos uma vez
do { statement(s); } while (condition);

A funo do while exactamente igual while s que pe a condio depois do bloco, o que significa que o bloco executado pelo menos uma vez. ou seja o seu uso garante que os statements ou declarao executada pelo menos uma vez! por isso que ela to usada nos menus.

for
Esta para mim a arma mais poderosa
#include <iostream> using namespace std; int main(void) { for (int num = 1; num <= 10; num++) cout << num << " "; return 0; }

A sintaxe
for ([iniciao]; [condio]; [incremento]) statement;

A condio tem de ser true (=1) para ser executado o statement. Depois dos statements serem executados vem a instruo de incremento e Novamente avaliada a condio. Se esta ainda for true volta-se a repetir o ciclo.

Notar mais uma vez onde est o ponto e vrgula. Notar que a condio pode ser a<10 || b>20, a iniciao e o incremento tambm podem ser desta forma.

Pergunta: se no tivermos um dos parmetros o que que acontece? Com esta possibilidade podemos alcanar loops infinitos, tipo Caso 1: ausncia do 2 parmetro
for (int num =1; ;num++) { cout << num << " "; }

Isto vai colocar um valor a mais no num indefinidamente. Caso 2: ausncia do 3 parmetro
for (int num=1; num <= 10; { cout << num << " "; } )

Isto vai repetir sempre o num=1, apesar de termos condio, mas a condio num chega a ser alcanada.

Felizmente o sistema operativo consegue detectar muitas vezes o loop infinito, mas caso isso no acontea utilizar o CRTL-BREAK. Podemos ter tambm loops dentro de loops Podemos tambm quebrar o loop atravs do break

O Comando break
O que o break faz quebrar a execuo para fora do bloco de cdigo onde ela est presente
#include <iostream> using namespace std; int main(void) { int num; char choice; bool quit = false; while (true) { cout << "Enter a positive number: "; cin >> num; if (num > 0) break; else { cout << "Number must be positive; try again (Y/N): "; cin >> choice; if (choice != 'Y') { quit = true; break; } } } if (quit == false) cout << "The number you entered is " << num << " "; else cout << "You did not enter a positive number"; return 0; }

O break faz com que a execuo do programa continue na primeira linha seguinte ao loop ou bloco

O Comando continue
Esta instruo bem parecida com o break, mas algo diferente. Pois em vez de mandar a execuo para fora do bloco manda-a para a avaliao do loop. Ou seja faz saltar uma determinada iterao do loop, enquanto o break faz acabar o loop
#include <iostream> using namespace std; int main(void) { int num, counter = 0, total = 0; cout << "How many items do you want to buy: "; cin >> num; while (counter++ < num) { if (counter % 13 == 0) continue; total += 3; } cout << "Total for " << num << " items is $" << total; return 0; }

Neste exemplo quando o conter for mltiplo de 13, a instruo seguinte saltada total+=3

O Comando goto
O goto realiza um salto para um local especificado. Este local determinado por um rtulo. Portanto pode ser em qualquer parte do programa.
nome_do_rtulo: .... goto nome_do_rtulo; ....

// goto loop example #include <iostream> using namespace std; int main () { int n=10; loop: cout << n << ", ";

n--; if (n>0) goto loop; cout << "FIRE!"; return 0; }

repare no rtulo

Terminando o programa
Esta funo definida com a biblioteca cstdlib (c+std+lib) O propsito da funo terminar com o programa com um especfico cdigo de sada O prottipo :

int exit (int exitcode);

Esta funo usada por alguns sistemas operativos e podem ser usadas para chamar programas. Por conveno o cdigo 0 se sada significa que o programa terminou normalmente, como previsto, se vier com outro nmero significa que houve um erro e algo de inesperado sucedeu.

Operador vrgula ( , )
O operador vrgula (,) usado para separar 2 ou mais expresses onde se espera apenas uma expresso. Quando tivermos vrias expresses estiverem a ser avaliadas para um valor, a expresso mais direita a que considerada.

a = (b=3, b+2);

Neste exemplo iria colocar o valor 3 em b e depois adicionaria 2 ao valor de b ficando a com 5 e b com 3

Operador condicional ?
A sintaxe

[Relational expression] ? [statement if true] : [statement if false]

Ou seja, este operador faz um teste expresso relacional e se o resultado for verdadeiro executa logo a 1 afirmao caso contrrio executa a segunda. ou seja isto no mais do que um if-else.

H quem goste de usar este operador porque poupa escrita, mas acho que no vale a pena!
#include <iostream> using namespace std; int main(void) { int num; cout << "Enter a whole number: "; cin >> num; cout << "The number is " << (num % 2 == 0 ? "even" : "odd") << endl; return 0; }

Notar que o operador condicional exige 3 operandos. vamos fazer uns exerccios:

7==5 ? 4 : 3 // returns 3, since 7 is not equal to 5. 7==5+2 ? 4 : 3 // returns 4, since 7 is equal to 5+2. 5>3 ? a : b // returns the value of a, since 5 is greater than 3. a>b ? a : b // returns whichever is greater, a or b.

Incrementar/decrementar
Aqui vamos voltar a um tpico anterior que foi abordado nos operadores Temos

a=a+1 equivalente a ter a+=1 e ainda a ter a++ (este novo)

Mas isto tudo s no caso do incremento ser 1. Podemos ter ++a ou ainda a++. Eles so parecidos mas diferentes, a questo do prefixo e ps-fixo. A diferena que

O prefixo, faz o incremento ainda durante a instruo O ps-fixo faz o incremento quando se passa para a instruo seguinte.

#include <iostream> using namespace std; int main(void) { int num = 2; cout << num << \n; cout << ++num << \n; cout << num++ <<\n; cout << num << \n; return 0; }

Portanto

int num = 5; cout << (++num == 5);

Exerccios
Crie um programa que d o factorial de um nmero
#include <iostream> using namespace std; int main(void) { int num, counter, total = 1; cout << "Enter a number: "; cin >> num; cout << "The factorial of " << num << " is "; for (int counter = 1; counter <= num; counter++) total *= counter; cout << total; return 0; }

Crie um programa para o utilizador adivinhar um nmero de 0 a 3. D 3 hipteses para adivinhar. No caso de acertar antes de chegar ao fim das 3 hipteses termine.
#include <iostream> using namespace std; int main(void) { int num, counter, secret = 3; cout << "Guess a number between 1 and 10\n"; cout << "You have 3 tries\n"; for (int counter = 1; counter <= 3; counter++) { cout << "Enter the number now: "; cin >> num; if (num == secret) { cout << "You guessed the secret number!"; break; } } cout << "Program over"; return 0; }

Criao de menu.
#include <iostream> using namespace std; int main ()

{ int do { i;

cout << "\n\nEscolha a fruta pelo numero:\n\n"; cout << "\t(1)...Mamao\n"; cout << "\t(2)...Abacaxi\n"; cout << "\t(3)...Laranja\n\n"; cin >> i; } while ((i<1)||(i>3)); switch (i) { case 1: cout << ("\t\tVoce escolheu Mamao.\n"); break; case 2: cout <<"\t\tVoce escolheu Abacaxi.\n"; break; case 3: cout << ("\t\tVoce escolheu Laranja.\n"); break; } return(0); }

Lista de autores
Lista de autores

Edudobay - Eduardo Sangiorgio Dobay EvertonS - Everton.S.Baron Lightningspirit ThiagoL Uder Wbrito RenatoResende Maxtremus Noturno99 - Bruno Sampaio Pinho da Silva