curso básico c++

Curso básico de C++

DicasBCB

http://www.dicasbcb.com.br

Apostila de C++ Builder Pagina -2-

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:

28 = 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 (216) 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 (232) 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 minúsculas, como por exemplo: cout, cin, if, else, while, do ... while, for, switch ... 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.

É 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;

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;

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


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

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:

#pragma hdrstop


#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.

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ê 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 return

013 move o cursor para o início da linha

\t Horizontal Tab

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

\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: //---------------------------------------------------------------------------



{ /* 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: //---------------------------------------------------------------------------


{

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:


/* 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ê:


{

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

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

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

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

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 - 056

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

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 hexadecimais

0 00 0x0

1 01 0x1

2 02 0x2

3 03 0x3

4 04 0x4

5 05 0x5

6 06 0x6

7 07 0x7


8 010 0x8

9 011 0x9

10 012 0xA

11 013 0xB

12 014 0xC

13 015 0xD

14 016 0xE

15 017 0xF

16 020 0x10

17 021 0x11

18 022 0x12

19 023 0x13

20 024 0x14

21 025 0x15

22 026 0x16

23 027 0x17

24 030 0x18

25 031 0x19

26 032 0x1A

27 033 0x1B

28 034 0x1C

29 035 0x1D

30 036 0x1E

31 037 0x 1F

32 040 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

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' '§' '%' ' ' '*'

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 -128 a 127

unsigned char 1 0 a 255

signed char 1 -128 a 127

int 4 -2147483648 a 2147483647

unsigned int 4 0 a 4294967295

signed int 4 -2147483648 a 2147483647



short int 2 -32768 a 32767

unsigned short int 2 0 a 65535

signed short int 2 -32768 a 32767

long int 4 -2147483648 a 2147483647

signed long int 4 -2147483648 a 2147483647

unsigned long int 4 0 a 4294967295

float 4 -(3.4e38) a 3.4e38

double 8 1.7e308 a -(1.7e308)

long double 10 1.7e308 a -(1.7e308)

O exemplo a seguir usa um Edit, um Memo e um Button no Form. Quando o usuário dá um clique no botão, um loop começa a contar uma seqüência de valores numéricos de caracteres para a variável unsigned char c e só a encerra quando contar o último caracter, o de número 254. No corpo desse loop, nós declaramos uma variável do tipo char, que converterá os valores numéricos da variável c para os elementos correspondentes aos números na tabela ASCII, atribuindo esses valores a ch. Feito isso os valores obtidos serão imprimidos no Edit, exibindo as correspondências encontradas. Concomitantemente, quando o dedo do usuário deixa de fazer pressão com o mouse sobre o botão, configurando o evento OnMouseUp, o conteúdo do Edit (no caso os valores 0 a 254 da tabela ASCII e mais alguns caracteres para facilitar a visualização e a leitura) é adicionado a Memo1. void __fastcall TForm1::BitBtn1Click(TObject *Sender) { /* Declara e inicializa com 0 uma variável do tipo unsigned char dentro de um loop for; estabelece o limite de 254 para o loop; determina o incremento da variável. */ for(unsigned char c = 0; c < 255; c++) { /*Declara uma variável que converterá os números para o caracter da tabela ASCII*/ char ch = c;

/* Edit1 imprime os números, os caracteres correspondentes da tabela ASCII e mais alguns caracteres para facilitar a leitura*/ Edit1 -> Text = Edit1 -> Text + c + ' ' + '=' + ' ' + ch + ' ' + ' '; } }

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


void __fastcall TForm1::BitBtn1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { // Adiciona o conteúdo de Edit1 a Memo1 Memo1->Lines->Add(Edit1->Text); }

O exemplo acima pode ser modificado para exibir somente alguns caracteres ASCII. Por exemplo, após rodar a aplicação, o programa apresentará para você o número de cada caracter. Com base nestas informações, você poderá, facilmente, montar um programa que imprima somente as letras minúsculas do alfabeto etc.

Variáveis

Podemos entender um microcomputador como um sistema de cinco unidades de funcionamento: unidade de entrada (teclado, mouse, drive de CD-ROM, drive de disquetes etc), unidade de saída (impressora, monitor etc), unidade de memória (memória RAM -escrita e leitura-, memória ROM - leitura), e as unidades aritmética e lógica que se encontram agrupadas na CPU (Unidade Central de Processamento, o processador).

O chip responsável pelo controle de todo o computador é o processador. Outro circuito de extrema importância é a memória RAM, que podemos imaginar como um grupo de células usadas para armazenamento temporário das instruções e dos dados que são acessados e processados pelo microprocessador em altíssima velocidade. Trata de uma memória volátil pois seus dados perdem-se no momento em que são desligadas, o que não chega a ser um problema, visto que esses dados, de regra, após salvos, ficam guardados em algum disco de armazenamento permanente, como os discos rígidos ou os disquetes, sendo copiados novamente para a memória na ocasião de seu processamento.

A memória RAM é constituída por uma imensa seqüência de células de armazenamento (localizações) com o tamanho de oito bits (um byte) cada, o que permite que cada uma dessas localizações possa assumir um entre 256 valores diferentes. Ressalte-se, ainda, que cada célula possui um endereço único e inconfundível, expresso por um valor numérico que define a exata localização desse byte, bem como que, apesar do limitado tamanho de cada célula, podemos acessar dois bytes consecutivos (word) ou quatro bytes consecutivos (doubleword) simultaneamente com um único endereçamento.

Disso decorre que durante a execução de um programa, as instruções e os dados processados ficam armazenados na memória do computador. Cada informação é representada por certo grupo de bytes (char - 1 byte, float - 4 bytes, double - 8 bytes etc) e possui um local determinado na memória, um endereço que pode ser expressado por um valor hexadecimal. Não há necessidade de o programador conhecer o endereço absoluto de cada dado, pois o compilador relaciona o nome de cada variável com sua posição na memória, cuidando dessa tarefa da melhor maneira possível.

Para facilitar o entendimento, podemos imaginar a memória do computador como um enorme armário de gavetas. Cada gaveta (célula de armazenamento) é numerada seqüencialmente e possui o tamanho de 1 byte. Esse número seqüencial é o endereço da gaveta. Conforme o tipo de variável declarada (char = 1


byte; int = 4 bytes; float = 4 bytes; etc), o compilador reservará uma ou mais gavetas seqüencialmente para armazenar o valor correspondente, pois cada tipo de dado possui um tamanho próprio.

Imagine um armário imenso, com um milhões de gavetas iguais. Seria demasiadamente complicado localizar determinado objeto numa dessas gavetas se não possuíssemos uma forma de diferenciá-las entre si. Então, o nome da variável funciona como uma inscrição que individualiza a gaveta (endereço na memória).

Por exemplo, a declaração:

long double LgDbl;

informa ao compilador que ele deverá reservar 10 bytes seqüenciais (dez gavetas dispostas em seqüência) para uma variável do tipo long double cujo nome é LgDbl. Observe que as "gavetas" estão reservadas, porém nenhum "objeto" foi colocado nelas.

Um ponto bastante importante sobre o tamanho das variáveis é que seu tamanho pode variar de máquina para máquina, ou sistema operacional para sistema operacional. O tipo int, por exemplo, ocupa 2 bytes no sistema operacional MS-DOS e 4 bytes no Windows.

Com esses conceitos, já temos informações suficientes para entender o que vem a ser uma variável. Podemos definir uma variável como um local na memória do computador que a cada momento pode possuir um valor diferente, porém do mesmo tipo de dados.

Por exemplo, a declaração:

char ch;

faz com que o compilador reserve espaço suficiente para um caracter. Já a declaração abaixo é um pouco mais completa, pois inicializa a variável, colocando um caracter A no espaço reservado:

char ch = 'A';

O conceito de variáveis decorre justamente do fato de que podemos substituir o "conteúdo" dessas "gavetas":

ch = 'b'; // ch agora possui outro valor

O exemplo a seguir usa um SpeedButton no Form. Declararemos uma variável do tipo char num lugar onde ela será visível tanto pelo evento OnMouseDown quanto pelo evento OnMouseUp de SpeedButton1. Quando o botão do mouse for pressionado sobre o botão, o evento OnMouseDown será


ativado para atribuir o caracter A à variável ch, exibindo esse valor no Caption de SpeedButton1. Quando o botão do mouse for liberado, o evento OnMouseUp será ativado para alterar o valor da variável para b, exibindo esse valor no Caption de SpeedButton1. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- // declara uma variável char visível pelos eventos de SpeedButton1 char ch; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::SpeedButton1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { ch = 'A'; // atribui A para a variável ch SpeedButton1 -> Caption = ch; } //---------------------------------------------------------------------------

void __fastcall TForm1::SpeedButton1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { ch = 'b'; // atribui b para a variável ch SpeedButton1 -> Caption = ch; } //---------------------------------------------------------------------------

O C++Builder implementa a função sizeof() que nos permite visualizar o tamanho, em bytes, de uma variável ou de um tipo de dados:

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

void __fastcall TForm1::Button1Click(TObject *Sender) {

double Dbl; Edit1 -> Text = AnsiString(sizeof(Dbl)) + " bytes"; // retorna pelo nome da variável /* retorna o valor pelo tipo de dados*/ Edit2 -> Text = AnsiString(sizeof(bool)) + " byte"; RichEdit1 -> Clear(); // apaga o conteúdo de RichEdit1 for (int linha = 0; linha <= 3; linha ++) // Em breve estudadremos o loop for


RichEdit1 -> Lines -> Insert(linha, ""); // prepara RichEdit1 para receber // as quatro linhas de strings RichEdit1 -> Lines-> Strings[0] = "Tamanho de char = " + String(sizeof(char)); RichEdit1 -> Lines-> Strings[1] = "Tamanho de int = " + String(sizeof(int)); RichEdit1 -> Lines-> Strings[2] = "Tamanho de String = " + String(sizeof(String)); RichEdit1 -> Lines-> Strings[3] = "Tamanho de AnsiString = " + AnsiString(sizeof(AnsiString)); ShowMessage(sizeof(long double));

} //---------------------------------------------------------------------------

Atribuição de valores a variáveis

Conforme você já deve ter percebido, para criarmos uma variável, precisamos declarar o seu tipo (char, int, float, ...), seguido pelo nome da variável e por um símbolo de ponto e vírgula:

int i;

Com o operador de atribuição = atribuímos valores às variáveis:

i = 43;

Nada impede que, no momento da declaração, também inicializemos a variável com algum valor:

int i = 43;

Podemos, inclusive, declarar mais de uma variável na mesma instrução, bem como misturar declarações com inicializações:

// declararamos 5 variáveis das quais inicializamos duas (i3 e i4) int i, i2, i3 = 10, i4 = 15, i5;

O nome de uma variável deve ser sugestionável, nos indicando o tipo de dados com o qual ela trabalhará. Por exemplo, suponhamos um problema onde será calculada a área de um retângulo de 10 metros de comprimento por 7 metros de largura. Poderíamos definir as variáveis assim:

int compr = 10; int larg = 7; int total = compr * larg; // atribui o resultado da multiplicação a total


Existem algumas regras que devem ser respeitadas: Os nomes das variáveis só podem começar com letras (a, A, b, B, c, C, d, D, e, E, f, ...) ou por caracter de sublinhar ( _ ); depois de começado o nome, podemos colocar letras, números ou caracter de sublinhar no nome:

int i, i1, i_, _i, _2, i_2 ; // Ok. Todas as variáveis possuem nomes aceitáveis float 7_i; // nome inválido, pois começa com número char _AF$G; // nome inválido - caracter ilegal $

Coloque um botão BitBtn no Form sem alterar-lhe o tamanho. O exemplo exibirá o valor área do botão que será ampliada a cada clique do mouse. Eis o código: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- int altr = 25, larg = 75; // declara e inicializa duas variáveis globais //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { /* O código deste bloco será executado imediatamente (e somente) quando o aplicativo for inicializado*/ int total = altr * larg; // declara e inicializa uma variável local

/*Coloca no caption de BitBtn1 o título Área =, mais o valor da variável total convertido em AnsiString*/ BitBtn1 -> Caption = "Área = " + AnsiString(total); } //--------------------------------------------------------------------------- void __fastcall TForm1::BitBtn1Click(TObject *Sender) { altr = altr + 10; //incrementa a variável altr com + 10, alterando-lhe o valor larg = larg + 30; //incrementa a variável larg com + 30, alterando-lhe o valor BitBtn1 -> Height = altr; //atribui a BitBtn1 -> Height o novo valor de altr; BitBtn1 -> Width = larg; //atribui a BitBtn1 -> Width o novo valor de larg;

//atualiza o Caption de BitBtn1 BitBtn1 -> Caption = "Área = " + AnsiString(altr * larg); } //---------------------------------------------------------------------------

Nota: No exemplo acima, essa não é a melhor forma de se conseguir o resultado, pois o exemplo foi apenas didático para ilustrar a declaração, a inicialização e a substituição de valores em variáveis. Como exercício, procure conseguir o mesmo resultado sem declarar nenhuma variável, o que poupará memória durante a execução do programa. Você já possui conhecimentos suficientes para tanto!


Variáveis signed e unsigned

(com e sem sinal)

Quando tratamos dos modificadores de tipos, tivemos oportunidade de observar que em C++ os tipos char e int possuem as variedades signed (com sinal) e unsigned (sem sinal). Tais modificadores permitem-nos filtrar alguns valores que poderão ser desnecessários para determinados tipos de aplicação, como por exemplo os números negativos, ou os valores estendidos da tabela ASCII. Os tipos inteiros (int, short e long) e os char, de regra, podem armazenar valores positivos ou negativos. Todavia se declarados com o modificador de tipos unsigned, ficarão restritos a números iguais ou maiores do que zero.

A tabela abaixo exibe os valores possíveis para os tipos de dados, com ou sem os modificadores de tipo:


char 1 -128 a 127

unsigned char 1 0 a 255

signed char 1 -128 a 127

int 4 -2147483648 a 2147483647

unsigned int 4 0 a 4294967295

signed int 4 -2147483648 a 2147483647

short int 2 -32768 a 32767

unsigned short int 2 0 a 65535

signed short int 2 -32768 a 32767

long int 4 -2147483648 a 2147483647

signed long int 4 -2147483648 a 2147483647

unsigned long int 4 0 a 4294967295

Observe que o tipo não tem o seu tamanho alterado (número de bytes) em virtude da presença dos modificadores signed ou unsigned. O resultado direto desse fato é que, para um mesmo tipo de dados, o valor máximo que pode ser atribuído a um unsigned é o dobro do maior valor positivo que pode ser atribuído a um signed.

O programa abaixo mostra-nos alguns limites de valores:


void __fastcall TForm1::SpeedButton1Click(TObject *Sender) { for (char ch = -126; ch > -127; ch++) Memo1->Lines->Add(ch); Memo1 -> Lines -> Add("");

for (signed char Sch = 1 ;Sch > 0; Sch++) Memo1->Lines->Add(Sch); Memo1 -> Lines -> Add("");

for (unsigned char Uch = -1000; Uch > 0; Uch++) Memo1->Lines->Add(Uch); Memo1 -> Lines -> Add("");

for (int i = 2147483600; i > 0; i++) Memo1->Lines->Add(i); Memo1 -> Lines -> Add("");

for (unsigned int ui = 4294967200; ui > 0; ui++) Memo1->Lines->Add(ui); Memo1 -> Lines -> Add("");

for (signed short int SSi = 32768; SSi < -32000; SSi++) Memo1->Lines->Add(SSi);

}

Excedendo o limite de uma variável

Se tentarmos atribuir um valor fora da faixa que a variável pode conter, ela continuará a partir do zero, se for unsigned; porém, se for do tipo signed, continuará a armazenar dados a partir do menor valor negativo.

O Exemplo abaixo leva um SpeedButton e um ComboBox no Form. Quando o usuário clicar o botão, o programa mostrará o resultado de se tentar atribuir valores não contemplados pela variável. //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { ComboBox1 -> Text = "Excedendo limites de variáveis ..."; } //--------------------------------------------------------------------------- void __fastcall TForm1::SpeedButton1Click(TObject *Sender) { ComboBox1 -> Text = "Veja abaixo os novos valores ...";

int i = 2147483647; ComboBox1 -> Items -> Add("Limite para int = " + String(i)); ComboBox1 -> Items -> Add("Limite + 1 = " + String(i + 1)); ComboBox1 -> Items -> Add("Limite + 2 = " + String(i + 2)); ComboBox1 -> Items -> Add("");

unsigned int Ui = 4294967295; ComboBox1 -> Items -> Add("Limite para unsigned int = " + String(Ui)); ComboBox1 -> Items -> Add("Limite + 1 = " + String(Ui + 1)); ComboBox1 -> Items -> Add("Limite + 2 = " + String(Ui + 2));


ComboBox1 -> Items -> Add("");

signed int Si = 2147483647; ComboBox1 -> Items -> Add("Limite para signed int = " + String(Si)); ComboBox1 -> Items -> Add("Limite + 1 = " + String(Si + 1)); ComboBox1 -> Items -> Add("Limite + 2 = " + String(Si + 2)); ComboBox1 -> Items -> Add("");

char ch = 127; ComboBox1 -> Items -> Add("Limite para char = " + String(int(char(ch)))); ComboBox1 -> Items -> Add("Limite + 1 = " + String(int(char(ch + 1)))); ComboBox1 -> Items -> Add("Limite + 2 = " + String(int(char(ch + 2)))); ComboBox1 -> Items -> Add("");

signed char Sch = 127; ComboBox1 -> Items -> Add("Limite para signed char = " + String (Sch)); ComboBox1 -> Items -> Add("Limite + 1 = " + String(int(char(Sch + 1)))); ComboBox1 -> Items -> Add("Limite + 2 = " + String(int(char(Sch + 2)))); ComboBox1 -> Items -> Add("");

unsigned char Uch = 255; ComboBox1 -> Items -> Add("Limite para unsigned char = " + String (Uch)); ComboBox1 -> Items -> Add("Limite + 1 = " + String(int(char(Uch + 1)))); ComboBox1 -> Items -> Add("Limite + 2 = " + String(int(char(Uch + 2)))); ComboBox1 -> Items -> Add("");

} //---------------------------------------------------------------------------

Operações matemáticas com unsigned

Já sabemos que uma variável unsigned não pode ser atribuída com valores negativos. Se, numa operação matemática, tivermos um resultado menor do que zero para uma variável unsigned, no momento em que o cálculo atingir o primeiro valor negativo (-1) a operação é remetida para o maior valor do tipo do dado, de onde o programa dará continuidade aos cálculos com os valores restantes.

O exemplo a seguir usa um Label e um Timer no Form. São declaradas duas variáveis globais do tipo unsigned int, sendo que uma funcionará como base do cálculo da subtração e a outra como valor a ser subtraído. O Label ficará piscando no Form, ou melhor, o Timer fará com que o Label fique visível e depois de alguns instantes invisível, e depois visível, e depois invisível e assim sucessivamente. Ajustamos o intervalo de tempo para 500, mas você pode alterar o valor para mais ou menos, no Code Editor ou no Object Inspector. Haverá um decremento (diminuição do valor em razão de 1) do número apresentado no Label, a cada piscada. Ou seja, o primeiro valor apresentado será 10; o segundo, 9; o terceiro, 7; e assim por diante. Observe bem o que acontecerá depois que 0 (zero) for apresentado no Label, onde, equivocadamente, poderíamos estar esperando algum valor negativo:


//--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //---------------------------------------------------------------------------

unsigned int uiBase = 9; /* declara e inicializa a variável base (observe que poderia ser uma constante)*/ unsigned int uiAcresce = 1; /* declara e inicializa a variável que será incrementada na subtração */ //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender) {

if (Label1->Visible == true) // se label estiver visivel { Label1->Visible=false; // Label1 ficará invisível /* e altera-se o Caption de Label1, com o resultado da subtração, cada vez que ele ficar invisível*/ Label1 -> Caption = uiBase - uiAcresce; /* incrementa a variável uiAcresce (ela vale 1, depois 2, depois 3, 4, 5, etc)*/ uiAcresce = uiAcresce + 1; } else // ou então ( se Label1 estiver invisível) Label1->Visible=true; // Label1 ficará visível

} //---------------------------------------------------------------------------

AnsiString

O C++Builder implementa o tipo AnsiString como uma classe. AnsiString é projetado para funcionar como o tipo long string Delphi. Adequadamente, AnsiString fornece as seguintes características de tratamento de strings que são requeridas quando você chama funções do tipo VCL que usam qualquer tipo long string Delphi:

• reference count

• string length


• data

• null string terminator

Se você não fornecer um valor inicial, as variáveis AnsiString são iniciadas com instância zero.

Podemos conceituar uma string como um caracter, ou uma seqüência de caracteres colocados entre aspas duplas: "Alô, Thérbio!"

"Guarulhos é a terra das Pizzarias..."

"Oba!"

"ô"

A classe AnsiString possui um bom nível de independência e flexibilidade nos controles onde é usada, uma vez que não é descendente de Tobject, permitindo-nos realizar diversas operações úteis com strings. A implementação desse arquivo pode ser visualizada no diretório include/vcl/dstring.h da pasta de instalação de seu compilador: #ifndef DSTRING_H #define DSTRING_H

#pragma delphiheader begin

#include <sysmac.h>

namespace System { class TVarRec; class RTL_DELPHIRETURN Currency; class RTL_DELPHIRETURN WideString;

///////////////////////////////////////////////////////////////////////////// // AnsiString: String class compatible with Delphi's Native 'string' type ///////////////////////////////////////////////////////////////////////////// class RTL_DELPHIRETURN AnsiString { friend AnsiString __fastcall operator +(const char*, const AnsiString& rhs); public: // the TStringFloatFormat enum is used by FloatToStrF enum TStringFloatFormat {sffGeneral, sffExponent, sffFixed, sffNumber, sffCurrency}; static AnsiString __fastcall StringOfChar(char ch, int count); static AnsiString __fastcall LoadStr(int ident); static AnsiString __fastcall LoadStr(HINSTANCE hInstance, int ident); static AnsiString __fastcall FmtLoadStr(int ident, const TVarRec *args, int size); AnsiString& __fastcall LoadString(HINSTANCE hInstance, int ident); // Delphi style 'Format' // static AnsiString __fastcall Format(const AnsiString& format, const TVarRec *args, int size);


// C++ style 'sprintf' (NOTE: Target buffer is the string) // AnsiString& __cdecl sprintf(const char* format, ...); // Returns *this int __cdecl printf(const char* format, ...); // Returns formatted length

static AnsiString __fastcall FormatFloat(const AnsiString& format, const long double& value); static AnsiString __fastcall FloatToStrF(long double value, TStringFloatFormat format, int precision, int digits); static AnsiString __fastcall IntToHex(int value, int digits); static AnsiString __fastcall CurrToStr(Currency value); static AnsiString __fastcall CurrToStrF(Currency value, TStringFloatFormat format, int digits); // Constructors __fastcall AnsiString(): Data(0) {} __fastcall AnsiString(const char* src); __fastcall AnsiString(const AnsiString& src); // __fastcall AnsiString(const char* src, unsigned char len); __fastcall AnsiString(const char* src, unsigned int len); __fastcall AnsiString(const wchar_t* src); __fastcall AnsiString(char src); __fastcall AnsiString(short); __fastcall AnsiString(unsigned short); __fastcall AnsiString(int src); __fastcall AnsiString(unsigned int); __fastcall AnsiString(long); __fastcall AnsiString(unsigned long); __fastcall AnsiString(__int64); __fastcall AnsiString(unsigned __int64); __fastcall AnsiString(double src); __fastcall AnsiString(const WideString &src);

// Destructor __fastcall ~AnsiString();

// Assignments AnsiString& __fastcall operator =(const AnsiString& rhs); AnsiString& __fastcall operator +=(const AnsiString& rhs);

// Comparisons bool __fastcall operator ==(const AnsiString& rhs) const; bool __fastcall operator !=(const AnsiString& rhs) const; bool __fastcall operator <(const AnsiString& rhs) const; bool __fastcall operator >(const AnsiString& rhs) const; bool __fastcall operator <=(const AnsiString& rhs) const; bool __fastcall operator >=(const AnsiString& rhs) const; int __fastcall AnsiCompare(const AnsiString& rhs) const; int __fastcall AnsiCompareIC(const AnsiString& rhs) const; //ignorecase

// Accessing character at specified index

char __fastcall operator [](const int idx) const { ThrowIfOutOfRange(idx); // Should Range-checking be optional to avoid overhead ?? return Data[idx-1]; }


#if defined(ANSISTRING_USE_PROXY_FOR_SUBSCRIPT) // The use of a proxy class optimizes the case where Unique() must be called // when accessing the string via the subscript operator. However, the use of // of the proxy class has some drawbacks. First, it breaks code that apply // operators to the return value. For example, &MyString[i]. Second, it // fails in cases where a implicit conversion was relied upon. For example, // callFuncThatTakesAnObjectWithACharCtr(MyString[i]); // In that case, two implicit conversions would be required... // The first issue can be remedied by enhancing the proxy class to support // all valid operators. The second issue can be lessened but not completely // eliminated. Hence, the use of the PROXY class is not the default! // private: class TCharProxy; friend TCharProxy; class TCharProxy { public: TCharProxy(AnsiString& strRef, int index) : m_Ref(strRef), m_Index(index) {} TCharProxy& operator=(char c) { m_Ref.Unique(); m_Ref.Data[m_Index-1] = c; return *this; } operator char() const { return m_Ref.Data[m_Index-1]; }

protected: AnsiString& m_Ref; int m_Index; };

public: TCharProxy __fastcall operator [](const int idx) { ThrowIfOutOfRange(idx); // Should Range-checking be optional to avoid overhead ?? return TCharProxy(*this, idx); }

#else

char& __fastcall operator [](const int idx) { ThrowIfOutOfRange(idx); // Should Range-checking be optional to avoid overhead ?? Unique(); // Ensure we're not ref-counted return Data[idx-1]; }

#endif

// Concatenation AnsiString __fastcall operator +(const AnsiString& rhs) const;

// C string operator char* __fastcall c_str() const { return (Data)? Data: "";}

// Query attributes of string int __fastcall Length() const; bool __fastcall IsEmpty() const;

// Make string unique (refcnt == 1)


AnsiString& __fastcall Unique();

// Modify string AnsiString& __fastcall Insert(const AnsiString& str, int index); AnsiString& __fastcall Delete(int index, int count); AnsiString& __fastcall SetLength(int newLength);

int __fastcall Pos(const AnsiString& subStr) const; AnsiString __fastcall LowerCase() const; AnsiString __fastcall UpperCase() const; AnsiString __fastcall Trim() const; AnsiString __fastcall TrimLeft() const; AnsiString __fastcall TrimRight() const; AnsiString __fastcall SubString(int index, int count) const;

int __fastcall ToInt() const; int __fastcall ToIntDef(int defaultValue) const; double __fastcall ToDouble() const;

// Convert to Unicode int __fastcall WideCharBufSize() const; wchar_t* __fastcall WideChar(wchar_t* dest, int destSize) const;

// MBCS support enum TStringMbcsByteType {mbSingleByte, mbLeadByte, mbTrailByte};

TStringMbcsByteType __fastcall ByteType(int index) const; bool __fastcall IsLeadByte(int index) const; bool __fastcall IsTrailByte(int index) const; bool __fastcall IsDelimiter(const AnsiString& delimiters, int index) const; bool __fastcall IsPathDelimiter(int index) const; int __fastcall LastDelimiter(const AnsiString& delimiters) const; int __fastcall AnsiPos(const AnsiString& subStr) const; char* __fastcall AnsiLastChar() const;

protected: void ThrowIfOutOfRange(int idx) const;

private: char *Data; };

extern AnsiString __fastcall operator +(const char*, const AnsiString& rhs);

#if defined(VCL_IOSTREAM) ostream& operator << (ostream& os, const AnsiString& arg); istream& operator >> (istream& is, AnsiString& arg); #endif

///////////////////////////////////////////////////////////////////////////// // SmallStringBase ///////////////////////////////////////////////////////////////////////////// template <unsigned char sz> class SmallStringBase { protected:


unsigned char Len; char Data[sz]; };

///////////////////////////////////////////////////////////////////////////// // SmallString ///////////////////////////////////////////////////////////////////////////// template <unsigned char sz> class SmallString : SmallStringBase<sz> {

#if defined(VCL_IOSTREAM) friend ostream& operator <<(ostream& os, const SmallString& arg) { os << AnsiString(arg); return os; } friend istream& operator >>(istream& is, SmallString& arg) { AnsiString s; is >> s; arg = s; return is; } #endif

public: __fastcall SmallString() { Len = 0; } __fastcall SmallString(const SmallString& src); __fastcall SmallString(const char* src);

__fastcall SmallString(const AnsiString& src) { long len = src.Length(); Len = (unsigned char)((len > sz)? sz: len); strncpy(Data, src.c_str(), Len); }

char& __fastcall operator [](const unsigned char idx) {return Data[idx-1];}

SmallString& __fastcall operator =(const SmallString& rhs);

__fastcall operator AnsiString() const; };

// used when SmallStrings are in unions (can't have a ctor) // must cast DummySmallString to SmallString to do anything useful

template<unsigned char sz> __fastcall SmallString<sz>::SmallString(const char* src) { long len = strlen(src); Len = (unsigned char)((len > sz)? sz: len); strncpy(Data, src, Len); }


template<unsigned char sz> __fastcall SmallString<sz>::SmallString(const SmallString& src) { Len = src.Len; for (int i = 0; i < Len; i++) Data[i] = src.Data[i]; }

template<unsigned char sz> SmallString<sz>& __fastcall SmallString<sz>::operator =(const SmallString& rhs) { if (this != &rhs) { Len = rhs.Len; for (int i = 0; i < Len; i++) Data[i] = rhs.Data[i]; } return *this; }

template<unsigned char sz> inline __fastcall SmallString<sz>::operator AnsiString() const { return AnsiString(Data, Len); } } using namespace System;

// The following is provided for backward compatibility. // Otherwise, the new IntToStr(__int64) causes ambiguity for old code // that used 'bool', uint and DWORD. // namespace Sysutils { extern PACKAGE AnsiString __fastcall IntToStr(int Value)/* overload */; extern PACKAGE AnsiString __fastcall IntToStr(__int64 Value)/* overload */; }

#pragma option push -w-inl

inline AnsiString __fastcall IntToStr(bool value) { return Sysutils::IntToStr(int(value)); } inline AnsiString __fastcall IntToStr(unsigned int value) { return Sysutils::IntToStr(int(value)); } inline AnsiString __fastcall IntToStr(unsigned long value) { return Sysutils::IntToStr(int(value)); }

#pragma option pop

#pragma delphiheader end. #endif // DSTRING_H


Por enquanto não tente entender os fundamentos deste arquivo, pois nele aparecem muitos termos que nos são novidades ainda. No avançar do curso, muitos desses fundamentos serão abordados, tornando a compreensão de partes do arquivo mais ou menos intuitiva.

Todavia, vamos verificar alguns tópicos, por dois motivos:

1º - É importante que tenhamos conhecimento de determinadas facilidades que AnsiString nos proporciona;

2º - aprendermos a operar determinadas funções da classe, por intuição.

