C

Linguagem de Programao
C++
Bsico
Silvio Sabino de Souza Junior sabino@cefetjunior.com.br
Linguagem de Programao C++ Sumrio
Sumrio
Linguagens de programao Histria de C ____________ Caractersticas da linguagem C ______________________ A linguagem C++ ________________________________ Fundamentos de C++ Dados Padres ___________________________ 3 4 5 6
________________________________ 10
Tipos definidos e estruturas de dados _________________ 11 Modificadores de dados ___________________________ 13 Converses de dados Matrizes ___________________________ 14 ______________________ 15 Classes de armazenamento
_____________________________________ 16
Operadores _____________________________________ 17 Controle de fluxo ________________________________ 22 Ponteiros Funes Arquivos _____________________________________ 27 _____________________________________ 30 ______________________ 36 ______________________ 41 _____________________________________ 37 ___________________________ 43
Diretivas do pr-processador Introduo ao modo grfico Palavras reservadas
Linguagem de Programao C++ Linguagens de Programao Histria de C
Linguagens de programao Histria de C

O computador uma ferramenta poderosa que possui as mais variadas aplicaes no mundo moderno. Encontramos sistemas controlados por computadores em quase todas as reas do conhecimento humano, como telecomunicaes, indstrias, internet, medicina, etc. Entretanto, por mais potentes e flexveis que sejam os computadores, eles nada fariam sem que fossem orientados por listas de instrues detalhadas, interpretadas e executadas pelo processador: os programas. Tudo que fsido em um computador chamado hardware, e tudo que ele entende so dois estados de tenso que chamaremos, simbolicamente, de 0 e 1 (esses valores foram adotados somente para facilitar o entendimento). Todos os processadores possuem a sua linguagem de mquina (ou cdigo binrio), um conjunto de sequncias de zeros e uns que produzem determinadas aes. possvel escrever programas em linguagem de mquina, mas seria uma tarefa improdutiva porque para que o processador execute tarefas comuns necessrio escrever muito cdigo. Com o aumento da necessidade de programas, criaram-se as linguagens de programao, cdigos intermedirios entre a linguagem humana e a da mquina. Assim surgiram as linguagens Assembly, ADA, PL/I, CPL, BCPL, B, C, C++, Pascal, e muitas outras. As linguagens de programao podem estar mais prximas da linguagem de mquina ou da humana. Quanto mais prxima da linguagem humana, maior o nvel de uma linguagem de programao. A linguagens sofisticadas para ambientes visuais como Visual Basic e Delphi so de altssimo nvel por estarem muito longe do cdigo binrio. Os programas de computador tambm podem ser chamados de softwares. Para que o computador interprete os programas escritos em uma linguagem de programao, eles devem ser traduzidos em linguagem de mquina. Isso pode ser feito por compilao ou interpretao. A linguagem compilada quando o programa traduzido inteiramente para a linguagem de mquina antes da execuo, e interpretada quando a traduo feita linha por linha durante a execuo. Linguagens interpretadas tendem a ser mais lentas porque a traduo durante a execuo representa um trabalho extra. A linguagem C foi desenvolvida nos Laboratrios Bell por Dennis Ritchie em 1972. Sua origem est muito ligada ao sistema operacional UNIX, escrito inicialmente em 1969 em linguagem montadora. Para entendermos como a linguagem C surgiu, devemos retroceder para o Algol 60, projetado em 1960 por um Comit Internacional. Essa linguagem possua objetivos elevados para os computadores da poca e por isso nunca foi muito utilizada. Para trazer o Algol 60 mais prxmo da realidade, surgiu tanto em Londres quanto em Cambridge em 1963 a linguagem CPL, que tambm fracassou por ser muito difcil. Por isso Martim Richards criou em 1967 a linguagem BCPL, uma verso mais simples do CPL. Logo depois, Ken Tompson desenvolveu linguagem B, ainda mais simples que a BCPL, para reescrever o sofisticado sistema UNIX. Ainda havia uma problema: B e BCPL tornaram-se linguagens limitadas, teis apenas para alguns tipos de problemas. Devido a esses e outros contratempos, como imcompatibilidade com alguns tipos de hardware, Dennis Ritchie desenvolveu a sucessora de B, chamada de C. Com a nova linguagem, um mundo rico em possibilidades foi aberto aos novos programadores de sistemas. C permitia o contato ntimo com a mquina enquanto possibilitava implementar instrues de alto nvel nos mesmos programas, ou seja: uma linguagem de baixo e alto nvel simultaneamente.
Linguagem de Programao C++ Caractersticas da Linguagem C
Caractersticas da linguagem C
C pode ser considerada a principal linguagem orientada para mquinas. Diversamente de linguagens criadas para aplicaes especficas, como FORTRAN, que so orientadas para problemas, C possui flexibilidade suficiente para implementar solues para os mais variados tipos de problemas nos mais diversos hardwares. As linguagens de alto nvel permitiram que o programador se concentrasse no problema que tinha que resolver, deixando a manipulao da mquina para o compilador ou interpretador. Para a engenharia ou administrao, so excelentes. No entanto, os programadores que desenvolviam sistemas ainda dependiam das indigestas linguagens montadoras de suas mquinas. Para essa classe, C foi a soluo definitiva em termos de produtividade e eficincia: est distante o suficiente da mquina para implementar rotinas de alto nvel, e prxima o suficiente para especificar detalhes necessrios para o sistema operacional. Talvez por isso a popularidade de C seja to grande. Dentre as vantagens de C, podemos citar: 1. uma linguagem pequena; 2. Pode ser de alto ou baixo nvel, dependendo do ponto de vista; 3. Produz um cdigo muito eficiente, comparvel ao cdigo Assembly; 4. Fracamente figurada, possuindo alta flexibilidade para manipulao de dados; 5. estruturada, antecipando o surgimento formal desse conceito; 6. Suporta programao modular; 7. Possibilita interfaces com as linguagens Assembly e Pascal; 8. Apresenta operadores para manipulao de bits; 9. Permite notveis implementaes de aritmtica de ponteiros; 10. Contm estruturas flexveis de dados, limitados apenas pela necessidade; 11. Portabilidade para funcionar em mquinas e sistemas operacionais diferentes; Como nenhuma linguagem de programao perfeita, as principais desvantagens de C so: 1. Fracamente figurada, podendo produzir efeitos colaterais inesperados e bizarros; 2. Ausncia de verificao de tempo de processamento. Como surgiram muitos compiladores para a linguagem C e as variaes da linguagem comearam a ameaar a grande portabilidade de flexibilidade de C, em 1983 o ANSI padronizou a linguagem para que todos os compiladores fossem implementados segundo as mesmas regras. O ANSI manteve alguns conceitos que so conhecidos como esprito de C, como: Confie no programador. No impea que o programador faa o que precisa ser feito. Mantenha a linguagem pequena e simples.
Linguagem de Programao C++ A Linguagem C++
A Linguagem C++
Em 1980, o Dr. Bjarne Stroustrup desenvolveu a sucessora de C, a linguagem C++, que possui a base na linguagem C com idias do Algol 68 e Simula67: operadores podem ser sobrecarregados e variveis podem ser declaradas em qualquer ponto dentro do bloco de instrues como no Algol 68; objetos podem ser criados com funes virtuais e classes derivadas como no Simula67. Quando foi necessrio realizar algumas simulaes orientadas a eventos, muito rigorosas e com conceitos inexistentes nas linguagens de programao da poca como objetos e eventos, e exigindo eficincia que nenhuma linguagem existente era capaz de fornecer, nem mesmo C, um grupo liderado pelo Dr. Stroustrup comeou a trabalhar na implementao de uma nova linguagem, verstil e poderosa, mas que deveria manter a compatibilidade com programas e bibliotecas escritos em C. Devido ao alcance absoluto desse objetivo, a linguagem que nascia foi considerada sucessora de C e chamada C++. Dentre as melhorias, a mais significativa a orientao ao objeto, mudando radicalmente os conceitos avanados de programao estruturada orientada para procedimentos, que era o caso de C. No entanto, para manter o esprito de C, o programador ainda responsvel por muitas verificaes que so dispensveis em outras linguagens mais rigorosas e tambm mais limitadas, como tamanho de vetores e matrizes, endereamento de ponteiros, etc. Para que possamos ter idia do que foi modificado em relao linguagem C, citamos as principais melhorias de C++: 1. 2. 3. 4. 5. 6. 7. 8. Estruturas passam a ser de tipo nome, no exigindo o uso da palavra reservada na declarao; Declaraes de variveis em qualquer lugar do bloco, desde que antes da utilizao; Operador resoluo de escopo, permitindo variveis locais de globais de mesmo nome; Especificador const, bloqueando o valor de variveis; Unies annimas, recurso que economiza tempo e memria; Converses explcitas, que diminuem os efeitos colaterais de uma linguagem fracamente figurada; Modelagem de funo, especificando no cabealho da funo os tipos de cada argumento; Sobrecarga de funo, permitindo que mais de uma funo com o mesmo nome, desde que tenham tipo de retorno e/ou argumentos de tipos diferentes; 9. Funes com nmero de argumentos indefinido; 10. Tipo referncia, facilitando o entendimento e a sintaxe; 11. Especificador inline, deixando que o compilador decida se pode inserir o cdigo de um funo no cdigo em linha, economizando o tempo de chamada e armazenamento na pilha; 12. Operadores new e delete, melhorando a alocao dinmida de memria; 13. Ponteiros void e funes tipo void, aumentando o poder dos ponteiros e formalizando funes void; 14. Programao orientada ao objeto; 15. Biblioteca stream, melhorando sensivelmente as operaes de I/O.
Linguagem de Programao C++ Fundamentos de C++
Fundamentos de C++
Os programadores frequentemente relatam a dificuldade no aprendizado da linguagem C++ (bem como C), provavelmente devido sintaxe simblica e intimidativa. Essa queixa dificilmente acontece com Pascal, que possui uma sintaxe didtica. O fato que C e C++ foram projetadas para programadores de sistemas, ou seja, pessoas que j possuem um amplo conhecimento de lgica de programao, arquitetura e funcionamento do hardware. Mesmo assim, nada disso impede que a primeira linguagem de um programador seja C ou C++. Todos os programas devem receber dados de alguma fonte de entrada; processar as informaes recebidas por meio de instrues que podem ser divididas genericamente em: simples, condicionais, laos e funes; expressar os resultados da manipulao dos dados de entrada; possuir uma estrutura modular e nomes autodocumentados (com significado) para facilitar a manuteno e a leitura posterior feita por outros programadores. Um programa C++ constitudo de funes, que so blocos de cdigo cujas instrues executam aes de rotina. Tambm existem variveis que so locais da memria RAM onde so armazenadas informaes. Outros itens estaro presentes em um programa C++ e sero introduzidos oportunamente na compreenso da linguagem. Vamos escrever nosso primeiro programa C++, que imprime uma mensagem na tela:
// Primeiro programa C++ // Curso de Linguagem de Programao C++ PROG001.CPP - Silvio Sabino #include<iostream.h> void main(void){ cout << "\nMeu primeiro programa!"; return; } // Fim do programa
Vamos analisar linha a linha o contedo desse programa:

// Primeiro programa C++ // Curso de Linguagem de Programao C++ PROG001.CPP Silvio Sabino
Todo programa deve possuir comentrios significativos para facilitar o acompanhamento de outros programadores ou para manuteno posterior, que pode ocorrer muitos anos depois da criao do programa. Esse comentrio explica o que o programa.
#include<iostream.h>
Essa instruo uma diretiva do pr-processador que inclui o arquivo IOSTREAM.H no cdigo do programa. Esse arquivo um dos vrios arquivos de cabealho da linguagem C++, que so bibliotecas com rotinas implementadas pelos programadores da linguagem.
void main (void){ ... }
Esse bloco de cdigo uma funo C++. O smbolo { abre o cdigo e } fecha o mesmo. Esses smbolos tambm so utilizados para laos e estruturas de controle, que veremos mais adiante. A palavra void no
Linguagem de Programao C++ Fundamentos de C++ incio da linha representa o tipo de retorno da funo. Nesse caso a funo no retorna nenhum valor, fato evidenciado pela palavra void. A palavra main o identificador (nome) da funo. Todos os programas C++ possuem uma nica funo main e a execuo do programa comea sempre a partir dessa funo. A palavra entra parnteses void representa os argumentos da funo. Nesse caso, a funo no tem nenhum argumento, o que indicado pela mesma palavra void. Entre os delimitadores { e } do bloco, podem existir instrues que so chamadas corpo da funo:
cout << "\nMeu primeiro programa!";
Essa linha invoca a stream cout (console out) definida em IOSTREAM.H, que imprime o argumento Meu primeiro programa! na tela. Merece ateno a presena da sequncia \n que significa nova linha. C e C++ possuem uma srie de caracteres especiais que so formados por barra invertida (\) seguido de uma letra ou smbolo. Eis os mais comuns: \a \n \t \v \r \b \ \ \\ \f \0 Beep nova linha tabulao horizontal tabulao vertical retorno de carro retrocesso (backspace) aspas simples aspas duplas barra invertida salta uma pgina nulo (NULL)
return;
Retorna da funo para o processo anterior, no caso o sistema operacional. Essa instruo pode ser dispensada nesse caso sem nenhum aviso do compilador.
// Fim do programa
Comentrio para evidenciar que o programa terminou nesse ponto. O compilador C++ ignorar espaos repetidos, tabulaes ou linhas em branco em quase todos os pontos do programa. Portanto, o mesmo programa anterior pode ser escrito de vrias formas, como por exemplo:
// Primeiro programa C++ // Curso de Linguagem de Programao C++ PROG0011.CPP - Silvio Sabino #include <IOSTREAM.H> void main (void) {cout << "\nMeu primeiro programa!";return;}// Fim do programa
Esse programa igualmente vlido. Devemos observar que na diretiva do pr-processador no podem haver espaos entre os smbolos < > e o nome do arquivo de cabealho IOSTREAM.H pode ser escrito em maisculas. Todas as instrues C++ so terminadas em ponto-e-vrgula. Outra caracterstica marcante na sintaxe C e C++ a diferena entre letras minculas e maisculas. Em muitas linguagens, como Pascal, no existe nenhuma diferena, mas em C++ isso sentido pelo compilador. Vamos agora analisar um segundo programa C++. O cdigo apresenta declaraes de variveis e a funo adicao, cuja tarefa calcular o valor da soma de dois nmeros passados como parmetros. As explicaes esto inseridas em forma de comentrio:

// Segundo programa C++ // Curso de Linguagem de Programao C++ PROG002.CPP - Silvio Sabino #include<iostream.h> // incluindo iostream.h para utilizar a classe cout // funo que retorna a soma de 2 nmeros cujos valores // so passados como parmetros int adicao (int a, int b){ // declarando a varivel que conter o valor da soma // dos dois parmetros "a" e "b" int resultado; // atribuindo o valor da adicao de "a" e "b" varivel resultado resultado = a + b; // retornando o valor contido na varivel "resultado" para // o processo anterior, que nesse caso a funo main() return resultado; } // funo principal do programa onde iniciada a execuo void main(void){ // declarando duas variveis do tipo inteiro int n , m, soma; // atribuindo o valor 2 varivel "n" e 4 varivel "m" n = 2; m = 4; // passando "n" e "m" como parmetros para que a funo soma(int, int) // calcule a soma dos dois valores e retorne o resultado que atribudo // varivel soma soma = adicao (n, m); // imprimindo o valor de "soma" na tela cout << soma; // retornando o processo anterior, no caso o sistema operacional return; } // Fim do programa
O prximo programa melhora a interface com o usurio solicitando os valores das variveis n e m para que a funo adicao calcule a soma dos dois valores:
// Terceiro programa C++ // Curso de Linguagem de Programao C++ PROG003.CPP - Silvio Sabino #include<iostream.h> // incluindo iostream.h para utilizar as classes cout e cin // funo que retorna a soma de 2 nmeros cujos valores // so passados como parmetros int adicao (int a, int b){ // declarando a varivel que conter o valor da soma // dos dois parmetros "a" e "b" int resultado;
// atribuindo o valor da adicao de "a" e "b" varivel resultado resultado = a + b; // retornando o valor contido na varivel "resultado" para // o processo anterior, que nesse caso a funo main() return resultado; } // funo principal do programa onde iniciada a execuo void main(void){ // declarando duas variveis do tipo inteiro int n, m, soma; // pedindo para o usurio o valor de "n" cout << "\nDigite o 1o. no.: "; cin >> n; // pedindo para o usurio o valor de "m" cout << "Digite o 2o. no.: "; cin >> m; // passando "n" e "m" como parmetros para que a funo soma(int, int) // calcule a soma dos dois valores e retorne o resultado que atribudo // varivel soma soma = adicao (n, m); // imprimindo o valor de "soma" na tela cout << "A soma : " << soma; // retornando o processo anterior, no caso o sistema operacional return; } // Fim do programa
Nos programas acima, vimos como a sintaxe de declarao de funes e variveis, como passar parmetros para uma funo e como retornar valores para o processo anterior que chamou a funo. Depois disso, provavelmente ser possvel reconhecer um programa C++ se algum nos apresentar um. Passaremos agora a detalhar os aspectos especficos da linguagem C++.
Linguagem de Programao C++ Tipos definidos e estruturas de dados
Dados padres
Todo programa C++ deve ter pelo menos a funo main( ), e podem tambm conter dados que podem ser variveis ou constantes. Todos os dados e funes C++ so referenciados por identificadores (nomes). Os identificadores no podem comear com dgitos numricos porque assim o compilador no poderia separar tais identificadores de constantes.Eis a descrio suscinta dos tipos de dados padronizados C++: char: utilizado para armazenar caractares alfanumricos, o tipo char ocupa um byte na memria. Devido ao fato de C++ ser fracamente figurada, um dado char pode ser visto como nmero ou caractere, dependendo do desejo do programador na aplicao especfica. Seu valor padro pode variar de 128 a 127. int: ocupa no modelo padro uma palavra (nas mquinas da plataforma PC, isso corresponde a dois bytes) na memria e seu valor padro pode variar entre 32768 a 32767. Pode armazenar nmeros inteiros ou pode ser visto como caractere, dependendo da aplicao, mas o valor do segundo byte no considerado nesse caso. float: pode armazenar valores em ponto flutuante e correspondem aos nmeros reais. Ocupam duas palavras na memria e seu valor padro pode variar entre 3,4x10-38 at 3,4x10+38. double: armazena valores em ponto flutuante de preciso dupla. Ocupam quatro palavras na memria e seu valor padro pode variar entre 1,7x10-308 e 1,7x+308. enum: tipo de dado associado a um conjunto de constantes inteiras chamadas de conjunto de enumerao (enumeration set), que possuem valor presumido mas que podem ser especificados pelo programador. A sintaxe :
enum semana {domingo, segunda, tera, quarta, quinta, sexta, sbado} dias;
A declarao acima cria o tipo enum semana e a varivel dias, do tipo semana. A constante domingo tem valor 0 e as seguintes tm o valor da anterior mais um. void: tipo vazio para retorno e argumentos de funes. Seu uso importante para ponteiros, definindo ponteiros genricos. Isso ser visto quando tratarmos de dados dinmicos. Dados padro podem ser iniciados com algum valor quando so declarados, como na declarao:
int inteiro = 7;
Se o programador esquecer de iniciar a varivel na declarao ou fora dela, seu valor ser desconhecido at que lhe seja atribudo algum valor. Os dados variveis, em suma, so os que podem estar no lado esquerdo de uma instruo de atribuio, ou em outros termos, so lvalues. Quaisquer outras expresses no so lvalues (localizador de objeto) Pode-se conhecer o tamanho de qualquer tipo de dado C++ utilizando-se o operador sizeof que retorna o tamanho em bytes do operando. Por exemplo: sizeof(int) retorna 2, que o tamanho em bytes do tipo int.
10
Tipos definidos e estruturas de dados

