Programar em C

Programar em C
PDF gerado usando o pacote de ferramentas em cdigo aberto mwlib. Veja http://code.pediapress.com/ para mais informaes. PDF generated at: Fri, 21 Jun 2013 14:08:55 UTC
Contedo
Pginas
Capa Por que aprender a linguagem C Histria da linguagem C Pr-requisitos Utilizando um compilador Noes de compilao Um programa em C Conceitos bsicos Variveis Constantes Entrada e sada simples Operaes matemticas (Bsico) Operaes matemticas (Avanado) Operadores Controle de fluxo Funes Pr-processador Exerccios Vetores Strings Passagem de parmetros Tipos de dados definidos pelo usurio Enumerao Unio Estruturas Ponteiros Mais sobre variveis Mais sobre funes Bibliotecas Entrada e sada em arquivos Gerenciamento de memria Sockets Makefiles Lista de palavras reservadas 1 1 2 5 6 8 9 10 13 17 19 29 31 35 41 51 59 64 75 78 82 83 89 92 94 100 115 122 126 129 133 139 140 148
Seqncias de escape Lista de funes Lista de bibliotecas Dicas de programao em C Listas encadeadas Pilha Fila ou Queue rvores binrias Algoritmos de ordenao Algoritmo de alocao Lista de autores
148 149 150 151 155 158 160 162 166 169 170
Referncias
Fontes e Editores da Pgina Fontes, Licenas e Editores da Imagem 171 173
Licenas das pginas

Licena 174
Capa
Capa
ndice>> Ir para o ndice >>
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
Por que aprender a linguagem C 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
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.
Kenneth Thompson ( esquerda) e Dennis Ritchie ( direita), os criadores da linguagem C
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 "no-oficiais" 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-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.
Pr-requisitos 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 [1]: pgina para download do CodeBlocks, uma IDE para C ao estilo do Dev-C++, porm, mais nova. Dev-C++ [2]: pgina para download do Dev-C++. DJGPP [3]: pgina oficial, com informaes e links para download. GCC [4]: pgina oficial do compilador para diversas plataformas.
Referncias
[1] [2] [3] [4] http:/ / www. codeblocks. org http:/ / www. bloodshed. net/ dev/ devcpp. html http:/ / www. delorie. com/ djgpp/ http:/ / gcc. gnu. org/
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
Utilizando um compilador 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
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
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.
Um programa em C
[1] Esse comando uma diretiva do pr-processador; voc aprender mais sobre esses comandos na seo Pr-processador.
10
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; } {
Conceitos bsicos 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.
11
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);
Conceitos bsicos 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.
12
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
13
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;
Variveis
14
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; float, para reais entre (aproximadamente) 10-38 e 1038, utiliza 4 bytes, preciso de 7 dgitos; double, para reais entre (aproximadamente) 10-4932 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 Formato para leitura com scanf Intervalo Inicio Fim 8 %c -128 127 8 %c 0 255
char unsigned char
Variveis 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 8 %c -128 127 16 %i -32.768 32.767 16 %u 0 65.535 16 %i -32.768 32.767 16 %hi -32.768 32.767 16 %hu 0 65.535 16 %hi -32.768 32.767 32 %li -2.147.483.648 2.147.483.647 32 %li -2.147.483.648 2.147.483.647 32 %lu 0 4.294.967.295 32 %f 3,4E-38 3.4E+38 64 %lf 1,7E-308 1,7E+308 80 %Lf 3,4E-4932 3,4E+4932
15
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;
Variveis 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.
16
#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.
Variveis
17
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.
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.
Constantes
18
DEFINED CONSTANTS (#DEFINE)

#define PI 3.14159265 #define NEWLINE "\n"
Se colocarmos estas linhas no header, o que vai acontecer o seguinte: O pr-processador 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.
Constantes
19
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.
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.
20
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");
21
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.
22
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 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. Ponteiro: exibe o endereo de memria do ponteiro em notao hexadecimal. Caractere: imprime o caractere que tem o cdigo ASCII correspondente ao valor dado. Sequncia de caracteres (string, em ingls). Imprime um %
%X %f
%e %E %g %p %c %s %%
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.
Entrada e sada simples 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); E alguns outros exemplos: printf ("%-10s", "Jos"); printf ("%10s", "Jos"); printf ("%4s", "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" // exibe "Jos " // exibe " Jos" // exibe "Jos" // exibe " 15" // exibe "00015" // exibe "15 "
23
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
Entrada e sada simples resultar nisto: " 3.4500"
24
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:
25
Sequncia \n \t \b \r \a \f \v \" \' \\ \0 \N \xN Quebra de linha (line feed ou LF) Tabulao horizontal
Significado
Retrocede o cursor em um caractere (backspace) Retorno de carro (carriage return ou CR): volta o cursor para o comeo da 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 Octal \00 \12 \15 \07 \10 \13 Caracter \0 \n \r \a \b \v
scanf()
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);
Entrada e sada simples 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 e %g so sinnimos de %f. %lf deve ser usado para variveis do tipo double. %s 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
26
Entrada e sada simples 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.
27
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()
Entrada e sada simples { 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().
28
sprintf() e sscanf()
sprintf 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; }
Entrada e sada simples Nesse exemplo, usamos a funo sscanf para interpretar os valores contidos na string e guard-los nas variveis numricas.
29
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; }
Operaes matemticas (Bsico) 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.
30
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
Operaes matemticas (Bsico) 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.
31
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 */
32
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 */
33
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 */
34
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 */
35
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) [1]
Referncias
[1] http:/ / www. cplusplus. com/ reference/ clibrary/ cmath/
Operadores
Operadores Aritmticos
Tabela: Operadores aritmeticos
Operador Finalidade + * / % Adio Subtrao Multiplicao Diviso (Quociente) Exemplo Resultado 5+2 52 5*2 5/2 7 3 10 2 2
Diviso Euclidiana (Resto) 30 % 7
Notar o ltimo operador. Notar que so operadores que operam apenas com 2 operandos (operadores binrios). Na diviso euclidiana temos 30 dividido 7 tem por quociente 4 e como resto 2. 30 / 7 = 4 30 = 7 x 4 + 2 30 % 7 = 2 Existe uma maneira de fazer abreviaturas:
Operadores
36
Expresso Original Expresso equivalente x=x+k; x=x-k; x=x*k; x=x/k; x=x>>k; x=x<<k; x=x&k; x=x+1 x+=k; x-=k; x*=k; x/=k; x>>=k; x<<=k; x&=k;; x+=1 ou x++
Isto mais uma abreviatura para os programadores escreverem menos. H quem ache isto muito estpido pois um esforo de assimilao desnecessrio em troca a escrever uma letra. Iremos ver que ter a++ ou ++a diferente! Mas isso vai ser na histria dos loops. (iremos ter situaes tipo++a+5 que seria a+5 mas antes fazer a+1+5.) Mais uma nota. Em relao ao operador adio ele para alm dos nmeros tambm permite adicionar strings, isto , junta a segunda string no fim da primeira string. No entanto se juntarmos um dgito com uma string isso j no permitido.
Precedncia de Operadores aritmticos

