linguagem de programacao c

Centro Universitrio de Maring - CESUMAR

Cursos de AUTOMAO INDUSTRIAL e ENGENHARIA DE CONTROLE E AUTOMAO

Disciplina de Informtica para Automao Prof. EE. Carlos Henrique Z. Pantaleo 2005

Informtica para Automao Linguagem de Programao

2

SUMRIO1 Programao em C...........................................................................................................................5 2 Conceitos Bsicos da Programao C.............................................................................................7 2.1 Histrico de C......................................................................................................................7 2.2 Criando um Programa Executvel.......................................................................................8 2.3 A Estrutura Bsica de um Programa em C..........................................................................9 2.4 Variveis............................................................................................................................11 2.5 Tipos de Dados...................................................................................................................12 2.6 Constantes..........................................................................................................................14 2.7 Ponteiros.............................................................................................................................16 2.8 Exerccios...........................................................................................................................18 3 Entrada/Sada Console...................................................................................................................19 3.1 Printf()........................................................................................................................19 3.2 Cprintf().........................................................................23 3.3 Scanf()....................................................................................................................23 3.4 Getch(), Getche() e Getchar()....................................................................................24 3.5 Putch() ou Putchar()...........................................................................................................25 3.6 Exerccios...........................................................................................................................25 4 Operadores .....................................................................................................................................27 4.1 Operadores Aritmticos.....................................................................................................27 4.2 Operadores Relacionais......................................................................................................28 4.3 Operadores lgicos binrios...............................................................................................29 4.4 Operadores de Ponteiros....................................................................................................30 4.5 Operadores Incrementais e Decrementais..........................................................................31 4.6 Operadores de Atribuio..................................................................................................33 4.7 O Operador Lgico Ternrio..............................................................................................34 4.8 Precedncia........................................................................................................................35 4.9 Exerccios...........................................................................................................................35 5 Laos.................................................................................................................................................37 5.1 O Lao For.........................................................................................................................37 5.2 O Lao While.....................................................................................................................39 5.3 O Lao Do-While...............................................................................................................40 5.4 Break e Continue........................................................................................................41 5.5 Goto....................................................................................................................................42 5.6 Exerccios...........................................................................................................................42Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


3

6 Comandos para Tomada de Deciso.............................................................................................44 6.1 If.....................................................................................................................44 6.2 If-Else.........................................................................................................................45 6.3 Switch.........................................................................................................................46 6.4 Exerccios...................................................................................................................49 7 Funes ............................................................................................................................................50 7.1 Sintaxe................................................................................................................................50 7.2 Exemplos............................................................................................................................51 7.3 Prototipagem......................................................................................................................54 7.4 Classes de Armazenamento...............................................................................................55 7.4.1 Auto.....................................................................................................55 7.4.2 Extern......................................................................................................55 7.4.3 Static....................................................................................................................56 7.4.4 Variveis Estticas Externas...............................................................................57 7.4.5 Register................................................................................................................58 7.5 Exerccios...........................................................................................................................58 8 Diretivas do Pr-Processador.........................................................................................................60 8.1 Diretiva #define..................................................................................................................60 8.2 Macros................................................................................................................................61 8.3 Diretiva #undef..................................................................................................................63 8.4 Diretiva #include................................................................................................................63 8.5 Compilao Condicional....................................................................................................65 8.6 Operador defined................................................................................................................66 8.7 Diretiva #error....................................................................................................................66 8.8 Diretiva #pragma...............................................................................................................67 8.9 Exerccios...........................................................................................................................67 9 Matrizes...........................................................................................................................................68 9.1 Sintaxe de Matrizes............................................................................................................69 9.2 Inicializando Matrizes........................................................................................................70 9.3 Matrizes como Argumentos de Funes............................................................................73 9.4 Chamada Por Valor e Chamada Por Referncia................................................................75 9.5 Strings .......................................................................................................................78 9.5.1 Strings Constantes...........................................................................................79 9.5.2 String Variveis...................................................................................................79 9.5.3 Funes para Manipulao de Strings.................................................................81 9.6 Exerccios...........................................................................................................................83Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


4

10 Tipos Especiais de Dados.............................................................................................................84 10.1 Typedef............................................................................................................................84 10.2 Enumerados (Enum)........................................................................................................84 10.3 Estruturas (Struct)............................................................................................................86 10.4 Unies..............................................................................................................................91 10.5 Bitfields............................................................................................................................93 10.6 Exerccios.........................................................................................................................94 11 Ponteiros e a Alocao Dinmica de Memria...........................................................................95 11.1 Declarao de Ponteiros e o Acesso de Dados com Ponteiros.........................................95 11.2 Operaes com Ponteiros.................................................................................................96 11.3 Funes & Ponteiros........................................................................................................99 11.4 Ponteiros & Matrizes.....................................................................................................101 11.5 Ponteiros & Strings........................................................................................................103 11.6 Ponteiros para Ponteiros.................................................................................................105 11.7 Argumentos da Linha de Comando...............................................................................109 11.8 Ponteiros para Estruturas...............................................................................................110 11.9 Alocao Dinmica de Memria....................................................................................112 11.9.1 Malloc()...............................................................................................114 11.9.2 Calloc()................................................................................................115 11.9.3 Free()...............................................................................................................116 11.10 Exerccios.....................................................................................................................116 12 Manipulao de Arquivos em C................................................................................................118 12.1 Tipos de Arquivos..........................................................................................................118 12.2 Declarao, abertura e fechamento................................................................................118 12.3 Leitura e escrita de caracteres........................................................................................120 12.4 Fim de Arquivo (EOF)...................................................................................................120 12.5 Leitura e escrita de strings.............................................................................................121 12.6 Arquivos Padres..........................................................................................................122 12.7 Gravando um Arquivo de Forma Formatada.................................................................123 12.8 Leitura e escrita de valores binrios...............................................................................124 12.9 Exerccios.......................................................................................................................125

Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


5

1 Programao em CAtualmente, empregam-se cada vez mais sistemas computacionais na automatizao de processos industriais. Os sistemas computacionais empregados variam desde um simples circuito lgico digital, passando por uma circuito composto por um microprocessador ou um CLP, at sistemas complexos envolvendo um ou mais microcomputadores ou at estaes de trabalho. Um engenheiro que atua nesta rea deve conhecer os sistemas computacionais disponveis e ser capaz de selecionar o melhor equipamento para uma dada aplicao. Alm disto, este profissional deve conseguir instalar este sistema, configur-lo e acima de tudo program-lo para que este execute a tarefa de automatizao atendendo os requisitos industrias do sistema, como imunidade a falhas ou comportamento determinstico com restries temporais (sistemas tempo-real). Neste contexto, a programao destes sistemas se faz de suma importncia. Basicamente, a inteligncia dos sistemas automatizados implementada atravs de programas computacionais, comandando os componentes de hardware para executar a tarefa com o comportamento desejado.

Figura 1 - Comparao entre os diversos sistemas computacionais para aplicaes industriais.

Nas ltimas dcadas, o desenvolvimento em hardware permitiu que cada vez mais os processos industrias sejam automatizados e interligados atravs de sistemas computacionais. Entretanto, a evoluo em software no se deu em tamanha velocidade como a de hardware. Desta



6

forma, um dos grandes paradigmas tecnolgicos hoje o desenvolvimento de programas para a realizao de tarefas complexas e que exigem um alto grau de inteligncia. A maneira de se comunicar com um computador chama-se programa e a nica linguagem que o computador entende chama-se linguagem de mquina. Portanto todos os programas que se comunicam com a mquina devem estar em linguagem de mquina. Para permitir uma maior flexibilidade e portabilidade no desenvolvimento de software, foram implementados nos anos 50 os primeiros programas para a traduo de linguagens semelhantes humana (linguagens de "alto nvel") em linguagem de mquina. A forma como os programas so traduzidos para a linguagem de mquina classifica-se em duas categorias: Interpretadores: Um interpretador l a primeira instruo do programa, faz uma consistncia de sua sintaxe e, se no houver erro converte-a para a linguagem de mquina para finalmente execut-la. Segue, ento, para a prxima instruo, repetindo o processo at que a ltima instruo seja executada ou a consistncia aponte algum erro. So muito bons para a funo de depurao ("debugging") de programas, mas so mais lentos. Ex.: BASIC Interpretado, Java. Compiladores: Traduzem o programa inteiro em linguagem de mquina antes de serem executados. Se no houver erros, o compilador gera um programa em disco com o sufixo Este programa no pode ser executado at que sejam .OBJ com as instrues j traduzidas.