typedef
Alm dos dados padronizados, podem ser definidos outros tipos de dados com a palavra reservada typedef:
typedef int inteiro;
Com essa definio, poderemos declarar um dado inteiro a como int a ou inteiro. J que inteiro foi definido como sendo equivalente ao tipo int. Na maioria dos casos, typedef utilizado para conferir significado aos tipos criados pelo usurio e facilitar a sintaxe, nos poucos casos restantes uma necessidade para que a linguagem suporte certas declaraes ou passagem de argumentos para funes.
Estruturas de dados
Podem ser definidos tipos de dados heterogneos, ou estruturas de dados, formados por combinaes de tipos vlidos, padres ou no. Existem trs tipos de estruturas de dados em C++: struct: a estrutura segue o conceito de registro: dados relacionados logicamente referenciados por um nico nome, e cada dado representa um campo. Considere um nmero complexo com a parte real e imaginria. As duas partes podem ser referenciadas por um s nome, desde que declarada uma estrutura, como por exemplo:
struct complexo { double real; double imag; };
class: tipo de dado concebido para a criao de objetos e pode ser entendida com a uma evoluo de struct. As funes de uma classe so conhecidas como mtodos. A classe abaixo possui dados (campos ou instncias) e mtodos:
class exemplo{ int n,u; float t; public: char letra; }; int exemplo::metodo1(void){ return(0); }
As instncias e mtodos de uma classe somente podem ser acessadas pelo programa diretamente se especificadas com o modificador public. No exemplo, somente letra pode ser acessada fora da classe. Em C++, tipos de dados struct tambm podem ter mtodos, e suas instncias so sempre presumidas pblicas. Para impedir o acesso de alguma instnca pelo programa, utilizamos o modificador private. A palavra reservada this representa um ponteiro que aponta para o objeto atual. Quando criamos uma class, no criamos um objeto, mas apenas um tipo de dado. Quando em algum lugar do programa declaramos um dado do tipo de uma class definida, ento criamos um objeto na memria.
11
Para que o objeto seja construdo na memria, existe sempre uma funo especial denominada construtor do objeto e para dealocar o espao reservado, o programa chama uma outra funo, chamada destrutor. O programador pode criar seus prprios construtores de destrutores, como veremos mais adiante. union: um tipo interessante de estrutura de dados. Em uma union, todos os dados ocupam a mesma rea de memria, sendo que a memria ocupada pela union igual ao tamanho do maior tipo de dado. Consideremos a union abaixo:
union teste { char caractere; int inteiro; float flutuante double flutuante_duplo; };
O maior tipo de dado o campo flutuante_duplo, que ocupa 8 bytes. Na memria, esses campos estariam de forma parecida com o esquema abaixo: char int float
double
C45D:0780 C45D:0781 C45D:0782 C45D:0783 C45D:0784 C45D:0785 C45D:0786 C45D:0787 Em uma unio, os campos esto no mesmo endereo, portanto se um deles tiver seu valor alterado, todos podem sofrer a alterao. Para acessar bits em um local de memria, C e C++ possuem uma forma de acess-los com um tipo especial de estrutura denominada campo de bits:
struct campo{ unsigned unsigned unsigned unsigned }; c1:1; c2:1; c3:4; c4:2; // // // // 1 1 4 2 bit bit bits bits
Os campos de bits em uma estrutura pode ocupar no mximo 16 bits. A configurao na memria seria algo parecido com o esquema abaixo: c4 c3 c2 c1 Bit 8 Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1
Se o nmero total de bits ocupado pelos campos de bits da estrutura for diferente de um mltiplo de 8, os bits restantes at completar um mltiplo de 8 so desperdiados, pois no ser possvel acessar os bits restantes porque o processador s poder enderear bytes e no bits.
12
Linguagem de Programao C++ Modificadores de dados
Modificadores de dados
Os tipos padres char e int podem ter seus intervalos de valores alterados pelos modificadores signed e unsigned. O modificador signed (sinalizado) o estado padro e no necessrio express-lo na declarao. J unsigned (sem sinal) deve ser explicitado para que o compilador saiba que o dado ser considerado sempre positivo. Nos dados signed o bit mais significativo representa o sinal, e quando declaramos um dado unsigned o compilador utiliza todos os bits disponveis para guardar a informao. O efeito a alterao dos intervalos de valores: unsigned int pode variar de 0 a 65535 e unsigned char de 0 a 255. O modificador long dobra o tamanho em bytes ocupado pelos tipos int e double. E short pode modificar o tipo int, mas nenhum efeito ocorre na plataforma PC. O resumo abaixo mostra o efeito nos intervalos e no tamanho em bytes dos modificadores de sinal e tamanho nos tipos padres C++: Tipo unsigned char Char Enum unsigned int short int Int unsigned long Long Float Double long double Tamanho 8 bits 8 bits 16 bits 16 bits 16 bits 16 bits 32 bits 32 bits 32 bits 64 bits 80 bits Intervalo 0 a 255 -128 a 127 -32768 a 32767 0 a 65535 -32768 a 32767 -32768 a 32767 0 a 4294967295 -2147483648 a 2147483647 3,4x10-38 a 3,4x10+38 1,7 x10-308 a 1,7 x10+308 3,4 x104932 a 1,1 x104932
Os dados podem ter seus valores inalterveis pelo programa se modificados pela palavra reservada const, e podem ter seu valor modificado por algum evento externo atravs do modificador volatile. Se um dado varivel declarado normalmente como:
int a=0;
O valor contido na varivel pode ser alterado pelo programa em uma instruo de atribuio qualquer, mas se ele a varivel for declarada com o modificador const:
const int a=0;
O programador no poder alterar o valor dessa varivel, entretanto um processo externo pode se ela for declarada como volatile, mesmo sendo especificado o modificador const:
const volatile a=0;
Nesse caso, o compilador no presumir qualquer valor para a constante, que pode estar sendo atualizada por algum processo externo.
13
Linguagem de Programao C++ Converses de dados
Converses de dados
Quando escrevemos instrues que envolvem mais de um tipo de dado, eles so convertidos automaticamente seguindo uma ordem hierrquica para que o compilador possa executar a instruo. Essas operaes so chamadas de modo misto. Essa necessidade de converso existe porque tipos de dados diferentes so armazenados de modos diferentes na memria. Os dados originais no so alterados, pois somente durante o clculo da instruo que os tipos so alterados influenciando no resultado. Consideremos a instruo abaixo:
float termo1=2.0, resultado; int termo2=3; resultado = termo1*termo2;
Para executar a instruo de atribuio, o valor de termo2 temporariamente convertido para float e o valor de termo2 no alterado. A hierarquia de converso segue a sequncia: double, float, long, int, short. Se um float convertido para int a parte fracionria perdida sem arredondamento, vejamos o exemplo:
float termo1=2.9, termo2=7.8; int resultado; resultado = termo1*termo2;
Esse operao teria como resultado 22,62 se resultado fosse do tipo float ou double, mas como uma varivel do tipo int a parte fracionria perdida e resultado receber o valor 22 aps a instruo. Em algumas instrues o resultado normal indesejvel e nesse caso os dados devem ser convertidos com o operador cast, que modela o tipo de dado da melhor maneira para a aplicao:
float termo1=5.7, resultado; int termo2=3, termo3=4; resultado = termo1 + termo2/termo3;
Depois dessa instuo, o valor de resultado 5,7. Isso estranho, j que os dados inteiros no exerceram nenhuma influncia. Isso ocorreu porque aps a diviso termo2/termo3 o resultado deveria ser 0,75 mas como os dois operandos so inteiros a parte fracionria desprezada e o resultado da diviso 0. Para corrigir esse problema, C++ possui o operador de modelamento de dados (cast). Usando o operador cast em um dos operandos inteiros, o resultado seria 4,275:
resultado = termo1 + termo2/(float)termo3;
Quando o operador cast aplicado em termo3, a diviso passa a considerar todos os dados como float, conforme a hierarquia de converso, por isso no necessrio modelar os dois operandos da operao.
14
Linguagem de Programao C++ Classes de Armazenamento
Classes de armazenamento
Os dados em C++ podem ter seu armazenamento padro modificado, e isso ter efeitos na visibilidade (escopo) da varivel dentro do arquivo e dentro do programa (se o programa conter mais de um arquivo). Um dado declarado fora de qualquer funo um dado de escopo global, porm se ele for declarado dentro de um bloco de cdigo ele ter escopo local. As declaraes de dados pode ser de nvel interno ou externo. As classes possveis em declaraes de nvel interno so auto (padro) static e register. Um dado auto ou static existe enquanto o programa estiver dentro do bloco onde est declarado, mas se for static a cada chamada funo ele retm o ltimo valor e deve ser iniciado com algum valor, ou o compilador presumir o valor zero. Se um dado declarado com classe register o compilador tentar armazenar esse dado em um registrador da CPU ou otimiz-lo. Devemos ter cuidado: register uma solicitao e no uma ordem, pois nem sempre ser possvel armazenar dado em um registrador. Em declaraes de nvel externo, as classes podem ser somente extern ou static: extern refere-se a um dado declarado em outro arquivo, e pode ser declarado apenas uma vez em um dos arquivos; dados static podem ser declarados em mais de um arquivo, j que static limita o escopo no arquivo onde est declarado. Uma funo tambm pode ter classe de armazenamento modificada: funes static so visveis apenas dentro do arquivo onde est declarada e funes extern so visveis em todos os arquivos que formam o programa. Funes sem classe de armazenamento so extern por padro Abaixo um exemplo de declarao de de um dado com declaraes de nvel externo (para rodar, abra o projeto proj01.prj no Turbo C++):
// Ilustrando o uso de classes de armazenamento static e extern // Arquivo PROG004.CPP // Curso de Linguagem de Programao C++ PROG004.CPP - Silvio Sabino #include<iostream.h> int a=0; static int b; extern void modifica(void); // declarao de funo para acess-la em outro arquivo void main(void){ cout << "\nO valor de a : " << a; modifica(); cout << "\n\nE o de B em PROG004.CPP : " << b; } // Ilustrando o uso de classes de armazenamento static e extern // Arquivo PROG005.CPP // Curso de Linguagem de Programao C++ PROG005.CPP - Silvio Sabino #include<iostream.h> extern int a; static int b=2; void modifica(void){ a=a+1; cout << "\n\nO valor de a mudou para: " << a; cout << "\nE o de B em PROG005.CPP : " << b; }
15
Linguagem de Programao C++ Operadores
Matrizes
Qualquer tipo de dado em C e C++ pode ser organizados em arranjos (array) contguos na memria RAM. Esses arranjos so chamados matrizes e tm grande importncia na programao. As matrizes podem ter uma ou mais dimenses, e quando possuem uma dimenso podem ser denominadas de vetores. A declarao de uma matriz de 5 inteiros de nome matriz seria:
int matriz[5];
Para uma matriz bidimensional em que cada dimenso possui 5 elementos:

int matriz[5][5];
O n de elementos de uma matriz pode ser omitido na declarao, mas se a matriz no for iniciada o seu tamanho ser presumido como 0 pelo compilador. Para declarar uma matriz iniciando-a a sintaxe :
int matriz[]={0,1,2,3,4,5,6};
No caso de matrizes de mais de uma dimenso, somente a dimenso mais direita pode ficar sem o n de itens:
int matriz[5][]={{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15},{16,17,18,19}};
No caso de matrizes de caracteres (em Pascal, o tipo string padro, o que no ocorre com C e C++),a inicializao pode ser feita como mostrada acima ou de forma mais direta:
char matriz[]= "essa uma matriz de caracteres";
No caso de mais de uma dimenso:

char matriz[3][]={"primeiro item","segundo item","terceiro item";};
Nesse caso, o compilador criar todos os itens com o tamanho do maior item. Poderemos usar as matrizes com todas as possibilidades que elas oferecem quando estudarmos os ponteiros, um assunto de extrema importncia em C e C++ que um dos motivos da escolha delas para implementar sistemas operacionais.
16
Operadores
C++ possui alguns operadores que no so encontrados em outras linguagens de programao, como operadores bit a bit, de atribuio composta, incremento e decremento e operador vrgula. Os tipos de operadores C++ so:
Operadores bit a bit

Tratam os dados como sequncias de bit individuais. So & (AND), | (OR), ^ (XOR), ~ (complemento de um). O programa a seguir ilustra os efeitos dos operadores bit a bit:
// Ilustrando os efeitos dos operadores bit a bit // Curso de Linguagem de Programao C++ PROG006.CPP - Silvio Sabino #include<iostream.h> unsigned int zeros=0; unsigned int uns=255; unsigned int medio=127; void main(void){ cout << "\n\n 0 em binrio cout << "\n127 em binrio cout << "\n255 em binrio cout << "\n0 & 255 = " << cout << "\n0 | 255 = " << cout << "\n0 ^ 255 = " << cout << "\n~0 = " << cout << "\n0 & 127 = " << cout << "\n0 | 127 = " << cout << "\n0 ^ 127 = " << cout << "\n~127 = " << cout << "\n255 & 127 = " << cout << "\n255 | 127 = " << cout << "\n255 ^ 127 = " << cout << "\n~255 = " << } 0000000000000000"; 0000000001111111"; 0000000011111111\n"; (zeros & uns) << " 0000000000000000"; (zeros | uns) << " 0000000011111111"; (zeros ^ uns) << " 0000000011111111"; (~zeros) << " 1111111111111111"; (zeros & medio) << " 0000000000000000"; (zeros | medio) << " 0000000001111111"; (zeros ^ medio) << " 0000000001111111"; (~medio) << " 1111111110000000"; (uns & medio) << " 0000000001111111"; (uns | medio) << " 0000000011111111"; (uns ^ medio) << " 0000000010000000"; (~uns) << " 1111111100000000";
Deslocamento
Tambm conhecidos como rotao de bits. Esses operadores, bem como os operadores bit a bit, so bastante utilizados em programao de sistemas, por manipularem diretamente os bits dos dados. O operador deslocamento esquerda << move todos os bits uma posio para a esquerda, e o deslocamento direita >>, move todos os bits para a direita. Nos dois casos, os bits de um extremo perdido e o do outro extremo torna-se zero. O programa a seguir mostra como funcionam os operadores de deslocamento de bits:
// Ilustrando os efeitos dos operadores bit a bit // Curso de Linguagem de Programao C++ PROG007.CPP - Silvio Sabino #include<iostream.h> unsigned int valor1=7; unsigned int valor2=64512; void main (void){
17

cout cout cout cout cout cout } << << << << << << "\n\n 7 em binrio 0000000000000111"; "\n64512 em binrio 1111110000000000\n"; "\n 7<<1 = " << (valor1<<1) << " 0000000000001110"; "\n 7<<2 = " << (valor1<<2) << " 0000000000011100"; "\n64512>>1 = " << (valor2>>1) << " 0111111000000000"; "\n64512>>2 = " << (valor2>>2) << " 0011111100000000";
Incremento e decremento
Somar ou subtrair 1 de um nmero to comum em programao que C++ possui operadores especiais para essas aes: ++ (incremento) e (decremento). Eles s podem ser utilizados por dados variveis e a sua sintaxe pode ser observada no programa abaixo:
// Ilustrando os efeitos dos operadores bit a bit // Curso de Linguagem de Programao C++ PROG008.CPP - Silvio Sabino #include<iostream.h> #include<conio.h> int numero=10; void main(void){ clrscr(); cout << "\nnumero cout << "\nnumero cout << "\nnumero cout << "\nnumero }
incrementado: novamente incrementado: decrementado: novamente decrementado:
" " " "
<< << << <<
++numero; numero++; --numero; numero--;
J que numero foi iniciado com valor 10 e foi incrementado 2 vezes e depois decrementado 2 vezes, ento a princpio a sada deve ser:
numero numero numero numero incrementado: novamente incrementado: decrementado: novamente decrementado: 11 12 11 10
Mas a sada que ele apresenta outra. Execute o programa para verificar e veja que o resultado diferente. Isso acontece porque a posio dos operadores ++ e influi no resultado, pois altera a ordem de execuo da instruo. Quando escrevemos:
cout << "\nnumero incrementado: " << ++numero;
A ordem de execuo : primeiro a varivel numero incrementada e depois a sentena impressa por cout. Enquanto que na linha seguinte:
cout << "\nnumero novamente incrementado: " << numero++;
A ordem : primeiro a sentena impressa por cout e depois a varivel numero incrementada O mesmo ocorre com decremento.
18
Aritmticos
Os operadores para operaes aritmticas em C++ so: + (adio), - (subtrao), * (multiplicao), / (diviso) e % (mdulo). O operador mdulo retorna o resto de uma diviso entre dois inteiros.
Atribuio simples e compostos

Diferente de outras linguagens, C++ possui um operador de atribuio ao invs de uma instruo de atribuio. Isso torna-se claro na instruo abaixo, que no seria possvel em outras linguagens:
valor1 = valor2 = valor3 = 2;
Ou seja: valor3 recebe o valor 2 e a operao retorna o valor contido em valor3, que atribudo varivel valor2, e a perao retorna o valor contido em valor2 e finalmente valor1 recebe 2. C++ possui ainda um conjunto de operadores de atribuio compostos que permitem que o cdigo seja escrito de forma mais concisa sem perder a clareza. As instrues abaixo so equivalentes:
valor = valor + 5; valor + = 5;
Outras operaes que podem utilizar esses operadores so as demais peraes aritmticas, deslocamento de bits e bit a bit, gerando os seguintes operadores: +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=.
Relacionais e lgicos
Os operadores relacionais C++ sempre estabelecem uma relao entre os valores dos operandos. Eles retornam 0 se o teste for falso e 1 se for verdadeiro. Os operadores relacionais C e C++ so: == (igual, note que ele diferente do operador = de atribuio), != (diferente), > (maior), < (menor), >= (maior ou igual), <= (menor ou igual). Os operadores lgicos C e C++ retornam resultados de acordo com a relao lgica de seus argumentos: && (AND), || (OR), ! (NOT). O operador && retornar 1 quando os dois argumentos forem verdadeiros, || retornar 1 quando pelo menos 1 argumento for verdadeiro e ! inverte o valor que seria retornado. O programa a seguir mostra os resultados de teste relacionais e lgicos de acordo com a entrada do usurio:
// Ilustrando os resultados dos operadores relacionais e lgicos // Curso de Linguagem de Programao C++ PROG009.CPP - Silvio Sabino #include<iostream.h> void main(void){ float num1, num2; cout cin cout cin cout cout cout cout cout cout << >> << >> << << << << << << "\nInforme o primeiro valor real: "; num1; "\nInforme o segundo valor real: "; num2; "\n\nResultado de "<<num1<<" == "<<num2<<" -> "\nResultado de "<<num1<<" != "<<num2<<" -> " "\nResultado de "<<num1<<" > "<<num2<<" -> " "\nResultado de "<<num1<<" < "<<num2<<" -> " "\nResultado de "<<num1<<" >= "<<num2<<" -> " "\nResultado de "<<num1<<" <= "<<num2<<" -> " " <<(num1==num2); <<(num1!=num2); <<(num1>num2); <<(num1<num2); <<(num1>=num2); <<(num1<=num2);
19

cout << "\nResultado de "<<num1<<" && "<<num2<<" -> " <<(num1&&num2); cout << "\nResultado de "<<num1<<" || "<<num2<<" -> " <<(num1||num2); }
Operador condicional ternrio

Esse operador torna o cdigo compacto por envolver um deciso com pouco cdigo. Sua sintaxe :
condio ? expresso_verdadeira : expresso_falsa ;
A condio genrica na instruo acima um teste, que pode envolver operadores condicionais e lgicos:
// Ilustrando os resultados dos operadores relacionais e lgicos // Curso de Linguagem de Programao C++ PROG010.CPP - Silvio Sabino #include<iostream.h> int a, b, c; void main(void){ cout << "\n\nInforme o primeiro valor: "; cin >>a; cout << "Informe o segundo valor: "; cin >>b; cout << "Informe o terceiro valor: "; cin >>c; cout << "o "<<((a>=b && a>=c)?"1o.":(b>=c)?"2o.":"3o.")<<"no. maior"; }
Operador vrgula
O operador vrgula permite que duas expresses coexistam na mesma linha onde normalmente somente uma seria premitida. Seu uso ser evidenciado quando tratarmos de estruturas de controle de fluxo.
Resoluo de escopo
C++ permite que uma varivel local possua o mesmo nome de uma global, bastando que seja utilizado o operador resoluo de escopo ::. No trecho abaixo as h duas variveis teste:
int teste; ... void funcao(int teste){ ::teste=teste; }
Dentro da funo funcao, a varivel global recebeu o valor da varivel local por meio do operador ::.
Assim como nas outras linguagens, os operadores C++ obedecem a nveis de precedncia que determinam a ordem que o compilador avaliar os operadores. Efeitos colaterais pode surgir quando os operadores so colocados de forma confusa. As instrues abaixo podem causar efeitos colaterais:
valor = 2; resultado = (valor = 4) + valor;
Existem duas formas de avaliar a expresso: valor recebe 4 e em seguida resultado recebe 8 (4+4); ou valor usado como 2 e logo depois recebe 4, e resultado recebe 6.
20
A tabela abaixo relaciona os operadores C++ por ordem de precedncia, sendo que alguns ainda no foram descritos. Operadores da mesma categoria tem a mesma precedncia:
Categoria Precedncia mais alta Descrio Chamada de funo ndice de matriz Referncia indireta de estruturas Resoluo de escopo Referncia direta de estrutura NOT Complemento de 1 Sinal positivo Sinal Negativo Incremento Decremento Endereo Referncia indireta Modelamento (cast) Tamanho do operando Alocao dinmica Dealocao dinmica Multiplicao Diviso Mdulo Referncia indireta membro de estrutura Referncia indireta membro de estrutura Adio Subtrao Deslocamento esquerda Menor que Menor ou igual a Maior que Menor ou igual a Igual Diferente (no igual) AND bit a bit XOR bit a bit OR bit a bit AND lgico OR lgico Condicional ternrio Atribuio Atribuies compostas Vrgula Operador () [] -> :: . ! ~ + ++ -& * (tipo) sizeof new delete * / % .* ->* + << << <= > >= == != & ^ | && || ?: = *=, /=, %=, +=, -=, &=, ^=, |=, <<=, >>= ,
Unrios
Multiplicativos
Acesso a membros Aditivos Deslocamento Relacionais
Igualdade
Atribuio
21
Linguagem de Programao C++ Controle de fluxo
Controle de fluxo
Para que possamos escrever programas C++ mais elaborados, necessrio dominar as estruturas de controle de execuo de instrues, que so, basicamente, as instrues condicionais e laos. Quase todos os programas que escrevemos at o momento seguiram sempre uma sequncia definida e o programador no interferiu em nenhum momento para que o programa tomasse decises. A exceo foi o uso do operador condicional ternrio. Quando feito o controle de fluxo em um programa, algumas instrues podem no ser executadas em nenhum momento dependendo dos critrios adotados para a deciso.
if
Esse instruo executa condicionalmente um bloco de cdigo. Um bloco de cdigo com apenas uma instruo no precisa ser delimitado com chaves { }, mas deve ser delimitado se houver mais de uma. A sintaxe genrica da instruo if :
if(expresso de teste) ao;
Caso exista mais de uma instruo devem ser usadas as chaves:

if(expresso de teste){ instruo1; instruo2; ... }
O programa abaixo exemplifica o uso da instruo if:

//Ilustrando o uso da instruo if // Curso de Linguagem de Programao C++ PROG011.CPP - Silvio Sabino #include<iostream.h> void main(void){ int valor_teste; cout << "\nDigite um valor inteiro: "; cin >> valor_teste; if(valor_teste==2){ cout << "\nFoi digitado o valor 2."; return; } cout << "\nFoi digitado um valor diferente de 2."; }
Nesse exemplo, se o usurio digitar o valor 2, o teste valor_teste==2 retorna 1 e a instruo if direciona o fluxo para dentro do bloco, aparecendo a mensagem Foi digitado o valor 2. e o programa retorna para o processo anterior com a instruo return. Caso contrrio o programa segue com a instruo aps o bloco.
22
if-else
Com essa instruo o programa pode tomar duas direes baseado em um teste. A sintaxe geral seria:
if(expresso de teste){ instruo1; instruo2; ... } else{ instruo1; instruo2; ... }
As instrues dentro do bloco else somente sero executadas quando o teste for falso (retornar 0).
switch
Quando desejvel testar uma varivel em relao a vrios valores, improdutivo montarmos sequncias de instrues if. Nesses casos aconselhvel utilizar a instruo switch. A sintaxe geral :
switch (expresso){ case constante_1: instrues; break; case constante_2: instrues; break; ... case constante_n: instrues; break; default: instrues; }
Devemos observar as peculiaridades da instruo switch. Quando o programa encontra a constante que corresponde ao valor da expresso, ele executa as instrues abaixo do case at que seja encontrada uma instruo break ou outra instruo de controle que provoque um devio na odem normal do programa.
for
uma das estruturas de lao mais potentes em muitas linguagens de programao, mas em C e C++ o lao for ultrapassa os limites normais de flexibilidade. Sua sintaxe geral :
for(inicializao;expresso de teste;incremento){ instruo1; instruo2; ... }
O lao for deve ser usado preferencialmente quando o nmero de iteraes conhecido. O exemplo abaixo mostra o uso do lao for e da instruo switch:
23

//Ilustrando o uso do lao for e da instruo switch // Curso de Linguagem de Programao C++ PROG012.CPP - Silvio Sabino #include<iostream.h> void main(void){ // corpo do lao for, ateno s declaraes // de variveis dentro da inicializao. // O programa executar 5 vezes as instrues dentro do bloco for(register int i = 0; i < 5;i ++){ int valor; cout << "\nDigite um valor inteiro: "; cin >> valor; // a instruo switch testar o valor de "valor" e // direcionar o programa para o case certo switch(valor){ case 1: cout << "\n\nVoc digitou o valor 1"; break; case 2: cout << "\n\nVoc digitou o valor 2"; break; case 3: cout << "\n\nVoc digitou o valor 3"; break; default: cout << "\n\nVoc digitou um valor diferente de 1,2 ou 3"; } } }
while
Quando no podemos prever o nmero de iteraes necessrias recomendado o uso do lao while:
while(expresso de teste){ instruo1; instruo2; ... }
Vamos reescrever o exemplo anterior utilizando o lao while:

// Ilustrando o uso do lao while e da instruo switch // Curso de Linguagem de Programao C++ PROG013.CPP - Silvio Sabino #include<iostream.h> void main(void){ // iniciando a varivel com um valor diferente de 0 para // evitar efeito colateral no lao while int valor=1; // se o valor de "valor" for 0, o teste retorna 0 e o lao termina while(valor){ cout << "\nDigite um valor inteiro (0 para sair): "; cin >> valor; switch(valor){ case 1: cout << "\nVoc digitou o valor 1"; break; case 2: cout << "\nVoc digitou o valor 2";
24

break; case 3: cout << "\nVoc digitou o valor 3"; break; default: cout << "\nVoc digitou um valor diferente de 1,2 ou 3"; } } }
do-while
A principal direfena entre esse instru e while que as aes dentro do bloco sempre sero executadas pelo menos uma vez:
do{ instruo1; instruo2; ... }while(expresso de teste);
break e continue
Dentro de laos, a instruo break provoca a sada imediata do lao, e a instruo continue faz o programa saltar imediatamente para a avaliao da expresso de teste. O uso comum de break na instruo switch, e continue raramente usado.
return
Provoca a sada imediata de uma funo para o processo anterior. Se a mesma for de tipo diferente de void essa instruo deve vir acompanhada de um valor de retorno, caso contrrio o compilador emitir um aviso que no impede a execuo do programa. Se a funo for main() o programa terminar.
exit( ) e atexit( )
A funo exit( ) provoca a sada imediata do programa e pede um argumento inteiro que ser o cdigo de erro para o sistema operacional, e atexit( ) faz com que uma funo seja chamada imediatamente antes de terminar o programa. Essa funo pede um ponteiro de funo com argumento.
goto
uma instruo que desvia incondicionalmente o programa para um rtulo. Sua sintaxe geral :
goto rotulo; ... rotulo: instruo;
Seu uso condenvel por estar fora da filosofia da programao estruturada, mas foi mantido na transio de C para C++ porque em algumas situaes seu uso vantajoso. Exemplo genrico:
... for(...){ for(...){ for(...){ for(...){ ...
25

if(...)goto sair; } } } } sair: ...
Nesse esquema de laos profundamente aninhados, no importam os testes dos laos externos ao for mais interno, porque goto desvia incondicionalmente o fluxo para o rtulo especificado. A nica restrio que o rtulo deve estar dentro da mesma funo da instruo goto.
Laos infinitos
Se a expresso de teste de um lao for vazia ou se as variveis envolvidas no sofrerem modificao dentro do lao, deve existir alguma instruo para que o programa saia do lao por meio de break, return, goto ou pelas funo exit( ), caso contrrio o lao nunca terminar. Os laos infinitos podem ser usados quando o programa ou o lao termina mediante um evento produzido pelo usurio ou alguma entrada de valor especfica. O exemplo anterior pode ser reescrito novamente utilizando-se um lao for(poderia ser while ou do-while, mas a expresso de teste no seria vazia) infinito:
// Ilustrando o uso do lao infinito // Curso de Linguagem de Programao C++ PROG014.CPP - Silvio Sabino #include<iostream.h> void main(void){ // utlizando um lao for infinito // nota-se que os sinais de ponto-e-vrgula so mantidos for(;;){ int valor; cout << "\nDigite um valor inteiro (0 para sair): "; cin >> valor; switch(valor){ case 0: return; case 1: cout << "\nVoc digitou o valor 1"; break; case 2: cout << "\nVoc digitou o valor 2"; break; case 3: cout << "\nVoc digitou o valor 3"; break; default: cout << "\nVoc digitou um valor diferente de 1,2 ou 3"; } } }
26
Linguagem de Programao C++ Ponteiros
Ponteiros
Ponteiros so variveis dinmicas que guardam endereos de outra variveis. A declarao de ponteiros feita com o operador de referncia indireta *:
tipo *identificador;
Onde tipo o tipo apontado pelo ponteiro. Para atribuio, podemos utilizar o operador endereo &:
tipo nome; tipo *apontador = &nome;
O ponteiro apontador armazenar o endereo da varivel nome, ou em outras palavras, apontar para ela. Ponteiros podem apontar para ponteiros, aumentando o nvel de referncia indireta, que limitado apenas pela necessidade. Os ponteiros podem ser constantes ou variveis. Ponteiros constantes so as matrizes ou ponteiros que tenham classe de armazenamento const. O nome da matriz representa o endereo do 1 item, ou seja, se array[50] uma matriz, as expresses &array[0] ou array so equivalentes. Para declarar um ponteiro de nvel(ordem) maior, basta aumentarmos o n de operadores de referncia indireta:
int **p, *****p1; //p de segunda ordem e p1 de quinta ordem
Se o operador referncia indireta for utilizado em instrues durante o programa, ele permitir o acesso varivel apontada pelo ponteiro. O programa a seguir mostra como isso ocorre:
// Funcionamento de ponteiros // Curso de Linguagem de Programao C++ PROG015.CPP - Silvio Sabino #include<iostream.h> void main(void){ int valor, *ponteiro = &valor; cout << "\nDigite um valor inteiro: "; cin >> valor; cout << "\nO valor digitado foi: "<< *ponteiro; *ponteiro=10; cout << "\nO valor foi modificado para: " << valor; }
Aritmtica
Ponteiros podem ser incrementados, decrementados, adicionados ou subtrados de constantes, e a unidade vlida sempre o tamanho do tipo de dado apontado: depois e incrementar um ponteiro de nome pointer que aponta para o tipo float com a instruo pointer++, o seu valor ser o endereo sizeof(float) acima do anterior. E depois de pointer = pointer+3, o novo valor ser 3*sizeof(float) acima do anterior. Para obter o endereo do elemento n de um ponteiro de nome array, que aponta para uma matriz, podemos utilizar notao de matriz ou de ponteiro se o ponteiro for varivel: &array[n] ou array+n. E para acessar o valor desse elemento podemos escrever: array[n] ou *(array+n). Em qualquer caso, a notao de ponteiro executa mais rapidamente do que a de matriz.
27
Modificadores de ponteiros
A memria do processador 8088 segmentada, e cada segmento tem 64 kbytes (65535 bytes). Todo endereamento feito com dois nmeros denominados segmento e deslocamento (offset). Existem 4 segmentos em um programa .EXE: cdigo, dados, pilha e extra. Se nada for informado ao compilador, ele tentar sempre alocar espao dentro do segmento de dados, mas podemos modificar ponteiros para que sejam armazenados em outros locais com o uso de modificadores: near: fora o ponteiro a apontar somente para o deslocamento. Ocupam 2 bytes na memria; far: fora o ponteiro a contar sempre o valor do segmento e do deslocamento. Alm e tornar o acesso mais lento, ponteiros far ocupam 4 bytes; huge: semelhante ao ponteiro far, mas quando incrementado, o segmento pode ser alterado. Isso nunca ocorre com um ponteiro far. Para apontar para qualquer tipo de dado, um ponteiro pode ser declarado como void * e ser moldado para qualquer tipo de acordo com a necessidade. Um ponteiro void simplesmente aponta para uma endereo de memria sem estar associado a qualquer tipo de dado. Abaixo um programa para exemplificar:
// Funcionamento de ponteiros void // Curso de Linguagem de Programao C++ PROG016.CPP - Silvio Sabino #include<iostream.h> int inteiro; float flutuante; void *pointer=&inteiro; void main(void){ *(int *)pointer = 2; pointer = &flutuante; *(float *)pointer = 3.0; cout << "\nValor int: " << inteiro << "\nValor float: " << flutuante; }
Strings
C++ no possui cadeias de caracteres como tipo de dado padro. Todas as cadeias de caracteres so tratadas como ponteiros para o tipo char. O programador deve ter muito cuidado com strings, porque um acesso fora da rea reservada ou alocada no ser avisado pelo compilador e pode levar catstrofe: a rea invadida pode pertencer a outros dados, ao programa ou ao sistema operacional, no pior caso. Strings em C++ so sempre terminadas com o caractere nulo (NULL), portanto sempre devemos alocar espao para um elemento alm do tamanho da string.
Alocao dinmica de memria