Precedncia de operadores aritmticos (o operador aritmtico tem maior precedncia do que o operador de asignment) Table 4-3: Prioridade dos operadores aritmticos
Prioridade Operador Alta (Operador unrio de negao)
Mdia-alta * / % Normal +
No caso de termos na mesma instruo operadores com o mesmo nvel de precedncia (prioridade) fazer a regra da esquerda para a direita. eg. a=8/2*4 seria 16 e no 1, porque temos a diviso est no lado esquerdo. Mais um ponto em relao ao operador % mdulo (modulus). Podemos fazer o mdulo para nmeros inteiros mas se tentarmos para nmeros do tipo float (ou um deles) fica indefinido. Geralmente resulta num erro de compilao (mas isso vai depender do compilador) Notar igualmente overflow de que j falamos (antes e depois de compilar). ou seja pego no valor de uma varivel adiciono o valor de uma segunda varivel e dou esse resultado a uma terceira varivel. Isto pode resultar em overflow. Ser trabalho do programador em controlar isto. O que que resulta se adicionarmos um int por um float e esse float com casas decimais e colocarmos esse resultado num int? o que resulta que o resultado fica truncado. a mesma situao de declarar um int e colocar um float. como foi visto no capitulo das variveis.
Operadores
37
type casting
fazer com que o resultado saia com a tipologia desejada. #include <stdio.h> int main(void) { int firstOp = 10, secondOp = 4; float result = (float) firstOp / secondOp; printf("%d / %d = %f\n", firstOp, secondOp, result ); return 0; } Neste exemplo estamos a fazer com que o firstOp seja convertido para tipo float, quando antes tnhamos declarado como um int, ou seja o valor 10 passa a ser 10.0. e agora como temos um float a dividir por um int, o que acontece que h uma converso automtica, ou seja o 2 int convertido em float, fazendo com que o resultado seja um float Podemos utilizar qualquer uma das expresses seguintes para exprimir o tycasting. float float float float result result result result = = = = (float) firstOp / secondOp; float (firstOp) / secondOp; firstOp / (float) secondOp; firstOp / float (secondOp);
Expoentes
O C e o C++ no tm o operador expoente, no entanto, tem a funo pow (de power) que est no cabealho da biblioteca padro <math.h>. a funo pow() tem 2 argumentos, o primeiro para a base e o 2 para o expoente. o 1 argumento tem de ser float ou double.
Operadores relacionais
Permite fazer comparaes lgicas de ordenao de nmeros, e ainda de letras (mas no strings) Table: Relational Operators
Operador Significado > < >= <= == != Maior que Menor que Maior ou igual Menor ou igual Igual a Diferente de
Vo poderia se perguntar: Como que o computador faz essa comparao ? de onde que ele sabe que um nmero A maior que outro B? Resposta: Considere que voc quisesse comparar dois dados tipo char, lembrando que um char na verdade um nmero inteiro na tabela ASCII. Sendo assim suponha que gostarias de comparar o caractere 'a' que igual a 97 na tabela ascii com o caractere 't' que 116 na tabela; assim, ao comparar 97 com 116 o que acontee na memria a comparao de 01100001 (97) com 01110100 (116) em um registrador especfico, vo sendo somadas as potncias de 2 da esquerda para a direita de forma que fica evidente para ele (o registrador) quem maior. Isso o que acontee quando comparamos duas strings com a funo strcmp e ela retorna um nmero para a diferena entre elas.
Operadores Esse nmero justamente a diferena entre os valores da tabela ASCII entre o primeiro caractere das duas. notar o operador == que a comparao de igualdade. o operador = de atribuio. Estes operadores tambm so binrios, ie, comparam dois operandos. o resultado de uma expresso relacional d um valor bool (verdadeiro=1 ou falso=0) 4 != 4 false 4 == 5 false Eu ainda posso comparar um int com um float que isso no d problema. ou seja com dados nmericos no h problema. Comparaes entre dois caracteres tambm no h problema pois os caracteres so nmeros na tabela ASCII. Mas no usem para strings (pois a estaramos a comparar o qu, se as strings so conjunto de caracteres?) No esquecer o ponto que o digito pode ser um char ou estar em forma nmerica. e esse char vai ter o valor na tabela. ns num capitulo posterior iremos ver que poderemos fazer a converso de char para int e vice versa.
38
Precedncia dos operadores relacionais

Table: Precedence of Relational Operators
Precedence Operator Highest Lowest > >= < <= == !=
Novamente existe a regra da esquerda para a direita caso haja igualdade de precedncia
Operadores lgicos
Estes operadores comparam j condies de precedncia Table: Logical Operators
Operator Name What It Does && || ! And Or Not Connects two relational expressions. Both expressions must be true for the overall expression to be true. Connects two relational expressions. If either expression is true, the overall expression is true. Reverses the truth of an expression, making a true expression false, and a false expression true.
Estes operadores tambm so binrios mas desta vez os operandos so resultados boolean, que podem advir dos operadores relacionais (comparao) pois davam valores boolean. Para o operador and (&&) basta uma das comparaes ser falsa paro resultado ser falso Para o operador or (||) basta uma das comparaes dos operandos ser verdadeira para se tornar verdadeira Por fim o operador not um operador unrio apenas para um valor boolean que pode ser resultado de comparao Exemplo: if (age <= 12 || age >= 65) printf("Admission is free"); else printf("You have to pay");
Operadores
39
Precedncia Operadores lgicos e Relacionais

Tabela: A preedenia dos operadores logicos e relacionais Operador (da mais alta para a mais baixa) ! Relacionais (>, >=, <, <=, ==. !=) && || cuidado! if (!age > 12 && age < 65) Note o ! no exemplo. sempre bom recorrer aos parnteses
Operadores Lgicos Bit a Bit