agregadas a ele rotinas em linguagem de mquina que lhe permitiro a sua execuo. Este trabalho feito por um programa chamado linkeditor que, alm de juntar as rotinas necessrias ao programa .OBJ, cria um produto final em disco com sufixo .EXE que pode ser executado diretamente do sistema operacional. Compiladores bem otimizados produzem cdigo de mquina quase to eficiente quanto aquele gerado por um programador que trabalhe direto em Assembly. Oferecem em geral menos facilidades de depurao que interpretadores, mas os programas so mais rpidos (na ordem de 100 vezes ou mais). Ex.: BASIC Compilado, FORTRAN, PASCAL, MDULA - 2, C, C++. Alm da velocidade, outras vantagens podem ser mencionadas: desnecessria a presena do interpretador ou do compilador para executar o programa j compilado e linkeditado; programas .EXE no podem ser alterados, o que protege o cdigo-fonte.



7

Desta forma, os compiladores requerem o uso adicional de um editor de ligaes ("Linker"), que combina mdulos-objetos ("Traduzidos") separados entre si e converte os mdulos assim "linkados" no formato carregvel pelo sistema operacional (programa .EXE).

2 Conceitos Bsicos da Programao C2.1 Histrico de C O compilador "C" vem se tornando o mais difundido em ambiente industrial. A linguagem "C" se originou das linguagens BCPL e B desenvolvidas em 1970. A primeira verso de "C" foi implementada para o sistema operacional UNIX pela Bell Laboratories, especificamente por Dennis M. Ritchie e Ken Thompson no incio da dcada de 70, e rodava em um DEC PDP11 (Digital Equipment Corporation). A linguagem C foi utilizada para portar o UNIX para outros computadores. A linguagem "C" possui uma caracterstica dual: considerada linguagem estruturada de alto-nvel; Assembly de alto-nvel, que permite escrever programas muito prximos linguagem de mquina, sendo usada para desenvolver muitas aplicaes como compiladores, interpretadores, processadores de texto e mesmo sistemas operacionais. Ex: UNIX, MSDOS, TPW. A linguagem de programao C tornou-se rapidamente uma das mais importantes e populares, principalmente por ser muito poderosa, porttil, pela padronizao dos compiladores existentes (atravs da norma ANSI C) e flexvel. compactos e de execuo rpida. A linguagem C baseada em um ncleo pequeno de funes e estruturas bsicas, desta forma, todo programa desenvolvido a partir deste ncleo bsico. Isto implica na grande portabilidade de C, haja vista que basta a implementao deste ncleo bsico para um dado processador e automaticamente j estar disponvel um compilador C para este processador. Por esta razo, existem compiladores C para a grande parte dos sistemas computacionais atualmente disponveis. Devido tambm a este pequeno ncleo, um programador C capaz de desenvolver Os programas em C tendem a ser bastante



8

programas to eficientes, pequenos e velozes quanto os programas desenvolvidos em Assembly. Por isso, diz-se que C uma linguagem de alto nvel, porm, prxima da linguagem de mquina.

2.2 Criando um Programa Executvel Primeiro, escreva o seu programa (arquivo em modo ASCII), com o auxlio de um programa denominado de compilador, e grave o programa em disco dando a ele um nome como sufixo .C. O programa gerado chamado de cdigo fonte. Na seqncia, compile o fonte seguindo as instrues do seu compilador, o que criar um programa com o sufixo .OBJ em disco. O programa gerado chamado de objeto. Por fim, basta linkeditar o objeto seguindo as instrues do seu linkeditor o que criar um programa com sufixo .EXE em disco. O programa gerado chamado de executvel. A Figura 2 apresenta o processo de gerao de um programa em C.

Figura 2 - Ilustrao do processo de criao de um programa em C.



9

2.3 A Estrutura Bsica de um Programa em C A forma geral de um programa em "C" a seguinte: ; main() { ; ; } /* comentrios */

Vamos comear por um programa bem simples em C. escrever na tela a frase Bom Dia!!!!./* Programa : Bom Dia! */ #include void main() { printf(Bom Dia!!!!); }

Voc pode escrever este programa O programa serve para

em um arquivo ASCII e salv-lo com um nome terminando em .C.

Na primeira linha, os smbolos /* e */ servem para delimitar um comentrio do programa. muito importante que os programas sejam comentados de forma organizada. Isto permite que outras pessoas possam facilmente entender o cdigo fonte. Os comentrios no so interpretados pelo Depois, compilador, servindo apenas para a documentao e esclarecimento do programador. segue-se com uma diretiva para o pr-processador #include . Isto advm do fato de C ter um ncleo pequeno de funes bsicas. Ao escrever esta linha de cdigo, o pr-processador ir acrescentar ao programa todas as funcionalidades definidas na



10

biblioteca stdio e ir link-la posteriormente ao programa. todos os servios disponveis nesta biblioteca.

Desta forma, voc poder usufruir

Por fim, temos a funo main(). Esta funo indica ao compilador em que instruo deve ser comeada a execuo do programa. Portanto, esta funo deve ser nica, aparecendo somente uma vez em cada programa. O programa termina quando for encerrada a execuo da funo main(). No caso deste programa exemplo, ela no recebe nenhum parmetro e tambm no retorna parmetro nenhum. Isto fica explcito atravs da palavra-chave void escrita na frente do programa. Se em vez de void tivssemos escrito int, isto significaria que a funo main() deveria retornar um valor do tipo inteiro ao final de sua execuo. Como este o valor retornado pela funo main(), este tambm ser o valor retornado pelo programa aps a sua execuo. caractersticas sero apresentadas em detalhes nos prximos captulos. Todo o corpo de uma funo em C inicializado e finalizado atravs das chaves { e }. Estas chaves definem o bloco de instrues a serem executados por esta funo. dada dentro do programa printf (Bom Dia!!!!);. para escrever dados na janela console. A primeira instruo Printf uma funo definida em stdio.h As funes e as suas

Todas as instrues de programa tm que ser declaradas As

dentro de alguma funo (na main() ou outra qualquer). Todas as instrues devem estar dentro das chaves que iniciam e terminam a funo e so executadas na ordem em que as escrevemos. instrues C so sempre encerradas por um ponto-e-vrgula ( ; ). instruo e no um simples separador. O ponto-e-vrgula parte da

Esta instruo uma chamada funo printf(), os

parnteses nos certificam disso e o ponto-e-vrgula indica que esta uma instruo. Nota-se que a funo chamada escrevendo-se o nome desta e colocando-se os parmetros desta dentro dos parnteses. A final de cada instruo, faz-se necessrio o acrscimo de um ponto-vrgula ;. As variveis em C podem estar dentro de uma funo ou no incio do arquivo fonte. Variveis declaradas no incio do arquivo fonte so consideradas globais, isto , so visveis (acessveis) para todas as funes do programa. Variveis declaradas dentro de uma funo so consideradas locais, isto , visveis somente pela funo onde so declaradas. "C" distingue nomes de variveis e funes em maisculas de nomes em minsculas. Voc pode colocar espaos, caracteres de tabulao e pular linhas vontade em seu programa, pois o compilador ignora estes caracteres. Em C no h um estilo obrigatrio. Entretanto, procure manter os programas to organizados quanto for possvel, pois isto melhora muito a legibilidade do programa, facilitando o seu entendimento e manuteno.Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


11

2.4 Variveis As variveis so o aspecto fundamental de qualquer linguagem de computador. nome para referenciar o seu contedo. Uma

varivel em C um espao de memria reservado para armazenar um certo tipo de dado e tendo um O espao de memria de uma varivel pode ser Em outras palavras, uma compartilhado por diferentes valores segundo certas circunstncias.

varivel um espao de memria que pode conter, a cada tempo, valores diferentes./* Programa : Exemplo de variveis! */ #include void main() { int num; num = 2; } /* declaracao */ /*atribui um valor*/

printf(Este o nmero dois: %d, num); /*acessa a varivel*/

