Você está na página 1de 197
Curso básico de C++ DicasBCB http://www.dicasbcb.com.br

Curso básico de C++

DicasBCB

http://www.dicasbcb.com.br

Conteúdo

O

bê-a-bá da programação

5

Afinal, o quê é C++?

 

5

Um pouco de história

5

Conceitos

6

O

bit e o byte

12

Cuidados gerais

 

12

Documentar o trabalho

13

O

programa main()

15

Primeiro programa

15

Imprimindo dados nos componentes

28

Comentários

31

Tipos fundamentais

32

O

tipo inteiro

33

Os tipos ponto flutuante

 

36

O

tipo caracter

36

Modificadores de tipos

 

38

Variáveis

40

Atribuição de valores a variáveis

43

Variáveis signed e unsigned

45

Excedendo o limite de uma variável

46

Operações matemáticas com unsigned

47

AnsiString

48

Funções que modificam strings

61

Funções que modificam strings

63

AnsiString continuação

(dstring.h)

65

AnsiString continuação

66

AnsiString continuação

67

A palavra-chave typedef

67

A diretiva #define

68

A palavra-chave const

69

Operadores matemáticos

73

Expressões

75

Entendendo melhor o C++Builder

78

#include <vcl.h>

78

#pragma hdrstop

83

“Unit1.h”

 

84

“#pragma package(smart_init)”

85

#pragma resource

87

_fastcall,

fastcall

 

88

TComponent

88

TComponent::Owner

89

Operadores de incremento e decremento

90

Operadores relacionais

91

O

comando if

92

O

comando else

95

if

else

- Continuação

95

Comandos aninhados e Indentação

97

Operadores lógicos

98

O

operador condicional ternário

99

Funções

100

Chamada de Funções

102

Definição de uma função

103

Protótipos de funções

105

Variáveis locais e globais

107

A palavra-chave extern

109

A palavra-chave static

111

Parâmetros das funções

114

O

comando return

115

Valores Default

 

117

Funções inline

118

O

comando goto

119

O

loop while

119

break e continue

 

122

O

loop while sem fim

122

loop while - continuação

123

O

loop do

while

124

O

loop for

126

loop for - continuação

127

Omissão e aninhamento no loop for

128

O

comando switch

130

métodos Canvas para desenhar objetos gráficos

138

propriedades Canvas

140

TPen::Width

143

TPen::Mode

145

TPenRecall

146

Usando brushes

146

TBrush::Color

148

TBrush::Style

148

TBrush::Bitmap

150

TBrushRecall

151

Ler e inserir pixels

151

TCanvas::Pixels

152

TBitmap::ScanLine

153

Propriedades e métodos comuns de Canvas

154

Conhecendo arrays

165

Excedendo o limite de um array

167

Matrizes multidimensionais

168

Arrays de caracteres

172

Estruturas

174

Ponteiros

176

A

reutilização de um ponteiro

180

Ponteiros apontando para outros ponteiros

181

Ponteiros apontando para structs

182

O nome do array

184

Variáveis dinâmicas

186

Mais problemas

ponteiros soltos

190

Ponteiros & constantes

193

Referências

195

Reatribuição de uma referência

196

O bê-a-bá da programação

Não fique impressionado, se um dia você descobrir que o aplicativo que você está usando para ler ou tratar algum dado em seu computador foi desenvolvido em linguagem de programação C++ (pronuncia-se "cê mais mais"). Mesmo porque, em poucos dias, você já estará desenvolvendo um processador de texto que poderá, inclusive, ser usado para substituir o bloco de notas do seu Windows.

Na escolha de uma linguagem de programação, deve-se considerar não apenas a facilidade de aprendizado, mas principalmente aquilo que se quer e que se pode fazer com ela. Uma escolha errada pode nos trazer prejuízos e frustrações.

Certamente C++ não é a linguagem cujos conceitos mais facilmente são assimilados, mas também não é uma linguagem difícil. Na verdade, trata-se de uma linguagem de programação poderosa, para qualquer tipo de desenvolvimento computacional, e quando se começa compreender os seus conceitos fica bastante interessante e divertido o seu aprendizado. E não há nenhum inconveniente ou dificuldade em se aprender C++ como primeira linguagem de programação. O que é importante é que existam a vontade de aprender, a dedicação e a familiaridade com computadores.

Afinal, o quê é C++?

Segundo Bjarne Stroustrup (criador de C++), "C++ é uma linguagem de uso geral com uma tendência para a programação de sistemas que: é uma C melhor; suporta abstração de dados; suporta programação orientada a objetos; e suporta programação genérica".

C++ é um superset de C. Portanto quaisquer códigos escritos para a linguagem C devem funcionar normalmente em C++, porém, não raras vezes, C++ oferece uma maneira melhor, ou mais de uma maneira, de se obter o mesmo resultado, o quê nos proporciona grande flexibilidade em nosso trabalho.

C++ é uma linguagem de programação usada para a criação de uma infinidade de programas como sistemas operacionais, processadores de texto como o Microsoft Word, planilhas eletrônicas como o Excel, comunicação, automação industrial, bancos de dados, jogos, games, aplicativos multimídia, navegadores Web como o Internet Explorer etc; é uma linguagem que permite acesso aos recursos do hardware e vai por aí afora, sem deixar de lado os sistema embutidos usados nos automóveis, celurares etc.

Um pouco de história

Ocorreu em junho de 1983, a primeira utilização de C++ fora de uma organização de pesquisa. Podemos considerar C++ um resultado evolutivo da linguagem de programação BCPL, criada por Martin Richards

e que rodava num computador DEC PDP-7, com sistema operacional UNIX. Ken Thompson, em 1970,

efetuou algumas melhorias na linguagem BCPL e a chamou de linguagem "B". Em 1972, Dennis M. Ritchie, no Centro de Pesquisas da Beel Laboratories, implementou diversas melhorias na linguagem "B" que, considerada uma sucessora de "B", foi chamada de "C", rodando pela primeira vez num DEC PDP- 11, em sistema operacional UNIX.

O poder da linguagem "C" logo foi demonstrado, em sua primeira aplicação de peso, quando foi usada para reescrever o sistema operacional UNIX, até então escrito em linguagem assembly.

Com o tempo, a linguagem "C" tornou-se bastante popular e importante. Contribuiriam para o sucesso o fato de essa linguagem possuir tanto características de baixo nível quanto de alto nível; a portabilidade da linguagem, ou seja, poder ser usada em máquinas de diferentes portes e diferentes sistemas operacionais; bem como o fato de, em meados de 1970, o sistema operacional UNIX ser liberado para as Universidades, deixando de ficar restrito aos laboratórios. Por volta de 1980, várias empresas já ofereciam diversas versões de compiladores "C", compatíveis com outros sistemas operacionais, além do original UNIX.

Bjarne Stroustrup criou C++. Claramente, como pondera Stroustrup, C++ deve muito a "C" que foi mantida como um subconjunto. Também foi mantida a ênfase de "C" em recursos que são suficientemente de baixo nível para enfrentar as mais exigentes tarefas de programação de sistemas. Outra fonte de inspiração para C++ foi Simula67, da qual C++ tomou emprestado o conceito de Classes.

Desde 1980, versões anteriores da linguagem, conhecidas como "C com Classes" têm sido utilizadas. O nome C++, criado em 1983 por Rick Mascitti, representa as mudanças evolutivas a partir de "C", onde "++" é o operador de incremento em "C".

Bjarne Stroustrup projetou C++ basicamente para poder programar sem ter de usar Assembler, "C" ou outras linguagens de alto nível. Seu principal objetivo era tornar a escrita de bons programas mais fácil e mais agradável para o programador individual.

Em março de 1998, o American National Standards Institute (ANSI) aprovou e publicou um padrão para

a linguagem C++. A padronização melhora a portabilidade e a estabilidade dos programas. Usando a