Operador Aco & ^ ~ >> << AND OR XOR (OR exclusivo) NOT Deslocamento de bits direita Deslocamento de bits esquerda
Deslocamento de bits
x = a << b igual a x = a >> b igual a x = a*2^b; x = a/2^b;
Todos os Operadores
Comparaes de precedncia entre Operadores aritmticos, relacionais e lgicos
Level Operator 1 2 3 :: () [] . -> ++ -++ -- ~ ! *& +4 5 6 7 8 9 (type) .* ->* */% +<< >> < > <= >= Description scope Grouping Left-to-right
dynamic_cast static_cast reinterpret_cast const_cast typeid postfix Left-to-right sizeof new delete unary (prefix) indirection and reference (pointers) unary sign operator type casting pointer-to-member multiplicative additive shift relational Right-to-left Right-to-left Right-to-left Right-to-left Left-to-right Left-to-right Left-to-right Left-to-right Left-to-right
Operadores
40
10 11 12 13 14 15 16 17 18 == != & ^ | && || ?: equality bitwise AND bitwise XOR bitwise OR logical AND logical OR Description Left-to-right Left-to-right Left-to-right Left-to-right Left-to-right Left-to-right Right-to-left Right-to-left Left-to-right
= *= /= %= += -= >>= <<= &= ^= != assignment , comma
Exerccios
(7 == 5) // evaluates to false. (5 > 4) // evaluates to true. (3 != 2) // evaluates to true. (6 >= 6) // evaluates to true. (5 < 5) // evaluates to false (a == 5) // evaluates to false since a is not equal to 5. (a*b >= c) // evaluates to true since (2*3 >= 6) is true. (b+4 > a*c) // evaluates to false since (3+4 > 2*6) is false. ((b=2) == a) // evaluates to true. !(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true. !(6 <= 4) // evaluates to true because (6 <= 4) would be false. !true // evaluates to false !false // evaluates to true.
( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ). ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).
Controle de fluxo
41
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
Controle de fluxo 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)
42
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 {
Controle de fluxo ... /* 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"); } }
43
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; }
Controle de fluxo 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.
44
Controle de fluxo
45
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:
Controle de fluxo 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.
46
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");
Controle de fluxo break; case 2: printf ("Voc escolheu abacaxi.\n"); break; case 3: printf ("Voc escolheu laranja.\n"); break; } return 0; }
47
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
Controle de fluxo 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()) ;
48
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)
Controle de fluxo { case 1: printf("\n break; case 2: printf("\n break; case 3: printf("\n break; case 4: printf("\n break; case 5: printf("\n 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. --> Primeira opcao..");
49
--> Segunda opcao..");
--> Terceira opcao..");
--> Quarta opcao..");
--> Abandonando..");
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.
Controle de fluxo
50
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
51
Funes
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.
Funes
52
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.
Funes
53
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);
Funes 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; }
54
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);
Funes } 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.
55
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()".
Funes /*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 { /*variavel interna*/ long somma = largo + alto ; } long calcular() { long surface = largo * alto; } int main(void) { long reslt = calcular(); printf("A surface e:%ld\n",reslt); return 0 ; } /*Aqui ele pode enxegar a varivel "externa" (global)*/ = 20; void minhaFuncion()
56
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
Funes 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.
57
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.
Funes 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).
58
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.
Funes inline [tipo_de_retorno] [nome_da_funo] (argumentos) { //cdigo }
59
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>.
Pr-processador
60
#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).
Pr-processador
61
#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"
Pr-processador #else #define CABECALHO "unix_io.h" #endif #include CABECALHO
62
#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 pr-processador pular todo o contedo pois o smbolo j foi definido.
Pr-processador
63
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 ) ); }
Exerccios
64
Exerccios
Questes
O que faz o seguinte programa? #include <stdio.h> int main() { int x; scanf("%d",&x); printf("%d",x); getchar(); }
Resoluo Exibir a valor de 'X'. O uso de system("PAUSE ") permite segurar a tela no Windows quando o programa executado dando dois cliques no cone.
Escrevendo programas
Exerccio 1
Escreva uma funo que pea dois nmeros inteiros ao usurio e exibe o valor soma seguido pelo maior deles.
Resoluo
Exerccios
65
#include <stdio.h> int main(){ int a, b, result; printf("1"); scanf("%d", &a); printf("2"); scanf("%d", &b); result = a + b; printf("A soma de %d com %d %d\n", a, b, result); printf("O maior : %d\n", a>b? a : b ); getchar(); }
Exerccio 2
Faa um programa que converta Celcius para Fahrenheit. #include <stdio.h> #include <stdlib.h> #define FERVENDO 212
/* graus Fahrenheit */
int main() { float var_long; double var_double; long double var_long_double; int i; i = 0; printf("Fahrenheit para Celsius\n"); while(i <= FERVENDO) { var_long_double = 5*(i-32); var_long_double = var_long_double/9; var_double = var_long_double; var_long = var_long_double; printf("%d %f %f %lf\n", i, var_long, var_double, var_long_double); i = i+1; } return 0; }
Exerccio 3
Faa um programa que vai lendo cada caractere que o usurio digitar. Quando o usurio digitar o caractere 'x', o programa deve exibir todos os caracteres que foram digitados antes do 'x'. #include <stdio.h> #include <stdlib.h> int main() { int ch;
Exerccios ch = getchar(); while(ch != 'x') { if(ch != '\n') { printf("O caractere era %c, e o valor %d\n", ch, ch); ch = getchar(); } } return 0; }
66
Exerccio 4
Escreva um programa que comea pedindo um nmero N ao usurio e depois pede N nmeros. O programa dever mostrar na tela todos esses nmeros ordenados do menor para o maior. Escreva sua prpria funo de ordenao. #include <stdio.h> #include <stdlib.h> #define ARSIZE 10 int main(){ int m_carac[ARSIZE],qtd1; int qtd2, pare, ultcar; ultcar = 0; pare = 0; /* * Le os caracteres para uma matriz. * Para se for o fim da linha ou a matriz estiver cheia. */ while(pare != 1) { m_carac[ultcar] = getchar(); if(m_carac[ultcar] == '\n') pare = 1; else ultcar = ultcar + 1; if(ultcar == ARSIZE) pare = 1; } ultcar = ultcar-1; /* * Agora executa a ordenao bolha tradicional. */ qtd1 = 0; while(qtd1 < ultcar) { qtd2 = qtd1 + 1; while(qtd2 <= ultcar)
Exerccios { if(m_carac[qtd1] > m_carac[qtd2]) { /* troca */ int temp; temp = m_carac[qtd1]; m_carac[qtd1] = m_carac[qtd2]; m_carac[qtd2] = temp; } qtd2 = qtd2 + 1; } qtd1 = qtd1 + 1; } qtd1 = 0; while(qtd1 <= ultcar) { printf("%c\n", m_carac[qtd1]); qtd1 = qtd1 + 1; } exit(EXIT_SUCCESS); }
67
Exerccio 5
Faa um programa que encontra a raiz quadrada aproximada de um nmero. Para isso, use um dos mtodos existentes. #include <stdio.h> #include <stdlib.h> #define DELTA 0.0001 int main() { double raiz_quad(double); /* prottipo */ int i; for(i = 1; i < 100; i++) { printf("Raiz de %d e' %f\n", i, raiz_quad(i)); } return 0; } double raiz_quad(double x) { /* definio */ double aprox_atual, ult_aprox, dif; ult_aprox = x; dif = DELTA+1; while(dif > DELTA) {
Exerccios aprox_atual = 0.5*(ult_aprox + x/ult_aprox); dif = aprox_atual - ult_aprox; if(dif < 0) dif = -dif; ult_aprox = aprox_atual; } return(aprox_atual); } void func_chamada(int, float); int main() { func_chamada(1, 2*3.5); exit(EXIT_SUCCESS); } void func_chamada(int arg_int, float arg_float) { float temp; temp = arg_int * arg_float; }
68
Exerccio 6
O cdigo abaixo gera nmeros primos. #include <stdio.h> int main() { int x,y, comp; int saida = 1; while(saida==1) { comp=0; printf("Entre com o numero inteiro para o teste\n\n"); scanf("%d",&x); for(y=1;y<=x;y++) { if(x%y==0) { comp++; //prinf("%d",x); } } if((comp>2)||(x==1))
Exerccios { printf("\n\nO numero %d, nao e primo\n",x); } else { printf("\n\nO numero %d, e primo\n",x); } system("\n\nPause"); printf("\n\nPara fazer um outra verificacao digite 1,\ncaso contrario digite outro numero qualquer"); scanf("%d",&saida); } } Cdigo mais simples e fcil de entender. Vale a pena testar!
// Por Warley V. Barbosa
69
#include <stdio.h> #include <gconio.h> // Cabealho extra que pode substituir o "conio.h", encontrei em: www.wence.vandermeersch.org/gconio/
int main() { int num, primo, i, res;
do { clrscr(); // limpa tela printf("Digite um nmero (0 para encerrar): \n"); scanf("%d", &num);
primo = 1;
for (i = 2; i < num; i++) /* repete a partir do nmero dois e vai at o nmero anterior de 'num', incrementando varivel i a cada repetio */ { if (num % i == 0) { // se o resto do 'num' por 'i' for zero o nmero no primo primo = 0; break; // pula para a instruo seguinte } }
if ((primo) && (num > 1)) // 1 no primo! nem zero... printf("O nmero %d primo! \n", num);
Exerccios
else printf("O nmero %d no primo... \n", num);
70
delay(1000); // espera 1 segundo (funo do cabealho "gconio.h") } while (num != 0); // encerra quando usurio digitar 0 }
Partindo deste cdigo, tente criar um que some o ltimo primo resultante com o anterior.
Exerccio 7
#include <stdio.h> #include <stdlib.h> int main() { int este_car, qtd_virgulas, qtd_pontos; qtd_virgulas = qtd_pontos = 0; este_car = getchar(); while(este_car != EOF) { if(este_car == '.') qtd_pontos = qtd_pontos+1; if(este_car == ',') qtd_virgulas = qtd_virgulas+1; este_car = getchar(); } printf("%d virgulas, %d pontos\n", qtd_virgulas, qtd_pontos); return 0; }
Exerccio 8
#include <stdio.h> #include <stdlib.h> int main() { int i; for(i = 0; i <= 10; i++) { switch(i) { case 1: case 2: printf("1 or 2\n"); break; case 7:
Exerccios printf("7\n"); break; default: printf("default\n"); } } int i, j; for(i=0, j=0; i <= 10; i++, j = i*i) { printf("i %d j %d\n", i, j); } /* * Neste exemplo, todos os valores constantes, * exceto o ltimo, so descartados * Note o uso dos parntesis para forar uma * expresso vrgula em uma chamada de funo */ printf("Overall: %d\n", ("abc", 1.2e6, 4*3+2)); return EXIT_SUCCESS; } 1. Repare que se no tivssemos colocado o comando break, o programa continuaria a varrer os case seguintes. Retire este comando e use outras instrues no seu lugar
71
Exerccio 9
#include <stdio.h> #include <stdlib.h> void exibe_maior(int a1, int a2); */ int main() { int i,j; for(i = -10; i <= 10; i++) { for(j = -10; j <= 10; j++) { exibe_maior(i,j); } } return 0; } /* * Funo exibe_maior. /* declarao
Exerccios * Retorna: void * Imprime na tela o maior de seus dois argumentos. */ void exibe_maior(int a1, int a2){ /* definio int maior; if(a1 > a2) { maior = a1; } else { maior = a2; } printf("O maior entre %d e %d e' %d\n", a1, a2, maior); }
72
*/
Exerccio 10
Faa uma calculadora: #include <stdio.h> #include <stdlib.h> int int int int expr(void); mul_exp(void); unary_exp(void); primary(void);
int main() { int val; for(;;) { printf("expression: "); val = expr(); if(getchar() != '\n') { printf("error\n"); while(getchar() != '\n'); /* nada */ } else { printf("result is %d\n", val); } } return 0; }
Exerccios int expr(void) { int val, ch_in; val = mul_exp(); for(;;) { switch(ch_in = getchar()) { default: ungetc(ch_in,stdin); return(val); case '+': val = val + mul_exp(); break; case '-': val = val - mul_exp(); break; } } } int mul_exp(void) { int val, ch_in; val = unary_exp(); for(;;) { switch(ch_in = getchar()) { default: ungetc(ch_in, stdin); return(val); case '*': val = val * unary_exp(); break; case '/': val = val / unary_exp(); break; case '%': val = val % unary_exp(); break; } } } int unary_exp(void) {
73
Exerccios int val, ch_in; switch(ch_in = getchar()) { default: ungetc(ch_in, stdin); val = primary(); break; case '+': val = unary_exp(); break; case '-': val = -unary_exp(); break; } return(val); } int primary(void) { int val, ch_in; ch_in = getchar(); if(ch_in >= '0' && ch_in <= '9') { val = ch_in - '0'; goto out; } if(ch_in == '(') { val = expr(); getchar(); /* skip closing ')' */ goto out; } printf("error: primary read %d\n", ch_in); exit(EXIT_FAILURE); out: return(val); }
74
Exerccio 11
Esse programa converte um inteiro em bytes e depois realiza a operao inversa. Faa um programa que converte um short em bytes.
#include <stdio.h> int main (void) { unsigned char bytes[3]; unsigned long n = 123000;
Exerccios
bytes[0] = (n >> 24) & 0xFF; bytes[1] = (n >> 16) & 0xFF; bytes[2] = (n >> 8) bytes[3] = n & 0xFF; int i; char b[500]; sprintf(b,"0 = %d, 1 = %d, 2 = %d, 3 = %d",bytes[0],bytes[1],bytes[2],bytes[3]); int inteiro = (bytes[0]<<24)+(bytes[1] << 16)+(bytes[2] << 8)+bytes[3]; printf("bytes %s\n",b); printf("int = %i\n",inteiro); getchar(); } & 0xFF;
75
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!
Vetores 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.
76
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
77
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]);
Vetores printf("\nO resultado da soma de %s e %s eh: %d\n", argv[1], argv[2], result); }
78
Strings
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
Strings /*TL'*/
79
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".
Strings 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.
80
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; }
Strings
81
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);
Strings printf ("Resultado : %s\n", var); return 0; }
82
Passagem de parmetros
Passagem de Parmetros
Esta explicao para quem compila com o GNU gcc. O que so parmetros? Com os programas em interface grfica usa-se botes ou cones. Quando utiliza-se os parmetros com o console ou prompt os parmetros so reconhecidos como opes. Para quem usa sistemas do tipo Unix como o Linux, onde o console no banalizado como em outros SO's, mais fcil de se entender. Imagine que exista um programa cujo nome "Calcular" e que ele serve para executar operaes aritmticas. Pense agora na sua execuo no shell. $./Calcular restar
"Calcular" o nome, a "chamada" ao seu programa, enquanto que "restar" um parmetro, uma opo. Esse programa pode comportar vrios parmetros como somar, subtrair e multiplicar, por exemplo. Exemplo: /*----------------------------Parmetros.c------------------------------*/ #include <stdio.h> /* igual a int main(int argc, char *argv[]) */ int main(int argument_count, char *argument_value[]) { int i; printf("Nome do Programa :%s\n", argument_value[0] ); for (i = 1 ; i < argument_count; i++) printf("Parmetros passados %d : %s\n", i, argument_value[i]); /* De um enter no fim*/ } Para compilar: user@SO:/meu_diretotio$ gcc Parametros.c -o Argumentos Como diramos s passar alguns argumentos para o compilador ;) Examinando o cdigo Vamos dar uma olhada na funo main(int argc, char *argv[]) vocs podem remarcar os nomes: argc "argument count" : Conta o numero de argumentos incluindo o nome do programa.
Passagem de parmetros E argv "arguments values" : Vamos dizer que cada argv[] um nome de parmetro. Ento temos um que nos da a quantidade de parmetros e outro que nos da os nomes de cada parmetro ou opo. So nomes tradicionais eles podem ser modificado para outros nomes desde que os tipos continuem sendo os mesmos. Exe: NOME opao1 $./Calcular somar Aqui argc igual a 4. argv[] na realidade uma tabela de ponteiros exe: argv[0] e igual a '.' '/' 'C' 'a' 'l' 'c' 'u' 'l ' 'a' 'r' '/0' Calcular argv[1] e igual a 's' 'o' 'm' 'a' 'r' '/0' somar opao2 depois opao3 restar : : argc = 4 argv[] vai de argv[0]
83
argv[3]
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
Foi proposta a fuso deste mdulo com: Programar_em_C/Estruturas (discuta).
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.
Tipos de dados definidos pelo usurio 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.
84
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};
85
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};
Tipos de dados definidos pelo usurio 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!
86
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
Foi proposta a fuso deste mdulo com: Programar em C/Unio (discuta).
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:
Tipos de dados definidos pelo usurio 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).
87
Enumeraes
Foi proposta a fuso deste mdulo com: Programar em C/Enumerao (discuta).
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 */
88
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
89
Enumerao
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*/
Enumerao /*typedef transformamos 2 palavras em uma -> tipo_cores*/ typedef enum cores tipo_cores ;
90
/*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 ;
Enumerao mostrarRes(n); }
91
void mostrarRes(int quem) { switch(quem) { case BRASIL ); break; case ARGENTINA : printf("Argentina um dia quem sabe\n") ; break; case ITALIA : printf("Foi sorte\n") ; 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( "Brasil invencvel como de costume\n"
Unio
92
Unio
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
Unio
93
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
94
Estruturas
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;
Estruturas
95
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;
Estruturas
96
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; }
Estruturas
97
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"}; //no iria funcionar- erro de compilao
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
printf("Enter title: "); fgets(pmovie->title, 100, stdin); printf("Enter year: "; scanf("%d", &pmovie->year); printf("\nYou have entered:\n");
//operador ->
Estruturas 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)
98
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
99
Estruturas aninhadas
A ideia ter uma estrutura dentro de outra estrutura.
#include <stdio.h>
struct Date { int day; int month; int year; }; struct Person {
//estrutura chamada de date
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 ); }
Estruturas 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.
100
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
Ponteiros
101
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.
Esquema de um ponteiro
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()
Ponteiros { 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
102
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;
Ponteiros 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) .
103
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-a-byte! (*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.
Ponteiros 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
104
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};
Ponteiros estruturar *p; p = (struct estruturar*) &buffer; printf("a: %i b: %i", p->a,p->b); getchar(); return 0; }
105
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;
Ponteiros 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!
106
#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
107
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() {
Ponteiros 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.
108
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.
Ponteiros
109
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 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>
Ponteiros
110
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");
Ponteiros 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");
111
// 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() {
Ponteiros 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.
112
Ponteiros
113
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.
Ponteiros Veja mais um exemplo na verdade, uma extenso do exemplo anterior:
114
#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.
Mais sobre variveis
115
Mais sobre variveis

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;
Mais sobre variveis int int int char* } FILE; _file; _charbuf; _bufsiz; _tmpfname;
116
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>
Mais sobre variveis 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));
117
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
Mais sobre variveis
118
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{
Mais sobre variveis 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; }
119
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));
Mais sobre variveis } 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.
120
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 arquivo-cabealho 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.
Mais sobre variveis 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.
121
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.
Mais sobre variveis
122
Mais sobre funes

Os argumentos argc e argv
A funo main(), como dissemos antes, uma funo especial. Introduzimo-la como uma funo sem parmetros; no entanto, ela tambm pode receber parmetros formais. No entanto, o programador no pode escolher quais sero. Eles devem ser os seguintes: int main (int argc, char *argv[]) argc (argument count) um inteiro e possui o nmero de argumentos com os quais o programa foi chamado na linha de comando. Ele no mnimo 1, pois o nome do programa contado como sendo o primeiro argumento. argv (argument values) um ponteiro para uma matriz de strings (conceitos que sero abordados mais frente). Cada string desta matriz um dos parmetros da linha de comando. argv[0] sempre aponta para o nome do programa (que, como j foi dito, considerado o primeiro argumento). para saber quantos elementos temos em argv que temos argc. Como pode se imaginar, os nomes dos parmetros "argc" e "argv" podem ser mudados, mas por questo de padronizao no se costuma modific-los. Exemplo: Escreva um programa que faa uso dos parmetros argv e argc. O programa dever receber da linha de comando o dia, ms e ano correntes, e imprimir a data em formato apropriado. Veja o exemplo, supondo que o executvel se chame data: data 19 04 99 O programa dever imprimir: 19 de abril de 1999 #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int mes; char *nome_mes [] = { "Janeiro", "Fevereiro", "Maro", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro" }; if(argc == 4) /* Testa se o nmero de parmetros fornecidos est correto, o primeiro parmetro o nome do programa, o segundo o dia, o terceiro o mes e o quarto os dois ltimos algarismos do ano */ { mes = atoi(argv[2]); /* argv contem strings. A string referente ao mes deve ser transformada
Mais sobre funes em um numero inteiro. A funcao atoi esta sendo usada para isto: recebe a string e transforma no inteiro equivalente */ if (mes<1 || mes>12) /* Testa se o mes e' valido */ printf("Erro!\nUso: data dia mes ano, todos inteiros"); else printf("\n%s de %s de 19%s", argv[1], nome_mes[mes-1], argv[3]); } else printf("Erro!\nUso: data dia mes ano, todos inteiros"); }
123
Lista de argumentos
Na linguagem C possvel funes como "printf" onde o nmero de argumentos podem variar. As reticncias ( ... ) indicam um numero varivel de argumentos ou argumentos com tipos varivel. Ex: void f_erro(int n, char *fmt, ...); Essa declarao indica que se deve fornecer pelo menos dois argumentos, um do tipo int e um do tipo char mais pode se fornecer argumentos suplementares. Ou seja, "no h limites para sua criatividade"! Ex: f_erro( 3, "Erro: misso impossvel "); f_erro( valor, "%s %d\n", mensagem, errno); E necessrio ter pelo menos um argumento antes dos pontos. Veja um exemplo incorreto. void erreur(...); O arquivo de cabealho stdarg.h declara um tipo va_list e define trs macros para manipular uma lista de argumentos cuja quantidade e tipos so desconhecidos pela funo. va_start, va_arg et va_end (va como variable argument) Sintaxe: #include <stdarg.h> void type void void Descrio: va_start: A macro va_start inicializa ap para uso posterior por va_arg e va_end e deve ser chamada primeiro. O parmetro last o nome do ltimo parmetro antes da lista de argumentos variveis, isto , o ltimo parmetro o qual a funo conhee o tipo. Porque o endereo deste parmetro pode ser usado na macro va_start, ele no deve ser declarado como uma varivel register, ou como uma funo ou como um array. va_arg: va_start(va_list ap, last); va_arg(va_list ap, type); va_end(va_list ap); va_copy(va_list dest, va_list src);
Mais sobre funes A macro va_arg retorna o primeiro argumento varivel e faz ap apontar o prximo argumento. O parmetro ap aquele inicializado por va_start. O parmetro type um nome de tipo. Pode-se apontar para um objeto de um tipo especfico simplesmente adicionando um * ao tipo. O primeiro uso da macro va_arg aps a macro va_start retorna o argumento aps last. Chamadas sucessivas retornam os valores dos outros argumentos. Se no existe prximo argumento, ou se type no compatvel com o tipo do prximo argumento, erros aleatrios ocorrero. Se ap passado para uma funo que usa va_arg(ap,type) ento o valor de ap destrudo aps o retorno da funo. va_end: Cada chamada de va_start deve ter uma chamada correspondente a va_end na mesma funo. Aps a chamada de va_end a varivel ap destruda. Vrias chamadas com va_start e va_end aninhadas so possveis. va_end pode ser uma macro ou uma funo. Exemplo 1
124
/* Calcula a soma de n inteiros */ /* o ultimo argumento deve ser 0 */ #include <stdio.h> #include <stdarg.h> int soma(int n1, ...) { va_list pa; int som, n; som = n1; va_start(pa, n1); while( (n = va_arg(pa, int)) != 0) som = som + n; va_end(pa); return som; } main() { printf("1 + 3 + 5 + 7 + 9 = %d\n", soma(1,3,5,7,9,0)); printf("1 + 1 = %d\n", soma(1,1,0)); return 0; } /*-- resultado ---------------------------1 + 3 + 5 + 7 + 9 = 25 1 + 1 = 2 ---------------------------------------------------------*/ Exemplo 2
#include <stdio.h> #include <stdarg.h>
Mais sobre funes
125
void meu_printf(char *fmt, ...) { va_list pa; int n; char *s, c; float f; va_start(pa, fmt); while (*fmt != '\0') { if ( *fmt == '%' ) { /* (*++fmt) equivale a (*fmt = *fmt + 1 )*/ switch (*++fmt) { case '%' : putchar('%'); break; case 'c' : /* char*/ c = va_arg(pa, int); putchar(c); break; case 'd' : /* int */ n = va_arg(pa, int); printf("%d", n); break; case 'f' : /* float */ f = va_arg(pa, double); /* !!!!! */ printf("%f", f); break; case 's' : /* string */ s = va_arg(pa, char *); for ( ; *s != '\0'; s++ ) putchar( *s ); break; } /* end switch */ } else putchar( *fmt ); /*incrementa o ponteiro*/ fmt++; } va_end(pa); } int main() { meu_printf("float = %f\n", (float) 1.2345); meu_printf("int = %d char = %c String = %s\n", 123, 'A', "C is beautiful !" ); return 0; }
Bibliotecas
126
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>
Bibliotecas 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.
127
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:
Bibliotecas 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"
128
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: No GCC: gcc main.c -L. -l libteste1.a -o main.bin -lm
Bibliotecas 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.
129
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.
130
Modo r r+ w
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 pr-existente. (O a vem do ingls append, adicionar, apender) Abre o arquivo para escrita no final do arquivo e leitura.
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 arquivo no existe, caso tenha sido requisitado para leitura. 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; }
131
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 putchar puts printf N/A fputc fputs fprintf fwrite Explicao Imprime apenas um caractere. Imprime uma string diretamente, sem nenhuma formatao. Imprime uma string formatada. 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 getchar gets scanf N/A fgetc fgets fscanf fread Explicao Recebe apenas um caractere. L uma string (geralmente uma linha inteira). Recebe uma string formatada. 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
132
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
133
Funo feof ferror fseek rewind
Explicao Detecta se o final do arquivo j foi atingido Verifica se a ltima operao de leitura ou escrita do fluxo foi executada com sucesso Movimenta o indicador de posio dentro do arquivo de um fluxo especificado Volta para o comeo do arquivo de um fluxo
remove Remove um arquivo especificado
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");
Gerenciamento de memria 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.
134
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; }
135
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; }
136
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); ... normalmente */ p = Liberar_vetor_real (p); } /* outros comandos, utilizando p[]
137
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);
Gerenciamento de memria 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); ... }
138
Sockets
139
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
Sockets
140
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>
Makefiles #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.
141
Makefiles 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
142
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
Makefiles # #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. Tem outra idia?? Poderamos utilizar *c mais no podemos utilizar este caracter joker na definio de uma varivel. 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
143
@$(CC) -o $@ $^
Makefiles 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
144
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. Por exemplo "clean:" e uma regra sem nem uma dependncia no temos nada na pasta que se chame clean. 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. Para evitar esse problema usamos a regra .PHONY : . Fica assim. .PHONY: clean mrproper .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)
Makefiles 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 "sub-make".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)
145
Makefiles 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: prefix=/caminho/ate onde/esta/Projetos bindir=$(prefix)/bin .Igual a /caminho ate/Projetos/dentro de Projetos a pasta bin . E adicionarmos a regra install:all com seus comandos.
146
Makefiles 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 sub-make && $(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
147
Makefiles make install make clean make mrproper .Para apagar os binarios.
148
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 default do double else enum float for goto if int long return short signed sizeof static struct switch typedef union unsigned void volatile while
register
extern
continue
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
149
Lista de funes
Aqui esto as vrias funes presentes em C separadas por cabealho: stdio.h printf scanf vsnprintf sprintf vprintf fprintf fscanf feof fflush calloc malloc system
gets fgets puts fputs stdlib.h atoi atof atol itoa string.h strcmp stricmp strlen strstr strcat strcpy strncpy strncat strchr strrev signal.h iso10646.h time.h math.h tan sin cos atan asin acos
Lista de funes pow sqrt abs
150
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 [1] (english) Biblioteca C [2] (english)
Referncias
[1] http:/ / www. opengroup. org/ onlinepubs/ 9699919799/ functions/ contents. html [2] http:/ / www. cplusplus. com/ reference/ clibrary/
Dicas de programao em C
151
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. prefixos identificadores p_ a_ ou sa_ da_ s_
ponteiro tabela esttica(static array) tabela dinmica (dynamic array) cadeia de caracteres(string)
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");
Dicas de programao em C 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=...
152
Dicas de programao em C 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, imprimi-las 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
153
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
Dicas de programao em C 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; }
154
Listas encadeadas
155
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.
Listas encadeadas
156
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; }
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;
Listas encadeadas *p_Raiz = (*p_Raiz)->p_prox; free(p_atual); } }
157
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); } }
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); } }
Listas encadeadas
158
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;
Pilha
159
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;
Pilha for(i=0;i<monte->tamanho;++i){ printf("\t\t%s\n", atual->dados); atual = atual->proximo; } }
160
Fila ou Queue
Fila
Uma fila ou queue em ingls uma estrutura de dados que usa o mtodo FIFO(acrnimo para First In, First Out, que em portugus significa primeiro a entrar, primeiro a sair). A idia fundamental da fila que s podemos inserir um novo elemento no final da fila e s podemos retirar o elemento do incio. Exemplo de fila em C:
#include <stdio.h> #include <string.h> #include <stdlib.h>
void q_enter(void); void q_list(void); int q_store(char *ptr); int q_delete(void); int count = 0; int store = 0; int retrieve = 0; char *queue[100]; //contador // proxima posio na fila // recupera a posio da fila // vetor da fila
int main() { int i = 0; for ( i = 0; i < 100; i++ ) { queue[i] = NULL; } q_enter(); // entra os dados na fila printf("\n\nTodos os dados da fila (FIFO):\n"); q_list(); q_delete(); // Apaga a primeira entrada da fila
Fila ou Queue printf("\n\nA fila depois delete(FIFO):\n"); q_list(); printf("\n\nNumero de elementos restantes na fila: %i \n", count); getchar(); // espera return 0; }
161
void q_enter(void) { static char str[100], *ptr; puts("Pressione a tecla ENTER sem nome pra sair\n"); do { printf("Entre o nome:"); gets(str); ptr = (char *) malloc(strlen(str)); //alocar um espao na memria strcpy(ptr,str); if (*str) { count++; q_store(ptr); // Guarda o endereo da seqncia de caracteres } } while (*str); //Sair se no houver uma entrada }
// listar a fila void q_list(void) { int k; for (k = retrieve; k < store; k++) { printf("Elemento %d : %s \n",k+1,queue[k]); } }
// Guarda os itens na fila int q_store(char *ptr) { if (store == 100) { printf("\nA lista esta cheia!\n"); return 0 ; }
Fila ou Queue queue[store] = ptr; store++; // prximo ndice da fila } // Apaga um item da fila int q_delete(void) { if (store == retrieve) { printf("\nA fila esta vazia!"); return 0 ; } count--; retrieve++; }
162
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;
rvores binrias (*pRaiz)->numero = numero; }else{ if(numero < (*pRaiz)->numero) inserir(&(*pRaiz)->esquerda, numero); if(numero > (*pRaiz)->numero) inserir(&(*pRaiz)->direita, numero); } }
163
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);
rvores binrias 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; } } } } }
164
Em ordem
void exibirEmOrdem(No *pRaiz){ if(pRaiz != NULL){ exibirEmOrdem(pRaiz->esquerda); printf("\n%i", pRaiz->numero); exibirEmOrdem(pRaiz->direita); } }
rvores binrias
165
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; }
rvores binrias
166
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)); }
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;
167
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; }
168
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 No pior caso, so feitas operaes relevantes, onde n representa o nmero de elementos do vetor. 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])
Algoritmos de ordenao { memoria=vetor[i]; vetor[i]=vetor[i+1]; vetor[i+1]=memoria; troca=1; /*Se houve troca, "troca" recebe 1 para continuar rodando.*/ } } } }
169
Algoritmo de alocao
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.
Buddy System
Esta pgina somente um esboo. Ampliando-a voc ajudar a melhorar o Wikilivros.
Lista de autores
170
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
Fontes e Editores da Pgina
171