A primeira instruo (int num) um exemplo de declarao de varivel, isto , apresenta um tipo, int, e um nome, num. A segunda instruo (num = 2) atribui um valor varivel e este valor ser acessado atravs de seu nome. Usamos o operador de atribuio (=) para este fim. A terceira instruo chama a funo printf() mandando o nome da varivel como argumento. Esta l o valor da varivel e substitui na posio indicada por %d, compondo assim a frase apresentada na tela. O emprego da funo printf() ser apresentado em detalhe, posteriormente. Em C todas as variveis devem ser declaradas. Se voc tiver mais de uma varivel do mesmo tipo, poder declar-las de uma nica vez separando seus nomes por vrgulas. Exemplo:int aviao, foguete, helicoptero;



12

2.5 Tipos de Dados O tipo de uma varivel informa a quantidade de memria, em bytes, que esta ir ocupar e a forma como o seu contedo ser armazenado. Em C existem apenas 5 tipos bsicos de variveis, que so:

Com exceo de void, os tipos de dados bsicos podem estar acompanhados por modificadores na declarao de variveis. Os modificadores de tipos oferecidos em C so:

Tipos de Dados Resultantes:



13

Observao: As declaraes que aparecem na tabela acima entre parnteses (), indicam que estas declaraes so optativas. Por exemplo short unsigned int indica a mesma preciso que unsigned int. O tipo int tem sempre o tamanho da palavra da mquina, isto , em computadores de 16 bits ele ter 16 bits de tamanho. Emprega-se o complemento de dois dos nmeros positivos para o clculo e representao dos nmeros negativos. A escolha de nomes significativos para suas variveis pode ajud-lo a entender o que o programa faz e prevenir erros. Uma varivel no pode ter o mesmo nome de uma palavra-chave de C. Em C, letras minsculas e maisculas so diferentes.

Exemplo de um programa que emprega as variveis apresentadas.void main() { float y; int i; double x = 3.24; char c = 'a'; i = 100; y = (float) i; } /*varivel Real no inicializada*/ /*varivel Inteira no inicializada*/ /*var. Double inicializada com 3.24 */ /*varivel Char inicializada com a */ /*varivel i recebe o valor 100 */ /*converte tipos */

Preste ateno na operao y= (float) i;. Esta operao muita empregada para converso de tipos de variveis diferentes. Suponha que voc tenha uma varivel x de tipo A e queira



14

convert-la para o tipo B e armazen-la em y deste tipo. Voc pode executar esta operao atravs do operador:y = ((B) x);

Ateno: Cuidado ao converter variveis com preciso grande para variveis com preciso pequena, ou seja, variveis que utilizam um nmero diferente de bits para representar dados. Voc pode perder informaes importantes por causa desta converso. Por exemplo, se voc converter um float num int, voc perder todos os dgitos depois da vrgula (preciso).void main() { float y = 3.1415; int x = 0; x = (int) y; } /* Equivalente : x = 3 */

2.6 Constantes Um constante tem valor fixo e inaltervel.printf(Bom Dia!!!!);

No primeiro programa exemplo, mostramos o

uso de uma cadeia de caracteres constante juntamente com a funo printf():

H duas maneiras de declarar constantes em C: a) usando a diretiva #define do pr-processador:#define < nome da constante > < valor >

Esta diretiva faz com que toda apario do nome da constante no cdigo seja substituda antes da compilao pelo valor atribudo. valor sobre todo o cdigo). Exemplo: No reservado espao de memria no momento da declarao define. A diretiva deve ser colocada no inicio do arquivo e tem valor global (isto , tem



15

#define #define #define

size true false

400 1 0 /* no se utiliza ";" nem "=" */

b) utilizando a palavra-chave "const":const < tipo > < nome > = < valor >;

Esta forma reserva espao de memria para uma varivel do tipo declarado. Uma constante assim declarada s pode aparecer do lado direito de qualquer equao (isto equivale a dizer que no pode ser atribudo um novo valor quela varivel durante a execuo do programa). Exemplo:const char letra = 'a'; const int size = 400; const double gravidade = 9.81; /* Programa: Exemplo do uso de Constantes */ #define { const char c = c; const int num = 10; int val = Size; } Size 4 void main()

Em C uma constante caractere escrita entre aspas simples, uma constante cadeia de caracteres entre aspa duplas e constantes numricas com o nmero propriamente dito. Exemplos de constantes: a) caractere: a b) cadeia de caracteres: Bom Dia !!!! c) nmero: -3.141523



16

2.7 Ponteiros Uma das mais poderosas caractersticas oferecidas pela linguagem C o uso de ponteiros. Um ponteiro proporciona um modo de acesso a variveis sem referenci-las diretamente. entre a varivel e o programa que a acessa. Basicamente, um ponteiro uma representao simblica de um endereo. Portanto, utilizase o endereo de memria de uma varivel para acess-la. Um ponteiro tem como contedo um endereo de memria. Este endereo a localizao de uma outra varivel de memria. Dizemos que uma varivel aponta para uma outra quando a primeira contm o endereo da segunda. A declarao de ponteiros tem um sentindo diferente da de uma varivel simples. instruo:int *px;

O

mecanismo usado para isto o endereo da varivel. De fato, o endereo age como intermedirio

A

declara que *px um dado do tipo int e que px um ponteiro, isto , px contm o endereo de uma varivel do tipo int. Para cada nome de varivel (neste caso px), a declarao motiva o compilador a reservar dois bytes de memria onde os endereos sero armazenados. Alm disto, o compilador deve estar O endereo de uma ciente do tipo de varivel armazenada naquele endereo; neste caso inteiro.

varivel pode ser passado um ponteiro atravs do operador &, como apresentado abaixo:void main() { int num, valor; /* declara as variveis como inteiras */ int *ptr; ptr = 0; ptr = &num; num = 10; valor = *ptr; }Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

/* declara um ponteiro para um inteiro */ /* inicializa o ponteiro com o endereco 0 */ /* atribui ao ptr o endereo da varivel num*/ /* atribui varivel inteira o valor 10 */ /* acessa o contedo apontado por ptr e */ /* atribui a valor */


17

Neste programa, primeiro declaram-se duas variveis inteiras.

Em seguida, declara-se um

ponteiro para uma varivel do tipo inteira. Este ponteiro tem o seu contedo inicializado com 0. Este um procedimento normal na manipulao de ponteiros, muito empregado para evitar o aparecimento de erros. ser acessado. Na seqncia, emprega-se o operador & para obter o endereo da varivel num e armazenar este endereo em ptr. Logo aps, atribumos a varivel inteira num o valor 10. Como ptr contm o endereo de num, logo ptr poder j acessar o valor 10 armazenado na varivel num. Isto feito na ltima linha, onde o contedo apontado por ptr acessado e copiado para a varivel valor. Outro exemplo da manipulao de ponteiros:void main() { int i, j, *ptr; i = 1; j = 2; ptr = &i; *ptr = *ptr + j; } /* declara as variveis */ /* i recebe o valor 1 */ /* j recebe o valor 2 */ /* ptr recebe o valor do endereo de i */ /* equivale a: i = i + j */

Pois, enquanto o endereo de um ponteiro for nulo, isto indicar que este

endereo contm um valor invlido e, portanto, o contedo representado por este endereo no deve

Nosso objetivo neste momento no apresentar todas as potencialidades dos ponteiros. Estamos aqui apresentando os ponteiros primeiramente como um tipo de dado especial. O importante aqui entender o contedo de um ponteiro e como este pode ser empregado. Posteriormente, apresentaremos as funcionalidades dos ponteiros medida que formos evoluindo no aprendizado de C.



18

2.8 Exerccios 2.1 Crie o seu programa Hello, World! ou Ol, Mame!; 2.2 Crie um programa que contenha todos os tipos de variveis possveis e as combinaes dos modificadores possveis. Inicialize estas variveis com valores tpicos. Use o mtodo para a converso de tipos para converter: a) A varivel do tipo char em todos os outros tipos de variveis. b) A varivel do tipo double em todos os outros tipos de variveis. acontece com a preciso das variveis. 2.3 Crie um programa que exemplifique a utilizao de ponteiros. Que contenha pelo menos a declarao de um ponteiro, sua inicializao com zero, a obteno do endereo de uma varivel com o operador & e o acesso ao dado representado pelo ponteiro. 2.4 Utilize as diretivas #define para criar constantes e empregue estas constantes para inicializar as variveis do programa acima. 2.5 Analise o seguinte programa e aponte onde est o erro.#define Default_Y 2 void main() { const int num = 10; int y = Default_Y; const int *ptr = 0; ptr = &num; *ptr = *ptr + y; }

