Você está na página 1de 121

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.

Prof° José Marcelo Traina Chacon 3


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

Prof° José Marcelo Traina Chacon 5


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

Prof° José Marcelo Traina Chacon 7


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

Prof° José Marcelo Traina Chacon 9


• 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

Prof° José Marcelo Traina Chacon 11


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

Prof° José Marcelo Traina Chacon 13


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)

Prof° José Marcelo Traina Chacon 15


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.

Propriedades – Características de um componente

Alignment – Alinhamento de um texto

• taCenter – Alinhamento centralizado

• taLeftJustify – Alinhamento à esquerda

• taRightJustify – Alinhamento à direita

Prof° José Marcelo Traina Chacon 17


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.

Eventos – Ações de um componente

OnClick – Usuário dá um clique sobre o componente rótulo.

OnDblClick – Usuário dá um duplo clique sobre o componente rótulo.

Métodos – Ações que alteram o componente

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!

Prof° José Marcelo Traina Chacon 19


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.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 21


Eventos – Ações de um componente

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

Métodos – Ações que alteram o componente

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


propriedades explicadas anteriormente.

Segue uma lista das principais propriedades de um Botão de comando.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 23


Name – Define o nome do botão no programa

Eventos – Ações de um componente

OnClick – Usuário dá um clique sobre o componente botões de comando.

Métodos – Ações que alteram o componente

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

Prof° José Marcelo Traina Chacon 25


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.

Propriedades – Características de um componente

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


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

false true false true


Eventos – Ações de um componente

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


propriedades explicadas anteriormente.

Segue uma lista das principais propriedades de um Caixa de Lista.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 27


• 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

Eventos – Ações de um componente


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.

Métodos – Ações que alteram o componente

• Clear - Apaga as informações contidas na caixa de lista.

Prof° José Marcelo Traina Chacon 29


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


propriedades explicadas anteriormente.

Segue uma lista das principais propriedades de um Caixa Combinada.

Propriedades – Características de um componente

• 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

Eventos – Ações de um componente

OnChance – Ao alterar a caixa combinada

Métodos – Ações que alteram o componente

• Clear - Apaga as informações contidas na caixa combinada.

Programa Lista de Usuários

Eventos do programa lista de usuários:

Prof° José Marcelo Traina Chacon 31


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;
}
//--------------------------------------------------------------------

Prof° José Marcelo Traina Chacon 33


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


propriedades explicadas anteriormente.

Segue uma lista das principais propriedades de um Barra de rolagem.

Propriedades – Características de um componente

• 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

Prof° José Marcelo Traina Chacon 35


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

Clicar sobre o botão


de deslocamento
1

Eventos – Ações de um componente

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;
}
}
//--------------------------------------------------------------------

Prof° José Marcelo Traina Chacon 37


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


propriedades explicadas anteriormente.

Segue uma lista das principais propriedades de um Barra de menu.

Propriedades – Características de um componente

• 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

Eventos – Ações de um componente

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

Prof° José Marcelo Traina Chacon 39


Menu Editar
Item Propriedade Valor
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
Item Propriedade Valor
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.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 41


• 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


explicadas anteriormente.

Segue uma lista das principais propriedades de um Imagem.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 43


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

Prof° José Marcelo Traina Chacon 45


• false – Imagem não transparente .

Eventos – Ações de um componente

OnClick – Usuário dá um clique sobre o componente imagem.

OnDblClick – Usuário dá um duplo clique sobre o componente imagem.

Métodos – Ações que alteram o componente

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.

A grande parte das propriedades para o objeto Imagem é comum as propriedades


explicadas anteriormente.

Segue uma lista das principais propriedades de uma Forma.

Propriedades – Características de um componente

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

Prof° José Marcelo Traina Chacon 47


• Shape – Define a forma da figura geométrica.

Eventos – Ações de um componente

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.

A grande parte das propriedades para o objeto Imagem é comum as propriedades


explicadas anteriormente.

