Apostila CBUILDER

Puc - Campinas
Informática para Engenharia
Borland C++ Builder

Professor: José Marcelo Traina Chacon
Prof° José Marcelo Traina Chacon

Sumário
Introdução 01
Iniciando C++ Builder 02
Acessando comandos rapidamente 04
Criando uma Aplicação 05
Adicionando Componentes 07
Formulários 09
Rótulos 17
Caixa de Texto 20
Botão de Comando 23
Botões de opção 26
Caixa de verificação 26
Caixa de Lista 27
Caixa Combinada 30
Barra de rolagem 34
Barra de menu 38
PopupMenu 41
Imagem 43
Formas 47
Caixa de lista de arquivos, lista de diretórios e Combinada de Drivers 49
Temporizador 53
Caixa de Dialogo Comum 57
Painel 59
Itens Fundamentais 63
Operadores 68
Estruturas Condicionais 73
Estruturas de Repetição 79
Funções 84
Matrizes 86
Estruturas 93
Arquivos 97
Bibliografia 102
Bonus – Banco de Dados 103
Puc - Campinas
Introdução
Introdução
O C++ Builder da Borland é um ambiente visual, orientado a objetos que tem por
finalidade desenvolver aplicações rapidamente para o Windows 95/98/NT. Estas
aplicações podem ser de propósitos gerais ou cliente/servidor. Usando o C++ Builder,
você pode criar eficientes aplicações Windows com o mínimo de codificação manual.
O Borland C++ Builder disponibiliza uma extensa biblioteca de componentes

reutilizáveis e um ambiente de ferramentas RAD (Desenvolvimento de Aplicações
Rápida).
Quando você inicia o Borland C++ Builder, você é imediatamente colocado com o
ambiente de programação visual. É com este ambiente que o Borland C++ Builder
disponibiliza todas as ferramentas que você necessita para criar, desenvolver, testar,
e debugar suas aplicações.
Prof° José Marcelo Traina Chacon 1

Iniciando C++ Builder
Iniciando C++ Builder
A melhor maneira se aprender é rodando o Borland C++ Builder. Você poderá rodar o
BCB da mesma maneira que roda qualquer aplicação Windows, como segue abaixo:
Dando um duplo-clique no ícone C++ Builder
Usando o Windows Explorer. Localize e de um duplo-clique no arquivo BCB.EXE
Escolha Executar a partir do menu Iniciar, e especifique o path para o BCB.EXE
Selecionando a opção do menu
A figura abaixo mostra como o BCB irá aparecer quando for rodado pela primeira vez:
Menu
Principal
Barra de
Ferramentas
Paleta de
Componentes
Object
Inspector
Formulário
Editor de
Código
Puc - Campinas
O C++ Builder ambiente de desenvolvimento (também chamado de IDE), tem várias

partes flexíveis que você poderá coloca-las em qualquer local da tela. A janela
principal contem o menu principal, barra de ferramentas e a paleta de componentes.
O Object Inspector, Editor de Código e o formulário são automaticamente
apresentados. Quando você estiver trabalhando, você poderá redimensionar cada
parte e mostrar ferramentas adicionais conforme a sua necessidade.

Acessando comandos
rapidamente
Acessando comandos rapidamente
O menu principal no topo da janela principal, disponibiliza acesso a vários comandos

e ferramentas do Borland C++ Builder. Você pode também ver uma barra de
ferramentas no cantos esquerdo, embaixo do menu principal. Ela contem botões que
podem ajuda-lo quando estiver trabalhando. Cada botão executa uma operação ou
comando ( Abrir Arquivo, Salvar Projeto, Rodar, entre outras). A figura abaixo ilustra a
barra de ferramentas e mostra a função de alguns botões.
Abrir Salvar Salvar Abrir Adicionar Arquivo

Unit Unit Tudo Projeto para Projeto
Novo
Projeto Remover Arquivo
do Projeto
Ajuda
Ver Unit
Ver Alterar Novo Pausa

Formulário entre Unit e Rodar
Formulário
Formulário
Clique com o botão direito do mouse na barra de ferramentas e escolha

propriedades, você poderá personaliza-la de acordo com as suas necessidades.
Puc - Campinas
Criando uma Aplicação
Criando uma Aplicação
O Borland C++ Builder imediatamente apresenta as ferramentas necessárias para

que você inicie a criação da aplicação.
• Uma janela em branco, conhecida como formulário, na qual você criará a interface
do usuário
• Uma extensiva biblioteca, chamada de componentes
• Uma maneira fácil de alterar as propriedades de um objeto, utilizando o Object
Inspector
• Acesso direto ao código do programa utilizando o Editor de Código
Formulário
Componentes

Objeto Inspector
Editor de Códigos
Você pode usar o Borland C++ Builder para criar aplicações de 32-bits de qualquer
tipo. Desde aplicações de propósitos gerais, até sofisticados programas de acesso a
banco de dados.
Puc - Campinas
Adicionando Componentes
Adicionando Componentes
Componentes são elementos que você usa para construir suas aplicações Borland
C++ Builder. Eles incluem todas as partes visíveis de sua aplicação tais como, box de
dialogo e botões; bem como as partes não visíveis enquanto a aplicação estiver
rodando, como os Timers.
Componentes e suas páginas associadas
Muitos componentes visuais são disponibilizados no ambiente de desenvolvimento na

paleta de componentes. Você seleciona o componentes da paleta e arasta-o no
formulário que você esta desenvolvendo. Uma vez que o componentes esteja no
formulário você poderá ajustar as sua propriedades como, posição, tamanho entre
outras.
O Borland C++ Builder agrupa os componentes, em diferentes página, de acordo com

a sua funcionalidade.
Formulários e componentes tem muitos pontos em comum; você pode imaginar que
um formulário e um objeto que pode conter outros componentes.
O Borland C++ Builder inclui vários componentes que você pode usar na VCL
(Biblioteca de Componentes Visual). Verifique o Help VCL Reference para mais
detalhes dos componentes disponíveis. Você pode personalizar a biblioteca de

componentes adicionando ou removendo componentes, ou ainda escrever seus
próprios componentes.
Alterando o comportamento do componente
Você pode facilmente personalizar a aparência e o comportamento de sua aplicação

usando o Object Inspector. Quando um componente tem o foco no formulário, suas
propriedades e eventos são mostrados no Object Inspector.
Usando a página Propriedades do Object Inspector, você ajustará

os valores iniciais, dos componentes, com o qual sua aplicação irá
iniciar. Você usará a página Eventos para navegar através dos
eventos que o componente pode ter.
Dando um clique em um evento em particular, o Borland C++

Builder irá gerar o código para este evento ( event handler). Você
apenas deverá completar o código de acordo com a ação
desejada.
Puc - Campinas
Formulários
Formulários (Forms) são objetos especializados no qual você coloca componentes

VCL (Biblioteca de Componente Visual). Forms geralmente se parecem como janelas
e caixas de diálogo em uma aplicação que esta rodando. Você interage com o forms
lendo e fixando suas propriedades, chamando os métodos e respondendo aos seus
eventos.
Segue uma lista das principais propriedades de um formulário.
Propriedades – Características de um componente
Align – Alinhamento do formulário
• alBotton – Alinha na parte inferior da área gráfica
• alClient – Alinha em toda a área gráfica
• alLeft – Alinha na parte esquerda da área gráfica

• alNone – Sem alinhamento
• alRight – Alinha na parte direita da área gráfica
• alTop – Alinha na parte superior da área gráfica
BorderIcons – Determina qual botão irá aparecer na barra de título
• biSystemMenu – Botão Fechar

• biMinimize – Botão Minimizar
• biMaximize – Botão Maximizar
• biHelp – Botão Ajuda
biMinimize biSystemMenu
biHelp biMaximize
Puc - Campinas
BorderStyle – Estilo da Borda, dependem do BorderIcons
• bsDialog – Somente fechar e Help
• bsNone – Sem borda
• bsSingle – Borda Simples
• bsSizeable – Borda Normal
• vsSizeTollWin – Somente Botão Fechar
• bsToolWin – Somente Botão Fechar

BorderWidt – Determina um tamanho para a borda na janela onde não poderão ser
inseridos componentes
Caption – Texto que será mostrado na barra de titulo do formulário
Color – Cor do funda do formulário
Enable – Ativar e Desativar formulário. Quando esta desativado, ele fica visível, mas
não responde a eventos até ser ativado.
• true – ativa o formulário
• false – desativa o formulário
Puc - Campinas
Height – Altura do formulário em pontos

Width – Largura do formulário em pontos
Width
536
Heigth
218
Icon – Escolhe uma icone para o programa

Editor de Imagens – Ferramenta que desenha imagens e icones para o C++ Builder.
Funciona como um editor de imagens do Windows e salva como arquivo *.ico
1° Passo – Criar um novo arquivo de ícones.
2° Passo – Desenhar uma nova ícone.
3° Passo – Salvar o novo arquivo de ícone.
Left – Distância da Esquerda

Top – Distância do Topo
Top
Left
Name – Nome do formulário no programa. O name atribuído ao formulário principal
Puc - Campinas
será utilizado pelo programa para a definição do nome do programa executável a ser
criado.
Position – Determina a posição que aparecerá o formulário na tela.

• PoDesigned – Não determinada posição na tela
Name
• PoScreenCenter – Centro da tela
poScreenCente poDesigned
r
Visible – Determina se o formulário irá ficar visível ou invisível.

• true – visível
• false – invisível
true false
WindowState – Determina em que modo de exibição a tela será mostrada.

• WsMaximized – Tela Maximizada
• WsMinimized – Tela Minimizada
• WsNormal – Tela Normal (Restaurada)

wsMaximized wsMinimized wsNormal
Eventos – Ações de um componente
OnClick – Usuário dá um clique sobre o componente formulário.
OnDblClick – Usuário dá um duplo clique sobre o componente formulário.
OnCreat – Evento automático que é executado quando o formulário é executado.
Métodos – Ações que alteram o componente
Close – Fecha o formulário.
Hide – Oculta um formulário. Este método altera a propriedade visible do formulário

para false.
Show – Mostra um formulário. Este método altera a propriedade visible do formulário

para true.
ShowModal – Mostra um formulário como uma caixa de diálogo modal. Os outros

formulários ficam inacessíveis, até que o formulário atual seja fechado.
Puc - Campinas
Rótulo
Rótulos (Label) são objetos no qual você pode apresentar uma informação textual.
A grande parte das propriedades para o objeto rótulo é comum as propriedades

explicadas no objeto form.
Segue uma lista das principais propriedades de um rótulo.
Alignment – Alinhamento de um texto
• taCenter – Alinhamento centralizado
• taLeftJustify – Alinhamento à esquerda
• taRightJustify – Alinhamento à direita

AutoSize – Tamanho automático para o rótulo
• true - rótulo é automaticamente redimensionado
• false - rótulo mantém as dimensões do projeto, se o texto for longo, ele será
truncado
Caption – Define o texto que será escrito na tela.
Font – Define características de padrão de letra do texto que será escrito na tela.
ShowHint – Ativa um texto que aparecerá quando o mouse for colocado sobre o
componente.
• true – aparecera o texto
• false – não aparecera o texto
Puc - Campinas
Hint – Texto que aparecerá quando o mouse for colocado sobre o componente.
OnClick – Usuário dá um clique sobre o componente rótulo.
OnDblClick – Usuário dá um duplo clique sobre o componente rótulo.
Hide – Oculta um rótulo. Este método altera a propriedade visible do rótulo para false.
Show – Mostra um rótulo. Este método altera a propriedade visible do rótulo para
true.
Exemplo de um projeto com rótulo
Programa Hello World!

Caixa de Texto
Caixa de Texto (Edit) são objetos no qual você pode introduzir informação textual.
Podemos compará-lo a um comando de entrada.
A grande parte das propriedades para o objeto caixa de texto é comum as