Quando os programas tornam-se mais complexos, comum que o programador no possa prever quanta memria ser necessria para o programa, devendo alocar memria dinamicamente. Os operadores new e delete alocam e liberam memria, respectivamente. A sintaxe geral desses operadores :
tipo *ponteiro = new tipo[num_itens]; delete(ponteiro);
28
Quando o operador new invocado pelo programa, este solicita ao sistema operacional um bloco de tamanho igual a nm_itens*sizeof(tipo). Se no houver memria disponvel o ponteiro recebe o valor 0(NULL). Devemos testar se a alocao foi feita com sucesso, porque se tentarmos usar um ponteiro que aponta para NULL ou com valor desconhecido podemos causar uma catstrofe: os outros dados, o cdigo do programa ou de outros programas pode ser corrompido e o sistema pode cair, travando a mquina. O programa a seguir mostra o uso dos operadores new e delete:
// Operadores new e delete // Curso de Linguagem de Programao C++ PROG017.CPP - Silvio Sabino #include<iostream.h> void main(void){ int *valor, itens; cout << "\nDigite o nmero de itens: "; cin >>itens; if(!(valor=new int[itens])) cout << "\nMemria insuficiente!"; else{ cout << "\nAlocao dinmica efetuda com suceso!"; delete(valor); } }
Referncia
possvel simplificar a notaco de ponteiros usando o tipo referncia. Assim, nas chamadas de funes podemos utilizar os nomes das variveis e passar o endereo para a funo. O cabealho abaixo possui um argumento que passado por referncia:
int funcao(char *a, int &ref){...
Quando o programa chamar essa funo, a varivel referncia ref equivaler ao argumento passado para a funo, porque tero o mesmo endereo. O uso do tipo referncia C++ indispensvel quando no podem ser utilizados ponteiros e tampouco possvel o uso de variveis comuns. Em C, a nica forma de alterar o valor do parmetro original era por meio de ponteiros.
Membros de ponteiros de estruturas

Para referenciarmos membros de ponteiros que apontam para estruturas de dados, a referncia indireta realizada com os operadores -> e ->*. Por exemplo: seja *pont um ponteiro para uma struct casa, que possui uma instncia denominada sala que e um ponteiro do tipo comodo.
struct casa *pont = new casa; pont->casa = new comodo; pont->*casa = 20;
A instncia casa referenciada pelo operador-> porque a estrutura externa (pont) um ponteiro, e o contedo apontado por casa acessado com o operador ->*.
29
Linguagem de Programao C++ Funes
Funes
Conforme o conceitos da programao estruturada, todas as aes que so usadas rotineiramente devem ser modularizadas para economizar tempo e facilitar o entendimento. Cada mdulo ou sub-rotina em C++ um funo, como tambm foi explicado no incio. A sintaxe geral de uma funo C++ :
tipo_de_retorno identificador(tipo_1 argum_1, tipo_2 argum_2, ..., tipo_n argum_n){ instruo1; instruo2; ... }
O tipo de retorno o tipo da funo, ou seja, se ela retorna um tipo int dizemos que ela do tipo int. Para retornar um valor, basta que uma expresso constante ou varivel seja argumento de return.
Argumentos
Uma funo pode ter um n de argumentos limitado apenas pela necessidade e capacidade da mquina. Quando um argumento passado para uma funo, ele pode ser passado de duas formas: Passagem por valor: quando passamos o valor dos dados. Os valores das variveis originais da funo chamadora no so alterados porque apenas uma cpia de seus valores armazenada na pilha para serem utilizadas na funo chamada. Funes chamadas por valor s podem retornar um valor; Passagem por referncia: nesse caso, so utilizados tipos referncia e os dados originais podem ser alterados pela funo. Por isso podemos dizer que funes chamadas por referncia podem retornar mais de um valor (o normal com return e os outros que foram modificados). Em qualquer caso, a chamada por referncia mais rpida, consumindo menos espao na pilha e menos instrues. Em C++ os argumentos podem possuir um valor padro, definido no cabealho da funo:
int minha_funcao(int a, char n, double d=0.0, int c=0){ instruo1; instruo2; ... }
Argumentos com valores padres s podem ser os ltimos da funo. Portanto o cabealho:
int minha_funcao(int a, char n, double d=0.0, int c...
invlido porque aps um argumento iniciado com valor padro segiu-se um argumento normal. A funo main() pode aceitar dois argumentos:
void main(int argc, char argv[]){...}
O argumento argc o n de argumentos na linha de comando e argv[] uma matriz de ponteiros para char contendo os argumentos da linha de comando (o primeiro o nome completo do programa). Podem existir funes com n varivel de argumentos utilizando as elipses (...):
void funcao(int arg1, int arg2, ...){...}
30
Ponteiros de funo
Em alguns casos, para que o cdigo torne-se funcional, aconselhvel referenciar uma funo indiretamente por um ponteiro. Apontar para uma funo conter o endereo do incio do seu cdigo, representado pelo nome da funo. O programa abaixo mostra como funciona a sintaxe de um ponteiro de funo:
// Ponteiros de funo // Curso de Linguagem de Programao C++ PROG018.CPP - Silvio Sabino #include<iostream.h> // declarando um ponteiro que aponta para uma funo do tipo void // sem nenhum argumento void (*ponteiro)(void); void funcao_1(void){ cout << "\nExecutando a funo 1!"; return; } void funcao_2(void){ cout << "\nExecutando a funo 2!"; return; } void main(void){ int resposta; do{ cout << "\nVoc deseja executar qual funo (1 ou 2)?"; cin >>resposta; }while(resposta!=1&&resposta!=2); ponteiro = resposta==1?funcao_1:funcao_2; ponteiro(); return; }
O uso de ponteiros de funo uma das portas para a programao avanada orientada por eventos, onde estruturas de dados genricas so criadas e os objetos so diferenciados pelas funes apontadas.
Modificadores de acesso
C++ pode interagir com as linguagens Pascal e Assembly. Para que uma funo possa ser utilizada por um programa escrito em Pascal, ela deve ser modificada com a palavra reservada pascal. Assim a ordem de empilhamento dos argumentos seguir o padro da linguagem Pascal: do primeiro para o ltimo (em C++ o inverso). Diversamente, para garantir que a ordem de empilhamento dos argumento siga o padro C++ deve-se utilizar cdecl. Assim como os dados referenciados por ponteiros, as funes tambm podem estar localizadas em segmentos de cdigo diferentes. Com o uso dos modificadores near e far o compilador pode forar uma chamada somente utilizando deslocamento (near) ou segmento e deslocamento (far). Chamadas distantes (far) tornam todo o processo mais lento.
31
inline
Algumas vezes vantajogo expandir em linha uma funo pequena. Isso acontece porque existe um cdigo mnimo para chamar a funo envolvendo pilha, argumentos e endereamento que pode ser de tamanho ou tempo de execuo maior do que a colocao do cdigo da funo diretamente no local. Para que o programador possa sugerir a expanso em linha, usamos a palavra reservada inline. A limitao que no podem haver laos na funo candidata para a expanso.
Recursividade
Muitos problemas possuem soluo recursiva ou recorrente, ou seja, a soluo chama a si prpria at que uma condio bsica seja satisfeita e ela comea a retornar. O fatorial de um nmero um exemplo clssico de aplicao de recursividade. Observe a funo fatorial recursiva:
long fatorial(int n){ return(n<2?1:n*fatorial(n-1)); }
Sem dvida, a recursividade torna o cdigo claro. No exemplo do fatorial, a funo chamar a si mesma at que o argumento n seja menor do que 2. Nesse ponto ela comea a retornar as chamadas acumuladas na pilha at a primeira. Para comparao, abaixo segue uma funo de forma iterativa para o mesmo fim:
long fatorial(int n){ long resultado=1; if(n>1)for(register int i=n;i<2;i--)resultado=resultado*i; return(resultado); }
Sobrecarga
C++ permite que mais de uma funo possua o mesmo nome, desde que sejam de tipos diferentes ou tenham argumentos diferentes. Isso ajuda o programador porque s haver um nome para a mesma tarefa, que poder aceitar diferentes tipos de argumentos. Destrutores no podem ser sobrecarregados. O programa abaixo calcula o cubo de um nmero e aceita um argumento int ou float:
// Ilustrando a sobrecarga de funo // Curso de Linguagem de Programao C++ PROG019.CPP - Silvio Sabino #include<iostream.h> int cubo(int n){ return (n*n*n); } float cubo(float n){ return (n*n*n); } void main(void){ int inteiro; float real; cout cin cout cin << "\nDigite um valor inteiro: "; >>inteiro; << "\nDigite um valor real: "; >>real;
32

cout << "\nO cubo do valor inteiro : " << cubo(inteiro); cout << "\nO cubo do valor real : " << cubo(real); return; }
Com exceo de ., .*, ::, ?:, os operadores em C++ so sobrecarregveis para desempenhar funes diferentes das originais. Uma sobrecarga que j conhecemos a dos operadores de deslocamente de bits << e >> que so utilizados com os fluxos de entrada e sada cin e cout, que correspondem a stdin e stdout em C. A sobrecarga de operador realizada pela palavra reservada operator, cuja sintaxe :
operator <smbolo> (argumentos) { instrues }
Operadores sobrecarregados podem ser membros de uma class:

nome_da_classe::operator <smbolo> (argumentos){ instrues }
A definio da sobrecarga deve ter parmetros de um tipo de class ou deve ser membro de uma class e a precedncia do operador no sofre alterao. O programa abaixo sobrecarrega o operador + para somar as partes real e imaginria de dois nmeros complexos e para concatenar duas strings. Ateno nos detalhes.
// Sobrecarga de operador e outras aplicaes // Curso de Linguagem de Programao C++ PROG020.CPP - Silvio Sabino #include<string.h> #include<iostream.h> // criando uma struct para representar nmeros complexos struct complex{ double real; // parte real double imag; // parte imaginria // construtor para a classe complex com argumento padro complex(double real, double imag=0){ this->real=real; this->imag=imag; } // construtor sobrecarregado sem argumentos complex(void){ real=0; imag=0; } }; // criando a classe string para ser utilizada como parmetro // de operator class string { // ponteiro para char manipulado pelo objeto // nenhuma outra parte do programa pode acessar diretamente // o contedo desse ponteiro char *str; //comprimento mximo permitido int n;
33
// tornando pblicas as funes do objeto para que o programa // possa invoc-las public: // atribuindo uma cadeia str // note como o argumento str diferenciado do ponteiro str que // faz parte do objeto usando-se o ponteiro this, pois as instncias // no so variveis globais e por isso :: no funciona nesse caso int setstr(char *str){ if(!this->str||n<strlen(str))return(1); strcpy(this->str,str); return(0); } //obtendo o contedo de str // o uso do ponteiro temp evita que o processo externo // obtenha o endereo de str, podendo obter apenas o // contedo apontado por ele char *getstr(void){ char *temp=new char[strlen(str)+1]; return(strcpy(temp,str)); } // sobrecarregando + para concatenar strings; char *string::operator+(string &str1){ char *temp=new char[strlen(str)+1]; strcpy(temp,str); return(strcat(temp,str1.getstr())); } // construtor da classe, que aloca memria // de acordo com o nmero de itens informado // pelo processo anterior string(int itens=0){ n=itens; str=n?new char[n]:NULL; } // liberando o espao alocado para o ponteiro str // e destruindo o objeto ~string(void){ if(str)delete(str); } }; // sobrecarregando o mesmo operador para somar as partes real // e imaginria de dois nmeros complexos complex operator+(complex n1, complex n2){ return(complex(n1.real+n2.real,n1.imag+n2.imag)); } // programa principal void main(void){ // declarando objetos de classe string string string1(11),string2(11),string3(22); // declarando estruturas do tipo complex complex c1(5,8), c2(2.4), c3; string1.setstr("string1"); string2.setstr(" + string2"); // utilizando a sobrecarga do operador + para concatenar as strings
34

string3.setstr(string1+string2); c3=c1+c2; cout << "\nresultado com *char : " << string3.getstr(); cout << "\nresultado com complex: " << c3.real << " " << c3.imag; }
Prottipos
Normalmente, uma funo apenas poder invocar outra se esta estiver escrita acima daquela:
int acima(void){ ... } ... int abaixo(void){ ... }
No fragmento acima, a funo abaixo pode chamar acima, mas no o contrrio. Para que isso seja possvel, deve ser declarado um prottipo da funo abaixo antes do cdigo de acima.
int abaixo(void);
Modelos
Muitas vezes uma funo pode executar o mesmo trabalho com tipos de dados diferentes, sem que isso altere as instrues que fariam parte da funo. Funes desse tipo devem ser modeladas. Para construir um modelo, usamos as palavras reservadas template e class:
template <class tipo> nome_da_funcao(argumentos){ ... }
A modelo do programa seguinte aloca espao na memria para n elementos de qualquer tipo de dado conforme o argumento:
// Ilustrando o uso de modelos de funo e ponteiros de 2a ordem // Curso de Linguagem de Programao C++ PROG021.CPP - Silvio Sabino #include<iostream.h> // Implementando o modelo de funo que aloca memria e retorna NULL // se no existir espao disponvel template <class tipo> tipo* aloca(tipo **ponteiro, int n){ return(*ponteiro=new tipo[n]); } void main(void){ float *flutuante=NULL; int n; cout << "\nEscolha o nmero de elementos: "; cin >>n; cout << (aloca(&flutuante,n)?"Alocao executada":"Espao insuficiente!"); if(flutuante)delete(flutuante); return; }
O programa apresenta um detalhe interessante alm do uso do modelo de funo: para que o ponteiro flutuante seja alterado pela funo modelada aloca, passado o seu endereo, ou seja, um ponteiro de ponteiro (ponteiro de 2a ordem), exemplificando o seu uso.
35
Linguagem de Programao C++ Diretivas do pr-processador
Diretivas do pr-processador
Em alguns casos, deve-se compilar condicionalmente um trecho de cdigo, incluir um arquivo ou trocar um texto por outro segundo definies prvias. Para tal, C++ possui vrias diretivas para modificar a compilao. As diretivas com suas sintaxes genricas so: #define <id1>[(id2,id3...)] <sentena>: define uma macro, que pode ser simplesmente uma expresso constante ou com argumentos:
#define maior(x,y) ((x)>(y)?(x):(y)) #define NULL 0L
Depois de uma diretiva #define o pr-processador substituir a primeira sentena pela segunda, respeitando os argumentos. Por exemplo: maior(3,5) ser substitdo por ((3)>(5)?(3):(5)). O efeito de uma macro com argumento semelhante ao modelo abaixo, mas sempre ser expandida em linha:
template <class tipo> inline tipo maior (tipo x, tipo y){ return(x>y?x:y); }
#if <expresso>, #ifdef <nome>, #ifndef <nome>: instrui o compilador a considerar ou no um trecho do cdigo-fonte de acordo com uma diretiva #define anterior. Isso especialmente til para manter a compatibilidade com C e outras linguagens com C++. #ifdef equivale e #if defined(expresso) e #ifndef significa #if !defined(expresso). A palavra defined s pode ser utilizada com estas diretivas. #elif <expresso>:complemento de #if, #ifdef, #ifndef, instrui o compilador a compilar o cdigo subseqente se a condio destas diretivas for falsa e se a condio de #elif for verdadeira. #else: semelhante #elif, porm no inclui mais uma condio. #endif: termina o bloco onde as diretivas #if, #ifdef, #ifndef, #elif e #else exercem sua influncia. #error <msg>: instrui o compilador e emitir uma mensagem de erro cujo texto msg. #include <arquivo>: inclui um arquivo no local de sua ocorrnia, a diretiva mais usada. #line <constante> <arquivo>: faz com que o compilador considere que o a prxima linha do arquivofonte atual seja constante e que seu nome seja nome. #pragma: informa o compilador sobre caractersticas especficas da aplicao. Os tipos so: #pragma inline: informa que o arquivo possui cdigo assembly; #pragma argused: impede a emisso do aviso Parameter parmetro is never used; #pragma exit <funcao> <prioridade>, #pragma startup <funcao> <prioridade>: fazem com que funcao() seja invocada antes e depois de main(), respectivamente, seguindo uma ordem de prioridade: funes com maior prioridade so executadas antes com startup e depois com exit; #pragma hdrfile: informa onde esto localizados os arquivos cabealho pr-compilados; #pragma hdrstop: informe o trmino dos arquivos cabealho candidatos pr-compilao; #pragma option [opes...]: inclui opes de linha de comando para o compilador; #pragma saveregs: garante que uma funo so modificar os valores dos registradores da CPU; #pragma warn [+xxx;-xxx;.xxx]:habilita/desabilita ou troca o estado de um aviso C++; #undef: cancela uma definio de macro anteriormente feita com #define;
36
Linguagem de Programao C++ Arquivos
Arquivos
C++ oferece uma biblioteca para funes de leitura e escrita em arquivos, operaes necessrias em muitas aplicaes. A linguagem no oferece nenhum meio natural de entrada e sada, mas todas as necessidades foram embutidas na linguagem atravs das bibliotecas. As aes normais no trabalho com arquivos so: gravar, ler, testar o fim do arquivo, obter o tamanho do arquivo e percorrer o arquivo. Um arquivo pode ser tratado em alto ou baixo nvel. Em alto nvel as operaes so intermediadas por armazenamento na memria (buffer), que acelera bastante o processo. Os dados so gravados em blocos, para diminuir os acessos ao disco, muito mais lento do que a memria. Arquivos em alto nvel so conhecidos como streams (fluxos), e so referenciados por um ponteiro para uma struct FILE. Essa estrutura de dados, bem como as funes que tratam streams, so definidas em STDIO.H. Em baixo nvel, C++ trata diretamente com os arquivos e no utiliza buffers. Os arquivos so referenciados por nmeros inteiros denominados manipuladores de arquivos, tratando diretamente com o sistema operacional. No programa abaixo, h uma estrutura de dados representando um colaborador de uma empresa e o programa manipula os dados lendo e escrevendo os dados em um arquivo. Ateno ao menu apresentando opes ao usurio, implementado em uma funo.
// Arquivos em C++ // Curso de Linguagem de Programao C++ PROG022.CPP - Silvio Sabino // inserindo arquivos cabealho necessrios #include<iostream.h> #include<stdio.h> #include<conio.h> #include<ctype.h> #include<string.h> // definindo constantes para facilitar o entendimento #define ALTERA 0 #define EXCLUI 1 #define LISTA 2 FILE *arq; //arquivo onde sero armazenados os dados size_t tamanho; //varivel que guardar o tamanho da estrutura "colaborador" // estrutura para referenciar o registro struct colaborador{ int reg; // registro na empresa char nome[41]; // nome do colaborador char CPF[12]; // cadastro de pessoa fsica(CPF) }; // testa fim de arquivo e leitura int teste_fluxo(colaborador &empr,FILE *str){ return(!feof(str)&&fread(&empr,tamanho,1,str)==1); } // exibe os dados de um colaborador na tela void exibir(colaborador c){ cout <<c.reg<<" - "<<c.nome<<" - "<<c.CPF<<"\n"; } // testa abertura do arquivo int abrir(void){ //tenta abrir o arquivo para atualizao ou cria novo arquivo
37