Discuta o que



19

3 Entrada/Sada ConsoleAs rotinas de entrada/sada do console se encontram nas bibliotecas "stdio.h" e "conio.h" e, por isso, estas bibliotecas devem ser includas nos programas aplicativos atravs da diretiva include:#include #include

Algumas das funes de entrada e sada para a console mais utilizadas so apresentadas a seguir: 3.1 Printf() A funo printf() uma das funes de E/S (entrada e sada) que podem ser usadas em C. Ela no faz parte da definio de C mas todos os sistemas tm uma verso de printf() implementada. Ela permite a sada formatada na tela. J vimos duas aplicaes diferentes da funo printf():printf(Bom Dia!!!!); printf(Este o nmero dois: %d, num);

A funo printf() pode ter um ou vrios argumentos. No primeiro exemplo ns colocamos um nico argumento: Bom Dia !!!!. printf():printf(string-formatao, < lista de parmetros >);

Entretanto, no segundo colocamos dois: Este o nmero

dois: %d que est esquerda e o valor 2 direita da vrgula que separa os argumentos. Sintaxe de

A string de formatao pode conter caracteres que sero exibidos na tela e cdigos de formatao que indicam o formato em que os argumentos devem ser impressos. No nosso segundo exemplo, o cdigo de formatao %d solicita a printf() para imprimir o segundo argumento em formato decimal na posio da string onde aparece o %d. Cada argumento deve ser separado por uma vrgula.Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


20

Alm do cdigo de formatao decimal (%d), printf() aceita vrios outros. exemplo mostra o uso do cdigo %s para imprimir uma cadeia de caracteres:#include int main(int argc, char* argv[]) {

O prximo

printf(%s esta a %d milhoes de milhas \n do sol., Venus, 67); }

A sada ser: Venus est a 67 milhoes de milhas do sol. Aqui, alm do cdigo de formatao, a expresso de controle de printf() contm um conjunto de caracteres estranho: \n. O \n um cdigo especial que informa a printf() que o restante da A combinao de caracteres \n representa, na impresso deve ser feito em uma nova linha. Enter em um editor de texto). Os caracteres que no podem ser obtidos diretamente do teclado para dentro do programa (como a mudana de linha) so escritos em C, como a combinao do sinal \ (barra invertida) com outros caracteres. Por exemplo, \n representa a mudana de linha. A string de formatao define a forma como os parmetros sero apresentados e tem os seguintes campos: "%[Flags] [largura] [.preciso] [FNlh] < tipo > [\Escape Sequence]" onde:

verdade, um nico caractere em C, chamado de nova-linha (equivalente ao pressionamento da tecla



21

largura = nmero mximo de caracteres a mostrar; preciso = nmero de casas aps a vrgula a mostrar F = em ponteiros, apresentar como "Far" => base : offset (xxxx : xxxx) N = em ponteiros, apresentar como "Near" => offset h = apresentar como "short" l = apresentar como "long"

A seguir so mostrados alguns exemplos da formatao apresentada acima:



22

#include int main(int argc, char* argv[ ]) { float x; double y = -203.4572345; int a, b; a = b = 12; x = 3.141523; printf("Bom dia"); printf("\n\t Bom dia\n"); /*pula linha aps escrever bom dia*/ printf("O valor de x %7.3f\n", x); printf("Os valores de i, j e y so: %d %d %lf \n", a, b, y); }

Obs: Caso voc queira imprimir na tela os caracteres especiais \ ou %, voc deve escrevlos na funo printf() de forma duplicada, o que indicar ao compilador que este no se trata de um parmetro da funo printf() mas sim que deseja-se imprimir realmente este caractere. O exemplo abaixo apresenta este caso:#include void main() { int reajuste = 10; printf(O reajuste foi de %d%%. \n, reajuste); }

a sada ser: O reajuste foi de 10%.



23

3.2 Cprintf() Basicamente cprintf() igual a printf(), mas usa as coordenadas atuais do cursor e da janela que forem ajustados anteriormente, bem como ajustes de cr de caracteres. Utilize esta funo para escrever na tela em posies pr-definidas. 3.3 Scanf() A funo scanf() outra das funes de E/S implementadas em todos os compiladores C. Ela o complemento de printf() e nos permite ler dados formatados da entrada padro (teclado). A funo scanf() suporta a entrada via teclado. Um espao em branco ou um CR/LF (tecla Enter) definem o fim da leitura. Observe que isto torna inconveniente o uso de scanf() para ler strings compostas de vrias palavras (por exemplo, o nome completo de uma pessoa). Para realizar este tipo de tarefa, veremos outra funo mais adequada na parte referente strings. Sua sintaxe similar de printf(), isto , uma expresso de controle seguida por uma lista de argumentos separados por vrgula. Sintaxe:scanf(string de definio das variveis, );

A string de definio pode conter cdigos de formatao, precedidos por um sinal % ou ainda o caractere * colocado aps o % que avisa funo que deve ser lido um valor do tipo indicado pela especificao, mas no deve ser atribudo a nenhuma varivel (no deve ter parmetros na lista de argumentos para estas especificaes). A lista de argumentos deve consistir nos endereo das variveis. O endereo das variveis pode ser obtido atravs do operador & apresentado na seco sobre ponteiros. Exemplo:



24

#include void main() { float x; printf ("Entre com o valor de x : "); scanf ("%f",&x); } /*l o valor do tipo float e armazena em x*/

Esta funo funciona como o inverso da funo printf(), ou seja, voc define as variveis que deveram ser lidas da mesma forma que definia estas com printf(). Desta forma, os parmetros de scanf() so em geral os mesmos que os parmetros de printf(), no exemplo acima observa-se esta questo. O cdigo de formatao de scanf() igual ao cdigo de formatao de printf(). scanf():#include main() { float anos, dias; printf(Digite a sua idade em anos: ); scanf(%f, &anos); dias = anos*365; printf(Sua idade em dias e %.0f.\n, dias); }

Por isso,

veja as tabelas de formatao de printf() para conhecer os parmetros de scanf(). Outro exemplo de

3.4 Getch(), Getche() e Getchar() Em algumas situaes, a funo scanf() no se adapta perfeitamente pois voc precisa pressionar [enter] depois da sua entrada para que scanf() termine a leitura. usar getch(), getche() ou getchar(). Neste caso, melhor A funo getchar() aguarda a digitao de um caractere e

quando o usurio apertar a tecla [enter], esta funo adquire o caractere e retorna com o seuProf. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


25

resultado.

Getchar() imprime na tela o caractere digitado. A funo getch() l um nico caractere Ambas funes no requerem que o usurio digite [enter]

do teclado sem eco-lo na tela, ou seja, sem imprimir o seu valor na tela. A funo getche() tem a mesma operao bsica, mas com eco. para finalizar a sua execuo. Veja exemplo abaixo, junto funo putch(). 3.5 Putch() ou Putchar() A funo putch() apresenta um nico caractere na tela, recebendo-o como parmetro. funo putchar() executa a mesma operao, com caracteres. Exemplo:#include #include void main() { char c1, c2; c1 = getch(); c2 = getche(); putch(c1); putchar(c2); } /* l caractere c1 mas no mostra na tela */ /* l caractere c2, escrevendo-o na tela */ /* escreve valor de c1 na tela */

A

printf("\nO primeiro valor digitado foi: "); printf("\nO segundo valor digitado foi: ");

3.6 Exerccios 3.1 Escreva um programa que contenha uma nica instruo e imprima na tela:



26

3.2 Escreva um programa que imprima na tela:

3.3 Escreva um programa que pea os dados da conta bancria de um cliente e, posteriormente, escreva na tela os dados do cliente tambm de forma organizada. 3.4 Escreva um programa que exemplifique todos os tipos de formataes fornecidas para o printf(). 3.5 Escreva um programa que pea ao usurio para entrar com um valor real (float), converta este valor para uma varivel do tipo char e depois imprima o seu valor na tela em formato decimal e em formato caractere. 3.6 Faa um programa que pea ao usurio para entrar com um caractere, converta este nmero para um valor inteiro e apresente na tela o valor deste nmero em formato float e o endereo da varivel que o contm. Utilize ponteiros para armazenar e acessar este valor.



27

4 Operadores4.1 Operadores Aritmticos C uma linguagem rica em operadores, em torno de 40. Alguns so mais usados que

outros, como o caso dos operadores aritmticos que executam operaes aritmticas. C oferece 6 operadores aritmticos binrios (operam sobre dois operandos) e um operador aritmtico unrio (opera sobre um operando). So eles: Binrios: = + * / % Unrio: Menos unrio (indica a troca do sinal algbrico do valor) Em C, o sinal de Atribuio Soma Subtrao Multiplicao Diviso Mdulo (devolve o resto da diviso inteira)

O operador = j conhecido dos exemplos apresentados anteriormente. ao nome da varivel esquerda.

igual no tem a interpretao dada em matemtica. Representa a atribuio da expresso direita J os operadores + - / * representam as operaes aritmticas A seguir est um programa que usa vrios bsicas de soma, subtrao, diviso e multiplicao.

operadores aritmticos e converte temperatura Fahrenheit em seus correspondentes graus Celsius.#include void main() { int ftemp = 0; int ctemp = 0; printf("Digite temperatura em graus Fahrenheit: "); scanf("%d", &ftemp);Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


28

ctemp = (ftemp - 32)*5/9; printf("Temperatura em graus Celsius e %d", ctemp); }