propriedades explicadas anteriormente.
Segue uma lista das principais propriedades de um caixa de texto.
BorderStyle – Define o estilo da borda da caixa de texto

• bsSingle – Borda simples
• bsNone – Sem Borda
bsSingle bsNon
CharCase – Define o tipo de caracteres para a caixa de texto.

• ecLowerCase – Letras minúsculas
• ecNormal – Letras minúsculas e maiúsculas
• ecUpperCase – Letras maiúsculas
ecLowerCas ecNormal ecUpperCas

Puc - Campinas
Enabled – Ativa ou desativa uma caixa de texto.

• true – Habilita uma caixa de texto
• false – Desabilita uma caixa de texto – não aceitará digitação de valores e
aparecerá levemente acinzentado
true false
MaxLength – Limita o número de caracteres a ser digitado
Name – Define o nome da caixa de texto no programa
PasswordChar – Campo Senha - Define o caracter a ser mostrado
Text – Texto que será exibido na caixa de textos

OnChance – Ao alterar a caixa de texto
OnEnter– Ao teclar ENTER na caixa de texto
OnExit – Ao sair da caixa de texto
OnKeyPress – Ao pressionar uma tecla na caixa de texto
SetFocus – Fixa o foco do cursor no objeto escolhido

Puc - Campinas
Botões de Comando
Botões de Comando (Button) são componentes geralmente usados em programas

para disparar um processo quando acionados pelo clique do mouse.
A grande parte das propriedades para o objeto Botão de comando é comum as

Segue uma lista das principais propriedades de um Botão de comando.
Cancel – Permite que a tecla ESC tenha a mesma função do clique do mouse
• true - a tecla ESC terá o mesmo efeito de um clique do mouse
• false – desativa a função da tecla ESC para o botão
ESC ou
Clicar
Default – Permite que a tecla ENTER tenha a mesma função do clique do mouse
• true - a tecla ENTER terá o mesmo efeito de um clique do mouse
• false – desativa a função da tecla ENTER para o botão
ENTER ou
Clicar

Name – Define o nome do botão no programa
OnClick – Usuário dá um clique sobre o componente botões de comando.
Focused – Este método retorna o valor true se o objeto estiver em foco, caso
contrário retorna false.
Programa Temperatura
Eventos do programa temperatura:
OnClick no botão Converter
OnClick no botão Sair
OnCreat no Formulário FrmTemp

Puc - Campinas
//--------------------------------------------------------------------
void __fastcall TForm1::BtnConvClick(TObject *Sender)
{
//Declaração de Variáveis
int tcel, tkel, tfah;
AnsiString entrada;
//Faz a leitura da temp. Celsius

entrada = EdtCel->Text;
//Converte de Texto para Int
tcel = StrToInt(entrada);
//Calcula as temperaturas
tkel = tcel + 273;
tfah = (((tcel*9)/5)+32);
//Mostra na tela os valores calculados

EdtKel->Text = tkel;
EdtFah->Text = tfah;
}
//--------------------------------------------------------------------
void __fastcall TForm1::BtnFimClick(TObject *Sender)
{
//Fecha o programa
Close();
}
//--------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
//Inicializa as temperaturas
BtnConvClick (Owner);
}
//--------------------------------------------------------------------
Conversões de tipo
Classe AnsiString
String para Int
• StrToInt
Monetário para String
• CurrToStr
Float para String
• FloatToStr
Inteiro para representação hexadecimal
• IntToHex

Botões de Opção e
Caixas de verificação
Botões de Opção (RadioButton) – são componentes que são apresentam ao usuário

em grupo para a escolha de apenas uma opção. As opções não escolhidas ficam
desabilitadas.
Caixa de Verificação (CheckBox) – são componentes que são apresentam ao

usuário em grupo para a escolha de uma ou mais opções.
A grande parte das propriedades para os objetos Botão de opção e Caixa de

verificação é comum as propriedades explicadas anteriormente.
Segue uma lista das principais propriedades de um Botão de opção e Caixa de

verificação.
Checked – Indica se o componente está ou não selecionado.

• true – indica selecionado
• false – indica não selecionado
false true false true

OnClick – Usuário dá um clique sobre os componentes botões de opção e caixas de

verificação.
Puc - Campinas
Caixas de listas
Caixa de Lista (ListBox) – são componentes que dão ao usuário a opção de

escolhas, esta escolhas são feitas através do mouse.
A grande parte das propriedades para o objeto Caixa de Lista é comum as

Segue uma lista das principais propriedades de um Caixa de Lista.
• Columns – Indica a quantidade de colunas que a caixa de lista irá ter. Utilizando
o valor padrão 0 a caixa de lista terá apenas uma coluna.
Columns = 0 Columns = 3
• Items – Define uma lista inicial de opções na caixa de lista.

• ExtendedSelect – Define se o usuário pode selecionar uma seqüência de itens
da caixa ListBox,
• true permite seleção seqüêncial
• false não permite seleção seqüêncial
• MultiSelect – Permite ao usuário selecionar múltiplos itens

• true permite seleção de múltiplos itens
• false não permite seleção de múltiplos itens
Permite Permite Permite Permite várias

uma várias uma seleções c/ CTRL
seleção seleções seleções e SHIFT
• Sorted – Apresenta os itens em ordem alfabética

• true - apresenta em ordem alfabética
• false - apresenta na ordem editada no Itens
false true
• TabStop – Indica se o controle pode ser acessado usando a tecla TAB

• true - pode acessar utilizando o TAB
• false - não pode acessar utilizando o TAB
• TabWidth – Define o tamanho do caractere de tabulação em um a caixa de lista.

• 0 - padrão definido pelo Windows

Puc - Campinas
OnClick – Usuário dá um clique sobre o componente caixa de lista.
OnDblClick – Usuário dá um duplo clique sobre o componente caixa de lista.
• Clear - Apaga as informações contidas na caixa de lista.

Caixa Combinada
Caixa combinada (ComboBox) – são componentes que dão ao usuário a opção de

escolhas, esta escolhas são feitas através do mouse. Combina caixa de texto com
Caixa de lista
A grande parte das propriedades para o objeto Caixa Combinada é comum as

Segue uma lista das principais propriedades de um Caixa Combinada.
• Style – Determina o tipo de caixa combinada e seu comportamento
csDropDown
csDropDownList
csOwnerDrawFixed
• csSimple
csOwnerDrawVariable
Puc - Campinas
• Text – Irá conter o texto digitado pelo usuário. Depende do Style escolhido pelo
usuário.
csDropDown
csSimple
OnChance – Ao alterar a caixa combinada
• Clear - Apaga as informações contidas na caixa combinada.
Programa Lista de Usuários
Eventos do programa lista de usuários:

OnClick no botão Sair
OnCreat no Formulário FrmUsuários
OnClick no botão Adicionar
OnClick no botão Remover
OnChange no EdtUsuarios
void __fastcall TFrmUsuarios::BtnSairClick(TObject *Sender)

{
/*-------------------------------------------
Termina o Programa e descarrega o formulário
-------------------------------------------*/
//Mensagem de Finalização
Application->MessageBox ("Finalizando o Programa...",
"Lista de Usuários 1.00",MB_OK);
//Beep
MessageBeep(0);
//Termina o programa
Close();
}
//--------------------------------------------------------------------
void __fastcall TFrmUsuarios::FormCreate(TObject *Sender)

{
/*-------------------------------------------
Inicialização do Programa
-------------------------------------------*/
//Limpa Lista
LstUsuarios->Clear();
//Limpa caixa de texto
EdtUsuarios->Text="";
//Desabilita o Botão Adicionar
BtnAdicionar->Enabled = false;
}
//--------------------------------------------------------------------
void __fastcall TFrmUsuarios::BtnAdicionarClick(TObject *Sender)
{
/*-------------------------------------------
Adicionar Usuário
-------------------------------------------*/
//Verifica o tipo de Usuário
if (OptMaster->Checked) EdtUsuarios->Text =
EdtUsuarios->Text + " M";
else EdtUsuarios->Text = EdtUsuarios->Text + " N";
//Adiciona o nome da Caixa de Texto
LstUsuarios->Items->Add (EdtUsuarios->Text);
EdtUsuarios->Text="";
}
//--------------------------------------------------------------------
void __fastcall TFrmUsuarios::BtnRemoverClick(TObject *Sender)

{
/*------------------
Puc - Campinas
Remove Usuários
------------------*/
int num;
//Verifica o valor corrente da Caixa de Lista
num=LstUsuarios->ItemIndex;
//Remove o Usuário se existir
if (num!=1)
LstUsuarios->Items->Delete (num);
}
//--------------------------------------------------------------------
void __fastcall TFrmUsuarios::EdtUsuariosChange(TObject *Sender)

{
if(EdtUsuarios->Text!="")
BtnAdicionar->Enabled=true;
else
BtnAdicionar->Enabled=false;
}
//--------------------------------------------------------------------

Barra de rolagem
Barra de rolagem (ScroolBar) – são componentes que dão ao usuário a opção de

construir barras de rolagem na horizontal e na vertical.
A grande parte das propriedades para o objeto Barra de rolagem é comum as

Segue uma lista das principais propriedades de um Barra de rolagem.
• Kind – Define o tipo de barra de rolagem

• sbHorizontal – Barra de rolagem na horizontal
• sbVertical – Barra de rolagem na vertical
sbHorizontal
sbVertical
Puc - Campinas
• LargeChange - Incremento ou decremento da propriedade Position quando clica

sobre o curso da barra de rolagem
Clicar sobre o
10 curso
• Max - Valor máximo para o deslocamento de uma barra de rolagem
Valor máximo 1000
• Min - Valor mínimo para o deslocamento de uma barra de rolagem
Valor mínimo
• Position – Representa o valor corrente do deslocamento do cursor na barra de

rolagem
Posição atual 100
Posição atual 0

• SmallChance - Representa o incremento ou decremento ao clicar nos botões de
deslocamento
Clicar sobre o botão

de deslocamento
1
OnScroll – Ao deslocar a barra de rolagem
OnChance – Ao alterar a barra de rolagem
Programa Temperatura
Puc - Campinas
Eventos do programa Controle de Temperatura
OnChange no ScrollBar1
//--------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UnitControleTemp.h"
//--------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//--------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------
void __fastcall TForm1::ScrollBar1Change(TObject *Sender)

{
int num;
num=275-ScrollBar1->Position;
Edit1->Text= IntToStr(num)+" ºC";
ProgressBar1->Position=num;
if(num==-25)
{
LblMinimo->Visible=true;
}
else
{
LblMinimo->Visible=false;
}
if(num==300)
{
LblMaximo->Visible=true;
}
else
{
LblMaximo->Visible=false;
}
}
//--------------------------------------------------------------------

Barra de menu
Barra de menu (MainMenu) – são componentes que dão ao usuário a opção de

construir uma barra de menu principal no topo da tela.
A grande parte das propriedades para o objeto Barra de menu é comum as

Segue uma lista das principais propriedades de um Barra de menu.
• Items – Define os campos da barra de menu. A propriedade items será utilizada

para a construção da barra de menus.
Ao clicar sobre o botão de reticências na propriedade items será aberta uma janela de
construção de menus.
Para inserir uma opção no menu digite um texto no local selecionado na janela de
construção de menus. As setas de movimentações ajudarão na escolha do local a ser
criada a opção do menu.
Para se criar um submenu apertar a tecla CTRL mais a seta para a direita ou utilizar o
popupmenu da janela de construção de menus (Creat Submenu).
Puc - Campinas
OnClick– Ao clicar sobre uma opção da barra de menu
Programa Barra de Menu
Passos:
1. Inicia um novo Aplicativo – Menu File – New Aplication;
2. Insira um componente MainMenu;
3. Clique no botão reticências da propriedade Items;
4. Crie o menu do projeto abaixo.
Objeto Propriedade Valor