if(!(arq=fopen("C:\\exemplo.txt","a+"))){ cout << "Erro no abrir arquivo. Pressione qualquer tecla p/ voltar"; getch(); return(1); } return(0); } // exibe um menu na tela para que o usurio realize a escolha char menu(void){ // varivel esttica para identificar a primeira chamada static char opcao=0; // testando se a primeira chamada ou o usurio encerrou a sesso if(opcao&&opcao!=54)fclose(arq); // limpando a tela clrscr(); // exibindo o menu cout << "\nPrograma exemplo de manipulao de arquivos\n\n"; cout << "1) Inserir\n"; cout << "2) Consultar\n"; cout << "3) Alterar\n"; cout << "4) Excluir\n"; cout << "5) Listar\n"; cout << "6) Sair"; // esperando a opo do usurio. // o programa no ir adiante enquanto o usurio no efetuar // uma escolha vlida do{ gotoxy(1,10); cout << "Tecle a sua opo."; opcao=getch(); }while(opcao<49||opcao>54); // se o usurio no deseja encerrar a sesso, abre-se o arquivo // e se houver erro o usurio ser avisado, voltando para o menu if(opcao!=54&&abrir())return(-1); // retornando para main() return opcao; } // inserindo um colaborador void insere(void){ colaborador novo; // solicitando a entrada de dados para o usurio cout << "\nInforme o registro: "; cin >> novo.reg; cin.getline(novo.nome,40); cout << "\n\nInforme o nome: "; cin.getline(novo.nome,40); cout << "\nInforme o CPF: "; cin.getline(novo.CPF,11); // gravando os dados em arquivo
38