O operador mdulo (%) aceita somente operandos inteiros. inteiro sua esquerda pelo inteiro sua direita. dividimos 17 por 5 teremos resto 2. 4.2 Operadores Relacionais

Resulta o resto da diviso do

Por exemplo, 17%5 tem o valor 2 pois quando

Os operadores relacionais so usados para fazer comparaes. Em C no existe um tipo de varivel chamada booleana, isto , que assuma um valor verdadeiro ou falso. O valor zero (0) considerado falso e qualquer valor diferente de 0 considerado verdadeiro e representado pelo inteiro 1. Os operadores relacionais comparam dois operandos e retornam 0 se o resultado for falso e 1 se o resultado for verdadeiro. Os operadores relacionais disponveis em C so:

O programa a seguir mostra expresses booleanas como argumento da funo printf():#include void main() { int verdade, falso; verdade = (15 < 20); falso = (15 == 20);Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


29

printf("Verdadeiro= %d, falso= %d\n", verdade, falso); }

Note que o operador relacional igual a representado por dois sinais de iguais. Um erro comum o de usar um nico sinal de igual como operador relacional. O compilador no o avisar que este um erro, por qu? Na verdade, como toda expresso C tem um valor verdadeiro ou falso, este no um erro de programa e sim um erro lgico do programador. 4.3 Operadores lgicos binrios Estes operadores so empregados para comparar os bits contidos em duas variveis, por isso, so denominados operadores lgicos binrios. Ou seja, estes operadores fazem uma comparao lgica entre cada bit dos operandos envolvidos. Os operadores binrios disponveis so:

A seguir temos um exemplo da aplicao destes operadores.#include void main() { int i, j, k; i = 1; j = 2; printf("\ti = %x (00000001)\n\tj = %x (00000010)", i, j); k = i & j; /* k = i AND j */ printf("\n\t i & j => %x (00000000)", k);Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


30

k = i ^ j; k = i '); printf("\n"); } }

O mtodo de passagem do endereo da matriz para a funo idntico ao da passagem de uma matriz de uma dimenso, no importando quantas dimenses tem a matriz, visto que sempre passamos o seu endereo.grafico(pecas, FUNC);Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


78

Como no h verificao de limites, uma matriz com a primeira dimenso de qualquer valor pode ser passada para a funo chamada. Mas uma funo que recebe uma matriz bidimensional dever ser informada do comprimento da segunda dimenso para saber como esta matriz est organizada na memria e assim poder operar com declaraes do tipo:pecas[2][1]

pois, para encontrar a posio na memria onde pecas[2][1] est guardada, a funo multiplica o primeiro ndice (2) pelo nmero de elementos da segunda dimenso (MES) e adiciona o segundo ndice (1), para finalmente somar ao endereo da matriz (pecas). Caso o comprimento da segunda matriz no seja conhecido, ser impossvel saber onde esto os valores. 9.5 Strings C no possui um tipo de dado especial para tratar strings. Desta forma, uma das aplicaes mais importante de matrizes em C justamente a criao do tipo string, caracterizado por uma sequncia de caracteres armazenados terminados por \0 (que possui o valor 0 na tablea ASCII) em uma matriz. Por esta razo que C no fornece uma estrutura amigvel para a manipulao de Somente com o advento da string comparada com outras linguagens como Pascal, por exemplo.

orientao a objetos (C++) que C veio a fornecer uma estrutura amigvel e flexvel para tratar strings. Esta estrutura ser vista somente nos captulos posteriores. Aqui, apresentaremos string na sua forma bsica em C. String uma matriz tipo de char que armazena um texto formado de caracteres e sempre terminado pelo caractere zero (\0). Em outras palavras, string uma srie de caracteres, onde cada um ocupa um byte de memria, armazenados em seqncia e terminados por um byte de valor zero (\0). Cada caractere um elemento independente da matriz e pode ser acessado por meio de um ndice.



79

9.5.1 Strings Constantes Qualquer seqncia de caracteres delimitadas por aspas duplas considerada pelo compilador como uma string constante. O compilador aloca uma matriz com tamanho uma (1) unidade maior que o nmero de caracteres inseridos na string constante, armazenando estes caracteres nesta matriz e adicionando automaticamente o caractere delimitador de strings \0 no final da matriz. Vrios exemplos de strings constantes esto presentes ao longo de texto, exemplos como :printf(Bom Dia!!!!);

O importante lembrar que o compilador sempre adiciona o caractere \0 a strings constantes antes de armazen-las na forma de matriz para poder marcar o final da matriz. Observe que o caractere \0, tambm chamado de NULL, tem o valor zero decimal (tabela ASCII), e no se trata do caractere 0, que tem valor 48 decimal (tabela ASCII). A terminao \0 importante, pois a nica maneira que as funes possuem para poder reconhecer onde o fim da string. 9.5.2 String Variveis Um das maneiras de receber uma string do teclado atravs da funo scanf() pelo formato %s. A funo scanf() l uma string at voc apertar a tecla [enter], adiciona o caractere \0 e armazena em uma matriz de caracteres. Perceba que o endereo da matriz e passado escrevendo-se somente o nome da matriz. Abaixo apresentamos um exemplo, nele fica claro que se voc digitar uma frase com um nmero maior de caracteres do que a matriz alocada, (char[15]) um erro de memria ir ocorrer. Isto se deve ao fato de scanf() no testar a dimenso de matriz e simplesmente adquirir uma seqncia de caracteres at encontrar um caractere do [enter], espao simples ou tabulao. Depois ela armazena a string na matriz fornecida, sem testa a dimenso da matriz. A definio de uma string segue o mesmo formato da definio de matrizes, entretanto o tipo empregado o tipo char.



80

#include void main() { char nome[15]; /* declara uma string com 15 caracteres */ printf("Digite seu nome: "); scanf("%s", nome); printf("Saudacoes, %s.", nome); }

Se voc escrever Pedro Silva no programa acima, a funo scanf() ir eliminar o segundo nome. Isto se deve por que scanf() utiliza qualquer espao, quebra de linha ou tabulao para Neste caso, a funo gets() se aplica de forma mais eficiente para a aquisio de strings. A funo gets() adquire uma string at se pressionada a tecla [enter], adicionando o caractere \0 para especificar o fim da string e armazen-la em uma matriz. Desta forma podemos utilizar gets() para ler strings com espaos e tabulaes. Para imprimir strings utilizamos as duas funes principais printf() e puts(). O formato de impresso de strings com prinf() ns j conhecemos, basta escrever o parmetro %s no meio da string de formatao de printf() e posteriormente passar o nome da matriz de caracteres, terminada com \0, como parmetro. Puts() tem uma sintaxe bem simples tambm. Chamando a funo puts() e passando-se o nome da matriz de caracteres terminada por \0 como parmetro, teremos a string impressa na tela (sada padro) at encontrar o caractere \0. Aps a impresso, puts() executa uma quebra de linha automaticamente [enter], o que impossibilita a sua aplicao para escrever duas strings na mesma linha. Abaixo, temos um exemplo:char nome[] = Carlos Henrique; puts(nome);

determinar o fim da leitura de uma string.

Em C, a forma formal da inicializao de strings ocorre da mesma maneira que uma matriz, ou seja, inicializamos termo por termo como a seguir:Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


81

char text[] = {B, o, m, , d, i, a, !, \0};

C fornece ainda uma maneira bem simples, que foi apresentada no outro exemplo acima. Note que na forma formal de inicializao temos que adicionar explicitamente o caractere \0 para determinar o fim da matriz. J na forma simples, o compilador faz isto automaticamente para voc. 9.5.3 Funes para Manipulao de Strings Em C existem vrias funes para manipular matrizes e tentar tornar a vida do programador um pouco mais fcil. Veremos aqui as 4 funes principais: strlen(), strcat(), strcmp() e strcpy(). Note que estas funes exigem que o caractere \0 esteja delimitando o final da string. A funo strlen() aceita um endereo de string como argumento e retorna o tamanho da string armazenada a partir deste endereo at um caractere antes de 0, ou seja, ela retorna o tamanho da matriz que armazena a string menos um, descontando assim o caractere de final da string \0. Sintaxe:strlen(string);

A funo strcat() concatena duas strings, isto , junta uma string ao final de outra. Ela toma dois endereos de strings como argumento e copia a segunda string no final da primeira e esta combinao gera uma nova primeira string. A segunda string no alterada. Entretanto, a matriz da primeira string deve conter caracteres livres (ou seja, caracteres alocados localizados aps o delimitador de final de string \0) suficientes para armazenar a segunda string. A funo strcat() no verifica se a segunda string cabe no espao livre da primeira. Sintaxe de strcat():strcat(string1, string2);

A funo strcmp() compara duas strings e retorna: 0 : : : no caso da string 1 < que a string 2 no caso da string 1 = a string 2 no caso da string 1 > que a string2



82

Neste contexto, menor que () indica que, se voc colocar string1 e string2 em ordem alfabtica, o que aparecer primeiro ser menor que o outro. Sintaxe:strcmp(string1, string2);

A funo strcpy() simplesmente copia uma string para outra. Note, que a string1 deve conter espao suficiente para armazenar os dados da string2. Sintaxe:strcpy(string1, string2);

Abaixo vamos mostrar um exemplo que apagar um caractere do interior de uma string. Neste exemplo vamos implementar a funo strdel() que move, um espao esquerda, todos os caracteres que esto a direita do caractere sendo apagado.#include void strdel(char str[], int n); void main() { char string[81]; int posicao; printf("Digite string, [enter], posicao\n"); gets(string); scanf("%d", &posicao); strdel(string, posicao); puts(string); } /* strdel() - apaga um caractere de uma string */ void strdel(char str[], int n) { strcpy(&str[n], &str[n+1]); }Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


83

9.6 Exerccios 9.1 Crie um programa para calcular a matriz transposta de uma dada matriz. inicializar a matriz com zero. Aloque uma

memria para uma matriz bidimensional com dimenso mxima de 10x10. Crie uma funo para Depois questione o usurio para sob a dimenso da matriz que ele Depois, adquira os deseja calcular a transposta, considerando a dimenso mxima permitida. calcule a transporta da matriz e escreva na tela o resultado final da matriz. 9.2 Continue o programa anterior e agora calcule o tamanho de memria alocada para a matriz e que no est sendo utilizada. Ou seja, considerando o tipo de dado da matriz, que a matriz inicial tem tamanho 10x10 e o tamanho utilizado pelo usurio, quantos bytes de memria o computador alocou para a matriz e quantos bytes de memria o usurio realmente utilizou. este problema. 9.3 A decomposio LDU uma decomposio famosa de matrizes aplicada para calcular inversas de matrizes e resolver problemas de equaes lineares. Utilize o programa 9.1 e crie um programa que calcule a decomposio LDU de uma matriz, preferencialmente, com pivotamento. 9.4 Escreva uma funo que indique quantas vezes aparece um determinado caractere em uma dada string. 9.5 Escreva uma funo que localize um caractere em uma string, substituindo-a por outro. 9.6 Escreva uma funo que insira um determinado caractere em uma determinada posio de uma string. 9.7 Escreva uma funo que retire todos os caracteres brancos, tabulaes ou nova linha [enter] de uma dada string. 9.8 Escreva um programa que converta todas os caracteres minsculos de uma string para o correspondente caractere maisculo. 9.9 Refaa o seu exerccio 6.2 para criar uma tabela com os seus horrios ocupados e compromissos na semana. strings. Armazene o valor de cada compromisso atravs de uma tabela de Inicialize a tabela com valor 0, e solicite ao usurio que fornea o seu horrio. Por fim, Crie uma funo que calcule este dado comparando duas matrizes de dimenses quaisquer. Reflita sobre

valores dos termos que compem a matriz, solicitando ao usurio que fornea estes dados. Por fim,

apresente na tela o resultado obtido.Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


84

10 Tipos Especiais de DadosEm C podemos definir novos tipos de dados, adicionando complexidade aos tipos de dados j existentes. Com a finalidade de tornar a vida do programador mais fcil e permitir que este crie novos tipos de dados, compostos pelos tipos de dados j pr-existentes (char, int, float, double e matrizes destes tipos). 10.1 Typedef Typedef nos apresenta a primeira forma de criar um novo tipo de dado. Typedef permite a definio de novos tipos de variveis. Os novos tipos so sempre compostos de uma ou mais variveis bsicas agrupadas de alguma maneira especial. Sintaxe:typedef ;

Exemplo da definio de um novo tipo de dado:typedef double real_array [10]; real_array x, y; /* novo tipo */

/* declara variveis tipo real_array */

No exemplo acima, ambas x e y foram declaradas como sendo do tipo real-array e, por isso, representam um vetor de valores reais (double) com capacidade para armazenar 10 dados deste tipo. 10.2 Enumerados (Enum) Permitem atribuir valores inteiros seqenciais constantes. Tipos enumerados so usados

quando conhecemos o conjunto de valores que uma varivel pode assumir. A varivel deste tipo sempre int e, para cada um dos valores do conjunto, atribumos um nome significativo para represent-lo. A palavra enum enumera a lista de nomes automaticamente, dando-lhes nmeros emProf. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


85

seqncia (0, 1, 2, etc.). A vantagem que usamos estes nomes no lugar de nmeros, o que torna o programa mais claro. Abaixo so apresentados exemplos da aplicao de tipos enumerados e suas definies:enum dias { segunda, terca, quarta, quinta, sexta, sabado, domingo }; enum cores { verde = 1, azul = 2, preto, /*no foi dado valor, recebe valor anterior + 1 = 3*/ branco = 7 }; enum boolean { false, true }; void main() { enum dias dia1, dia2; /*declara varivel "dias" do tipo enum*/ enum boolean b1; dia1 = terca; dia2 = terca + 3; if (dia2 == sabado) b1 = true; }Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

/* atribui: segunda = 0; */ /* atribui: terca = 1; */ /* atribui: quarta = 2; */ /* atribui: quinta = 3; */ /* atribui: sexta = 4; */ /* atribui: sabado = 5; */ /* atribui: domingo = 6; */

/* false = 0 */ /* true = 1 */

/*declara varivel do tipo enum boolean*/ /* dia2 = sexta */


86

A palavra enum define um conjunto de nomes com valores permitidos para esse tipo e enumera esses nomes a partir de zero (default) ou, como em nosso programa, a partir do primeiro valor fornecido. Se fornecermos um valor a alguns nomes e no a outros, o compilador atribuir o prximo valor inteiro aos que no tiverem valor. A sintaxe fica clara no exemplo acima. Um varivel de tipo enumerado pode assumir qualquer valor listado em sua definio. Valores no listados na sua definio no podem ser assumidos por esta varivel. permitida com eles. 10.3 Estruturas (Struct) Estruturas permitem definir estruturas complexas de dados, com campos de tipos diferentes. Observe que nas matrizes (arrays), todos os campos so do mesmo tipo. dados. Por meio da palavra-chave struct definimos um novo tipo de dado. Definir um tipo de dado significa informar ao compilador o seu nome, o seu tamanho em bytes e o formato em que ele deve ser armazenado e recuperado na memria. Aps ter sido definido, o novo tipo existe e pode ser Abaixo apresentamos as utilizado para criar variveis de modo similar a qualquer tipo simples. variveis deste tipo: As structs permitem, entretanto, criar elementos semelhantes a arrays, mas composta de elementos com tipos diferentes de Tipos enumerados so tratados internamente como inteiros, portanto qualquer operao vlida com inteiros