Capa Fonte: http://pt.wikibooks.org/w/index.php?oldid=186016 Contribuidores: David Stress, Delemon, Edudobay, Elvire, Joaodaveiro, Jorge Morais, Lightningspirit, Master, SallesNeto BR, Voz da Verdade, Wbrito, 159 edies annimas Por que aprender a linguagem C Fonte: http://pt.wikibooks.org/w/index.php?oldid=257353 Contribuidores: Abacaxi, Edudobay, Fabiobasso, Jorge Morais, Joo Jernimo, Lightningspirit, SallesNeto BR, Sourf, Thiagol, Wbrito, 7 edies annimas Histria da linguagem C Fonte: http://pt.wikibooks.org/w/index.php?oldid=239950 Contribuidores: Edudobay, Helder.wiki, Jorge Morais, Lightningspirit, Scorpion, 12 edies annimas Pr-requisitos Fonte: http://pt.wikibooks.org/w/index.php?oldid=249065 Contribuidores: Abacaxi, Albmont, Edudobay, Helder.wiki, Jorge Morais, Lightningspirit, Marcos Antnio Nunes de Moura, Wbrito, 16 edies annimas Utilizando um compilador Fonte: http://pt.wikibooks.org/w/index.php?oldid=249208 Contribuidores: Abacaxi, Albmont, Edudobay, EvertonS, Fabiobasso, Master, Thiagol, 7 edies annimas Noes de compilao Fonte: http://pt.wikibooks.org/w/index.php?oldid=212773 Contribuidores: Aprendiz de feiticeiro, Edudobay, SallesNeto BR, Thiagol, Wbrito Um programa em C Fonte: http://pt.wikibooks.org/w/index.php?oldid=247671 Contribuidores: Awillian, Edudobay, EvertonS, Fabiobasso, Jorge Morais, Marcos Antnio Nunes de Moura, Thiagol, Wbrito, 11 edies annimas Conceitos bsicos Fonte: http://pt.wikibooks.org/w/index.php?oldid=246560 Contribuidores: Algum, Edudobay, Fabiobasso, Helder.wiki, Thiagol, Wbrito, 3 edies annimas Variveis Fonte: http://pt.wikibooks.org/w/index.php?oldid=252120 Contribuidores: Abacaxi, Defender, Edudobay, EvertonS, Jorge Morais, Marcos Antnio Nunes de Moura, Mr.Yahoo!, Thiagol, Wbrito, 12 edies annimas Constantes Fonte: http://pt.wikibooks.org/w/index.php?oldid=256737 Contribuidores: Abacaxi, Daveiro, Helder.wiki, Iraziel, Jorge Morais, Marcelo-Silva, Marcos Antnio Nunes de Moura, Master, SallesNeto BR, Wbrito, 8 edies annimas Entrada e sada simples Fonte: http://pt.wikibooks.org/w/index.php?oldid=255625 Contribuidores: Abacaxi, Albmont, Edudobay, EvertonS, Thiagol, Wbrito, Yuu eo, 14 edies annimas Operaes matemticas (Bsico) Fonte: http://pt.wikibooks.org/w/index.php?oldid=248640 Contribuidores: Edudobay, Wbrito, 4 edies annimas Operaes matemticas (Avanado) Fonte: http://pt.wikibooks.org/w/index.php?oldid=254252 Contribuidores: Marcos Antnio Nunes de Moura, Rogerboff, SallesNeto BR, Thiagol, Wbrito, 8 edies annimas Operadores Fonte: http://pt.wikibooks.org/w/index.php?oldid=248481 Contribuidores: Abacaxi, Daveiro, Jorge Morais, Marcelo-Silva, Marcos Antnio Nunes de Moura, Master, Petrusz1, Raylton P. Sousa, Wbrito, 13 edies annimas Controle de fluxo Fonte: http://pt.wikibooks.org/w/index.php?oldid=255638 Contribuidores: Abacaxi, Albmont, Edudobay, Helder.wiki, Hycesar, Rogerboff, Thiagol, Wbrito, 8 edies annimas Funes Fonte: http://pt.wikibooks.org/w/index.php?oldid=257232 Contribuidores: Abacaxi, Albmont, Awillian, Cleiton wi, Edudobay, EvertonS, Fabiobasso, Hycesar, Rogerboff, Victor Aurlio, Wbrito, 41 edies annimas Pr-processador Fonte: http://pt.wikibooks.org/w/index.php?oldid=235568 Contribuidores: Edudobay, EvertonS, Hycesar, Lgrave, Rogerboff, SallesNeto BR, 2 edies annimas Exerccios Fonte: http://pt.wikibooks.org/w/index.php?oldid=254306 Contribuidores: Abacaxi, Albmont, Algum, Delemon, Jorge Morais, Lightningspirit, Raylton P. Sousa, Wbrito, 6 edies annimas Vetores Fonte: http://pt.wikibooks.org/w/index.php?oldid=255624 Contribuidores: Abacaxi, Ajraddatz, Dante Cardoso Pinto de Almeida, Edudobay, EvertonS, Fabiobasso, Helder.wiki, Hycesar, Jonas AGX, Wbrito, 17 edies annimas Strings Fonte: http://pt.wikibooks.org/w/index.php?oldid=257810 Contribuidores: Albmont, Defender, Edudobay, Jorge Morais, Wbrito, 12 edies annimas Passagem de parmetros Fonte: http://pt.wikibooks.org/w/index.php?oldid=245335 Contribuidores: Abacaxi, David Stress, EvertonS, Wbrito, 4 edies annimas Tipos de dados definidos pelo usurio Fonte: http://pt.wikibooks.org/w/index.php?oldid=234520 Contribuidores: Edudobay, Wbrito, 11 edies annimas Enumerao Fonte: http://pt.wikibooks.org/w/index.php?oldid=255616 Contribuidores: Abacaxi, Daveiro, EvertonS, Helder.wiki, Jorge Morais, Marcelo-Silva, Marcos Antnio Nunes de Moura, Master, Wbrito, 18 edies annimas Unio Fonte: http://pt.wikibooks.org/w/index.php?oldid=255617 Contribuidores: Abacaxi, Daveiro, Jorge Morais, Marcelo-Silva, Marcos Antnio Nunes de Moura, Master, Wbrito, 5 edies annimas Estruturas Fonte: http://pt.wikibooks.org/w/index.php?oldid=255614 Contribuidores: Abacaxi, Albmont, Daveiro, EvertonS, Jorge Morais, Marcelo-Silva, Marcos Antnio Nunes de Moura, Master, Wbrito, 23 edies annimas Ponteiros Fonte: http://pt.wikibooks.org/w/index.php?oldid=255620 Contribuidores: Abacaxi, Albmont, Edudobay, EvertonS, Fabiobasso, Hycesar, Jesielt, Jorge Morais, Marcos Antnio Nunes de Moura, Noturno99, Wbrito, 29 edies annimas Mais sobre variveis Fonte: http://pt.wikibooks.org/w/index.php?oldid=255635 Contribuidores: Abacaxi, Edudobay, GabrielFalcao, Helder.wiki, Wbrito, 2 edies annimas Mais sobre funes Fonte: http://pt.wikibooks.org/w/index.php?oldid=250214 Contribuidores: Abacaxi, EvertonS Bibliotecas Fonte: http://pt.wikibooks.org/w/index.php?oldid=212778 Contribuidores: Edudobay, EvertonS, Helder.wiki, Rogerboff, Wbrito, 5 edies annimas Entrada e sada em arquivos Fonte: http://pt.wikibooks.org/w/index.php?oldid=248712 Contribuidores: Abacaxi, Edudobay, EvertonS, MateusGPe, Wbrito, 3 edies annimas Gerenciamento de memria Fonte: http://pt.wikibooks.org/w/index.php?oldid=255622 Contribuidores: Abacaxi, Edudobay, Frigotoni, Gabrielhtec, Marcos Antnio Nunes de Moura, 21 edies annimas Sockets Fonte: http://pt.wikibooks.org/w/index.php?oldid=253321 Contribuidores: Abacaxi, Albmont, EvertonS, Jorge Morais, 8 edies annimas Makefiles Fonte: http://pt.wikibooks.org/w/index.php?oldid=249304 Contribuidores: David Stress, EvertonS, Helder.wiki, Jorge Morais, 49 edies annimas Lista de palavras reservadas Fonte: http://pt.wikibooks.org/w/index.php?oldid=186025 Contribuidores: Jorge Morais, 2 edies annimas Seqncias de escape Fonte: http://pt.wikibooks.org/w/index.php?oldid=186035 Contribuidores: Devarde, Master, SallesNeto BR, 3 edies annimas Lista de funes Fonte: http://pt.wikibooks.org/w/index.php?oldid=186024 Contribuidores: Devarde, Master, SallesNeto BR Lista de bibliotecas Fonte: http://pt.wikibooks.org/w/index.php?oldid=254253 Contribuidores: Abacaxi, EvertonS, Jorge Morais, Marcos Antnio Nunes de Moura, 3 edies annimas Dicas de programao em C Fonte: http://pt.wikibooks.org/w/index.php?oldid=258291 Contribuidores: Abacaxi, Dante Cardoso Pinto de Almeida, Helder.wiki, 8 edies annimas

Listas encadeadas Fonte: http://pt.wikibooks.org/w/index.php?oldid=251885 Contribuidores: Abacaxi, EvertonS, Gabrielhtec, Jorge Morais, Maxtremus, 11 edies annimas Pilha Fonte: http://pt.wikibooks.org/w/index.php?oldid=250331 Contribuidores: Lukas, 6 edies annimas Fila ou Queue Fonte: http://pt.wikibooks.org/w/index.php?oldid=243774 Contribuidores: Abacaxi, Defender, 6 edies annimas rvores binrias Fonte: http://pt.wikibooks.org/w/index.php?oldid=247775 Contribuidores: EvertonS, Maxtremus, Ruy Pugliesi, 46 edies annimas Algoritmos de ordenao Fonte: http://pt.wikibooks.org/w/index.php?oldid=254603 Contribuidores: Abacaxi, EvertonS, 12 edies annimas Algoritmo de alocao Fonte: http://pt.wikibooks.org/w/index.php?oldid=223824 Contribuidores: EvertonS, Jorge Morais, 2 edies annimas Lista de autores Fonte: http://pt.wikibooks.org/w/index.php?oldid=249033 Contribuidores: Cardinhotk, EvertonS, RenatoResende, 3 edies annimas
172
Fontes, Licenas e Editores da Imagem
173
Fontes, Licenas e Editores da Imagem