fwrite((void*)&novo,tamanho,1,arq); } // consultando os dados armazenados void consulta(void){ char opcao; //perguntando ao usurio qual o chave de consulta desejada //a instruo do-while somente terminar quando a resposta for vlida do{ gotoxy(1,12); cout << "Deseja consultar por nome, CFP ou registro (N/C/R)?"; opcao=toupper(getch()); }while(opcao!='N'&&opcao!='C'&&opcao!='R'); //solicitando agora a entrada do dado a ser consultado //observe o uso do operador ternrio ?: cout <<"\n\n"<<(opcao=='N'?"Nome: ":opcao=='C'?"CPF: ":"Registro: "); colaborador cons,temp; if(opcao=='R')cin >> cons.reg; else cin.getline(opcao=='N'?cons.nome:cons.CPF,opcao=='N'?40:11); cout <<"\n"; rewind(arq); //pesquisando o arquivo e exibindo os dados que satisfazem consulta while(teste_fluxo(temp,arq))if( (opcao=='N'&&!strcmp(cons.nome,temp.nome))|| (opcao=='C'&&!strcmp(cons.CPF,temp.CPF))|| (opcao=='R'&&cons.reg==temp.reg)){ exibir(temp); } //deixando o usurio decidir quando voltar ao menu cout <<"\nPressione qualquer tecla para voltar ao menu"; getch(); } //alterando, excluindo ou listando os dados gravados void modifica(int z=ALTERA){ int reg,opcao; colaborador temp; //como o registro nico para cada colaborador, as operaes de //alterao e excluso so direcionadas por esse campo if(z!=LISTA){ cout <<"\nInforme o no. do registro: "; cin >>reg; } else cout <<"\n\n"; //criando um arquivo temporrio para auxiliar as operaes de // alterao e excluso FILE *tmp=tmpfile(); // pesquisando o arquivo e efetuando a operao desejada while(teste_fluxo(temp,arq)){ // se foi pedida a listagem, ento todos os dados so exibidos if(z==LISTA)exibir(temp); //seno, executada a ao somente no colaborador informado
39

else if(temp.reg==reg){ if(z==ALTERA){ do{ gotoxy(1,11); cout <<"\n\nAlterar nome ou CPF (N/C)?"; opcao=toupper(getch()); }while(opcao!='N'&&opcao!='C'); // novamente o uso extensivo do operador ternrio ?: cout <<"\n"<<"Novo "<<(opcao=='N'?"nome: ":"CPF: "); cin.get(temp.CPF[11]); cin.getline(opcao=='N'?temp.nome:temp.CPF,opcao=='N'?40:11); <<"Registro "<<(z==ALTERA?"alterado. ":"excludo. "); } if(temp.reg!=reg||z==ALTERA)fwrite(&temp,tamanho,1,tmp); } //reescrevendo os dados reorganizados no arquivo de origem if(z!=LISTA){ fclose(arq); arq=fopen("C:\\Exemplo.txt","wb+"); rewind(tmp); while(teste_fluxo(temp,tmp))fwrite(&temp,tamanho,1,arq); } // se foi pedida a lista, ento somente impresso o caractere nova linha else cout <<"\n"; fclose(tmp); cout <<"Pressione qualquer tecla p/ voltar."; getch(); } // programa principal void main(void){ // obtendo o tamanho da estrutura colaborador // isto til porque economiza cdigo e chamadas de funo tamanho=sizeof(colaborador); // o programa fica esperando o usurio escolher a ao // e direciona a ao conforme e sua opo for(;;)switch(menu()){ case '1': insere(); break; case '2': consulta(); break; case '3': modifica(); break; case '4': modifica(EXCLUI); break; case '5': modifica(LISTA); case -1: break; case '6': return; } } // fim do programa } cout
40
Linguagem de Programao C++ Introduo ao modo grfico
Introduo ao modo grfico

Acessar o modo grfico significa mudar o modo de acesso ao vdeo. Em modo texto padro, a tela dividida em 80 colunas e 25 linhas e no modo grfico existem vrios tipos possveis dependendo do hardware. No programa abaixo, o usurio informa os coeficientes de uma funo do 2o grau (f(x) = ax2 + bx + c) e o programa desenha o grfico da funo.
// Introduo ao modo grfico - Funo do 2o. grau // Curso de Linguagem de Programao C++ PROG023.CPP - Silvio Sabino #include<graphics.h> #include<iostream.h> #include<conio.h> // parmetros e varivel da funo float *p, x; // retornando o valor da funoo do segundo grau float bhaskara(void){ return(p[0]*x*x+p[1]*x+p[2]); } // desenhando o grfico na tela em escala 10:1 // observar o uso de continue void plot(float (*funcao)(void)){ float y; for(x=-32;x<32;x+=0.0001){ if((y=funcao())>24||y<-24)continue; putpixel(x*10+320,y*10+240,15); } } void main(void){ //declarando um int register para uso nos laos register int i; float (*funcao)(void)=bhaskara; // para a funoo especfica p=new float[3]; // alocando espao para 3 parmetros da funoo clrscr();// limpando a tela //solicitando os dados para o usurio for(i=0;i<3;i++){ cout << "Digite o parmetro \""<<(!i?"A":i==1?"B":"C")<<"\": "; cin >> p[i]; } //iniciando o modo grfico int d=DETECT,m; initgraph(&d,&m,"C:\\ARQUIV~1\\TC\\BGI"); // especificando azul como cor de fundo azul e // cinza claro como cor da linha setbkcolor(1); setcolor(7); // desenhando os eixos na tela line(0,240,639,240); line(320,0,320,479); for(i=0;i<640;i+=10){
41
Linguagem de Programao C++ Introduo ao modo grfico

line(i,238,i,242); if(i<480)line(318,i,322,i); } plot(funcao); // chamando a funo que desenha o grafico getch(); // esperando o usuario pressionar um tecla closegraph(); // fechando o modo grafico }
No segundo exemplo, o programa desenho um boto e espera at que o usurio pressione uma tecla para ento sair do programa.
// Introduo ao modo grfico - Desenhando um boto // Curso de Linguagem de Programao C++ PROG024.CPP - Silvio Sabino #include<graphics.h> #include<conio.h> #include<dos.h> // funo que desenha o boto na tela void botao(int flag){ moveto(100,100); // movendo o cursor grfico para (100,100) setcolor(flag?15:8); linerel(80,0); linerel(0,-32); setcolor(flag?8:15); linerel(-80,0); linerel(0,32); // escrevendo um texto no boto for(register i=0;i<=flag;i++){ setcolor(!i&&flag?7:8); outtextxy(120+i,80+i,"teste"); } } // programa principal void main(void){ //iniciando o modo grfico int d=DETECT,m; initgraph(&d,&m,"C:\\ARQUIV~1\\TC\\BGI"); // especificando cinza claro como cor de fundo e chamando // a funcao que desenha o boto setbkcolor(7); botao(0); getch(); botao(1); // esperando 0,2 segundo para que seja percebido // o movimento do botao delay(200); closegraph();// fechando o modo grafico }
42
Linguagem de Programao C++ Palavras reservadas
Palavras reservadas
Todas as linguagens de programao possuem um conjunto de palavras reservadas que apenas devem ser utilizadas de acordo com a especificao original da linguagem, no podendo ser usadas como nome de funes ou variveis e podem, embora seja altamente desaconselhvel, ser definidas para outras atribuies com a diretiva #define. O resultado dessa acrobacia certamente ser um cataclisma. As palavras reservadas C++ so:
Asm Class Do Extern Friend Interrupt Pascal _saveregs Static Union
auto const double _export goto _loadds private _seg struct unsigned
break continue _ds far huge long protected short switch virtual
case _cs else _fastcall if near public signed template void
cdecl default enum float inline new register sizeof this volatile
char delete _es for int operator return _ss typedef while
43

C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

C

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagem de Programao

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Sumrio

Diretivas do pr-processador Introduo ao modo grfico Palavras reservadas

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Linguagens de Programao Histria de C

Linguagens de programao Histria de C

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Caractersticas da Linguagem C

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ A Linguagem C++

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Fundamentos de C++

Vamos analisar linha a linha o contedo desse programa:

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Fundamentos de C++

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Fundamentos de C++

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Tipos definidos e estruturas de dados

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Tipos definidos e estruturas de dados

Tipos definidos e estruturas de dados

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Tipos definidos e estruturas de dados

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Modificadores de dados

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Converses de dados

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Classes de Armazenamento

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

Para uma matriz bidimensional em que cada dimenso possui 5 elementos:

No caso de mais de uma dimenso:

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

Operadores bit a bit

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

incrementado: novamente incrementado: decrementado: novamente decrementado:

" " " "

<< << << <<

++numero; numero++; --numero; numero--;

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

Atribuio simples e compostos

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

Operador condicional ternrio

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Operadores

Acesso a membros Aditivos Deslocamento Relacionais

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Controle de fluxo

Caso exista mais de uma instruo devem ser usadas as chaves:

O programa abaixo exemplifica o uso da instruo if:

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Controle de fluxo

Silvio Sabino de Souza Junior sabino@cefetjunior.com.br

Linguagem de Programao C++ Controle de fluxo

Vamos reescrever o exemplo anterior utilizando o lao while: