Você está na página 1de 5

Introdução ao C++ Builder - um breve

tutorial

1. Iniciando o C++ Builder

Ao iniciar-se o C++ Builder, o seguinte conjunto de janelas padrão é mostrado:

Barras de ferramentas e menus: contêm todos os comandos necessários para


uso do ambiente, bem como as barras contendo os componentes que podem ser
inseridos em um projeto.

Janela principal: constitui-se na janela que é criada quando um novo projeto é


iniciado. Essa janela é exibida quando da execução do aplicativo e pode conter
outros componentes dentro de si.

Class Explorer e código fonte: nessa janela são exibidos os códigos-fonte dos
métodos criados pelo Builder e pelo usuário e também um pequeno “browser”, no
qual podem ser visualizadas todas as classes do projeto e seus respectivos métodos
e atributos.

Dica: se a janela do class explorer não estiver visível, selecionar a opção Class
Explorer no menu View.

Object Inspector: esta janela exibe as propriedades (atributos) e eventos


associados a um determinado componente (objeto) que esteja selecionado.
2. Criando um novo projeto

No menu File, selecionar New Application.

Um novo “form” (janela), chamado form1, será criado. Associado a ele será criado
um novo módulo de programa chamado Unit1.cpp, o qual conterá o código para a
nova aplicação.

Por enquanto, o projeto consiste do form1, que é um objeto da classe TForm1. Esta
classe é derivada da classe TForm, a partir da qual janelas comuns são criadas.

A janela denominada “object inspector” permite alterar as propriedades associadas


ao form1, incluindo seu tamanho, os botões que são mostrados no canto superior
direito, e outras.

3. Inserindo componentes

O form criado é capaz de conter outros componentes dentro de si, como janelas de
texto, botões, etc.

Para inserir qualquer componente sobre o form, clicar sobre o componente


correspondente na barra de ferramentas (junto ao menu do C++ Builder) e
arrastá-lo sobre o form, na posição desejada.

Ao clicar-se sobre o componente recém-posicionado, a janela “object inspector”


passa a exibir os atributos deste componente em particular, bem como os eventos
associados a ele.

Por exemplo, ao inserirmos um botão (classe TButton), podemos alterar a sua


propriedade “Caption” para mudar o texto exibido sobre o botão.

OBSERVAÇÃO IMPORTANTE : Todos os componentes inseridos em um form são


referenciados por ponteiros. Assim, qualquer referência a um atributo (propriedade)
ou método de um componente deve ser feita utilizando-se o operador de seta (->).

4. Manipulando eventos

A janela “object inspector” possui uma aba chamada “Events”. Esta aba apresenta
uma série de eventos que são gerados em relação àquele objeto em particular e
que podem ser capturados e tratados pelo programa.

Para escrever a função que trata um evento em particular, basta clicar sobre o
espaço ao lado do nome do evento. Por exemplo, para tratar um evento de clique
do mouse sobre o form1, clicar ao lado de OnClick. Uma função, que será chamada
quando ocorrer o evento de clique do mouse sobre o form1, terá o seu código
iniciado.

Inserindo, por exemplo, o seguinte código no corpo da função:


Canvas->Font->Color = clRed;
AnsiString texto("Texto inicial");
Canvas->TextOutA(20, 20, texto);

Verificamos que, ao clique do mouse sobre o form1, o texto “Texto inicial” aparece
pintado sobre a janela nas coordenadas (20, 20) em relação ao canto superior
esquerdo da janela.

O objeto Canvas, classe TCanvas, utilizado no código, é um objeto associado ao


form1 que possui métodos para pintura sobre a janela. Ao alterar-se o
atributo Color do atributo Font contido em Canvas para clRed, qualquer texto a ser
escrito na janela passará a ser escrito na cor vermelha.

A classe AnsiString define um objeto que encapsula um texto qualquer, sobre o


qual pode-se efetuar uma série de operações (por exemplo, concatenação
utilizando o operador “+”). No caso, utilizamos um construtor de AnsiString para
criar um objeto chamado texto e preenchê-lo com a string “Texto inicial”.

Ao chamarmos o método TextOutA do objeto Canvas, podemos escrever o


conteúdo de um AnsiString (no caso, o objeto texto) em coordenadas quaisquer da
janela (no caso, 20 e 20).

No exemplo anterior, no qual inserimos um botão, ao selecionarmos o


evento OnClick e inserirmos o seguinte código:

Canvas->Font->Color = clBlue;
AnsiString texto2("Clicou o botão!");
Canvas->TextOutA(20, 80, texto2);

O texto “Clicou o botão!” aparecerá na janela na posição 20, 80 sempre que o


botão for clicado.

Como saber quais atributos e quais métodos fazem parte de quais classes?
Consultar a documentação online (menu Help – Index ou teclando CTRL+F1 sobre
um termo qualquer).

5. Componentes mais utilizados

Apresenta-se a seguir uma lista dos componentes mais simples e mais utilizados.
Estes são apenas exemplos da grande variedade de componentes que os pacotes
do C++ Builder oferecem, por isso um trabalho de pesquisa é sempre necessário
para descobrir quais são os componentes mais adequados para uma determinada
finalidade e como utilizá-los.

5.1 Botões

Objetos da classe TButton. Normalmente o evento OnClick é tratado, para tomar


ações em relação ao clicar do botão

5.2 Caixas de texto

Objetos da classe TEdit.


Os eventos OnKeyPress, OnKeyDown e OnKeyUp são úteis para o tratamento do
texto da caixa, no momento da digitação. Este texto pode ser obtido através do
atributo Text; assim, na caixa de texto Text1,

Text1->Text

representa um objeto da classe AnsiString que encapsula o texto da caixa de texto.

A classe AnsiString, por sua vez, possui diversos métodos para manipulação do
texto. Por exemplo, para se obter um número inteiro escrito numa caixa de
texto Text1 pode-se utilizar o método ToInt da seguinte forma:

int x;
x = (Text1->Text).ToInt();

5.3 Label

Objetos da classe TLabel.

Um label nada mais é do que componente de texto não editável. Ele é muito
utilizado para marcar, por exemplo, a funcionalidade de uma caixa de texto.

Normalmente a propriedade Caption de um label é ajustada, para que ele exiba o


texto desejado.

6. Exercício

Implementar em C++ Builder um conversor instantâneo Celsius-Kelvin-Fahrenheit.


Uma sugestão de interface gráfica é mostrada a seguir:

A interface apresentada contém três caixas de texto, uma para inserção de graus
Celsius, outra para Kelvin e a terceira para Fahrenheit. Ao digitar-se um número
em qualquer uma das caixas, deve acontecer uma conversão instantânea para as
outras escalas e a exibição automática dos valores nas respectivas caixas de texto.

O botão “Zerar” é utilizado para zerar o valor dos graus Celsius; essa situação é
mostrada na figura, resultando em 273 K e 32 Fahrenheit.

Fórmulas para cálculo:

Fahrenheit = celsius*9/5 + 32

Kelvin = celsius+273

Caso um valor não numérico seja inserido em qualquer das caixas, este valor deve
ser mostrado em vermelho e as demais caixas devem mostrar a palavra ERRO.

Dica: para implementar esta última funcionalidade, utilizar a


exceção EConvertError. Esta exceção é lançada por qualquer dos métodos de
conversão de AnsiString (ToDouble, ToInt, etc.) quando é impossível converter o
valor da AnsiString para o tipo numérico correspondente.

Exemplo:

try {

x = (Text1->Text).ToDouble();

} catch (const EConvertError& e)

//código para tratamento da exceção

Você também pode gostar