Form1 Caption Aplicativo Menu
Name FrmAplicativo
MainMenu1 Name MnuAplicativo
Menu Arquivo
Item Propriedade Valor
Arquivo Caption &Arquivo
Name MnuArq
Novo Caption &Novo
Name MnuArqNovo
Abri Caption &Abrir
Name MnuArqAbrir
Separador Caption -
Name MnuArqSep1
Salvar Caption &Salvar
Name MnuArqSalvar
Salvar Como Caption Salvar &Como
Name MnuArqSalvarComo
Separador Caption -
Name MnuArqSep2
Impressora Caption &Impressora
Name MnuArqImp
Configurar Caption &Configurar
Name MnuArqImpCfg Submenu
Imprimir Caption &Imprimir
Name MnuArqImpPrn
Separador Caption -
Name MnuArqSep3
Sair Caption Sa&ir
Name MnuArqSair

Menu Editar
Editar Caption &Editar
Name MnuEdt
Copiar Caption &Copiar
Name MnuEdtCopiar
Colar Caption C&olar
Name MnuEdtColar
Separador Caption -
Name MnuEdtSep1
Selecionar Caption &Selecionar
Name MnuEdtSelecionar
Menu Ajuda
Ajuda Caption A&juda
Name MnuAju
Conteúdo Caption &Conteúdo e Indice
Name MnuAjuConteudo
Separador Caption -
Name MnuAjuSep1
Sobre Caption &Sobre o aplicativo
Name MnuAjuSobre
Puc - Campinas
PopupMenu
PopupMenu – são componentes que dão ao usuário a opção de construir uma barra
de menu que aparecerá quando clicar com o botão direito do mouse sobre um objeto
assoado ao popupmenu.
A grande parte das propriedades para o objeto popupmenu é comum as propriedades

explicadas anteriormente.
Segue uma lista das principais propriedades de um PopupMenu.
• Alignment – Define o alinhamento do PopupMenu em relação a posição do

ponteiro do mouse.
• paCenter – Centralizando coma posição do cursor do mouse.
• paLeft – à esquerda da posição do cursor do mouse.
• paRight – à direita da posição do cursor do mouse.

• AutoPopup – Define se o PopupMenu irá aparecer automaticamente ao clicar
botão direito do mouse sobre o componente.
• true – Aparecerá automaticamente
• false – Não aparecerá automaticamente.
Puc - Campinas
Imagem
Imagem (Image) – são componentes que permitem ao usuário inserir no programa

uma imagem gráfica.
A grande parte das propriedades para o objeto Imagem é comum as propriedades

Segue uma lista das principais propriedades de um Imagem.
• AutoSize – Define que o tamanho do desenho inserido será ajustado

automaticamente
• true – Ajuste automático de tamanho do desenho.
• false – Não possui ajuste automático de tamanho do desenho.

• Center – Define que o desenho inserido centralizado.
• true – Centralização automática do desenho.
• false – Não centraliza automaticamente desenho.
• Picture – Clicar sobre a reticências para abrir o Editor de Imagens
Clicar no Load e escolher a figura desejada e clicar no abrir.
Será carregada a figura escolhida no Editor de Imagens

Puc - Campinas
Clicar no botão OK
• Stretch – Ajusta o tamanho da figura não tamanho estabelecido para a imagem.

O tamanho da imagem escolhida é forçada a se adequar ao tamanho do
componente Image.
• true – Imagem adequada ao tamanho do componente image.
• false – Imagem não adequada ao tamanho do componente image.
• Transparent – Define se o fundo da imagem irá ficar transparente sobrepondo a

outros objetos
• true – Imagem transparente sobrepondo a outros objetos.

• false – Imagem não transparente .
OnClick – Usuário dá um clique sobre o componente imagem.
OnDblClick – Usuário dá um duplo clique sobre o componente imagem.
Refresh – Força o redesenho de uma imagem. A sua utilização é em conjunto com o

método Repaint
Repaint – Força que a imagem apresentada seja redesenhada.

Puc - Campinas
Formas
Formas (Shape) – são componentes que permitem ao usuário inserir no programa

formas geométrica como retângulos, círculos, elipses, etc.

Segue uma lista das principais propriedades de uma Forma.
• Brush – Define propriedades de preenchimento do desenho
• Color – Defini a cor de preenchimento.

• Style – Define o estilo de preenchimento.
• Pen – Define o contorno da figura geométrica.

• Color – Defini a cor do contorno da figura.
• Style – Define o estilo da linha de contorno da figura.
• Width – Define a espessura da linha de contorno da figura.

• Shape – Define a forma da figura geométrica.
OnMouseMove – Ao mover o mouse.
OnMouseDown – Ao apertar o botão do mouse.
OnMouseUp – Ao soltar o botão do mouse.

Puc - Campinas
Lista de Arquivos,
Drivers e Diretórios
Drivers (DriveComboBox) – são componentes que permitem ao usuário selecionar

através de uma caixa combinada um driver a ser trabalhado.
Diretório (DiretoryListBox) – são componentes que permitem ao usuário visualizar

uma lista de diretórios e selecionar diretórios desta lista.
Arquivo (FileListBox) – são componentes que permitem ao usuário visualizar uma

lista de arquivos e selecionar arquivos desta lista.

Segue uma lista das principais propriedades destes objetos.
• DirList – Conecta o driver escolhido no DriveComboBox a Lista de Diretórios do

DirectoryListBox.

• TextCase – Determina se o texto será mostrado com letras maiúsculas ou
minúsculas.
tcLowerCase tcUpperCase
• DirLabel – Quando associado a um nome de rótulo (Label), qualquer seleção no

objeto diretório se reflete na propriedade caption do objeto rótulo.
• FileList – Conecta o diretório escolhido no FileListBox a Lista de Arquivos do

FileListBox.
• FileEdit – Conecta o arquivo escolhido no FileListBox a Caixa de Texto.
• FileType – Define quais arquivos serão mostrados através de seus atributos.

• ftReadOnly –serão mostrados arquivos de Leitura
• ftHidden –serão mostrados arquivos ocultos
• ftNormal – serão mostrados arquivos normais
Puc - Campinas
• Mask – Define quais os tipos de arquivos serão mostrados através da

determinação de sua extensão.
• ShowGlyphs – Define se as ícones serão mostradas ao lado do nome do
arquivo.
false true
OnClick – Usuário dá um clique sobre os componentes listados.
OnDblClick – Usuário dá um duplo clique sobre os componentes listados.
OnMouseMove – Ao mover o mouse sobre os componentes listados.
OnKeyPress – Ao pressionar uma tecla sobre os componentes listados.

Programa Mostra Imagem
//--------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//--------------------------------------------------------------------
TFrmTemp *FrmTemp;
//--------------------------------------------------------------------
__fastcall TFrmTemp::TFrmTemp(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------
void __fastcall TFrmTemp::FileListBox1Click(TObject *Sender)
{
//Nome do Arquivo
AnsiString nome;
//Mostra nome
nome=FileListBox1->FileName;
//Carrega o Arquivo
ImgMostrar->Picture->LoadFromFile(nome);
}
//--------------------------------------------------------------------
void __fastcall TFrmTemp::DirectoryListBox1Change(TObject *Sender)
{
//Atualiza a Lista de Arquivos
FileListBox1->Directory=DirectoryListBox1->Directory;
}
//--------------------------------------------------------------------
Puc - Campinas
Temporizador
Temporizador (Timer) – são componentes que permitem executar uma tarefa em

intervalos de tempo pré determinados.
O intervalo de tempo no temporizador é contado em milissegundos.
Interval – Tempo entre um disparo e outro.
OnTimer – Seqüência de comandos a ser realizados no intervalo de tempo

determinado no temporizados
uma tecla sobre os componentes listados.
Programa Animação

Puc - Campinas
//--------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UnitAnimacao.h"
//--------------------------------------------------------------------
TForm1 *Form1;
// Declaração de variável
int seta=1;
char sentido='H';
//--------------------------------------------------------------------
: TFor(Owner)
{
}
//--------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)

{
if (sentido=='H')
{
switch(seta)
{
case 1 : Image1->Visible=true;
Image2->Visible=false;
break;
case 2 : Image1->Visible=false;
Image2->Visible=true;
break;
break;
}
seta++;
if (seta >3)
seta=1;
}
else
{
switch(seta)
{
break;

break;
break;
} // fim switch case
seta++;
if (seta>3)
seta=1;
}
}
//--------------------------------------------------------------------
void __fastcall TForm1::ScrollBar1Scroll(TObject *Sender,
TScrollCode ScrollCode, int &ScrollPos)
{
Timer1->Interval=1001-ScrollBar1->Position;
ProgressBar1->Position=ScrollBar1->Position;
}
//--------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
sentido='H';
seta=1;
}
//--------------------------------------------------------------------
{
sentido='A';
seta=4;
}
//--------------------------------------------------------------------
{
Timer1->Interval=0;
ScrollBar1->Position=0;
ProgressBar1->Position=0;
}
//--------------------------------------------------------------------
{
Close();
}
//--------------------------------------------------------------------
Puc - Campinas
Caixas de Diálogo Comuns
Caixas de Diálogo Comuns (Dialogs) – são componentes que permitem abrir caixas
de diálogos comuns do windows.
Substituir
Localizar
Configurar Impressora
Imprimir
Cores
Fontes
Salvar Imagem
Abrir Imagem
Salvar como...
Abrir
Programa Fontes e Cores

//--------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UnitFontesCores.h"
//--------------------------------------------------------------------
TFrmFonCor *FrmFonCor;
//--------------------------------------------------------------------
__fastcall TFrmFonCor::TFrmFonCor(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------
void __fastcall TFrmFonCor::BtnFonteClick(TObject *Sender)
{
//Carrega a caixa de diálogo fonte
if(DlgFonte->Execute())
{
LblMens->Font=DlgFonte->Font;
}
}
//--------------------------------------------------------------------
void __fastcall TFrmFonCor::BtnCorClick(TObject *Sender)
{
//Carrega a caixa de diálogo cor
if(DlgCor->Execute())
{
LblMens->Color=DlgCor->Color;
}
}
//--------------------------------------------------------------------
void __fastcall TFrmFonCor::BtnSairClick(TObject *Sender)
{
if(MessageDlg("Deseja mesmo terminar?",mtConfirmation,
TMsgDlgButtons()<<mbYes << mbNo, 0)==mrYes)
Close(); // termina o programa
}
//--------------------------------------------------------------------
Puc - Campinas
Painel
Painel (Panel) – são componentes que permitem ao usuário criar guias visuais na
criação de painéis de controle.
Segue uma lista das principais propriedades de um Painel.
• BevelInner – Define estilo de efeito tridimensional interno do painel
• BevelOuter – Define estilo de efeito tridimensional exterior do painel
• BevelWidth – Define a espessura do efeito tridimensional do painel

Programa Ordena Números
Puc - Campinas
//--------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UnitOrdena.h"
//--------------------------------------------------------------------
TFrmNum *FrmNum;
//--------------------------------------------------------------------
__fastcall TFrmNum::TFrmNum(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------
void __fastcall TFrmNum::BtnCresClick(TObject *Sender)
{
//Declaração de matriz 5x1
int matnum[5];
int matcres[5];
int i,j,posmat;
//Leitura dos números
matnum[0]=StrToInt(EdtNum1->Text);
//Coloca em ordem crescente
for (i=0;i<5;i++)
{
//inicializa o contador de posições
posmat=0;
for(j=0;j<5;j++)
{
/*Compara todos os elemento
e calcula a posição na matriz resultado*/
if(matnum[i]>matnum[j])
posmat++;
}
//Armazena o elemento corrente na nova posição
calculada
matcres[posmat]=matnum[i];
}
//Mostra o resultado
PnlNum1->Caption = matcres[0];
}
//--------------------------------------------------------------------
void __fastcall TFrmNum::BtnDecClick(TObject *Sender)
{
//Declaração de matriz 5x1
int matnum[5];

int matdec[5];
int i,j,posmat;
//Leitura dos números
//Coloca em ordem crescente
for (i=0;i<5;i++)
{
//inicializa o contador de posições
posmat=0;
for(j=0;j<5;j++)
{
/*Compara todos os elemento
e calcula a posição na matriz resultado*/
if(matnum[i]<matnum[j])
posmat++;
}
//Armazena o elemento corrente na nova posição
calculada
matdec[posmat]=matnum[i];
}
//Mostra o resultado
PnlNum1->Caption = matdec[0];
}
//--------------------------------------------------------------------
void __fastcall TFrmNum::BtnSairClick(TObject *Sender)
{
if(Application->MessageBox("Tem certeza que deseja finalizar o
aplicativo?","Aplicativo Números",MB_OKCANCEL)==IDOK)
Close();
}
//--------------------------------------------------------------------
void __fastcall TFrmNum::FormShow(TObject *Sender)
{
EdtNum1->SetFocus();
}
//--------------------------------------------------------------------
Puc - Campinas
Itens Fundamentais
Tipos de Dados
O ambiente de programação C++ Builder trabalha com vários tipos de dados que
podem ser manipulados pelo programa.
Os tipos de dados que podemos trabalhar estarão listados a seguir:
Tipos de Dados Inteiros:

Os tipos de dados inteiros são números, positivos ou negativos, excluindo qualquer
número fracionário.
TIPO FAIXA
int -32768 .. 32767
long int -2147483648 a 2147483647
unsigned int 0 a 65535
unsigned long int 0 a 4294967295
Tipos de Dados Reais:

Os tipos de dados reais são números, positivos ou negativos, incluindo números
fracionários.
TIPO FAIXA
float -3.4x1038 a 3.4x1038
double -3.4x10308 a 3.4x10308
Tipos de Dados Caracteres:

Os tipos de dados caracteres são seqüência contendo letras, números e símbolos
especiais. São
TIPO FAIXA
AnsiString Equivale a 231 caracteres
WideString Equivale a 230 caracteres

Tipos de Dados Lógicos:
Os tipos de dados lógicos são representados pelas palavras true para verdadeiro e
false para falso.
Variáveis
Variáveis são informações que serão armazenadas na memória do computador e

poderão sofrer alterações durante a execução do programa.
Para criar uma variável é necessário fazer a declaração de variável.
Declaração de variáveis
A declaração de variável é feita em qualquer parte da função seguindo a seguinte

forma:
<tipo> <nome das variáveis>;
Exemplo;
int A;
float B
AnsiString nome;
O nome das variáveis em C++ podem ter até 32 caracteres, sendo que as letras
maiúsculas e minúsculas são diferentes.
Comentários
Os comentários são utilizados para documentar o programa fonte, mas não fazem
parte do mesmo na compilação, pois serão substituído por espaços em branco.
Os comentários poderão ser feitos em qualquer parte do programa.

Puc - Campinas
Os comentários são feitos através dos símbolos // se o comentário for de uma linha
e através dos símbolos /* */ se for para um trecho do programa.
Ex:
/* Programa elaborado por Professional Computer */

// linha de comentário
Aplicação com Tipo de Dado Caractere
O exemplo a seguir concatena o nome e sobrenome de uma pessoa
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
Label3->Caption = Edit1->Text + " " + Edit2->Text;
}
//-------------------------------------------------------------------- ------

{
Edit1->Text = "";
Edit2->Text = "";
Label3->Caption = "";
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------

Aplicação com Tipo de Dado Inteiro
O exemplo a seguir soma os valores de dois números inteiros.
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
int A, B, R;
A = StrToInt(Edit1->Text);
B = StrToInt(Edit2->Text);
R = A + B;
Label1->Caption = IntToStr(R);
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Aplicação com Tipo de Dado Real
O exemplo a seguir faz calculo de salário liquido utilizando números reais.
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
float HT, VH, PD, TD, SB, SL;
AnsiString FORMATO;
HT = StrToFloat(EditHT->Text);
VH = StrToFloat(EditVH->Text);
PD = StrToFloat(EditPD->Text);
SB = HT * VH;
TD = SB * (PD/100);
SL = SB - TD;
FORMATO = FormatFloat("#,##0.00;(#,##0.00);ZERADO", SL);
Label4->Caption = FORMATO;
}
//-------------------------------------------------------------------- ------

Operadores
Operador de atribuição =
O operador de atribuição representado pelo sinal de igual é utilizado para atribuir um

valor a uma variável.
Ex:
int x;
x = 3;
ou
int x = 3;
Operadores aritméticos (+,-,*,/,%)
As expressões aritméticas são escritas linearmente, seguindo as seguintes

restrições:
a) o sinal de multiplicação é o asterisco (*)
b) a divisão é indicada com a barra (/)
c) o módulo de uma divisão é representado por (%)
d) Os parênteses são usados para quebrar as prioridades entre os operadores
Ex:
A +B *4
17 % 3 (Retorna 2, pois o resto da divisão de 17 por 3 é 2)
A * B * (C + (A + 5))
Puc - Campinas
Operadores de incremento (++)
O operador de incremento soma 1 a variável.
O operador pode ser pré-fixado ou pós fixado.
Operadores de decremento (--)
O operador de decremento subtrai 1 da variável.
O operador pode ser pré-fixado ou pós fixado.
Operadores Aritméticos de Atribuição
Os operadores aritméticos são:
+= , -= , *= , /= , %=
Estes operadores eqüivalem a:
i += 2; equivale i = i + 2;
i -= 2; equivale i = i - 2;
i *= 2; equivale i = i * 2;
i /= 2; equivale i = i / 2;
i %= 2; equivale i = i % 2;

Operadores Relacionais
Uma relação é a comparação realizada entre dois valores do mesmo tipo.
A natureza da operação é indicada por um operador relacional que pode ser:
OPERADOR RESULTADO
== igual a
!= diferente de
<= menor ou igual a
< menor que
> maior que
>= maior ou igual a
O resultado da relação será um valor lógico (0 ou 1).
Ex.: A != B
C>B
A <= C
Operadores Lógicos
Os operadores lógicos são descritos em tabela abaixo:
OPERADOR RESULTADO
&& conjunção
|| disjunção
! negação
Puc - Campinas
Tabelas:
&& || !
0 0 0 0 0 0 0 1
0 1 0 0 1 1 1 0
1 0 0 1 0 1
1 1 1 1 1 1
Ex.: P && Q
A || B !C

Precedência entre operadores
A tabela representa a precedência entre os vários tipos de operadores. Para quebrar

estas precedências é utilizado os parênteses.
Operador Tipos
- Sinal de menos unário
++ Incremento
-- Decremento
! Não Lógico
* Multiplicação
/ Divisão
% Módulo
+ Adição
- Subtração
< Menor que
<= Menor ou igual a
> Maior
>= Maior ou igual a
== Igual a
!= Diferente de
&& E lógico
|| Ou lógico
?: Condicional
= Atribuição
*= Aritmético de Atribuição (vezes)
/= Aritmético de Atribuição (divide)
%= Aritmético de Atribuição (módulo)
+= Aritmético de Atribuição (soma)
-= Aritmético de Atribuição (menos)

Puc - Campinas
Estruturas Condicionais
Estruturas Condicionais
A estrutura condicional faz com que uns grupos de ações sejam realizados quando
uma determinada condição é satisfeita.
As estruturas condicionais podem ser divididas em três partes:

• Estrutura condicional simples
• Estrutura condicional composta
• Comando seletivo
Estrutura Condicional Simples
Executa uma seqüência de comandos se a condição for verdadeira.
A estrutura condicional simples é representada por:
if (Expressão teste)
Instrução;
ou
{
Instrução;
:
Instrução N;
}

Exemplo:
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
int X, A, B;
A = StrToInt(Edit1->Text);
B = StrToInt(Edit2->Text);
if (A > B)
{
X = A;
A = B;
B = X;
}
Label3->Caption = IntToStr(A);
Label4->Caption = IntToStr(B);
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Estrutura Condicional Composta
Executa uma seqüência de comandos se a condição for verdadeira, e outra seqüência de comandos se for
falsa, e é representado por:
Instrução;
else
Instrução;
ou
{
Instrução;
:
Instrução N;
}
else
{
Instrução;
:
Instrução N;
}
Exemplo:

//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
float A, B, C;
A = StrToFloat(Edit1->Text);
B = StrToFloat(Edit2->Text);
C = StrToFloat(Edit3->Text);
if (A<B+C && B<A+C && C<A+B)
if (A==B && B==C)
ShowMessage("Triângulo Equilátero");
else
if (A==B || A==C || C==B)
ShowMessage("Triângulo Isósceles");
else
ShowMessage("Triângulo Escaleno");
else
ShowMessage("Os valores fornecidos não formam um triângulo");
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Comandos Seletivos
O comando switch é um seletor de opções, executando apenas a opção que for

igual à expressão.
A forma geral do comando switch é:
switch (variável ou constante)

{
case constante1:
Instrução;
:
Instrução N;
break;
case constante2:
Instrução;
Puc - Campinas
:
Instrução N;
break;
case constante3:
Instrução;
:
Instrução N;
break;
default:
Instrução;
:
Instrução N;
}
Exemplo:
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
int MES;
MES = StrToInt(Edit1->Text);
switch (MES)
{
case 1 : Edit2->Text = "Janeiro"; break;
case 2 : Edit2->Text = "Fevereiro"; break;
case 3 : Edit2->Text = "Março"; break;
case 4 : Edit2->Text = "Abril"; break;

case 5 : Edit2->Text = "Maio"; break;
case 6 : Edit2->Text = "Junho"; break;
case 7 : Edit2->Text = "Julho"; break;
case 8 : Edit2->Text = "Agosto"; break;
case 9 : Edit2->Text = "Setembro"; break;
case 10 : Edit2->Text = "Outubro"; break;
case 11 : Edit2->Text = "Novembro"; break;
case 12 : Edit2->Text = "Dezembro"; break;
default : Edit2->Text = "Mês inválido"; break;
}
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Estruturas de Repetição
Estrutura de Repetição
A estrutura de repetição permite que uma seqüência de comandos seja executada

repetidamente, até que, uma determinada condição de interrupção seja satisfeita.
Existem três formas de interrupção que são:
1. Interrupção automática
2. Interrupção no início
3. Interrupção no final
Estrutura de Repetição com Interrupção Automática
Executa um número determinado de vezes a seqüência de comandos estabelecida na repetição. É

representado por:
for( i = 0 ; i < 20 ; i++)
Inicialização Enquanto Incremento
for ( i = 0 ; i < 20 ; i++)

{
Instrução;
:
Instrução N;
}
Para a variável ser decrementada utilizamos o operador de decremento. É representado por:
for ( i = 30 ; i > 0 ; i--)

{
Instrução;
:
Instrução N;
}

Exemplo:
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
int N, I, R;
AnsiString N1, I1, R1;
ListBox1->Items->Clear();
N = StrToInt(Edit1->Text);
for (I = 1; I <= 10; I++)
{
R = N * I;
N1 = StrToInt(N);
I1 = StrToInt(I);
R1 = StrToInt(R);
ListBox1->Items->Add(N1 + " X " + I1 + " = " + R1);
}
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Estrutura de Repetição com Interrupção no Início
A condição de interrupção é testada no início, antes da seqüência de comandos, e se a condição não for
satisfeita não realizará a seqüência de comandos. É representada por:
while (Expressão de teste)

{
Instrução 1;
Instrução 2;
:
Instrução n;
}
Exemplo:
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------

: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{
int N, I, R;
I = 1;
while (I <= 10)
{
R = N * I;
N1 = IntToStr(N);
I1 = IntToStr(I);
R1 = IntToStr(R);
I++;
}
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Estrutura de Repetição com Interrupção no Final
A condição de interrupção é testada após a execução da seqüência de comandos, e executará pelo menos
uma vez esta seqüência de comandos. É representada por:
do
{
Instrução;
:
Instrução N;
} while (teste);
Puc - Campinas
Exemplo:
//-------------------------------------------------------------------- -----
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- -----
TForm1 *Form1;
//-------------------------------------------------------------------- -----
: TForm(Owner)
{
}
//-------------------------------------------------------------------- -----

{
int N, I, R;
I = 1;
do
{
R = N * I;
N1 = StrToInt(N);
I1 = StrToInt(I);
R1 = StrToInt(R);
I++;
}
while (I <= 10);
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ----

Funções
A função é um conjunto de tarefas que desejamos realizar.
Devemos escrever funções para quebrarmos o programa em subprogramas que

executem tarefas simples e com baixa complexidade.
Devem-se escrever funções para tarefas que repitam várias vezes no programa.
A estrutura básica de um programa em C++ são as funções. O programa em C++ é

constituído de uma ou mais funções.
Forma geral das funções
tipo nome ( tipo )
instrução_1;
instrução_2;
: :
instrução_N
onde:
tipo define que tipo de variável é recebida ou enviada pela função.
instrução instruções utilizadas para compor o programa

{ marca o início da função
} marca o final da função

Puc - Campinas
Exemplo de Funções
A estrutura básica das funções em C++ são apresentadas abaixo:
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
int Fatorial(int N)
{
int I, FAT;
FAT = 1;
for (I = 1; I <= N; I ++)
FAT *= I;
Form1->Label2->Caption = IntToStr(FAT);
return(0);
}
{
int N;
Fatorial(N);
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------

Matrizes
Matrizes correspondem a conjuntos de elementos de um mesmo tipo, onde todos são
igualmente acessíveis, isto quer dizer que o tempo e tipo de procedimento para
acessar qualquer um dos elementos é identificado pelo nome da matriz seguido de
um ou mais índices que define sua posição na matriz. Podem ser dos tipos
unidimensional ou multidimensional.
Podemos montar uma matriz de caracteres para armazenarmos uma frase.
Matriz Unidimensional
A criação de variáveis compostas unidimensionais é feita através da seguinte

declaração:
int notas [5];
char letras [6];
Para entendermos melhor a definição de matrizes , podemos imaginar a seguinte

situação: temos que armazenar dados de uma empresa por meses, e para isto
poderíamos ter 12 variáveis diferentes que poderiam por sua vez, estar em locais
diferentes de memória.
Int mes01, mes02, mes03,

mes04, mes05, mes06,
mes07, mes08, mes09,
mes10, mes11, mes12 ;
ou ainda, estar em uma área contínua, permitindo um acesso um pouco mais

facilitado, aliás a grande vantagem de se ter uma matriz está justamente no fato de
se poder criar algoritmos, que facilitam a lógica de alguns programas:
int meses [12];

Puc - Campinas
a referência a um dos elementos de uma matriz é feita, de acordo com o

deslocamento de endereço, partindo do primeiro elemento, mais o tamanho em bytes
de cada elemento, multiplicado pela posição menos 1. Se na matriz meses acima
descrita, quisermos nos referir ao mês de maio, basta que coloquemos o valor 5
como índice:
meses[5] = expressão;
Ex: Dado um conjunto de 8 notas, armazená-las em uma variável nota, determinando

sua média.
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

{

float MD[8];
float SOMA = 0, MEDIA;
int I;
AnsiString FORMATO;
MD[0] = StrToFloat(Edit1->Text);
for (I = 0; I <= 7; I++)
SOMA = SOMA + MD[I];
MEDIA = SOMA / 8;
FORMATO = FormatFloat("0.00", MEDIA);
Label3->Caption = FORMATO;
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
Matriz Multidimensional
São as variáveis que utilizam mais que um índice para a definição da posição de seus
elementos.
A dimensão da matriz em computação é conceituada diferente da matemática.
Um vetor em matemática pode possuir n dimensões, enquanto em computação ele

possui apenas uma dimensão.
A declaração da matriz multidimensional é feita:

int notas [5][4]; // [5] => número do aluno, [4] => número da classe.
Puc - Campinas
Ex: Programa de matriz multidimensional.
//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
int A[4][5], B[4][5];
TForm1 *Form1;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
void Limpa()
{
Form1->Edit1->Text = "";

Form1->Edit1->SetFocus();
return;
}
//-------------------------------------------------------------------- ------
void Entrada()
{
A[0][0] = StrToInt(Form1->Edit1->Text);
}
//-------------------------------------------------------------------- ------
void Saida()
{
Form1->Edit21->Text = IntToStr(B[0][0]);
}
Puc - Campinas
//-------------------------------------------------------------------- ------
{
Limpa();
}
//-------------------------------------------------------------------- ------
{
int NUMERO, RESPOSTA, I, J;
Entrada();
for (I = 0; I <= 3; I++)
for (J = 0; J <= 4; J++)
{
NUMERO = A[I][J];
RESPOSTA = NUMERO * NUMERO;
B[I][J] = RESPOSTA;
}
Saida();
}
//-------------------------------------------------------------------- ------
{
int NUMERO, RESPOSTA, I, J;
Entrada();
for (I = 0; I <= 3; I++)
for (J = 0; J <= 4; J++)
{
NUMERO = A[I][J];
RESPOSTA = NUMERO * NUMERO * NUMERO;
B[I][J] = RESPOSTA;
}
Saida();
}
//-------------------------------------------------------------------- ------
{
int RESPOSTA, I, J;
Entrada();
for (I = 0; I <= 3; I++)
for (J = 0; J <= 4; J++)
{
RESPOSTA = A[I][J];
if (RESPOSTA % 2 == 0)
B[I][J] = RESPOSTA;
else
B[I][J] = 0;
}
Saida();
}
//-------------------------------------------------------------------- ------
{
int RESPOSTA, I, J;
Entrada();
for (I = 0; I <= 3; I++)
for (J = 0; J <= 4; J++)
{
RESPOSTA = A[I][J];
if (RESPOSTA % 2 != 0)
B[I][J] = RESPOSTA;
else
B[I][J] = 0;
}
Saida();
}
//-------------------------------------------------------------------- ------
{
int SOMAT, LIMITE, I, J, K;
Entrada();
for (I = 0; I <= 3; I++)

for (J = 0; J <= 4; J++)
{
SOMAT = 0;
LIMITE = A[I][J];
for (K = 1; K <= LIMITE; K++)
SOMAT += K;
B[I][J] = SOMAT;
}
Saida();
}
//-------------------------------------------------------------------- ------
{
int FAT, LIMITE, I, J, K;
Entrada();
for (I = 0; I <= 3; I++)
for (J = 0; J <= 4; J++)
{
FAT = 1;
LIMITE = A[I][J];
for (K = 1; K <= LIMITE; K++)
FAT *= K;
B[I][J] = FAT;
}
Saida();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Estruturas
Estrutura é um grupo de informações relativas a uma mesma entidade. Estas
informações podem ter características diferentes, como em cadastro onde temos o
nome, endereço, telefone, etc.
struct
A declaração de uma struct permite-nos a definir um estrutura.
struct registro
{
int num;
char nome[40];
char end[30];
char fone [15];
};
Após a declaração da estrutura deve-se declarar variáveis que conterão esta

estrutura.
registro clientes;
registro alunos[30];
Ex:

//-------------------------------------------------------------------- ------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
//-------------------------------------------------------------------- ------
struct CadAluno
{
AnsiString NOME;
float NOTA[4];
float MEDIA;
};
struct CadAluno ALUNO[8];

int I;
//-------------------------------------------------------------------- ------

: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
void LimpaTela()
{
Form1->Label7->Caption = "";
}
void Limpar()
{
int J, X;
for (J = 0; J <= 7; J++)
{
ALUNO[J].NOME = "";
for (X = 0; X <= 3; X++);
ALUNO[J].NOTA[X] = 0;
ALUNO[J].MEDIA = 0;
}
LimpaTela();
/* Inicializa contador de registro */
I = 0;
}
void __fastcall TForm1::FormShow(TObject *Sender)

{
Limpar();
}
//-------------------------------------------------------------------- ------
int ExibeRegistro(int POSICAOATUAL)

{
Form1->Edit1->Text = ALUNO[POSICAOATUAL].NOME;
Form1->Edit2->Text = FormatFloat("#0.00", ALUNO[POSICAOATUAL].NOTA[0]);
Form1->Label7->Caption = FormatFloat("#0.00", ALUNO[POSICAOATUAL].MEDIA);
Puc - Campinas
return(0);
}

{
int CONTA;
float SOMA;
if (I <= 7 && ALUNO[I].NOME == "")
{
ALUNO[I].NOME = Edit1->Text;
ALUNO[I].NOTA[0] = StrToFloat(Edit2->Text);
SOMA = 0;
for (CONTA = 0; CONTA <= 3; CONTA++)
SOMA =+ ALUNO[I].NOTA[CONTA];
ALUNO[I].MEDIA = SOMA/4;
Label7->Caption = FormatFloat("#0.00", ALUNO[I].MEDIA);
I++; /* Conta registro */
LimpaTela();
}
else
{
LimpaTela();
if (I > 7)
ShowMessage("Memória cheia");
else
ShowMessage("Posição ocupada");
}
}
//-------------------------------------------------------------------- ------
{
int J;
ALUNO[I].NOME = "";
for (J = 0; J <= 3; J++)
ALUNO[I].NOTA[J] = 0;
ALUNO[I].MEDIA = 0;
LimpaTela();
}
//-------------------------------------------------------------------- ------
{
if (I < 7)
{
I++;
ExibeRegistro(I);
}
else
{
ShowMessage("Chegou no fim");
Edit1->SetFocus();
}
}
//-------------------------------------------------------------------- ------
{
if (I > 0)
{
I--;
ExibeRegistro(I);
}
else
{
ShowMessage("Chegou no começo");
Edit1->SetFocus();
}
}
//-------------------------------------------------------------------- ------

{
Limpar();
}
//-------------------------------------------------------------------- ------
Puc - Campinas
Arquivos
Para armazenar informações em disco e recupera-las em seguida é necessário a
utilização das funções de arquivo.
Estas funções encontram-se na biblioteca stdio.h. As funções mais comuns de

arquivo serão apresentadas na tabela seguinte:
Nome Função
fopen() Abre um arquivo
fclose() Fecha um arquivo
putc() Escreve um caractere em um arquivo
fputc() Escreve um caractere em um arquivo
getc() Lê um caractere de um arquivo
fgetc() Lê um caractere de um arquivo
fseek() Posiciona o arquivo em um byte específico
fprintf() Escreve uma informação no arquivo
fscanf() Lê uma informação de um arquivo
feof() Devolve verdadeiro se o fim do arquivo for atingido
ferror() Devolve verdadeiro se ocorreu um erro
rewind() Recoloca o ponteiro de arquivo no início
remove() Apaga um arquivo
fflush() Descarrega um arquivo
Tipos de Arquivos
Os Arquivos possuem dois tipos:

Arquivos de texto – armazenam uma seqüência de caracteres.
Arquivos binários – armazenam uma seqüência de bytes, não ocorre nenhuma tradução de caracteres.
Ponteiro de Arquivo
Todo Arquivo deverá possuir um ponteiro para direcionar as operações a serem realizadas.
Para escrever ou ler uma informação de um Arquivo, seu programa precisa usar o
ponteiro de arquivo:
Para utilizar uma variável ponteiro é necessário declara-la, como exemplo abaixo:

Exemplo:
FILE *fp;
Abrindo um Arquivo
A função fopen associa o nome de um Arquivo em disco com o ponteiro de arquivo.

A função fopen retorna um ponteiro de arquivo, o seu programa nunca poderá alterar este valor. Se
ocorrer um erro ao abrir o arquivo será retornado um valor nulo para o ponteiro.
Um arquivo pode ser aberto de várias maneiras, conforme mostra a tabela a seguir:
Modo Significado
r Abre um arquivo-texto para leitura
w Cria um arquivo-texto para escrita
a Anexa a um arquivo-texto
rb Abre um arquivo-binário para leitura
wb Cria um arquivo-binário para escrita
ab Anexa a um arquivo-binário
r+ Abre um arquivo-texto para leitura / escrita
w+ Cria um arquivo-texto para leitura / escrita
a+ Anexa ou cria um arquivo-texto para leitura / escrita
r+b Abre um arquivo-binário para leitura / escrita
w+b Cria um arquivo-binário para leitura / escrita
a+b Anexa ou cria um arquivo-binário para leitura / escrita
Exemplo de Abertura de Arquivo
Exemplo :
Criar um arquivo texto para escrita, associando ao arquivo em disco c:\arquivo.dat.
FILE *fp;
fp = fopen(“c:\\arquivo.dat”,”w”);
Exemplo 2:
Criar um arquivo texto para escrita, associando ao arquivo em disco c:\arquivo.dat,

verificando se não ocorreu erro na abertura do arquivo.
Puc - Campinas
FILE *fp;
if ((fp = fopen(“c:\\arquivo.dat”,”w”))==NULL)
{
ShowMessage(“O arquivo não pode ser aberto”);
Close();
}
Fechando um arquivo
Todo arquivo aberto deverá ser fechado no final do programa, ou assim que a sua
utilização não se faça mais necessária.
Se o arquivo não for fechado poderá ocorrer perdas de dados, arquivos destruídos ou
problemas intermitentes na execução do programa.
A função fclose fecha um arquivo aberto, conforme exemplo abaixo:
fclose(fp);
Arquivo do Tipo Texto
O arquivo de texto grava somente caracteres no formato texto.
Arquivo Binário
Arquivos binários – armazena uma seqüência de bytes, não ocorre nenhuma tradução de caracteres.
Exemplo de escrita em arquivo binário:
struct registro
{
int num;
char nome[30];
}aluno;
aluno.num=5;
aluno.nome=“João da Silva”;
FILE *arquivo;
arquivo = fopen(“a:\\dados.dat”,”wb”);
fwrite(&aluno, sizeof(aluno), 1, arquivo);
: : :

fclose (arquivo);
Programa de Arquivo com registros
O programa a seguir mostra a utilização de arquivo para registros.
#include <vcl.h>
#include <stdio.h> //biblioteca para trabalhar com arquivo
#pragma hdrstop
#include "Unit1.h"
//-------------------------------------------------------------------- ------
TForm1 *Form1;
struct CadAluno
{
char NOME[50];
float NOTA[4];
float MEDIA;
};
FILE *arquivo; //ponteiro de arquivo
CadAluno ALUNO;
//-------------------------------------------------------------------- ------
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
void LimpaTela()
{
Form1->Edit1->Text = ""; Form1->Edit2->Text = "";
Form1->Edit3->Text = ""; Form1->Edit4->Text = "";
Form1->Edit5->Text = ""; Form1->ListBox1->Items->Clear();
}
//-------------------------------------------------------------------- ------
{
//se não conseguir abrir arquivo de aluno para adicionar valores
if ((arquivo=fopen("C:\\TEMP\\ALUNO.DAT","ab"))==NULL)
{
ShowMessage("Não posso abrir arquivo de alunos");
}
else //senão
{
Puc - Campinas
//copia valor de Edit1 para matriz de caracteres ALUNO.NOME

strcpy(ALUNO.NOME , Edit1->Text.c_str());
ALUNO.NOTA[0] = StrToFloat(Edit2->Text);
float SOMA = 0;
// soma todas as notas
for (int C = 0; C <= 3; C++)
{
SOMA += ALUNO.NOTA[C];
}
// calcula a média
ALUNO.MEDIA = SOMA/4;
//grava registro ALUNO em arquivo
fwrite(&ALUNO,sizeof(ALUNO),1,arquivo);
//fecha arquivo
fclose(arquivo);
LimpaTela();
}
}
//-------------------------------------------------------------------- ------
{
//se não conseguir abrir arquivo de aluno para leitura de valores
if ((arquivo=fopen("C:\\TEMP\\ALUNO.DAT","rb"))==NULL)
{
ShowMessage("Não posso abrir arquivo de alunos");
}
else //senão
{
LimpaTela();
//enquanto conseguir ler arquivo de aluno
while((fread(&ALUNO,sizeof(ALUNO),1,arquivo)==1))
{
char FORMATO[60]; // matriz de caracteres para saída
//copia valor de ALUNO.NOME para FORMATO
strcpy(FORMATO,ALUNO.NOME);
//concatena (soma) valor de ALUNO.NOME com a frase " MEDIA =
"
strcat(FORMATO," Média= ");
char media[5]; // matriz de caracteres para media
//converte float para texto
gcvt(ALUNO.MEDIA, 1, media);
//concatena (soma) valor de FORMATO com media
strcat(FORMATO,media);
//adiciona resultado no ListBox1
ListBox1->Items->Add(FORMATO);
}
fclose(arquivo);
}
}
//-------------------------------------------------------------------- ------
{
Close();
}
//-------------------------------------------------------------------- ------

Bibliografia
1 MATEUS, César Augusto, C++ Builder 5 - Guia Prático, São Paulo, SP,
Editora Érica, 2000.
2 MANZANO, José Augusto Navarro Garcia, Estudo Dirigido de C++ Builder,

São Paulo, SP, Editora Érica, 2003.
3 MIZRAHI, Victorine Viviane. Treinamento em Linguagem C++. São Paulo.

Makron Books do Brasil Editora Ltda.
4 BERRY, John. Programando em C++. São Paulo. Makron Books do Brasil

Editora Ltda.
5 SCHILDT, Herbert. Linguagem C – Guia Prático e Interativo. São Paulo.

Makron Books do Brasil Editora Ltda.
6 SCHILDT, Herbert. Linguagem C – Completo e total. São Paulo. Makron

Books do Brasil Editora Ltda.
7 ELLIS, Margaret A., Stroustrup Bjarne. C++ Manual de Referência

Comentado. Rio de Janeiro. Editora Campus Ltda.
8 DAVIS, Stephen R. C++ Para Leigos. São Paulo. Berkeley.
9 JAMSA, Kris. Salvo pelo... C++. Rio de Janeiro. Livros Técnicos e Científicos
Ltda.
10 BERGSMAN, Paul. Controlling the world with your PC. Eagle Rock,
Virginia. LLH Technology Publishing.
11 TORRES, Gabriel. Hardware Curso Completo. Rio de Janeiro. Axcel Books

do Brasil Editora.
Puc - Campinas
Banco de Dados
Introdução
O C++ Builder oferece uma série de ferramentas e recursos que possibilitam a

criação de aplicações de bancos de dados de forma rápida e fácil. Serão introduzidos,
a diante, os conceitos básicos de manipulação de bancos de dados em C++ Builder,
oferecendo uma visão geral dos componentes de acesso a dados mais
corriqueiramente utilizados.
A base das aplicações de bancos de dados do C++ Builder está no Borland
Database Engine (BDE), uma camada de software que realiza o acesso a bancos de
dados baseados em arquivos como Paradox e dBase ou a servidores de bancos de
dados locais ou remotos como InterBase, Informix, Oracle, SyBase, etc. Os
componentes de bancos de dados do C++ Builder oferecem uma forma simplificada,
que utiliza programação visual baseada em PME (Propriedades, Métodos e Eventos),
para acessar a API do BDE.
Há duas grandes classes de componentes: os componentes de acesso a
dados (data-access) e os componentes de controle, visualização e manipulação dos
dados (data-controls), sendo que os componentes de visualização e manipulação de
dados são também denominados de componentes data-aware (componentes
capazes de mostrar e atualizar os dados armazenados em uma tabela associada).
Estes dois grupos de componentes estão localizados, respectivamente, nas páginas
Data Access e Data Controls da paleta de componentes do C++ Builder.
Os principais componentes do tipo data-access utilizados na criação de
aplicações com bancos de dados em C++ Builder são os componentes derivados da
classe abstrata TDataSet, que são: Table da classe TTable, Query da classe TQuery
e StoredProc da classe TStoredProc. Qualquer um dos componentes derivados da
classe TDataSet podem ser referenciados como datasets. Os componentes Query e
StoredProc são mais utilizados em aplicações cliente-servidor. O componente Table
oferece a forma mais simples de se acessar informações em uma tabela de banco de
dados.
Um dataset possui um conjunto de estados onde pode se encontrar. Os
estados possíveis são:

Uma aplicação pode posicionar um dataset em determinado estado através de
uma chamada explícita a um método ou através da ocorrência de um evento que
desencadeie uma troca de estado. Há métodos que sempre levam para determinado
estado e são chamados métodos correspondentes aos estados. São eles: Edit, Insert,
Append e Setkey. Um outro conjunto de métodos sempre retorna o dataset para o
seu estado de Browse como Delete, Cancel, GotoKey e GotoNearest. Há casos em
que o sucesso ou insucesso do método define se o dataset volta ao estado de
Browse, como o método Post.
O diagrama de estados da Figura 1 mostra os possíveis estados de um
dataset e os métodos que causam as trocas de estado para outro.
Puc - Campinas
O componente Table é a interface entre o Borland Database Engine e os

componentes DataSource O componente DataSource por sua vez oferece a interface
para os componentes data-aware. que irão compor a interface com o usuário.
Trabalhando-se com o componente Table usa-se a propriedade DatabaseName para
especificar o banco de dados a ser acessado; a propriedade TableName serve para
indicar a tabela a acessar; utiliza-se a propriedade IndexName para definir o uso de
um determinado índice com a tabela; configura-se a propriedade Active para True ou
chame-se o método Open para abrir o dataset, colocando ele no estado Browse;
coloca-se a propriedade Active em False ou chame-se o método Close para fechar o
dataset.
O componente DataSource é a interface entre um componente dataset e os
componentes data-aware nos formulários. O DataSource liga-se a um dataset através
da propriedade Dataset. Os componentes Data-aware, como DBEdit e DBGrid, ligam-
se ao DataSource através de suas propriedades DataSource. Usualmente há apenas
um DataSource para cada dataset, no entanto pode-se conectar a um dataset tantos
DataSource quantos forem necessários. Para monitorar alterações no estado do
dataset associado ao DataSource pode-se associar um método ao evento
OnStateChange.
Há vários componentes do tipo data-controls no C++ Builder. O DBGrid
permite a visualização, alteração e navegação no conjunto de todos os registros e
campos de uma tabela; o DBText que mostra os dados em um campo de uma tabela
como um label read-only similar ao componente Label; o DBEdit usado para
apresentar e alterar os valores de um campo numa caixa de edição similar a um
componente Edit; o DBImage que apresenta gráficos e figuras do tipo bitmap
armazenados em um campo do tipo BLOB (BinaryLarge Object), de forma
semelhante ao realizado pelo componente Image; e o DBNavigator que oferece um
conjunto de botões para navegar pelas linhas de um dataset, adicionar ou eliminar
uma linha, colocar o dataset no estado de edição, confirmar ou cancelar as alterações
realizadas
no dataset ou recarregar os dados do disco, atualizando o dataset.
Exercícios
1) Crie um novo projeto. Altere a propriedade Name do Form1 para “J_Main”, e a

propriedade Caption para “Prática 1 - Aplicação com Banco de Dados”.
2) Salve o projeto atribuindo o nome MAIN.CPP para a Unit1 e PRAT1.BPR para o

projeto.
3) Introduza um componente Table no formulário, (ícone da página Data Access

da paleta de componentes), configure sua propriedade Name para tbEmpregados,
sua propriedade DatabaseName para BCDEMOS e sua propriedade TableName
para EMPLOYEE.DB.
4) Insira um componente DataSource (ícone da página Data Access da paleta

de
componentes) no formulário, configure sua propriedade DataSet para tbEmpregados.

5) Insira um componente DBGrid (ícone da página Data Controls da paleta de
componentes), ajuste suas dimensões para se adaptarem ao tamanho do formulário

e altere sua propriedade DataSource para DataSource1.
6) Altere a propriedade Active do componente tbEmpregados para True. A tabela

será aberta e você visualizará os dados no grid em tempo de projeto. Em seguida
coloque esta mesma propriedade novamente para False.
7) Programe o evento OnActivate do formulário com o seguinte comando:
tbEmpregados->Open(); Que é equivalente a fazer tbEmpregados->Active =

true; Isto irá abrir a tabela em tempo de execução.
8) Execute e teste a aplicação. Observe que os dados poderão ser alterados, mas
recomendamos que não se façam alterações, uma vez que estes dados são
utilizados por aplicações exemplo do C++ Builder.
9) Adicione na parte superior esquerda do formulário principal um componente Label.

Altere sua propriedade Name para labelEstado e limpe o conteúdo de sua
propriedade Caption.
10) Crie um manipulador de eventos para o evento OnStateChange do componente

DataSource1. Este evento é gerado toda vez que o dataset associado ao datasource
(neste caso tbEmpregados) muda de estado. Digite o seguinte código:
switch (tbEmpregados->State) {
case dsInactive: labelEstado->Caption = "Estado Inativo";

break;
case dsBrowse: labelEstado->Caption = "Estado de Browse";
break;
case dsEdit: labelEstado->Caption = "Estado de Edição";
break;
case dsInsert: labelEstado->Caption = "Estado de Inserção";
break;
case dsSetKey: labelEstado->Caption = "Estado de Busca
(SetKey)";
break;
case dsCalcFields: labelEstado->Caption = "Estado de Campo
Calculado";
break;
11) Adicione ao formulário principal um componente Button. Altere sua propriedade