duas sintaxes que podem ser empregadas para a definio de estruturas e para a declarao de



87

Definir uma estrutura no cria nenhuma varivel, somente informa ao compilador as caractersticas de um novo tipo de dado. No h nenhuma reserva de memria. A palavra struct indica que um novo tipo de dado est sendo definido e a palavra seguinte ser o seu nome. Desta forma, faz-se necessrio a declarao de variveis deste tipo. Na primeira sintaxe, mostramos no exemplo como podemos declarar um varivel do tipo da estrutura Dados_Pessoais j na definio da estrutura (P1) e como podemos criar outras variveis deste tipo ao longo do programa (P2 e P3). J na segunda sintaxe, a forma da declarao de variveis deve ser sempre explcita, como mostrado no exemplo. Uma vez criada a varivel estrutura, seus membros podem ser acessados por meio do operador ponto. O operador ponto conecta o nome de uma varivel estrutura a um membro desta. Abaixo, fornecemos exemplos de acesso as variveis definidas por meio de estruturas:gets(P1.Nome); P1.Idade = 41; P3.Peso = 75.6;

A linguagem C trata os membros de uma estrutura como quaisquer outras variveis simples. Por exemplo, P1.Idade o nome de uma varivel do tipo int e pode ser utilizada em todo lugar onde



88

possamos utilizar uma varivel int. uma matriz. Veja um exemplo:struct data { int dia; char mes[10]; int ano; };

A inicializao de estruturas semelhante inicializao de

data natal = { 25, Dezembro, 1994}; data aniversario = { 30, Julho, 1998};

Uma varivel estrutura pode ser atribuda atravs do operador igual (=) a outra varivel do mesmo tipo:aniversario = natal;

Certamente constatamos que esta uma estupenda capacidade quando pensamos a respeito: todos os valores dos membros da estrutura esto realmente sendo atribudos de uma nica vez aos correspondentes membros da outra estrutura. Isto j no possvel, por exemplo, com matrizes. Estruturas no permitem operaes entre elas, somente entre os seus membros. Aps definirmos um tipo de dado atravs de uma estrutura, podemos incluir este tipo de dado como membro de uma outra estrutura. Isto cria o que chamamos tipos aninhados de estruturas, onde uma estrutura contm no seu interior como membro outra estrutura. Esta operao funciona assim como uma matriz bidimensional na verdade uma matriz de matrizes unidimensionais. Estruturas podem ser passadas para funes assim como qualquer outra varivel, sendo declarada e utilizada da mesma forma. resultado do seu processamento. mais de um parmetro. Podemos criar uma matriz para estruturas assim como criamos uma matriz de um tipo qualquer, basta declarar o tipo da matriz como o tipo definido pela estrutura. A seguir apresentamosProf. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

Funes podem tambm retornar uma estrutura como o

Para tal, basta declarar o tipo de retorno de uma funo como

sendo um tipo declarado por uma struct. Esta uma forma de fazer com que uma funo retorne


89

um exemplo envolvendo matrizes de estruturas, onde trataremos de uma matriz de estruturas que contm os dados necessrios para representar um livro. A forma de acesso aos membros da estrutura, armazenadas na matriz fica clara no exemplo. As funes atoi() e atof() apresentadas no exemplo abaixo servem para converter strings para um tipo inteiro ou float, respectivamente, e esto definidas em stdlib.#include #include /* definioes de tipo */ struct list { char titulo[30]; char autor[30]; int regnum; double preco; }; /* declaracao de variaveis e funcoes*/ struct list livro[50]; int n = 0; void novonome(); void listatotal(); void main() { char ch; while(1) { printf("\nDigite 'e' para adicionar um livro"); printf("\n'l' para listar todos os livros: "); ch = getche(); switch(ch) { case 'e' : novonome();Prof. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

/* para atof() e atoi() */


90

break; case 'l': listatotal(); break; default: puts("\nDigite somente opcoes validas!!!!"); } } } /* novonome() - adiciona um livro ao arquivo */ void novonome() { char numstr[81]; printf("\nRegistro %d. \nDigite titulo: ", n+1); gets(livro[n].titulo); printf("\nDigite autor: "); gets(livro[n].autor); printf("\nDigite o numero do livro (3 digitos): "); gets(numstr); livro[n].regnum = atoi(numstr); /* converte string p/ int */ printf("\nDigite preco: "); gets(numstr); livro[n].preco = atof(numstr); n++; } /* listatotal() - lista os dados de todos os livros */ void listatotal() { int i; if(!n) printf("\nLista vazia.\n"); else for(i=0; i 0) soma += *(notas+i); }while(*(notas+i++) > 0); printf("Media das notas: %.2f", soma/(i-1)); }

Vamos mostrar um exemplo

O operador de incremento ou decremento no pode ser aplicado a ponteiros constantes. Por exemplo, no podemos substituir o comando (notas + i++) por (notas++), haja visto que notas um ponteiro constante. Para fazer isto, precisamos criar um ponteiro varivel qualquer, atribuir a ele o endereo da matriz e depois incrementar o valor deste ponteiro:float * ptr = 0; ptr = notas; (notas + i++) == (ptr++) /* so equivalentes */

Como, ptr aponta para uma matriz do tipo float, o operador (++) incrementa em 4 bytes a cada operao. Podemos passar matrizes como parmetros para funes, passando-se como parmetro um ponteiro para o primeiro elemento da matriz e depois utilizando este ponteiro paraProf. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao


103

acessar todos os elementos da matriz. Esta sintaxe funciona exatamente igual como se estivssemos passando um ponteiro de uma varivel normal como parmetro. verificar esta sintaxe. 11.5 Ponteiros & Strings Como strings so na verdade tratadas em C como matrizes simples de caracteres finalinazadas por 0 (caractere \0), podemos utilizar as facilidades fornecidas pelos ponteiros para manipular strings tambm. Abaixo mostramos um exemplo que ilustra este caso:#include #include char * procstr(char *, char); void main() { char *ptr; char ch, lin[81]; puts("Digite uma sentenca: "); gets(lin); printf("Digite o caractere a ser procurado: "); ch=getche(); ptr = procstr(lin, ch); printf("\nA string comeca no endereco %p.\n", lin); if(ptr) /* if(ptr != 0) */ { printf("Primeira ocorrencia do caractere: %p.\n", ptr); printf("E a posicao: %d", ptr-lin); } else printf("\nCaractere nao existe.\n"); }

Veja a seco anterior para



104

char * procstr(char * l, char c) { if(l == 0) return 0; while((*l != c)&&(*l != '\0')) l++; if(*l != '\0') return l; return 0; }

Primeiramente, fornecemos aqui um exemplo de funo que retorna como resultado um ponteiro. Note que, antes de acessarmos o valor deste ponteiro, testamos se este um ponteiro vlido para no cometer nenhum erro acessando uma rea imprpria da memria. O programa utilizou a manipulao de ponteiros para localizar a posio de um caractere em uma string e fornecer a sua posio ao usurio. A maioria das funes em C manipulam strings Em vez de declararmos uma como ponteiros e, por isso, so extremamente rpidas e otimizadas.

string como uma tabela, podemos faze-lo diretamente como sendo um ponteiro. O tipo (char *) reconhecido em C como sendo um tipo string, ou seja, um ponteiro para uma seqncia de caracteres. Por isso, as inicializaes abaixo so equivalentes:char * salute = Saudacoes; char salute[] = Saudacoes;

Entretanto, esta inicializao alocar memria somente para o correspondente nmero de caracteres da string passada mais um caractere \0 para delimitar a string. Nenhum espao a mais de memria ser alocado neste caso. As duas formas provocam o mesmo efeito, mas so diferentes: a primeira declara salute como um ponteiro varivel e a segunda como um ponteiro constante. O valor de um ponteiro constante no pode ser modificado, j um ponteiro varivel pode ter seu valor modificado, por um incremento (++), por exemplo: Podemos criar em C matrizes de ponteiros



105

para strings.

Esta uma das maneiras mais econmicas para alocar memria para uma

matriz de strings sem desperdiar memria. Por exemplo, a inicializao:static char * list[5] = { Katarina, Nigel, Gustavo, Francisco, Airton };