Imagem:Programar_c_cover.png Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Programar_c_cover.png Licena: GNU Free Documentation License Contribuidores: Dante Cardoso Pinto de Almeida, Lightningspirit Imagem:Translation_arrow.svg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Translation_arrow.svg Licena: GNU Free Documentation License Contribuidores: Jesse Burgheimer Image:Ken n dennis.jpg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Ken_n_dennis.jpg Licena: Public Domain Contribuidores: 32X, Bastique, Ebcdic, Lzur, Mormegil, Quibik, Reisio, Sven, 1 edies annimas Imagem:Searchtool.svg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Searchtool.svg Licena: GNU Lesser General Public License Contribuidores: David Vignoni, Ysangkok Image:Nuvola apps konsole.png Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Nuvola_apps_konsole.png Licena: GNU Lesser General Public License Contribuidores: Alno, Alphax Image:Recycle001.svg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Recycle001.svg Licena: desconhecido Contribuidores: Users Cbuckley, Jpowell on en.wikipedia imagem:Exercicios c cover.png Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Exercicios_c_cover.png Licena: GNU Free Documentation License Contribuidores: Dante Cardoso Pinto de Almeida, Lightningspirit Image:Merge-arrows.svg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Merge-arrows.svg Licena: Public Domain Contribuidores: User:Erin Silversmith, User:Lifeisunfair, User:Rei-artur Imagem:EsquemaPonteiro.png Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:EsquemaPonteiro.png Licena: desconhecido Contribuidores: Edudobay Imagem:Crystal_Clear_app_kaddressbook.png Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Crystal_Clear_app_kaddressbook.png Licena: GNU Free Documentation License Contribuidores: CyberSkull, It Is Me Here, Rocket000 Imagem:Rekopis chopin.jpg Fonte: http://pt.wikibooks.org/w/index.php?title=Ficheiro:Rekopis_chopin.jpg Licena: Public Domain Contribuidores: Andreagrossmann, Kevyn, Maire, Man vyi, Niki K, Subitosera, Tsca
Licena
174
Licena
Creative Commons Attribution-Share Alike 3.0 Unported //creativecommons.org/licenses/by-sa/3.0/