Name para btAbreFecha, sua propriedade Caption para Fechar e programe um
tratador de eventos para o seu evento OnClick com o seguinte código:
tbEmpregados->Active = !tbEmpregados->Active;
if (tbEmpregados->Active) btAbreFecha->Caption = "Fechar";

Puc - Campinas
else btAbreFecha->Caption = "Abrir";
12) Compile e teste a aplicação.
QUESTÃO No 1: Qual é o estado inicial do dataset tbEmpregados? Quando se clica

no
botão fechar qual o novo estado? Que transição no diagrama da Figura 1 está
associada a essa mudança?
13) Com a tabela tbEmpregados aberta, posicione no campo EmpNo do empregado

de cujo valor de EmpNo é 2. Dê um clique neste campo e digite o valor 4. Troque
para um novo registro dando um clique no registro para onde se deseja ir.
QUESTÃO No 2: O que acontece? Porque a exceção foi gerada? Qual o estado do

dataset antes e após a tentativa de mudar de registro? Que transição no diagrama da
Figura 1 está associada a essa mudança?
14) Pressione a tecla Esc para cancelar as alterações. Use a barra de rolagem do
grid para posicionar a tabela no último registro. Use a tecla Down (↓) para inserir um
novo registro.
QUESTÃO No 3: Qual o novo estado do dataset? Que transição no diagrama da

Figura 1 está associada a essa mudança? Uma outra forma de inserir um registro
usando o grid é pressionar a tecla Insert, que realizará a inserção no ponto atual do
cursor.
15) Digite o número 147 no campo EmpNo e os dados do seu nome nos campos
FirstName e LastName. Mude de registro para confirmar as alterações (Post).
16) Posicione sobre o registro récem-incluído e pressione as teclas Ctrl+Del para

eliminar o registro. Escolha Ok quando for mostrada a caixa de diálogo de
confirmação.
17) Adicione um componente Edit ao formulário J_Main. Altere sua propriedade

Name para editBusca e limpe o conteúdo de sua propriedade Text.
18) Adicione 2 botões do tipo SpeedButton. Configure a propriedade Name de cada

um deles para btPreparaBusca e btBusca, respectivamente. Programe a propriedade
glyph do primeiro para o bitmap contido no arquivo C:\Arquivos de
Programas\Arquivos comuns\Borland Shared\Images\Buttons\fcabopen.bmp e a
do segundo para o bitmap do arquivo C:\Arquivos de programas\Arquivos
comuns\Borland Shared\images\buttons\find.bmp. O formulário deve ficar com o
aspecto da figura a seguir.

19) Programe o evento OnClick do botão btPreparaBusca com o seguinte código:
tbEmpregados->SetKey();
tbEmpregados->FieldByName("EmpNo")->AsString = editBusca->Text;
20) Programe o evento OnClick do botão btBusca com o segunite código:

tbEmpregados->GotoKey();
21) Compile e teste a aplicação. A busca é realizada pelo código, índice principal da
tabela. Digite o valor 10 na caixa de edição. Clique sobre o botão btPreparaBusca.
QUESTÃO No 4: Qual o novo estado do dataset? Que transição no diagrama da

Figura 1 está associada a essa mudança?
22) Clique sobre o botão btBusca. O registro foi localizado? Digite o valor 11 na caixa
de edição. Pressione os botões btPreparaBusca e btBusca. E agora o registro foi
localizado? Encerre a aplicação.
23) Altere o evento OnClick do botão btBusca para:

tbEmpregados->GotoNearest();
24) Recompile e teste a aplicação. Faça uma busca usando o valor 10.
QUESTÃO No 5: Qual registro foi localizado? Qual a diferença entre os métodos

GotoKey e GotoNearest?
Puc - Campinas
! "
25) Selecione o componente tbEmpregados. Altere sua propriedade IndexName para

ByName.
26) Crie um tratador de eventos para o evento OnChange do componente EditBusca

e digite:
if (editBusca->GetTextLen() > 0)
tbEmpregados->FindNearest(ARRAYOFCONST((editBusca->Text)));
27) Compile e teste a aplicação. Digite um nome na caixa de edição começando com
r. O que acontece?
QUESTÃO No 6: Por que a busca agora foi realizada pelo nome? Qual a função do
método FindNearest? Ele condensa a função de quais outros métodos?
28) Digite o valor 146 na caixa de edição. Pressione o botão btPreparaBusca. O que
acontece?
QUESTÃO No 7: Qual a razão do erro? Por que não foi possível atribuir o valor 146
ao
campo EmpNo com o dataset no modo SetKey? Que campos podem ter valores
atribuídos no modo SetKey?
# #$%&'
29) Chame o Database DeskTop (Menu Tools | Database DeskTop).
30) No DataBase DeskTop Escolha o menu File | Open | Table… Na caixa de diálogo
Open Table, abra o combobox Alias (última linha) e escolha BCDEMOS. Selecione
Employee.db e clique no botão abrir.
31) Escolha o menu Table | Restructure… Com a caixa de diálogo aberta, use a
tecla Down (↓) para posicionar além do último campo (Salary), incluindo um novo
campo.
32) Digite na coluna FieldName, o nome Picture, pressione a tecla <Tab> para
posicionar na coluna Type. Digite G (Campo do tipo Graphic BLOB).
33) Clique no botão Save para validar as alterações. Feche a tabela Employee.db
(Clique duplo no menu de controle da sua janela) e feche o Database DeskTop.
( ) *
34) Crie um novo formulário. Altere sua propriedade Name para J_Empregados, sua
propriedade Caption para ‘Empregados’ e a propriedade BordeStyle para bsDialog.
Salve o projeto, dando o nome EMPREG.CPP (lembrar de voltar o diretório atual
para o diretório da Prática 1) para a Unit associada ao novo formulário criado.
35) Ajuste o formulário J_Empregados para ser o formulário principal da aplicação.

Menu Project | Options.

36) Introduza um componente Table no formulário, configure sua propriedade Name
para tbEmpregados, sua propriedade DatabaseName para BCDEMOS e sua
propriedade TableName para EMPLOYEE.DB.
37) Insira um componente DataSource no formulário, configure sua propriedade

DataSet para tbEmpregados.
38) Insira um componente DBText (ícone da página Data Controls da paleta de

componentes), configure sua propriedade DataSource para DataSource1 e sua
propriedade DataField para EmpNo. Mude sua propriedade Font para tamanho 18,
estilo negrito e cor castanho. Este componente serve para exibir valores de uma
determinada tabela, sem permitir que os mesmos sejam alterados.
39) Adicione um componente DBEdit (ícone da página Data Controls da paleta

de componentes), configure sua propriedade DataSource para DataSource1 e sua
propriedade DataField para FirstName. Inclua um componente Label para identificar
o campo, posicionando-o logo acima do DBEdit e ajuste seu Caption para ‘Primeiro
Nome’.
40) Repita o passo 39 para os campos LastName e Salary.
41) Adicione um componente DBImage (ícone da página Data Controls da

paleta de componentes). Altere sua propriedade DataSource para DataSource1, sua
propriedade DataField para Picture e sua propriedade Stretch para True.
42) Inclua um componente DBNavigator (ícone da página Data Controls da

paleta de componentes). Configure sua propriedade DataSource para DataSource1 e
sua propriedade ShowHint para True.
43) Posicione um componente BitBtn. Ajuste sua propriedade Kind para bkOk, a
propriedade Name para btOk e seu Caption para ‘&Fechar’. Programe o evento
OnClick do mesmo com o seguinte código: Close();
44) Adicione um Bevel, configurando sua propriedade Shape para bsBottomLine. O

formulário deve ficar
com o seguinte
aspecto:
Puc - Campinas
45) Ajuste a propriedade Active do componente tbEmpregados para True.
46) Compile e teste a aplicação. Verifique o funcionamento de cada um dos botões

no navegador (DBNavigator).
+ ) $
47) Adicione um componente OpenDialog no formulário J_Empregados. Ajuste sua

propriedade Filter para conter na coluna Filter Name Imagens (*.bmp) e na coluna
Filter para *.bmp; altere o item ofHideReadOnly da propriedade Options para True.
48) Programe um tratador de eventos para o evento OnDblClick do componente

DBImage1 contendo os seguinte código:
if (OpenDialog1->Execute()) {
DataSource1->DataSet->Edit();
DBImage1->Picture->LoadFromFile(OpenDialog1->FileName);
49) Compile e teste a aplicação. Para carregar uma nova figura no campo DBImage
basta dar um duplo-click sobre a mesma.
Obs: Uma outra forma de carregar valores sobre um campo DBImage é usando o
ClipBoard (Sequências de teclas Ctrl+V para inserir e Ctrl+C para copiar).
, -& .
50) Transfira o formulário J_Empregados da lista Auto-create forms para a lista

Available forms (menu Project | Options).
51) Selecione o formulário J_Main e neste o componente DBGrid1. No Object

Inspector selecione sua propriedade Options e dê um duplo-clique sobre a mesma
para visualizar os seus itens. Configure os itens dgEditing para False, dgRowSelect
e dgAlwaysShowSelection para True. Altere ainda a propriedade ReadOnly deste
componente para True.
52) Utilize o menu File | Include Unit Hdr….para fazer uso do módulo MAIN.CPP.
53) Crie um tratador de eventos para o evento OnDblClick do componente DBGrid1 e

digite as seguintes linhas de código:

J_Empregados = new TJ_Empregados(this);
J_Empregados->DataSource1->DataSet = tbEmpregados;
J_Empregados->ShowModal();
delete J_Empregados;
54) Selecione o formulário J_Empregados e elimine o componente tbEmpregados. O

DataSource1 será ligado em tempo de execução (linha 2 do item anterior) ao dataset
do tipo TTable do formulário J_Main denominado tbEmpregados.
Obs: Neste caso temos 2 componentes datasource ligados ao mesmo dataset.
55) Altere a propriedade Name do botão btAbrirFechar do formulário J_Main para

btSair, a sua propriedade Caption para Sair e o código do seu envento OnClick
para:
Close();
56) Compile e teste a aplicação. Para visualizar e editar um determinado registro

basta dar um duplo clique sobre o mesmo. Realize algumas operações com os dados
e observe as alterações no LabelEstado do formulário J_Main.
QUESTÃO No 8: Porque o estado do dataset tbEmpregados é influenciado quando