Segue uma lista das principais propriedades destes objetos.

Propriedades – Características de um componente

• DirList – Conecta o driver escolhido no DriveComboBox a Lista de Diretórios do


DirectoryListBox.

Prof° José Marcelo Traina Chacon 49


• 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

Eventos – Ações de um componente

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.

Prof° José Marcelo Traina Chacon 51


Programa Mostra Imagem

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//--------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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.

Propriedades – Características de um componente

Interval – Tempo entre um disparo e outro.

Eventos – Ações de um componente

OnTimer – Seqüência de comandos a ser realizados no intervalo de tempo


determinado no temporizados
uma tecla sobre os componentes listados.

Programa Animação

Prof° José Marcelo Traina Chacon 53


Puc - Campinas

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

#include <vcl.h>
#pragma hdrstop

#include "UnitAnimacao.h"
//--------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
// Declaração de variável
int seta=1;
char sentido='H';
//--------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TFor(Owner)
{
}
//--------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)


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

Prof° José Marcelo Traina Chacon 55


Image2->Visible=false;
Image3->Visible=false;
Image4->Visible=false;
Image5->Visible=true;
Image6->Visible=false;
break;
case 3 : Image1->Visible=false;
Image2->Visible=false;
Image3->Visible=false;
Image4->Visible=false;
Image5->Visible=false;
Image6->Visible=true;
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;
}
//--------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
sentido='A';
seta=4;
}
//--------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Timer1->Interval=0;
ScrollBar1->Position=0;
ProgressBar1->Position=0;
}
//--------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
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

Prof° José Marcelo Traina Chacon 57


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

#include <vcl.h>
#pragma hdrstop

#include "UnitFontesCores.h"
//--------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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.

Propriedades – Características de um componente

• 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

Prof° José Marcelo Traina Chacon 59


Programa Ordena Números
Puc - Campinas

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

#include <vcl.h>
#pragma hdrstop

#include "UnitOrdena.h"
//--------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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);
matnum[1]=StrToInt(EdtNum2->Text);
matnum[2]=StrToInt(EdtNum3->Text);
matnum[3]=StrToInt(EdtNum4->Text);
matnum[4]=StrToInt(EdtNum5->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];
PnlNum2->Caption = matcres[1];
PnlNum3->Caption = matcres[2];
PnlNum4->Caption = matcres[3];
PnlNum5->Caption = matcres[4];
}

//--------------------------------------------------------------------
void __fastcall TFrmNum::BtnDecClick(TObject *Sender)
{
//Declaração de matriz 5x1
int matnum[5];

Prof° José Marcelo Traina Chacon 61


int matdec[5];
int i,j,posmat;
//Leitura dos números
matnum[0]=StrToInt(EdtNum1->Text);
matnum[1]=StrToInt(EdtNum2->Text);
matnum[2]=StrToInt(EdtNum3->Text);
matnum[3]=StrToInt(EdtNum4->Text);
matnum[4]=StrToInt(EdtNum5->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
matdec[posmat]=matnum[i];
}
//Mostra o resultado
PnlNum1->Caption = matdec[0];
PnlNum2->Caption = matdec[1];
PnlNum3->Caption = matdec[2];
PnlNum4->Caption = matdec[3];
PnlNum5->Caption = matdec[4];
}
//--------------------------------------------------------------------
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

Prof° José Marcelo Traina Chacon 63


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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

void __fastcall TForm1::Button1Click(TObject *Sender)


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

void __fastcall TForm1::Button2Click(TObject *Sender)


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

Prof° José Marcelo Traina Chacon 65


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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

void __fastcall TForm1::Button1Click(TObject *Sender)


{
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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

void __fastcall TForm1::Button1Click(TObject *Sender)


{
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;
}
//-------------------------------------------------------------------- ------

Prof° José Marcelo Traina Chacon 67


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;

Prof° José Marcelo Traina Chacon 69


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

Prof° José Marcelo Traina Chacon 71


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
if (Expressão teste)
{
Instrução;
:
Instrução N;
}

Prof° José Marcelo Traina Chacon 73


Exemplo:

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

#include <vcl.h>
#pragma hdrstop

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

void __fastcall TForm1::Button1Click(TObject *Sender)


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

if (Expressão teste)
Instrução;
else
Instrução;

ou
if (Expressão teste)
{
Instrução;
:
Instrução N;
}
else
{
Instrução;
:
Instrução N;
}

Exemplo:

Prof° José Marcelo Traina Chacon 75


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

#include <vcl.h>
#pragma hdrstop

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

void __fastcall TForm1::Button1Click(TObject *Sender)


{
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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

void __fastcall TForm1::Button1Click(TObject *Sender)


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

Prof° José Marcelo Traina Chacon 77


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

Prof° José Marcelo Traina Chacon 79


Exemplo:

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

#include <vcl.h>
#pragma hdrstop

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

void __fastcall TForm1::Button1Click(TObject *Sender)


{
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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)

Prof° José Marcelo Traina Chacon 81


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

void __fastcall TForm1::Button1Click(TObject *Sender)


{
int N, I, R;
AnsiString N1, I1, R1;
ListBox1->Items->Clear();
N = StrToInt(Edit1->Text);
I = 1;
while (I <= 10)
{
R = N * I;
N1 = IntToStr(N);
I1 = IntToStr(I);
R1 = IntToStr(R);
ListBox1->Items->Add(N1 + " X " + I1 + " = " + R1);
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"
//-------------------------------------------------------------------- -----
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- -----
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- -----

void __fastcall TForm1::Button1Click(TObject *Sender)


{
int N, I, R;
AnsiString N1, I1, R1;
ListBox1->Items->Clear();
N = StrToInt(Edit1->Text);
I = 1;
do
{
R = N * I;
N1 = StrToInt(N);
I1 = StrToInt(I);
R1 = StrToInt(R);
ListBox1->Items->Add(N1 + " X " + I1 + " = " + R1);
I++;
}
while (I <= 10);
Edit1->SetFocus();
}

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

Prof° José Marcelo Traina Chacon 83


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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: 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);
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
int N;
N = StrToInt(Edit1->Text);
Fatorial(N);
Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------

Prof° José Marcelo Traina Chacon 85


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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------

void __fastcall TForm1::Button1Click(TObject *Sender)


{

Prof° José Marcelo Traina Chacon 87


float MD[8];
float SOMA = 0, MEDIA;
int I;
AnsiString FORMATO;
MD[0] = StrToFloat(Edit1->Text);
MD[1] = StrToFloat(Edit2->Text);
MD[2] = StrToFloat(Edit3->Text);
MD[3] = StrToFloat(Edit4->Text);
MD[4] = StrToFloat(Edit5->Text);
MD[5] = StrToFloat(Edit6->Text);
MD[6] = StrToFloat(Edit7->Text);
MD[7] = StrToFloat(Edit8->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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
int A[4][5], B[4][5];
TForm1 *Form1;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
void Limpa()
{
Form1->Edit1->Text = "";
Form1->Edit2->Text = "";
Form1->Edit3->Text = "";
Form1->Edit4->Text = "";
Form1->Edit5->Text = "";
Form1->Edit6->Text = "";
Form1->Edit7->Text = "";
Form1->Edit8->Text = "";
Form1->Edit9->Text = "";
Form1->Edit10->Text = "";
Form1->Edit11->Text = "";
Form1->Edit12->Text = "";
Form1->Edit13->Text = "";
Form1->Edit14->Text = "";
Form1->Edit15->Text = "";
Form1->Edit16->Text = "";
Form1->Edit17->Text = "";
Form1->Edit18->Text = "";
Form1->Edit19->Text = "";
Form1->Edit20->Text = "";
Form1->Edit21->Text = "";
Form1->Edit22->Text = "";

Prof° José Marcelo Traina Chacon 89


Form1->Edit23->Text = "";
Form1->Edit24->Text = "";
Form1->Edit25->Text = "";
Form1->Edit26->Text = "";
Form1->Edit27->Text = "";
Form1->Edit28->Text = "";
Form1->Edit29->Text = "";
Form1->Edit30->Text = "";
Form1->Edit31->Text = "";
Form1->Edit32->Text = "";
Form1->Edit33->Text = "";
Form1->Edit34->Text = "";
Form1->Edit35->Text = "";
Form1->Edit36->Text = "";
Form1->Edit37->Text = "";
Form1->Edit38->Text = "";
Form1->Edit39->Text = "";
Form1->Edit40->Text = "";
Form1->Edit1->SetFocus();
return;
}
//-------------------------------------------------------------------- ------

void Entrada()
{
A[0][0] = StrToInt(Form1->Edit1->Text);
A[0][1] = StrToInt(Form1->Edit2->Text);
A[0][2] = StrToInt(Form1->Edit3->Text);
A[0][3] = StrToInt(Form1->Edit4->Text);
A[0][4] = StrToInt(Form1->Edit5->Text);
A[1][0] = StrToInt(Form1->Edit6->Text);
A[1][1] = StrToInt(Form1->Edit7->Text);
A[1][2] = StrToInt(Form1->Edit8->Text);
A[1][3] = StrToInt(Form1->Edit9->Text);
A[1][4] = StrToInt(Form1->Edit10->Text);
A[2][0] = StrToInt(Form1->Edit11->Text);
A[2][1] = StrToInt(Form1->Edit12->Text);
A[2][2] = StrToInt(Form1->Edit13->Text);
A[2][3] = StrToInt(Form1->Edit14->Text);
A[2][4] = StrToInt(Form1->Edit15->Text);
A[3][0] = StrToInt(Form1->Edit16->Text);
A[3][1] = StrToInt(Form1->Edit17->Text);
A[3][2] = StrToInt(Form1->Edit18->Text);
A[3][3] = StrToInt(Form1->Edit19->Text);
A[3][4] = StrToInt(Form1->Edit20->Text);
}
//-------------------------------------------------------------------- ------

void Saida()
{
Form1->Edit21->Text = IntToStr(B[0][0]);
Form1->Edit22->Text = IntToStr(B[0][1]);
Form1->Edit23->Text = IntToStr(B[0][2]);
Form1->Edit24->Text = IntToStr(B[0][3]);
Form1->Edit25->Text = IntToStr(B[0][4]);
Form1->Edit26->Text = IntToStr(B[1][0]);
Form1->Edit27->Text = IntToStr(B[1][1]);
Form1->Edit28->Text = IntToStr(B[1][2]);
Form1->Edit29->Text = IntToStr(B[1][3]);
Form1->Edit30->Text = IntToStr(B[1][4]);
Form1->Edit31->Text = IntToStr(B[2][0]);
Form1->Edit32->Text = IntToStr(B[2][1]);
Form1->Edit33->Text = IntToStr(B[2][2]);
Form1->Edit34->Text = IntToStr(B[2][3]);
Form1->Edit35->Text = IntToStr(B[2][4]);
Form1->Edit36->Text = IntToStr(B[3][0]);
Form1->Edit37->Text = IntToStr(B[3][1]);
Form1->Edit38->Text = IntToStr(B[3][2]);
Form1->Edit39->Text = IntToStr(B[3][3]);
Form1->Edit40->Text = IntToStr(B[3][4]);
}
Puc - Campinas

//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Limpa();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
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();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
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();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
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();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button5Click(TObject *Sender)
{
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();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button6Click(TObject *Sender)
{
int SOMAT, LIMITE, I, J, K;
Entrada();
for (I = 0; I <= 3; I++)

Prof° José Marcelo Traina Chacon 91


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();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button7Click(TObject *Sender)
{
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:

Prof° José Marcelo Traina Chacon 93


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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------------- ------
struct CadAluno
{
AnsiString NOME;
float NOTA[4];
float MEDIA;
};

struct CadAluno ALUNO[8];


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

__fastcall TForm1::TForm1(TComponent* Owner)


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

void LimpaTela()
{
Form1->Edit1->Text = "";
Form1->Edit2->Text = "";
Form1->Edit3->Text = "";
Form1->Edit4->Text = "";
Form1->Edit5->Text = "";
Form1->Label7->Caption = "";
Form1->Edit1->SetFocus();
}

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->Edit3->Text = FormatFloat("#0.00", ALUNO[POSICAOATUAL].NOTA[1]);
Form1->Edit4->Text = FormatFloat("#0.00", ALUNO[POSICAOATUAL].NOTA[2]);
Form1->Edit5->Text = FormatFloat("#0.00", ALUNO[POSICAOATUAL].NOTA[3]);
Form1->Label7->Caption = FormatFloat("#0.00", ALUNO[POSICAOATUAL].MEDIA);
Form1->Edit1->SetFocus();
Puc - Campinas

return(0);
}

void __fastcall TForm1::Button1Click(TObject *Sender)


{
int CONTA;
float SOMA;
if (I <= 7 && ALUNO[I].NOME == "")
{
ALUNO[I].NOME = Edit1->Text;
ALUNO[I].NOTA[0] = StrToFloat(Edit2->Text);
ALUNO[I].NOTA[1] = StrToFloat(Edit3->Text);
ALUNO[I].NOTA[2] = StrToFloat(Edit4->Text);
ALUNO[I].NOTA[3] = StrToFloat(Edit5->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");
}
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
int J;
ALUNO[I].NOME = "";
for (J = 0; J <= 3; J++)
ALUNO[I].NOTA[J] = 0;
ALUNO[I].MEDIA = 0;
LimpaTela();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
if (I < 7)
{
I++;
ExibeRegistro(I);
}
else
{
ShowMessage("Chegou no fim");
Edit1->SetFocus();
}
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
if (I > 0)
{
I--;
ExibeRegistro(I);
}
else
{
ShowMessage("Chegou no começo");
Edit1->SetFocus();
}
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button5Click(TObject *Sender)

Prof° José Marcelo Traina Chacon 95


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

Prof° José Marcelo Traina Chacon 97


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);
: : :

Prof° José Marcelo Traina Chacon 99


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"
//-------------------------------------------------------------------- ------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
struct CadAluno
{
char NOME[50];
float NOTA[4];
float MEDIA;
};
FILE *arquivo; //ponteiro de arquivo
CadAluno ALUNO;
//-------------------------------------------------------------------- ------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------------------------------- ------
void LimpaTela()
{
Form1->Edit1->Text = ""; Form1->Edit2->Text = "";
Form1->Edit3->Text = ""; Form1->Edit4->Text = "";
Form1->Edit5->Text = ""; Form1->ListBox1->Items->Clear();
Form1->Edit1->SetFocus();
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
//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);
ALUNO.NOTA[1] = StrToFloat(Edit3->Text);
ALUNO.NOTA[2] = StrToFloat(Edit4->Text);
ALUNO.NOTA[3] = StrToFloat(Edit5->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();
}
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
//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);
}
}
//-------------------------------------------------------------------- ------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Close();
}
//-------------------------------------------------------------------- ------

Prof° José Marcelo Traina Chacon 101


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:

Prof° José Marcelo Traina Chacon 103


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.

Prof° José Marcelo Traina Chacon 105


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.

Prof° José Marcelo Traina Chacon 107


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.

Prof° José Marcelo Traina Chacon 109


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:

Prof° José Marcelo Traina Chacon 111


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:

Prof° José Marcelo Traina Chacon 113


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.

Prof° José Marcelo Traina Chacon 115


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.

Prof° José Marcelo Traina Chacon 117


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.

Prof° José Marcelo Traina Chacon 119