Programar em C

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Programar em C

Загружено:

Авторское право:

Доступные форматы

Programar em C

Licenas das pginas

ndice>> Ir para o ndice >>

Por que aprender a linguagem C

Kenneth Thompson ( esquerda) e Dennis Ritchie ( direita), os criadores da linguagem C

char unsigned char

Converter um tipo de varivel

DEFINED CONSTANTS (#DEFINE)

Declared constants (const)

Entrada e sada simples

Entrada e sada simples

Entrada e sada simples

Entrada e sada simples

Entrada e sada simples resultar nisto: " 3.4500"

Entrada e sada simples

Operaes matemticas (Bsico)

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

O resultado que voc deve obter ao executar o exemplo : 11 6 10 6

Operaes matemticas (Avanado)

Operaes matemticas (Avanado)

As funes atan e atan2

As funes cos, sin e tan

Operaes matemticas (Avanado)

Funes Exponencial e Logaritmo

As funes frexp, ldexp e modf

As funes log e log10

Operaes matemticas (Avanado)

Funes pow e sqrt

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

Operaes matemticas (Avanado)

Diviso Euclidiana (Resto) 30 % 7

Precedncia de Operadores aritmticos

Precedncia dos operadores relacionais

Precedncia Operadores lgicos e Relacionais

Operadores Lgicos Bit a Bit

= *= /= %= += -= >>= <<= &= ^= != assignment , comma

Operador ternrio "?:"

--> Segunda opcao..");

--> Terceira opcao..");

--> Quarta opcao..");

Saltos incondicionais: goto

/* Para a funo exit() */

Definindo uma funo

// poderia tambm ser return (3);

Prottipo ou Declarao de funo

Variveis locais versus globais

Passagem de parmetros por valor e por referncia

Funes inline [tipo_de_retorno] [nome_da_funo] (argumentos) { //cdigo }

Pr-processador #else #define CABECALHO "unix_io.h" #endif #include CABECALHO

Usos comuns das diretivas

#include<stdio.h> int main (void) {

int main() { int num, primo, i, res;

vetor[0] = 3; int x = vetor[2]; int y = vetor[5]; // ERRO!

Exemplo de Aplicao de Vetores

Vetores multidimensionais (matrizes)

Argumentos na funo main

Exemplo de uso de parmetros na funo main

Vetores printf("\nO resultado da soma de %s e %s eh: %d\n", argv[1], argv[2], result); }

Funes da biblioteca padro

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

Strings printf ("Resultado : %s\n", var); return 0; }

Tipos de dados definidos pelo usurio

Tipos de dados definidos pelo usurio

int strcmp (char s1, char s2);

void setValues(Person); void getValues(const Person);

vInt = 10; pInt = &vInt; pInt2 = &pInt; pInt3 = &pInt2; x=0;

FILE fopen (char nome_do_arquivo, char *modo_de_acesso);

Listas encadeadas p_Raiz = (p_Raiz)->p_prox; free(p_atual); } }