biblioteca Standart de C++, podemos, rapidamente, construir aplicações confiáveis, bem como mantê-las

com menos custo e esforço.

Desde seu desenvolvimento por Dr. Bjarne Stroustrup, C++ foi extensamente usado na construção de grandes e complexas aplicações como telecomunicações, finanças, negócios, sistemas embutidos e computação gráfica. A padronização final da biblioteca de C++ torna mais fácil o seu aprendizado, facilitando seu uso por uma grande variedade de plataformas, o que, por outro lado, significa garantia de colocação profissional permanente para os bons programadores da linguagem.

Conceitos

Podemos classificar as linguagens de programação em dois grupos: aquelas consideradas de baixo nível e aquelas consideradas de alto nível.

1º. Linguagens de baixo nível.

Quando nascemos, à medida que crescemos, nossa percepção e o contato com a realidade do mundo, nos anexa às coisas como elas já foram sedimentadas na cultura de um povo. Assim também ocorre com o idioma e, de um modo geral, com algumas ciências que assimilamos em sequer darmos conta disso.

Por exemplo, quando uma criança conta para outra que possui trinta ou quarenta figurinhas, não percebe, mas está fazendo uso do sistema numérico decimal (base 10). E o sistema numérico decimal está incrustado em nosso cotidiano. Via de regra, todos os valores que usamos e todas as contas que fazemos têm esse sistema numérico como base. Por exemplo, quando escrevo 543, você entende 543 e não tem dúvidas, pois sabe o que 543 significa. Raciocinando em sistema numérico decimal, também não é difícil compreender que:

543

= (5 x 10²) + (4 x 10¹) + (3 x 10º)

pois

543

= (5 x 100) + (4 x 10) + (3 x 1)

pois

543

= 500 + 40 + 3.

Infelizmente, os sistemas computacionais não representam valores usando o sistema numérico decimal. Internamente, os computadores representam valores usando dois níveis de voltagem (normalmente 0v e

+5v). Com esses dois níveis de voltagem, nós podemos representar dois valores. Por convenção, adota-se

o zero e o um. Então, para todos os efeitos, os computadores só conhecem uma linguagem que é

constituída por zeros e uns, ou código de máquina, mais conhecida por linguagem binária. Nesse contexto,

se quisermos representar o número 543, devemos escrever:

1000011111

Qualquer quantia de dígitos binários com valor igual a zero pode anteceder um número binário sem alterar-lhe o valor. Por exemplo, podíamos representar o número 543 assim:

00000000000000000000000000000000001000011111.

Ante o exposto, não fica difícil compreender que a menor unidade de dados num computador é um dígito binário. Um dígito binário é o mesmo que um bit, abreviatura de binary digits.

Complicado? No início da era dos computadores (aqueles gigantes à válvula), os programas eram escritos basicamente em binário, mas, felizmente, longe se vão os dias em que se precisava programar diretamente em binário, embora ainda exista quem trabalhe nesta base.

O sistema numérico binário tem um modo de funcionamento semelhante ao sistema numérico decimal,

porém com duas diferenças básicas:

1ª. o sistema numérico binário contém apenas os dois valores 0 e 1, em vez de 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9; e

2ª. o sistema numérico binário usa potências de 2, em vez de potências de 10.

Embora um bit seja capaz de assumir apenas dois valores (zero e um), o número de elementos que se pode representar com um único bit é infinitamente grande. Por exemplo, pode-se representar quaisquer dois valores diferentes com um único bit: falso ou verdadeiro, maior ou menor, redondo ou quadrado e assim por diante, numa lista incomensurável. Todavia, esse tipo de construção não é usual.

Um sério problema com o sistema binário é o tamanho de suas representações. Veja bem, enquanto a versão decimal de 543 contém apenas três dígitos: 5, 4 e 3, a representação binária do mesmo valor contém dez dígitos: 1000011111. Disso decorre que, ao se trabalhar com valores grandes, os números binários rapidamente se tornam difíceis de ser controlados. Embora seja possível converter binários em decimal e vice-versa, tal tarefa não é simples nem trivial. Mas é essa a linguagem que a máquina entende.

Alternativamente, tentou-se programar em hexadecimal, que pode representar dezesseis valores entre 0 e 15 decimais. Os números hexadecimais possuem duas características positivas:

1ª. sua conversão para binário é relativamente simples; e

2ª. são razoavelmente compactos.

O

sistema hexadecimal é uma base de numeração que começa a ser contado no "0" e termina em "F":

0,

1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

O

sistema hexadecimal possui uma relação simples com o sistema binário, uma vez que para cada grupo

de quatro dígitos binários temos um em hexadecimal.

veja a tabela abaixo:

decimal

binário

hexadecimal

1

0001

1

2

0010

2

3

0011

3

4

0100

4

5

0101

5

6

0110

6

7

0111

7

8

1000

8

9

1001

9

10

1010

A

11

1011

B

12

1100

C

13

1101

D

14

1110

E

15

1111

F

16

0001

0000

10

17

0001

0001

11

18

0001

0010

12

19

0001

0011

13

20

0001

0100

14

21

0001

0101

15

22

0001

0110

16

23

0001

0111

17

24

0001

1000

18

25

0001

1001

19

26

0001

1010

1A

27

0001

1011

1B

28

0001

1100

1C

29

0001

1101

1D

30

0001

1110

1E

31

0001

1111

1F

32

0010

0000

20

Existem algumas convenções que devem ser adotadas para se diferenciar os sistemas numéricos:

1ª. pode-se colocar um sufixo "d" num valor decimal;

2ª. a letra "b" deve ser colocada no final de todo e qualquer valor binário. Exemplo: 1011 0001b

3ª. a letra "h" deve ser colocada ao final de todo e qualquer valor hexadecimal. Exemplo 4D5Fh;

Não há necessidade de enfatizar que a programação em hexadecimal, embora menos complexa que a binária, continuava sendo demasiadamente complicada e demorada.

Nesse contexto, surge uma nova linguagem de programação: o Assembly, uma linguagem de símbolos designados mnemónicas, que são instruções Assembly. Cada mnemónica tem a sua correspondência em um comando elementar inteligível pelo computador. Nesse tipo de programação, o programador trabalha diretamente com registradores da CPU e com a memória, entre outras coisas.

Programar em Assembly significa conversar quase que diretamente com a CPU, tal qual os sistemas binário e hexadecimal. Ou seja, nesses tipos de programação, o programa é escrito em uma linguagem muito próxima àquela que a máquina entende, e por isso são as linguagens ditas de baixo nível.

Abaixo, exemplo de instrução em Assembly:

a 100

MOV AX, 20

MOV BX, 30

ADD AX, BX

NOP

Do exemplo, AX e BX são registradores internos da CPU. O comando “a 100” determina o endereço inicial para o programa em 0100h; o programa executa o seguinte: move para o registrador AX o valor 20; move para o registrador BX o valor 30; soma o conteúdo do registrador AX com o conteúdo do registrador BX e deixa o resultado em AX; e a instrução NOP finaliza o programa.

2º. Linguagens de alto nível

Quando nos referimos às linguagens de alto nível, estamos falando daquelas que são escritas em um distanciamento relativo da linguagem máquina. Ou seja, as linguagens de alto nível são aquelas que se aproximam da linguagem humana, como a Linguagem Basic, C++, Pascal, Java etc.

Por exemplo, Para fazer uma frase aparecer na tela no DarkBASIC, basta digitar:

PRINT " Esta frase que está entre aspas será exibida na tela! "

Veja agora, a mesma frase em linguagem C:

main()

{

printf (" Esta frase que está entre aspas será exibida na tela! ");

exit (0);

}

Em Pascal:

program

begin

write (" Esta frase que está entre aspas será exibida na tela! ");

end

Visualmente, o que diferencia estas linguagens de programação daquelas ditas de baixo nível é justamente

o fato de nestas linguagens podermos encontrar algum sentido naquilo que estamos lendo ou escrevendo.

Um simples programa como este que foi apresentado nessas linguagens de alto nível, seria praticamente ininteligível para nós, se fosse escrito em binário.

De uma forma simplista, podemos dizer que nas linguagens de alto nível, o próprio programa tradutor

(compilador ou interpretador) que usamos se encarrega de conversar com a máquina, transformando todos os comandos que inserimos no programa para uma linguagem que a máquina compreenda qual a resposta

a ser dada. Ou seja, o tradutor converte o código-fonte em um código executável pela máquina.

O bit e o byte

O tipo de dado mais utilizado pelos chips da família 80x86 não é o bit, e sim o byte. Um byte equivale a um grupo de oito bits. Para facilitar a leitura e a compreensão, costumam-se adotar algumas convenções:

1ª. completar com zeros os números binários para que eles se tornem um múltiplos de quatro ou de oito bits.

Exemplo: 543 = 001000011111;

2ª. cada grupo de quatro bits deve ser separado por espaço.

Exemplo: 0010 0001 1111.

Um byte pode representar até 256 valores diferentes, pois são oito bits em potência de dois:

2 8 = 256.

Geralmente um byte é usado para representar valores compreendidos entre 0 e 255 não sinalizados ou valores entre -127 a 128 sinalizados.

Para os tipos de dados, como os caracteres (letras ou símbolos), que não possuem mais do que 256 elementos, um byte normalmente é suficiente.

Embora sejam visualizadas como letras e símbolos, as constantes caracteres são armazenadas internamente pelo computador como um número inteiro entre 0 e 255. O caracter A, por exemplo, tem valor 65; o B, 66; o C, 67; e assim por diante. Os valores numéricos dos caracteres estão padronizados em uma tabela chamada de American Standard Code for Information Interchange Table ou simplesmente tabela ASCII.

Um grupo de 16 bits denomina-se word, ou palavra. Com 16 bits podemos representar até 65.536 (2 16 ) valores diferentes: 0 a 65.535 não sinalizados e -32.767 a 32.767 sinalizados. Um dos principais usos para a palavra são para os valores de inteiros.

Um grupo de 32 bits denomina-se double words. Com 32 bits podemos representar uma infinidade de tipos de dados, como por exemplo valores ponto flutuante de 32 bits. São 4.294.967.296 (2 32 ) valores diferentes: 0 a 4.294.967.295 não sinalizados e -2.147.483.647 a 2.147.483.647 sinalizados.

Cuidados gerais

Ao escrever um código-fonte em C++, algumas precauções extras devem ser adotadas.

1. Deixar o código o mais claro e compreensível possível, inserindo comentários e usando-os adequadamente, bem como tomar bastante cuidado com a grande liberalidade na forma que o formato livre admite.

Documentar o trabalho

Em princípio, comentários são textos que inserimos no programa para esclarecer qual é a tarefa que determinado comando realiza. Comentários são muito importantes em nossos códigos C++. A linguagem C++ suporta dois estilos de comentários:

a) comentário no estilo C: /*

*/

/* Neste tipo de comentário, tudo aquilo que estiver inserido entre a chave de abertura do comentário (barra e asterisco) e a chave de fechamento do comentário (asterisco e barra) será desconsiderado pelo compilador, independentemente da quantidade de linhas usadas. */

b) comentário no estilo C++: //

// Neste tipo de comentário, tudo aquilo que estiver inserido à direita // do comentário (barras duplas), até o final da linha // será desconsiderado pelo compilador. // Neste estilo, a cada nova linha, // precisamos iniciar um novo comentário.

Outra aplicação que podemos dar aos comentários, é a de tirar, temporariamente, a validade de uma parte do programa:

cout << " Esta mensagem aparece na tela! \n"; // cout << " Esta mensagem não aparece na tela! \n"; /* cout << Esta mensagem não aparece na tela! \n"; *

Uma vez iniciado um comentário no estilo C, não podemos inserir outro comentário dentro deste, pois o compilador considerará apenas a primeira chave de fechamento, o quê ocasionará um erro:

/* Abrimos um comentário no estilo C; /* até a primeira chave de fechamento não há problemas, pois a abertura desse novo comentário, na verdade não ocorreu, sendo considerada parte integrante do comentário inicial */ aqui começa a parte ilegal do comentário, e o compilador deve acusar o erro */

Cuidado com o formato livre

Há uma grande liberalidade na forma em que podemos escrever um código C++, o que significa que o posicionamento de alguns comandos ou caracteres dentro do texto, de regra, não influenciarão no resultado da compilação. Esclarecendo melhor, espaços, tabulações, retornos ou comandos escritos em novas linhas são caracteres desconsiderados pelo compilador.

Abaixo transcrevemos um mesmo programa escrito de três formas diferentes:

void main(void)

{

cout << " C++ possui formato livre!!!\n"; getch();

}

void

main

(

void

)

{

cout << " C++ possui formato livre!!!\n"

;

getch

(

)

;

}

void main(void){cout << " C++ possui formato livre!!!\n";getch();}

O resultado apresentado pelo programa acima é rigorosamente o mesmo em qualquer das três hipóteses.

Evidentemente, se, quando trabalharmos num projeto, não tivermos cuidado de escrever um bom e legível código, o resultado poderá apresentar-se bagunçado, dificultando sua compreensão e, até mesmo, a localização e conserto de bugs (erros no código que afetam diretamente o resultado) no programa.

Certamente em pouco tempo você já estará desenvolvendo sua própria técnica para escrever bons programas, usando o formato livre a seu favor.

2. Cuidado com o uso de letras maiúsculas e minúsculas

C++ é Case Sensitive

C++ é Case Sensitive, isto é, letras maiúsculas e minúsculas são interpretadas de forma diferente pelo compilador. Dentre outras implicações, isso significa que se, por acaso, declararmos uma variável com o nome Temp, os seguintes nomes terão significados diferentes: TemP; TEMP; temp; tEmp; TeMp. Atenção especial devemos ter quando escrevemos os comandos da linguagem nas instruções dos códigos-fontes,

bem como com algumas funções pré-existentes. Boa parte desses comandos são digitados com letras

case, include,

iostream.h, conio.h, open(), getch(), define, undef, \n, \t, \a etc. Mas essa regra, dependendo do compilador, não é absoluta e comporta exceções, como algumas funções ou classes internas do C++

Builder, como ShowMessage() ou AnsiString ou quando, por exemplo no IBM-PC, trabalhamos com os 128 caracteres adicionais da tabela ASCII, pois neste tipo de dado, trabalhamos com o código do símbolo

na base hexadecimal.

minúsculas, como por exemplo: cout, cin, if, else, while, do

while, for, switch

É bastante comum erros de compilação por causa da sensitividade de C++, mas esse não é um erro difícil

de se corrigir.

O programa main()

Todo programa C++ deve ter uma função principal denominada main(), não podendo haver outra função com esse mesmo nome, sendo que a execução do programa sempre será iniciado em main().

O menor programa possivel em C++ é:

main() {}

Ele define a função main, que não recebe nenhum argumento e não devolve nada. O programa logo encerra e o máximo que se percebe é uma janela piscando rapidamente na tela.

Em se tratando aplicações tradicionais Windows, necessário far-se-á entendermos a função WinMain. Em capítulos posteriores, estudaremos essa função com detalhes

Primeiro programa

Diversos programas-exemplo serão apresentados durante este curso, sendo que os mesmos foram processados no c++builder 5.02, c++builder 3, c++builder 4 e no c++builder 6, todos da borland. Alguns desses programas foram escritos com o intuito de ilustrar os tópicos apresentados; outros, para deixar o curso mais interessante. Sendo assim, procuraremos apresentar tutoriais sobre a confecção de programas, que irão se completando aos poucos, à medida que avançamos no curso. No final, tudo deverá fazer sentido.

O código-fonte de um programa C++ pode ser escrito em qualquer editor de texto simples que possa

salvar seu conteúdo em formato de texto puro. Podemos, inclusive, usar o Bloco de Notas do Windows. Porém, no lugar da extensão .txt, devemos salvar os códigos do programa com extensão .cpp. Contudo, a forma mais rápida e sensata de se escrever um programa C++ é usando o próprio editor de códigos que acompanha o ambiente de desenvolvimento C++. Esclarecemos aqui que muitos exemplos deste livro estão redigidos com fonte formatada (itálica, negrito, colorida etc) apenas para fins didáticos e para facilitar uma eventual localização no mesmo. Um código-fonte C++ não deverá ser escrito com este formato e sim, conforme já exposto, em formato de texto puro, não formatado. Se você está procurando um bom editor de códigos para seus programas, nos atrevemos a indicar o ConTEXT. Usamos esse editor grandemente na elaboração destas páginas. Com ele ficou muito fácil padronizar a visualização dos

códigos fontes, bem como exportar os mesmos, já formatados, para o padrão .html ou .rtf. Para maiores informações, consulte http://www.fixedsys.com/context

Inicialmente, para compreendermos melhor o conceito dos comandos e das instruções em C++, trabalharemos um programa definido como aplicação Console Win32, que gera programas parecidos com o DOS quando estão rodando, mas, na realidade, trata-se de programas de 32 bits executados no ambiente Windows.

Bem, chega de conversa e vamos por as mãos na obra:

1. inicialize o C++Buider;

e vamos por as mãos na obra: 1. inicialize o C++Buider ; 2. dê um clique

2. dê um clique no menu File;

3. dê um clique em New

4. Na janela que se abrir, selecione a opção Console Wizard e clique em OK;

selecione a opção Console Wizard e clique em OK ; 5. selecione Console em Window Type

5. selecione Console em Window Type e clique em finish.

O Builder C++ , abrirá o editor de textos para você. É nesta janela que

O Builder C++, abrirá o editor de textos para você. É nesta janela que digitaremos o código-fonte de nosso programa.

janela que digitaremos o código-fonte de nosso programa. Observe o próprio BuiderC++ , por default (padrão),

Observe o próprio BuiderC++, por default (padrão), já digita parte do código que usaremos. Porém essa sugestão da Borland, neste tipo de aplicação Console Wizard, em princípio, pode ser ignorada, conforme demonstramos abaixo. Você pode optar por qualquer uma das duas formas para desenvolver seus programas:

Na sugestão da Borland:

#pragma hdrstop #include <condefs.h>

//----------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])

{

return 0;

}

devemos digitar o código-fonte de nosso programa imbricando-o no código pré-estabelecido acima.

Outra opção que temos é deletar todo esse código e simplesmente iniciar nosso programa a partir do código já visto do menor programa possível em C++:

main()

{

}

Esse modelo é aconselhável, se você estiver usando outro tipo de compilador. Caso haja algum conflito entre o exemplo apresentado e o seu compilador, procure ajuda no manual do mesmo.

Nosso primeiro programa, ao ser compilado, escreverá na saída de vídeo uma string (cadeia de caracteres) com um espaço de tabulação na segunda linha da tela, levará o cursor para a terceira linha da tela, emitirá um beep e, por fim, aguardará que uma tecla qualquer seja pressionada para encerrar a aplicação.

Delete toda a sugestão da Borland e, no editor de textos, digite:

#include <iostream> #include <conio>

main()

{

std::cout << "\n\tEstou fazendo o meu primeiro programa\n\a";

getch();

}

Se preferir manter a sugestão da Borland, o código deverá ficar assim:

#include <condefs.h> #include <iostream> #include <conio>

//---------------------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])

{

std::cout << "\n\tEstou fazendo o meu primeiro programa\n\a";

getch();

return 0;

}

Para Salvar, clique o menu File, escolha a opção Save e, na pasta de sua preferência, salve o programa com o nome PrimProgram.bpr.

Agora vamos rodar o programa para ver o resultado.

Compilar significa converter o código-fonte em linguagem que o processador (CPU) entenda, ou seja, em código de máquina, reunindo todos os comandos em um só arquivo. Linkeditar é transformar esse código fonte em um executável - um .exe (programa pronto).

Para executar o programa, nós podemos pressionar a tecla F9, ou podemos dar um clique em Run no menu Run, ou podemos clicar a seta verde (Run F9) sob o botão Open Project.

clicar a seta verde ( Run F9 ) sob o botão Open Project . Feito isso,

Feito isso, seu primeiro programa produzirá um executável semelhante à figura abaixo:

Muito bem, salvado o programa, encerre o aplicativo C++Builder . Abra a pasta onde você

Muito bem, salvado o programa, encerre o aplicativo C++Builder. Abra a pasta onde você salvou o projeto PrimProgram.bpr e observe que o compilador colocou lá cinco arquivos:

PrimProgram.bpr

PrimProgram.cpp

PrimProgram.exe

PrimProgram.obj

PrimProgram.tds

Ora, mas vejam só, nós já temos um arquivo .exe (PrimProgram.exe) em nossa pasta! Inicialize-o e perceba que o nosso primeiro programa já roda sem auxílio do compilador. Pois bem, pressione uma tecla qualquer para encerrar o aplicativo e dê um (ou dois) clique(s) em PrimProgram.bpr para ver o que

acontece:

Estamos de volta no ambiente de desenvolvimento do primeiro programa.

A seguir, procuraremos entender como conseguimos criar esse programa. Na explanação, aparecerão nomes como Classes, objetos, macros, funções etc, que talvez lhe pareçam estranhos e incompreensíveis. Não se preocupe, pois, no momento certo, tudo ficará claro.

Diretivas de pré-processador

O pré-processador C++ é um programa que fornece mecanismos para inclusão de arquivos-textos,

cabeçalhos padrão e compilação condicional baseada em macros. Esse programa também pode ser usado para definir e usar macros.

Talvez você esteja se perguntando: afinal, o quê quer dizer esse monte de coisas?

Por enquanto, apenas para elucidar nosso primeiro programa sem tumultuar nosso entendimento, vamos nos contentar com uma explicação bem singela:

O pré-processador C++ é um programa que roda antes do compilador e, baseando-se em certas instruções denominadas diretivas de compilação, examina o programa fonte e implementa-lhe algumas modificações.

As diretivas de compilação mais comuns são:

#include

#define

#line

#ifdef

#ifndef

#if

#else

#elif

#endif

#undef

#error

#pragma

Algumas particularidades:

1ª. todas as diretivas iniciam com #;

2ª. devemos respeitar a regra de colocar somente uma diretiva em cada linha. Ou seja, não podemos colocar outro comando qualquer na linha em que há uma diretiva.

a diretiva #include

Imagine que muitos dos resultados que esperamos obter de nossos programas já estão, de certa forma, prontos, na biblioteca padrão, para ser inseridos em nosso código-fonte. Ou seja, não temos necessidade de desenvolver determinados arquivos (classes, funções ou gabaritos) porque eles já existem e podem ser usados em qualquer momento que precisemos deles.

Quando o pré-processador encontra a diretiva #include em nosso código fonte, substitui a mesma pelo conteúdo do arquivo indicado (no nosso exemplo, o conio e o iostream). O resultado é que o compilador encontrará e processará o arquivo implementado, e não a diretiva de compilação.

A diretiva #include é um mecanismo de tratamento do código-fonte que reúne, em um único arquivo de compilação, códigos (arquivos de cabeçalho ou hearder files, ou arquivos que contenham funções ou definições de dados) que se encontram dispersos em vários arquivos.

Para incluir os herder files em nosso código-fonte, devemos usar os símbolos < e > ou " e " para envolver o arquivo de cabeçalho:

#include <iostream>

ou

#include "iostream.h"

Se deixarmos espaço entre o caracter < e o nome do arquivo de cabeçalho, ou entre o caracter " e o nome do arquivo de cabeçalho, o compilador indicará erro:

< iostream.h> // [C++ Error] Project2.cpp(4): E2209 Unable to open include file ' iostream'.

Convencionou-se usar para os arquivos de cabeçalho o sufixo .h e para outros tipos de arquivos que contenham funções ou definições de dados, o sufixo .hpp, .c, ou .cc, .cpp, .cxx, .C, conforme o compilador. No caso do C++Builder, o arquivo que se encontra associado é o .hpp, responsável pela interface com a VCL, que foi escrita em Object Pascal.

Historicamente, o sufixo .h era padrão para todos os arquivos de cabeçalho. Entretanto, para evitar problemas de compatibilidade com cabeçalhos de versões redefinidas de biblioteca padrão, ou com novos recursos de biblioteca que foram surgindo, resolveu-se suprimir o sufixo .h dos nomes de cabeçalho padrão (podemos dizer que cabeçalho padrão é o arquivo de cabeçalho definido na biblioteca padrão). A

partir de então, nenhum sufixo é necessário para cabeçalhos da biblioteca padrão: <iostream>, <conio>, <map> etc.

A principal diferença entre a biblioteca padrão e a não padrão é que, enquanto uma biblioteca não padrão

tem de ser incorporada manualmente, a padrão é incorporada automaticamente pelo compilador. É importante saber, ainda, que os recursos da biblioteca padrão estão definidos num ambiente de nomes

chamado std e apresentados como uma série de cabeçalhos.

O arquivo de cabeçalho iostream

Para o nosso programa imprimir a string Estou fazendo o meu primeiro programa no vídeo, nós providenciamos para que a Classe iostream fosse chamada à compilação através da diretiva #include. A biblioteca iostream contém as declarações necessárias ao uso de streams de entrada (teclado) e saída (vídeo), como, por exemplo, o objeto cout e o operador de inserção <<. Obtém-se o operador de inserção << digitando-se o caracter "menor que" duas vezes.

O objeto cout é o responsável pela saída, no console ou na tela, da string que digitamos: Estou fazendo o

meu primeiro programa.

O operador de inserção << (envie para) escreve o argumento da direita (a string) no da esquerda (no

cout).

Além do cout e do operador de inserção << a Classe iostream contém outras definições de impressão e leitura (I/O), que estudaremos mais adiante.

Você deve ter notado que demonstramos a inclusão dos arquivos de cabeçalho da Classe iostream de três modos diferentes:

#include <iostream> // Cabeçalho padrão sem sufixo .h

#include "iostream.h" // Cabeçalho de biblioteca não padrão

#include <iostream.h> // Cabeçalho padrão com sufixo .h

Não há necessidade de inserirmos nenhum sufixo para cabeçalhos da biblioteca padrão, porque os símbolos < > já denotam o chamamento de cabeçalhos padrão. Contudo, as declarações dos cabeçalhos mais antigos, são colocadas no ambiente de nomes global, carecendo do sufixo .h.

Os cabeçalhos colocados entre aspas " " determinam que o pré-processador procure o cabeçalho primeiro no diretório atual, e depois na biblioteca padrão (Include).

Em nosso programa: #include<iostream> instrui o pré-processador a incluir os recursos de entrada e saída de iostream padrão, e std::cout determina a inclusão do cout padrão.

Se quisermos, podemos tornar todos os nomes std globais, o que nos poupa da tarefa de ter que digitar constantemente o prefixo std:: antes de cout:

#include <iostream>

using namespace std;

Se algum dos nossos programas não rodar, podemos usar uma versão mais tradicional. Para isso colocamos o sufixo .h nos cabeçalhos e removemos o prefixo std::. Exemplo:

#include <iostream.h> #include <conio.h>

main()

{

cout << "\n\tEstou fazendo o meu primeiro programa\n\a";

getch();

}

Boa parte dos programadores, talvez por praticidade, parece preferir essa segunda versão. Daqui para frente, escolha é sua!

O arquivo de cabeçalho conio

Nosso programa possui outro cabeçalho, o arquivo conio. Trata-se de um arquivo de inclusão necessário à utilização da função getch(). Quando descrevemos o que o nosso programa faria, afirmamos que, por fim, ele aguardaria que uma tecla qualquer fosse pressionada para encerrar a aplicação. Essa tarefa foi desempenhada pela função getch() que retorna o caracter lido no teclado, sem imprimi-lo no vídeo. Se quisermos que o caracter lido seja impresso no vídeo, podemos usar a função getche(), também integrante de a conio.

Lembra-se do menor programa possível em C++, quando afirmamos que tudo o que veríamos seria um breve piscar da janela na tela e o encerramento do programa? Pois bem, poderíamos usar getch() para segurar a janela na tela até que uma tecla fosse pressionada!

Caracteres especiais

Antes que nossa string fosse imprimida no vídeo, o programa pulou uma linha (caracter de nova linha) e imprimiu uma caracter de tabulação horizontal. Depois da string, o programa colocou o cursor na linha de baixo (nova linha) e emitiu um beep (sinal sonoro).

Como fizemos isso?

Alguns caracteres não podem ser inseridos diretamente pelo teclado. Por exemplo, se, durante a elaboração do código-fonte, no meio da string, pressionarmos a tecla Enter pensando que estaremos inserindo uma nova linha, faremos com que o compilador apresente uma mensagem de erro.

A solução é usarmos algumas combinações de caracteres que realizam essas tarefas. Essas combinações, conhecidas como seqüência de escape, são representadas por uma barra invertida \ e um caracter. Por exemplo, a combinação \n representa nova linha (Enter), \t representa tabulação horizontal (Tab) e \a representa o beep. Essas seqüências de escape, nós já conhecemos. Vejamos outras:

Escape

Nome

Valor ASCII

Descrição

\a

Bell (alerta)

007

emite um som do computador

\b

Backspace

008

retrocede um caracter

\n

New Line

010

envia o curso para a próxima linha

\r

 

Carriage

013

move o cursor para o início da linha

return

\t

 

Horizontal

009

põe o cursor para a próxima tabulação

Tab

\xff

   

representação hexadecimal

\0

 

Null

000

exibe um caracter nulo

\"

Aspas duplas

034

exibe aspas duplas (“)

\'

apóstrofe

039

exibe apóstrofe (')

\?

Interrogação

063

exibe ponto de interrogação

\\

Barra invertida

092

exibe barra invertida

String(s) de texto

Constante caracter é uma letra ou símbolo colocado entre apóstrofes: 'a', 'b', '~', 'A', 'B', '\n, '\r', '\xa0', '\xa2', 'xa3' etc.

Uma importante atividade nos programas em geral é a manipulação de textos como palavras, frases, nomes etc. Na realidade, esses textos são constantes string(s), que se compõem de um conjunto de caracteres colocados entre aspas: "Estou fazendo o meu primeiro programa", "constante string", "\tOuviram do Ipiranga as margens pl\xa0" "cidas\n\tde um povo her\xa2ico o brado retumbante\n\te o sol da liberdade em raios f\xa3lgidos,\n\tbrilhou no c\x82u da P\xa0tria nesse instante.\n"

Funções

Funções são a base de qualquer programa C++. Elas compõem, juntamente com as Classes, os blocos construtivos da linguagem. Dentro das funções, encontramos todos os comandos executáveis, sendo que as mesmas são a maneira típica de se obter alguma execução em C++.

Vamos reescrever o primeiro programa. Por enquanto, não queira compreender todos os detalhes da alteração, uma vez que, por ora, nossa preocupação é apenas esclarecer, sem pormenores, quais são os elementos básicos de uma função. Em outra seção deste curso, abordaremos as funções de uma forma mais abrangente e minuciosa.

Inicialize PrimProgram.bpr, caso não esteja com ele aberto. No compilador, clique em Edit e depois em Select All; Clique novamente em Edit e depois em Delete. Agora copie o código abaixo no editor de textos do compilador.

/*Dica: não use o recurso de copiar e colar códigos-fontes quando estiver estudando.

Procure digitar todo o código e entender o resultado que cada. instrução conhecida produzirá no programa.*/

#include <iostream> #include <conio> using namespace std; // torna todos o nomes std globais void ModifPrimProg(void); // declara a finção ModifPrimProg

int main() // estamos em main()

{

ModifPrimProg(); // chama a função ModifPrimProg return 0;

} // fim de main()

void ModifPrimProg(void) // cabeçalho da definição da função

{

cout << "\n\t\tModificando o primeiro programa." "\n\n\n\t\tDigite dois caracteres mas veja " "s\xa2 o primeiro: "; getche(); // retorna e imprime o caracter lido no vídeo cout << '\a'; // beep - sinal sonoro getch(); // retorna o caracter sem imprimi-lo no vídeo

} // fim de ModifPrimProg()

Execute o programa e volte aos estudos.

Com essa pequena alteração no código, podemos visualizar melhor alguns detalhes sobre as funções.

Uma função deve ter a seguinte forma geral:

tipo nome(declaração dos parâmetros)

{

Primeira_Instrução;

Segunada_Instrução;

Etc_instrução;

}

Nosso programa agora possui quatro funções: main(), ModifPrimProg(), getche() e getch(). O nome delas é: main, ModifPrimProg, getche e getch respectivamente. A função main(), como sabemos, é a principal, é aquela onde a execução do programa se inicia; ModifPrimProg() é uma função que não estava em biblioteca alguma, tendo sido criada por nós; getche() e getch() nós também já conhecemos do arquivo de cabeçalho conio.

Precedendo o nome da função main() temos o tipo int, que informa ao compilador que main() pode retornar um tipo int. Já a função ModifPrimProg() é do tipo void. O tipo void significa que a função não possui valor de retorno. Quando nenhum tipo de retorno for especificado, presume-se o valor de retorno int para a função. As funções retornam valores por meio do comando return.

Após o nome de qualquer função temos parênteses de abertura "(" e de fechamento ")". Nesses parênteses, informamos ao compilador a lista de parâmetros que a função pode receber. Logo, ModifPrimProg(void) não pode receber nenhum parâmetro por causa do tipo void.

Entende-se por cabeçalho da definição da função o conjunto tipo nome(declaração dos parâmetros) que

antecede a chave "{" de abertura do corpo da função. Entre a chave de abertura "{" e a de fechamento "}"

do corpo da função, encontramos as tarefas (instruções) que a mesma realiza.

Instruções são as tarefas que determinados comandos realizam. Toda instrução é encerrada com um ponto e vírgula ";":

cout << "uma instrução!";

getch();

return 0;

A falta do ponto e vírgula ensejará mensagem de erro pelo compilador. Porém, não se coloca ponto e

vírgula após as chaves de abertura e fechamento das funções.

Não se preocupe em entender, por ora, todos os conceitos apresentados, posto que os abordaremos novamente no correr do curso. Até aqui, tivemos apenas a intenção de colocá-los em contado com o ambiente de programação C++Builder e com os fundamentos da linguagem C++.

Imprimindo dados nos componentes

Se você ainda não se sente familiarizado com o C++Builder, ou não se sente seguro para a respeito da forma correta de se colocar componentes nos formulários (Forms), antes de prosseguir no curso, dê uma olhada nas seguintes lições:

Introdução ao BCB(http://www.dicasbcb.com.br/Iniciando_o_BCB/Inicia_o_BCB.htm)

Introdução ao BCB - 2ª parte(http://www.dicasbcb.com.br/Iniciando_o_BCB2/Inicia_o_BCB2.htm)

Podemos inserir palavras, textos ou frases em diversos componentes através códigos ou de suas propriedades no Object Inspector. Essas propriedades, uma vez demarcadas, determinam o modo que o programa iniciará a sua execução. Podemos, posteriormente, em tempo de execução, alterar essas propriedades de diversas formas, conforme o caso.

Exemplos: No Object Inspector, mude o texto da propriedade Caption do Form, de um Label, de um botão, e assim por diante e visualize, já no projeto, o resultado da alteração.

Outros componentes, derivados de outros ramos, possuem outras formas de ser alterados. Por exemplo, altere a propriedade Text de um Edit, ou de um MaskEdit; ou a propriedade Items de um ListBox; ou as propriedades Text e Items de um ComboBox etc.

Vejamos algumas formas de inserir textos em componentes, através do código, em tempo de execução:

//---------------------------------------------------------------------------

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

Canvas->TextOut( Canvas->PenPos.x, Canvas->PenPos.y, "Imprimindo um texto no form com o objeto Canvas" );

Label1 -> Canvas->TextOut( Canvas->PenPos.x, Canvas->PenPos.y, "Imprimindo um texto no Label com o objeto Canvas" );

Canvas->TextOut( Canvas->PenPos.x = 100, Canvas->PenPos.y = 100, "Imprimindo um texto nas coordenadas X = 100 e Y = 100 do Form" );

}

Outro exemplo:

//---------------------------------------------------------------------------

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

/* Este exemplo deve ser testado com dois cliques. O primeiro chamará a propriedade Caption; o segundo, o objeto Canvas */ Label1 -> Caption = "Testando o Caption";

/* Na linha de código abaixo, precisamos determinar uma coordenada diferente da default (0, 0), para que esse texto não venha a sobrescrever o Caption de Label */ Label1 -> Canvas->TextOut( Canvas->PenPos.x = 100, Canvas->PenPos.y = 100, "Imprimindo um texto nas coordenas X = 100 e Y = 100 do Label" );

}

Outro exemplo:

//---------------------------------------------------------------------------

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

Label1 -> Caption = "Testando propriedades";

Edit1->Text = "Continuando o teste

ListBox1->Items-> Add(Label1 -> Caption);

ListBox1->Items-> Add("Testando

ComboBox1 -> Text = "Fala, Grande!"; ComboBox1 -> Items -> Add(Label1 -> Caption);

");

ComboBox1 -> Items -> Add("Fala, Grande ComboBox1 -> Items -> Add(Edit1->Text);

";

");

}

Outro exemplo:

//---------------------------------------------------------------------------

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

ShowMessage("Alô, Thérbio!");

ShowMessage("Alô, Thérbio!" "\nEstou na segunda caixa de mensagem,\n e na terceira linha");

MessageBox(0, "Agora uma caixa de mensagens \nm\n\ta\n\t\ti\n\t\t\ts\neditada!",

}

"Caixa de Aprendizagem

", 64);

Nota introdutória. No avançar deste curso, você perceberá que, propositadamente, usamos alguns nomes, comandos ou tipos de dados com os quais você poderá não estar habituado a trabalhar. Não se assuste e nem se preocupe em querer entender imediatamente todos os detalhes apresentados, pois tudo deverá ficar bastante claro no tempo certo. Concentre-se, basicamente, em entender a manipulação dos dados referentes ao tópico apresentado.

Conhecendo melhor as propriedades que capturam dados

Nos exemplos anteriores, conhecemos um modo de inserir textos ou strings nos componentes, sem nos preocuparmos de que modo isso nos pode ser útil. Agora aprofundaremos um pouco mais o estudo para podermos entender que essas propriedades não estão limitadas e pode produzir alguns resultados mais úteis:

void

fastcall

TForm1::Button1Click(TObject *Sender)

/* Neste exemplo, iremos corrigir uma falha referente à cor do primeiro exemplo em que usamos o objeto Canvas do Form. Como você deve ter notado, as cores da frase sairam com um fundo branco (clWhite), enquento que o form

manteve a cor original clBtnFace, visto que não procedemos a nenhuma alteração nela. Para visualizar melhor essa situação, dê uma olhada na propriedade Color do Form no Object Inspector. Pois bem, vamos corrigir a cor do fundo da frase para igualá-la ao Form.*/

{

// Ok. A cor do fundo igual à cor do Form Canvas -> Brush -> Color = clBtnFace;

/* A linha de código abaixo nos mostra como podemos usar propriedades matemáticas diretamente no Form*/ Canvas->TextOut( Canvas->PenPos.x = 10, Canvas->PenPos.y = 100, (5 * 4) + (60 - 50) );

/* Podemos chamar funções que nos mostrem a data e a hora

Canvas->TextOut( Canvas->PenPos.x, Canvas->PenPos.y, Date()/* +Time()*/);

}

*/

Evidentemente, outros componentes também são férteis para trabalharmos com dados:

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

/*Uma caixa de mensagem que pode nos mostrar a data, a hora ou ambas.*/ ShowMessage( Time() /* + Date()*/ );

}

Por certo, as operações abaixo já não causam muitas surpresas em você:

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

ShowMessage("Alô, Thérbio!\nVocê sabe qual é o resultado de " "286 multiplicado por 132 somado com 412?");

ShowMessage((286 * 132) + 412); Label1 -> Caption = (5 * 4) + 13; // imprime 33 no label AnsiString a = 2 + 12; // AnsiString pode funcionar como inteiro ou ponto flutuante

/* neste exemplo, o sinal + neste local do código, serve para concatenar os dados. Só ocorre a concatenação porque usamos o tipo AnsiString. Se tivéssemos usado uma variável inteira ou ponto flutuante, o resultado seria diferente*/ Label2 -> Caption = "Multiplicação de 14 X 14 = " + a * a;

/* produz o mesmo resultado no Label. O mesmo resultado teríamos se tivéssemos usados variáveis inteiras ou ponto flutuante*/ Edit1 -> Text = "****Elimina os quatro primeiros caracteres" + 4;

}

Vamos aproveitar para conhecer a base do código que será usado para construirmos uma calculadora. Usaremos um Label e um Botão qualquer no Form.

void

fastcall

TForm1::BitBtn1Click(TObject *Sender)

{

/* O código abaixo determina que o programa coloque no Caption de Label1 tudo aquilo que já está nele e mais o número 1. */ Label1 -> Caption = Label1 -> Caption + 1;

}

Comentários

Quando estamos empenhados na tarefa de escrever uma aplicação, é fundamental tomarmos algumas providências para que não nos percamos nas diversas linhas de código que por ventura utilizaremos. Uma coisa muito útil que podemos, ou melhor, que devemos fazer é colocar comentários que nos esclareçam a utilidade das diversas partes do código. Evidentemente, você já tem percebido que, junto às linhas de código, nós colocamos algumas frases esclarecedoras dentro de um par de barras com asterisco /* */, ou imediatamente após duas barras //. Essas frases são os comentários.

C++ aceita esses dois estilos de comentários:

/* Esse estilo de comentário é derivado da linguagem C. Ele é aberto com uma barra seguida de um asterisco. Tudo aquilo que estiver após essa chave de abertura, até encontrar uma chave de fechamento (um asterisco e uma barra) será desconsiderado pelo compilador */

// Essas duas barras significam comentários no estilo C++. // Uma vez aberto, esse comentário não precisa ser fechado. // Mas ele só vale para a linha em que foi aberto, // a partir do ponto em que foi aberto // e até o final da linha nada mais será considerado

Comentários também podem ser úteis para tirar o efeito de determinadas partes de código, quando estamos fazendo experiências. Você já viu tal fato, nos exemplos que colocamos o código para apresentar a data ou a hora. Se você retirar as chaves de abertura e de fechamento, perceberá que o resultado do programa será diferente.

Abaixo apresentamos um exemplo de como podemos usar comentários para retirar efeitos de um código que já usamos anteriormente. Compile e execute para ver que o resultado do programa será outro:

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

// Label1 -> Caption = "Testando propriedades";

// Edit1->Text = "Continuando o teste

/* ListBox1->Items-> Add(Label1 -> Caption);

ListBox1->Items-> Add("Testando

ComboBox1 -> Text = "Fala, Grande!";

ComboBox1 -> Items -> Add(Label1 -> Caption);

ComboBox1 -> Items -> Add("Fala, Grande ComboBox1 -> Items -> Add(Edit1->Text);

}

");

";

"); */

Tipos fundamentais

A linguagem C++ possui tipos fundamentais de dados que representam valores como caracteres, inteiros, pontos flutuantes e booleanos. Os tipos inteiro (int) e pontos flutuantes (float e double) representam os números de um modo geral. Caracteres (char) representam as letras ou símbolos e o tipo booleano (bool) oscila entre dois valores, geralmente para representar duas situações inversas como, por exemplo, falso ou verdadeiro. Podemos, ainda, considerar um tipo básico de dados, o tipo enum, ou enumerados, o qual nos permite definir conjuntos de constantes, normalmente do tipo int, chamados tipos de dados enumerados. As variáveis declaradas deste tipo poderão adquirir somente entre os valores definidos.

Coloque um Memo e um Button no Form. No evento OnClick do botão digite:

void

fastcall

TForm1::BitBtn1Click(TObject *Sender)

{

char ValChar = 'a'; int ValInt = 100; float ValFloat = 100.78; // problemas na precisão double ValDoub = 9.9876543; bool ValBool = (2.0000 == (20 - 18)); //Verdade: dois = a vinte menos dezoito Memo1->Lines->Strings[0] = ValChar; // 1ª linha do Memo imprime: a

Memo1->Lines->Strings[1] = ValInt; // 2ª linha do Memo imprime: 100 Memo1->Lines->Strings[2] = ValFloat; // 3ª linha do Memo imprime: 100.78 Memo1->Lines->Strings[3] = ValDoub; // 4ª linha do Memo imprime: 9.9876543

// Se a afirmação feita na declaração de ValBool é verdadeira if( ValBool == True) /*5ª linha de Memo imprime: Afirmação Verdadeira*/ Memo1->Lines->Strings[4] = "Afirmação Verdadeira";

else // senão - ou seja, se a afirmação é falsa

/* Quinta linha de Memo imprime: Afirmação Mentirosa */ Memo1->Lines->Strings[4] = "Afirmação Mentirosa";

}

Nota: Se o programa acima não imprimir todas as linhas, pressione a tecla Enter alguma vezes para criar linhas vazias no Memo. Desta forma, as strings serão colocadas no espaço correto. Depois (no tópico Variáveis) veremos outra solução mais adequada para o problema!

A linguagem C++ ainda nos oferece um tipo especial que serve para indicar, justamente a ausência de

tipo: o void. No exemplo acima percebemos o uso deste tipo junto à função do evento chamado, indicando que tal função não devolverá nenhum valor. O void também será é usado em funções que não requerem parâmetros.

O tipo inteiro

O tipo inteiro é um número de valor inteiro, ou seja, não fracionário. De um modo geral, trata-se de

seqüências de dígitos que representam números inteiros, que podem ser escritos na base 8 (octal), na base 10 (decimal) ou na base 16 (hexadecimal).

Um inteiro decimal é formado pela seqüência de dígitos decimais: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Exemplos válidos para decimais são:

0 12345 1 - 89
0
12345
1
- 89

Os números a seguir não são exemplos válidos para decimais:

00 123.4 1,0 89-8 12 34 045
00
123.4
1,0
89-8
12 34
045

OBS. Embora alguns compiladores aceitem declarações do tipo:

int i = 123.4;

todos os números colocados depois do ponto fracionário (nesse caso, o 4) serão desconsiderados.

Um inteiro hexadecimal é formado pela seqüência de dígitos decimais: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 combinados com letras que vão de "A" a "F" (A, B, C, D, E, F ou a, b, c, d, e, f). Como não há regras que impeçam que um hexadecimal possua só valores decimais em sua composição, devemos diferenciá-los dos inteiros decimais inserindo 0x em seus primeiros dígitos. Exemplos válidos para hexadecimais são:

0x0 0x1234 0x1 0xA 0xaBcD 0x1A9F
0x0
0x1234
0x1
0xA
0xaBcD
0x1A9F

Os números a seguir não são válidos para valores hexadecimais:

00x 0x123.4 0x1,0 0xAGB OxaB cD FF12
00x
0x123.4
0x1,0
0xAGB
OxaB
cD
FF12

Um inteiro octal é formado pela seqüência de dígitos decimais: 0, 1, 2, 3, 4, 5, 6, 7. Devemos diferenciá- los dos inteiros decimais inserindo 0 em seu primeiro dígito. Exemplos válidos para octais são:

00

012345

01
01

- 056

Os números a seguir não são exemplos válidos para octais:

0 0123.4 01,0 089 012 34 45
0 0123.4
01,0
089
012 34
45

Via de regra, os dados inteiros são devolvidos pelo programa no formato decimal. Desta forma, podemos testar uma aplicação, onde colocaremos valores inteiros em vários formatos, porém os mesmos sempre serão exibidos em formato decimal. Você poderá testar valores válidos e valores não válidos para cada base de dados e visualizar os resultados.

Coloque um Label e um Button no Form. No evento OnClick do botão digite:

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

// declara um valor inteiro decimal cujo nome será i int i = 43; // podemos substituir o 43 por hexadecimais, //octais ou outros valores decimais

Label1 -> Caption = i; // coloca i no Caption de Label1

}

Compile e execute a aplicação. O Label imprimirá o número 43. Feche a aplicação e substitua o valor 43 (decimal) no Editor de Códigos por 0x2b (hexadecimal). Rode o programa e dê um clique no botão para ver o resultado. Agora faça a mesma experiência substituindo o 0x2b por 053 (octal). Se você fez tudo direitinho, qualquer dos testes que você executar deverá imprimir o número 43 no Label do Form. Isso porque esses valores são equivalentes. Baseando-se nas explicações introdutórias sobre esses valores inteiros e na tabela abaixo, faça mais alguns testes para compreender melhor o que ocorre a nível equivalência desses dados.

veja uma tabela inicial:

decimais

octais 00 01 02 03 04 05 06
octais
00
01
02
03
04
05
06

hexadecimais

0

0x0

1

0x1

2

0x2

3

0x3

4

0x4

5

0x5

6

0x6

7

07

0x7

8

010

0x8

9

0x9

10

0xA

11

0xB

12

0xC

13

0xD

14

0xE

15

0xF

16

0x10

17

0x11

18

0x12

19

0x13

20

0x14

21

0x15

22

0x16

23

0x17

24

0x18

25

0x19

26

0x1A

27

0x1B

28

0x1C

29

0x1D

30

0x1E

31

0x 1F

32

0x20

Tudo pode estar parecendo muito complicado, mas não se preocupe porque o uso de valores octais ou hexadecimais não é comum. Além do mais, no avançar do curso (ou talvez na seção de tutoriais), nós aprenderemos a construir uma calculadora que nos apresentará como resultado o valor de conversão entre esses dados. Por enquanto, contentemo-nos com a calculadora do Windows que pode realizar esse tipo de cálculos.

Os tipos ponto flutuante

De um modo geral, podemos afirmar que os tipos ponto flutuante são representados pelos números fracionários na base decimal. Ou seja, trata-se de números, de regra, constituídos por um ponto fracionário que não pode ser substituído por uma vírgula.

Um número de ponto flutuante pode apresentar-se na forma de notação científica. Por exemplo: 4.32 vezes dez elevado a quarta. Neste caso, o vezes dez ( X 10) é substituído por e ou E. Logo o número supramencionado será representado por 4.32e4, que vale 43200.

OBS. Embora o C++Builder aceite a notação científica para inteiros, todos os valores que estiverem situados após um eventual ponto fracionário, no resultado, serão desconsiderados.

Exemplos válidos para ponto flutuante são:

-1.e4 12.345 .1 1.23e-2 1.23E+2
-1.e4
12.345
.1
1.23e-2
1.23E+2

Não podemos colocar vírgulas para representar pontos flutuantes: 12,345 // ilegal.

Os números ponto flutuante se dividem basicamente nos tipos float e double. Posteriormente entenderemos melhor a que se referem esses nomes.

Eis um código para visualizarmos a matéria tratada neste tópico. Para executar esse código, precisaremos

de um Button e dois Label(s) no Form. De quebra, visualizaremos um problema de precisão com o tipo

float.

void

fastcall

TForm1::Button1Click(TObject *Sender)

{

float f = 3.65e-2; double d = 3.65e-2; Label1 -> Caption = f; // problemas de precisão com o tipo float

Label2 -> Caption = d;

}

O tipo caracter

O tipo caracter é uma letra ou um símbolo colocado entre aspas simples. Embora sejam visualizados

como letras ou símbolos, é importante ter em mente que, internamente, os computadores armazenam os caracteres como um número inteiro entre 0 e 255. Por exemplo, a letra a é associada ao número 97, b ao 98, c ao 99, d ao 100 e assim sucessivamente. Os valores numéricos dos caracteres estão padronizados em uma tabela chamada de American Standard Code for Information Interchange Table ou simplesmente tabela ASCII. Então concluímos que um char tanto pode ser interpretado como um número entre 0 e 255,

quanto pode ser interpretado como um elemento de um conjunto de caracteres da tabela ASCII. O tipo char geralmente tem um byte, o que é suficiente para conter os 256 valores mencionados.

Exemplos válidos para caracteres são: 'a' 'A' 'z' '5' '§' '%'
Exemplos válidos para caracteres são:
'a'
'A'
'z'
'5'
'§'
'%'
'
'
'*'

Seqüências de escape

Certos caracteres da tabela ASCII devem ser representados pela combinação especial de outros caracteres. Essas combinações, conhecidas como seqüência de escape, são representadas por uma barra invertida ( \ ) e outro caracter. Esse grupo de dois caracteres é interpretado como uma seqüência simples. Por exemplo, nós já usamos em exemplo anterior, o '\n' e o '\t'. Essas combinações são interpretadas como nova linha (Enter) e Tab, respectivamente.

Abaixo, representaremos algumas seqüências de escape:

Controle/Caracter

Sequencia de escape

Valor ASCII

nulo (null)

\0

00

campainha (bell)

\a

07

retrocesso (backspace)

\b

08

tabulacao horizontal

\t

09

nova linha (new line)

\n

10

tabulacao vertical

\v

11

alimentacao de folha (form feed)

\f

12

retorno de carro (carriage return)

\r

13

aspas (")

\"

34

apostrofo (')

\'

39

interrogacao (?)

\?

63

barra invertida (\)

\\

92

É bom notarmos que, embora alguns desses caracteres possam ser compilados sem a barra invertida ( \ )

em algumas aplicações pelo C++Builder (", ?), noutras a barra poderá fazer falta.

Coloque um Label no Form e no evento OnClick do Label digite:

void

fastcall

TForm1::Label1Click(TObject *Sender)

{

/*Declara uma variável int chamada StrInt e atribui a ela o valor que será digitado no InputBox pelo usuário*/ int StrInt = StrToInt /*converte AnsiString para int*/ (InputBox("Converte int para char","Digite um valor entre 0 e 255

",""));

Label1 -> Caption = char(StrInt)/*converte int(StrInt) para char*/;

}

Agora rode a aplicação e faça algumas experiências, dando um clique em Label para inserir valores entre

0 e 255 e visualizar a equivalência de valores entre os números e os elementos da tabela ASCII.

Modificadores de tipos

Podemos alterar o significado de um tipo básico de dados, adaptando-o a uma necessidade específica, por meio de modificadores de tipos precedendo os tipos na declaração:

signed (com sinal);

unsigned (sem sinal);

long (máxima precisão);

short (menor precisão).

Tipo

bytes

possíveis valores

char

1