Nota: Caption é o rótulo que pode ser estampado no componente, suportando mudanças em tempo de execução. Controles que exibem textos, fazem-no através da propriedade Caption ou da propriedade Text. A propriedade a ser usada dependerá do tipo do controle. De um modo geral, Caption é usado por textos que aparecem como títulos de uma janela ou um rótulo (estampa), enquanto Text é usado por textos que aparecem como conteúdo de um controle. Via de regra, Text podem ser editados pelo usuário, enquanto Caption é uma propriedade que não recebe o foco da aplicação, tendo como característica a finalidade básica de enviar uma informação ao usuário.

Muitos controles usam propriedades da classe AnsiString. Por exemplo, todos os controles que possuem rótulo (forms, edits, panels, labels) usam AnsiString através da propriedade Caption. Outros controles como o EditBox usam a classe AnsiString como base de seus textos (propriedade Text). Se repararmos bem, notaremos que nós já temos usado e implementado objetos AnsiString sem qualquer espécie de declaração. Em outra situação qualquer, a declaração e inicialização de uma string sempre será necessária antes do uso respectivo.

A declaração de uma String é análoga à declaração de um tipo básico, porém usando a palavra AnsiString seguida de um nome válido C++. Eis um exemplo:

AnsiString Pais;

Em dstring.h podemos observar que AnsiString é uma classe com seu próprio construtor e destruidor: // Constructors __fastcall AnsiString(): Data(0) {} __fastcall AnsiString(const char* src); __fastcall AnsiString(const AnsiString& src); // __fastcall AnsiString(const char* src, unsigned char len); __fastcall AnsiString(const char* src, unsigned int len); __fastcall AnsiString(const wchar_t* src); __fastcall AnsiString(char src); __fastcall AnsiString(short); __fastcall AnsiString(unsigned short); __fastcall AnsiString(int src);


__fastcall AnsiString(unsigned int); __fastcall AnsiString(long); __fastcall AnsiString(unsigned long); __fastcall AnsiString(__int64); __fastcall AnsiString(unsigned __int64); __fastcall AnsiString(double src); __fastcall AnsiString(const WideString &src);

// Destructor __fastcall ~AnsiString();

Logo você também pode declarar uma variável dela com parênteses vazios, determinando a chamada do construtor da classe. Eis um exemplo:

AnsiString Animal();

Há dois modos principais para você iniciar uma variável AnsiString. Depois de declará-la, pode-se determinar o valor desejado para a variável usando o nome escolhido. Eis um exemplo: AnsiString Especie; Especie = "Cachorro";

também podemos, tal qual nos tipos básicos, inicializar a variável String na sua declaração, fornecendo o valor desejado para o nome escolhido. Eis um exemplo:

AnsiString Raca("Pastor Alemão");

Uma vez definida, a String poderá ser usada, por exemplo, para alterar o Caption de controles: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Meu_Cao; Meu_Cao = " O Tobby é um vira-lata, que só sabe latir, latir e latir..."; Label1->Caption = Meu_Cao; } //---------------------------------------------------------------------------

Também poderá ser usada para preencher um controle Edit: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Pre_Hist = "Tiranossauro ou 286???"; Edit1->Text = Pre_Hist; } //---------------------------------------------------------------------------

Um texto introduzido num Edit box, por exemplo, é, por padrão, considerado uma String, visto que o compilador não pode deduzir que espécie de dado ou valor o usuário deseja manipular. Por essa razão,


depois que um valor foi fornecido para um controle que fundamenta-se na classe AnsiString como base de seu conteúdo, para executar qualquer operação matemática com tal String, devemos convertê-la para o tipo de dado desejado. Para essa finalidade podemos, por exemplo, usar a função StrToInt(): void __fastcall TForm1::Button1Click(TObject *Sender) { Label1->Caption = "111"; int i = StrToInt(Label1->Caption) - 11; Edit1->Text = i; }

Conforme apresentado, a classe AnsiString provê um grande número de construtores que nos permitem a criação de strings de qualquer espécie:

Por exemplo, podemos usar:

um caracter: AnsiString Simbolo = 'T';

um inteiro AnsiString Int = 120;

um long int AnsiString LongoInt = -73495745;

um valor ponto flutuante: AnsiString PtoFlut = 675.15;

Um double: AnsiString DplPrec = 2.15e28;

um string AnsiString AloTher = "Alô, Thérbio";

Qualquer dessas variáveis pode ser declarada usando os construtores equivalentes: //--------------------------------------------------------------------------- AnsiString Simbolo('T'); AnsiString Int(120); AnsiString AloTher("Alô, Thérbio"); AnsiString PtoFlut(675.15); AnsiString LongoInt(-73495745); AnsiString DplPrec(2.15e28); //---------------------------------------------------------------------------

Baseado na configuração dos construtores AnsiString, podemos converter qualquer valor e torná-lo disponível para um controle que use as propriedades AnsiString. Por exemplo, podemos converter e exibir:


um caracter: char Letra = 't'; Edit1 -> Text = AnsiString(Letra);

um inteiro:

Integer Numero = 256; Edit1->Text = AnsiString(Numero);

um long integer: long Valor = 4949431; Panel1->Caption = AnsiString(Valor);

um valor ponto flutuante: Single Distancia = 5698.03; Label1->Caption = AnsiString(Distancia);

um double: Double Tamanho = 24588; Edit1->Text = AnsiString(Tamanho);

uma string AnsiString Servico = "Limpador de Fogões";

Button2->Caption = AnsiString(Servico);

Nota: Você deve ter notado o uso de nomes de tipos diferentes dos apresentados anteriormente.

Por exemplo:

chamamos o tipo int de Integer, o tipo float de Single; o tipo double de Double ...

Por que será?

No início do arquivo dstring.h vemos a inclusão do arquivo de cabeçalho sysmac.h:

#include <sysmac.h>

NOTA: Logo abordaremos o uso da palavra typedef para criar outro nome para um tipo de dados:

Vejamos um trecho do arquivo sysmac.h:

class PACKAGE TVarArray;


typedef TVarArray *PVarArray;

typedef bool Boolean; //

typedef int Integer; // -2147483648..2147484647

typedef char Char; // 0..255

typedef wchar_t WideChar; // Unicode character

typedef signed char Shortint; // -128..127

typedef short Smallint; // -32768..32767

typedef unsigned char Byte; // 0..255

typedef unsigned short Word; // 0..65535

typedef unsigned long DWord; // 0..4294967295

typedef void* Pointer; //

typedef char AnsiChar; //

typedef signed long Longint; // -2147483648..2147484647

typedef unsigned int Cardinal; // 0..2147484647

typedef long double Extended; // 10 byte real

typedef float Single; // 4 byte real

typedef double Double; // 8 byte real

typedef char* const Openstring; // D16 string/D32 shortstring formalparm

typedef void* file; //

typedef void* Text; //

typedef Text TextFile; //

typedef char* PChar; //

typedef char* PAnsiChar; //

typedef wchar_t* PWideChar; //

typedef unsigned char ByteBool; //


typedef unsigned short WordBool; //

typedef Cardinal LongBool; //

typedef AnsiString String; //

typedef SmallStringBase<255> ShortStringBase; //

typedef SmallString<255> ShortString; //

typedef ShortString* PShortString; //

typedef AnsiString* PAnsiString; //

typedef PAnsiString PString; //

typedef WideString* PWideString; //

typedef Extended* PExtended; //

typedef Currency* PCurrency; //

typedef Variant* PVariant; //

typedef __int64 LONG64; // !! obsolete

typedef GUID TGUID; //

typedef TGUID* PGUID; //

typedef HRESULT HResult; //

typedef Integer __fastcall (*TThreadFunc)(Pointer Parameter);

typedef void (*TModuleUnloadProc)(HINSTANCE hinstance);

typedef bool (*TEnumModuleFunc)(HINSTANCE hinstance, void *data);

typedef struct TVarData *PVarData;

Os nomes à direita representam os sinônimos que podem ser usados em substituição aos tipos básicos. Por exemplo, Boolean pode ser usado em substituição ao tipo bool.

Nas próximas lições abordaremos várias implementações de AnsiString.


Nota: voltamos a insistir para que você não se preocupe quando se deparar com nomes de tipos de dados ainda não estudados (como classe, por exemplo) visto que no momento apropriado do curso abordaremos tais tópicos com a profundidade necessária.

Funções que modificam strings

Agora conheceremos algumas implementações do tipo AnsiString. Embora tenhamos, para facilidade de compreensão, nos referido às instâncias de classes como variáveis, tecnicamente isso está incorreto. Na verdade, a instância de uma classe (AnsiString, por exemplo) é denominada objeto. E os objetos possuem funções-membro que facilitam sua manipulação. Essas funções-membro podem ser acessadas através do operador ponto “.”.

Vejamos alguma funções-membro utilizadas para modificar strings.

// Modify string AnsiString& __fastcall Insert(const AnsiString& str, int index); AnsiString& __fastcall Delete(int index, int count); AnsiString& __fastcall SetLength(int newLength);

int __fastcall Pos(const AnsiString& subStr) const; AnsiString __fastcall LowerCase() const; AnsiString __fastcall UpperCase() const; AnsiString __fastcall Trim() const; AnsiString __fastcall TrimLeft() const; AnsiString __fastcall TrimRight() const; AnsiString __fastcall SubString(int index, int count) const;

Insert()

AnsiString& __fastcall Insert(const AnsiString& str, int index);

insere uma string especificada dentro de AnsiString, iniciando a inserção na posição determinada pela variável index.

O exemplo abaixo leva um Label no Form. Quando o usuário dá um clique no Label, o programa providencia a inserção de uma string dentro de outra.

void __fastcall TForm1::Label1Click(TObject *Sender) { AnsiString test = "O_ _está_feito"; Label1->Caption = test.Insert("grande_teste", 3); }

Delete()

AnsiString& __fastcall Delete(int index, int count);


Remove um número especificado de caracteres de uma string. Inicia a contagem para a remoção na variável especificada por index, encerrando a exclusão com a remoção do último caracter contado para completar count:


{

AnsiString test = "O_grande_teste_está_feito";

Label1->Caption = test.Delete(3, 12);

Label1->Caption = test.Insert(" ", 3);

}

SetLength()

AnsiString& __fastcall SetLength(int newLength);

Determina um novo tamanho para a string, especificado por newLength, desde que esse novo comprimento seja menor do que o tamanho inicial. SetLength não pode aumentar o tamanho da string:


{


Label1->Caption = test.SetLength(14);

}

Pos()

int __fastcall Pos(const AnsiString& subStr) const;

a posição do primeiro caracter de uma substring especificada na string. Se a substring não for encontrada na string, Pos() retorna “zero”.


{



Label1->Caption = test.Pos("está");

}

LowerCase() e UpperCase()

AnsiString __fastcall LowerCase() const; AnsiString __fastcall UpperCase() const;

LowerCase() transforma todas as letras da string para letras minúsculas e UpperCase() transforma todas para maiúsculas:


{

AnsiString test = "O_grande_TESTE_está_FEITO";

Label1->Caption = test;

Label2->Caption = test.LowerCase();

Label3->Caption = test.UpperCase();

}

Funções que modificam strings

AnsiString ... continuação AnsiString __fastcall Trim() const; AnsiString __fastcall TrimLeft() const; AnsiString __fastcall TrimRight() const; AnsiString __fastcall SubString(int index, int count) const;

Trim(), TrimLeft()e TrimRight()

AnsiString __fastcall Trim() const; AnsiString __fastcall TrimLeft() const; AnsiString __fastcall TrimRight() const;

Podemos usar essas funções-membro para eliminar caracteres em branco no início (TrimLeft()), no final (TrimRight()) e no início e no final da string (Trim()):


void __fastcall TForm1::Label1Click(TObject *Sender) { Label1->Color = clYellow; Label2->Color = clYellow; Label3->Color = clYellow; Label4->Color = clYellow; AnsiString test = " O grande teste está feito "; Label1->Caption = test; Label2->Caption = test.Trim(); Label3->Caption = test.TrimLeft(); Label4->Caption = test.TrimRight();

}

SubString()

AnsiString __fastcall SubString(int index, int count) const;

Retorna uma substring especificada de uma string. A substring inicia a contagem dos caracteres em index e termina de contá-los em count.

O exemplo abaixo possui um Button, um Edit e um Label no Form. Quando o usuário der um clique no botão, a função membro SubString() da classe AnsiString será chamada para acessar uma substring (parte da frase) contida na variável Frase: //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { // Coloca uma string em Edit1 Edit1 -> Text = "Meu pai se chama Julio Alves"; // Declara e inicializa a variável Frase com a string contida no texto de em Edit1 AnsiString Frase = Edit1 ->Text; /* Declara e inicializa a variável MeuPai com a string que começa no caracter 18 e termina no 28 de Frase*/ AnsiString MeuPai = Frase.SubString(18, 28); // Concatena string com MeuPai, imprimindo no Label1 Label1 -> Caption = "Papai se chama " + MeuPai; } //---------------------------------------------------------------------------

Nota: Como você deve ter observado, já temos utilizado AnsiString em diversas oportunidades. Também já utilizamos a denominação String que é análoga ao uso de AnsiString (Lembre-se da palavra-chave typedef).

Como sabemos, o C++Builder possui várias funções para manipulação de strings. Veja abaixo um exemplo com AnsiPos(), uma função que retorna a posição de um caracter dentro de uma String:


void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Teste = "abcdefghijlmnopqrstuvxz"; ShowMessage((String)"A posição de 'q' é: " + AnsiPos('q', Teste)); }

AnsiString continuação... (dstring.h)

Agora já conheceremos diversas funções-membro de AnsiString. Como exercício tente entender a lógica de alguma funções localizadas no arquivo dstring.h. Evidentemente você deverá consultar o HELP do C++Builder. Para tanto, você pode proceder da seguinte maneira. Escolha uma função-membro. Por exemplo:

static AnsiString __fastcall IntToHex(int value, int digits);

Copie o nome da função para o Editor de Códigos do C++Builder:

IntToHex

Dê um clique para que o cursor fique situado sobre o nome da função e tecle F1.

O HELP do BCB deverá abrir-se automaticamente mostrando as eventuais opções para essa função. Eis uma delas:

AnsiString::IntToHex

AnsiString

Description

Converts a number into a string containing the number's hexadecimal (base 16) representation.

static AnsiString __fastcall IntToHex(int value, int digits);

Value is the number to convert. Digits indicates the minimum number of hexadecimal digits.

Percebemos que a função em questão trata da conversão de valores inteiros para hexadecimais, devolvendo AnsiString, onde int value é o valor a ser convertido e int digits é o número de dígitos devolvido pela função na conversão:

void __fastcall TForm1::Label1Click(TObject *Sender) { Label1->Caption = IntToHex(100000, 10); }


Percebeu como é fácil?!? Sem dúvida alguma, a melhor fonte de pesquisas para compreendermos o funcionamento do C++Builder é o seu próprio HELP. Se você realmente ambiciona aprender programar C++ usando esse excelente compilador, entendemos que não existe melhor fonte de pesquisas. Grande problema que parte dos programadores iniciantes encontram diz respeito ao idioma. Nem todos tem facilidades com inglês. Confesso que eu também não possuo grande facilidade. Procuro supri-la com programas que podem ser baixados na própria NET. Particularmente, eu prefiro o Babylon (considero as versões antigas melhores. Aliás, tenho o ótimo hábito de não atualizar aplicativos com os quais eu me identifico. Várias vezes me arrependi de atualizá-los, em face de “pequenas armadilhas” embutidas nas novas versões do tipo: deixar de ser freeware. Nesses casos, se você não tomou o cuidado de fazer um backup do programa de instalação antigo, a dor de cabeças e o arrependimento poderá ser considerável).

Um dos trabalhos que estaremos disponibilizando, sempre que possível, neste site é a tradução de partes que consideramos fundamentais no HELP do BCB.

AnsiString continuação...

(operadores relacionais)

Embora ainda não tenhamos abordado o tema (fato reservado para lições futuras), já tivemos oportunidade de apreciar exemplos com os comandos if e else. Por enquanto tenhamos em mente que esses comandos são usados basicamente para efetuar comparações do tipo:

Se “A” é maior do que “B”, faça isso;

Senão, faça aquilo.

No caso acima, o termo maior está representando o operador relacional “>”. Para mais detalhes, dê uma olhadinha no tópico que trata tal assunto.

Ansistring implementa métodos para tratamento de operadores relacionais:

// Comparisons bool __fastcall operator ==(const AnsiString& rhs) const; bool __fastcall operator !=(const AnsiString& rhs) const; bool __fastcall operator <(const AnsiString& rhs) const; bool __fastcall operator >(const AnsiString& rhs) const; bool __fastcall operator <=(const AnsiString& rhs) const; bool __fastcall operator >=(const AnsiString& rhs) const; int __fastcall AnsiCompare(const AnsiString& rhs) const; int __fastcall AnsiCompareIC(const AnsiString& rhs) const; //ignorecase

Vejamos outra implementação de AnsiString:

// Query attributes of string int __fastcall Length() const;


Length() retorna o número de caracteres de um AnsiString. Logo podemos escrever um código mesclando operadores relacionais com essa função:

void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Str = "Esta é a primeira string"; AnsiString Str2 = "Esta é a segunda string";

if(Str.Length() > Str2.Length()) ShowMessage((String)"A primeira string é maior. Ela possui " + Str.Length() + " caracteres"); else ShowMessage((String)"A segunda string é maior. Ela possui " + Str2.Length() + " caracteres"); }

Depois que você estudar os comandos if e else, e os operadores relacionais, procure fazer alguns exercícios implementando outros tipos de comparações suportadas por AnsiString , com outros operadores relacionais.

AnsiString continuação...

(concatenation) // Concatenation AnsiString __fastcall operator +(const AnsiString& rhs) const;

Podemos usar o operador + para concatenar strings (colocar uma após a outra): void __fastcall TForm1::Label1Click(TObject *Sender) { AnsiString AS1 ("\tTestando"); AnsiString AS2 ("\n\tAnsiString"); String S1 ("\n\nTestando"); String S2 ("\nString"); Label1 -> Caption = AS1 + AS2 + "\n\t\t\tOutro teste" + S1 + S2 + " !!!!"; }

A partir de agora assumimos que você já conhece razoavelmente a classe AnsiString. Porém ainda há muito mais a conhecer sobre strings. Dedique algumas horas ao estudo, sempre procurando documentar os estudos.

A palavra-chave typedef

Podemos usar a palavra-chave typedef para criar um sinônimo para um tipo de dados existente qualquer. Isso poderá nos auxiliar quando estivermos lidando com nomes de tipos muito longos e, portanto, sujeito a erros de digitação. Por exemplo, na área dos cabeçalhos, digitamos:


typedef signed short int ssint;

e, a partir daí, todas as vezes que quisermos declarar uma variável signed short int poderemos fazê-lo através da declaração: ssint:

void __fastcall TForm1::Button1Click(TObject *Sender) { // cria um sinônimo (ssint) para signed short int typedef signed short int ssint; // declara e inicializa variáveis ssint ssint Altura = 15, Largura = 20, Comprimento = 26; ssint Volume; Volume = Altura * Largura * Comprimento; // centraliza o caption de Label1 Label1 -> Alignment = taCenter; // altera o estilo da font de Label1 para negrito, itálico e sublinhado Label1->Font->Style = Label1->Font->Style<<fsBold<<fsItalic<<fsUnderline;

Label1 -> Caption = "******Cálculo do volume de um cubo******\n" "Altura = " + String(Altura) + "\n" "Largura = " + String(Largura) + "\n" "Comprimento = " + String(Comprimento) + "\n" "Volume = " + String(Volume);

}

A diretiva #define

Podemos criar um nome para definir valores constantes através da diretiva de preprocessador #define. Esse nome é conhecido por constante simbólica.

#define Kelvin -273

Embora Kelvin não tenha sido declarado como nenhum tipo em particular (char, float, AnsiString etc), o compilador saberá lidar com os dados da melhor forma possível em virtude do estilo da declaração. Por exemplo:

void __fastcall TForm1::Button1Click(TObject *Sender) { #define Kelvin -273 #define Frase "Ibirarema é uma pequena cidade do Estado de São Paulo!" #define pi 3.141592653589 #define letra 'A'

/* Essas constantes não são tão constantes afinal.


Se, mantendo a declaração anterior, fizéssemos uma nova declaração para pi:

#define pi 10

o compilador aceitaria esse novo valor desconsiderando o anterior!!!!!*/

Label1 -> Caption = Frase "\n" + AnsiString(Kelvin * pi) + "\n" + letra;

}

Além da habilidade de definir constantes simbólicas, a diretiva #define pode ser usada para definir macros, desde que se lhe forneça algum argumento:

#define SOMA(X, Y) (X + Y)

Em capítulos posteriores, estudaremos essa diretiva com detalhes.

A palavra-chave const

Outra forma (melhor) que a linguagem C++ nos oferece para definir constantes é através da palavra-chave const.

A diferença básica entre os dois tipos de declaração é o fato de que naquela (#define), é o tipo de declaração quem informa ao compilador qual será o provável tipo, enquanto nesta (const), o tipo (char, int etc) é declarado:

const int Kelvin = -273;

const double pi = 3.141592653589;

Este método é o mais recomendado na maioria dos casos, pois além de tornar o código mais fácil de ler e manter, dificulta a introdução de bugs, posto que o compilador pode checar se a constante está sendo usada de acordo com seu tipo.

void __fastcall TForm1::Button1Click(TObject *Sender) { const int km = 170; const AnsiString Itap = "Em Itapetininga faz muito frio!!!!"; const float mtr = 17; const char alf = 'm';

// Erro .... Aqui estamos diante de uma verdadeira constante Itap = "tentando alterar uma constante..."; Label1 -> Caption = Itap + "\n" + AnsiString(km + mtr) + "\n" + alf; }


O tipo enum

O tipo enum cuida tratar de um tipo cuja sintaxe é bastante elaborada, para conter um conjunto de valores definidos pelo usuário chamados dados de tipos enumerados ou enumeração.

Usando a palavra-chave enum, podemos definir um conjunto de constantes agrupadas sob um nome como um novo tipo de dados, somando-se uma nova maneira às duas formas apresentadas anteriormente para definição de constantes. A essa coleção de constantes, dá-se o nome de constantes enumeradas.

As constantes enumeradas possibilitam-nos a criação de novos tipos de dados, bem como a definição de variáveis desses tipos, sendo que os valores assumidos ficam restritos a determinada coleção de valores. Podemos, por exemplo, declarar uma enumeração representando os meses do ano: enum Meses_do_Ano { janeiro, fevereiro, marco, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro }; // Fim de enum Meses_do_Ano

Feito isso, podemos definir variáveis do tipo Meses_do_Ano, que podem assumir apenas valores inteiros:

enum Meses_do_Ano { janeiro = 0, fevereiro = 1, marco = 2, abril = 3, maio = 20, junho = 21, julho = 22, agosto = 56, setembro = 57, outubro = 58, novembro = 200, dezembro = 201 }


Observe que cada constante enumerada possui um valor inteiro e que podemos atribuir um valor específico a determinada constante. Todavia se não especificarmos tal valor, a primeira constante assumirá o valor 0; a segunda, 1; a terceira, 2; a quarta, 3; e assim sucessivamente. Como, em nosso exemplo optamos por atribuir valores aleatórios às constantes, percebemos que as constantes subseqüentes assumem valores com incremento de 1 a partir das que receberam um valor qualquer (em nosso exemplo, os meses de maio, agosto e novembro).

Internamente as constantes enumeradas são representadas como sendo do tipo int.

O exemplo a seguir contém um Label no Form. Quando o usuário dá um clique no Label, uma caixa de inserção de dados aparece para que seja digitado um valor entre 1 e 12. Dependendo do valor digitado, teremos a resposta dos mês correspondente no Label: //--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { enum Meses_do_Ano { janeiro = 1, // especifica o valor 1 para a primeira constante fevereiro, // vale 2 marco, // vale 3 ... abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro }; // Fim de enum Meses_do_Ano

// declara variável do tipo Meses_do_Ano Meses_do_Ano Mes; //declara variável int int iMes;

iMes = StrToInt(InputBox ("Caixa para colheita de Valores", "Digite um número entre 1 e 12", "")); Mes = Meses_do_Ano(iMes); switch(Mes) { case 1: Label1 -> Color = clGreen; /*escolha uma cor diferente para cada mês*/ Label1 -> Font -> Name = "Arial"; /*e uma font para cada mês*/ Label1 -> Font -> Color = clYellow; /*e uma cor de font para cada mês*/ Label1 -> Caption = AnsiString(iMes) + " equivale a janeiro..."; break;

case 2: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a fevereiro...";


break;

case 3: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a março..."; break;

case 4: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a abril..."; break;

case 5: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a maio..."; break;

case 6: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a junho..."; break;

case 7: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a julho..."; break;

case 8: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a agosto..."; break;

case 9: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a setembro..."; break;

case 10: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a outubro..."; break;


case 11: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a novembro..."; break;

case 12: Label1 -> Color = clGreen; Label1 -> Font -> Name = "Arial"; Label1 -> Font -> Color = clYellow; Label1 -> Caption = AnsiString(iMes) + " equivale a dezembro..."; break;

default: ShowMessage(AnsiString(iMes) + " não é um valor válido..."); break; } } //---------------------------------------------------------------------------

Operadores matemáticos

A linguagem C++ possui cinco operadores matemáticos binários representados pelos seguintes operadores:

+ (adição);

- (subtração);

* (multiplicação);

/ (divisão); e

% (módulo);

e possui um operador unário:

- (menos unário).

Os operadores binários operam sobre dois operandos e o unário sobre um.

Os operadores de adição, subtração, multiplicação e divisão funcionam normalmente como nos cálculos matemáticos usuais. Já o operador módulo fornece-nos o resto de uma divisão inteira (sem eventuais partes fracionárias) como resultado. Por exemplo, quando fazemos a divisão de 9 por 5, o resultado é 1 e o resto é 4.

O operador menos unário serve para trocar o sinal de seu operando (positivo para negativo ou negativo para positivo):


int i = 440; i = -i; Label1 -> Caption = i; // Agora o valor de i é - 440

O exemplo a seguir (calculadora básica) possui, no Form, três componentes Edit e cinco RadioButton(s) dentro de um RadioGroup. Todas as propriedades do programa serão geradas em tempo de execução (no código), e não diretamente no Object Inspector. O usuário deverá digitar um valor no Edit1, outro valor no Edit2 e escolher uma operação matemática no RadioGroup para visualizar o resultado no Edit3.


#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { Form1 -> Caption = "Calculadora Básica"; Form1 -> BorderStyle = bsSizeToolWin; // altera a borda de Form1

Edit1 -> Text = ""; // esvazia Edit1 Edit2 -> Text = ""; // Esvazia Edit2 Edit3 -> Text = ""; // esvazia Edit3 Edit3 -> ReadOnly = true; // Edit3 não aceita dados via teclado ou mouse (arrastar e soltar)

RadioGroup1 -> Caption = "Escolha uma operação";

RadioButton1 -> Caption = "+ (adição)"; RadioButton2 -> Caption = "- (subtração)"; RadioButton3 -> Caption = "* (multiplicação)"; RadioButton4 -> Caption = "/ (divisão)"; RadioButton5 -> Caption = "% (módulo)"; } //--------------------------------------------------------------------------- void __fastcall TForm1::RadioButton1Click(TObject *Sender) { /*Na operação de adição precisamos declarar variáveis e realizar as respectivas coversões para evitar erros de concatenação de strings em face do operador + */ double primeiro = StrToFloat(Edit1 -> Text); double segundo = StrToFloat(Edit2 -> Text); Edit3->Text = primeiro + segundo; //realiza o cálculo por via indireta Edit1->SetFocus(); //chama a função SetFocus() para colocar o foco em Edit1 } //---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton2Click(TObject *Sender) {


Edit3->Text = double((Edit1->Text) - (Edit2->Text)); //realiza o cálculo por via direta Edit1->SetFocus(); //chama a função SetFocus() para colocar o foco em Edit1 } //---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton3Click(TObject *Sender) { Edit3->Text = double((Edit1->Text) * (Edit2->Text)); //realiza o cálculo por via direta Edit1->SetFocus(); //chama a função SetFocus() para colocar o foco em Edit1 } //---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton4Click(TObject *Sender) { Edit3->Text = double((Edit1->Text) / (Edit2->Text)); //realiza o cálculo por via direta Edit1->SetFocus(); //chama a função SetFocus() para colocar o foco em Edit1 } //---------------------------------------------------------------------------

void __fastcall TForm1::RadioButton5Click(TObject *Sender) { /* Essa parte do código foi corrigido com o comando if ...else pois apresentava um bug nas operações em que o divisor era maior que o dividendo*/

//se o valor convertido para ponto flutuante de Edit1 for maior do que o de Edit2 if (StrToFloat(Edit1 -> Text) > StrToFloat(Edit2 -> Text)) // Edit3 apresentará o resto da divisão de Edit1->Text por Edit2->Text Edit3 -> Text = double((Edit1 -> Text) % (Edit2 -> Text)); // caso contrário else // Edit3 apresentará o valor 0 (zero) em seu texto Edit3 -> Text = 0; Edit1 -> SetFocus(); // chama a função SetFocus() para colocar o foco em Edit1 }//---------------------------------------------------------------------------

Expressões

Todo comando que ao ser efetuado retorna um valor, é considerado uma expressão em C++.

São expressões:

-273; // Retorna o valor -273

x = (a + b) - ((c * d) / e);

e assim por diante...

Observe as expressões no exemplo a seguir que leva apenas um Label no Form e será usado para calcular o resultado de uma equação de segundo grau:



#include <math.h> // Declarar essa biblioteca para funções matemáticas

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- AnsiString a, b, c; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { Form1->BorderStyle = bsNone; //retira as bordas e barra de títulos do programa

Label1 -> Caption = "*****CALCULA EQUAÇÃO DE SEGUNDO GRAU*****\n" "Dê um clique aqui para digitar os valores \"a\", \"b\" e \"c\" "; } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { Form1 -> AutoSize = true; // ajusta o tamanho do form ao label try { retornoA: a = InputBox("Caixa de Entrada de Valores", "Digite um valor para 'a'", ""); StrToInt(a); if (a == 0) { MessageBox(0,"Zero não é um valor válido para 'a' !" "\nDigite outro valor... ", "Erro no valor escolhido", 16); goto retornoA; }

else Label1 -> Caption = " a = " + a; Label1 -> Font -> Color = clRed; Label1 -> Font -> Style = TFontStyles()<< fsBold; } catch(...) { MessageBox(0, "Erro ... Valor não suportado pelo programa ...", "Erro de digitação", 16); }

try { b = InputBox("Caixa de Entrada de Valores", "Digite um Valor para 'b'", "");


StrToInt(b); Label1 -> Caption = Label1 -> Caption + "\n b = " + b; } catch(...) { MessageBox(0, "Erro ... Valor não suportado pelo programa ...", " Erro de digitação", 16); }

try { c = InputBox("Caixa de Entrada de Valores", "Digite um Valor para 'c'", ""); StrToInt(c); Label1 -> Caption = Label1 -> Caption + "\n c = " + c; } catch(...) { MessageBox(0, "Erro ... Valor não suportado pelo programa ...", "Erro de digitação", 16); }

try { Label1 -> Font -> Color = clBlue; Label1 -> Font -> Style = TFontStyles()<< fsBold;

double x1, x2, delta;

delta = (b*b) - ((a * 4) * c); if(delta < 0) MessageBox(0,"delta negativo... não existem raízes reais...\n" "\ntente novamente com outros valores...", "Erro nos valores", 16);

else { Label1 -> Caption = Label1 -> Caption + "\n\ndelta = " + FloatToStr(delta);

x1 = ((b * (-1)) + (sqrt (delta))) / (a * 2); Label1 -> Caption = Label1 -> Caption + "\nx1 = " + FloatToStr(x1);

x2 = ((b * (-1)) - (sqrt (delta))) / (a * 2); Label1 -> Caption = Label1 -> Caption + "\nx2 = " + FloatToStr(x2); } } catch(...) { MessageBox(0, "Por favor, digite os valores corretamente", "Erro de execução...", 16); }

}


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

void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key) { if (Key == 13) // se for pressionada a tecla Enter Close(); // encerra o programa } //---------------------------------------------------------------------------

Entendendo melhor o C++Builder

Quando você inicia o C++Builder, ele escreve automaticamente algumas linhas de código para a sua aplicação. Tentaremos entender o que significa cada uma dessas linhas:

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

#include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

Inicialmente, na parte superior da janela, podemos contemplar uma linha de comentários, constituída basicamente de vários hífens seguindo //. Como sabemos, em C++ tudo o que segue a dupla de caracteres // será ignorado pelo compilador até o final da linha. O compilador insere essas linhas, basicamente, para separar seções de códigos ou funções. Eles estão ali, apenas, para melhorar a visualização.

Perceba que, existem outras linhas iguais a essa no código e que sempre que codificarmos um um método de algum evento, através da chamada no Object Inspector, essas linhas de comentário estarão lá, criadas automaticamente para melhorar a visualização dos códigos.

#include <vcl.h>

Já sabemos que quando o pré-processador encontra a diretiva #include em nosso código fonte, ele substitui a mesma pelo conteúdo do arquivo indicado, sendo que o compilador encontrará e processará o arquivo implementado, e não a diretiva de compilação. Avançado no estudo do código inicial inserido automaticamente pelo C++Builder, encontramos essa diretiva de determina a inclusão do arquivo chamado vcl.h:


#include <vcl.h>

Se você instalou o C++Builder no diretório padrão, poderá abrir e visualizar esse arquivo em

C:\Arquivos de programas\Borland\CBuilder6\Include\Vcl\vcl.h

Vejamos o seu conteúdo:

///////////////////////////////////////////////////////////////////////////////// // VCL.H - Borland C++ Builder pre-compiled header file // $Revision: 1.12.1.0.1.1 $ // Copyright (c) 1997, 2002 Borland Software Corporation ///////////////////////////////////////////////////////////////////////////////// #ifndef VCL_H #define VCL_H

#define INC_VCL #include <basepch0.h>

#endif // VCL_H

A vcl.h é parte da Visual Component Library usada para linkar a definição de componentes como botões, menus etc. Perceba que no arquivo em questão aparece novamente um include. Vejamos o conteúdo do arquivo basepch0.h:

///////////////////////////////////////////////////////////////////////////////// // BASEPCH0.H - Borland C++ Builder pre-compiled header file // $Revision: 1.0.1.0.1.0 $ // Copyright (c) 1997, 2002 Borland Software Corporation // // BASEPCH0.H is the core header that includes VCL/CLX headers. The headers // included by BASEPCH0.H are governed by the following macros: // // MACRO DESCRIPTION DEFAULT // ======= ============= ======= // // NO_WIN32_LEAN_AND_MEAN When this macro is defined, BASEPCH.H does OFF // not define WIN32_LEAN_AND_MEAN. // // INC_VCL This macro is defined by VCL.H to OFF // include the base set of VCL headers // // VCL_FULL Same as NO_WIN32_LEAN_AND_MEAN OFF // (NOTE: This macro is for BCB v1.0 backward // compatibility) // // INC_VCLDB_HEADERS When this macro is defined, VCL.H includes // requires INC_VCL the core Database headers of VCL. OFF // (Defining this macro is functionally // equivalent to including VCLDB.H) // // INC_VCLEXT_HEADERS When this macro is defined, VCL.H includes // requires INC_VCL all VCL headers. OFF // (Defining this macro is functionally


// equivalent to including VCLMAX.H) // // INC_CLX This macro is defined by CLX.H to include OFF // the base set of CLX headers // // INC_CLXDB_HEADERS When this macro is defined, CLX.H includes // requires INC_CLX the core Database headers of CLX. OFF // // INC_CLXEXT_HEADERS When this macro is defined, CLX.H includes // requires INC_CLX all CLX headers. OFF // ///////////////////////////////////////////////////////////////////////////////// #ifndef __BASEPCH0_H__ #define __BASEPCH0_H__

// v1.0 of BCB checked for VCL_FULL to avoid LEAN_AND_MEAN support // #if defined(VCL_FULL) // BCB v1.0 compatible #define NO_WIN32_LEAN_AND_MEAN #endif

#if !defined(_WINDOWS_) // Don't optimize if WINDOWS.H has already been included #if !defined(NO_WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN // Enable LEAN_AND_MEAN support #define _VCL_LEAN_AND_MEAN // BCB v1.0 compatible #endif // NO_WIN32_LEAN_AND_MEAN #endif // _WINDOWS_

#if !defined(COM_NO_WINDOWS_H) //Make sure COM Headers don't include WINDOWS.H/OLE2.H #define COM_NO_WINDOWS_H #define UNDEF_COM_NO_WINDOWS_H #endif

#if !defined(RPC_NO_WINDOWS_H) // Make sure RPC Headers don't include WINDOWS.H #define RPC_NO_WINDOWS_H #define UNDEF_RPC_NO_WINDOWS_H #endif

// Core (minimal) Delphi RTL headers // #include <System.hpp> #include <Types.hpp> #include <Windows.hpp> #include <Messages.hpp> #include <SysUtils.hpp> #include <Classes.hpp>

// Core (minimal) VCL headers // #if defined(INC_VCL) #include <Controls.hpp> #include <Graphics.hpp> #include <Forms.hpp> #include <Dialogs.hpp> #include <StdCtrls.hpp> #include <ExtCtrls.hpp>


// Full set of VCL headers // #if defined(INC_VCLEXT_HEADERS) #include <Buttons.hpp> #include <ChartFX.hpp> #include <ComCtrls.hpp> #include <DdeMan.hpp> #include <FileCtrl.hpp> #include <GraphSvr.hpp> #include <Grids.hpp> #include <MPlayer.hpp> #include <Mask.hpp> #include <Menus.hpp> #include <OleCtnrs.hpp> #include <OleCtrls.hpp> #include <Outline.hpp> #include <Tabnotbk.hpp> #include <Tabs.hpp> #include <VCFImprs.hpp> #include <VCFrmla1.hpp> #include <VCSpell3.hpp> #endif // INC_VCLEXT_HEADERS

#endif // INC_VCL

// Core (minimal) CLX headers // #if defined(INC_CLX) #include <Qt.hpp> #include <BindHelp.hpp> #include <QConsts.hpp> #include <QStdActns.hpp> #include <QStyle.hpp> #include <QControls.hpp> #include <QTypes.hpp> #include <QGraphics.hpp> #include <QForms.hpp> #include <QDialogs.hpp> #include <QStdCtrls.hpp> #include <QExtCtrls.hpp> #include <QMenus.hpp> #include <QClipbrd.hpp> #include <QMask.hpp> #include <QButtons.hpp> #include <QComCtrls.hpp>

// CLX Database related headers // #if defined(INC_CLXDB_HEADERS) #include <QDBCtrls.hpp> #include <DB.hpp> #include <DBTables.hpp> #endif // INC_CLXDB_HEADERS

// Full set of CLX headers //


#if defined(INC_CLXEXT_HEADERS) #include <QDBGrids.hpp> #include <QDBCtrls.hpp> #include <QDBActns.hpp> #include <QGrids.hpp> #include <QImgList.hpp> #include <QSearch.hpp> #include <QActnList.hpp> #include <QCheckLst.hpp> #include <QPrinters.hpp> #endif // INC_CLXEXT_HEADERS

#endif // INC_CLX

#if defined(INC_OLE_HEADERS) #include <cguid.h> #include <dir.h> #include <malloc.h> #include <objbase.h> #include <ole2.h> #include <shellapi.h> #include <stddef.h> #include <tchar.h> #include <urlmon.h> #include <AxCtrls.hpp> #include <OleCtnrs.hpp> #include <OleCtrls.hpp> #endif

// Using ATLVCL.H // #if defined(INC_ATL_HEADERS) #include <atl\atlvcl.h> #endif #if defined(UNDEF_COM_NO_WINDOWS_H) //Clean up MACRO to prevent inclusion of WINDOWS.H/OLE2.H #undef COM_NO_WINDOWS_H #undef UNDEF_COM_NO_WINDOWS_H #endif

#if defined(UNDEF_RPC_NO_WINDOWS_H) // Clean up MACRO to prevent inclusion of WINDOWS.H #undef RPC_NO_WINDOWS_H #undef UNDEF_RPC_NO_WINDOWS_H #endif

#endif // __BASEPCH0_H__

Veja quantos include. Por exemplo, #include <Buttons.hpp>, #include <Menus.hpp> etc. Um bom conhecimento dessas bibliotecas, pode nos facilitar bastante a compreensão. Todavia, por enquanto, não se preocupe com isso, mesmo porque o compilador cuida muito bem da tarefa, à margem de nosso profundo, ou escasso, conhecimento de suas particularidades. Quanto ao estudo das diretivas, no avançar do curso procuraremos conhecer pelo menos um pouco de cada uma delas.


#pragma hdrstop

A seguir, encontramos a seguinte linha de códigos:

#pragma hdrstop

Através da diretiva #pragma, o C++Builder pode definir diretivas que podem ser passadas ao compilador. Se o compilador não identificar o nome da diretiva, ele simplesmente ignora #pragma sem emitir qualquer aviso ou mensagem de ERRO. A sintaxe de pragma é #pragma nome_da_diretiva.

O compilador C++Builder suporta as seguintes diretivas #pragma:

#pragma alignment

#pragma anon_struct

#pragma argsused

#pragma checkoption

#pragma codeseg

#pragma comment

#pragma defineonoption

#pragma exit

#pragma hdrfile

#pragma hdrstop

#pragma inline

#pragma intrinsic

#pragma link

#pragma message

#pragma nopushoptwarn

#pragma obsolete

#pragma option


#pragma pack

#pragma package

#pragma resource

#pragma startup

#pragma undefineonoption

#pragma warn

Sintaxe: #pragma hdrstop

Descrição: Esta diretiva termina a lista de hearde files escolhidos para pré-compilação. Você pode usá-lo para reduzir a quantia de espaço em disco usados por headers de pré-compilação.

Hearder files pré-compilados podem ser compartilhados entre os arquivos fonte de seu projeto sendo que somente as diretivas #include antes de #pragma hdrstop são idênticas (comuns a todos os arquivos do projeto). Então, você adquire o melhor desempenho do seu compilador se você incluir os header files comuns de seu projeto antes de #pragma hdrstop, e os específicos depois disto. Certifique-se de ter inserido as diretivas #include antes de #pragma hdrstop de forma indêntica em todo o código fonte, ou que haja apenas pequenas variações.

O ambiente de desenvolvimento integrado gera o código para aumentar desempenho de header pré-compilados. Por exemplo, depois de uma Aplicação Nova, o arquivo fonte " Unit1.cpp" terá a seguinte aparência (comentários adicionados):

#include <vcl.h> // arquivos de header comuns

#pragma hdrstop // fim da lista comum

#include "Unit1.h" // header files específicos

// ....

Só se usa essa diretiva pragma em arquivos fonte. Ela não tem nenhum efeito quando usada em um arquivo header (.h, .hpp etc).

“Unit1.h”

A seguir, percebemos mais um enunciado include inserido automaticamente pelo BCB:


#include “Unit1.h”

O arquivo de cabeçalho “Unit1.h” é criado simultaneamente com o arquivo “Unit1.cpp” que é o arquivo que contém o código principal de um aplicativo (aquele onde temos efetuado a maioria das inclusões de códigos até agora). Já sabemos que 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). Entende-se por diretório atual, aquele onde salvamos o projeto, ou seja, onde se encontram os arquivos do projeto gerados pelo sistema no desenvolvimento do programa. Eventualmente, se o arquivo não se encontrar em nenhum desses dois diretórios, podemos indicar o seu caminho completo entre as aspas:

“C:\\Meu_aplicativo\\Unit1.h”

Evidentemente que Unit1.h é o nome padrão dado pelo C++Builder ao arquivo. Se, num projeto, salvarmos os arquivos com nomes diferentes, esses nomes serão aqueles que encontraremos acompanhados do “.h” e do “.cpp”. Por exemplo, “Edit_Texto.h” e “Edit_Text.cpp”. Outra questão importante diz respeito ao número 1 entre Unit e o .h ou o .cpp. Esse número refere-se ao número do componente na aplicação. Se colocarmos um segundo Form no aplicativo, o arquivo principal dele será nomeado de Unit2.cpp; um terceiro, de Unit3.cpp , e assim por diante. Evidentemente, conforme exposto, não precisamos concordar com nomes padrão.

Em outra seção, abordaremos técnicas de como dar nomes a nossas aplicações e aos componentes nelas inseridos. Porém, no nosso curso, raramente trocaremos o nome padrão fornecido pelo compilador. Por um motivo muito simples. O nome padrão facilita a compreensão para estudantes de línguas diferentes, que não compreendem nosso idioma. Quando eu fazia pesquisas na internet, várias vezes pude aproveitar códigos, cujos autores eu nem poderia, de mim mesmo, imaginar a nacionalidade, de tão complexa a forma de escrever (tipo chinês, russo, grego etc). Mesmo assim, quando os códigos eram mantidos no default fornecido pelo C++Builder, eram-me bastante claros (exceto strings e comentários, evidentemente).

Penso que é o mínimo que posso fazer, uma vez que a maior parte do que consegui aprender sobre programação foi através da Internet, através de uma infinidades de generosos professores anônimos. Porém, quando eu aproveitar exemplos que já fiz anteriormente, alterando os nomes, manterei estes nomes.

“#pragma package(smart_init)”

Sintaxe:

#pragma package(smart_init)

#pragma package(smart_init, weak)

Descrição: smart_init argument


A diretiva #pragma package(smart_init) é utilizada durante a inicialização do aplicativo. Ela assegura que qualquer unidade de códigos requisitada pelo programa será inicializada na segqüência correta, ou seja, serão inicializadas na ordem determinada por suas dependências (Incluída por default no pacote arquivo fonte). Tipicamente, você pode usar o #pragma package para arquivos .CPP que são criados como packages.

Esta diretiva pragma afeta a ordem de inicialização desta unidade de compilação. Para units, a inicialização ocorre na seguinte ordem:

1. Pelas suas dependências de "usos", quer dizer, se unitA depende de unitB, unitB deve ser inicializa antes de unitA.

2. A ordem de vínculo.

3. Ordem de prioridade dentro da unit.

para arquivos .OBJ regulares (aqueles não construídos como units), a inicialização acontece primeiro de acordo com a ordem de prioridade e, então, de acordo com a ordem de vínculo. Mudando a ordem de vínculo dos arquivos .OBJ muda-se a ordem na qual os objetos construtores globais são chamados.

Os exemplos seguintes mostram como a inicialização difere entre units e arquivos .OBJ regulares.

Tome como um exemplo três arquivos unit, A, B e C que são “inteligentemente inicializados” com #pragma package(smart_init) e possuem valor de prioridade (definidas no parâmetro prioridades do #pragma startup) setados de 10, 20 e 30. As funções são nomeadas de acordo com os seus valores de prioridades e o parent .OBJ. assim os nomes são a10, a20, a30, b10, e assim por diante.

Desde que todas as três são units, e se A usa B e C e a ordem de vínculo é A, B e então C, a ordem de inicialização é:

B10 B20 B30 C10 C20 C30 A10 A20 A30

Se, ao invés de units, o arquivo anterior fosse .OBJ a ordem seria:

A10 B10 C10 A20 B20 C20 A30 B30 C30

Os arquivos .CPP que usam #pragma package(smart_init) também requerem que algum #pragma link

referencie outro arquivo .OBJ desde um arquivo .CPP que declara #pragma package(smart_init), e deve estar resolvido na unit. Se #pragma link fizer referências para arquivos não .OBJ pode ainda ser resolvido por bibliotecas etc.

Descrição: weak packages

A diretiva #pragma package(smart_init, weak) afeta o modo que um arquivo .OBJ é armazenado num package’s .BPI e arquivos .BPL. Se #pragma package(smart_init, weak) aparece em um arquivo de unit,


o compilador omite a unit de BPLs quando possível, e cria uma cópia local non-packaged da unit quando ela é requerida por outra aplicação ou package. Uma unit compilada com esta diretiva é dita como sendo “weakly packaged”.

#pragma package(smart_init, weak) é usado para eliminar conflitos entre packages que possivelmente dependem da mesma biblioteca externa.

Arquivos Unit contendo a diretiva #pragma package(smart_init, weak) não devem ter variáveis globais.

para maiores informações sobre uso weak packages, veja Weak packaging.

#pragma resource

Sintaxe:

#pragma resource “*.dfm”

Descrição: Esta diretiva pragma faz o arquivo ser marcado como uma unidade de Form e requer combinação .dfm. Ou seja, ela determina que o compilador utilize tal arquivo (.dfm) de definição do Form, requisitado por essa Unit. Tais arquivos são administrados pelo IDE.

Se seu Form requer qualquer variável, elas devem ser declaradas depois da inscrição do pragma resource. As declarações devem ser pertencentes ao Form.

TFormName *Formname;

TForm

TForm representa uma janela padrão da aplicação (Form).

Unit: Forms

Descrição:

Quando você cria formulários no Form designer em tempo de projeto, eles são implementados como descendentes de TForm. Forms podem representar a janela principal da aplicação, caixas de diálogo, ou janelas filhas (MDI children). Um form pode conter outros objetos como TButton, TCheckBox, TcomboBox etc.

Exemplos de forms incluem objetos TLoginDialog e TPasswordDialog.


Nota: Quando trabalhamos com objetos form, não chamamos explicitamente os métodos Free ou Destroy para liberá-los. Em vez disso, usamos o método liberar (Release method), o qual espera até que todos event handlers (parte do programa que trata determinadas situações) tenham terminados sua execução.

_fastcall, __fastcall

Categoria: modificadores C++Builder, extensão de palavra-chave

Sintaxe:

valor_de_retorno _fastcall nome_da_função(parm-lista)

valor_de_retorno __fastcall nome_da_função(parm-lista)

Descrição:

use o modificador __fastcall para declarar funções que aguardam parâmetros para serem passados em registros. os três primeiros parâmetros são passados (da esquerda para a direita) em EAX, EDX, e ECX, se eles se ajustarem no registro. Os registros não são usados se o parâmetro é um ponto flutuante ou uma estrutura (struct type).

Todas as funções-membro da classe Form devem usar a convenção __fastcall.

O compilador trata essa convenção chamada como uma nova language, ao longo das linhas of _cdecl e _pascal

Funções declaradas usando _cdecl ou _pascal não podem ter os modificadores _fastcall porque eles usam a pilha para passar os parâmetros. Igualmente, o modificador __fastcall não pode ser usado junto com _export.

O compilador antepõe o nome da função __fastcall com um a-sinal (at-sign) ("@"). Este prefixo aplica-se a desqualificação de nomes de função C e para C++.

Para implementação estilo Microsoft VC++ __fastcall, veja __msfastcall e __msreturn.

Nota: o modificador __fastcall está sujeito desqualificação do nome da função. Veja a descrição do -VC option.

TComponent

TComponent é o ancestral comum de todos os componentes que podem aparecer no form designer.


Unit: Classes

Descrição:

Components são objetos persistentes que possuem as seguintes capacidades:

1. A capacidade de aparecer no Componente palette e ser transferido para o form designer. 2. A capacidade de administrar-se, a si, e a outros componentes. 3. Incrementar o fluxo e armazenar capacidades. 4. A capacidade de ser convertido em um controle ActiveX ou outro objeto COM por wizards na página ActiveX do diálogo New Objects.

Não crie instâncias de TComponent. Use TComponent como uma classe base quando declarar um componente não-visual que pode mostrar-se no component palette e ser usado no form designer. Propriedades e métodos de TComponent fornecem comportamentos básicos que classes dependentes herdam e também comportamentos que componentes podem ativar para ajustar seu comportamento.

Para criar componentes os quais são visíveis em tempo de execução para os usuários, use TControl ou seus descendentes como base. Para criar controles baseados em objetos janelas, use TWinControl ou seus descendentes como base.

TComponent::Owner

Owner = Proprietário

Indica o componente que é responsável por carregar e liberar seus componentes.

__property TComponent* Owner = {read=FOwner};

Descrição:

Use Owner para encontrar o proprietário de um componente. O Owner de um componente é responsável por duas coisas:

A memória referente ao componente é liberada assim que a memória de seu proprietáro é liberada.

O Owner é responsável por carregar e salvar as propriedades published de seu controle proprietário.

Por default, um form possui todos os componentes que estão nele. Por sua vez, o form é pertencente à aplicação. Assim, quando a aplicação é encerrada e a memória correspondente é liberada, a memória para todos os forms (e todos os seus componentes) também é liberada. Quando um form é carregado na memória, automaticamente são carregados todos os componentes que nele estão instalados.


O proprietário de um componente é determinado pelo parâmetro passado ao construtor quando o componente é criado. Pelo fato de os componentes serem criados no form designer, o form é automaticamente nomeado como o proprietário.

Aviso: Se um componente tem um proprietário diferente de um form ou módulo de dados, ele não será salvo ou carregado com seu proprietário, a menos que você o identifique como um subcomponente. Para identificar um componente como um subcomponente, chame o método SetSubComponent.

Operadores de incremento e decremento

Você já deve ter percebido que mencionamos expressões do tipo incremento e decremento. Num sentido mais técnico, trata-se de dois operadores de extrema utilidade em C++.

O operador de incremento é formado por dois sinais de adição ++ e adiciona 1 ao valor da variável à qual é aplicado. Num exemplo anterior (Operações matemáticas com unsigned), a expressão:

uiAcresce = uiAcresce + 1;

produziria o mesmo resultado se fosse substituída por:

uiAcresce++;

Já o operador de decremento é formado por dois sinais de subração -- e subtrai 1 do valor da variável à qual é aplicado:

uiDecresce--;

é equivalente a:

uiDecresce = uiDecresce - 1;

É relevante a posição dos operadores de incremento (++) ou decremento (--) em relação à variável: ++uiAcresce; // operador antecedendo do nome da variável - prefixo

uiAcresce++; // operador após o nome da variável - sufixo

--uiDecresce; // prefixo

uiDecresce--; // sufixo


Na posição de prefixo, primeiro o operador é aplicado e depois a variável tem seu valor acessado. Na posição de sufixo, o valor da variável é acessado antes de o operador ser aplicado.

O exemplo abaixo usa um Button e um Memo no Form. Quando o usuário dá cliques no botão, as variáveis são, conforme o caso, incrementadas ou decrementadas, com operadores pós e pré-fixados. A diferença dos resultados que tais operadores operam nas variáveis nessas diversas situações é demonstrada no Memo: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- int Acresce = 100, ACRESCE = 100, Decresce = 100, DECRESCE = 100; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------


Memo1->Lines->Add("incrementa Acresce com sufixo " + String(Acresce++) + " " "incrementa ACRESCE com prefixo " + String(++ACRESCE));

Memo1->Lines->Add("decrementa Decresce com sufixo " + String(Decresce--) + " " "decrementa DECRESCE com prefixo " + String(--DECRESCE));

} //---------------------------------------------------------------------------

Operadores relacionais

Existem alguns operadores que fazem comparações e, por isso, são chamados de relacionais:

> maior

>= maior ou igual

< menor

<= menor ou igual

== igual a


> maior

!= diferente

Os operadores relacionais são bastante usados pelas partes dos programas que trabalham com laços e comandos de decisão. O exemplo a seguir usa um desses operadores num programa que coloca um efeito degradê no form: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


void __fastcall TForm1::FormPaint(TObject *Sender) { /* inicia o loop (laço) for com variável ponto flutuante. Aqui está sendo usado um operador relacional menor ou igual */ for ( float fVar = 0; fVar <= 200; fVar = fVar + 0.1) { TRect Val; // tipo que define um retângulo // função que agrupa as coordenadas do retângulo especificado SetRect((RECT *)&Val,0,(Height*fVar) / 200, Width,(Height*(fVar+1)) / 200); //determina a cor para preenchimento do background. Canvas->Brush->Color=RGB(0,0,255-fVar*1.1); // preenche o retângulo especificado no canvas usando o Brush atual Canvas->FillRect(Val); } } //---------------------------------------------------------------------------

void __fastcall TForm1::FormResize(TObject *Sender) { /* determina a repintura do controle depois de outra importante mensagem Windows ser tratada*/ Invalidate(); } //---------------------------------------------------------------------------

O comando if

No início deste curso informamos que usaríamos alguns nomes, comandos ou tipos de dados com os quais você poderia não estar habituado a trabalhar. Em algumas ocasiões, já tivemos oportunidade de usar o


comando if ... else sem, contudo, entrar em detalhes sobre o funcionamento do mesmo, exceto por alguma rápida explicação, até mesmo em comentários, que já devem ter lhe dado uma pequena noção acerca do mesmo. Essa é justamente nossa intenção na utilização antecipada dessas instruções. Você vai tendo contato com os comandos e, aos poucos, assimilando sua utilidade e forma de funcionamento. Dessa forma, o estudo deve ser facilitado no momento que tratamos diretamente do assunto, pois, ainda que não se lembre das minúcias, o comando não será algo totalmente estranho para você.

Dentro de cada bloco de códigos, o fluxo de execução de um programa faz com que as linhas sejam executadas na ordem em que aparecem. Por exemplo: Edit1 -> Text == ""; Edit1 -> SetFocus();

Nestas duas linhas acima, primeiro será esvaziado o Text de Edit1 que depois receberá o foco.

Todavia, é bastante comum um programa precisar quebrar esse fluxo na execução, seguindo por um caminho diferente, deixando de executar determinadas instruções em resposta a certas condições. O comando if permite testar uma condição (por exemplo, se o valor de uma variável booleana é verdadeiro - true) e seguir para uma ou outra parte do código em virtude do resultado desse teste.

Podemos resumir o uso do if da seguinte forma:

if(expressão)

comando;

É mais comum que a expressão avaliada pelo comando if seja do tipo relacional, mas, em princípio, pode ser de qualquer tipo. Feita a avaliação pelo comando, se o resultado da expressão for zero, ela é considerada falsa, e o comando não será executado. Se o valor da expressão for diferente de zero, ela é considerada verdadeira, e o comando será executado.

No exemplo: void __fastcall TForm1::Button1Click(TObject *Sender) { if(Edit1 -> Text == "") Edit1 -> SetFocus(); }

Quando o usuário der um clique no botão, o foco ira para Edit1 somente se Edit1 estiver vazio.

Também podemos determinar um bloco de comandos entre chaves { }: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { if(Edit1 -> Text == "") { Edit1 -> Text = "Primeiro Comando deste bloco"; Label1 -> Caption = "Segundo Comando deste bloco";


Memo1 -> Lines -> Add("Terceiro Comando e último comando deste bloco"); } }

O exemplo a seguir usa um ComboBox, um Label e um Button no Form. Quando o usuário dá um clique no botão, IndexOf() faz uma busca pelo item que contém a string Teste no ComboBox. Se o item é encontrado, o valor numérico do item é atribuído à variável que passará a ter um valor igual ou maior do que zero (zero corresponde ao primeiro item da relação no ComboBox, 1 ao segundo e assim por diante). Feito isso, o programa chama Delete() para apagar o item correspondente à busca. Consecutivamente, o programa informa o valor da variável no Label. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { /* Adiciona cabeçalho (texto) e items no ComboBox na inicialização do programa*/ ComboBox1 -> Text = "Fatos e Testes"; ComboBox1 -> Items -> Add("Hoje é 22 de julho de 2002"); ComboBox1 -> Items -> Add("Teste"); ComboBox1 -> Items -> Add("Está fazendo um pouco de frio"); ComboBox1 -> Items -> Add("A Marta é professora"); ComboBox1 -> Items -> Add("Ela está trabalhando no Jd. Álamo");

} //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { /* declara e inicializa variável iBusc com o número devolvido por IndexOf() para o item que contém Teste*/ int iBusc = ComboBox1->Items->IndexOf("Teste"); // se a a busca tiver êxito, a variável possui valor diferente de -1 if (iBusc > -1) // chama Delete() para apagar o item buscado ComboBox1->Items->Delete(iBusc);

} //---------------------------------------------------------------------------


O comando else

Pode ocorrer de um aplicativo ter de executar uma instrução se determinada condição for verdadeira, e outra instrução se tal condição for falsa. Um recurso oferecido por C++ para essas situação é a combinação if ... else.

A forma do uso de if ... else pode ser resumido da seguinte forma:

if(expressão)

comando;

else

outro_comando;

O Exemplo a seguir usa um Edit, um Label e um Button no Form. Quando o usuário dá um clique no botão, o programa fará uma busca pelo arquivo, cujo caminho estiver especificado no Edit. O resultado da busca será informado no Label. //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { /* Declara e inicializa variável BuscArquiv com o resultado da busca por um arquivo, cujo caminho completo é especificado em Edit1 */ AnsiString BuscArquiv = FileSearch(Edit1->Text, GetCurrentDir()); // Se BuscArquiv estivar vazia (pelo fato de a busca fracassar) if (BuscArquiv == "") // O Label informará que não encontrou o arquivo Label1 -> Caption = "Não foi possível encontrar " + Edit1->Text + "."; // caso contrário (Se houver algum dado em BuscArquiv) else // Label informará que encontrou o arquivo Label1 -> Caption = "Encontrado " + BuscArquiv + "."; } //---------------------------------------------------------------------------

if ...else - Continuação

O comando if ... else comporta em seu interior quaisquer outros comandos, incluindo combinações else if, if ... else: //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { if(StrToInt(Edit1 -> Text) >= StrToInt(Edit2 -> Text)) { if((StrToInt(Edit1 -> Text) % StrToInt(Edit2 -> Text)) == 0) { if(StrToInt(Edit1 -> Text) == StrToInt(Edit2 -> Text))


Label1 -> Caption = "O número de Edit1 é igual ao de Edit2!!!"; else Label1 -> Caption = "O número de Edit1 é multiplo do de Edit2"; } else Label1 -> Caption = "O número de Edit1 não é múltiplo do de Edit2"; } else Label1 -> Caption = "O número de Edit2 é maior que o de Edit1";

} //---------------------------------------------------------------------------

Nota: O comando else nem sempre estará associado ao comando if mais recente. Um comando if contido com todas as suas instruções num bloco de chaves {} deverá remeter o else (fora desse bloco) para o if antecedente. Um bloco de código, em virtude de "pequenas" alterações, poderá apresentar resultados totalmente diferentes. Por exemplo: //-----------------------------------------------------------------------------

int x = 45, y = 200, z = 10; if (x == 1) { // início do bloco if (y == 200) z = y - x; } //fim do bloco sem else else // a instrução desse comando será aplicada se x for diferente de 1 z = y + x; Label1->Caption = z; /*Resultado: z = 245, pois o comando else, em virtude das chaves {}, está relacionado com o primeiro if, cuja condição é falsa, porque x é diferente de 1 */

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

int x = 45, y = 200, z = 10; if (x == 1); //o ponto e vírgula faz a diferença. Não existe instrução para essa condição if (y == 200) z = y - x; // Ok. y é igual a 200 else z = y + x; // essa instrução seria aplicada se y fosse diferente de 200 Label1->Caption = z; /*Resultado: z = 155, porque o primeiro if não é levado em consideração em virtude do ponto e vírgula que deixa a instrução deste comando vazia */

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

int x = 45, y = 200, z = 10; if (x == 1) if (y == 200) z = y - x; else z = y + x; Label1->Caption = z; /*Resultado: z = 10, pois o programa avalia as duas condições e não encontra uma opção (um segundo else) para o fato de a primeira condição ser falsa */

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


int x = 45, y = 200, z = 10; if (x == 1) if (y == 200) z = y - x; else z = y + x; else z = 300; Label1 -> Caption = z; /* Resultado: z = 300, pois esse segundo else vai de encontro com o fato de a primeira condição ser falsa */

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

int x = 45, y = 200, z = 10; if (x == 45) if (y == 200) z = y - x; else z = y + x; Label1 -> Caption = z; // Resultado: z = 155, porque as duas condições são verdadeiras.

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

Comandos aninhados e Indentação

Já tivemos oportunidade de mostrar a grande importância do correto uso das chaves {} nos comandos if ... else. Dito isso, é bom realçarmos que esses comandos podem ser aninhados tantas vezes quantas forem necessárias, ou seja, um if ... else pode conter outro if ... else, que pode conter outro if ... else etc, etc, etc.

Esse tipo de codificação pode se tornar difícil de escrever e interpretar, induzindo a erros. Daí a necessidade do adequado uso das chaves {}, bem como de recursos que facilitem a escrita como a indentação do código.

Promover à indentação do código significa indicar os níveis de aninhamento de suas diversas partes, afastando-se gradualmente (através de espaços ou tabulações) as linhas (ou blocos) de código da margem da página: void __fastcall TForm1::Button1Click(TObject *Sender) { if(Edit1->Text == "Olá") Label1->Caption = "Olá"; else if(Edit1->Text == "Pessoal") Label1->Caption = "Pessoal"; else if(Edit1->Text == "da cidade") Label1->Caption = "da cidade"; else if(Edit1->Text == "de Assis") Label1->Caption = "de Assis"; else Label1->Caption = "Olá pessoal de Assis!!!";


} //---------------------------------------------------------------------------

Conforme o caso, podemos tornar mais legíveis as construções aninhadas if ... else, sem o recurso da identação:

void __fastcall TForm1::Button1Click(TObject *Sender) { if(Edit1->Text == "Olá") Label1->Caption = "Olá"; else if(Edit1->Text == "Pessoal") Label1->Caption = "Pessoal"; else if(Edit1->Text == "da cidade") Label1->Caption = "da cidade"; else if(Edit1->Text == "de Assis") Label1->Caption = "de Assis"; else Label1->Caption = "Olá pessoal de Assis!!!"; }//---------------------------------------------------------------------------

Operadores lógicos

Pode ocorrer de um comando precisar receber mais de uma resposta para tomar uma decisão.

A linguagem C++ oferece três operadores lógicos que são:

&& significa: E

|| significa: OU

! significa: NÃO

A sintaxe é:

expressão_1 && expressão_2

resulta verdadeiro somente se ambas as expressões forem verdadeiras;

expressão_1 || expressão_2

se pelo menos uma das expressões for verdadeira, o resultado será verdadeiro;

! expressão

o resultado será verdadeiro somente se a expressão for falsa.

Como os dois primeiros operadores avaliam duas expressões, são classificados como binários; já o último, unário.

Nota: O tipo TShiftState é usado para eventos de teclado e eventos do mouse para determinar o estado das teclas Alt, Ctrl e Shift, bem como dos botões do mouse, quando ocorrer um evento. Trata-se de um grupo de flags que indica o seguinte:


ssShift A tecla Shift está segura em baixo.

ssAlt A tecla Alt está segura em baixo.

ssCtrl A tecla Ctrl está segura em baixo.

ssLeft O botão esquerdo do mouse está seguro em baixo.

ssMiddle O botão do meio do mouse está seguro em baixo..

ssDouble O mouse recebeu um duplo clique.

O exemplo a seguir leva um label no Form. Conforme o usuário produzir um dos eventos acima, uma resposta diferente será dada pelo programa: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


void __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key, TShiftState Shift) { if(Shift.Contains(ssCtrl) && Shift.Contains(ssShift)) Label1->Caption = "Tecla Ctrl \"e\" tecla Shift pressionadas";

if(!Shift.Contains(ssAlt) && !Shift.Contains(ssCtrl) && !Shift.Contains(ssShift)) ShowMessage("A tecla pressionada não é a tecla Alt, Shift ou Ctrl."); } //--------------------------------------------------------------------------- void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { if(Shift.Contains(ssDouble) || Shift.Contains(ssLeft)) Label1->Caption = "Evento do mouse detectado: Duplo Clique \"ou\" botão esquerdo."; } //---------------------------------------------------------------------------

O operador condicional ternário

C++ possui o operador condicional ternário ? : que nos formece uma maneira concisa de expressar, simplificadamente, uma instrução if ... else:


condição? expressão_1 : expressão_2;

É feita uma avaliação da condição. Se ela for verdadeira, o programa retornará a expressão_1; se falsa, a expressão_2. A nomenclatura ternário decorre do fato de o operador manipular três termos. Embora o operador condicional ternário seja constituído de dois caracteres (? :), trata-se de um único operador.

O exemplo a seguir leva um Edit no Form e é usado para permitir a edição de valores numéricos inteiros:

//--------------------------------------------------------------------------- void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key) { isdigit(Key)? Key<48 || Key>57 : Key = 0; } //---------------------------------------------------------------------------

Funções

Todos os aplicativos escritos em linguagem C ou C++ iniciam a execução do programa através de uma função principal. Nas aplicações tipo Console, essa função denomina-se main. Aplicações Win32 GUI chamam WinMain para iniciar a execução:

int WINAPI WinMain( HINSTANCE hInstance, // manipulador da instancia atual HINSTANCE hPrevInstance, // manipulador da instancia prévia LPSTR lpszCmdLine, // ponteiro à línha de comando int nCmdShow // estado de visualização da janela );

A função WinMain tem quatro parâmetros de entrada:

hInstance é um manipulador para a instância do programa que estamos executando. Cada vez que se executa uma aplicação, o Windows cria uma Instância para ela, e lhe passa um manipulador de dita instância para a aplicação

hPrevInstance é um manipulador a instâncias prévias da mesma aplicação. Como o Windows é multitarefa, podem existir várias versões da mesma aplicação executando-se varias instâncias. Em Windows 3.1, este parâmetro nos servia para saber se nossa aplicação já estava sendo executada, e desse modo podiam compartilhar os dados comuns a todas as instâncias. Mas isso era antes, já que em Win32 usa um segmento distinto para cada instância e este parâmetro é sempre NULL, sendo conservado apenas por motivo de compatibilidade

lpszCmdLine ponteiro a uma cadeia (terminada em zero) que especifica os argumentos


hInstance é um manipulador para a instância do programa que estamos executando. Cada vez que se executa uma aplicação, o Windows cria uma Instância para ela, e lhe passa um manipulador de dita instância para a aplicação

de entrada da linha de comando da aplicação

nCmdShow este parâmetro especifica como se mostrará a janela

Não entraremos em detalhes sobre essa função, visto que tal assunto está reservado para outro curso, sobre WinAPI, que em breve esperamos estar disponibilizando neste Sítio:

Eis um arquivo básico de um Project.cpp do C++Builder, onde podemos visualizar a função principal:

//--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop USERES("Project2.res"); USEFORM("Unit1.cpp", Form1); //--------------------------------------------------------------------------- WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { try { Application->Initialize(); Application->CreateForm(__classid(TForm1), &Form1); Application->Run(); } catch (Exception &exception) { Application->ShowException(&exception); } return 0; } //---------------------------------------------------------------------------

A função acima encontra-se num arquivo em separado daqueles que estamos acostumados a trabalhar.

Via de regra, em C++, é irrelevante se a função inicial está colocada no início ou no fim do arquivo, pois o programa ignorará o fato, executando do mesmo jeito, tanto numa quanto noutra posição. Evidentemente, no BCB não devemos alterar, sem prévio conhecimento, o conteúdo ou disposição da função WinAPI.

As instruções em C++ aparecem dentro de alguma função, ou seja, de um grupo de comandos que executa alguma tarefa, sendo que as funções podem conter instruções que chamam outras funções, bem como retornar algum valor no seu encerramento para a instrução chamadora.

Criamos a função AloCy() no exemplo abaixo. Quando o usuário der um clique no botão colocado no Form, AloCy() será chamada para imprimir uma mensagem no Label1.


//-------------------ilustra o uso de uma função ---------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- void AloCy(); // Protótipo da função //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { AloCy(); // Chama a função AloCy() } //--------------------------------------------------------------------------- // Definição da função AloCy() void AloCy() { Form1 -> Label1 -> Caption = "Alô, Cy!!!! \n" "Como estão todos aí em Araçatuba???" "\nEstou com saudades !!!!!"; }

NOTA: Esclarecemos que neste e nos próximos tópicos estaremos trabalhando com funções de uma maneira que, embora não seja incorreta, não é a convencional para o C++Builder. Basicamente estaremos preocupados em conhecer os fundamentos das funções em C++, sem nos preocupar se essa é a forma ideal de se trabalhar com o BCB.

Chamada de Funções

Já tivemos oportunidade de, em tópicos anteriores, verificar que todo programa C++ deve ter uma função principal denominada main() ou, conforme o caso, WinMain(), não podendo haver outra função com esse mesmo nome, sendo que a execução do programa sempre será iniciado por essa função. As funções main() e WinMain() são diferentes das outras funções, visto que estas são chamadas após iniciada e ao longo da execução do programa.

Evidente que uma função, quando é chamada, pode também chamar a uma outra função: //-------------------ilustra chamada de funções----------------------------- #include <vcl.h> #pragma hdrstop


#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- void AloCy(); // Protótipo da função AloCy() void AloDau(); // Protótipo da função AloDau() //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { AloCy(); // Chama a função AloCy() } //--------------------------------------------------------------------------- // Definição da função AloCy() void AloCy() { Form1 -> Label1 -> Caption = "Alô, Cy!!!! \n" "Como estão todos aí em Araçatuba???" "\nEstou com saudades !!!!!"; AloDau(); // Chama AloDau() return; } //-------------------------------------------------------------------------- // Definição de AloDau() void AloDau() { // Acrescenta dados no caption de Label1, sem apagar o que já está nele Form1 -> Label1 -> Caption = Form1 -> Label1 -> Caption + "\nAlo, Daury!!!!"; return; } //--------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { Label1->Caption = ""; // Limpa o caption de Label1 } //---------------------------------------------------------------------------

Definição de uma função

A definição de uma função se dá por meio de um cabeçalho e de um corpo. O cabeçalho é constituído pelo tipo retornado, pelo nome da função, bem como pelos parâmetros que a mesma recebe. Os parâmetros são declarações dos tipos dos valores ou os dados que serão passados para a função, e sobre os quais a função poderá operar. Os dados ou valores passados são denominados de argumentos. Por exemplo, se desejássemos que uma função efetue uma operação matemática de divisão de dois números


inteiros e nos devolva o resultado que poderia ser valor um ponto flutuante, poderíamos ter o cabeçalho da definição assim:

float Opera_Divisao( int, int)

Já o corpo da função consiste de uma chave de abertura {

seguida pelos comandos que executam a tarefa da função, seguidos pela chave de fechamento

}

Por exemplo:

float Opera_Divisao( int Divsr, int Divdnd) { float Result = Divsr / Divdnd; Return Result; }

O Exemplo abaixo possui um Button, um Edit e um Label. Preste bastante atenção nos comentários, pois eles explicam os códigos com detalhes: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- /* Protótipo da função com o tipo retornado, o nome da função e o parâmetro entre parênteses*/ AnsiString Recb_Pass(AnsiString); //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { /* Cria um texto para Edit1 e um caption para Label1 em tempo de execução*/ Edit1 -> Text = "Essa string será passada para" " a função Recb_Pass() que a imprimirá em Label1";

Label1 -> Caption = "Esta string será devolvida para Edit1"; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Valor_Devolvido; // declara variável para receber valor de Recb_Pass()


/* recebe valor devolvido pelo comando return de Recb_Pass()*/ Valor_Devolvido = /*Texto de Edit1 será passado como parâmetro para Recb_Pass()*/ Recb_Pass (Edit1 -> Text); /*O valor devolvido por Recb_Pass() será o novo texto de Edit1*/ Edit1 -> Text = Valor_Devolvido; /*Desabilita Button1 para evitar que valores sejam trocados a cada clique do mouse*/ Button1 -> Enabled = false; } //--------------------------------------------------------------------------- //Definição de Recb_Pass() //Recb_Pass() devolverá um valor tipo AnsiString //Recb_Pass() receberá AnsiString de Edit1->Text AnsiString Recb_Pass(AnsiString Valor_Recebido) { /*Antes de alterar o caption de Label1, acumula o valor atual na variável Valor_a_Devolver para retorná-lo via comando return*/ AnsiString Valor_a_Devolver = Form1 -> Label1 -> Caption; //Coloca o valor recebido no Caption de Label Form1 -> Label1 -> Caption = Valor_Recebido; //Devolve o valor acumulado do caption de Label1 return Valor_a_Devolver; }

Protótipos de funções

Não podemos usar uma função sem declará-la previamente. Trata-se duma instrução geralmente colocada no início do programa ou do arquivo, obrigatoriamente antecedendo a definição e a chamada da função.

O protótipo informa ao compilador o tipo que a função retorna, o nome da função, bem como os parâmetros que ela recebe. Eis um exemplo:

double diametro (int raio);

Esse protótipo está declarando uma função chamada diametro, que recebe um valor inteiro (a declaração int dentro dos parênteses: diametro(int raio)) e devolve um valor ponto flutuante (o double que antecede o nome da função: double diâmetro()). Poderiam ser quaisquer outros tipos.

O protótipo e a definição da função devem conter o mesmo nome, o mesmo tipo retornado e a mesma lista de parâmetros:

double diametro(int raio); // Protótipo da função: com ponto e vírgula após os parênteses

double diametro(int raio) // Definição da função: sem ponto e vírgula { // chave de abertura do corpa da função return raio * 3.14; // única instrução dessa função } // chave de encerramento da função


O nome da variável passada como parâmetro (em nosso exemplo, a inteira raio) é facultativo, mas o tipo é obrigatório. Quanto ao valor de retorno será um tipo, ou será void (caso não haja valor de retorno):

void diametro(int raio); // Protótipo da função

Se nenhum tipo for especificado como valor de retorno, o compilador retornará o tipo int:

O exemplo: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- Experimenta_Tipos(char raio); // Protótipo da função //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { // o caption de Label1 chama diametro e passa o caracter 'a' como parâmetro /* IMPORTANTE: em qualquer hipótese, na chamada à função não podemos colocar o tipo de retorno, pois o compilador retornará mensagem de ERRO*/ Label1 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a'); } //---------------------------------------------------------------------------

Experimenta_Tipos(char raio) /* Definição da função sem tipo especificado para retorno. A função retornará como sendo int */ { // 'a' equivale a 97 na tabela ASCII. return raio * 1000.01; }

terá como valor de retorno: 97000.

Experimente, nesse mesmo exemplo, colocar como valor de retorno o tipo char. Depois faça o mesmo como o tipo double. Com essas pequenas pequenas alterações, você poderá visualizar os diferentes comportamentos do compilador.

Além da forma de declaração apresentada (protótipo externo, pois é escrito fora e antes das funções), existe a possibilidade de declararmos o protótipo dentro do corpo de cada função chamadora (protótipo interno).


Para esses casos, há duas restrições:

1ª. A função é visível apenas dentro do bloco onde estiver o seu protótipo;

2ª. devemos declarar o tipo retornado no protótipo (ou void), para que o compilador não interprete o protótipo como uma chamada à função e, conseqüentemente, retorne uma mensagem de erro:

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

void __fastcall TForm1::Label1Click(TObject *Sender) { char Experimenta_Tipos(char raio); // Protótipo da função Label1 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a'); } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { char Experimenta_Tipos(char raio); // Protótipo da função Label2 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a'); } //---------------------------------------------------------------------------

Variáveis locais e globais

Já tivemos oportunidade de trabalhar com variáveis locais e globais sem, contudo, entrar em detalhes acerca de suas particularidades.

Comecemos pelas variáveis locais. Imaginemos o seguinte bloco de códigos com as respectivas mensagens de erro na forma de comentários:

void __fastcall TForm1::Button1Click(TObject *Sender) { // início do primeiro bloco (bloco externo)

// [C++ Error] Unit1.cpp(20): E2451 Undefined symbol 'a'. Label1->Caption = a;

{ // início do segundo bloco (bloco interno)

int a = 10, b = 20; Label2->Caption = a + b; // Ok. Label2 enxerga as variáveis "a" e "b"

// [C++ Error] Unit1.cpp(24): E2451 Undefined symbol 'c'. Label3->Caption = a + b + c; // Erro. Label3 não enxerga "c"

// [C++ Error] Unit1.cpp(25): E2238 Multiple declaration for 'c'. int c = 30; } // fim do bloco interno

//[C++ Error] Unit1.cpp(27): E2451 Undefined symbol 'c'.


Label4->Caption = c;

} // fim do bloco externo

Analisemos o código. No exemplo acima visualizamos dois blocos de código: um externo e outro interno.

1 - O componente Label1 não enxerga a variável porque sua chamada encontra-se antes e fora do bloco da declaração de a;

2 - não temos qualquer problema com o componente Label2 porque sua chamada se encontra no mesmo bloco e após as declarações das variáveis a e b;

3 - Embora a chamada a Label3 se encontre no mesmo bloco, é anterior à declaração da variável c.

4 - Label4 não enxerga a variável c pelo fato de estar fora do bloco onde tal variável é declarada.

Conclusão: podemos entender como locais as variáveis que se encontram declaradas dentro de determinado bloco, com a ressalva de que essas variáveis são visíveis apenas dentro desse bloco e a partir do local de sua declaração:

Já as variáveis globais devem ser declaradas antes e fora de qualquer função, uma vez que elas serão visíveis somente pelas instruções posteriores à sua declaração. Logo se você quiser que uma variável seja "vista" por todas as funções de uma determinada Unit, pode declará-la na região dos include. A seguir ilustramos um exemplo que demonstra a o relacionamento existente entre as variáveis globais e locais:

//--------------------------------------------------------------------------- // Unit1.cpp


#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- int global_1 = 50; // declara e inicializa variável global //---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { /*o código abaixo apresentará um erro, pois Button1Click não enxerga global_2 */


Label1->Caption = global_1 + global_2; } //---------------------------------------------------------------------------

int global_2; //variável que será visível somente pelas funções abaixo dela

void __fastcall TForm1::Button2Click(TObject *Sender) { global_2 = 45; // aqui essa variável adquire característica de global

int local_de_Button2Click = 12; // variável local

// não haverá erro Label1->Caption = global_1 + global_2 + local_de_Button2Click;

} //---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender) { // ERRO: local_de_Button2Click não pode ser visualizada // pelo evento OnClick de Button3. ELA É LOCAL A Button2Click

Label1->Caption = global_1 + global_2 + local_de_Button2Click; } //---------------------------------------------------------------------------

Muito importante: as variáveis locais são criadas pelo aplicativo cada vez que sua declaração é encontrada pela execução do programa e são destruídas cada vez que a execução sai do bloco em que elas se encontram; já as variáveis globais são criadas uma única vez no início do programa e destruídas uma única vez no encerramento do programa.

O resultado da observação acima é que, cada vez que uma variável local for destruída, se ela for criada novamente, não terá conservado o valor que possuía no momento em que foi destruída. Será inicializada novamente com o valor que lhe for atribuído no momento apropriado.

Quanto às variáveis globais, seus valores vão sendo alterados durante a execução do programa, sendo que cada vez que tal variável for chamada trará em si o valor resultante da última operação em que foi tratada.

A palavra-chave extern

As palavras-chaves extern e static são recursos oferecidos pela linguagem C++ para alterar o comportamento dos conceitos local e global, abordados no tópico anterior.

A palavra-chave extern pode ser usada para que um arquivo fonte possa usar uma variável global que se encontra definida em outro arquivo fonte.


O exemplo a seguir trabalha com dois Forms. O primeiro leva um Label e três Buttons. O segundo leva um Label e um Button. Declaramos duas variáveis inteiras globais no primeiro formulário (Form1), as inicializamos e alteramos seus valores conforme o componente que recebe um clique, exibindo o resultado em Label1. No segundo formulário (Form2), através da palavra-chave extern, manipulamos e exibimos o resultado, conforme o componente que recebe o clique do mouse:

Unit1.h //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" #include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- int a, b; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { a = 1; b = 2; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { a = 100; b = 200; } //--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { Label1->Caption = a + b; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button3Click(TObject *Sender) { Form2->ShowModal();

} //---------------------------------------------------------------------------


Unit2.h


#include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm2 *Form2; //--------------------------------------------------------------------------- extern int a; extern int b; //--------------------------------------------------------------------------- __fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm2::Label1Click(TObject *Sender) { Label1->Caption = a + b; } //--------------------------------------------------------------------------- void __fastcall TForm2::Button1Click(TObject *Sender) { a = 1000; b = 2000;

} //---------------------------------------------------------------------------

O recurso extern é um modo de trabalhar uma mesma variável em mais de um arquivo, guardando sempre o último valor atribuído à variável, não importando em qual arquivo se tenha dado tal atribuição.

Em C++ , extern não é mais tão necessário por causa do conceito de namespace, o qual é mais facilmente gerenciado em sistemas grandes. Futuramente abordaremos esse conceito.

A palavra-chave static

As palavra-chave static, usada junto a variáveis, possui uma amplitude maior, visto que possui três significados distintos. Vejamos cada um deles:

1 - Dentro de um bloco:


Como sabemos, as variáveis declaradas dentro de um bloco, só existem durante a execução do bloco. Quando o bloco acaba, elas são destruídas. Exemplo:

void __fastcall TForm1::Label1Click(TObject *Sender) { int numero = 16; numero+= numero; Label1->Caption = numero; }

O exemplo acima sempre exibirá o número 32 no label. Isto acontece porque cada vez que a função é chamada, a variável numero é criada com o valor dezesseis, e quando a função acaba, ela é destruída. Se alterarmos a forma de declarar a variável, inserindo a palavra-chave static:

void __fastcall TForm1::Label1Click(TObject *Sender) { static int numero = 16; numero+= numero; Label1->Caption = numero; }

tudo muda de figura. Declarada deste modo, a variável numero é criada uma única vez, e não é destruída até o encerramento do programa. Note que ela não poderá ser usada fora do bloco onde foi declarada, mas, exceto por esse fato, essa variável comporta-se exatamente como uma variável global. Deste modo, na primeira vez que chamamos Label1Click(), o label exibe 32; na segunda, 64; na terceira, 128; e assim por diante... a cada nova chamada, a variável numero já está lá, com o valor deixado na última chamada.

2 - Em variável global.

Em uma variável global, a palavra static esconde a variável de acessos através de declarações extern. Assim se definimos a variável global numero como:


#include "Unit1.h" #include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- static int numero = 10; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { }


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

void __fastcall TForm1::Label1Click(TObject *Sender) { numero+= numero; Label1->Caption = numero; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { Form2->ShowModal(); } //---------------------------------------------------------------------------

esta variável global numero só poderá ser usada dentro do fonte em que foi definida.

Uma outra unidade como essa a seguir:


#include "Unit2.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm2 *Form2; //--------------------------------------------------------------------------- extern int numero; //--------------------------------------------------------------------------- __fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm2::Label1Click(TObject *Sender) { numero+= numero; Label1->Caption = numero; } //---------------------------------------------------------------------------

não apresentará o resultado esperado para extern int numero, provavelmente apresentando alguma mensagem de erro: [Linker Error] Unresolved external '_numero' referenced from C:\ARQUIVOS DE PROGRAMAS\BORLAND\CBUILDER4\PROJECTS\UNIT2.OBJ.

Esse resultado pode ser desejado para reduzir a interferências entre equipes de programação.

3) Em uma definição de classe


Em uma definição de classe, a palavra static indica que um dado membro é compartilhado por todas as instâncias da classe. Esse uso para static em C++ será abordado no momento oportuno, quando estivermos estudando as classes.

Parâmetros das funções

passando argumentos por valor

Podemos, de modo errado, supor que toda vez que passamos valores na forma de argumentos para outras funções, estas, ao manipular esses dados, estariam alterando o valor original das mesmas. Observe o exemplo, onde criamos uma função para manipular os dados recebidos de ButtonClick():


#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- void Impr_Label_1(int a, int b); // Protótipo da função //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { int a = 10, b = 40; // declara e inicializa duas inteiras /* imprime os valores de a e b em Label1*/ Label1 -> Caption = "Valor de a = " + String(a) + "\n" + "Valor de b = " + String(b) + "\n";

Impr_Label_1(a, b); // chama a função Impr_Label_1 pasando argumentos por valor

/* após o comando retornar para Button1Click(), imprime novamente o valor local de a e b no Label, adicionando esta impressão aos valores que já estavem no Label*/ Label1 -> Caption = Label1 -> Caption + "\n" + "Valor de a após a chamada a Impr_Label_1() = " + String(a) + "\n" + "Valor de b após a chamada a Impr_Label_1() = " + String(b) + "\n";


} //--------------------------------------------------------------------------- void Impr_Label_1(int a, int b) { /* A função Impr_Label_1() recebe dois valores e cria cópias dessas variáveis para operar */

a = 100; // altera o valor da variável a (cópia) para 100 b = 400; // altera o valor da variável b (cópia) para 400

/*Imprime o valor das variáveis originais e das cópias no label*/ Form1 -> Label1 -> Caption = Form1 -> Label1 -> Caption + "\n" + "Valor de a em Impr_Label_1() = " + String(a) + "\n" + "Valor de b em Impr_Label_1() = " + String(b) + "\n";

return; // não há valores a retornar }

Na execução deste programa. ocorre o seguinte: Quando o usuário dá um clique no botão, o valor das variáveis a e b são imprimidos no Label e é chamada a função Impr_Label_1(a, b) que recebe os valores de a e b como argumentos. Impr_Label_1() cria uma cópia para cada argumento que lhe foi passado e opera sobre essas cópias, alterando e imprimindo os novos valores no Label. Quando a função retorna o controle para a função chamadora, todas as cópias criadas em Impr_Label_1(a, b) são destruídas e, então, ButtonClick() imprime novamente no Label os valores das variáveis a e b que, nessa função, permanecem inalterados.

Passar argumentos dessa forma, onde a função cria cópias dos valores transmitidos, dá-se o nome de: passar argumentos por valor.

Podemos, então, concluir que os valores passados dessa forma a uma função funcionam como variáveis locais a essa função.

O comando return

Quando tivermos que retornar um valor de alguma função, devemos fazê-lo através do comando return, seguido do valor a ser retornado:

return altura * largura;

return 412;

Podemos retornar uma expressão, cujo valor deve ser compatível com o valor retornado por return:

return(ImprLabel_1(int, int));


return (i <= 100);

Se não houver valores a retornar, usamos a palavra void indicando a circunstância:

void Impr_Diam(int raio); // protótipo

O comando return funciona como uma porta de saída da função. Assim que é executado, a expressão que o segue é retornada, sendo desconsideradas todas as instruções posteriores. Contudo, o fato de um comando return ser encontrado, não significa necessariamente que o mesmo será executado, pois poderá haver um desvio na linha de execução do código. Daí, podemos ter um ou mais comandos return numa função: if(a > b) return a; else return b;

Exemplo: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- int Form_Capt(int, int); // protótipo - recebe dois inteiros e devolve um //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { int a = 10, b = 40; //declara e inicializa duas int que serão passadas como argumentos da função Form1->Caption = Form_Capt(a, b); // Chama Form_Capt(), passando a e b como argumentos } //--------------------------------------------------------------------------- int Form_Capt(int c, int d) { if(c > d) return c * d; // retorna c vezes d se c for maior que d else if(c == d) return c + d; // retorna c mais d se c for igual a d else return d - c; // retorna c menos d se c for menor que d

}


Valores Default

Conforme vimos, na chamada de uma função existe a necessidade de fornecermos um argumento que corresponda a cada parâmetro declarado no protótipo e na definição da função, respeitando-se os tipos que aparecem no protótipo:

/*double*/ conta (/*int*/ a, /*double*/ b);

Podemos, contudo, estabelecer um valor defaut (padrão) para um ou mais parâmetros:

/*protótipo*/ double conta ( int raio, double Pi = 3.1416);

Em tais situações, se na chamada à função não fornecermos um valor, o default será usado:

conta ( raio); // chamada à função

Se, porém, fornecermos um valor, o default não será usado:

double Pi = 3.14; conta (raio, Pi); // chamada à função

Não há limites para a quantia de parâmetros com valores default. A única exigência é que os parâmetros com valores default devem ser, sempre, os últimos na lista de parâmetros de uma função. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- /*protótipo*/ double conta ( int raio, double Pi = 3.1416); //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { double diametro = conta(6); ShowMessage((String)"O diâmetro com o default é: " + diametro); }


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

void __fastcall TForm1::Button2Click(TObject *Sender) { double diametro = conta(6, 3.14); ShowMessage((String)"O diâmetro sem o default é: " + diametro); } //---------------------------------------------------------------------------

/*definição*/ double conta ( int i, double Pi) { return 2*Pi*i; }

Funções inline

Quando uma função é chamada, a execução do programa salta para o grupo de instruções constantes dessa função na memória. Encerrada a função, a execução do programa retorna para a linha de código seguinte àquela que chamou a função.

Esse trabalho de saltar para o conjunto de instruções onde se encontra definida a função e depois retornar para a linha de código seguinte à instrução chamadora à função denota um trabalho que ocupa certo espaço em memória, acarretando determinada quantidade de tempo para ser executada.

Para ganhar um pouco de tempo, podemos colocar a palavra-chave inline como primeira palavra do cabeçalho da definição de uma função, para que seja inserida uma cópia da função em todo lugar onde a mesma é chamada. Contudo esse procedimento só se justifica se a função chamada for muito pequena (uma ou duas linhas de instruções), pois nesses casos as instruções necessárias à chamada da função podem ocupar mais espaço na memória do que as instruções do seu próprio código.

Outro cuidado a ser tomado é que a definição (e não o protótipo apenas) da função deve anteceder à sua primeira chamada.

Não devemos esquecer que se uma função inline for chamada muitas vezes, a mesma quantia de vezes será realizada uma cópia de seu código no programa, o que poderá significar um aumento considerável no tamanho do executável.

O exemplo a seguir leva um Label no Form e é usado para devolver o valor da área de um retângulo: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- inline int Area(int a, int b)


{ return(a * b); } //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { int x, y; x = StrToInt(InputBox("Cálculo da área", "entre com o valor de um lado", "")); y = StrToInt(InputBox("Cálculo da área", "entre com o valor do outro lado", "")); Label1->Caption = (String)"Área = " + Area(x, y); } //---------------------------------------------------------------------------

O comando goto

A instrução goto é formada por duas partes: o comando goto e um rótulo:

goto Erro;

A instrução goto causa um desvio na execução normal do programa para a instrução seguinte ao rótulo. Um rótulo é um nome (que respeita a convenção para a nomenclatura de variáveis) que deve ser colocada em dois locais: imediatamente após a instrução goto e, completada por dois pontos, antecedendo a instrução para a qual o goto desviará a execução do programa: Erro: ShowMessage("Erro... Não é possível efetuar divisão por zero..."); // ... if(Divid / 0) goto Erro; // ...

No exemplo, se o usuário tentar efetuar uma divisão por zero, o comando goto remeterá a execução do programa para " Erro: " que chamará uma caixa de mensagem.

Existem códigos que possibilitam usar o goto como um laço (loop), mas é desaconselhável, uma vez que os laços for , while e do... while fazem com muito mais segurança a tarefa.

O loop while

LAÇOS - Algumas vezes um aplicativo precisa executar operações repetitivas. A fim de evitar que um programador tenha de repetir uma diversidade de vezes um mesmo código, criou-se o conceito de loop (ou laço).


Laços são comandos que fazem com que uma ou mais instruções sejam repetidas enquanto determinada condição não estiver satisfeita.

A linguagem C++ possui três formas de laços:

for

while

do ... while

Podemos imaginar os laços como uma roda gigante que fica girando até que determinada condição se verifique. E a cada giro da roda, determinada tarefa é realizada. A ocorrência da última tarefa dar-se-ia com a satisfação da condição.

Quando não possuímos prévio conhecimento acerca do número de vezes que o corpo de um loop deverá ser executado, o while se mostra como opção mais correta, que, basicamente, fará o seguinte: testará uma condição definida inicialmente; enquanto o comando verificar que a condição continua verdadeira, o conjunto de instruções contido no corpo do laço continuará sendo executado. No instante em que o comando verificar um valor de retorno falso para a condição, o processamento será desviado para fora do laço.

Voltando ao exemplo da roda gigante, no while não haveria a necessidade de uma catraca contando o número de giros, mas um funcionário aguardando a ocorrência de determinado fato para desligar o aparelho, como, por exemplo, uma pessoa pedir para descer do aparelho.

Se a condição avaliada for falsa logo no início do loop, o conjunto de instruções será ignorado e o laço não será executado.

Eis a forma do laço while:

while(condição)

corpo_do_loop;

O exemplo a seguir usa um Label no Form. Quando o usuário dá um clique no label, inicia-se um loop onde o comando while irá procurar nove caracteres z, ou Z, em quantas tabelas ASCII forem necessárias, sendo que essas tabelas serão imprimidas no label. Depois informará o resultado da busca no próprio label. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm"


TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { Label1->Caption = "Dê um clique em mim para iniciar um loop while " "\nonde serão montadas sucessivas tabelas ASCII " "\naté encontrar as letras 'z' ou 'Z' nove vezes!"; } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { Label1 -> Caption = ""; // Apaga o Caption de Label1

// Declara e inicializa três variáveis para ser incrementadas no loop int contador = 0; // variável que contará o número de loops int paraZ = 0; // variável que contará ocorrências de z e Z unsigned char caract = 0; // variável usada para montar as tabelas ASCII

while( paraZ < 9) // enquanto a variável paraZ form menor do que 9 { contador++; // incrementa contador a cada giro do loop caract++; // incrementa caract a cada giro do loop

/* A tabela ASCII vai sendo construída no Caption de Label1 */ Label1->Caption = Label1->Caption + char(caract);

/* Um comando de decisão switch ... case dentro do corpo do loop*/ switch(caract) /* o comando switch ... case avaliará os valores de caract*/ {

/*caso o valor de caract seja 100, 200 ou 256, a tabela ASCII continuará sendo imprimida na linha de baixo do Label1*/ case 100: Label1->Caption = Label1->Caption + '\n'; break; /* o break remete o processamento para fora do comando switch*/ case 200: Label1->Caption = Label1->Caption + '\n'; break; case 256: Label1->Caption = Label1->Caption + '\n'; break;

/*caso o valor de caract seja Z ou z, a variável paraZ sofre um incremento e a execução do programa sai do switch*/ case 'Z': paraZ++; break; case 'z': paraZ++; break; } // fim do comando switch ... case } // fim do loop while

/*o label usará as variáveis paraZ e contador para informar os resultados da busca*/ Label1->Caption = Label1->Caption + "\n\nEncontrei os caracteres " "\"Z\" e \"z\" " + String(paraZ) + " vezes!"; Label1->Caption = Label1->Caption + "\n\nPara encontrar esses caracteres, " "o loop foi executado " + String(contador) + " vezes";

} //---------------------------------------------------------------------------


O comando goto pode fazer com que a execução do programa pule para qualquer ponto visível do código, e seu uso incorreto ou indiscriminado facilita a introdução de erros. Via de regra, os programadores evitam usar esse comando, mas existem ocasiões em que o mesmo poderá ser útil.

break e continue

Existem dois comandos que podemos usar no loop while. O comando continue causa uma interrupção na execução das instruções, remetendo a execução para o topo do laço; já o comando break determina a imediata saída do laço, independentemente de a condição ter sido satisfeita. Ao encontrar a instrução break, a execução do programa é enviada para primeira instrução após a chave de fechamento } do corpo do laço. //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { int i = 1; while(i <= 1000) {

ShowMessage((String)"i é igual a " + i++);

if(i <= 5) continue;

ShowMessage("Agora o corpo todo do laço será executado, até i ser igual a 10");

if(i == 10) { ShowMessage("Agora i é igual a 10 e, embora i ainda não seja 1000, " "vou embora... Adeus..."); break; } }

ShowMessage("Se você está vendo esta mensagem, " "significa que estamos fora do while");

Close();

} //---------------------------------------------------------------------------

O loop while sem fim

Podemos inserir uma condição permanentemente verdadeira (igual a 1) para ser testada por um laço while. Nessas condições, o while será executado indeterminadamente, num loop sem fim. Essas situações carecem de um comando break satisfazendo uma condição de encerramento em algum ponto do laço, para evitar o travamento da máquina.


É preciso tomar um cuidado especial sempre que se utilizar laços nos programas, pois qualquer erro de lógica ou de condição de encerramento poderá fazer com que o programa entre em um loop sem fim. //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { int i = 0; while(1) // também poderia ser: while(true) { ShowMessage((String)"Mensagem número: "+ ++i);

if(i == 10) break;

}

} //--------------------------------------------------------------------------

loop while - continuação

A condição avaliada num loop pode ser qualquer expressão válida em C++, incluindo expressões construídas com o uso de operadores lógicos &&, ||, ! :

Uma das instruções que compõem um bloco de códigos do corpo de um loop while pode ser outro laço while. A essa situação denominamos laços while aninhados.

O exemplo a seguir leva um Button e dois Labels no Form. Quando o usuário der um clique no Button, uma sequência de loops será executada, mostrando o resultado final nos Labels: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


void __fastcall TForm1::Button1Click(TObject *Sender) { Label1->Caption = ""; Label2->Caption = "";

bool bl = true; // variável que nos dará uma das formas de encerrar o loop


int i = 0; // variável para avaliação no primeiro loop int j2 = 0; /* variável que contará o total de vezes que o segundo loop executará */

/*enquanto i for menor ou igual a 10 e bl for verdadeira*/ while(i <= 10 && bl == true) { i++; // incrementa i (i = i + 1)

/*Label1 exibirá o número de vezes que o primeiro loop rodará*/ Label1->Caption = Label1-> Caption + " " + i;

int j = 10; // variável para avaliação no segundo loop

while(j >= 0) /*enquanto j for maior ou igual a zero*/ { j--; // decrementa j (j = j - 1) j2++; // incrementa j2

/*Label1 exibirá o número de vezes que o segundo loop rodará*/ Label2->Caption = Label2->Caption + " " + j2; }

/*condição para forçar o encerramento do loop antes de a variável i ser igual a 10*/ if (i >= 4 && j <= 6) { bl = false; } }

} //---------------------------------------------------------------------------

O loop do... while

A estrutura do laço do... while é muito parecida com a estrutura do laço while. A diferença básica entre elas consiste no fato de, enquanto o teste condicional no comando while é realizado no início do loop (antes das instruções), no laço do... while o teste é realizado no fim do loop (após as instruções).

Dessa forma, o programador garante que pelo menos uma vez as instruções contidas no corpo do laço serão processadas, mesmo que a condição seja falsa.

eis a sintaxe:

do

{

...

}


while(condição)

O exemplo a seguir leva um Button e um Label no Form. Quando o usuário dá um clique no Button, uma mensagem é exibida no Label e, após sete segundos (7000 milisegundos), o programa é encerrado.


void __fastcall Esperar(int Miliseg);


void __fastcall TForm1::Button1Click(TObject *Sender) { Label1->Caption = "Aguarde... Após sete segundos o programa será fechado"; Esperar(7000); // tempo que o programa aguardará até ser encerrado Close(); // encerra o programa } //---------------------------------------------------------------------------

void __fastcall Esperar (int Miliseg) { TDateTime Hora; // declara variável da classe TDateTime unsigned short Hor, Min, Seg, Miles; // declara vairiáveis int Tempo; Hora = Time(); // atribui a hora do sistema à variável Hora

/*todas as instruções abaixo serão executadas ao menos uma vez, (independente de a condição avaliada ser verdadeira) */ do // início do loop {

/*DecodeTime() suspende um objeto TdateTime em horas, minutos, segundos e milisegundos*/ (Time() - Hora).DecodeTime (&Hor, &Min, &Seg, &Miles);

/*incrementa a variável Tempo*/ Tempo = (Min * 60000) + (Seg * 1000) + Miles;

/*interrompe a execução da aplicação possibilitando ao Windows processar determinadas mensagens*/ Application->ProcessMessages(); } /* o loop será executado enquanto Tempo for menor que Miliseg */


while (Tempo < Miliseg); } //---------------------------------------------------------------------------

O loop for

Retornando à idéia de que poderíamos comparar os laços com uma roda-gigante, o laço for funcionaria do seguinte modo: O aparelho começaria a girar e cada volta seria registrada num contador (ou catraca). Quando o aparelho atingisse o número de voltas determinado no controlador da catraca (na condição), o aparelho automaticamente se desligaria.

Isso significa que quando possuímos prévio conhecimento acerca do número de vezes que um loop deverá ser executado (ver while), a melhor opção será o laço for.

A sintaxe do for é um cabeçalho onde encontramos o valor inicial, a condição e a atualização separados por ponto e vírgula dentro de um par de parênteses, antecedendo o corpo do laço que contém os comandos da instrução:

for( valor inicial; condição; atualização)

comando;

Geralmente o valor inicial, também conhecido como inicialização, é uma instrução de atribuição a uma variável (geralmente inteira), que será executado apenas uma vez no início do loop.

A condição é uma instrução que é avaliada sempre que o loop inicia ou reinicia. Se o valor retornado pela condição for verdadeiro (ver while), as instruções do corpo do laço são executadas; caso contrário, se falsa, a execução do programa sai do loop e vai para a instrução seguinte.

A atualização contém a instrução de acordo com que a variável será alterada cada vez que o loop repetir. Geralmente a variável será incrementada. exemplo:

for(int i = 0; i < 100; i++);

O corpo do loop contém as instruções que serão processadas a cada giro do laço. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include <math.h> // biblioteca para floor #include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- /*função para arredondar casas decimais*/ double Arredonda(double valor, int casas_dec);


//--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { /*variável para receber os números inteiros*/ AnsiString a = InputBox("Caixa de Valores", "Digite um Valor", "");

/*variável para guardar o número de casas decimais*/ AnsiString b = InputBox("Caixa de casas decimais", "Digite as casas decimais", "");

/*chama a função que arredonda casas decimais, atribuindo o valor retornado a b*/ b = Arredonda(StrToFloat(a), StrToInt(b));

/*exibe o valor retornado, já com as casas decimais arredondadas*/ ShowMessage(b); } //---------------------------------------------------------------------------

double Arredonda(double valor, int casas_dec) { int i = 1;

/* j será incrementada até o número de casas decimais*/ for(int j = 1; j <= casas_dec; j++) i*= 10; // o mesmo que: i = i * 10;

// floor é uma função matemática usada para arredondar cifras return floor(valor * i + 0.5) / i; }

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

loop for - continuação

O loop for aceita diversas construções como, por exemplo, conter mais de um valor inicial:

for(int i = 0, j = 100; ...

múltiplas condições:

...; i <= j, j >= i; ...

e processar múltiplas instruções de atualização:

...; i = i + 3, j = j - 7)

Esses múltiplos comandos são separados entre si por vírgulas e das demais instruções por ponto e vírgula.




void __fastcall TForm1::BitBtn1Click(TObject *Sender) { Label1->Caption = "";

int i, j, k; // variáveis para o laço for for(i = 0, j = 50, k = 100; // inicializa as variáveis i <= 10, j <= 100, k >= 0; // estabelece os limites i++, j=j*2, k--) // alterações para as variáveis

/****************************** NOTA: O EXEMPLO NOS DEIXA CLARO QUE O LIMITE A SER OBEDECIDO PELO LOOP SERÁ O LIMITE MAIOR. OU SEJA, EMBORA A VARIÁVEL "i" DEVA SER INCREMENTADA SOMENTE DE "0" ATÉ "10", ELA CONTINUARÁ SENDO INCREMENTADA ATÉ A VARIÁVEL "k" SER SATISFEITA PLENAMENTE O SEU DECREMENTO (DE 100 A 0). QUANTO À VARIÁVEL "k", NÓS PROCURAMOS DEMONSTRAR UMA FORMA DE INTERFERIR EM SUA VARIAÇÃO DENTRO DO LAÇO, ATRAVÉS DO COMANDO if ******************************/

{ if(j > 900000000) // um novo limite para "j" j = 53; // "j" agora é igual a 53

// as variações serão demonstradas no Label Label1-> Caption = (String) Label1->Caption + " i = " + i + " " + " j = " + j + " " + " k = " + k + '\n'; }

} //---------------------------------------------------------------------------

Omissão e aninhamento no loop for

Podemos deixar de incluir uma ou mais instruções no cabeçalho do loop for. Caso isso ocorra, não podemos nos esquecer de colocar o ponto e vírgula respectivo:

for( ; ; )


Dependendo da forma que construímos o laço for, o mesmo poderá funcionar como se fosse um loop while: //---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn1Click(TObject *Sender) { int i = 1; for(;i < 10;) { ShowMessage((String)"laço for com alguns comandos nulos. " + i + "°" + " loop"); i++; } }

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

É possível construir um loop for com todos os comandos nulos: //---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn1Click(TObject *Sender) { int i = 1; for(;;) { if(i<10) { ShowMessage((String)"laço for com todos os comandos nulos. " + i + "°" + " loop"); i++; } else break; } } //---------------------------------------------------------------------------

Por incrível que pareça, às vezes podemos colocar instruções que estariam no corpo do loop dentro do cabeçalho. Nessas situações, se o corpo do loop não for usado pelo comando, será necessário colocar-se a instrução de nulo (um ponto e vírgula) no corpo do laço. //---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn1Click(TObject *Sender) {

for(int i = 1; i<10; ShowMessage((String)"laço for com instruções no corpo do laço. " + i++ + "°" + " loop"));


} //---------------------------------------------------------------------------

loops for aninhados

Os laços for também podem ser aninhados (um dentro do outro):

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


{

StringGrid1->ColCount = 10;

StringGrid1->RowCount = 10;

int coluna, linha, celula;

celula = 0;

for (coluna = 0; coluna < StringGrid1->ColCount; coluna++)

{

for (linha = 0; linha < StringGrid1->RowCount; linha++)

StringGrid1->Cells[coluna][linha] = IntToStr(++celula);

}

}

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

O comando switch

Existem situações onde a execução do programa deverá avaliar uma opção entre várias alternativas. Uma forma de resolvermos essas situações, seria através de várias estruturas if ... else; outra forma, através do comando switch() ... case.

Em tais situações, o uso do comando switch() ... case é, de longe, o mais apropriado pois o uso de vários if ... else pode tornar o código confuso, sujeito a erros e cansativo de depurar.

O comando switch consiste de um cabeçalho e de um corpo. O cabeçalho é montado com a palavra-chave switch seguida de uma expressão (que pode ser uma constante ou uma variável) entre parênteses:


switch (expressão)

após o parênteses de fechamento, não há ponto e vírgula, seguindo-se imediatamente a abertura do corpo do comando com a chave {.

O corpo do comando consiste de várias opções rotulando a palavra-chave case, bem como os comandos para os quais será desviado o controle do programa. Via de regra, essas ações conterão o comando break, remetendo o processamento do programa para fora do switch (primeira linha de código após o comando).

Sempre que o comando não encontrar uma opção para processar nos case, a opção default, caso exista, será processada; se, porém, nesses casos, a opção default não existir, a execução do programa atravessará o switch sem executar instrução alguma:

case valor_x: faz_isso; break;

case valor_y: faz_isto; break;

case valor_z: faz_aquilo; break;

default: faz_outra_coisa; faz_isso_também;

O exemplo a seguir leva um Edit no Form. O código está voltado a impedir a entrada de caracteres não numéricos no Text do Edit.


#include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- bool virgula = true; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key) {

if (virgula == false) DecimalSeparator = '\0';


//if(Edit1->Text.Length() != DecimalSeparator) //virgula = true;

switch(Key) { case '1': Key = '1'; break; case '2': Key = '2'; break; case '3': Key = '3'; break; case '4': Key = '4'; break; case '5': Key = '5'; break; case '6': Key = '6'; break; case '7': Key = '7'; break; case '8': Key = '8'; break; case '9': Key = '9'; break; case '0': Key = '0'; break; case '.': Key = DecimalSeparator; virgula = false; break; case ',': Key = DecimalSeparator; virgula = false; break; case 13: Key = 13; break; case 8: Key = 8; break; default: Key = '\0'; }

} //---------------------------------------------------------------------------

Entendendo o evento OnMouseMove

Um evento OnMouseMove ocorre periodicamente quando o usuário move o mouse. O evento inicia-se no objeto que está sob o ponteiro do mouse quando o usuário pressiona o botão. Isto permite ao usuário algumas opções intermediárias enquanto o mouse move. Observe, porém, que podemos chamar esse evento mesmo sem que qualquer botão esteja pressionado.

Para responder aos movimentos do mouse, defina um evento handler para o evento OnMouseMove.

Num Form vazio, selecione a guia Events do Object Inspector. No setor esquerdo das opções dessa guia, procure pelo evento OnMouseMove. Dê um duplo clique no campo situado ao lado direito desse evento para abrir a janela de edição de códigos. Imediatamente você entrará em contato com as seguintes linhas de código: //---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y) {

} //---------------------------------------------------------------------------

Já temos conhecimento prévio do significado de várias partes do código acima. Mas há algumas novidades: TShiftState Shift, int X, int Y)


Primeiramente, vamos entender o significado de do tipo TShiftState Shift.

O tipo TShiftState indica o estado das teclas Alt, Ctrl e Shift, bem como dos botões do mouse.

typedef Set<Classes__1, ssShift, ssDouble> TshiftState;

Descrição: O tipo TShiftState é usado para eventos de teclado e eventos do mouse para determinar o estado das teclas Alt, Ctrl e Shift, bem como dos botões do mouse, quando ocorrer um evento. Trata-se de um grupo de flags que indica o seguinte:

Valor Significa

ssShift A tecla Shift está segura em baixo.

ssAlt A tecla Alt está segura em baixo.

ssCtrl A tecla Ctrl está segura em baixo.

ssLeft O botão esquerdo do mouse está seguro em baixo.

ssRight O botão direito do mouse está seguro em baixo.

ssMiddle O botão do meio do mouse está seguro em baixo..

ssDouble O mouse recebeu um duplo clique.

Podemos entender TShiftState como uma espécie de variável que, automaticamente, é nomeada de Shift pelo C++Builder no evento estudado.

Quanto às duas variáveis inteiras nomeadas respectivamente de X e Y ( int X, int Y ) pelo C++Builder, nada mais são do que os possíveis valores para as coordenadas X e Y do Form.

Então se, por exemplo, inserirmos as seguintes linhas de código no evento acima: //---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y) { if(Shift.Contains(ssShift) && X == 0 && Y == 0) Close(); } //---------------------------------------------------------------------------

Não ficará difícil entender que: se a tecla Shift (Shift.Contains(ssShift)) estiver pressionada enquanto o mouse mover-se sobre as coordenadas 0 e 0 ( X == 0 && Y == 0 ), ou seja, no extremo esquerdo do topo de Form1, o programa será encerrado.


TCanvas

A classe TCanvas encapsula um dispositivo de contexto Windows na VCL e um dispositivo de pintura (Qt painter) em CLX, que lida com todo desenho para forms, containers visuais (como panels) e o objeto printer, em ambas as formas. Usando o objeto canvas, você não tem dificuldades para alocar pens, brushes, palettes, e assim por diante — todas as alocações e desalocações são tratadas por você.

TCanvas inclui um grande número de gráficos primitivos, rotinas para desenhar linhas, shapes (figuras), polygons (polígonos), fonts (fontes), etc para qualquer controle que contém um canvas.

O exemplo abaixo trata um evento através do clique de um botão, determinando o desenho de uma linha desde as coordenadas X = 100 e Y = 100 até as coordenadas X = 200 e Y = 200, bem como a colocação de um texto, cujo início dar-se-á nessas últimas coordenadas:


{ Canvas->Pen->Color = clBlue; Canvas->MoveTo( 100, 100 ); Canvas->LineTo( 200, 200 ); Canvas->Brush->Color = clBtnFace; Canvas->Font->Name = "Arial"; Canvas->TextOut( Canvas->PenPos.x, Canvas->PenPos.y,"Este é o fim da linha"

); }

O objeto TCanvas também protege você contra erros gráficos comuns Windows, como por exemplo restaurar dispositivos contexto, pens, brushes, e assim por diante de acordo com os valores que eles possuiam antes da operação desenho. TCanvas é usado em qualquer lugar no C++Builder onde um desenho seja requerido ou possível, e faz gráficos facilmente.

TCanvas::CopyMode

Especifica como uma imagem gráfica é copiada sobre a tela.

__property int CopyMode = {read=FCopyMode, write=FCopyMode, default=13369376};

Descrição:

Use CopyMode para afetar o modo como imagens gráficas são desenhadas sobre a tela. CopyMode é usado quando copiamos uma imagem de outra tela usando o método CopyRect. O CopyMode também é usado por objetos TBitmap para desenhar sobre a tela.


Use CopyMode para executar uma variedade de afeitos quando desenhar uma imagem. Consiga efeitos especiais como fundir imagens e criar partes de um bitmap transparente combinando imagens múltiplas com diferentes CopyModes.

A tabela seguinte mostra os possíveis valores de CopyMode. (trata-se de constantes definidas em Windows.hpp.)

cmBlackness Preenche o retângulo de destino na tela com negro.

cmDstInvert Inverte a imagem na tela e ignora a fonte.

cmMergeCopy Combina a imagem na tela e a fonte bitmap usando o operador booleano AND.

cmMergePaint Combina a fonte invertida bitmap com a imagem na tela usando o operador booleano OR.

cmNotSrcCopy Copia a fonte bitmap invertida para a tela.

cmNotSrcErase

Combina a imagem na tela e a fonte bitmap usando o operador booleano OR, e inverte o resultado.

cmPatCopy Copia a fonte moldando na tela.

cmPatInvert

Combina a fonte moldando com a imagem na tela usando o operador booleano XOR.

cmPatPaint Combina a fonte invertida bitmap com a fonte moldada usando o operador booleano OR. Combina o resultado dessa operação com a imagem na tela usando o operador booleano OR.

cmSrcAnd Combina a imagem na tela e a fonte bitmap usando o operador booleano AND.

cmSrcCopy Copia a fonte bitmap na tela.

cmSrcErase Inverte a imagem na tela e combina o resultado com a fonte bitmap usando o operador booleano AND.

cmSrcInvert Combina a imagem na tela e a fonte bitmap usando o operador booleano XOR.

cmSrcPaint Combina a imagem na tela e a fonte bitmap usando o operador booleano OR.

cmWhiteness Preenche o retângulo de destino na tela com branco.


O seguinte exemplo usa CopyMode para deixar branco fora da imagem quando o usuário escolher “Cortar” no menu .

void __fastcall TEdtDsnh::Cortar1Click(TObject *Sender) { TRect ARect;

// copia a figura para o Clipboard, através do método copiar. Copiar1Click(Sender);

// preenche a seção cortada com branco. CmBlackness determinaria preto Image1->Canvas->CopyMode = cmWhiteness;

// dimensiona a seção da tela copiada que será preenchida com branco ARect = Rect(0, 0, Image1->Width, Image1->Height);

// complementa as duas linhas acima, retirando a figura (cortando) Image1->Canvas->CopyRect(ARect, Image1->Canvas, ARect);

// restaura o modo default Image1->Canvas->CopyMode = cmSrcCopy;

}

TRect, Rect, TextRect, Brush e FrameRect

Rect cria uma estrutura TRect para colocar as coordenadas.

Use Rect para criar uma TRect que representa o retângulo segundo as coordenadas especificadas. Use Rect para construir parâmetros para funções que requerem TRect, especialmente para colocar variáveis locais para cada parâmetro.

O exemplo a seguir usa um Button no Form que, ao ser clicado, exibe um texto em um retângulo definido pelas coordenadas (10 e 10) e (300 e 300). Após exibir o texto por meio do método TextRect, o código desenha uma linha definida pelo método FrameRect em volta do retângulo.


// TRect, Rect, TextRect, Brush e FrameRect

TRect ARect; // coordenadas do retângulo. //O mesmo que: ARect = Rect(10,10,300,300); ARect.Top = 10; ARect.Left = 10; ARect.Bottom = 300; ARect.Right = 300;


// TCanvas::TextRect - escreve uma string // dentro de um recorte retangular // coordenadas do texto: X = 85 e Y = 100 Canvas->TextRect(ARect, 85, 100, "Texto no recorte retangular");

// clicar uma vez deixará a borda será vermelha; // duas vezes, toda a área dentro do retângulo Canvas->Brush->Color = clRed;

// A função FrameRect desenha uma borda em torno do retângulo // especificado, usando o brush especificado. A largura e altura // da borda será sempre uma unidade lógica. Canvas->FrameRect(ARect); }

CopyRect

A função CopyRect copia as coordenadas de um retângulo em outro.

BOOL CopyRect( LPRECT lprcDst, // aponta para a estrutura do retângulo de destino CONST RECT *lprcSrc // aponta para a estrutura com o retângulo inicial );

O parâmetro lprcDst aponta para a estrutura RECT que recebe as coordenada lógicas do retângulo inicial e o parâmetro lprcSrc aponta para a estrutura RECT à qual pertencem as coordenadas que estão sendo copiadas.

Se a função lograr êxito, produzirá um valor de retorno diferente de zero; se fracassar, o valor de retorno será zero. Para obter informações de erro estendidas, use GetLastError.

TCanvas::CopyRect

Copia partes de uma imagem de um a outro canvas.

void __fastcall CopyRect(const Windows::TRect &Dest, TCanvas* Canvas, const Windows::TRect &Source);

Use CopyRect para transferir parte da imagem de outro canvas para a imagem do objeto TCanvas. Dest especifica o retângulo no canvas onde a imagem inicial será copiada. O parâmetro Canvas especifica a tela com a imagem fonte. Source especifica um retângulo que limita a porção de tela fonte que será copiada.

A porção da tela inicial é copiada usando o modo especificado por CopyMode.


O exemplo a seguir ilustra como usufruir a diferença entre CopyRect e BrushCopy. O bitmap gráfico “meu_desenho.bmp” é carregado dentro de Bitmap e exibido no Canvas de Form1. BrushCopy substitui a cor negra no gráfico com o brush de canvas, enquanto CopyRect mantém a cor intacta.

void __fastcall TForm1::Button1Click(TObject *Sender) { Form1->WindowState = wsMaximized; // amplia a janela Graphics::TBitmap *Bitmap; // declara Bitmap TRect ARect, A2Rect; // declara ARect = Rect(30, 30, 480, 300); // inicializa ARect determinado as coordenadas A2Rect = Rect(30, 310, 480, 570); // inicializa o retângulo A2Rect Bitmap = new Graphics::TBitmap; // alocação dinâmica de memória para Bitmap Bitmap->LoadFromFile("c:\\meu_desenho.bmp"); // carrega o arquivo especificado

// BrushCopy carregará o desenho substituindo as cores negras do mesmo Form1->Canvas->BrushCopy(ARect, Bitmap, ARect, clBlack);

// CopyRect carregará o arquivo sem alterá-lo Form1->Canvas->CopyRect(A2Rect, Bitmap->Canvas, ARect);

// desaloca a memória dinâmica delete Bitmap;

}

métodos Canvas para desenhar objetos gráficos.

Esta seção mostra a forma de usar alguns métodos comuns para desenhar objetos gráficos. Eles envolvem:

desenhar linhas e múltiplas-linhas;

desenhar figuras;

desenhar retângulos arredondados;

desenhar polígonos.

desenhar linhas e múltiplas-linhas

Canvas pode ser usado para desenhar linhas e múltiplas-linhas. uma linha reta pode ser entendido como uma linha de pixels conectando dois pontos. Múltiplas-linhas pode ser interpretado como uma série de linhas retas, conectando cada ponto inicial com o seu ponto final. O canvas desenha todas as linhas usando pen (caneta).

desenhar figuras


Canvas possui métodos diferentes para desenhar diferentes espécies de figuras. Você pode usar pen para desenhar uma figura e brush (pincel) para preencher o interior da figura. A linha que firma a borda da figuras é controlada pelo corrente objetos Pen.

Esta parte envolve:

desenhar retângulos e elipses;

desenhar retângulos arredondados;

desenhar polígonos.

desenhar retângulos e elipses

Para desenhar retângulo ou elipse na tela, chame o método Rectangle ou o método Ellipse, passando as coordenadas dos limites do retângulo.

O método Rectangle desenha um retângulo; Ellipse desenha uma elipse que toca todos os lados das coordenadas de um retângulo que lhe fornece os limites.

O seguinte método desenha um retângulo no canto superior esquerdo do form, colocando, depois, uma elipse no interior do mesmo:

void __fastcall TForm1::FormPaint(TObject *Sender)

{ // ClientWidth especifica a largura da área do controle em pixels Canvas->Rectangle(0, 0, ClientWidth/2, ClientHeight/2); // ClientHeight especifica a altura da área do controle em pixels Canvas->Ellipse(0, 0, ClientWidth/2, ClientHeight/2); }

desenhando retângulos arredondados

Para desenhar um retângulo arredondado na tela, chame o método RoundRect.

Os quatro primeiros parâmetros passados para RoundRect referem-se aos limites do retângulo (coordenadas), da mesma forma que nos métodos Rectangle ou Ellipse. RoundRect recebe mais dois parâmetros que indicam como desenhar cantos arredondados.

O seguinte método desenha um retângulo arredondado no quadrante superior esquerdo do form, arredondando os cantos com seções de um círculo de 30 pixels de diâmetro:


void __fastcall TForm1::FormPaint(TObject *Sender)

{ Canvas->RoundRect(0, 0, ClientWidth/2, ClientHeight/2, 30, 30); }

desenhando polígonos

Para desenhar polígonos com qualquer número de linhas na tela, use o método Polygon de canvas, que desenha uma série de linhas na tela conectando os pontos passados, providenciando, por fim, o fechamento da figura por unir o último ponto com o primeiro.

Polygon recebe um array de pontos como seu único parâmetro e conecta os pontos com pen, até conectar o último ponto com o primeiro para fechar o polígono. Depois de estipular os limites, Polygon usa o brush para preencher a parte interior do polígono.

O exemplo a seguir leva um PaintBox no Form. Quando o programa é executado, desenha um polígono irregular no form, cujas coordenadas são especificadas pelo array. Observe que, uma das maneiras pela qual você pode alterar o resultado da execução, é variando as possibilidades de acordo com o exposto nos comentários.

void __fastcall TForm1::PaintBox1Paint(TObject *Sender) { TPoint ponto[6]; ponto[0] = Point(0,0); ponto[1] = Point(30,80); ponto[2] = Point(280,130); ponto[3] = Point(280,220); ponto[4] = Point(340,320); ponto[5] = Point(440,380); // ((TPaintBox *)Sender)->Canvas->Brush->Color = clBlue; /*opcional*/ ((TPaintBox *)Sender)->Canvas-> Polygon(ponto, 5 /*número de lados: ou 4, ou 3, ou 2 ...*/); }

propriedades Canvas

Com o objeto Canvas, você pode colocar as propriedades de uma pen para desenhar linhas, um brush para preencher figuras, uma font para escrever um texto, e um array de pixels para representar a imagem.

As próximas seções descrevem:

Usando pens (canetas);

Usando brushes (pincéis);

Lendo e inserindo pixels.


Usando pens

A propriedade Pen de um controle canvas é o meio de fazer linhas aparecerem, incluindo linhas trabalhadas como linhas de figuras. Desenhar uma linha linha reta é alterar um grupo de pixels que estão entre dois pontos.

De si mesmo, pen possui quatro propriedades que você pode alterar: Color, Width, Style, e Mode.

Color muda a cor de pen.

Width muda a largura de pen.

Style muda o estilo de pen.

Mode muda a forma de pen.

O valor dessas propriedades determinam como pen pode alterar os pixels numa linha. Por default, cada pen inicia com cor negra, com largura (width) de 1 pixel, um estilo sólido e um modo chamado copy que escreve qualquer coisa elaboradamente na tela.

Você pode usar TPenRecall para rapidamente salvar e restaurar as propriedades de pens.

TPen::Color

Color determina a cor usada para desenhar linhas na tela.

__property TColor Color = {read=GetColor, write=SetColor, default=0};

Você pode usar Color para mudar a cor usada para desenhar linhas ou figuras. O jeito que Color é usado depende das propriedades Mode e Style.

O exemplo a seguir desenha uma infinidade de elipses de vários estilos, cores e tamanhos (pen e brush) no form para preencher inteiramente a tela. Para executar o código, coloque um componente TTimer no form e use o Object Inspector para criar os eventos handlers OnTimer e OnActivate.

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



#include "Unit1.h" #include <stdlib.h> // para random() e randomize(): valores aleatórios

//--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm"

int x, y;

TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //---------------------------------------------------------------------------

void __fastcall TForm1::FormActivate(TObject *Sender) { WindowState = wsMaximized; // janela maximizada Timer1->Interval = 50; // intervalo de tempo para Timer randomize(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) { // inicializa variáveis com valores aleatórios x = random(Screen->Width - 10); y = random(Screen->Height - 10);

// Cor aleatória para pen Canvas->Pen->Color = (Graphics::TColor) random(65535);

// comando de decisão switch (random(5)) { case 0: Canvas->Pen->Style = psSolid; // estilo da linha Canvas->Brush->Color = clLime; break; // cor da figura: clLime

case 1: Canvas->Pen->Style = psDash; Canvas->Brush->Color = random(65535); break; // cor aleatória

case 2: Canvas->Pen->Style = psDot; Canvas->Brush->Color = random(65535); break;

case 3: Canvas->Pen->Style = psDashDot; Canvas->Brush->Color = random(65535); break;

case 4: Canvas->Pen->Style = psDashDotDot; Canvas->Brush->Color = clAqua; break; } // desenha elípses com tamanhos diversos escolhidos aleatoriamente Canvas->Ellipse(x, y, x + random(400), y + random(400)); }


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

TPen::Width

Especifica a largura máxima de um pen em pixels.

__property int Width = {read=GetWidth, write=SetWidth, default=1};

Você pode usar a propriedade Width para dar à linha maior ou menor espessura. Se Width for colocado para um valor menor do que 1, o valor de pen automaticamente será remetido para 1.

Nota: O valor de Width influencia os possíveis valores válidos de Style.

O exemplo a seguir desenha muitos grupos, geralmente sobrepostos, de retângulos, retângulos arredondados e elipses de vários tamanhos e cores em um form maximizado, preenchendo totalmente o screen: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop

#include "Unit1.h" #include <stdlib.h> // para random() e randomize(): valores aleatórios

//--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm"

int x, y;


void __fastcall TForm1::FormActivate(TObject *Sender) { WindowState = wsMaximized; // janela maximizada Timer1->Interval = 600; // intervalo de tempo para Timer randomize(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) { x = random(Screen->Width - 10); y = random(Screen->Height - 10); Canvas->Pen->Color = (Graphics::TColor) random(65535);

Canvas->Pen->Width = random(50); // Pen terá largura variável


int Dx = random(400); // variáveis para os pixels int Dy = random(400); // do arredondamento do retângulo

Canvas->Brush->Color = random(65535); // cor aleatória p retângulo arredondado Canvas->RoundRect(x, y, x + Dx, y + Dy, Dx/2, Dy/2); Canvas->Brush->Color = random(65535); // cor aleatória para o retângulo Canvas->Ellipse(x, y, x + random(400), y + random(400)); Canvas->Brush->Color = random(65535); // cor aleatória para a elípse Canvas->Rectangle(x, y, x + random(400), y + random(400));

} //---------------------------------------------------------------------------

TPen::Style

Determina o estilo que pen desenha linhas.

enum TPenStyle {psSolid, psDash, psDot, psDashDot, psDashDotDot, psClear, psInsideFrame}; __property TPenStyle Style = {read=GetStyle, write=SetStyle, default=0};

Você pode usar Style para escolher entre várias opções de como desenhará linhas, como por exemplo, desenhar uma linha pontilhada ou tracejada, ou para omitir a linha que aparece como uma moldura em torno de uma figura. Eis os possíveis valores para Style:

psSolid Uma linha sólida.

psDash Uma linha composta de uma série de traços.

psDot Uma linha feita com uma série de pontos.

psDashDot Uma linha construída alternando traços e pontos.

psDashDotDot Uma linha feita com uma série de combinações traço-ponto-ponto.

psClear Linhas não são desenhadas (usado para omitir a linha em volta de figuras que traça um desenho usando a atual pen).

psInsideFrame Uma linha sólida, mas que pode usar uma cor diferente se Width é maior do que 1.

Nota: Só o estilo psInsideFrame produz cor diferente para adaptar à propriedade Color que não está na tabela de cores. Todos os outros escolhem cores na tabela de cores do Windows.

Nota: estilos pontilhados ou tracejados não estão disponíveis quando a propriedade Width é diferente de 1.


Veja o exemplo do tópico Tpen::Color.

TPen::Mode

Determina como pen desenha linhas na tela.

enum TPenMode {pmBlack, pmWhite, pmNop, pmNot, pmCopy, pmNotCopy, pmMergePenNot, pmMaskPenNot, pmMergeNotPen, pmMaskNotPen, pmMerge, pmNotMerge, pmMask, pmNotMask, pmXor, pmNotXor}; __property TPenMode Mode = {read=FMode, write=SetMode, default=4};

Use Mode para determinar como a cor de pen atua sobre a cor sobre o canvas. Os efeitos de Mode estão descritos na seguinte tabela:

Mode Cores Pixels

pmBlack Sempre negro.

pmWhite Sempre branco.

pmNop Imutável.

pmNot Inverso à cor de canvas background.

pmCopy Cor de Pen especificada na propriedade Color.

pmNotCopy Inverso da cor de pen.

pmMergePenNot Combinação da cor de pen e o inverso de canvas background.

pmMaskPenNot Combinação de cores comuns para ambos, pen e inverso de canvas background.

pmMergeNotPen Combinação da cor de canvas background e o inverso da cor de pen.

pmMaskNotPen Combinação de cores comuns para ambos, canvas background e o inverso de pen.

pmMerge Combinação da cor de pen e da cor de canvas background.


Mode Cores Pixels

pmNotMerge Inverso de pmMerge: combinação da cor de pen e cor de canvas background.

pmMask Combinação de cores comuns em ambos, pen e canvas background

pmNotMask Inverso de pmMask: combinação de cores comuns em ambos, pen e canvas background

pmXor Combinação de cores em um ou em outro (pen ou canvas background), mas não em ambos.

pmNotXor Inverso de pmXor: combinação de cores em um ou outro (pen ou canvas background), mas não juntos.

TPenRecall

TPenRecall salva e restaura as propriedades de um objeto TPen.

Use TPenRecall para armazenar o estado atual de um objeto TPen. Então você estará livre para mudar esse estado atual armazenado do objeto pen. Para restaurar o objeto pen para o seu estado original armazenado, basta destruir o objeto TPenRecall o que fará com que o objeto pen seja automaticamente restaurado para as propriedades e valores salvos.

Você pode atualizar a instância TPenRecall para refletir as propriedades atuais do objeto TPen chamando o método Store. Você pode prevenir a destruição de TPenRecall da atualização do objeto TPen pela chamada do método Forget.

Usando brushes

A propriedade Brush de um controle canvas é o meio pelo qual podemos preencher o interior de áreas, incluindo figuras. Preencher uma área com um brush é, nada mais, do que um meio de alterarmos um grande número de pixels na área especificada, ou seja, um pincel.

Brush possui três propriedades que podemos manipular:

Color Muda a cor de preenchimento.

Style muda o estilo de brush.

Bitmap usa um bitmap como um modelo para brush.


O valor dessas propriedades determina o jeito que o canvas preenche figuras ou outras áreas. Por default, qualquer brush inicia branco, com um estilo sólido e modelo não bitmap.

Você pode usar TBrushRecall para rapidamente salvar e restaurar as propriedades de brushes.

Tcanvas::Brush

Determina a cor e o padrão de preenchimento para figuras gráficas e backgrounds.

__property TBrush* Brush = {read=FBrush, write=SetBrush};

Use a propriedade Brush para especificar a cor e o padrão quando desenhar o background ou preencher em figuras gráficas. O valor de Brush está num objeto TBrush. Use as propriedades do objeto TBrush para especificar a cor e o modelo ou bitmap quando preencher espaços no canvas.

Nota: Fixando a propriedade Brush nomeie o objeto TBrush especificado, no lugar de substituir o objeto TBrush atual.

O código a seguir carrega um bitmap desde um arquivo, destinando-o ao Brush do Canvas de Form1:

Graphics::TBitmap *BrushBmp = new Graphics::TBitmap;

try { BrushBmp->LoadFromFile("C:\meu_desenho.bmp"); Form1->Canvas->Brush->Bitmap = BrushBmp; Form1->Canvas->FillRect(Rect(0,0,100,100)); } __finally { Form1->Canvas->Brush->Bitmap = NULL; delete BrushBmp; }

TCanvas::FillRect

Preenche o retângulo especificado no canvas usando o brush atual.

void __fastcall FillRect(const Windows::TRect &Rect);

Use FillRect para preencher uma região retangular usando o pincel atual. A região preenchida inicia-se com as coordenadas do topo esquerdo do retângulo até as coordenadas da base direita do mesmo.


O exemplo a seguir cria um retângulo no form, preenchendo-o de branco (cor default para Brush), ou vermelho (se você remover o símbolo: // ).

void __fastcall TForm1::Button1Click(TObject *Sender) { TRect NewRect = Rect(20, 30, 350, 290); // Canvas->Brush->Color = clRed; Canvas->FillRect(NewRect);

}

TBrush::Color

Indica a cor do brush.

__property TColor Color = {read=GetColor, write=SetColor, default=16777215};

A propriedade Color determina a cor de brush. Esta cor é usada para traçar a forma representada pela propriedade Style, e não a cor background do brush (a menos que Style seja sólido).

Nota: Se o valor da propriedade Style for bsClear, a propriedade Color é ignorada. Mais ainda, qualquer valor marcado para a propriedade Color é perdido quando Style é marcado para bsClear.

O exemplo a seguir leva um Button e um Image no Form. Quando o usuário clicar o botão, uma elipse é desenhada em Image1 (TImage sobre o form), adotando o estilo bsDiagCross para Brush, ou seja, linhas cruzadas, as quais serão vermelhas:


{ TCanvas *pCanvas = Image1->Canvas; pCanvas->Brush->Color = clRed; pCanvas->Brush->Style = bsDiagCross; pCanvas->Ellipse(0, 0, Image1->Width, Image1->Height); }

TBrush::Style

Especifica a forma para brush. enum TBrushStyle {bsSolid, bsClear, bsHorizontal, bsVertical, bsFDiagonal,


bsBDiagonal, bsCross, bsDiagCross __property TBrushStyle Style = {read=GetStyle, write=SetStyle, default=0};

A propriedade Style determina a forma pintada por brush, a menos que um valor seja determinado por Bitmap. Os possíveis valores de Style são:

bsSolid

bsCross

bsClear

bsDiagCross

bsBDiagonal

bsHorizontal

bsFDiagonal

bsVertical

O exemplo a seguir demonstra o uso dos possíveis valores da propriedade Style de Brush, pintando os exemplos no Form que é redimensionado quando o mesmo recebe um clique do mouse: //---------------------------------------------------------------------------

void __fastcall TForm1::FormClick(TObject *Sender) { Form1->Height = 430; Form1->Width = 410;

TCanvas *pCanvas = Form1->Canvas; pCanvas->Brush->Color = clBlue;


pCanvas->Brush->Style = bsDiagCross; pCanvas->Ellipse(0, 0, 100, 200);

pCanvas->Brush->Color = clRed; pCanvas->Brush->Style = bsSolid; pCanvas->Rectangle(101, 0, 200, 200);

pCanvas->Brush->Color = clYellow; pCanvas->Brush->Style = bsDiagCross; pCanvas->RoundRect(201, 0, 300, 200, 50, 90);

pCanvas->Brush->Color = clLime; pCanvas->Brush->Style = bsBDiagonal; pCanvas->Ellipse(301, 0, 400, 200);

pCanvas->Brush->Color = clFuchsia; pCanvas->Brush->Style = bsHorizontal; pCanvas->Rectangle(0, 200, 100, 400);

pCanvas->Brush->Color = clWhite; pCanvas->Brush->Style = bsFDiagonal; pCanvas->RoundRect(101, 200, 200, 400, 90, 50);

pCanvas->Brush->Color = clGreen; pCanvas->Brush->Style = bsVertical; pCanvas->Ellipse(201, 200, 300, 400);

pCanvas->Brush->Color = clGreen; pCanvas->Brush->Style = bsClear; pCanvas->Rectangle(301, 200, 400, 400);

} //---------------------------------------------------------------------------

Dica: Coloque a propriedade Style para bsClear para eliminar instabilidade na tela (pisca-pisca) quando o objeto é repintado.

TBrush::Bitmap

Especifica uma imagem bitmap externa que define uma composição para brush.

__property TBitmap* Bitmap = {read=GetBitmap, write=SetBitmap};

Bitmap aponta para um objeto TBitmap que guarda uma imagem bitmap. Se Bitmap não estiver vazio, a imagem bitmap define a composição para brush’s. Se a imagem é maior do que oito pixels por oito pixels, somente a região do topo esquerdo oito-por-oito é usado.


Mudar a imagem não afeta brush até que TBitmap seja redefinido para a propriedade Bitmap. Deve-se liberar o TBitmap depois de finalizado com brush, visto que TBrush não pode fazê-lo.

O exemplo a seguir leva um Button no Form. Quando o usuário clicar o botão, um bitmap é carregado do disco e destinado para o Brush do Canvas de Form1. O form é totalmente preenchido, mesmo que a figura tenha um dimensionamento menor. Nesse caso as imagens serão colocadas lado a lado.

void __fastcall TForm1::Button1Click(TObject *Sender) { Graphics::TBitmap *BrushBmp = new Graphics::TBitmap;

try { TRect ARect = Rect(0, 0, Width, Height); BrushBmp->LoadFromFile("C:\\Meu_desenho.bmp"); Canvas->Brush->Bitmap = BrushBmp; Canvas->FillRect(ARect); } __finally { Canvas->Brush->Bitmap = NULL; delete BrushBmp; } }

TBrushRecall

TBrushRecall salva e restaura um objeto TBrush.

Use TBrushRecall para guardar o atual estado de um objeto TBrush. Você então está livre para mudar o estado atual do objeto brush. Para restaurar o objeto brush ao seu estado original, basta destruir o objeto TBrushRecall e o objeto brush é automaticamente restaurado para os valores da propriedade salvos.

Você pode atualizar a instância TBrushRecall para refletir as propriedades atuais do objeto TBrush pela chamada do método Store. Você pode impedir o destruidor de TBrushRecall pela atualização do objeto TBrush pela chamada do método Forget.

Ler e inserir pixels

Você pode reparar que cada tela possui uma propriedade Pixels que representa pontos individuais coloridos que compõem a imagem na tela. Raramente você precisará acessar Pixels direta ou individualmente, sendo que eles estão disponíveis apenas, por conveniência, para executar pequenas ações como, por exemplo, buscar ou inserir uma cor.


Nota: Manipular pixels individuais é muito mais lento do que executar operações gráficas por regiões. Não use a propriedade array Pixel para ter acesso a pixels de imagem de um array geral. Para acesso de alto-desempenho a pixels de imagem, veja a propriedade TBitmap::ScanLine.

TCanvas::Pixels

Especifica as cores dos pixels dentro do atual ClipRect.

__property TColor Pixels[int X][int Y] = {read=GetPixel, write=SetPixel};

Use Pixels para descobrir a cor na superfície do desenho em uma posição específica dentro da região selecionada. Se a posição estiver fora do retângulo selecionado, a leitura do valor de Pixels retornará -1; use Pixels para mudar a cor individual de pixels na superfície do desenho; e use Pixels para detalhar efeitos em uma imagem. Pixels também pode ser usado para determinar a cor que deveria ser usada pelo método FillRect.

Nem todo contexto de dispositivo suporta a propriedade Pixels. Ler a propriedade Pixels para cada contexto de dispositivo retorna um valor de -1. Colocar a propriedade Pixels para cada contexto de dispositivo não realiza ação alguma.

O exemplo a seguir desenha várias linhas coloridas formando uma moldura, quando o usuário pressiona o botão.


for (int i = 10; i <= 300; i++) { Canvas->Pixels[i][10] = clRed; Canvas->Pixels[i][14] = clBlue; Canvas->Pixels[i][18] = clYellow; Canvas->Pixels[i][22] = clWhite; Canvas->Pixels[i][26] = clFuchsia; Canvas->Pixels[i][30] = clGreen;

Canvas->Pixels[10][i] = clRed; Canvas->Pixels[14][i] = clBlue; Canvas->Pixels[18][i] = clYellow; Canvas->Pixels[22][i] = clWhite; Canvas->Pixels[26][i] = clFuchsia; Canvas->Pixels[30][i] = clGreen;

Canvas->Pixels[i][280] = clRed; Canvas->Pixels[i][284] = clBlue; Canvas->Pixels[i][288] = clYellow;


Canvas->Pixels[i][292] = clWhite; Canvas->Pixels[i][296] = clFuchsia; Canvas->Pixels[i][300] = clGreen;

Canvas->Pixels[280][i] = clRed; Canvas->Pixels[284][i] = clBlue; Canvas->Pixels[288][i] = clYellow; Canvas->Pixels[292][i] = clWhite; Canvas->Pixels[296][i] = clFuchsia; Canvas->Pixels[300][i] = clGreen;

} }

Para entender o que cada bloco faz, você pode tirá-lo da execução, colocando-o entre os símbolos de comentário C: /* */

TBitmap::ScanLine

Provê acesso indexado a cada linha de pixels.

__property void * ScanLine[int Row] = {read=GetScanline};

ScanLine é usado somente com DIBs (Device Independent Bitmaps) para imagens que são editadas em ferramentas que fazem trabalhos de pixels de baixo nível. void __fastcall TForm1::Button1Click(TObject *Sender)

{ Graphics::TBitmap *pBitmap = new Graphics::TBitmap(); // Este exemplo mostra edição diretamente no Bitmap Byte *ptr;

try { pBitmap->LoadFromFile ("C:\\meu_desenho.bmp"); for (int y = 0; y < pBitmap->Height; y++) { ptr = (Byte *)pBitmap->ScanLine[y];

for (int x = 0; x < pBitmap->Width; x++) ptr[x] = (Byte)y; } Canvas->Draw(0,0,pBitmap); } catch (...) { ShowMessage("Não foi possível carregar ou alterar bitmap"); }


delete pBitmap; }

Propriedades e métodos comuns de Canvas

A tabela a seguir exibe as propriedades do objeto Canvas geralmente usadas.

Propriedades descrições

Font Especifica a fonte a ser usada quando escrever textos na imagem. Use as propriedades do objeto TFont para especificar a aparência da fonte, como cor, tamanho e estilo da fonte.

Brush Determina a cor e a forma que Canvas usa para preencher figuras gráficas e backgrounds. Use as propriedades do objeto TBrush para especificar a cor e a forma ou bitmap em uso quando preencher espaços no canvas.

Pen Especifica a espécie de caneta que o canvas usa para desenhar linhas e esboçar figuras. Use as propriedade do objeto TPen para especificar a cor, estilo largura e modo da caneta.

PenPos Especifica a posição atual de pen.

Pixels Especifica a cor de pixels da área dentro do atual ClipRect.

Estas propriedades são descrevidas em maiores detalhes em Using the properties of the Canvas object.

Abaixo a lista de vários métodos que você pode usar:

Métodos Descrições

Arc void __fastcall Arc(int X1, int Y1, int X2, int Y2, int X3, int Y3, int X4, int Y4);

Desenha um arco na imagem ao longo do perímetro da elipse limitada pelo retângulo especificado.

Use Arc para desenhar uma linha encurvada elipticamente com a Pen (caneta) atual. O arco atravessa o perímetro de uma elipse que é limitada pelos pontos (X1,Y1) e (X2,Y2). O arco é desenhado seguindo o perímetro da elipse, no sentido anti-horário (à esquerda), do ponto de partida para o ponto final. O ponto inicial é definido pela intersecção da elipse e uma linha definida pelo centro da elipse e (X3,Y3). O ponto final é definido pela intersecção da elipse e uma linha definida pelo centro da elipse e (X4, Y4). Exemplo:

void __fastcall TForm1::FormPaint(TObject *Sender) { TRect R = GetClientRect(); // Coordenadas retangulares // da janela atual



Canvas->Arc(R.Left, R.Top, R.Right, R.Bottom, R.Right, R.Top, R.Left, R.Top);

}

Chord void __fastcall Chord(int X1, int Y1, int X2, int Y2, int X3, int Y3, int X4, int Y4);

Desenha figura fechada representada pela intersecção de uma linha e uma elipse.

Use Chord para criar uma forma que é definida por um arco e uma linha que une os pontos finais do arco. A corda (chord) consiste numa porção da elipse que é limitada pelos pontos (X1,Y1) e (X2,Y2). A elipse é dividida por uma linha que liga os pontos (X3,Y3) e (X4,Y4).

O perímetro de chord vai da direita (X3, Y3), para a esquerda, ao longo da elipse para (X4,Y4), e para trás (X3,Y3). Se (X3,Y3) e (X4,Y4) não estiver na superfície da elipse, os cantos correspondentes em chord serão os pontos mais íntimos do perímetro que cruza a linha. O desenho da corda (chord) é feito usando valores tirados de Pen, e a figura é preenchida usando valores de Brush.

void __fastcall TForm1::Button1Click(TObject *Sender) { TRect R = Rect(20, 5, 350, 350); Canvas->Chord(20, 5, 350, 350, 10, 10, 200, 200);

}

CopyRect void __fastcall CopyRect(const Windows::TRect &Dest, TCanvas* Canvas,const Windows::TRect &Source);

Copia parte de uma imagem de um canvas diferente para dentro do Canvas.

Use CopyRect para transferir parte da imagem de outra tela para a imagem do objeto TCanvas. Dest especifica o retângulo na tela onde a imagem de fonte será copiada. O parâmetro de Canvas especifica a tela com a imagem fonte. Source especifica um retângulo que limita a porção da tela fonte que será copiada.

A porção da tela fonte é copiada usando o modo especificado por CopyMode. Exemplo:

void __fastcall TForm1::Button1Click(TObject *Sender) { Graphics::TBitmap *Bitmap; TRect Figura_Copiada; Figura_Copiada = Rect(0,0,300,300); Bitmap = new Graphics::TBitmap; Bitmap->LoadFromFile("c:\\indio2.bmp"); Form1->Canvas->CopyRect(Figura_Copiada, Bitmap->Canvas, Figura_Copiada);



delete Bitmap;

}

Draw void __fastcall Draw(int X, int Y, TGraphic* Graphic);

Desenha o objeto gráfico especificado pelo parâmetro Graphic na tela na localização determinada pelas coordenadas (X, Y).

Chame Draw para colocar um gráfico na tela. Draw chama o método Draw da imagem. A imagem é desenhada em um retângulo determinado pelo tamanho de Graphic, com o canto esquerdo superior nos pontos X e Y.

Gráficos podem ser bitmaps, ícones, ou metafiles. Se o gráfico é um objeto TBitmap, o bitmap é desenhado usando o valor de CopyMode. Exemplo:

void __fastcall TForm1::Button1Click(TObject *Sender) { Graphics::TBitmap* figura = new Graphics::TBitmap; figura->LoadFromFile("c:\\meu_desenho.bmp"); Canvas->Draw(10, 10, figura); delete figura; }

Ellipse void __fastcall Ellipse(int X1, int Y1, int X2, int Y2);

Desenha a elipse definida pelos limites de um retângulo na tela.

Use Ellipse para desenhar um círculo ou elipse na tela. O ponto do topo superior direito do retângulo é o pixel representado pelas coordenadas X1 e Y1 e o ponto inferior direito pelas coordenadas X2 e Y2. Se os pontos do retângulo formam um quadrado, um círculo é desenhado.

A elipse é desenhada usando o valor de Pen, e preenchida usando o valor de Brush. Exemplo:

TCanvas *pCanvas = Canvas; pCanvas->Brush->Color = clRed; pCanvas->Brush->Style = bsSolid; pCanvas->Ellipse(0, 0, Width*2, Height/2); pCanvas->Brush->Color = clYellow; pCanvas->Brush->Style = bsVertical; pCanvas->Ellipse(0, 0, Width, Height); pCanvas->Brush->Color = clBlue; pCanvas->Brush->Style = bsHorizontal; pCanvas->Ellipse(200, 0, Width*2, Height);

FillRect void __fastcall FillRect(const Windows::TRect &Rect);



Preenche o retângulo especificado na tela usando o brush (pincel) atual.

Use FillRect para preencher uma região retangular usando o pincel atual. A região preenchida inicia-se com as coordenadas do topo esquerdo do retângulo até as coordenadas da base direita do mesmo. O exemplo a seguir cria um retângulo no form, preenchendo-o de azul.

void __fastcall TForm1::Button1Click(TObject *Sender) { TRect NewRect = Rect(20, 30, 350, 290); Canvas->FBrush->Color = ClBlue; Canvas->FillRect(NewRect);

}

FloodFill enum TFillStyle {fsSurface, fsBorder}; void __fastcall FloodFill(int X, int Y, TColor Color, TFillStyle FillStyle);

Preenche a área da tela usando o brush atual.

Use FloodFill para encher uma região possivelmente não retangular da imagem com o valor de Brush. Os limites da região para ser preenchidos são determinados pelo passar ao lado externo do ponto (X,Y) quando o limite de cor que envolve o parâmetro Color é encontrado.

FillStyle determina qual tipo de mudança de cor define os limites, como indicado na seguinte tabela.

fsSurface Enche toda a área que tem a cor indicada pelo parâmetro Color. Para quando outra cor é encontrada.

fsBorder Enche toda a área que não tem a cor indicada pelo parâmetro Color. Para quando Color é encontrado.

Use a propriedade Pixels para adquirir o valor exato da cor no ponto (X,Y) quando usar fsSurface de FillStyle. Semelhantemente, quando FillStyle é fsBorder, use Pixels para adquirir o valor exato da cor limite se um ponto no limite é conhecido.

void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { TCanvas *pCanvas = Canvas; pCanvas->Ellipse(0, 0, 100, 400); } //---------------------------------------------------------------- void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)



{ Canvas->FloodFill(ClientWidth/2, ClientHeight/2, clBlack, fsBorder); }

FrameRect void __fastcall FrameRect(const Windows::TRect &Rect);

Desenha uma borda de retângulo usando o Brush do canvas.

Use FrameRect para desenhar um 1 pixel de borda ao redor de uma região retangular. FrameRect não enche o interior do retângulo com o Brush padrão.

Para desenhar um limite usando Pen, use o método Polygon.

void __fastcall TForm1::Button1Click(TObject *Sender) { TRect ARect; Canvas->Brush->Color = clFuchsia; ARect.Top = 10; ARect.Left = 10; ARect.Bottom = 200; ARect.Right = 200; Canvas->FrameRect(ARect); }

LineTo void __fastcall LineTo(int X, int Y);

Desenha uma linha no canvas desde PenPos para o ponto especificado por X e Y, colocando a posição atual de Pen para (X, Y).

Use LineTo para desenhar uma linha desde PenPos até o ponto X e Y, mas não incluindo o mesmo. LineTo altera o valor de PenPos para X e Y. A linha é desenhada usando Pen.

void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { Canvas->LineTo(X, Y); }

MoveTo void __fastcall MoveTo(int X, int Y);

Altera, determinado a posição atual do desenho de acordo com as coordenadas X e Y.

Muda a posição atual do desenho para o ponto X e Y. Use MoveTo para colocar o valor de PenPos antes de LineTo. Chamar MoveTo é equivalente a setar a propriedade PenPos.



int p_X, p_Y; // Variáveis para trabalhar com o ponto (X,Y)

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y) { // Canvas->FillRect(ClientRect); Canvas->MoveTo(p_X, p_Y); Canvas->LineTo(X, Y); } //-------------------------------------------------------------- void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { p_X = X; p_Y = Y; }

Pie void __fastcall Pie(int X1, int Y1, int X2, int Y2, int X3, int Y3, int X4, int Y4);

Desenha a figura seccionada em direção da elipse como se dela houvera sido retirada uma fatia (como num bolo redondo). O seccionamento (ou cunha) é determinado por duas linhas que radiam do centro da elipse pelos pontos (X3, Y3) e (X4, Y4). A cunha é desenhada com Pen, e preenchida com Brush. Exemplo:

Canvas->Pie(50, 50, 300, 200, 50, 30, 100, 50);

Polygon void __fastcall Polygon(const Windows::TPoint * Points, const int Points_Size);

Desenha uma série de linhas na tela, ligando os pontos passados e fechando a figura ao ligar o último ponto ao primeiro ponto.

Use Polygon para desenhar uma figura com vários lados fechados na tela, usando o valor de Pen. Depois de completar o desenho da figura, Polygon preenche a figura usando o valor de Brush. Para desenhar um polígono na tela, sem preenchê-lo, use o método Polyline, especificando o primeiro ponto uma segunda vez no fim (após o último ponto).

O exemplo a seguir desenha uma estrela de cinco pontas no Form, preenchendo as pontas da mesma com amarelo:

void __fastcall TForm1::FormPaint(TObject *Sender) { TPoint points[5]; points[0] = Point(40,10); points[1] = Point(20,60); points[2] = Point(70,30); points[3] = Point(10,30); points[4] = Point(60,60);



Canvas->Brush->Color = 0xffff; // Color = clYellow Canvas->Polygon(points, 4);

}

PolyLine void __fastcall Polyline(const Windows::TPoint * Points, const int Points_Size);

Desenha uma série de linhas na tela com a atual caneta (pen), conectando cada um dos pontos passados de acordo com Points. Use Polyline para ligar um grupo de pontos na tela. Se existem apenas dois pontos, Polyline desenha uma linha linha simples.

Chamando a função MoveTo com o valor do primeiro ponto, e então chame LineTo repetidamente com todos os pontos subseqüentes para desenhar uma imagem na tela. De qualquer forma, diferente de LineTo, Polyline não altera o valor de PenPos.

O exemplo a seguir, que procura demonstrar sutis diferenças, desenha duas estrelas com linhas coloridas. Uma estrela no Form e outra num PaintBox:

void __fastcall TForm1::FormPaint(TObject *Sender) { TPoint points[6]; Canvas->Pen->Color = 0xff0000; // clBlue points[0].x = 40; points[0].y = 10; points[1].x = 20; points[1].y = 60; points[2].x = 70; points[2].y = 30; points[3].x = 10; points[3].y = 30; points[4].x = 60; points[4].y = 60; points[5].x = 40; points[5].y = 10; Canvas->Polyline(points,5); }

//----------------------------------------------------------- void __fastcall TForm1::PaintBox1Paint(TObject *Sender) { TPaintBox *pPB = (TPaintBox *)Sender; TPoint points[6]; pPB->Canvas->Pen->Color = clFuchsia; // Color = 0xff00ff; points[0].x = 40; points[0].y = 10; points[1].x = 20; points[1].y = 60; points[2].x = 70;



points[2].y = 30; points[3].x = 10; points[3].y = 30; points[4].x = 60; points[4].y = 60; points[5].x = 40; points[5].y = 10; ((TPaintBox *)Sender)->Canvas->Polyline(points,5); // A linha acima é equivalente a: // pPB->Canvas->Polyline(points,5);

}

Rectangle void __fastcall Rectangle(int X1, int Y1, int X2, int Y2);

Desenha um retângulo na tela com o canto superior esquerdo no ponto (X1, Y1) e o canto inferior direito no ponto (X2, Y2). Use Rectangle para desenhar um retângulo com Pen e preenchendo-o com Brush. Para preencher a região retangular externa desenhando a borda no corrente pen, use FillRect. Para desenhar uma área retangular externa adicional, use FrameRect ou Polygon. Para desenhar um retângulo com cantos arredondados, use RoundRect.

O exemplo a seguir desenha muitos retângulos de vários tamanhos e cores no form maximizado preenchendo janela. Para executar o exemplo, inclua o cabeçalho stdlib.h, coloque um componente TTimer no Form e use o object inspector para criar o evento OnTimer.

int x, y;

//--------------------------------------------------------- void __fastcall TForm1::FormActivate(TObject *Sender) { WindowState = wsMaximized; Canvas->Pen->Width = 20; Canvas->Pen->Style = psDot; Timer1->Interval = 50; randomize(); } //---------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) { x+= 4; y+=4;

Canvas->Pen->Color = random(65535); Canvas->Rectangle(x, y, x + random(400), y + random(400));

if(x > 700) Timer1->Enabled = false; }



RoundRect void __fastcall RoundRect(int X1, int Y1, int X2, int Y2, int X3, int Y3);

Desenha um retângulo na tela com o canto superior esquerdo no ponto (X1, Y1) e o canto inferior direito no ponto (X2, Y2). Use Rectangle para desenhar um retângulo com Pen e preenchendo-o com Brush. Para preencher a região retangular externa desenhando a borda no corrente pen, use FillRect. Para desenhar uma área retangular externa adicional, use FrameRect ou Polygon. Para desenhar um retângulo com cantos arredondados, use RoundRect.

Este exemplo desenha retângulos de cantos arredondados de vários tamanhos e cores no form maximizado preenchendo a janela. Para executar o exemplo, coloque um componente TTimer no form e use o object inspector para criar o evento OnTimer.

int x, y; void __fastcall TForm1::FormActivate(TObject *Sender) { WindowState = wsMaximized; Canvas->Pen->Width = 20; Canvas->Pen->Style = psInsideFrame; Timer1->Interval = 100; randomize(); } //----------------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) { x+=4; y+=4;

Canvas->Pen->Color = random(65535); Canvas->RoundRect(x, y, x + random(400), y + random(400), 40, 40);

if(x == 600) { x = 400; y = 4; } }

StretchDraw void __fastcall StretchDraw(const Windows::TRect &Rect, TGraphic* Graphic);

Desenha o gráfico especificado no parâmetro Graphic no retângulo especificado pelo parâmetro Rect. Chame StretchDraw para desenhar um gráfico na tela de forma que a imagem encaixe-se no retângulo especificado. StretchDraw chama o método Draw do gráfico. O objeto gráfico determina a forma de preenchimento do



retângulo. Isto talvez envolva mudança de tamanho e/ou relação entre altura e largura.

Para desenhar o gráfico em seu tamanho natural, use o método Draw.

Graphics podem ser bitmaps, ícones ou metafiles. se o gráfico é um objeto TBitmap, o bitmap desenhado usando o valor de CopyMode.

O código a seguir estica o bitmap para preencher a área cliente de Form1.

void __fastcall TForm1::Button1Click(TObject *Sender) { Graphics::TBitmap* figura = new Graphics::TBitmap; figura->LoadFromFile("c:\\Meu_Desenho.bmp"); // Canvas->Draw(10, 10, figura); Canvas->StretchDraw(ClientRect, figura); delete figura; }

TextHeight, TextWidth

int __fastcall TextHeight(const AnsiString Text);

Retorna a altura (height), em pixels, de uma string desenhada na atual font. Use TextHeight para determinar o height que uma string ocupa na imagem. Outros elementos na imagem como linha, boxes, ou linhas adicionais de textos podem ser posicionadas para acomodar o height do texto. TextHeight retorna o mesmo valor de TextExtent(Text).cy.

Este exemplo exibe o height de um texto string na atual font do canvas num edit box no form:

void __fastcall TForm1::FormCreate(TObject *Sender)

{ int x = Canvas->TextHeight(" Curso de C++Builder"); Edit1->Text = String(x) + String(" pixels em height"); }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int __fastcall TextWidth(const AnsiString Text);

Retorna a largura (width), em pixels, de uma string desenhada na atual font. Use TextWidth para determinar o comprimento (length) que uma string ocupa numa



imagem. TextWidth indica se determinada string encaixa-se no espaço disponível. Outros elementos gráficos na imagem como linhas, ou strings adicionais podem ser posicionadas para acomodar a largura (width) do texto.

TextWidth retorna o mesmo valor que TextExtent(Text).cx.

Esse exemplo determina a largura (width) de uma string especificada, e se a string é demasiadamente grande para ser exibida no Edit, o Edit é redimensionado para acomodar a string. A string é exibida no edit box.


{ long int t; String str("Tutorial de C++Builder"); t = Canvas->TextWidth(str);

if(t > Edit1->Width) Edit1->Width = t + 10; Edit1->Text = str; }

TextOut void __fastcall TextOut(int X, int Y, const AnsiString Text);

Escreve uma string na tela, iniciando nos pontos X e Y, e envia o PenPos para o fim da string. Use TextOut para escrever uma string na tela. A string pode ser escrita usando a font atual, ou não. Use o método TextExtent para determinar o espaço ocupado pelo texto na imagem. Para escrever somente o texto que ajusta dentro do retângulo, use TextRect.

Este exemplo exibe uma string na posição especificada no form quando o usuário clica o botão no form:

void __fastcall TForm1::Button1Click(TObject *Sender) { Canvas->Brush->Color = clBtnFace; Canvas->Font->Name = "Courier New"; Canvas->TextOut(20, 100, "Este curso C++Builder destina-se a facilitar o aprendizado de C++ "); }

TextRect void __fastcall TextRect(const Windows::TRect &Rect, int X, int Y, const AnsiString Text);



Escreve uma string dentro de um retângulo. Use TextRect para escrever uma string dentro de uma limitada região retangular. Qualquer porção da string que ultrapasse o retângulo passado no parâmetro é cortado e não aparece. O canto superior esquerdo do texto é colocado no ponto (X, Y).

O código a seguir insere u texto num retângulo definido pelas coordenadas (10, 10) e (100, 100).


{ TRect TheRect; TheRect.Top = 10; TheRect.Left = 10; TheRect.Bottom = 40; TheRect.Right = 100; Canvas->TextRect (TheRect, 20, 20, String("Wilson e Milton... bons amigos!!!")); }

Conhecendo arrays

As palavras matriz, array ou vetor são sinônimos utilizados para um mesmo tipo de dados utilizado na linguagem C++ para representar uma coleção de variáveis do mesmo tipo, referenciadas por um mesmo nome e identificadas através de um índice numérico.

Essas variáveis ficam alocadas seqüencialmente na memória, seguindo o sentido da primeira variável (índice 0 - zero, o endereço mais baixo) para a última variável (índice n - endereço mais alto).

Para declarar uma matriz, devemos escrever um tipo, seguido do nome da matriz, seguidos pelo índice, que nada mais é do que um número, indicando a quantidade de elementos de array, contido entre colchetes.

A instrução:

char Abcdario[26];


declara uma matriz de vinte e seis ([26]) caracteres (char), cujo nome é Abcdario. Quando o compilador se depara com essa declaração, ele reserva vinte e seis bytes (1 byte para cada char), enfileirados seqüencialmente na memória do computador.

O exemplo a seguir usa matrizes para imprimir o abecedário num Label: //---------------------------------------------------------------------------


Label1->Caption = ""; char Abcdario[26]; for(int i = 0; i < 26; i++) { Abcdario[i] = 97 + i; Label1 -> Caption = (String)Label1 -> Caption + "Abcdario[" + i + "] = " + Abcdario[i] + '\n'; }

} //---------------------------------------------------------------------------

As variáveis de uma matriz são numeradas a partir do zero (índice). No exemplo anterior,

char Abcdario[0] é a primeira variável;

char Abcdario[1] é a segunda variável;

char Abcdario[2] é a terceira variável;

...

char Abcdario[25] é a última variável;

Para acessar uma variável determinada de um array, indicamos o nome do array e o índice; ou seja, o número que está entre colchetes [ ] e indica a posição da mesma na memória.

No exemplo anterior (Abcdario[]), temos que:

Abcdario[0] = a (1ª posição)

Abcdario[1] = b (2ª posição)

Abcdario[2] = c (3ª posição)

Abcdario[3] = d (4ª posição)


Abcdario[4] = e (5ª posição)

...

Abcdario[25] = z (26ª posição)

Vamos reescrever o exemplo para acessar apenas um caracter:

//--------------------------------------------------------------------------- // reescrito void __fastcall TForm1::Button1Click(TObject *Sender) { char Abcdario[26]; for(int i = 0; i < 26; i++) { Abcdario[i] = 97 + i; Label1 -> Caption = Abcdario[10]; } } //---------------------------------------------------------------------------

Agora o programa acessa apenas a 11ª variável, ou seja, a letra k.

Excedendo o limite de um array

Quando uma matriz é declarada, o espaço necessário em memória é calculado pelo compilador com base no tipo da variável, multiplicado pelo índice: a declaração float Notas[26] faz que o compilador reserve 104 bytes seqüenciais em memória para armazenar as 26 variáveis, visto que cada variável float ocupa 4 bytes. Logo, 4 * 26 = 104.

A utilização de arrays traz uma uma responsabilidade a mais para o programador: a de verificar se o limite da matriz não foi excedido, uma vez que a linguagem C++ não realiza esse tipo de verificação.

No exemplo anterior, se no código houvesse alguma instrução para que fosse escrito algum dado em Notas[26], o fato de que não existe espaço reservado em memória para essa variável seria ignorado pelo compilador que implementaria a instrução (lembre-se de que a primeira variável de vetores inicia-se com o índice zero).

Uma vez que os valores do array estão armazenados seqüencialmente na memória, o compilador, sem fazer qualquer verificação, colocará esse elemento imediatamente após Notas[25] (endereço mais alto do exemplo).

Teoricamente, qualquer dado, instrução ou comando poderá estar ocupando esse endereço, o que poderá produzir um resultado totalmente desastroso.


O exemplo a seguir, que pode causar danos ao sistema, procura demonstrar esse tipo de erro na lógica de programação.

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


Label1->Caption = ""; char Abcdario[26]; for(int i = 0; i <= 26; i++) { Abcdario[i] = 97 + i; Label1 -> Caption = (String)Label1 -> Caption + "Abcdario[" + i + "] = " + Abcdario[i] + '\n'; }

} //---------------------------------------------------------------------------

Matrizes multidimensionais

Até agora, temos visto vetores unidimensionais (pois apresentam apenas uma dimensão):

char Abcdario[26]; // um par de colchetes

Podemos, também, ter matrizes com duas ou mais dimensões:

bidimensionais: unsigned char Bid_Vetor[3][4]; // dois pares de colchetes

tridimensionais: int Trid_Array[2][3][2]; // três pares de colchetes

e assim por diante, cada par de colchetes representa uma dimensão.

Matrizes com mais de uma dimensão significa: os elementos da matriz são outras matrizes.

Considere uma matriz int bidimensional, cujos índices são [3] e [4]. Vejamos quais seriam as coordenadas: | (0 0), (0 1), (0 2), (0 3) | | (1 0), (1 1), (1 2), (1 3) | | (2 0), (2 1), (2 2), (2 3) |


As coordenadas das linhas localizam-se no lado esquerdo do interior dos parênteses e as coordenadas das colunas localizam-se no lado direito do interior dos parênteses. Logo, na primeira linha, a coordena horizontal são os zeros; na segunda, os um; na terceira, os dois. Na primeira coluna, a coordenada vertical são os zeros; na segundo, os um; na terceira, os dois; e na quarta, os três.

Nós podemos inicializar as matrizes na mesma instrução onde a declaramos: char Bid_Array[3][4] = { { a, b, c, d } { e, f, g, h } { i, j, l, m } };

No exemplo acima, o caracter 'g' ocupa as coordenadas (1, 2).

Então, Bid_Array[1][2] == 'g'.

Nas matrizes de três dimensões, cada elemento é uma matriz de duas dimensões:

char Trid_Vetor[3][2][4] = { { // início do primeiro elemento[0] { a, b, c, d }, // primeira linha [0] { e, f, g, h } // segunda linha [1] } // fim do primeiro grupo

{ // início do segundo grupo [1] { i, j, k, l }, // primeira linha [0] { m, n, o, p } // segunda linha [1] } // fim do segundo grupo { // início do terceiro grupo [2] { q, r, s, t } // primeira linha [0] { u, v, x, z } // segunda linha [1] } // fim do terceiro grupo }; // fim da matriz

Na declaração char Trid_Vetor[3][2][4], o índice [3] declara o número de grupos; o índice [2], o número de linha; e i índice [4], o número de colunas.

Logo, Trid_Vetor[0][0][0] == 'a' Trid_Vetor[0][0][1] == 'b' Trid_Vetor[0][0][2] == 'c' Trid_Vetor[0][0][3] == 'd' Trid_Vetor[0][1][0] == 'e' Trid_Vetor[0][1][1] == 'f' Trid_Vetor[0][1][2] == 'g' Trid_Vetor[0][1][3] == 'h'

e assim sucessivamente...


Outra maneira de dizermos:

'a', 'b', 'c', 'd', 'e', 'f', 'g' e 'h' estão no primeiro grupo;

'i', 'j', 'k', 'l', 'm', 'n', 'o' e 'p' estão no segundo grupo; e

'q', 'r', 's', 't', 'u', 'v', 'x' e 'z' estão no terceiro grupo.

'a', 'b', 'c', 'd', i', 'j', 'k', 'l', 'q', 'r', 's' e 't' estão na primeira linha; e

e', 'f', 'g', 'h', 'm', 'n', 'o', 'p', 'u', 'v', 'x' e 'z' estão na segunda linha.

'a', 'e', 'i', 'n', 'q', 'u', estão na primeira coluna;

'b', 'f', 'j', 'n', 'r', 'v', estão na segunda coluna;

'c', 'g', 'k', 'o', 's', 'x', estão na terceira coluna; e

'd', 'h', 'l', 'p', 't', 'z', estão na quarta e última coluna.

Para projetar imagens na tela, o computador trabalha com as coordenas X e Y, dentro de uma matriz bidimensional denominada Pixels. No Windows 98, se você der um clique com o botão direito do mouse sobre a área de trabalho (Desktop) e escolher a opção Propriedades no menu PopUp que aparecer, poderá acessar a aba Configurações na caixa que se abrir. No campo Área da tela, encontram-se as opções 640 por 480 pixels, 720 por 480 pixels, 800 por 600 pixels, 1024 por 600 pixels e 1024 por 768 pixels. Basicamente o computador projeta imagens na tela preenchendo-a com pontos coloridos. Por exemplo, a opção 800 por 600 pixels significa que serão colocados 800 pontos (pixels) na linha horizontal (coordenada X) por 600 na vertical (coordenada Y). Logo podemos supor que esses pontos estão localizados dentro da matriz Pixels de tamanho [800] por [600]: Pixels[800][600];

Através do exemplo abaixo podemos conhecer cada coordenada do Form, através do evento OnMouseDown, e, de quebra, conhecer uma forma de mudar a cor do Hint através de parâmetros passados para RGB():

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

void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { ShowHint = true; Application->HintColor = RGB(X%255, Y%255, (X+Y)%255); Hint = (String)"Coordenada X = " + X + '\n' + "Coordenada Y = " + Y +"\n" + "RGB(" + X%255 + ", " + Y%255 + ", " + (Y+X)%255 + ")";

} //---------------------------------------------------------------------------


Conforme dissemos, essas coordenadas são preenchidas com pontos coloridos que podem ser visualidas e acessadas. O exemplo a seguir nos possibilita visualizar a cor do pixels que receber o evento mouse down: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { Form1->Color = clRed; } //--------------------------------------------------------------------------- void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { ShowHint = true; Hint = ColorToString(Form1->Canvas->Pixels[X][Y]); } //---------------------------------------------------------------------------

Agora vamos criar uma matriz bi-dimensional que receberá o valor do RGB (cor) do local do form onde ocorrer o evento mouse down:

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

void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { Form1->Color = clPurple; short Ponto[800][600]; Ponto[X][Y] = ColorToRGB(Canvas->Pixels[X][Y]); Label1->Caption = Ponto[X][Y]; } //---------------------------------------------------------------------------


Arrays de caracteres

Podemos declarar e inicializar strings (arrays de caracteres) de mesma forma que fazemos com outros

tipos de matrizes.

Recapitulando um pouco, podemos entender uma constante caracter como sendo uma letra ou símbolo

colocado entre aspas simples: 'A', 'b', 'c', ']'. Também já sabemos que tais dados são armazenados

internamente pelo computador como um número inteiro entre 0 e 255.

Já uma seqüência de caracteres colocados entre aspas duplas constitui uma constante string, ou constante

de caracteres (no plural):

"Assis e Palmital"

"D. Pedro I deu um grito que ecôa até hoje!"

"A"

"b"

Essa "cadeia" ordenada de caracteres contém um caracter a mais do que parece ter, pois é encerrada com

o caracter nulo '\0'. Por exemplo:

char Nome[8] = "Therbio"; // visualmente Therbio possui apenas sete caracteres

Na memória a estrutura de armazenamento que se forma é:

Nome

T h e r b i o \0

0 1 2 3 4 5 6 7 //--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { char Nome[ ] = "Therbio"; // não fornecemos um índice Label1 -> Caption = sizeof(Nome); } //---------------------------------------------------------------------------

É diferente a interpretação que o compilador faz quando encontra um caracter entre aspas simples ou entre aspas duplas:


//--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { Label1 -> Caption = "Tamanho de \'A\' = " + String(sizeof('A')) + " byte" "\nTamanho de \"A\" = " + sizeof("A") + " bytes"; } //---------------------------------------------------------------------------

Certamente você já percebeu que a diferença se dá em virtude do caracter NULL (nulo) colocado a mais automaticamente pelo compilador.

Existem outras formas de declarar e inicializar constantes de caracteres:

int i[ ] = {0, 1, 2, 3, 4, 5, 6, 7}; // inteiros não precisam do caracter nulo

char ch[ ] = {'T', 'h', 'e', 'r', 'b', 'i', 'o', '\0'}; // essa não é a melhor

forma...

char* ch = "Que saudades do Rio Paraná!!!!"; // Ponteiros... logo os entenderemos!!!

Nessas declarações, [ ] significa "array de" e * significa "ponteiro para".

Obs. A expressão

char ch[3] = "Ola";

incorretamente declara uma matriz de índice três e a inicializa com os três caracteres 'O', 'l' e 'a' sem a terminação usual com o caracter nulo, '\0'. Embora essa notação, algumas vezes, pareça funcionar, deve ser evitada.

Uma forma sempre preferível é a notação:

char ch[ ] = "Ola";

pois inicializa a matriz com a mesma facilidade e implementa, automaticamente, a terminação usual com o caracter nulo '\0'.

Se na inicialização fornecermos elementos a menos do que o índice comporta, o valor 0 será atribuído inicialmente para os elementos restantes da matriz: //---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender) { /*O exemplo imprime a string referente ao mês de março e demonstra o preenchimento de alguns elementos restantes com 0*/ char nome [12] [10] = {"janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"};


Label1 -> Caption = AnsiString(nome[2][0]) + AnsiString(nome[2][1]) + AnsiString(nome[2][2]) + AnsiString(nome[2][3]) + AnsiString(nome[2][4]) + // até aqui, imprime março int(nome[2][5]) + // imprime zero int(nome[2][6] + 'a') + // imprime 97 int(nome[2][6] + 1) + // imprime 1 int(nome[2][7] - 1); // imprime -1 } //---------------------------------------------------------------------------

Estruturas

Conforme estudamos, uma matriz consiste num agrupamento de elementos do mesmo tipo, enquanto uma struct (estrutura) consiste num agrupamento de tipos de dados arbitrários, denominados membros, sob um único novo tipo e nome. Por exemplo: struct dados { AnsiString Nome; // conforme a inicialização, aqui haverá um ERRO char* rua; int Numero; String Cidade; // e aqui também. char Estado[3]; // ou então aqui, se a inicialização for de outro tipo int Cep; long Idade; float Peso; }; // o ponto-e-vírgula é necessário

define um novo tipo de dados agrupados sob o nome dados, onde podemos anotar alguns dados de alguma pessoa. Observe que existem itens que requerem diferentes tipos de dados. Enquanto alguns armazenarão strings (sob suas diversas formas, escolhidas aleatoriamente), outros armazenarão números inteiros e, por fim, o último, valores numéricos que poderiam conter uma fração.

Feito isso, podemos declarar variáveis do tipo dados como faríamos para declarar outra variável qualquer:

dados DeLima;

Acessamos os membros individuais através do operador . (ponto): DeLima.Nome = "Therbio"; DeLima.Rua = "Rua Central"; DeLima.Numero = 163;

Podemos inicializar estruturas da mesma forma que inicializamos um array: struct dados // define uma estrutura { char *Nome; // sem problemas


char rua[12]; // não esquecer de colocar o índice int Numero; char *Cidade; char Estado[3]; int Cep; long Idade; float Peso; }; // o ponto-e-vírgula é necessário

// inicializa a estrutura igual a uma matriz dados DeLima = { "Therbio", // essa inicialização não trabalha com AnsiString "Rua Central", 163, "Ibirarema", // também não trabalha com String "SP", 7073, 40, 91.6 };

// para imprimir num label, precisamos converter os dados em AnsiString ou String Label1 -> Caption = AnsiString(DeLima.Nome) + '\n' + String(DeLima.rua) + '\n' + AnsiString(DeLima.Numero) + '\n' + String(DeLima.Cidade) + '\n' + AnsiString(DeLima.Estado) + '\n' + AnsiString(DeLima.Cep) + '\n' + AnsiString(DeLima.Idade) + '\n' + String(DeLima.Peso);

Porém, esse tipo de inicialização acima tem dificuldade para inicializar dados do tipo AnsiString.

Eis outra forma de inicializar os membros individuais através do operador . (ponto): struct dados // define uma estrutura { AnsiString Nome; char *rua; // sem problemas int Numero; char *Cidade; // não trabalha com dados do tipo ch[ ] ou ch[i] String Estado; int Cep; long Idade; float Peso; }; // o ponto-e-vírgula é necessário

dados DeLima; // declara variável do tipo dados

// inicializa as variáveis que trabalha com AnsiString e String DeLima.Nome = "Therbio"; DeLima.rua = "Rua Central"; DeLima.Numero = 163; DeLima.Cidade = "Ibirarema"; DeLima.Estado = "SP";


DeLima.Cep = 07073; DeLima.Idade = 40; DeLima.Peso = 91.6;

// ok. Nesse exemplo não precisamos converter pra String ou AnsiString Label1 -> Caption = DeLima.Nome + '\n' + DeLima.rua + '\n' + DeLima.Numero + '\n' + DeLima.Cidade + '\n' + DeLima.Estado + '\n' + DeLima.Cep + '\n' + DeLima.Idade + '\n' + DeLima.Peso;

Observação:

Ainda que duas struct possuam os mesmos membros: struct aluno { char* Nome; int Nota; float media; };

struct __aluno { char* Nome; int Nota; float media; };

elas sempre serão diferentes tipos de dados entre si. Portanto a declaração: aluno Paulo;

__aluno Paulo_Jose = Paulo;

fará com que o compilador acuse um erro, uma vez que se trata de tipos incompatíveis entre si:

[C++ Error] Unit 1.cpp(36): E2034 Cannot convert 'aluno' to '__aluno'.

Ponteiros

Podemos entender um microcomputador como um sistema de cinco unidades de funcionamento: unidade de entrada (teclado, mouse, drive de CD-ROM, drive de disquetes etc), unidade de saída (impressora, monitor etc), unidade de memória (memória RAM -escrita e leitura-, memória ROM - leitura), e as unidades aritmética e lógica que se encontram agrupadas na CPU (Unidade Central de Processamento, o processador).

O chip responsável pelo controle de todo o computador é o processador. Outro circuito de extrema importância é a memória RAM, que podemos imaginar como um grupo de células usadas para


armazenamento temporário das instruções e dos dados que são acessados e processados pelo microprocessador em altíssima velocidade. Trata de uma memória volátil pois seus dados perdem-se no momento em que são desligadas, o que não chega a ser um problema, visto que esses dados, de regra, após salvos, ficam guardados em algum disco de armazenamento permanente, como os discos rígidos ou os disquetes, sendo copiados novamente para a memória na ocasião de seu re-processamento.

A memória RAM é constituída por uma imensa seqüência de células de armazenamento (localizações) com o tamanho de oito bits (um byte) cada, o que permite que cada uma dessas localizações possa assumir um entre 256 valores diferentes. Ressalte-se, ainda, que cada célula possui um endereço único e inconfundível, expresso por um valor numérico que define a exata localização desse byte, bem como que, apesar do limitado tamanho de cada célula, podemos acessar dois bytes consecutivos (word) ou quatro bytes consecutivos (doubleword) simultaneamente com um único endereçamento.

Conforme exposto, durante a execução de um programa, as instruções e os dados processados ficam armazenados na memória do computador. Cada informação é representada por certo grupo de bytes (char - 1 byte, float - 4 bytes, double - 8 bytes etc) e possui um local determinado na memória, um endereço que pode ser expressado por um valor hexadecimal. Não há necessidade de o programador conhecer o endereço absoluto de cada dado, pois cabe ao compilador relacionar o nome de cada variável com sua posição na memória.

Em muitas ocasiões é preferível trabalhar com os endereços das variáveis a acessá-las pela maneira convencional. A linguagem C++ dispõe do operador unário & que permite que os ponteiros (do inglês pointer), um tipo especial de variável, armazenem o endereço de outras variáveis.

Considerando-se o poder que os ponteiros representam na linguagem, a compreensão e o uso correto desses recursos são fundamentais para a criação de muitos programas em C++.

Podemos citar vários motivos para isso: são a única forma de implementar determinadas operações; produzem código compacto robusto e eficiente; constituem ferramenta bastante poderosa para manipulação da informação ou de elementos de arrays; constituem um meio para que as funções possam realmente modificar os argumentos da função chamadora; são usados na alocação e desalocação da memória do sistema; são usados para passar strings de uma função para outra; podem ser usados no lugar de arrays, o que proporciona aumento de eficiência.

Mas nem tudo é simples na utilização dos ponteiros. Em primeiro lugar, a sintaxe de ponteiros pode ser nova para muitos programadores de outras linguagens que estão iniciando seus estudos em C++; e, para complicar, o uso incorreto ou descuidado dos ponteiros pode causar o travamento imediato do programa, do sistema ou algo pior, como, por exemplo, a formatação do disco rígido.

Conceitualmente, ponteiro é uma variável que contém o endereço de localização na memória de outro objeto. Normalmente, esse endereço é a localização de alguma variável declarada no programa. Então dizemos que o ponteiro aponta para determinada variável. Logo também é correto chamá-lo de apontador.

Declaração


Quando realizamos operações com ponteiros, basicamente desejamos conhecer o endereço de uma variável e manipular o seu conteúdo. Para tanto, C++ nos fornece dois operadores especiais, o operador de endereços & (determina o primeiro byte do bloco ocupado pela variável) e o operador indireto de conteúdos * (retorna o conteúdo, ou seja, o valor do dado armazenado no endereço apontado).

Como qualquer variável, os apontadores precisam ser declarados. Ao declará-los, tomemos o cuidado de observar o tipo do bloco que será apontado. Por exemplo, se queremos um ponteiro apontando para uma variável char (bloco de 1 byte), devemos declará-lo como char; se o queremos apontando para uma variável int (bloco de 2 (ou 4) bytes, conforme a máquina), também devemos declará-lo como int, e assim por diante.

A declaração de um ponteiro é parecida com a declaração de outra variável qualquer. Eis a sintaxe:

tipo *nome;

onde tipo é o grupo a que pertence a variável e nome é o nome que escolhemos para a variável. Exemplo:

char *ch;

int *pi;

float *flot;

O operador unário *, mais conhecido como operador indireto, nos permite acessar o conteúdo do objeto apontado; permite, também, que o compilador saiba que a variável guardará um endereço, e não outro dado qualquer.

Quando declaramos um ponteiro, devemos inicializá-lo com algum "valor" que, de regra, será o endereço de alguma variável. Conforme vimos, C++ dispõe do operador de endereço & que permite que um apontador guarde o endereço da variável a qual se refere:

tipo *nome = &nome1;

onde nome1 é o nome da variável apontada:

char c;

int p;

float flt;


char *ch = &c;

int *pi = &p;

float *flot = &flt;

Para compreendermos melhor, vamos supor que a variável inteira p seja inicializada com o valor 257 (int p = 257;) e que esteja localizada no endereço 0065FDF8. Então, após a atribuição do ponteiro (int *pi = &p;), pi estará apontado para o endereço de memória 0065FDF8 e *pi será igual a p, ou seja, seu valor será exatamente os mesmos 257.

Veja as instruções:

int *p, p2;

float* flot, *flot2;

A primeira instrução declara um ponteiro p (para int) e uma variável p2 do tipo int. Já a segunda instrução declara dois ponteiros (flot e flot2) do tipo float. Observe o operador indireto * determinando os elementos da lista que serão ponteiros. Observe também que os três ponteiros ainda não foram inicializados, o que significa que eles apontam para um endereço qualquer da memória do micro. Um ponteiro, nessas circunstâncias, pode acarretar sérios problemas. Se não existir nenhum "valor" para inicializar o ponteiro, devemos inicializá-lo com 0 (zero), o que indicará que o ponteiro não se refere a nenhum objeto:

tipo *nome = 0;

Vamos escrever um simples programa Console Wizard abordando o tema:

#include <iostream> #include <conio> using namespace std; main() { int i = 97; //variável int int *Pi = &i; //ponteiro para int int *Pi2 = 0; //Ponteiro apontando para null cout << "\n\tConteudo via variavel = " << i; cout << "\n\tEndereco via variavel = " << &i; cout << "\n\tConteudo via ponteiro = " << *Pi; cout << "\n\tEndereco via ponteiro = " << Pi; cout << "\n\n"; int i2 = 98; //variável int Pi2 = & i2; //inicializa Pi2 com endereço de i2 cout << "\n\tAgora podemos acessar *Pi2 ... "


<< *Pi2 << "\n"; //exibe o conteúdo de i2 via ponteiro getch(); }

Veja um exemplo equivalente no ambiente visual do C++Builder:

//--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { int i = 97; //variável int int *Pi = &i; //ponteiro para int int *Pi2 = 0; //Ponteiro apontando para null Label1 -> Caption = "\tConteúdo via variável = " + String(i) + "\n\tEndereço via variável = " + IntToHex(int(&i), 8) + "\n\tConteúdo via ponteiro = " + *Pi + "\n\tEndereço via ponteiro = " + IntToHex(int(Pi), 8); int i2 = 98; //variável int Pi2 = & i2; //inicializa Pi2 com endereço de i2 Label2 -> Caption = "\tAgora podemos acessar *Pi2 ... " + String(*Pi2); //exibe o conteúdo de i2 via ponteiro } //---------------------------------------------------------------------------

O código abaixo exibe o endereço da variável: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { double r = 65; Label1 -> Caption = IntToHex(int(&r), 8);

} //---------------------------------------------------------------------------

Os exemplos acima ilustram bem o fato de que toda variável possui um endereço e de que, mesmo sem saber o endereço específico da variável, podemos armazenar esse endereço em um ponteiro.

A reutilização de um ponteiro

Uma vez declarado e inicializado, podemos redefinir o conteúdo de um ponteiro indefinidamente. Basta atribuirmos um novo endereço para o ponteiro, descartando o endereço anterior (que será perdido pelo ponteiro). O exemplo a seguir usa um Label no Form. Conforme o evento do mouse, (down, move ou up), um ponteiro apontará para variáveis diferentes, exibindo os valores respectivos no Label:


#include "Unit1.h" //---------------------------------------------------------------------------


#pragma package(smart_init) #pragma resource "*.dfm"

int i_1 = 100; // declara e inicializa variável int global int *P_i = 0; // declara e inicializa com 0, ponteiro para int


void __fastcall TForm1::Label1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { P_i = &i_1; // atribui o endereço0 de i_1 ao ponteiro P_i Label1 -> Caption = *P_i; // exibe o conteúdo da variável (100) via ponteiro } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { int i_2 = 200; // declara e inicializa variável int local P_i = &i_2; // atribui o endereço da variável local ao ponteiro Label1 -> Caption = *P_i; // exibe o conteúdo da variável (200) via ponteiro } //---------------------------------------------------------------------------

void __fastcall TForm1::Label1MouseMove(TObject *Sender, TShiftState Shift, int X, int Y) { int i_3 = 300; // declara e inicializa variável int local P_i = &i_3; // atribui o endereço da variável local ao ponteiro Label1 -> Caption = *P_i; // exibe o conteúdo da variável (300)via ponteiro } //---------------------------------------------------------------------------

Ponteiros apontando para outros ponteiros

Como sabemos, um ponteiro pode apontar para qualquer tipo de variável.

void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString Alvo = "AnsiString é uma variável ou uma classe?"; AnsiString *Aponta_Alvo = &Alvo; Edit1 -> Text = *Aponta_Alvo; }

Ele pode, inclusive apontar para outro ponteiro:


//--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { char Alvo[ ] = "Alvo[ ] é uma matriz ou um ponteiro?"; // logo saberemos char *Aponta_Alvo = &*Alvo; // igual a: char *Aponta_Alvo = &Alvo[0]; Edit1 -> Text = *Aponta_Alvo; // experimente: Edit1 -> Text = Aponta_Alvo; } //---------------------------------------------------------------------------

A notação acima pode parecer estranha. Ocorre que o nome de um array é um ponteiro que aponta para o primeiro elemento da matriz (conforme explicado em outra seção mais adiante). Logo, usamos essa característica para montar o exemplo acima, onde um ponteiro aponta para outro ponteiro.

veja um exemplo, usando três ponteiros: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { char *ch = "testando ponteiros"; char **ch_Ptr = &ch; char ***Ptr_ch_Ptr = &ch_Ptr; Label1 -> Caption = "*ch = " + String(*ch) + '\n' + "ch = " + ch + '\n' + '\n' + "**ch_Ptr = " + **ch_Ptr + '\n' + "*ch_Ptr = " + *ch_Ptr + '\n' + '\n' + "***Ptr_ch_Ptr = " + ***Ptr_ch_Ptr + '\n' + "**Ptr_ch_Ptr = " + **Ptr_ch_Ptr; } //---------------------------------------------------------------------------

Ponteiros apontando para structs

Diferente do que ocorre com matrizes (das quais podemos acessar seus elementos individuais por meio de índices), não podemos usar valores numéricos para acessar os membros de uma estrutura com base em sua ordem. Isso ocorre porque, enquanto todos os elementos de uma matriz são constituídos de um mesmo tipo de dado, os de uma estrutura podem ser constituídos de dados de tipos diferentes.

Uma vez que cada membro da estrutura possui um nome simbólico, podemos usá-lo no acesso aos dados, separado do nome do membro através do operador . (ponto - que significa "membro de"): //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


struct Endereco { AnsiString Nome; int idade;


}Marta; // outra forma de declarar uma variável struct

TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender) { /*inicializa variáveis na criação do Form*/ Marta.Nome = "Marta C. Plaça"; Marta.idade = 36; } //--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { (*Label1).Caption = /*Breve você entenderá essa notação*/ Marta.Nome + '\n' + Marta.idade; } //--------------------------------------------------------------------------- void __fastcall TForm1::Label2Click(TObject *Sender) { Marta.Nome = "Marta C. Plaça Alves"; // casou!!! Marta.idade = 432; // se for variável, aceita estes novos valores Label1 -> Caption = "Será que Marta.Nome e Marta.idade são variáveis?"; (*Label2).Caption = Marta.Nome + '\n' + Marta.idade + " meses"; } //---------------------------------------------------------------------------

A notação de ponteiros para estruturas segue um procedimento semelhante, com duas diferenças:

1 - Substituição do nome da estrutura pelo nome do ponteiro;

2 - Substituição do operador . "membro de" pelo operador -> ("aponta para"), que é formado por um hífen “ - ” mais o símbolo "maior que “ > ”:

No exemplo anterior, altere o evento OnClick, apenas, de Label2: void __fastcall TForm1::Label2Click(TObject *Sender) { Endereco *PtrNome = &Marta, *PtrIdade = &Marta; (*Label2).Caption = PtrNome -> Nome + '\n' + (*PtrIdade).idade; /* Ops!! Parece que já vi essa notação*/ }

Você já deve ter entendido. Veja:

Label1 -> Caption é igual a (*Label1).Caption, assim como, obviamente, PtrNome -> Nome será igual a (*PtrNome).Nome, então essas notações têm muito em comum!


Por aí, podemos perceber a grande importância que os ponteiros representam na linguagem C++, especialmente no C++Builder. Você, mesmo sem consciência, já tem trabalhado com esses conceitos ora apresentado, desde os nossos primeiros exemplos. Um completo domínio sobre ponteiros, pode fazer a diferença para qualquer pessoa que se aventure nesse ramo da programação.

O nome do array

Veja o seguinte trecho de código: void __fastcall TForm1::Label1Click(TObject *Sender) { char Abcdario[26]; for(int i = 0; i < 26; i++) { Abcdario[i] = 65 + i; Label1 -> Caption = Abcdario[0]; } }

Ao ser executado, o programa imprimirá o caracter 'A' no label. Como sabemos, os elementos de um vetor ficam enfileirados seqüencialmente na memória do computador. Supondo que Abcdario[0], o primeiro elemento da matriz, ocupe a posição 651256 na mémória, Abcdario[1] ocuparia a posição 651257; Abcdario[2], a posição 651258; Abcdario[3], a posição 651259; Abcdario[4], a posição 65125A; e assim sucessivamente.

Veja agora o próximo exemplo, usando o nome da matriz, que também imprime 'A' no Label:

void __fastcall TForm1::Label1Click(TObject *Sender) { char Abcdario[26] = {65, 66, 67, 68, 69}; // A, B, C, D, E - na tabela ASCII Label1 -> Caption = *Abcdario; }

Pergunta: Se não colocamos o índice, porque essa aplicação imprime o caracter 'A' no Label? E porque usamos a notação de ponteiros?

Resposta: Simplesmente porque o nome de um array representa o seu endereço de memória, sendo que tal endereço é o do elemento que ocupa o índice 0 (zero) da matriz. Ou, de um modo mais objetivo: o nome

de um array é um ponteiro que aponta para o primeiro elemento da matriz.

Raciocine. Se Label1 -> Caption = Abcdario[0]; // imprime 'A' equivale a


Label1 -> Caption = *Abcdario; // imprime 'A'

então,

Label1 -> Caption = Abcdario[1]; // imprime 'B'

equivale a

Label1 -> Caption = *(Abcdario + 1); // imprime 'B'

e

Label1 -> Caption = Abcdario[2]; // imprime 'C'

equivale a

Label1 -> Caption = *(Abcdario + 2); // imprime 'C'

e assim por diante.

Considere a seguinte declaração: void __fastcall TForm1::Label1Click(TObject *Sender) { int i = 6; char Abcdario[26] = {65, 66, 67, 68, 69, 70, 71}; Label1 -> Caption = Abcdario[i]; // imprime 'G' Label2 -> Caption = *(Abcdario + i); // imprime 'G'

}

do exposto temos que a expressão *(Abcdario + i) sempre terá o mesmo valor de Abcdario[i].

Vamos, agora, montar dois exemplos que imprimem os caracteres 'C', 'D', 'E', 'F' e 'G':

int i = 2; /* cada valor de i determina inícios de impressão de diferentes*/ { char Abcdario[26] = {65, 66, 67, 68, 69, 70, 71}; Label1 -> Caption = Abcdario + i; /* se i = 0, Label1 -> Caption = Abcdario; */ } // fim do primeiro exemplo

{ char Abcdario[26] = {65, 66, 67, 68, 69, 70, 71}; Label2 -> Caption = &Abcdario[i]; } // fim do segundo exemplo

Agora temos, também, que Abcdario + i é equivalente a &Abcdario[i].

Vejamos, agora, um exemplo onde um ponteiro é declarado e inicializado apontando para um vetor: void __fastcall TForm1::Button1Click(TObject *Sender) { Label1 -> Caption = "";


char Ch[] = "O Osmarino é um grande amigo de infância"; char *ApontCh; ApontCh = &Ch[0]; for(int i = 0; i < 42; i++) { Label1 -> Caption = Label1 -> Caption + *ApontCh; ApontCh++; } }

Quando estudamos arrays de caracteres, aprendemos algumas formas de declarar e inicializar constantes de caracteres, entre elas:

char* ch = "Que saudades do Rio Paraná!!!!"; // Ponteiros... logo os entenderemos!!!

Agora já possuímos conceitos suficientes para entende o porquê de tal declaração. Veja um exemplo:

void __fastcall TForm1::Button1Click(TObject *Sender) { char *ch = "Que saudades do Rio Paraná!!!!"; // Ponteiros... logo os entenderemos!!! Label1 -> Caption = *ch; // imprime: Q Label2 -> Caption = ch; // imprime: Que saudades do Rio Paraná!!!! Label3 -> Caption = *ch + 1; // imprime: 82 Label4 -> Caption = ch + 1; // imprime: ue saudades do Rio Paraná!!!! Label5 -> Caption = *(ch + 1); // imprime: u }

Conclusão: Na linguagem C++, o relacionamento entre arrays e ponteiros é muito grande, a ponto de, sob

muitos aspectos, poderem ser tratados juntos.

Variáveis dinâmicas

Quando um programa é executado, o sistema operacional reserva um espaço de memória para o código (ou instruções do programa) e outro espaço para as variáveis usadas durante a execução. Grosso modo, esses espaços ocupam uma mesma região, que podemos denominar memória local. Também existem outras zonas de memória, como a pilha, usada, entre outras coisas, para realizar o intercâmbio de dados entre as funções. O resto, a memória que não estiver em uso por nenhum programa, é o que se conhece por memória livre (área de alocação dinâmica, heap ou free store). Quando um programa usa a área de alocação dinâmica, naturalmente estará usando parte desse resto de memória.

O maior poder esperado na utilização de ponteiros decorre, justamente, de seu uso junto a esse conceito de alocação de memória no free store.

C++ dispõe de dois operadores para acesso à memória dinâmica: new e delete.


Operador new:

O operador new oferece um meio para alocação de espaço na memória livre, de uma forma parecida, porém muito superior àquela alocação oferecida pela função malloc() da livraria padrão da linguagem C. O operador new precisa, necessariamente, ser suprido com o tipo de dados para o qual está alocando memória, a fim de que o compilador saiba exatamente quanta memória deverá reservar para colocar os dados no heap. Por exemplo:

new double

aloca 8 bytes, suficientes para conter um double.

O operador new retorna um endereço de memória a ser atribuído a um ponteiro:

double *dbl = new double;

Feito isso, o que acontece é que dbl passará a apontar para uma variável double na área de alocação dinâmica. Logo, podemos inserir algum valor nessa variável:

*dbl = 563.9082;

Se a reserva de memória não for bem sucedida, o operador new devolverá um ponteiro nulo (NULL).

Sintaxe (para tipos pré-definidos – baseado no Help do BCB):

<::> new <placement> type-name <(initializer)>

<::> new <placement> (type-name) <(initializer)>

Na sintaxe acima, os símbolos < > significam que os dados inseridos não são obrigatórios. Ex: placement. Continuemos: :: new placement tipo ( inicializador) // char *ch = :: new char ('A');

:: new placement (tipo) (inicializador) // char *ch = new (char) (65);

Parênteses envolvendo o tipo é opcional. Os argumentos opcionais podem ser os seguintes:

:: , placement e ( inicializador)

O operador ::, relacionado com a sobrecarga de operadores, executa a versão global de new.

O mesmo se aplica a placement, que pode ser usado para fornecer argumentos adicionais para new. Mas você poderá usar essa sintaxe somente se você tiver uma versão sobrecarregada de new que seja compatível com os argumentos opcionais.


O inicializador, se aparece, é usada para assinalar valores iniciais para a memória reservada com new, mas não pode ser usado com arrays.

Um pedido para uma alocação para um dado não-array usa apropriadamente o operador new(). Qualquer pedido, porém, para alocação array deve chamar o apropriado operador new[]:

:: new tipo[ ]

Alocação de memória para um objeto não-array é feito pelo uso de ::new(). Note que essa alocação é sempre usada para tipos pré-definidos. Ela também é possível para sobrecarga de operador de função global. De qualquer forma, isso geralmente não é aconselhável.

Nota: Classes de arrays requerem um construtor default.

Há uma regra de ouro, quando se usa a área de alocação dinâmica:

"toda memória reservada durante a execução do programa deve ser liberada antes do encerramento do

programa".

A memória é liberada através do operador delete.

Vejamos um exemplo: //--------------------------------------------------------------------------- void __fastcall TForm1::Label1Click(TObject *Sender) { int *a; char *b = new char; float *c = new float (123.4);

struct stPunto { double e,f; } *d; a = new int;

d = new stPunto; *a = 65; *b = 65;

d->e = 123.456; d->f = 0.5;

Label1 -> Caption = "a = " + String(*a) + '\n' + "\nb = " + *b + '\n' + "\nc = " + *c + '\n' + "\nd = (" + d->e + " " + (*d).f + ")"; delete a; delete b; delete c; delete d; } //---------------------------------------------------------------------------


Não seguir a regra de liberar a memória alocada antes do encerramento do programa é uma atitude extremamente irresponsável, e na maior parte dos casos acarretará conseqüências desastrosas, tais como:

Tenha muito cuidado: se um ponteiro perde uma variável reservada dinamicamente (perda de memória), esta não poderá mais ser liberada. Exemplo: void __fastcall TForm1::Button1Click(TObject *Sender) { int *a; a = new int; // variável dinâmica *a = 10; a = new int; // nova variável dinâmica. Perde-se a anterior *a = 20; delete a; // só é possível liberar a última reserva

}

Neste exemplo vemos como é impossível liberar a alocação de memória feita em primeiro lugar. Se não necessitamos mais dela, deveríamos tê-la liberado antes de reservá-la outra vez, e se ainda necessitamos, devemos guardar sua posição, por exemplo com outro ponteiro.

Operador delete:

Como sabemos, em C++, devemos desalocar a memória usada por qualquer coisa que tenha sido criada pelo operador new. Existe uma exceção a essa regra que é o filho de um form MDI, criado como filho de um parent MDI, pois esses objetos serão deletados, automaticamente, pelo sistema quando do encerramento do programa. Logo, os blocos de memória reservados com o operador new serão válidos até que sejam liberados com delete ou, em certos casos, até o fim do programa. Mas é sempre aconselhável liberar-se a memória reservada com new usando delete.

Sintaxe: ::

<::> delete <cast-expression>

<::> delete [ ] <cast-expression>

delete <array-name> [ ];

Acima adotamos a mesma regra usada na sintaxe de new:


::delete expressão //expressão normalmente será um ponteiro.

:: delete [ ] expressão // delete[] expressão é usado para arrays dinamicos

como sabemos, em muitos casos, :: é opcional.

Quando se usa o operador delete com um ponteiro nulo, nenhuma ação será realizada. Essa

característica permite usar o operador delete com ponteiros sem a necessidade de se perguntar antes se

o mesmo é nulo.

int *i = new (int) ('\0');

delete i;

Nota: Os operadores new e delete são próprios de C++. Em C, usamos as funções malloc e free para reservar e liberar memória dinâmica. Liberar um ponteiro nulo com free pode provocar conseqüências desastrosas.

Em tópicos mais avançados abordaremos arrays dinâmicos (alocados através de new e liberados através de delete).

Mais problemas ... ponteiros soltos

Outra forma de se pedir problemas, é tentar reutilizar um ponteiro cujo espaço apontado na memória foi liberado pelo operador delete, sem antes atribuir um novo endereço ou uma nova variável ao ponteiro: //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


int * i = new int (100); // cria variável dinâmica

TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender) { Label1 -> Caption = *i; // código implementado na criação de Form1 }


//--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { /*************deleta a variável dinâmica. **************Se você clicar Button1 e ENCERRAR O PROGRAMA **************sem clicar Button2, **************ou clicar Button2 antes de clicar Button1, **************não haverá bug *******************************************************/ delete i; } //---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender) { /********* SE VOCÊ JÁ DEU UM CLIQUE EM Button1******** *********E CLICAR Button2, O BICHO VAI PEGAR**********/

*i = 200; /* coloca um novo valor no endereço apontado pelo ponteiro... ... só que, se Button1 foi já clicado, não existirá uma variável no endereço para receber o novo valor... então!!!!! */ Label1 -> Caption = *i; } //---------------------------------------------------------------------------

O melhor resultado produzido nos meus testes pelo exemplo acima foi o seguinte:

Vamos entender o que aconteceu. A instrução:

int * i = new int (100);

de certa forma, combina várias instruções numa só, pois, na verdade, cria um ponteiro:


int * i

uma variável:

new int

e atribui um valor a essa variável:

int (100);

Só que essa variável não possui um nome próprio. Observe que o ponteiro não foi criado por new. O operador new criou apenas a variável int inominada. Logo o ponteiro não estará sujeito às regras de criação e destruição new / delete, visto ter sido criado naturalmente pelo programa, como outro ponteiro qualquer.

Para melhor compreensão, veja a mesma instrução montada de forma diferente:

int * i; // cria naturalmente um ponteiro i = new int; // cria variável dinâmica e atribui seu endereço ao ponteiro *i = 100; // inicializa a variável, via ponteiro

Podemos acessar e modificar essa variável inominada através do ponteiro * i. Quando chamamos o operador delete ele destrói apenas a variável criada pelo operador new, desalocando a memória respectiva. A partir desse momento, o sistema fica livre para colocar qualquer tipo de dado nesse endereço. O ponteiro, que não foi destruído pelo operador delete, visto que não foi criado por new, continua existindo e apontando para o mesmo endereço.

Então, tentar usar esse ponteiro poderá ocasionar o imediato travamento do programa, ou a derrubada de todo o sistema. Ou pior, o programa poderá continuar funcionando normalmente, e só travar posteriormente, o que tornará bastante difícil a solução do bug.

Vamos refazer o exemplo, retirando o bug através da colocação de uma nova variável no endereço:

Nota: No exemplo abaixo, primeiro dê um clique em Button1, e depois em Button2. E depois, para liberar a memória, clique novamente em Button1 antes de encerrar o programa. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop


int * i = new int (100);

TForm1 *Form1; //---------------------------------------------------------------------------


__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender) { Label1 -> Caption = "valor de i = " + String(*i) + "\nendereço = " + IntToHex(int(&*i), 8); } //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { delete i; } //---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender) { i = new int; *i = 200; Label1 -> Caption = "valor de i = " + String(*i) + "\nendereço = " + IntToHex(int(&*i), 8); // NÃO ESQUEÇA DE DESALOCAR A MEMÓRIA, // CLICANDO NOVAMENTE (Button1Click) // ANTES DE ENCERRAR O PROGRAMA } //---------------------------------------------------------------------------

Ao rodar o exemplo, você observará que o ponteiro continuará apontando sempre para o mesmo endereço de memória. Poderíamos, também, retirar o bug fazendo com que o ponteiro apontasse para outro endereço. Para isso alteraríamos apenas o código de Button2Click: //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { int j = 1000; // essa variável não foi criada por new i = &j; Label1 -> Caption = "valor de i = " + String(*i) + "\nendereço = " + IntToHex(int(&*i), 8); } //---------------------------------------------------------------------------

Ponteiros & constantes

Veja algumas declarações usando const com ponteiros, e tente visualizar as possíveis diferenças de resultados, em virtude da posição do prefixo const: AnsiString * const Const_Str = &Str; // o ponteiro é constante

const int* Const_i = &i; // a variável é constante para *Const_i


const double * const Const_dbl = &dbl; // Nem Const_i, nem *Const_i podem ser alterados

Vejamos agora um exemplo com respectivos comentários abordando cada situação:



//////////////GRUPO DO PONTEIRO CONSTANTE ////////////////// AnsiString Str = "Testando Ponteiros e Constantes"; AnsiString Str_1 = "Um novo endereço não pode ser atribuído" " a um ponteiro const"; AnsiString * const Const_Str = &Str; // ponteiro const para Str

////////////////////////////////////////////////////////////////////////////////

////////////GRUPO DO DADO APONTADO CONSTANTE ////// int i = 100; // obs. i pode ter seu valor alterado, mas não por *Const_i int i_1 = 200; const int *Const_i = &i; // o ponteiro (*Const_i) não consegue alterar i ////////////////////////////////////////////////////////////////////////////////

// PONTEIRO E VARIÁVEL CONSTANTES VIA PONTEIRO double dbl = 0.123456789; // dbl é variável, mas não via ponteiro *Const_dbl double dbl_1 = 9.876543210; const double * const Const_dbl = &dbl; // Const_dbl e *Const_dbl constantes ////////////////////////////////////////////////////////////////////////////////

TForm1 *Form1;

//--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender) { // eventos na criação de Form1 Label1 -> Caption = *Const_Str; Label2 -> Caption = *Const_i; Label3 -> Caption = *Const_dbl; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender)


{ // altera a variável via ponteiro. Ok *Const_Str = "alterando a variável via ponteiro - operação permitida."; Label1 -> Caption = *Const_Str;

Const_i = &i_1; // altera endereço apontado via ponteiro. Ok Label2 -> Caption = "Alterando endereço via ponteiro. " "Operação permitida. *Const_i = " + String() + *Const_i; Const_i = &i; // volta apontar para a variável inicial } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { // tenta redirecionar ponteiro const para outra variável... ERRO!!!! Const_Str = &Str_1; // [C++ Error] Unit1.cpp(57): E2024 Cannot modify a const object. Label1 -> Caption = *Const_Str; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button3Click(TObject *Sender) { // tenta alterar variável const para ponteiro ... ERRO!!!! *Const_i = 400; // [C++ Error] Unit1.cpp(63): E2024 Cannot modify a const object. Label2 -> Caption = *Const_i; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button4Click(TObject *Sender) {// tenta alterar variável / ponteiro const e redirecionar ponteiro const ... ERRO!!!! *Const_dbl = 5.43; // [C++ Error] Unit1.cpp(69): E2024 Cannot modify a const object. Const_dbl = &dbl_1; // [C++ Error] Unit1.cpp(70): E2024 Cannot modify a const object. Label3 -> Caption = *Const_dbl; } //---------------------------------------------------------------------------

Referências

É possível criar um segundo nome para determinado tipo de dados, ou seja, um "apelido". O nome original e o "apelido" serão, exatamente, o mesmo dado, ocupando, inclusive, o mesmo endereço. Toda modificação que implementarmos através do "apelido" estará afetando, diretamente, o dado original: //---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString esposa = "Marta"; // declara e inicializa variável esposa AnsiString &ref_esposa = esposa; // cria e inicializa uma referência para esposa ref_esposa = "Marta é minha esposa!"; // altera variável esposa através do "apelido"

Label1 -> Caption = esposa + '\n' + // imprime esposa (modificada por ref_esposa) // demonstra que se trata do mesmo dado, através do endereço "Endereço de esposa = " + IntToHex(int(&esposa), 8) + '\n' + "Endereço de ref_esposa = " + IntToHex(int(&ref_esposa), 8); } //---------------------------------------------------------------------------


Analisando o código, percebemos que uma referência deve ser criada com o mesmo tipo de dados do dado alvo (AnsiString, no exemplo) e com o operador & antecedendo o "apelido", bem como ser inicializada com o nome do dado original (esposa, no exemplo). Outra observação importantíssima é que referências devem ser inicializadas na mesma instrução de sua declaração.

Instruções do tipo: AnsiString &ref_esposa; ref_esposa = esposa;

Retornarão uma mensagem de erro, avisando que a referência deve ser inicializada:

[C++ Error] Unit1.cpp(19): E2304 Reference variable 'ref_esposa' must be initialized.

Reatribuição de uma referência

Desde minha infância, tenho um grande amigo chamado Wanderley. Desde que o conheço (trinta anos, ou mais), o Wanderley tem um apelido: "Churrasco". Esse apelido está tão difundido na personalidade do Wanderley, que uma vez ele me falou que eu seria a única pessoa que o chamava pelo nome verdadeiro. Todas as outras pessoas tratavam-no por seu apelido. Muitos nem sabem seu verdadeiro nome. Agora vamos supor uma hipótese meio absurda. Amanhã eu chego até o Wanderley para, formalmente, comunicar-lhe de que, a partir daquele momento, o apelido não será mais dele. Que o apelido será meu. E saio da presença do Wanderley convencido de que, a partir de então, todos me chamarão de Churrasco, enquanto tratarão o antigo Churrasco por Wanderley. É possível????

NÃO DÁ PRA TROCAR APELIDO!!!!!

E, POR MAIS QUE SE POSSA QUERER,

NÃO SE PODE PEGAR O APELIDO DE NINGUÉM!!!!

Certamente você já entendeu onde queremos chegar: Uma referência, uma vez inicializada no momento de sua criação, apontará sempre para o mesmo dado. Não podemos pegar o "apelido" daquele dado e transferi-lo para outro dado: //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString irma = "Cybele"; // declara e inicializa variável irma AnsiString &ref_irma = irma; // cria e inicializa uma referência para irma ref_irma = "Cybele é minha irmã!"; // altera variável esposa através do "apelido"

Label1 -> Caption = irma + '\n' + // imprime irma (modificada por ref_irma) // demonstra que se trata do mesmo dado, através do endereço "Endereço de irma = " + IntToHex(int(&irma), 8) + '\n' + "Endereço de ref_irma = " + IntToHex(int(&ref_irma), 8);

AnsiString irma_1 = "Daurylene também é minha irmã"; // variável irma_1


irma_1 = ref_irma; /* parece que está atribuindo a referência para a outra variável. Mas está alterando o conteúdo de irma_1, que passa ser igual a irma. O apelido continua pertencendo a irma (v. endereços) */

//ref_irma = irma_1; // eis outra possibilidade de verificação no lugar da anterior

Label2 -> Caption = irma_1 + '\n' + // imprime irma_1, seja qual for o conteúdo "Endereço de irma_1 = " + IntToHex(int(&irma_1), 8) + '\n' + // mostra que ref_irma mantém o antigo endereço "Endereço de ref_irma = " + IntToHex(int(&ref_irma), 8) + "\n\n\n" + irma + '\n' + // mostra que irma foi alterada // demonstra que se trata do mesmo dado, através do endereço "Endereço de irma = " + IntToHex(int(&irma), 8) + '\n' + ref_irma + '\n' + "Endereço de ref_irma = " + IntToHex(int(&ref_irma), 8); } //---------------------------------------------------------------------------

Pelo exemplo, percebemos que a referência não pode apontar para outro dado. O que ela faz é alterar o valor dos dados. E pode alterar tanto o valor do alvo, como do outro tipo que estivermos trabalhando, atribuindo a esse segundo, o valor do alvo, ou vice-versa.

Este curso está disponível, online, no DicasBCB, o Site dos Programadores C++Builder

http://www.dicasbcb.com.br

nosso fórum:

http://www.dicasbcb.com

Autor: Thérbio de Lima Alves (DeLima)

Agradecimentos especiais:

Lucas Santos Sanches ( mais conhecido por scorpio) em nosso Fórum.

Lucas, em nome de toda nossa comunidade, muito obrigado por viabilizar esta edição em PDF de nosso curso, antiga reivindicação de grande parte dos freqüentadores de nosso site!

curso básico c++

Documents