altera-se os componentes ligados ao datasource do formulário J_Empregados?
( ) "*
O componente DBNavigator pode ser configurado para apresentar apenas alguns dos
botões de navegação. Além disso as mensagens apresentadas no Hint podem ser
personalizadas.
57) Selecione o componente DBNavigator1 do formulário J_Empregados. Selecione a

sua propriedade VisibleButtons e dê um duplo clique para visualizar os seus itens.
Altere os itens nbEdit e nbRefresh para False.
58) Selecione a propriedade Hints do componente DBNavigator1. Dê um clique sobre

o botão para ativar o editor de lista de strings. Digite os seguintes itens: Primeiro,
Anterior, Próximo, Último, Adicionar, Eliminar, Editar, Gravar Alterações, Cancelar
Alterações, Atualizar Informações.
Obs: Veja que mesmo os botões Edit e Refresh não estando visíveis no navegador,
as mensagens de Hint devem ser obrigatoriamente especificadas para os mesmos,
na ordem em que os botões apareceriam.
59) Compile e teste a aplicação. Chame a janela de edição dos registros (Janela
Empregados) e posicione o mouse sobre os botões do navegador. As mensagens
programadas irão aparecer.
Aplicação de BDE
O Borland Database Engine (BDE, apresentado anteriormente) oferece um
utilitário de configuração chamado BDE Administrator (BDEAdmin.EXE) que permite
configurar os aliases utilizados e alterar o ambiente do Engine como: drivers
instalados, configuração interna do sistema e formato de apresentação de data e hora
e valores numéricos. Essas informações são gravadas em um arquivo de
configuração, normalmente chamado IDAPI32.CFG.
Puc - Campinas
O BDE usa os aliases como nomes alternativos para data sources

freqüentemente utilizados, sejam estes locais ou remotos. Além do BDE Administrator
para criar e configurar aliases pode-se utilizar também o Database Explorer para
realizar estas tarefas. Alternativamente pode-se utilizar o programa BDE
Configuration Utility (BDECFG32.EXE) e o Database Desktop para manipular aliases.
No entanto, o seu uso com versões mais novas do C++ Builder não é aconselhável.
O Database Desktop (DBD) é um utilitário independente do C++ Builder, que
pode ser utilizado para visualizar criar e modificar tabelas Paradox e dBase, além de
efetuar outras tarefas relacionadas à administração de banco de dados. Pode-se
também realizar operações restritas em outros bancos de dados, como Oracle,
Interbase e outros. Este não vem sendo atualizado junto com as novas versões do
C++ Builder, e a sua utilização deve ser descontinuada progressivamente, à medida
que outras ferramentas assumam as suas funções.
O Database Explorer permite visualizar e manter bancos de dados (remotos
ou locais, com restrições), trabalhar com aliases do BDE e com metadados (tabelas,
visões, etc., ou seja, dados sobre dados). Na versão Enterprise do C++ Builder o
Database Explorer recebe o nome de SQL Explorer, porque tem a possibilidade de
acessar bancos de dados SQL.
Exercícios
) *
1) Crie um diretório denominado Prat1. No interior deste crie um outro denominado

Dados.
2) Chame o BDE Administrator através do menu Iniciar | Programas | Borland
C++Builder 5 | BDE Administrator, ícone . O BDE Administrator pode ser

acessado também a partir do Painel de Controle do Windows.
3) A interface do BDE Administrator é implementada com um componente TreeView,
no estilo do Windows Explorer. Clique no sinal do ícone para verificar

os bancos de dados existentes.
4) Escolha no menu Object a opção New. Será apresentada a caixa de diálogo New
Database Alias. Mantenha o Database Driver Name como STANDARD (tabelas
locais Paradox e dBase) que já é o valor default e pressione o botão OK.
5) Substitua o nome STANDARD1 sugerido por Prat2. Na propriedade PATH do lado

direito da janela digite o caminho onde serão armazenados os dados da prática 2, ou
seja o diretório Dados criado no item 1. Ou procure o diretório, clicando no botão .
Por exemplo:

6) Escolha o menu Object | Apply (pressione OK na janela de confirmação) para
salvar as novas configurações. O novo alias está criado e salvo. Quando as
alterações são salvas a seta verde no novo alias some. Antes de fechar a aplicação
dê uma olhada geral na guia Configuration do utilitário de administração, para
conhecer um pouco os drivers instalados e o que mais pode ser configurado no BDE.
Em seguida feche o utilitário.
/ ) 0 /
7) Com o alias criado, vamos realizar agora a criação das novas tabelas a serem
utilizadas na nossa aplicação.
8) Chame o DataBase Desktop (Menu Iniciar | Programas | Borland C++Builder 5 |
DataBase Desktop, ícone , da barra de tarefas do Windows).
9) Com a aplicação aberta escolha o menu File | Working Directory… e preencha a

caixa de diálogo de acordo com a figura abaixo. No campo Alias escolha Prat2 e o
campo Working Directory será preenchido automaticamente !
(
Puc - Campinas
10) Em seguida escolha o menu File | New | Table… para criar uma nova tabela ou
alternativamente clique com o botão da direita sobre o ícone da SpeedBar e

escolher a opção New…. O tipo da tabela deve ser Paradox 7.0, que já é o default.
Preencha então os campos de acordo com a figura a seguir.
Obs: Para especificar a chave primária da tabela (indicada por um asterisco na coluna
Key dos campos que a compõem) basta pressionar qualquer tecla com o cursor na
coluna Key do campo.
11) Definidos os campos, vamos criar os índices secundários a serem utilizados como
alternativas para a ordem de visualização e consulta, que não aquela estabelecida
pela chave primária Cod_Emp. Escolha no combobox Table properties a opção
Secondary Indexes e em seguida clique sobre o botão . Será aberta a

caixa de diálogo para definição de índices secundários. Preencha-a de acordo com a
figura abaixo e clique no botão Ok. Dê o nome idxNome para o índice.
Obs: Os índices compostos por um único campo e que sejam do tipo Case Sensitive
não requisitam
nome e assumem o
próprio nome do
campo.

12) Pressione no botão e escolha o nome emp.db para o arquivo que
armazenará a
tabela.
13) Repita os passos 10 a 12 para criar a tabela de Departamentos.
14) Insira os campos apresentados na tabela abaixo:
Field Name Type Size Key

Cod_Dep N *
Descricao A 25
Gerente N
Fone A 20
15) Crie um índice secundário denominado idxDescricao contendo o campo

Descricao.
16) Salve a tabela com o nome depto.db.
( )
17) Abra a tabela de Departamentos (Depto.db). Clique no menu Table |
Restructure… ou no ícone para realizar alterações na estrutura da tabela.

Escolha no combobox Table properties a opção Referencial Integrity e em seguida
clique sobre o botão . Será aberta a caixa de diálogo para definição das
regras de integridade referencial para esta tabela. Preencha-a de acordo com a figura
a seguir. Isto garantirá que as atualizações realizadas no campo Cod_Emp da tabela
de empregados irá se refletir de forma automática para a chave estrangeira Gerente
da tabela de departamentos. A regra para deleção é implícita e sempre proibitiva.
Puc - Campinas
Clique sobre o botão OK para validar os dados, aparecerá uma caixa de diálogo
pedindo o nome para a regra de integridade referencial. Forneça o nome rGerente e
clique em OK.
18) Clique no botão para salvar as alterações. Feche a tabela Depto.db.
19) Abra a tabela Emp.db e crie uma regra de integridade referencial para a chave
estrangeira Cod_Dep relacionando-a com a tabela Depto.db. Atribua o nome rDepto
para esta regra. A caixa de diálogo de criação de regras de integridade referencial
deve ser preenchida da seguinte forma:
20) Saia do Database Desktop.

21) Abra o Database Explorer (no C++ Builder Client/Server se chama SQL Explorer)
através do menu Database | Explore .
22) A interface do Explorer é semelhante à do BDE Administrator. Navegue no banco

de dados Prat2 e verifique as tabelas que acabaram de ser criadas no Database
Desktop.
23) Repare que, no lado direito da janela, além de visualizar a definição das tabelas
(guia Definition) pode-se manipular os seus dados, através da guia Data.
24) Abra o banco de dados DBDEMOS e consulte os dados da tabela ANIMALS.DBF.

Repare que o navegador acima dos dados fica habilitado.
OBS.: O Database Explorer permite inserir, excluir e alterar dados em tabelas locais
(Paradox e dBase), mas não permite criar novas tabelas ! No entanto, em bancos de
dados SQL é possível criar tabelas e também outros meta-dados.
Puc - Campinas
2 (
25) Crie uma aplicação usando o C++Builder, semelhante a Prática 1, para acessar
as tabelas Emp.db e Depto.DB criadas nesta prática.

Apostila CBUILDER

Enviado por

Dados do documentoclique para ver informações do documento

Direitos autorais:

Formatos disponíveis

Apostila CBUILDER

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila CBUILDER

Enviado por

Direitos autorais:

Formatos disponíveis

Puc - Campinas

Informática para Engenharia

Borland C++ Builder

Prof° José Marcelo Traina Chacon

O Borland C++ Builder disponibiliza uma extensa biblioteca de componentes

Prof° José Marcelo Traina Chacon 1

Iniciando C++ Builder

O C++ Builder ambiente de desenvolvimento (também chamado de IDE), tem várias

Prof° José Marcelo Traina Chacon 3

Acessando comandos rapidamente

O menu principal no topo da janela principal, disponibiliza acesso a vários comandos

Abrir Salvar Salvar Abrir Adicionar Arquivo

Ver Alterar Novo Pausa

Clique com o botão direito do mouse na barra de ferramentas e escolha

Criando uma Aplicação

Criando uma Aplicação

O Borland C++ Builder imediatamente apresenta as ferramentas necessárias para

Prof° José Marcelo Traina Chacon 5

Muitos componentes visuais são disponibilizados no ambiente de desenvolvimento na

O Borland C++ Builder agrupa os componentes, em diferentes página, de acordo com

Prof° José Marcelo Traina Chacon 7

Alterando o comportamento do componente

Você pode facilmente personalizar a aparência e o comportamento de sua aplicação

Usando a página Propriedades do Object Inspector, você ajustará

Dando um clique em um evento em particular, o Borland C++

Formulários (Forms) são objetos especializados no qual você coloca componentes

Segue uma lista das principais propriedades de um formulário.

Propriedades – Características de um componente

Align – Alinhamento do formulário

• alBotton – Alinha na parte inferior da área gráfica

• alClient – Alinha em toda a área gráfica

• alLeft – Alinha na parte esquerda da área gráfica

Prof° José Marcelo Traina Chacon 9

• alRight – Alinha na parte direita da área gráfica

• alTop – Alinha na parte superior da área gráfica

BorderIcons – Determina qual botão irá aparecer na barra de título

• biSystemMenu – Botão Fechar

BorderStyle – Estilo da Borda, dependem do BorderIcons

• bsDialog – Somente fechar e Help

• bsNone – Sem borda

• bsSingle – Borda Simples

• bsSizeable – Borda Normal

• vsSizeTollWin – Somente Botão Fechar

• bsToolWin – Somente Botão Fechar

Prof° José Marcelo Traina Chacon 11

Caption – Texto que será mostrado na barra de titulo do formulário

Color – Cor do funda do formulário

Height – Altura do formulário em pontos

Icon – Escolhe uma icone para o programa

Prof° José Marcelo Traina Chacon 13

1° Passo – Criar um novo arquivo de ícones.

2° Passo – Desenhar uma nova ícone.

3° Passo – Salvar o novo arquivo de ícone.

Left – Distância da Esquerda

Position – Determina a posição que aparecerá o formulário na tela.

Visible – Determina se o formulário irá ficar visível ou invisível.

WindowState – Determina em que modo de exibição a tela será mostrada.