Vai alocar uma matriz com 5 elementos, onde cada elemento conter o valor de um ponteiro para uma lista de caracteres (string). Desta forma, o espao de memria necessrio para alocar ser somente o tamanho estritamente necessrio. Como a string de ponteiros, basta alocar espao para cada elemento de 2 bytes, enquanto que a seqncia de caracteres apontado por este ponteiro pode estar em qualquer posio de memria. Se quisssemos fazer a mesma inicializao utilizando uma matriz de vetores de caracteres, isto implicaria que teramos que alocar uma tabela MxN para conter todos os caracteres e isto nos levaria a desperdiar algumas posies da memria que no chegaram nunca a conter algum caractere, j que as strings se caracterizam por conter um comprimento diferentes de caracteres. Por isto, uma das razes para se inicializar strings com ponteiros a alocao mais eficiente de memria. Uma outra razo a de obter maior flexibilidade para manipular matrizes de strings. Por exemplo, suponha que desejssemos reordenar as strings da matriz acima. Para fazer isto, no precisamos remover as strings de sua posio e escrev-las em outra matriz na ordem correta, basta trocar de posio os ponteiros que apontam para as strings. em outra posio de memria. 11.6 Ponteiros para Ponteiros A habilidade da linguagem C de tratar partes de matrizes como matrizes cria um novo tpico de C, ponteiros que apontam para ponteiros. Esta habilidade d a C uma grande flexibilidade na Reordenando os ponteiros, obteremos a ordem desejada das strings sem ter que se preocupar em reescrever as strings



106

criao e ordenao de dados complexos.

Vamos analisar um exemplo de acesso duplamente

indireto de dados derivados de uma matriz de duas dimenses:#include #define LIN 4 #define COL 5 void main() { static int tabela[LIN][COL] = { {13, 15, 17, 19, 21}, {20, 22, 24, 26, 28}, {31, 33, 35, 37, 39}, {40, 42, 44, 46, 48} int c = 10; int j, k; int * ptr = ( int *) tabela; for(j=0; jtitulo, ptrl->autor); return 0; }

A declarao feita como se estivssemos declarando uma varivel de qualquer tipo, adicionando-se o operador (*) na frente do nome da varivel. Por isso, a declarao de um ponteiro para uma estrutura feito na forma:struct lista *ptrl;

O ponteiro ptrl pode ento apontar para qualquer estrutura do tipo lista. A atribuio de um endereo a um ponteiro de estrutura funciona da mesma forma como uma varivel qualquer, empregando-se o operador (&):ptrl = &(livro[0]);

Vimos no captulo sobre estruturas como fazer o acesso a um elemento de uma estrutura atravs do operador (.). Por exemplo, se quisermos ler o valor do preo da primeira estrutura da matriz livro, procederamos da forma: livro[0].preco = 89.95; Mas como proceder com ponteiros? Podemos faz-lo de duas formas. Primeiro, podemos utilizar o operador (*) para obter a estrutura apontada por um ponteiro e depois empregar o operador normal (.) para acessar um elemento desta estrutura. Aplicando no exemplo acima, teremos:(*ptrl).preco = 89.95;



112

O segundo mtodo utiliza o operador (->) que nos permite acessar um elemento de uma estrutura apontada por um dado ponteiro. Aplicando-se este operador no problema acima, temos:ptrl->preco = 89.95;

Em outras palavras, um ponteiro para estrutura seguido pelo operador (->) trabalha da mesma maneira que o nome de uma estrutura seguido pelo operador (.). importante notar que ptrl um ponteiro, mas ptrl->preco um membro da estrutura apontada. Neste caso, ptrl->preco uma varivel double. O operador (.) conecta a estrutura a um membro dela; o operador (->) conecta um ponteiro a um membro da estrutura. 11.9 Alocao Dinmica de Memria A linguagem C oferece um conjunto de funes que permitem a alocao ou liberao dinmica de memria. Desta forma, podemos alocar memria para um programa de acordo com a sua necessidade instantnea de memria. so: segmento de dados, onde so alocadas as variveis globais (extern), definidas em preruntime; o segmento de cdigo, onde esto as instrues de mquina do programa em si; o segmento de pilha (stack), onde as funes alocam provisoriamente suas variveis locais (auto). Este segmento tambm usado para passagem de parmetros; o segmento extra, que pode conter mais variveis globais; Toda a rea de memria restante entre o fim do programa e o fim da RAM livre chamada de heap. O heap usado para a criao de variveis dinmicas, que so criadas em run-time (isto , durante a execuo do programa). Este tipo de varivel til quando no se sabe de antemo quantas variveis de um determinado tipo sero necessrias para a aplicao em questo. Quando escrevemos um programa utilizando o mtodo de declarao de variveis visto anteriormente (alocao esttica de memria), o programa ao ser executado alocar somente umProf. Carlos Pantaleo Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

A memria de trabalho do computador (RAM) Estes segmentos

usualmente subdividida em vrios segmentos lgicos dentro de um programa.


113

bloco fixo de memria para armazenar todos os seus dados. Isto resolve o problema de termos um espao de memria alocado para podermos armazenar os dados do programa. Entretanto, como visto no captulo de matrizes, este mtodo no otimiza a utilizao do espao de memria alocado. Por exemplo, imagine que voc precise de uma matriz temporria para armazenar alguns dados temporrios durante a execuo de uma dada funo de manipulao de matrizes. Para tal, voc dever declarar esta matriz na funo, o que implicar que o computador ir alocar um bloco de memria para esta matriz. Este espao de memria ficar alocado ao seu programa durante toda a execuo deste, apesar do programa s utilizar uma vez esta matriz e, posteriormente, no precisar mais desta matriz e nem do espao de memria alocado a esta. Com a alocao dinmica de memria, podemos, em tempo de execuo, fazer com que um programa aloque um determinado espao de memria, utilize este espao por um determinado tempo e depois o libere, para que outros programas possam vir a utiliz-lo. No caso do nosso exemplo, podemos fazer com que sempre que a funo for chamada, ela alocar um espao de memria para armazenar a referida matriz e aps o seu uso, o programa liberar este bloco de memria para que outro programa o utilize. Desta forma, se executarmos esta funo apenas uma vez, o programa ir liberar esta memria posteriormente, permitindo assim que outros programas faam um uso mais adequado desta. Desta forma, a alocao dinmica de memria utilizada em programas para alocar e liberar blocos temporrios de memrias durante a execuo de um programa (por isso chamado alocao dinmica). Este bloco de memria solicitado ao sistema operacional que procura um espao livre de memria para o programa. Se o sistema operacional achar um bloco de memria livre do tamanho do bloco solicitado, este passa o bloco de memria para o controle do programa e no ir permitir que nenhum outro programa utilize esta memria enquanto ela estiver alocada. No final do seu uso, o programa libera novamente esta memria ao sistema operacional. Outro exemplo de aplicao da alocao dinmica de memria na utilizao de matrizes quando no sabemos de antemo quantos elementos sero necessrios. Desta forma, podemos utilizar a alocao dinmica de memria para somente alocar a quantidade necessria de memria e no momento em que esta memria for requerida.



114

11.9.1 Malloc() A funo malloc() utilizada para fazer a alocao dinmica de um bloco de memria a um dado programa. A funo malloc() toma um inteiro sem sinal como argumento. Este nmero representa a quantidade em bytes de memria requerida. A funo retorna um ponteiro para o importante verificar que o

primeiro byte do novo bloco de memria que foi alocado.

ponteiro retornado por malloc() para um tipo void. O conceito de ponteiro para void deve ser introduzido para tratar com situaes em que seja necessrio que uma funo retorne um ponteiro genrico, i.e., que possa ser convertido em um ponteiro para qualquer outro tipo de dado. Este ponteiro void pode ser convertido para um ponteiro do tipo de dado desejado (int, float, struct, ...) empregando-se o mtodo de converso de tipos apresentado na seco sobre tipos de dados (ver 2.5). No prximo exemplo, mostraremos seu emprego novamente. Quando a funo malloc() no encontrar espao suficiente de memria para ser alocado, esta retornar um ponteiro NULL, i.e., um ponteiro invlido. O exemplo abaixo mostra como a funo malloc() opera. nova estrutura.#include struct xx { int numl; char chl; }; void main() { struct xx *ptr = 0; int j; printf("sizeof(struct xx) = %d\n", sizeof(struct xx)); for(j=0; j

linguagem de programacao c

Documents