L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
2. O C++ Builder e O IDE – Ambiente de Desenvolvimento Integrado 2.1. C++ Builder - Conhecimentos Básicos Para ser um bom programador de C++ Builder existem vários aspectos que se devem conhecer: O ambiente de desenvolvimento integrado C++ Builder (IDE). No Capítulo 2 se estuda o IDE do C++ Builder. Os objetos componentes disponíveis para criar aplicações Windows e nelas, as suas propriedades mais importantes, os métodos associados e os eventos aos que as aplicações devem responder (Capítulo 3) Um conhecimento genérico da biblioteca de classes virtuais da Borland (VCL) para conhecer as hierarquias das classes que formam parte dos objetos componentes (Capítulo 4). Os conceitos fundamentais da metodologia de programação orientada a objetos (OOP), a linguagem C++ e como esta deve ser usada no estilo do C++ Builder (Capítulo 5). Certas técnicas avançadas de programação, como por exemplo, o tratamento de exceções, a programação com threads, a construção de objetos componentes personalizados, a interação com as bases de dados, a programação de aplicações para a Internet.
No desenvolver do curso se pretende introduzir o aluno na programação de aplicações para Windows usando o C++ Builder. Ainda se supõe que esta já possua certa experiência na programação em linguagem C e conhecimento básico da programação orientada a objetos.
2.2. O IDE do C++ Builder O IDE é o ambiente integrado de desenvolvimento. O IDE3 do C++ Builder é uma aplicação Windows que proporciona um ambiente de trabalho visual para construir aplicações Windows que integra diversos aspectos da programação em um entorno unificado e integrado. A integração de funções e facilidade de utilização
3
faz
com
que
seja
uma
IDE: Integrated Development Environment
26
ferramenta
indispensável
para
o
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
desenvolvimento rápido de aplicações RAD4. O IDE do C++ Builder guarda uma grande similitude com o IDE do Visual Studio da Microsoft, no entanto existem algumas diferenças. O IDE do C++ Builder é uma aplicação Windows e como tal está de acordo com os padrões de aspecto, desenho e comportamento sugerido pela Microsoft aos desenvolvedores de aplicações. Dessa forma, qualquer um que estiver familiarizado com a utilização dos programas Windows como usuário não deverá fazer um grande esforço para usar o IDE com certa facilidade.
2.3. Uma Visão Geral do IDE do C++ Builder O ambiente de desenvolvimento está dividido em cinco partes. Uma série de janelas que podem estar visíveis ou ocultas constitui a base do C++ Builder. O aspecto da aplicação no início de uma sessão de trabalho é mostrado na Figura 2-1
Figura 2-1 - Aspecto do C++ Builder no início de uma sessão. 4
RAD: Rapid Application Development.
27
L
U
I
S
F
E
R
N
A
N
D
E
O
S
P
I
N
O
S
A
C
O
C
I
A
N
Na parte superior é colocada a janela principal que contém o menu principal, com uma barra de ferramentas à esquerda e uma paleta de objetos componentes à direita. Abaixo da janela principal e à esquerda fica o inspetor de objetos. À direita do inspetor de objetos está a área de trabalho do C++ Builder, que inicialmente mostra o editor de quadros ou “janelas” mo modo de desenho, e escondido ou oculto atrás desse, está o editor de códigos. À direita da tela normalmente escondido, fica o gerenciador de projetos. Vejamos de forma bastante geral a função de cada uma dessas partes.
2.3.1. A Janela Principal Na janela principal estão o menu principal, a barra de ferramentas e a paleta de objetos componentes, como mostra a Figura 2-2.
O MENU PRINCIPAL. O menu principal permite o acesso a todas as operações e possibilita a configuração do programa. Menu Principal
Figura 2-2 - Janela principal do C++ Builder. Barra de Ferramentas
Paleta de Componentes
A BARRA DE FERRAMENTAS Permite o acesso rápido às operações que se realizam com mais freqüência.
A PALETA DE OBJETOS COMPONENTES Agrupa os objetos componentes que se podem incluir nas aplicações.
2.3.2. O Inspetor de Objetos. O inspetor de objetos serve para alterar as propriedades dos objetos que formam a aplicação e para selecionar os eventos aos quais devem responder esses objetos.
28
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-3 - O inspetor de objetos.
2.3.3. O Editor de Quadros O editor de quadros é uma janela que usualmente aparece pontilhada sobre a qual se colocam os objetos componentes para desenhar as janelas que formarão a aplicação.
Figura 2-4 - O editor de quadros.
2.3.4. O Editor de Código O editor de código é um editor de texto multi-janela que serve para editar e ver o código da aplicação. Ele está perfeitamente integrado com o inspetor de objetos e com o editor de quadros.
29
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-5 - O editor de códigos.
Na Figura 2-5 você pode observar que à esquerda na janela do editor de código há uma área destinada a mostrar os objetos, estruturas e funções existentes no projeto. Existem outras partes do ambiente que serão comentadas à medida do decorrer deste documento. A seguir, trataremos com mais detalhes as partes comentadas anteriormente.
2.4. Um Estudo mais Detalhado do IDE do C++ Builder 2.4.1. O Menu Principal O menu é a janela principal do IDE e sempre está visível. Nela podemos encontrar todas as operações disponíveis.
Figura 2-6 - O menu principal
O menu principal tem as tarefas comuns a qualquer aplicação Windows: File, Edit, Search, Help, etc., além de outras que serão tratadas ao longo deste documento. Na barra de título da janela principal aparece o nome do aplicativo (C++ Builder) e o nome do projeto ou grupo de projetos com que se está trabalhando. O nome default do projeto é Project1 e pode ser mudado para o nome desejado.
30
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Como veremos mais adiante, o conceito de projeto é fundamental no C++ Builder porque é o mecanismo de organizar de forma coerente todos os arquivos (quadros, códigos, recursos, etc.) associados à aplicação a ser desenvolvida.
MENU FILE - ARQUIVO
Figura 2-7 - Menu File.
MENU EDIT - EDIÇÃO
Figura 2-8 - Menu Edit.
31
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
MENU SEARCH - BUSCA
Figura 2-9 - Menu Search.
MENU VIEW - VISUALIZAR
Figura 2-10 - Menu View.
32
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
MENU PROJECT - PROJETO
Figura 2-11 - Menu Project.
MENU RUN - EXECUTAR
Figura 2-12 - Menu Run.
33
I
G
I
T
A
L
I I
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
MENU COMPONENT – OBJETOS COMPONENTES
Figura 2-13 - Menu Component.
MENU DATABASE – BASE DE DADOS
Figura 2-14 - Menu Database.
MENU TOOLS - FERRAMENTAS
Figura 2-15 - Menu Tools.
MENU HELP - AJUDA
34
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-16 - Menu Help.
2.4.2. A Barra de Ferramentas A barra de ferramentas permite acelerar as operações mais comuns do menu principal. Se você se acostumar a usá-la poderá agilizar significativamente o uso do ambiente. A sua aparência habitual é mostrada na Figura 2-17.
Figura 2-17 - A barra de ferramentas.
Passando o cursor do mouse sobre os ícones aparecerão os hints com as descrições que informar sobre a funcionalidade de cada um deles. As barras de ferramentas podem ser personalizadas (assim como praticamente todas as partes do ambiente) apertando o botão direito do mouse e selecionando a opção Properties. Se você observar com atenção poderá ver que a barra de ferramentas é formada por várias barras agrupadas, tais como View, Debug, Help, etc.
2.4.3. A Paleta de objetos Componentes Os objetos componentes incluem os blocos básicos com os quais se constroem as aplicações Windows com o C++ Builder baseados na VCL5. Todos os objetos componentes (visuais e não-visuais) ficam acessíveis de forma rápida e prática graças à paleta de objetos componentes. Podemos dizer que é um grande armazém de objetos prontos para serem incorporados a uma aplicação, selecionado e colocando-os num quadro (Form). Por conveniência, todos os objetos componentes disponíveis se encontram organizados em distintas páginas ou pastas segundo a sua funcionalidade. Cada aba da paleta de objetos componentes dá acesso a um conjunto de ícones que representam os objetos componentes que se pode usar para desenhar a aplicação. O seu aspecto é mostrado na figura 2.8.
5
VCL: Virtual Component Library. – Biblioteca de componentes virtuais.
35
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-18 - A paleta de componentes.
Todos os componentes do C++ Builder se carregam no default, no entanto podem ser inseridos mais componentes usando as opções do menu “Component”. Cada componente está relacionado a uma aba e o usuário não pode escolher a localização dos componentes carregados automaticamente na paleta entretanto pode modificar a disposição das abas e acrescentar novas abas ou novos componentes nas abas já existentes (opção de menu Tools + Environment Options na aba Palette). Para colocar um componente em um quadro, deve se selecionar na paleta de componentes o ícone que o representa e a continuação deve se clicar no quadro na posição que o usuário desejar. Uma forma alternativa de selecionar o componente a ser inserido na aplicação é usando o menu View + Component List que também possui uma ferramenta de procura pelo nome. Conhecer os componentes disponíveis e a sua filosofia de trabalho (propriedades, métodos e eventos) é fundamental para um programador. No Capítulo 3 discutiremos com mais profundidade sobre os componentes disponíveis no C++ Builder e no Capítulo 4 discutiremos sobre a estrutura da VCL.
2.4.4. O Editor de Quadros Como se falou anteriormente é uma janela pontilhada que serve para desenhar as janelas (ou forms) que formarão a aplicação. É uma ferramenta visual destinada a desenhar e apresentar a interface do usuário de uma aplicação. Um quadro pode ser a janela principal de um programa, uma janela de diálogo ou qualquer outra janela.
36
E
N
G
E
N
H
A
R
I
A
D
P
E
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-19 - Editor de quadros.
Usando o mouse podem se colocar os componentes da paleta de componentes na área do quadro. O processo procede como segue: Buscar o componente desejado na paleta. 6. Selecionar o ícone do componente. 7. Clicar no quadro. Neste ponto o componente deve aparecer no quadro. 8. Mover o componente no quadro na posição desejada.
A posição de um componente sempre se ajusta ao local mais próximo da grade para facilitar o seu ajuste (alinhamento). As opções relacionadas com a grade podem ser modificadas no menu Tools + Environment Options. Dentro do quadro sempre haverá um componente ativo representado por pontos ao redor do componente. Caso nenhum componente estiver selecionado é porque a seleção está no quadro (Form). Pode se ativar qualquer componente clicando sobre o mesmo. Clicando duas vezes num componente pode permitir o acesso a configurações específicas ou a eventos do mouse dependendo do tipo de componentes. Caso isto seja feito sem querer não há problemas, simplesmente retorne ao editor de quadros e continue o seu trabalho. Por exemplo, no caso de um componente que implementa um objeto do tipo botão (TButton). Imagine que você colocou-o no seu quadro e que clicou duas vezes nele.
Este objeto
quando clicado duas vezes no quadro, gera um código para atendimento ao evento OnClick() do mouse. Se não era isso o que desejava, simplesmente volte ao editor de quadros.
O código inserido automaticamente irá desaparecer na
próxima compilação caso você não tenha inserido nada dentro da função. Nunca
37
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
tente apagar manualmente o código automático gerado pelo C++ Builder, pois isso provoca inconsistências internas e pode inutilizar o seu código. É obvio que no caso de você ter apagado sem querer há formas de consertar, no entanto isso requer de mais conhecimentos sobre os arquivos do projeto que são afetados por esse tipo de acontecimento, conhecimentos que virão com a experiência no uso do C++ Builder e que normalmente não são conhecidos pelos iniciantes.
EXERCÍCIO 1: DESENHO DE UM QUADRO 1. 2. 3.
Colocar os componentes em um quadro. Redimensionar o quadro para que fique parecida com a Figura 2-20. Criar e configurar o projeto: 3.1. Diretório: Exercício, 3.2. Unidade de código associada ao quadro (por default: - Unit1.cpp): alterar para UPrincipal.cpp ou outro nome que lhe agrade. 3.3. Projeto (por default Project1.bpr): alterar para MeuSoftware.bpr ou outro que mais lhe agrade. 4. Gerar o arquivo executável: Selecionar a opção de menu Project + Build. 5. Executar o programa: selecionar a opção do menu Run + Run. Os passos 6 e 7 podem ser simplificados num só pressionando o botão Run ( atalho <F9>.
) ou a tecla de
Figura 2-20 - Exercício 1.
Todos os componentes necessários para realizar este exemplo se encontram na aba de componentes Standard.
2.4.5. O Inspetor de Objetos O inspetor de objetos é uma das ferramentas mais úteis e atrativas do C++ Builder. A janela do inspetor de objetos possui duas abas Properties e Events como mostra a Figura 2-21.
38
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-21 – Configuração off-line de Propriedades e Eventos dos objetos.
Cada objeto componente tem associado um conjunto de propriedades, métodos e eventos aos quais pode responder. Com o inspetor de objetos podemos moldar os componentes de uma aplicação de acordo com as necessidades no que se refere à sua aparência (propriedades) e funcionalidade (eventos e funções). Em suma, podemos modificar as propriedades dos componentes e construir os gerenciadores de eventos aos que esses podem responder. Na parte superior se especifica o objeto ativo (na Figura 2-21, no caso está selecionado o quadro chamado Form1). As propriedades do objeto ativo aparecem na página na aba Properties e os eventos aos quais ele pode responder estão na aba Events. Para selecionar um objeto desde o inspetor de objetos abre-se a lista de objetos e se seleciona o objeto desejado. O objeto também pode ser selecionado a partir do editor de quadros clicando no objeto correspondente. Se o que se deseja é modificar as suas propriedades se abre a pasta clicando na aba Properties. Da mesma forma para a aba Events quando se deseja associar uma função de atendimento a um evento. Por exemplo, podemos colocar o texto “Ouvir” em um botão colocado no quadro (modificando a propriedade Caption) e escrever o
39
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
código para reproduzir um arquivo WAV ou MP3 que contém uma música (escrevendo um gerenciador para o evento OnClick() do botão).
EXERCÍCIO 2. USO DO INSPETOR DE OBJETOS PARA MODIFICAR PROPRIEDADES Alterar o quadro do quadro desenhado no exercício 1 para que apresente o aspecto
Figura 2-22 – Alteração das propriedades dos objetos do exercício 1.
As modificações devem ser realizadas usando o inspetor de objetos (aba Properties). A seguir se detalham as modificações a serem realizadas. Observar que basicamente são alteradas as propriedades Caption e/ou Name. Caption: Se refere ao título ou legenda que acompanha os componentes. Por exemplo, o texto de um botão, ou da barra do quadro. Name: Se refere ao nome com o que vai se diferenciar o objeto dentro do código do programa. Por ser um identificador (como o nome de uma variável) deve ser significativo e seguir as regras dos identificadores da linguagem C/C++. Por exemplo, para os botões o C++ Builder designa nomes tais como Button1 e Button2, entretanto convém designar nomes mais esclarecedores tais como BotOK ou BotSair.
Quando se coloca um objeto em um quadro, o C++ Builder cria um ponteiro no arquivo de cabeçalho *.h (no exemplo no arquivo UPrincipal) e graças a isso se pode acessar o objeto através do código. O C++ Builder utiliza a propriedade Name do componente para denominar o ponteiro. As modificações das propriedades a realizar neste exercício são as seguintes: Form1: o Caption = Quadro de Teste o Name = frmPrincipal Label1: o Caption = Nome
40
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
o Name = lblNome Edit1: o Text = Opções o Name = edtOp RadioButton1: o Caption = Opção 1 o Checked = true o Name = rdbtOp1 RadioButton2: o Caption = Opção 2 o Name = rdbtOp2s CheckBox1: o Caption = Ativar Opções o Checked = true o Name = chkOp Button1: o Caption = OK o Name = btOK Button2: o Caption = Sair o Name = btSair
A propriedade Caption é um objeto do tipo AnsiString que é um objeto que carrega strings. Você pode mudar as características das fontes de letra modificando a propriedade Font do objeto. A seguir, gere o arquivo executável, cujo resultado deverá ser similar ao quadro mostrado na Figura 2-23
Figura 2-23 - Quadro de teste em execução.
2.4.6. O Editor de Código O editor de código permite editar o código de uma aplicação de forma prática e rápida. Ele permite a diferenciação colorida dos comandos e de abrir simultaneamente vários arquivos.
41
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Na janela do editor de código podem ser “coladas” as janelas do Gerenciador de Projetos e do Explorador de Classes, embora que estas duas janelas possam aparecer também em janelas separadas.
Figura 2-24 – Editor de código com integração do gerenciador de projetos e inspetor de classes.
O Explorador de Classes: é um navegador que mostra as classes, objetos e métodos associados à aplicação. Aparece por default associada ao editor de código à esquerda da tela. Caso esta janela tenha desaparecido do ambiente, pode ser novamente aberta através da opção de menu View + Class Explorer.
Figura 2-25 – O explorador de classes e estruturas.
O Gerenciador de Projetos: é basicamente um navegador entre os diferentes arquivos que compõem a aplicação. Caso não esteja visível no ambiente pode ser aberto usando a opção de menu View + Project Manager.
42
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-26 - O gerenciador de projetos.
No editor de código quando pressionado o mouse no seu botão direito, aparece um menu contextual com algumas opções úteis.
Figura 2-27 - Menu contextual no editor de código.
O C++ Builder permite o acesso à totalidade do código fonte da aplicação. Por isso é importante saber quais partes desse código é mantido e atualizado automaticamente pelo sistema para evitar modificá-lo sem querer.
43
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
O editor de código está relacionado de forma bastante estreita com o Inspetor de Objetos. Ao fazer dois cliques num determinado evento, o IDE gera automaticamente o código para a função gerenciadora de tal evento. O programador não tem que se preocupar qual exatamente é o protótipo da função que se deve usar para gerenciar o evento, uma vez que ela será gerada de forma correta na unidade de código associada ao quadro atual. Quando for necessário eliminar uma função gerenciadora de evento que foi gerada automaticamente não é conveniente apagar diretamente a função no editor de código. O que se recomenda fazer é apagar todas as linhas que foram inseridas pelo programador naquela função e deixar que o C++ Builder elimine as linhas criadas por ele mesmo, o que será feito automaticamente na próxima compilação.
EXERCÍCIO 3: USO DO INSPETOR DE OBJETOS PARA ESCREVER FUNÇÕES DE GERENCIAMENTO DE EVENTOS Neste exercício deve se construir um gerenciador do evento que se gera ao fazer clique do mouse sobre o botão Sair. No apertar do botão Sair, o programa deverá encerrar a execução. Para fazer isto selecionar o objeto btSair e no Inspetor de Objetos na aba Events faça dois cliques no campo vazio ao lado de OnClick.
Figura 2-28 - O Inspetor de Objetos para gerar as funções de gerenciamento de eventos.
O editor de código mostrará o seguinte código gerado de forma automática.
44
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
void __fastcall TfrmPrincipal::btSairClick(TObject *Sender) { }
Escrever no corpo da função o seguinte código: void __fastcall TfrmPrincipal::btSairClick(TObject *Sender) { Application->Terminate(); }
Agora gere o arquivo executável e execute o programa. Você deverá observar que ao clicar no botão Sair o programa finalizará a sua execução.
2.4.7. O Gerenciador de Projetos Um projeto é um conjunto de arquivos que trabalham em conjunto para criar um arquivo executável independente ou uma biblioteca dinâmica de funções (DLL6). Um grupo de projetos é um conjunto de projetos que cooperam entre si.
Figura 2-29 - O Gerenciador de Projetos.
Os projetos que compõem um grupo de projetos e os arquivos que compõem cada um deles são apresentados na forma de árvores no Gerenciador de Projetos. Essa ferramenta pode ser usada também para selecionar o módulo com que se deseja trabalhar. Caso ele não esteja visível pode se usar a opção de menu View + Project Manager ou a tecla de atalho <CRTL+ALT+F11>. A janela do Gerenciador de Projetos pode ser anexada à janela do Editor de Código clicando e arrastando-o até esta última. A qualquer momento existe um único projeto ativo e será esse a ser executado quando se escolher a opção Run. Os arquivos do projeto especificam todos os recursos necessários (arquivos cpp, h, dfm, etc.) que se necessitam
6
DLL: Dynamic Link Library – Biblioteca de conexão dinâmica.
45
L
U
I
F
S
E
R
N
A
N
D
O
E
S
P
I
N
O
S
C
A
O
C
I
A
N
para a construção do arquivo executável. Os arquivos de projeto têm a extensão bpr e o executável gerado tem o mesmo nome do projeto com a extensão exe. Todo projeto em C++ Builder está composto de pelo menos um arquivo de código que contém a função principal (WinMain() ou main()). O nome do arquivo que a contém é o próprio nome do projeto com a extensão cpp (no caso deste exemplo é MeuSoftware3.cpp). Este arquivo não está sempre visível porque não é necessária a sua modificação freqüente. Qualquer aplicação típica Windows terá pelo menos uma janela. Para cada janela ou quadro (neste exemplo frmPrincipal) haverá uma unidade de código cpp e o correspondente arquivo de cabeçalho h. Na unidade de código cpp estarão os gerenciadores de eventos associados aos demais objetos desse quadro e nos arquivos de cabeçalho estarão as declarações dos objetos componentes do quadro. Além do arquivo que contém a função principal, um projeto pode ter associados uma série de módulos adicionais nos quais podem se incluir funções e classes de objetos como em qualquer aplicação C++. Cada um desses módulos está formado por uma dupla de arquivos, um cpp e o seu correspondente h. A um grupo de projetos pode se adicionar novos projetos, arquivos, quadros, e novos módulos de código. Em suma, o gerenciador de arquivos é que organiza todos os arquivos que formam parte dos projetos. Ver a seguir uma descrição da função dos arquivos que podem estar relacionados para a montagem de um projeto. Tabela 2-1 Extensão
Descrição
bpr
É o arquivo “makefile” do projeto. Define o que e como compilar.
cpp
Arquivos de código fonte em linguagem C++.
c
Arquivos de código fonte em linguagem C.
h
Arquivos de cabeçalho em linguagem C ou C++.
obj
Arquivos objeto resultantes da compilação e prontos para o linker.
exe
É o programa executável resultante do linker.
tds
São arquivos temporários que armazenam as tabelas de símbolos para depuração. Pode ser apagado após a depuração.
dfm
São os arquivos com as descrições dos quadros. Contém os valores das propriedades de cada objeto componente7.
res
É um arquivo de recursos. Contém ícones, tabelas de strings, bitmaps e outros.
dsk
Contém informações sobre a configuração das opções de trabalho e edição do ambiente de
7 Embora esteja em formato binário, pode ser visualizado como texto selecionando a opção View as Text no menu contextual que aparece ao clicar com o botão direito do mouse quando estiver apontando para o quadro.
46
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
programação para um determinado projeto. bpg
É o arquivo de grupo de projetos. Armazena quais projetos fazem parte do grupo.
hpp
São arquivos de cabeçalho gerados automaticamente pelo C++ Builder.
2.5. O Sistema de Ajuda O sistema de ajuda é uma das ferramentas mais úteis no trabalho da programação com o C++ Builder especialmente a documentação dos objetos componentes e das classes pré-definidas. Saber programar com o C++ Builder não significa dominar todos e cada um dos aspectos do ambiente de desenvolvimento, senão em conhecer os princípios nos quais ele se baseia sendo que os detalhes concretos serão buscados no Help quando necessário. Os arquivos de ajuda são no padrão Windows e podem ser acessados diretamente com a tecla <F1>. O sistema de Ajuda é contextual, i.e., ela é sensível ao contexto (janela ativa) e a posição do cursor. Você pode fazer um teste colocando o cursor no exercício 3, deixe o cursor piscante acima da palavra “Application->...” e aperte a tecla <F1>. O resultado é mostrado na Figura 2-30 onde aparece uma lista de arquivos de ajuda relacionados com o tópico procurado. A mesma mecânica se aplica às opções de menu e a maioria dos elementos da área de trabalho.
47
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-30 – Ajuda detalhada para a variável Application.
O C++ Builder proporciona alguma facilidades úteis na hora de escrever o código. As mais importantes são: Completar Código: ao escrever o nome de um objeto seguido pelo operador de acesso “ponto” (nome_da_classe.) ou no caso de um ponteiro para o objeto, na hora
de
escrever o seu nome
seguido
do
operador “seta”
(nome_do_ponteiro->) aparece a lista de propriedades, métodos e eventos relacionados com a classe desse objeto, e pode ser visto na Figura 2-31.
Figura 2-31 – Recurso de Completar Código relacionados à classe TApplication.
Padrões de Código: usando a combinação de teclas <CTRL+J> tem-se acesso a trechos padronizados de código também chamados de “esqueletos”. Esses esqueletos podem ser usados para inserir códigos que são repetitivos. Novos padrões podem ser criados e armazenados configurando a opção de menu Tools + Editor Options na aba Code Insight. Por default vem programados esqueletos para rotinas while, for, struct, class e variações.
48
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-32 - Esqueletos de código com <CTRL+J>.
2.6. Compilação, Execução e Depuração de Programas O objetivo final da programação é a geração de um programa executável ou de uma biblioteca dinâmica de funções que funcionem com o sistema Windows®. O programa executável se constrói tomando como referência os arquivos que formam o projeto ativo. Para esta tarefa podem se utilizar as opções de menu Project e Run.
49
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-33 - Submenus Project e Run.
A compilação trata da obtenção de arquivos objeto (em código de máquina com a extensão *.obj) que depois do linker (opções Make ou Build) servirão para a construção do arquivo executável. Essas opções e outras podem ser acessadas no menu Project sendo as importantes descritas a seguir. Compile Unit: compila a unidade de código ativa (extensão c ou cpp) gerando um arquivo objeto com extensão obj. Make: gera o arquivo executável a partir dos arquivos objeto associados ao projeto, compilando os arquivos fonte de código que tenham sido modificados e que ainda não foram recompilados. Build: gera o arquivo executável a partir dos arquivos objeto associados ao projeto recompilando todos os arquivos fonte de código, mesmo os que não se modificaram após a última compilação. Os erros de sintaxe e incoerências lógicas que venham aparecer serão mostrados na janela Messages que geralmente ocupa um espaço reservado abaixo das linhas de código. Clicando diretamente nos erros mostrados o Editor de Código altera para a linha correspondente do código fonte onde foi encontrado o erro, o que facilita de sobremaneira a tarefa de correção.
50
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-34 – Janela Messages.
No caso em que não se entenda a mensagem de erro, pode se obter uma descrição mais detalhada selecionado o erro correspondente e apertando a tecla de ajuda <F1>.
Figura 2-35 – Descrição do erro relacionado com a Figura 2-34.
Para executar o programa diretamente basta com clicar no botão Run (tecla de atalho <F9>) da barra de ferramentas, que invocará a função Make para os arquivos de códigos que foram alterados após a última compilação, e construindo um novo executável. No caso em que exista um arquivo executável e nenhum dos arquivos fontes de código tenham sido alterados, simplesmente executará o programa.
51
L
U
I
F
S
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
O C++ Builder proporciona facilidades para a depuração de programas através do menu Run, sendo as mais usadas: Step Over (<F8>): executa o programa passo-a-passo executando as chamadas de função como instruções de um único passo. Trace Into (<F7>): executa o programa passo-a-passo “entrando” nas funções e executando o seu código correspondente passo-a-passo. Run to Cursor (<F4>): executa o programa até a linha em se coloca o cursor. Para permitir uma depuração mais completa e versátil estão incorporadas as seguintes opções: Evaluate/Modify
<CTRL+F7>:
permite
avaliar
expressões
que
se
relacionem com variáveis assim como modificar diretamente as mesmas. Add Watch <CTRL+F5>: permite observar constantemente os valores de variáveis definidas pelo usuário. Add Breakpoint: coloca um ponto de interrupção da execução do código na linha em que foi colocado o cursor. É provavelmente a ferramenta mais útil na depuração dos programas. Uma forma alternativa de colocar breakpoints no código é clicando na barra cinza que fica à esquerda da janela de edição de códigos. Os breakpoints são sinalizados por uma barra vermelha na linha de código. Quando o programa for executado e tiver parado na linha de breakpoint, aparecerá uma seta verde do lado da bola vermelha. Os pontos de parada ou breakpoints são usados para examinar as variáveis referentes ao trecho de código a ser depurado com o objetivo de procurar por erros lógicos e matemáticos.
52
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Figura 2-36 - Breakpoints.
2.7. O Armazém de Objetos O Armazém de Objetos (Object Repository) contém quadros de diálogo, objetos ActiveX, módulos de dados e assistentes. Esses objetos podem ser usados diretamente copiando-os diretamente no seu projeto ou herdando itens de objetos existentes. Todos esses estão pré-desenhados e podem servir como ponto de partida para os seus próprios projetos. Além dos elementos já existentes, outros podem ser adicionados. É acessado através da opção de menu File + New.
Figura 2-37 – O Armazém de Objetos.
Um dos objetos usados com mais freqüência é o objeto Application que serve para criar novos projetos visuais; Console Wizard para criar aplicações de console; Form para adicionar um novo quadro e Unit para adicionar uma nova unidade de código.
53
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
2.7.1. Exemplo de Aplicação Simples de Console Uma aplicação de console pode ser útil em aplicações em que não se precise usar objetos da VCL. O aspecto de uma aplicação desse tipo é o gerado pelos compiladores tradicionais que lembram as aplicações antigas do MS-DOS. Os aplicativos de console são menores e mais rápidos que as aplicações visuais e podem ser úteis para determinados tipos de programas que não requerem de apresentações bonitas na tela ou para poder testar algoritmos de forma rápida e eficiente, antes de inseri-los numa aplicação visual. Se você for um dos programadores em linguagem C, que usava o Turbo C, ou o Borland C++ da época DOS, certamente se achará confortável. Uma aplicação de console pode ser criada usando a opção File + New + Console Wizard onde aparecerá um assistente que permitirá definir as opções de geração do projeto.
Figura 2-38 – Assistente para a criação de um programa de console.
Clicando na tecla OK, o assistente gerará o seguinte código:
Figura 2-39 - Código gerado pelo assistente.
54
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Observar que no Editor de Código não aparecem as linhas necessárias para a inclusão das definições dos objetos da VCL e a função principal é main() e não WinMain() como acontece nas aplicações visuais. Altere o código automático para aparecer como segue: //--------------------------------------------------------------------------#include <vcl.h> #pragma hdrstop #include <condefs.h> #include <iostream.h> #include <conio.h> //--------------------------------------------------------------------------#pragma argsused int main(int argc, char* argv[]){ for (int i=0; i<5; i++){ cout << "Valor de i = " << i << endl; } getch(); return 0; } //---------------------------------------------------------------------------
Antes de executar o programa salve o seu projeto usando a opção de menu File + Save Project As com os nomes Console1.cpp e Console1.bpr, ou outro nome que mais lhe agrade. Depois disso, execute o programa com o ícone Run. O resultado é mostrado na Figura 2-40.
Figura 2-40 - Resultado da aplicação de console.
2.7.2. Exemplos de Aplicações Visuais Simples No C++ Builder podem ser construídas aplicações visuais simples (usando a VCL) sem a necessidade do Editor de Quadros. A seguir são colocados alguns exemplos.
EXEMPLO 1: O MENOR PROGRAMA VISUAL Este exemplo mostra um programa que emite uma janela de mensagem para o usuário. O primeiro passo é criar uma aplicação usando a opção de menu File + New Application. Antes de mais nada, salve o novo projeto numa nova
55
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
pasta no local adequado usando a opção File + Save Project As... (por exemplo, Mensagem.bpr). Como a aplicação é simples (sem quadro) deve se apagar o quadro que foi gerado por default (usualmente Unit1 formado pela dupla de arquivos: Unit1.cpp + Form1.frm). Isto pode ser feito de duas maneiras: a primeira é deixar o quadro ativo e usar a opção de menu Project + Remove from Project.... Outra maneira é usando o Gerenciador de Projetos selecionando Unit1 e apertando a tecla <DEL> ou clicando com o botão direito do mouse para acessar o menu contextual selecionando a opção Remove from Project....
Figura 2-41 - Removendo um quadro da aplicação.
Depois de confirmar a exclusão se eliminam os dois arquivos do projeto que compõem o quadro. A seguir ative o Editor de Código com o arquivo fonte Mensagem.cpp e altere o código aí existente para o que segue. //--------------------------------------------------------------------------#include <vcl.h> //--------------------------------------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { ShowMessage ("E daí Tchê!? Como estás?"); return 0; } //---------------------------------------------------------------------------
Para testar, execute o programa usando a opção Run. O resultado da execução deverá ser parecido com o seguinte:
Figura 2-42 - Resultado do programa visual mais simples.
56
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
EXEMPLO 2: MENSAGENS MÚLTIPLAS Este exemplo mostra várias mensagens sendo mostradas de forma seqüencial. Proceda com um novo projeto e armazene-o numa nova pasta. Da mesma forma do exemplo anterior, remova o quadro e altere o programa automático para parecer com o que segue: //----------------------------------------------------------#include <vcl.h> //----------------------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { for (int i=0 ;i<5 ;i++){ ShowMessage ("Valor de i = " + AnsiString(i)); } return 0; } //-----------------------------------------------------------
O resultado da execução para cada iteração será como mostra a Figura 2-43. Para passar para a próxima iteração deve se clicar no botão OK. Primeira iteração
Segunda iteração
......
Quinta iteração
. . . . . .
Figura 2-43 – Resultado da execução do programa de mensagens múltiplas.
EXEMPLO 3: VÁRIAS STRINGS EM UMA ÚNICA JANELA Neste exemplo se cria uma string pela soma de várias substrings e se mostra o resultado final na janela de mensagem. Para criar o projeto proceda como nos casos anteriores, criando uma nova aplicação, salvando o projeto, apagando os arquivos relacionados com o quadro e alterando o código para o que segue. Nomeie o projeto como “AnsiString.bpr”. Neste exemplo se cria um vetor dinâmico de cinco valores inteiros e se mostra o seu conteúdo numa única janela de mensagem. //----------------------------------------------------------#include <vcl.h> //----------------------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){ int *vetor; AnsiString cadeia = ""; vetor = new int[5]; for (int i=0; i<5; i++) { vetor[i] = i*2; cadeia = cadeia + "vetor[" + AnsiString (i) + "] = " + AnsiString (vetor[i]) + "\n"; }
57
L
U
I
S
F
E
R
N
A
N
D
E
O
S
P
I
N
O
S
A
C
O
C
I
A
N
ShowMessage (cadeia); delete []vetor; return 0; } //-----------------------------------------------------------
A execução do programa deverá apresentar o seguinte resultado:
Figura 2-44 – Resultado do terceiro exemplo.
2.8. Estrutura e Configuração de um projeto 2.8.1. Estrutura habitual de um projeto escrito em C++ Uma aplicação escrita na linguagem C++ é composta de um módulo que contém a função main() e opcionalmente de uma série de módulos adicionais que podem conter declarações de classes, funções (protótipos), etc. Para a criação de um arquivo executável se requer de: Um arquivo makefile no qual se especifica a dependência entre os diferentes módulos e a forma em que se geram os arquivos objeto, bibliotecas e o programa executável final. 9. Executar o programa make para que se interprete o arquivo makefile e se proceda com as instruções apropriadas para a criação do executável de acordo com os dados especificados no arquivo makefile.
ARQUIVOS DE UM PROJETO EM C++ BUILDER No C++ Builder a gerência dos projetos se realiza de forma automática e o usuário não precisa construir o arquivo makefile nem executar o programa make para obter o executável. O IDE se encarrega de fazer tudo isso. Para isso estrutura todos os arquivos associados a uma aplicação em um projeto. Pode se dizer que o arquivo de projeto é um arquivo makefile. A extensão desses arquivos é *.bpr (Borland Project).
58
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
Como exemplo crie uma nova aplicação usando a opção de menu File + New Application.
Usando a opção de menu File + Save Project as..., o IDE
solicitará salvar primeiro o arquivo *.cpp, Unit1.cpp em alguma pasta. Crie uma nova pasta no local que achar conveniente e salve esse arquivo com o nome de UPrincipal.cpp. Esta ação irá alterar o nome default Unit1.cpp, Unit1.h e Unit1.dfm para UPrincipal.cpp, UPrincipal.h e UPrincipal.dfm.
Figura 2-45 – Salvando o arquivo *.cpp da unidade de código do quadro gerado automaticamente.
A seguir o sistema solicitará o nome para armazenar o arquivo de projeto. Usar o nome Inicial.bpr.
Figura 2-46 – Salvando o arquivo *.bpr das configurações do projeto.
O resultado dessas escolhas criará os seguintes arquivos dentro da pasta selecionada:
59
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-47 – Arquivos de um projeto simples C++ Builder.
Os arquivos que compõem um projeto podem ser visualizados usando o Gerenciador de Projetos.
Figura 2-48 - Arquivos no Gerenciador de Projetos. Figura 2-49 - Usando o Gerenciador de Projetos para visualizar os arquivos componentes.
Em todos os projetos existe um arquivo que contém a função principal. Nas aplicações que fazem uso da VCL a função main () se chama WinMain () e está num arquivo cujo nome coincide com o nome do projeto. Em geral não é necessário modificar esse arquivo. //-------------------------------------------------------------------------#include <vcl.h> #pragma hdrstop USERES("Inicial.res"); USEFORM("UPrincipal.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; } //--------------------------------------------------------------------------
60
E
N
G
E
N
H
A
R
I
A
D
E
P
R
O
C
E
S
S
A
M
E
N
T
O
D
I
G
I
T
A
L
I I
No caso deste exemplo, a função WinMain() estará no arquiv Inicial.cpp. Em geral qualquer aplicação terá pelo menos um quadro e para cada quadro haverá três módulos casados: Um módulo com a extensão *.cpp com o código associado ao quadro correspondente que contém os gerenciadores de eventos relacionados; no caso UPrincipal.cpp. 10. Um arquivo de cabeçalho com extensão *.h que contém as declarações dos objetos e variáveis que compõem esse quadro; no caso UPrincipal.h. 11. Um arquivo binário com as descrições dos atributos e preferências escolhidas pelo programador para o quadro; no caso UPrincipal.dfm.
COMO CONFIGURAR UM PROJETO EM C++ BUILDER? O primeiro conselho é que cada aplicação deve estar em um diretório (pasta) próprio onde serão armazenados todos os arquivos relacionados com a aplicação. Tente não usar a mesma pasta para armazenar mais de um projeto. Isto normalmente aumenta o potencial de erros no gerenciamento automático dos arquivos. No Gerenciador de Projetos da Figura 2-48 pode observar que embora o arquivo do quadro se chame UPrincipal.dfm, o nome do quadro permanece como Form1. No Editor de Quadros deixe ativo o quadro Form1 e altere as propriedades Name (“Form1”) para “FPrincipal” e Caption para “Janela Principal”, usando o Inspetor de Objetos.
Figura 2-50 - Alteração do nome e da barra de título do quadro.
Para dar o nome à nova aplicação e definir um ícone diferente do padrão deve se utilizar a opção de menu Project + Option na aba Application selecione o nome desejado para a aplicação e o ícone.
61
L
U
I
S
F
E
R
N
A
N
D
O
E
S
P
I
N
O
S
A
C
O
C
I
A
N
Figura 2-51 – Configuração do nome da aplicação e escolha do ícone.
O resultado da escolhas fica como mostrado na Figura 2-52. Observar que o novo ícone aparece na janela durante a execução. O novo nome escolhido para a aplicação aparecerá na barra de programas como mostra a Figura 2-53.
Figura 2-52 - Resultado da alteração do nome da aplicação e do ícone.
Figura 2-53 – O novo nome da aplicação aparece na barra de programas.
62