visual basic

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Microsoft Visual Basic 4.0 1
 
 
 
Módulo 1 
 
Criando Aplicações 
Visual Basic 
 
 
 
 1.1 Programação Procedural Versus Programação 
 Orientada a Eventos 
 
 
 Na programação procedural, ou seja, baseada nas chamadas de 
procedimentos/rotinas, a aplicação em si inicia na primeira linha do código e 
segue um fluxo determinado pelo próprio programa, durante a sua execução. 
 Devido a essa característica, o usuário se vê amarrado à forma de 
trabalho da aplicação. 
 Na programação orientada a eventos, as ações do usuário (comumente 
denominadas eventos) determinam o fluxo de execução do programa, ou seja, 
qual procedimentos/rotina será chamada. 
 
 Isso significa que um programa desenvolvido com base nessa técnica, 
as chamadas das rotinas dependem dos eventos que ocorrem, em outras 
palavras, dependem do que o usuário fará ou não. 
 
 Portanto, com base nisso, podemos definir um evento como sendo uma 
ação reconhecida por um controle, que nada mais é que um objeto adicionado 
ao formulário. Os diversos controles do Visual Basic (campos de entrada, lista 
de opções, caixas de seleção, etc.) reconhecem e respondem a um conjunto 
predefinido de eventos. 
 
 
 Para que um controle responda a um evento de 
uma forma particular, você deverá escrever um 
procedimento na linguagem Visual Basic e atribuir 
esse código ao evento desejado. 
 
 
 
 Por exemplo, você pode escrever uma rotina para avançar para o 
próximo registro de uma tabela de dados assim que o botão identificado pela 
Microsoft Visual Basic 4.0 2
legenda Avança de um formulário for pressionado. Você então atribui o nome 
dessa rotina ao evento Click do botão. Assim, toda vez que o botão for 
pressionado através de um clique do mouse, a rotina será chamada. Após o 
término de sua execução, haverá o retorno automático ao formulário. 
 
 Podemos perceber então que o primeiro passo no desenvolvimento de 
uma aplicação no Visual Basic consiste na criação dos formulários, aplicando-
lhes os controles (botões de ação, menus, caixas de listagem, caixas de 
combinação, etc.). 
 Após isso passamos ao desenvolvimento das rotinas que serão 
vinculadas aos controles do formulário. 
 
 Note que essa técnica difere do processo antigo, em que primeiro o 
programador definia o que seria feito pelo programa (desenvolvia as rotinas), 
para depois pensar na interface com o usuário. Agora o mesmo programador 
sentir-se-á mais livre da árdua tarefa de elaboração dessa interface, já que o 
Visual Basic executa a maior parte do processo, tendo assim mais tempo para 
se concentrar nas rotinas principais do programa. Isso torna a tarefa de 
desenvolvimento de aplicações mais produtiva. 
 
 Do lado do usuário, um programa orientado a eventos é mais fácil de 
assimilar e utilizar, pois ele reflete a maneira como uma pessoa trabalharia no 
mundo real. Não há necessidade de se adaptar ao aplicativo. 
 
 
 1.2 Criando um programa Visual Basic 
 
 Prática : 
 
 Adicionar no formulário : 
 
 1 command : Propriedade Caption = &OK 
 1 Label : Propriedade Caption = Nome 
 1 Textbox : Limpar Propriedade Text 
 1 Label : Propriedade Caption = Endereço 
 1 Textbox : Limpar Propriedade Text 
 
 
 Nomeá-los :Na janela de propriedades colocar no campo Name o nome 
com o prefixo indicativo do tipo de objeto. 
 
 
 
 
 
 
Microsoft Visual Basic 4.0 3
Exemplos: 
 
Objetos Prefixo Exemplo 
form frm frm_cliente 
check box chk chkapenasleitura 
combo box cbo cboidioma 
image img imgicon 
label lbl lblnome 
menu mnu mnufileopen 
text box txt txtnome 
 
 
 
Dica: Para chamar o Help clique no ícone e tecle F1 
 
 
 
 1.3 Algumas Propriedades 
 
 Podemos defini-las em tempo de projeto ou em tempo de execução: 
 
• Tempo de Projeto : No objeto lblnome - clique sobre o objeto uma vez. 
 Propriedade caption : vai para janela de propriedades. 
 Resultado : &NOME ⇒ NOME 
 
( Tecla de Atalho ALT+N ) 
 
• Tempo de Execução : No objeto txtnome - dê um double clique no objeto. 
No evento txtnome_click( ) - colocar : 
 txtnome.text = “BOCA” ou lblnome.caption = 
txtnome.text 
 
 
 Sempre: <nome objeto.propriedade> = <valor>. 
 
 
 
 Executar ⇒ Clicar sobre o Label Nome. 
 
 
 No objeto Form colocar : 
Caption exemplo 
Name frmexemplo 
Backcolor ( escolher ) 
Fillstyle ( escolher ) 
Microsoft Visual Basic 4.0 4
 
 
Uma proprieddade de um objeto1, pode ser alterada 
em tempo de execução por outro objeto2 
 
 
 
 1.4 Métodos 
 
 
 Os métodos determinam a realização de uma ação para um determinado 
objeto. Essa ação quem define é o programador. 
 
Exemplos : 
 
 txtnome.setfocus { posiciona o ‘foco’ para a caixa de texto do 
 objeto txtnome}. 
 
 lblcodigo.move 0,0 { posiciona o objeto lblcodigo para as 
 coordenadas 0,0}. 
 
 txtfrase.textwidth { retorna o tamanho da string do objeto 
txtfrase}. 
 
 frmcliente.hide { esconde, mais permanece na memória 
 principal, o objeto frmcliente}. 
 
 
 
 
 
 
 1.5 Eventos 
 
 É uma ação reconhecida por um formulário ou por um controle, o agente 
da ação pode ser : o usuário ou o código. 
 
Exemplos : 
 
 click 
 dblclick 
 keypress 
 load 
 gotfocus 
 lostfocus 
 
Microsoft Visual Basic 4.0 5
 1.6 Formulários e Controles Básicos 
 
 Formulários 
 
 O usuário interage com os controles no formulário para obter resultados 
 
 
 Algumas Propriedades para Formulários 
 
 backcolor ⇒ cor do fundo 
 borderstyle ⇒ estilo da moeda 
 caption ⇒ cabeçalho 
 name ⇒ nome do objeto 
 
 
 Alguns Métodos para Formulários 
 
 hide ⇒ esconde 
 nome ⇒ movimenta o formulário 
 print ⇒ imprime 
 setfocus ⇒ ativa o formulário 
 show ⇒ mostra na tela o formulário ( semelhante 
 chamada de rotina ). 
 
 
 Alguns Eventos para Formulários 
 
 click ⇒ 1 click 
 dblclick ⇒ 2 clicks 
 gotfocus ⇒ quando ele ganha o foco 
 load ⇒ carrega 
 mousedown ⇒ 1 click para baixo 
 mouseup ⇒ 1 click para cima ( larga o botão ) 
 unload ⇒ descarrega 
 
 
 
 
Obs. : Para obter mais informações, clique no formulário e tecle <F1>. 
 
 
 
Microsoft Visual Basic 4.0 6
 Controle Label 
 
 
 Mostra uma informação estática ( um rótulo). 
 
 Exemplo : Fornecer instruções ao usuário. 
 
 Nome 
 
 ↑ ↑ 
 label textbox 
 
 
 Algumas Propriedades 
 
 caption ⇒ rótulo 
 font ⇒ tipo de letra 
 autosize ⇒ tamanho automático 
 appearance ⇒ aparência (2D,3D) 
 
 Alguns Eventos (mais usados) 
 
 click 
 dblclick 
 
 
 
 Controle Textbox 
 
 Usado para obter informação do usuário. 
 
 
 
Obs. : Você pode utilizar o textbox em conjunto com o controle 
 data, para exibir informações de um Banco de Dados 
 
 
 
 Algumas Propriedades 
 
 multiline ⇒ mais de uma linha 
 passwordchar ⇒ senha ( **** ) 
 Alguns Métodos 
Microsoft Visual Basic 4.0 7
 
 move ⇒ move o objeto 
 setfocus ⇒ deixa o objeto ativo 
 
 
 Alguns Eventos 
 
 change ⇒ qualquer alteração no campo 
 click ⇒ evento clique 
 gotfocus ⇒ evento ganho de foco 
 
 
 
 Controle Commandbutton 
 
 É utilizado para invocar uma ação. A maioria dos formulários possuem 
os controles OK e CANCEL 
 
 
 Algumas Propriedades 
 
 visible ⇒ visível ou não 
 default ⇒ irá indicar que o botão é o que irá ficar ativo 
 inicialmente quando o formulário for lido. ( note 
 que deverá existir apenas um controle de 
 comando default por formulário. 
 
 
 Controle Combobox 
 
 Permite que você selecione uma opção existente em uma lista pre-
determinada, digitando-os em uma caixa de texto associada a esta lista 
 
 
 Data 
 
 Permite acessar dados
armazenados em um arquivo de Banco de 
Dados. 
 
 
 
 Algumas Propriedades 
Microsoft Visual Basic 4.0 8
 
 editmode 
 readonly 
 top 
 database 
 
 
 Menu 
 
 Permite a criação de menus personalizados para a sua aplicação, 
deixando-a com uma aparência mais profissional. 
 
 
 Algumas Propriedades 
 
 appearance 
 name 
 caption 
 index 
 
 
 Evento ( único ) 
 
 click 
 
 
 Ole Container 
 
 Insere no formulário outros aplicativos ( som, .doc, planilha excel, etc). 
 
 
 Picture Box 
 
 O controle picture box é utilizado para exibir imagens de arquivos 
bitmap, icon e metafile. 
 
 
 Timer 
 
 Permite a você executar certas partes de seu código a intervalos de 
tempo. ( Background ) 
 
 Exemplo : A cada ‘ t ‘ segundos você pode verificar se foi realizada a 
inclusão de um nome ou você pode inserir a hora atual. 
Microsoft Visual Basic 4.0 9
 
 
File List Box 
 
 Apresenta uma caixa de listagem de itens. Seu ícone no toolbox 
corresponde à figura de uma folha com a ponta direita superior dobrada. Adiante 
faremos um exercício para melhor entendermos esse controle. 
 
 
 
 
 Prática 1 
 
 
 O Objetivo desta prática é fazer com que o aluno se familiarize com o 
ambiente e obtenha conceito básicos dos objetos do Visual Basic. 
 
 Vamos simular um pequeno editor de texto para que você entenda como 
o controle Timer vai realizando tarefas em segundo plano (background). 
 
 Dentro do seu aplicativo. Inclua no formulário : 
 
1 textbox propriedades ⇒ multiline = true 
 name = txtedit 
 scrollbar = 2-vertical 
 text = <apaga> 
 
1 timer propriedades⇒ interval = 1000(ms), 
 name = timer 
 
1 label propriedades ⇒ caption = <apagar> 
 name = lbltime 
 
 
 
 Na seção General (geral) inclua o seguinte código: 
 
 Public tempo as date 
 
 No procedimento sub form_load() inclua: 
 
 tempo = now 
 
 No procedimento timer_timer inclua: 
 
Microsoft Visual Basic 4.0 10
 lbltime.caption = format(now-tempo, “long time”) 
 
 Execute sua aplicação. 
 
 
 
 Prática 2 
 
 
 
 Para vermos como o controle FileListBox funciona, vamos fazer o 
seguinte: 
 
 Crie um objeto FileListBox em um novo formulário e dê a ele o Nome = 
File1 (Já é o nome default dele!). 
 Depois insira o seguinte código no evento click do formulário: 
 
 
 
Private Sub Form_Click () 
 
Dim nome As String, I As Integer, Msg As String ' Declarando variaveis. 
 
 File1.Pattern = "Arquivo.*" ' Setando a forma geral do nome do arquivo 
 
 For I = 1 To 8 ' oito vezes. 
 nome = "Arquivo." & I 
 Open nome For Output As FreeFile ' cria um arquivo vazio. 
 File1.Refresh ' abre e atualiza o file list box. 
 Close ' fecha ao arquivo. 
 Next I 
 
 Msg = "Tecle OK para remover os arquivos criados." 
 MsgBox Msg ' mostra mensagem. 
 Kill "Arquivo.*" ' Remove os arquivos de teste. 
 File1.Refresh ' atualiza o filelistbox. 
 
 
End Sub 
 
 Agora execute a aplicação. 
 
 Prática 3 
 
 
• Crie um formulário (form) {nomeie, escolha um caption} 
Microsoft Visual Basic 4.0 11
 
• Insira um textbox e um label {nomear, limpar textos} 
 
• No evento form_mousemove inclua o seguinte código: 
 
 Fillcolor = qbcolor (int (rnd * 15)) ‘ sortea-se uma cor para o fundo da 
 ‘circunferência 
 Fillstyle = int(rnd * 8) ‘ sortea-se um grid para a circunf. 
 Circle (x,y), 250 ‘ desenha um círculo 
 
 
 No evento Textbox_change() inclua: 
 
 Label_caption = textbox.text ‘o que for escrito no textbox sairá no 
caption ‘ do label 
 
 
 
 Prática 4 
 
 
 
• Crie um form {nome:login} 
 
• Desenhe o seguinte layout 
 
 
 Forneça seu nome e sua senha para logar: 
 
 Nome OK Command ⇒ cmd Ok 
 cmd 
Cancela 
 Senha Cancelar 
 
 
 
 
 Label Textbox ⇒ txtnome 
 txtsenha 
 
 
 
Obs .: Nomear todos os objetos 
 Limpar textos dos texbox’s 
 
Microsoft Visual Basic 4.0 12
 
 Inserir Código : 
 
 
cmdcancela_click() 
 msgbox “Esse botão cancela a aplicação” 
 end 
 
 
cmdok_click() 
 
 msgbox “Nome do usuário = “ & txtnome.text & “, senha = “& txtsenha.text 
 
txtsenha_change() 
 If txtnome.text<> “ ” and txtsenha.text<> “ “ 
 then cmdok.enable = true 
 endif 
 
txtnome_change() 
 If txtnome.text <> “ “ and txtsenha.text <> “ “ 
 then cmdok.enable= true 
 endif 
 
 
 
 
 Prática 5 
 
 
 
 
 Vamos fazer um programa em Visual Basic que calcule o número de 
dias (aproximado) vividos pelo usuário após ele ter fornecido a idade. 
 
 Adicione a um formulário (abra um novo projeto) 4 label’s, 2 textbox’s e 2 
command’s, conforme a figura abaixo : 
 
 
 
 
 
 Form1 
 
 
 Label1 Text1 
 
Microsoft Visual Basic 4.0 13
 Label2 Text2 
 
 
 Comand1 Comand2 
 
 Label3 
 
 Label4 
 
 
 
 A seguir ajuste as propriedades conforme a tabela a seguir : 
 
 
Objeto Propriedade Valor 
Label1 Autosize 
Caption 
Name 
TRUE 
Entre com seu nome : 
lblNome 
Label2 Autosize 
Caption 
Name 
TRUE 
Entre com sua idade : 
lblidade 
Label3 Autosize 
Caption 
Name 
TRUE 
(nenhum) 
lblNomeResposta 
Label4 Autosize 
Caption 
Name 
TRUE 
(nenhum) 
lblidadeResposta 
text1 Name 
Text 
txtNome 
(nenhum) 
text2 Name 
Text 
txtIdade 
(nenhum 
Command1 Caption 
Name 
Default 
&OK 
btnOK 
TRUE 
Command2 
 
 
Caption 
Name 
 
&Cancela 
btnCancela 
 
Form1 Caption 
Name 
Dias vividos 
Idade 
 
 
 
Obs : A propriedade “default” do objeto command1 está setada em “TRUE” 
para que inicialmente, quando o usuário teclar ENTER, acione o botão OK. 
 
 
Microsoft Visual Basic 4.0 14
 
 A seguir inserir o código 
 
 btnOK_click() 
 
 DIM idade as integer, dias as long 
 idade = val(txtidade.text) 
 dias = idade * 365 
 lblNomeResposta.caption = txtnome.text 
 lblidadeResposta.caption = “Você viveu até hoje aproximadamente “ 
 &dias& “dias.” 
 
 
 btnCancela_click() 
 end 
 
 
 
 Para executar : 
 
1. 4 
2. Criando um .EXE 
• Selecione opção Make EXE File do menu File. 
 
• Escolha Options. 
 
• No quadro Version Number podemos entrar com o número da versão 
do programa. 
 
• No quadro application podemos informar o nome do programa ou um 
ícone. 
 
• No quadro version information podemos comentar o programa. 
 
Clique OK duas vezes depois execute o programa através da pasta onde foi 
gerado o executável. 
 
 
 
 1.7 Criando Rotinas para Validação de Dados 
 
 
 
Como fazer para inibir a entrada de dados numéricos em um textbox alfabético 
e/ou a entrada de
dados alfabéticos em um textbox numérico ? 
 
Microsoft Visual Basic 4.0 15
 
 
 Faça o seguinte, crie um novo formulário com apenas um objeto (um 
textbox) e no procedimento Keypress (para achá-lo clique sobre a seta da caixa 
de combinação denominada Proc) do objeto textbox e insira o código: 
 
 If keyascii >= asc(“0”) and keyascii <= asc(“9”) then keyascii = 0 
 
 Isso irá inibir a entrada de dados numéricos. 
 
 Asc(X) - retorna a ordem de X na tabela ascii, então, se o caractere 
teclado estiver entre 0 e 9 o campo é realimentado. 
 
 Para inibir entrada alfabética, insira o código a seguir em 
txtidade_keypress() : 
 
 If keyascii < asc(“0”) or keyascii > asc(“9”) then keyascii = 0 
 
 Para convertermos caracteres alfabéticos, por exemplo nomes de 
pessoas, para maiúsculos fazemos: 
 
 Private Sub Text1_KeyPress(KeyAscii As Integer) 
 
 If KeyAscii >= Asc("0") And KeyAscii <= Asc("9") Then 
 
 KeyAscii = 0 
 
 ElseIf KeyAscii >= Asc("a") And KeyAscii <= Asc("z") Then 
 
 KeyAscii = KeyAscii - 32 
 
 End If 
 
 
 
 
Módulo 2 
 
Trabalhando com 
Formulários 
 
 
 
Microsoft Visual Basic 4.0 16
 Cada formulário na sua aplicação é gravado com a extensão .FRM e 
contém: 
 
• As instâncias das propriedades do formulário e do controle. 
 
• Declaração das variáveis ao nível de formulário. 
 
Procedimentos e módulo “General”. {O código situado neste módulo pode ser 
“visto” por todos os procedimentos do formulário} 
 
 
 
 2.1 Configurando o Ambiente de Trabalho 
 Menu Tools/Options 
 
 
 Ambiente (Environment) 
 
 
 Grid do formulário(Form design grid) : determina o espaçamento do grid 
do formulário. 
 
 Janelas superiores(Windows on top) : Determina quais janelas sempre 
serão mostradas durante o projeto. 
 
 Exige declarações de variáveis(Require variable declaration) : Determina 
a obrigatoriedade de declaração de variáveis (cuidado !!!) 
 
 Checagem automática de sintaxe (Auto sintaxe check) : quando 
permitida fornece correção ao código durante implementação. 
 
 
 
 Project 
 
 Startup form : Indica qual formulário deverá ser executado incialmente. 
 
 
 
 
É comum o programador ter mais de um formulário 
em umaplicativo e com isso se esquecer de setar o início da 
execução para o formulário inicial. Vamos prestar atenção. 
 
 
Microsoft Visual Basic 4.0 17
 
 
 
 
 
 Editor 
 
 
 Fonte(Font) : Determina a fonte usada nos códigos. 
 Tamanho(Size) : Determina o tamanho da fonte usada nos códigos. 
 
 Cor do código(code color) : determina a cor do código. 
 
 
 2.2 Interagindo com o Usuário 
 
 
 2.2.1 Função MSGBOX 
 
 
 Mostra informações ou questionamento ao usuário. 
 
 Sintaxe : 
 
 MSGBOX (Mensagem, [botão],[Título do Botão]) 
 
 Mensagem - Informação enviada ao usuário. 
 
 Botão - Tipo de caixa de diálogo + tipo de ícone. 
 
 
Valor Tipo de Ícone 
16 ⊗ 
32 ? 
48 ! 
64 i 
 
 
 
Valor Tipo de Caixa 
0 OK 
1 OK, Cancela 
2 Aborta, Retorna, Ignora
Microsoft Visual Basic 4.0 18
3 Sim, Não Cancela 
4 Sim e Não 
5 Retorna e cancela 
 
 
 
 
 
Valor Botão Default Ativo 
0 1° Botão 
256 2° Botão 
512 3° Botão 
 
 
 
 A função MSGBOX irá retornar um valor baseado no tipo de caixa 
escolhida. 
 
 
Botão Valor(constantes) 
OK vbok(1) 
Cancela vbcancel(2) 
Aborta vbabort(3) 
Retorna vbretry(4) 
Ignore vbignore(5) 
Yes vbyes(6) 
No vbno(7) 
 
 
Exemplo : 
 
 Inserir o seguinte código em um objeto cmdaqui com caption = clique 
aqui. 
 
 
 Clique Aqui 
 
 
 No evento click do objeto cmdaqui insira o código 
 
 
Private Sub cmdaqui_Click() 
 
Dim Resposta As Integer 
 
Microsoft Visual Basic 4.0 19
 Resposta = MsgBox("quer continuar?", 4 + 48 + 256, "mensagem") 
 
 If Resposta = vbYes Then MsgBox "Escolheu SIM", 0 + 48 + 0, "Resultado" 
 Else MsgBox "Escolheu NÃO", 0 + 48 + 0, "Resultado" 
 End Sub 
 2.2.2 Caixa de Entrada (INPUTBOX Function) 
 
 
 Esta função fornece um meio fácil de obter informações do usuário. É 
semelhante ao controle textbox, difere na emissão de uma caixa de diálogo. 
 
 
 Sintaxe : INPUTBOX (Mensagem, Título da caixa, Mensagem Default) 
 
 Exemplos: 
 
• Crie um objeto command (cmd) 
 
• No evento Dbclick insira o código 
 
 Private Sub Form_DblClick() 
 
 Dim arquivo As String 
 
 
 arquivo = InputBox("Entre com o nome do arquivo", "Abrir Arquivo", "C:\") 
 MsgBox "Arquivo " & arquivo & " aberto ! " 
 
 End Sub 
 
 
 
 
Dica : Para mais informações, veja “INPUTBOX” no Help 
 
 
 
 
 2.3 Gerenciando Formulários 
 
 
 Na maioria dos aplicativos a interface com o usuáro é composta por 
mais de um formulário. 
 O formulário “STARTUP” é mostrado automáticamente quando a 
aplicação VB é inicializada. 
Microsoft Visual Basic 4.0 20
 
 
 
 
 
Ação Método ou Função 
Lê um formuláro na memória mas não 
mostra na tela 
LOAD 
Lê e mostra um formulário SHOW 
Mostra um formulário já lido SHOW 
Esconde um formulário mostrado na tela HIDE 
Esconde e tira da memória um 
formulário 
UNLOAD 
 
 
 Exemplo : 
 
 
Frmform1.show Frmform1.hide 
Load Frmform1 Unload Frmform1 
 
 
 
 Formulário Modal ou Não-Modal 
 
 
 Um formulário Modal não permite que o usuário interaja com outros 
formulários da aplicação ao mesmo tempo (como o “Save File as”) 
 
 Um formulário Não-Modal permite que o usuário escolha entre os 
formulários. 
 O método Show seta um formulário como modal ou não modal. 
 
 Exemplo: 
 
 Frmform1.show vbmodeless ‘ não modal 
 Frmform1.show vbmodal ‘ modal 
 
 
 
 
Terminando uma aplicação 
 
 END faz um Unload em todos os formulários e termina a aplicação. 
 
Microsoft Visual Basic 4.0 21
 
 
 
 
 Prática 6 
 
 
 
 Faça um aplicativo que calcule raízes de um polinômio de grau dois. O 
polinômio é da forma : 
 
 AX2 + BX + C = 0 
 
 Relembrando : 
 
 A,B coeficientes da equação 
 C termo independente 
 
 Resolver uma equação do 2° grau é encontrar o valor ou os valores 
que se colocados no lugar da variável X, tornam a sentença verdadeira. 
 A fórmula para encontra as raízes (X1,X2) é a seguinte: 
 
 X = - B ± SQR( delta) , Delta = B^2 - 4AC 
 2A 
 
 Os resultados deverão ser fornecidos por outro formulário. 
 
 
 
 
 Você deverá fazer esta prática sozinho! 
 
 Mesmo sem conseguir você estará assimilando 
com maior ênfase as características da programação 
orientada a evento e os “macetes” do ambiente Visual Basic. 
 Deixe para olhar a resolução depois que você “eventualmente” se 
perdeu! 
 
 
 
 
 
 Resolução: 
 
 Passos : 
Microsoft Visual Basic 4.0 22
 
 Crie um formulário com as seguintes propriedades : 
 
 Name - Frmmain 
 Caption - Equação do 2° grau 
 
 
 
Objetos : 
 
Label 
 da Equação 
ientes A= 
 3 - Name lblB 
 Caption B= 
 - Name lblC 
o independente C= 
ular 
 
r 
 
 
 
 1 - Name lblDados
 Caption Dados
 2 - Name lblA 
 Caption Coefic 
 
 
 4 
 Caption Term
 
Command 
 
 1 - Name cmdcalc
 Caption &Calcular
 Default TRUE 
 2 - Name cmdsai
 Caption &Sair
 
 
Textbox 
 
 1 - Name TXTA 
 Text <vazio> 
Microsoft Visual Basic 4.0 23
 Maxlength 5
2 - Name TXTB 
 Text <vazio> 
 Maxlength 5 
 
 
double , delta as double, A as double, B 
 
 
 
 Raiz2 = (-(-b) - SQR(delta))/(2*A) 
 FrmResultado.txtx1.text = Raiz1 
Resultado.txtx2.text = Raiz2 
 FrmMain.Hide 
do.Show 
 Elseif Delta = 0 then 
 Raiz1 = (-(b) + SQR(delta))/(2*A) 
 FrmResultado.txtx1.text = Raiz1 
 FrmResultado.txtx2.text = Raiz2 
 FrmResultado.Show 
 Else 
 Msgbox ‘Não existem raízes reais !!!” 
 Endif 
 EndSub 
 
 CmdSair_click() 
 End 
 EndSub 
 
 
 A seguir crie outro formulário com as seguintes caracteristicas: 
Name FrmResultado 
Caption Resultado 
 
 3 - Name TXTC 
 Text <vazio>
 Maxlength 5 
 
Código 
 
 CmdCalcular_click() 
 
 DIM Raiz1 as double, Raiz2 as 
 as double, C as double 
 A = VAL (txta.text) 
 B = VAL (txtb.text) 
 C = VAL (txtc.text) 
 Delta = (B*B) - 4*A*C 
 If Delta>0 then 
 Raiz1 = (-(-b) + SQR(delta))/(2*A) 
 
 
 Frm
 
 FrmResulta
 
 
 
 
 FrmMain.Hide 
 
 
 
 
 
 
 
 
Microsoft Visual Basic 4.0 24
 
 
 
 
 
me lblX1 
 = 
 
ult TRUE 
2 
 text <vazio> 
 
 
 Depois insira o código seguinte no evento click do objeto cmdvoltar 
 
 FrmMain.txta.text = “ “ 
 FrmMain.txtb.text = “ “ 
 FrmMain.txtc.text = “ “ 
 Frmresultado.Hide 
 FrmMain.Show 
 
 Execute a aplicação !!! 
Label 
 
 1 - Na
 Caption X1
 
 2 - Name lblX2 
 Caption X2 = 
 
Command 
 1 - Name Cmdvoltar 
 Caption &Voltar 
 Defa
 
Textbox 
 
 1 - Name txtx1 
 text <vazio> 
 
 2 - Name txtx
Microsoft Visual Basic 4.0 25
Módulo 3 
 
Aspectos de Programação 
Visual Basic 
 
 
 
 
 3.1 Atribuindo Valores 
 
 
 [LET] nome_da_palavra = <valor> 
 
 
 3.3 Variáveis 
 
 
 O que são variáveis ? 
 
 Toda linguagem de programação precisa de algum lugar para armazenar 
o resultado de seus cálculos ou simplesmente para controlar o fluxo do 
programa. 
 Assim como acontece na álgebra cotidiana, as linguagens de 
programação se valem de variáveis para armazenar dados na memória do 
computador. 
 Uma variável de memória nada mais é do que uma posição da memória 
do computador reservada exclusivamente para que sejam guardadas 
informações e dados. A essa posição de memória damos um nome para 
referência dentro do nosso programa, como por exemplo, NomeCliente. 
 Quem controla qual posição de memória do computador será reservada 
é a própria linguagem e o sistema operacional, ou seja, devemos apenas nos 
preocupar em nomear e declarar as variáveis. 
 
 E já que estamos falando de variáveis, quando formos nomeá-las, 
deveremos seguir algumas regras básicas: 
 
⇒ O nome precisa iniciar com uma letra. 
 
⇒ Somente são permitidas letras, números e o caractere de sublinhado. 
 Qualquer sinal de pontuação e espaço em branco será inválido. 
 
Microsoft Visual Basic 4.0 26
⇒ No Visual Basic 4.0, os nomes podem ter até 255 caracteres de comprimento. 
Isso significa que podemos ter nomes de variáveis bem descritivos, como por 
exemplo, PrimeiroNomedoCliente. 
⇒ Não podem coincidir com uma palavra reservada do Visual Basic, como 
nomes de funções ou procedimentos. 
 
⇒ Precisam ser únicos dentro do escopo atual, ou seja, não podemos ter duas 
variáveis com o mesmo nome dentro de uma rotina, porém, entre rotinas 
diferentes, isso é perfeitamente possível. 
 
 
 Escolha nomes sugestivos para as variáveis, de tal forma que 
descrevam sua função ou conteúdo que será armazenado nelas. 
 Por exemplo para uma variável onde seria armazenado o resultado do 
cálculo do salário de um funcionário, poderíamos escrever nSalarioFunc, em vez 
de X, Y ou Z. 
 
 
 3.4 Declaração de Variáveis 
 
 
 Dim Nomedavariavel [ as tipo de dados] 
 
 
 3.5 Tipos de Dados 
 
 
 Como toda linguagem de programação, o Visual Basic também possui 
vários tipos de dados aplicáveis às varáveis, que definem quais os valores que 
essas poderão armazenar. 
 O Visual Basic 4.0 define 11 tipos de dados básicos, cada qual com suas 
características peculiares, como largura da faixa de dados, tamanho em bytes, 
etc. 
 
 A tabela a seguir relaciona todos esses tipos: 
 
 
Tipo de 
Dado 
Tamanho em Bytes Faixa de Valores 
Integer 2 Bytes - 32.768 a 32.767 
Long 4 Bytes - 2.147.483.648 a 2.147.483.647 
Single 4 Bytes - 3,402823E38 a - 1,401298E-45 (Val. 
Negativos) 
 1,401298E-45 a 3,402823E38 (Val. 
Positivos) 
Double 8 Bytes -1,79769313486232E308 a -
Microsoft Visual Basic 4.0 27
4,9406564584124E-324 
(Val. Negativos) 
4,9406564584124E-324 a 
1,79769313486232E308 
(Val. Positivos) 
Currency 8 Bytes - 922.337.203.685.477,5808 a 
 922.337.203.685.477,5807 
String 1 Byte por caractere De zero a 65.500 caracteres 
Em sistemas de 32 bits,máximo de 2E32 
caracteres. 
Byte 1 Byte 0 a 255 
Boolean 2 Bytes True (verdadeiro) ou False (falso) 
Date 4 Bytes Qualquer referência a objeto 
Variant 16 bytes + 1 byte para 
cada caractere 
Qualquer valor numérico, caractere, objeto ou 
valor nulo. 
 
 
 Os tipos de dados determinam o que você pode armazenar numa 
variável. 
 
 Por exemplo, você não pode entrar com uma expressão caractere numa 
variável do tipo numérico, nem tampouco digitar um número numa variável 
lógica. 
 
 Vejamos os detalhes dos tipos de dados mais comumente utilizados. 
 
 
 
 
 Tipos lnteger e Long 
 
 
 Esses dois tipos de dados permitem o armazenamento de valores 
numéricos inteiros, com os quais podemos efetuar cálculos e operações 
matemáticas. 
 A faixa de valores permitida para o tipo lnteger vai de -32.768 a 32.767, 
sendo portanto limitada para alguns tipos de operações. Variáveis desse tipo 
são muito úteis como contadores de loops For... Next, por serem de 
manipulação muito rápida pelo processador, pois necessitam de poucas 
instruções de máquina. 
 O tipo Long, por outro lado, abrange uma faixa muito maior de valores, da 
ordem de 2 milhões, conforme pode ser constatado pela tabela anterior. 
 
 
 
 
Microsoft Visual Basic 4.0 28
 Tipos Single e Double 
 
 
 Single e Double também são tipos de dados numéricos, porém permitem 
a manipulação de valores decimais, como pesos, unidades de medidas, etc. 
Como os tipos anteriores, podemos efetuar qualquer operação matemática com 
eles. 
 O que diferencia o tipo Single do tipo Double é a precisão nas casas 
decimais e a faixa de valores abrangida por cada um. Veja a tabela anterior 
para comparação. Variáveis do tipo Single são ditas de precisão simples, 
comumente chamadas apenas de variáveis de ponto-flutuante. Variáveis do tipo 
Double são denominadas variáveis de dupla precisão. 
 
 
 
 Tipo Currency 
 
 
 O Visual Basic possui um tipo de dado especial para tratamento de 
valores monetários, evitando-se assim erros de arredondamento durante 
cálculos matemáticos. Esse tipo de dado é chamado de Currency. Devemos 
utilizá-lo apenas para armazenamento de valores monetários. 
 Se num determinado cálculo, o valor resultante tiver mais de quatro casas 
decimais, as casas decimais extras (a partir da quinta casa) serão
truncadas. 
Assim, o número 5402,105782 será armazenado como 5402,1057 numa variável 
do tipo Currency. 
 
 
 
 Tipo String 
 
 
 O tipo de dado string é certamente o mais utilizado. Ele possibilita que 
uma sequência de caracteres seja armazenada numa variável. 
 Essa sequência de caracteres pode conter desde letras do alfabeto até 
símbolos gráficos e números, muito embora não possamos efetuar cálculos com 
os números armazenados numa sequência. Devemos envolver a cadeia de 
caracteres com aspas ("). 
 Com variáveis do tipo caractere, é possível efetuarmos algumas 
operações de comparação, concatenação (junção) de duas ou mais seqüências 
de caracteres ou extração de uma parte da seqüência. 
 
 Não é possível, porém, efetuar cálculos matemáticos e aritméticos, já que 
qualquer número armazenado numa variável desse tipo será considerado como 
uma sequência de texto e não um valor numérico. 
 
Microsoft Visual Basic 4.0 29
 Podemos determinar um tamanho máximo para urna variável do tipo 
String, simplesmente adicionando um asterisco (*) seguido por um número que 
define o tamanho máximo em caracteres. 
 
 
 
 
 
 Por exemplo, para declarar uma variável strNomeCliente com um 
tamanho máximo de 50 caracteres, você escreveria: 
 
 
 
 Dim strNomeCliente As String * 50 
 
 
 Se for armazenada uma cadeia de caracteres menor que o tamanho 
máximo especificado, a variável será preenchida com espaços em branco à 
direita para completá-la. Se por outro lado, você tentar armazenar mais 
caracteres do que o permitido, os excedentes serão descartados. 
 
 
 
 Tipo Byte 
 
 
 Variáveis do tipo Byte são também numéricas, mas somente podem 
armazenar números na faixa de O a 255. Esse tipo de variável também , é útil 
em contador de loops For... Next pequenos, cujo ciclo de repetição não 
ultrapasse 255. 
 
 
 
 Tipo Boolean 
 
 
 Uma variável do tipo Boolean pode conter apenas dois tipos de valores: 
True (verdadeiro) ou False (falso). São muito utilizadas como sinalizadores, ou 
seja, variáveis que indicam se uma determinada condição lógica retornou ou 
resultou num desses dois valores. Veja o pequeno exemplo a seguir : 
 
 Dim blnrepete As Boolean 
 blnrepete = True 
 While blnrepete 
Microsoft Visual Basic 4.0 30
 . 
 . 
 Wend 
 
 
 
 
 Tipo Date 
 
 
 Variáveis do tipo data permitem o armazenamento de valores que 
representam uma data do calendário ou um horário. Para armazenar uma data 
numa variável, especifique-a entre "#", como no seguinte exemplo: 
 
 
 dtDataVencimento = #05/06/95# 
 dthora = #05:25# 
 
 
 Com valores do tipo data é possível executarmos adição ou subtração, 
para assim calcularmos uma nova data. Por exemplo: 
 
 dtDataHoje = Now 
 dtDataAmanha = dtDataHoje + 1 
 dtDataOntem = dtDataHoje - 1 
 
 Tipo Object 
 
 
 Variáveis do tipo Object podem fazer referência a objetos definidos pelo 
Visual Basic ou mesmo campos de uma base de dados, como dados OLE ou 
binários. Elas são armazenadas em endereços de 32 bits. Para esse tipo de 
variável, precisamos utilizar o comando de atribuição Set para assinalar valores 
a ela, em não apenas o sinal de igualdade. 
 
 
 Tipo Variant 
Microsoft Visual Basic 4.0 31
 
 O dado Variant é um tipo especial, já que ele permite que qualquer valor 
seja armazenado. Se você declara uma variável mas não especifica seu tipo de 
dado, o Visual Basic automaticamente atribui a ela o tipo Variant. Assim, o dado 
que você armazenar na variável é que definirá o seu tipo naquele momento. 
 
 Podemos atribuir também um valor nulo à variáveis variant, especificando 
a palavra-chave Null à direita do sinal de igual. Diversas funções podem ser 
utilizadas para determinar qual o tipo de dado armazenado numa variável 
Variant. 
 
 
 
 3.6 Constantes 
 
 
 Agora que já falamos de variáveis, vejamos as constantes, que são o 
oposto das primeiras. 
 As constantes, diferentemente das variáveis, não podem ter seus valores 
alterados durante a execução da aplicação. Elas são utilizadas principalmente 
para fornecer maior legibilidade ao código-fonte, substituindo expressões 
numéricas ou caractere mais complexos e de difícil entendimento. 
 
 Um dos tipos de constantes mais famoso é o famigerado valor de PI 
(3,14159265358979... ). 
 Como convenção, adotamos letras maiúsculas para os nomes de 
constantes, mas isso não é regra geral. 
 Essa é uma prática comum para os programadores em C/C++, Pascal ou 
mesmo Assembly. 
 
 
 3.7 Matrizes 
 
 
 Dim NomeMatriz (n,m) As <tipo de dados> 
 
 Exemplo: 
 Dim idade(30) As integer 
 Dim nota( 60,4) As double 
 
 
 
 
 3.8 Tipos definidos pelo usuário 
 
Microsoft Visual Basic 4.0 32
 Semelhantemente às variáveis estruturadas da linguagem C/C + + ou às 
variáveis registro do Pascal, o Visual Basic oferece a capacidade de definirmos 
nossos próprios tipos de dados. 
 
 Definir um novo tipo de dado pode ser muito útil quando precisamos 
agrupar vários tipos de dados diferentes mas correlacionados numa única 
variável, facilitando assim seu tratamento. Você poderia pensar que as matrizes 
resolveriam esse problema, mas nesse caso não são tão convenientes. 
 
 Para criar uma variável com um novo tipo de dado você utiliza o comando 
Type, colocado na seção Declarations do módulo. Vejamos um exemplo 
prático, onde criaremos uma variável tipada chamada tpcliente, contendo outras 
variáveis para armazenamento do código do cliente, do endereço do cliente, 
nome da firma, cidade onde reside, salário e departamento onde trabalha. 
 
 Type tpcliente 
 
 intCodigoCliente As Integer 
 strendereco As String * 50 
 strcidade As String * 25 
 strempresa As String * 40 
 strdepto As String * 20 
 sglsalario As Single 
 
 End Type 
 
 Aqui podemos dizer que a variável tpcliente comporta-se como um 
registro completo de um banco de dados e as diversas variáveis que a 
compõem, são os campos do registro. 
 
 
 tpCliente 
 
 intCodigoCiiente 
 
 strendereco 
 
 strcidade 
 
 strempresa 
 
 strdepto 
 
 sglsalario 
 
 
Microsoft Visual Basic 4.0 33
 Após ter sido criado o tipo de dado definido pelo usuário, você deverá 
ainda declarar a(s) variável(eis) desse tipo específico, como ocorre com as 
demais variáveis: 
 
 Dim DadosCliente As tpcliente 
 
 Cada campo da variável estruturada é acessado através de uma sintaxe 
própria. Precisamos especificar a variável estruturada seguida pela variável 
campo desejada, separadas por um ponto. Por exemplo, para acessar o campo 
strEndereco, deveríamos especificar a seguinte expressão: 
 
 DadosCliente.strEndereco = "Av. Paulista, no 1815, 6o andar" 
 
 Se você tiver duas variáveis do mesmo tipo de dado definido pelo usuário, 
poderá assinalar o valor de uma à outra apenas com o sinal de atribuição (=), 
similarmente às variáveis simples. Por exemplo, suponhamos que você tenha 
criado um tipo de dado chamado ContaCorrente, e que a partir dele tenha 
declarado as variáveis ContaBanco1 e ContaBanco2. Assim você poderia 
atribuir todos os valores dos campos da variável ContaBanco1 a ContaBanco2 
através da expressão: 
 
 ContaBanco2 = Contabancol 
 
 Você pode também ter campos numa variável tipada que é uma matriz de 
dados. Por exemplo: 
 
 Type ConsumoMensal 
 strmes(12) AS String * 15 
 intconsumo(12) As Integer 
 End Type 
 
 Aqui nós temos um novo tipo de dado que nos permite entrar com os 
consumos mensais de energia elétrica, e quem sabe desenvolver um sistema 
aplicativo que nos auxiliará a economizar energia. 
 
 Um outro recurso interessante é que você pode ter uma estrutura de 
dados dentro de outra estrutura. Veja o seguinte exemplo: 
 
 Type DadosPessoais 
 strNome AS String * 20 
 strSobreNome As String * 40 
 btIdade As Byte
btEstadoCivil As Byte 
 End Type 
 
 Type DadosEndereco 
 strrua As String * 50 
 strBairro As String * 30 
Microsoft Visual Basic 4.0 34
 strCidade As String * 30 
 strEstado AS String * 2 
 End Type 
 
 
 Type Funcionário 
 DadosFuncionario As DadosPessoais 
 DadosResidencia As DadosEndereco 
 btCodigoEmpresa As Byte 
 btCodigoCargo As Byte 
 End Type 
 
 
 Type Empresa 
 strNomeEmpresa As String * 50 
 EnderecoComercial As DadosEndereco 
 End Type 
 
 
 Aqui definimos duas estruturas básicas, denominadas DadosPessoais e 
DadosEnderecos. A partir delas,pudemos montar as outras duas estruturas de 
forma mais organizada e legível. 
 
 
 Obviamente, para saber o nome do funcionário, teríamos de escrever a 
expressão: 
 
 Funcionario.DadosFuncionario.strNome = "William Pereira Alves" 
 
 
 
 
Microsoft Visual Basic 4.0 35
 
3.9 Operadores 
 
 
 
Aritméticos 
 
 
Operador Descrição 
+ Efetua a soma entre dois ou mais números 
- Efetua a subtração entre dois ou mais números 
* Efetua a multiplicação entre dois ou mais números 
/ Efetua a divisão entre dois números e resulta num número de 
ponto-flutuante 
\ Efetua a divisão entre dois números e resulta num número 
inteiro 
^ Efetua a exponênciação 
Mod Retorna o resto de uma divisão não exata entre dois números 
 
 
 
 
Lógicos 
 
 
Operador Descrição 
And Efetua a operação lógica E. Se ambas as expressões forem 
verdadeiras, então o resultado será verdadeiro 
Or Efetua a operação lógica OU. Se uma das expressões (ou 
ambas) for verdadeira, então o resultado será verdadeiro 
Not Efetua a operação lógica NÃO. Inverte o estado lógico de uma 
expressão, se ela for verdadeira, torna-a falsa e vice-versa 
Xor Efetua a operação OU EXCLUSIVO. Se uma das expressões for 
verdadeira, o resultado será verdadeiro, porém se ambas forem 
verdadeiras, o resultado será falso 
Eqv Efetua a operação de equivalência de expressões. O resultado 
será verdadeiro somente se ambas as expressões forem 
equivalentes. 
Imp Efetua a operação de implicação lógica. Retorna verdadeira se 
uma expressão implica em outra 
 
 
Tabela do operador lógico Imp 
Microsoft Visual Basic 4.0 36
A primeira expressão é A segunda expressão é O resultado será 
Verdadeiro Verdadeiro Verdadeiro 
Verdadeiro Falso Falso 
Verdadeiro Nulo Nulo 
Falso Verdadeiro Verdadeiro 
Falso Falso Verdadeiro 
Falso Nulo Verdadeiro 
Nulo Verdadeiro Verdadeiro 
Nulo Falso Nulo 
Nulo Nulo Nulo 
 
 
 
Operadores Relacionais 
 
 
Operador Descrição 
< Menor que 
> Maior que 
<= Menor que ou igual a 
>= Maior que ou igual a 
= Igual a 
<> Diferente de 
 
 
 
 String 
 
 
 “&” ou “+” ⇒ concatenam duas strings 
 msgbox “exemplo” & “concatenação” ⇒ Exemploconcatenção 
 
 
 
 
Prática 7 
 
 
 Vamos fazer uma aplicação que some dois vetores com 8 elementos do 
tipo inteiro cada um. Lembre-se que os vetores na linguagem Visual Basic inicia-
se com índice zero (0). 
 
 Crie um formulário com os seguintes objetos: 
Microsoft Visual Basic 4.0 37
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Calcular 
Entrada do vetor A 
Entrada do Vetor B 
 Ok 
 Ok 
Resultado 
cmdok 
cmdok2 
txtentrada txtentrada2 
lblentrada 
cmdcalcular 
 
 
 Tente fazer sozinho! Apenas em caso de emergência consulte a 
resolução. 
 
 
 
 
 Resolução: 
 
 Nomeie os objetos e depois insira o seguinte código: 
 
 
 Na seção General (declarations) insira: 
 
Option Explicit ‘ na parte General (declarations) 
 
 Dim vetorA(8), vetorB(8), vetorC(8) As Integer 
Microsoft Visual Basic 4.0 38
 Dim i As Integer 
 
 
 
 
 Na rotina click do botão calcular: 
 
Private Sub cmdcalcular_Click() 
 
 lblsaida.Caption = "Resultado = " 
 For i = 0 To 7 
 vetorC(i) = vetorA(i) + vetorB(i) 
 
 lblsaida.Caption = lblsaida.Caption & " " & vetorC(i) 
 Next i 
 
End Sub 
 
 
 
No evento click do primeiro botão Ok do formulário: 
 
Private Sub cmdok_Click() 
 
 If i <= 8 Then 
 
 
 vetorA(i) = Val(txtentrada.Text) 
 i = 1 + i 
 txtentrada.Text = "" 
 txtentrada.SetFocus 
 If i = 8 Then 
 
 txtentrada.Enabled = False 
 txtentrada.Text = "" 
 cmdok.Enabled = False 
 cmdok2.Enabled = True 
 txtentrada2.SetFocus 
 i = 0 
 End If 
 
 End If 
 
 No evento click do segundo botão Ok: 
 
Private Sub cmdok2_Click() 
 
Microsoft Visual Basic 4.0 39
 If i <= 8 Then 
 
 vetorB(i) = Val(txtentrada2.Text) 
 
 i = i + 1 
 txtentrada2.Text = "" 
 txtentrada2.SetFocus 
 
 If i = 8 Then 
 
 txtentrada2.Enabled = False 
 txtentrada2.Text = "" 
 cmdok2.Enabled = False 
 End If 
 
 End If 
 
End Sub 
 
 
 No evento load do formulário: 
 
Private Sub Form_Load() 
 
 
 lblentrada.Caption = "Entrada do vetor A" 
 lblentrada2.Caption = "Entrada do vetor B" 
 
End Sub 
 
 
Microsoft Visual Basic 4.0 40
 
 
Prática 8 
 
 
Fazer uma aplicação que simule uma calculadora, as operações possíveis 
serão: 
 
 + soma 
 - subtração 
 / divisão com resto 
 Mod resto 
 \ divisão com inteiro 
 ^ exponenciação 
 * multiplicação 
 
 
 
 
 Ajuste as propiedades dos objetos da seguinte forma: 
 
 frm (formulário) 
 caption = calculadora 
 icon = <escolhe um ícone> 
 name = frm calculadora 
 
 cmd (botões de comando) 
 1. name = cmdsair 
 caption = &sair 
 2. name = cmdlimpar 
 caption = &limpar 
 3. name = cmdcalcular 
 caption = &calcular 
 default = true 
 txt (caixas de texto) 
 1. name = txtresultado 
 enable = false 
 text = <vazio> 
 2. name = txtop2 
 tabindex = 2 
 text = <vazio> 
 3. name = txtop 
 tabindex = 1 
 text = <vazio> 
 3. name = textop1 
 tabindex = 0 
Microsoft Visual Basic 4.0 41
 text = <vazio> 
 
 lbl 
 1. name = lblresultado 
 captiom = resultado 
 2. name = lblanuncio 
 caption = operações : + - / mod ^ \ * 
 3. name = lbloperação 
 caption = operação 
 4. name = lbloperador2 
 caption = operador2 
 5. name = lbloperador1 
 caption = operador1 
 6. name = lbligual 
 caption = = 
 
 A seguir insira o seguinte código: 
 
cmdcalcular_click( ) 
 dim op1 as double, op2 as double, opção as string 
 op1 = val (txtop1.text) 
 op2 = val (txtop2.text) 
 opção = txtop.text 
 
 select case opção ‘nós ainda não vimos esta estrutura mas ela já nos é 
 ‘ familiar 
 
 case “+” : txtresultado.text = op1 + op2 
 case “-” : txtresultado.text = op1 - op2 
 case “/” : txtresultado.text = op1 / op2 
 case “\” : txtresultado.text = op1 \ op2 
 case “Mod” : txtresultado.text = op1 Mod op2 
 case “^” : txtresultado.text = op1 ^ op2 
 case “*” : txtresultado.text = op1 * op2 
 end select 
 cmdlimpar.setfocus 
end sub 
 
 
 No evento click do objeto cmdlimpar insira: 
 
 cmdlimpar_click( ) 
 
 txtop1.text = “ “ 
 txtop2.text = “ “ 
 txtop.text = “ “ 
 txtop1.setfocus 
Microsoft Visual Basic 4.0 42
 
No evento click do botão sair escreva: 
 
cmdsair_click( ) 
 end 
end sub 
 
 
Microsoft Visual Basic 4.0 43
Módulo 4 
 
Estruturas de 
Controle 
 
 
 
 
 Neste módulo, aprenderemos a criar estruturas de controle, que são 
importantes componentes de qualquer linguagem de programação. 
 Estas estruturas permitem que
você verifique a ocorrência de 
determinadas condições lógicas bem como reutilize blocos de código, tomando 
seu trabalho de programação mais produtivo. 
 
 
 
 Como já adiantamos a você, as estruturas de controle são uma 
importante ferramenta de programação, permitindo não só a realização de 
desvios lógicos no processamento de seu programa, mas também a reutilização 
de blocos de código existentes até que determinado resultado seja obtido. 
 
 O Visual Basic coloca à sua disposição uma série de comandos com esta 
finalidade, permitindo-lhe uma grande flexibilidade no desenvolvimento de suas 
aplicações. 
 Como você já deve estar imaginando, a melhor maneira de aprender 
como estas estruturas operam é na prática, através de um novo aplicativo que 
iremos desenvolver. 
 
 
 
 4.1 Criando o Aplicativo Estruturas de Controle 
 
 Vamos iniciar a criação de nosso aplicativo selecionando a opção New 
Project no menu File. 
 
 
 
 
 Prática 9 
 
 
 Crie um formulário com o seguinte layout: 
 
 
Microsoft Visual Basic 4.0 44
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
FOR NEXT (LABEL1) 
Início 
(label2) 
Limite 
(label 3) 
Passo 
(label 4) 
Valor Atual de Início: (label 6) 
Iniciar (command) 
ESTRUTURAS DE CONTROLE 
(label 5, sem texto) 
(Text 5) 
Text 1 Text 2 Text3 
Text 4 
Imagem 
 
 
 
 Determine as seguintes propriedades aos objetos: 
 
 
 
 
 
Vamos iniciar pelo Formulário. 
 
Propriedade Valor 
Caption Estrutura de Controle 
Name frmEstruturas 
Microsoft Visual Basic 4.0 45
 
 
 
 
 
 
 
 
 
 
Selecione agora o controle Label1: 
 
Propriedade Valor 
Alignment 2 - Center 
Caption FOR NEXT 
Font MS Sans Serif - Negrito - 14* 
Name LblTítulo 
 
 
 
 
 
* Ao selecionar o botão “...”, é aberta a janela “Fonte” onde você pode 
definir as características do texto a ser exibido. 
 
 
 
 
 
Passe agora para o controle Label2: 
 
Propriedade Valor 
Alignment 1 - Right Justify 
Caption Início: 
Name LblÍnicio 
 
 
 
 
Vamos ajustar agora o controle Text1. 
 
Propriedade Valor 
Name TxtÍnicio 
Text <apagar o valor atual> 
 
Microsoft Visual Basic 4.0 46
 
 
Selecione o controle Label3: 
 
Propriedade Valor 
Alignment 1 - Right Justify 
Caption Limite: 
Name LblLimite 
 
 
 
Passe agora para o controle Text2: 
 
Propriedade Valor 
Name TxtLimite 
Text <apagar o valor atual> 
 
 
 
 
Ajuste agora Label4: 
 
Propriedade Valor 
Alignment 1 - Right Justify 
Caption Passo: 
Name LblPasso 
 
 
 
Faça o mesmo com Text3: 
 
Propriedade Valor 
Name TxtPasso 
Text <apagar o valor atual> 
 
 
 
 
Selecionar agora Label5 e ajuste as suas propriedades conforme a tabela 
abaixo : 
 
Propriedade Valor 
Alignment 2 - Center 
Caption <apagar o valor atual> 
Name LblMsg 
Microsoft Visual Basic 4.0 47
 
 
 
 
Aproveite para alterar as propriedades do Label6 para : 
 
Propriedade Valor 
Alignment 1 - Right justify 
Caption <apagar o valor atual> 
Name Lblação 
 
 
 
Calma, agora falta pouco. Pode parecer cansativo, mas seja sincero: 
Quanto tempo você gastou para criar este aplicativo ? Uns poucos minutos não 
foi ? Pode ter certeza de que os minutos que você empenhou na criação deste 
aplicativo renderão bons conhecimentos sobre as estruturas de controle que 
estamos estudando agora. 
 
Respire fundo e passe para o próximo controle, que é o Text4. 
 
 
 
 
Faça as seguintes alterações : 
 
Propriedade Valor 
Name TxtValorAtual 
TabStop False 
Text <apagar o valor atual> 
 
 
 
 
O próximo passo será alterar o controle Text5: 
 
Propriedade Valor 
Name TxtAção 
TabStop False 
Text <apagar o valor atual> 
 
 
 
 
Complementando nosso aplicativo, altere as propriedades do controle Image1 
para o seguinte: 
Microsoft Visual Basic 4.0 48
 
 
Propriedade Valor 
BorderStyle 1 - FixedSingle 
Enabled False 
 
 
Repita o mesmo para o controle Image2 : 
 
Propriedade Valor 
BorderStyle 1 - FixedSingle 
Enabled False 
 
 
 
 
Finalmente, ajuste as propriedades do controle Command1: 
 
Propriedade Valor 
Caption &Iniciar 
Default True 
Name BtnIniciar 
 
 
 
 A única coisa que falta agora é definirmos o código que será associado ao 
botão "Iniciar" de nosso formulário, mas isto dependerá dos próximos 
assuntos que iremos aprender em seguida. 
 
 
 
 4.2 Adicionando Comentários em seu Código 
 
 
 Agora que você já está ficando com mais prática na utilização do Visual 
Basic e pouco a pouco está desenvolvendo aplicativos cada vez mais 
sofisticados, está na hora de começar a documentar as suas rotinas. 
 
 Talvez você até ache desnecessário fazer isto devido à simplicidade dos 
códigos que estamos criando, mas não custa nada documentar desde o início, 
pois é uma boa prática ir se acostumando a documentar as rotinas criadas por 
voce. 
 Lembre-se de que uma rotina que é óbvia hoje pode não ser tão óbvia 
quando você voltar a estudá-la daqui há seis meses ou um ano. 
 
Microsoft Visual Basic 4.0 49
 Imagine também que talvez outra pessoa irá analisar sua rotina no futuro, 
e que poderá ter grandes dificuldades para entender o que você fez. 
 
 
 
 
 
Documentar suas rotinas é muito importante para 
tornar seu código mais legível não só para você, mas também 
para as outras pessoas que irão analisá-lo mais tarde. 
Adotar este hábito saudável irá poupar seu tempo 
no futuro, quando será necessário relembrar por que 
 você adotou determinadas soluções técnicas 
e , não outras aparentemente mais simples. 
 
 
 
 
 
 
A Instrução REM 
 
 
 A instrução REM nada mais é do que uma abreviação da palavra Remark, 
que significa Comentário. 
 
 Você pode incluir comentários em seus códigos de duas formas: através 
da instrução REM seguida do comentário desejado, ou do apóstrofo ( ‘ ) antes 
do comentário a ser incluído. 
 
 Tudo o que estiver à direita da palavra Rem ou do sinal de apóstrofo será 
simplesmente ignorado pelo Visual Basic. 
 Quando você utilizar a instrução REM, deixe um espaço em branco entre 
esta instrução e o comentário propriamente dito, como em: 
 
 
 REM Este é um exemplo de comentário 
 
 
 Já para o apóstrofo, não é necessário deixar o espaço em branco entre o 
sinal e o comentário: 
 
 'Exemplo de comentário usando o apóstrofo 
 
 Estes comentários também podem ser utilizados em linhas de código que 
contêm outras instruções, como em: 
Microsoft Visual Basic 4.0 50
 
 Dim Teste As lnteger 'Declara a variável Teste como Inteiro 
 
 O único cuidado que deve ser tomado quando incluímos comentários em 
uma linha que contém instruções para o Visual Basic, é quando utilizamos a 
instrução REM. 
 
 Neste caso, será necessário acrescentarmos o sinal de dois pontos ( : ) 
logo após a última instrução válida, para em seguida incluirmos a instrução 
REM. Você entenderá melhor vendo o exemplo abaixo: 
 
 
 Dim Teste As lnteger: REM Não esqueça de incluir : antes de REM 
! 
 
 
 
 Note que este caso somente se aplica à utilização de REM em uma linha 
que já contém comandos. 
 
 
 
 
 
 
 
 
 
 
Este recurso é bastante útil durante a fase de 
desenvolvimento de aplicativos, pois podemos evitar 
 a execução de determinadas linhas de nosso código pelo 
 Visual Basic, sem que haja necessidade de apagarmos tais informações 
de nossas rotinas. Após os testes, basta eliminar os 
 sinais de comentário para que o Visual Basic volte a 
 interpretar as linhas de código 
 existentes. 
 
 
 
 
 Agora que já sabemos utilizar os comentários para documentar nossas rotinas, 
vamos iniciar nosso estudo pela estrutura de controle lf Then Else.
Microsoft Visual Basic 4.0 51
4.3 Estrutura lf Then Else 
 
 
 Uma das estruturas de controle mais utilizadas na programação em Visual Basic é 
sem dúvida alguma a instrução lf Then, que é utilizada para avaliar uma determinada 
expressão e definir se um determinado bloco de código deve ou não ser executado. 
 
 A sintaxe para utilização deste comando é a seguinte: 
 
 
 If Condição Then 
 [Bloco de Código] 
 
 [Elseif Condição-n Then 
 [Bloco de Códígoll 
 
 [Else 
 [Bloco de Código]] 
 
 End lf 
 
 
 
 
 
 
 
 Detalhes: 
 
• Condição - É a condição a ser avaliada pelo VB. Esta condição utiliza os 
operadores de comparação que aprendemos anteriormente, sendo que a 
mesma tanto pode ser do tipo numérico como do tipo String. 
 
• Condlção-n - É uma outra condição lógica que pode ser avaliada pelo VB. 
O índice n indica que você pode inserir quantas condições lógicas quiser, 
bastando para isso repetir a instrução Elself. 
 
• Else - O bloco de código associado a esta instrução só será executado caso 
nenhuma das condições lógicas anteriores tenha sido verdadeira, ou seja, se 
todas as condições lógicas associadas ao lf e Elself resultaram em False, o VB 
executará o bloco de código associado ao Else. 
 
 
• End lf - Indica o final da estrutura de controle lf Then. Ao longo deste 
módulo você notará que a maioria das estruturas de controle são 
iniciadas pelo comando que as identifica e terminadas pela instrução 
Microsoft Visual Basic 4.0 52
End. Por questões de documentação, o VB aceita que você identifique 
que estrutura está sendo finalizada através do acréscimo do comando 
inicial da estrutura à palavra End, como em End lf por exemplo. 
 
 
 
 Descrição 
 
 A instrução lf ... Then (Se ... Então) sempre está associada a uma 
comparação lógica qualquer, como A > 10, por exemplo . 
 Se a condição for verdadeira (True), o VB executa o bloco de código 
imediatamente abaixo desta linha até encontrar uma outra instrução Elself, Else 
ou Endif, quando então a execução do programa passa para a linha 
imediatamente abaixo da instrução Endif. 
 Caso o primeiro teste lógico resulte em False, o VB irá procurar pela 
próxima instrução de comparação da estrutura lf Then. Caso exista alguma 
instrução Elself, o VB procederá da mesma forma como fez com a instrução lf, 
executando o bloco de código logo abaixo desta linha se a comparação for 
verdadeira, ou continuando a busca pela próxima instrução se a comparação for 
falsa. 
 
 Caso todas as comparações lógicas anteriores tenham resultado em 
False e exista uma instrução Else no bloco de código, esta será executada sem 
a realização de qualquer tipo de comparação lógica. 
 
 Caso não exista a condição Else em sua estrutura lf Then, a execução 
será encerrada quando o VB encontrar a instrução Endlf, que sinaliza o fim da 
estrutura de controle. 
 
 Como já construímos um novo aplicativo para o estudo das estruturas de 
controle, vamos utilizá-lo para entender melhor como funciona o comando lf... 
Then. 
 
 
 
 
 
Prática 10 Alterando o Aplicativo Estruturas de Controle 
 
 
 
 Selecione o botão "Iniciar" e dê dois cliques sobre o mesmo para ter 
acesso à janela de código. 
 
 Entre com as seguintes instruções neste arquivo: 
 
Microsoft Visual Basic 4.0 53
 Rem Estudo de lfThenElse 
 
 Dim Inicio As Integer, Limite As Integer 
 
 lnicio = Txtinicio.TEXT ' inicializa variável com o valor do controle 
 
 Limite = TxtLimite.TEXT ' Idem 
 
 lf Inicio > Limite Then ' Se Inicio > Limite executa esta opção 
 
 TxtAção.TEXT = "A opção IF foi a escolhida! " 
 
 Elseif Inicio = Limíte Then ' Se Inicio = Limite executa esta: 
 
 TxtAção.TEXT = "A opção ELSEIF foi a escolhida!" 
 
 Else 'Se nenhuma das anteriores executa esta: 
 
 TxtAção. TEXT = "A opção ELSE foi a úníca escolhida! " 
 
 Endif 
 
 
 
 Faça um último ajuste em sua janela de código, selecionando a opção 
Form na caixa de listagem Object e a opção Load na caixa de listagem Proc. 
 
 Digite a seguinte expressão nesta janela: 
 
 
 LbiTitulo. Caption = "IF THEN " ' Altera o titulo da janela 
 
 TxtPasso.Enabled = False 'Desabilita a TextBox Passo 
 Execute o seu aplicativo e entre com os valores 100 e 10 nas caixas de 
texto Início e Limite. Não se preocupe com os demais controles, pois os 
mesmos serão utilizados pelos exercícios futuros no momento adequado. 
 
 Por enquanto utilizaremos apenas as caixas de texto citadas. 
 Clique sobre o botão "Iniciar" e veja o resultado obtido em nosso primeiro 
exemplo. 
 
 
 Note que agora a condição associada à instrução IF não é mais 
verdadeira (início não é maior do que Limite) e desta forma o VB procurou a 
próxima instrução de comparação. Como existe uma condição lógica que 
analisa se o valor de Início e Limite são iguais, o VB executou esta opção, 
apresentando a mensagem correspondente a esta situação. 
Microsoft Visual Basic 4.0 54
 
 Um último teste: entre com 1 e 10. 
 
 
 Se você reparar com atenção, perceberá que nós estabelecemos três 
condições lógicas possíveis em nossa estrutura lf then se o valor Inicial fosse 
maior do que o valor Limite, se ambos os valores fossem iguais e se nenhuma 
das condições anteriores ocorresse. 
 Aliás, foi o que ocorreu em nosso exemplo, pois os valores que entramos 
não satisfazem as condições do lf ou do ElselF. 
 
Diante disso a opção Else foi executada sem maiores perguntas. 
 
 Vamos fazer uma leve modificação em nosso aplicativo. 
Pare a sua execução e dê dois cliques sobre o botão "iniciar" ou selecione 
F7 para abrir a janela de código. 
 Acrescente a seguinte expressão dentro da estrutura lffhen, logo a seguir 
da opção Elself existente: 
 
 
 Elself Inicio = 12 Then ' Somente se Inicio = 12 executa esta opção 
 TxtAção. TEXT = "A 2a. opção ELSEIF foi escolhida! " 
 
 
 Execute o seu aplicativo mais uma vez e entre com os valor 12 e 10 para 
ver o que ocorre: 
 
 Pode parecer estranho, mas apesar de termos declarado o valor Início 
como sendo igual a 12 o VB não executou o segundo Elself como haviamos 
determinado. 
 
 A explicação para este fato serve de alerta para quando você for criar 
seus próprios aplicativos utilizando as estruturas de controle lfThen. 
 
 Observe seu código com cuidado e note que o segundo Elself que 
inserimos na estrutura somente será executado quando o valor Início for igual a 
12 e o valor Limite for maior que 12, caso contrário a instrução IF será 
executada em primeiro lugar, pois sempre que 12 for maior do que o valor 
Limite, a primeira condição lógica será satisfeita e o VB não analisará nenhuma 
outra condição do lf. O mesmo acontecerá se você utilizar os valores 12 e 12, 
pois também neste caso o VB executará o primeiro Elseif da estrutura onde a 
condição estabelecida é valor Início = Limite, ignorando todas as demais 
condições. 
 
 
 Instrução Será executada se... 
Microsoft Visual Basic 4.0 55
 
 lf Início > Limite 
 Elself Início = Limite 
 2o Elself Início = 12 e Limite > 12 
 Else Início < Limite 
 
 
 
 Execute o aplicativo novamente com os valores 12 e 20 e veja que desta 
vez sua rotina foi executada sem maiores problemas. 
 
 
 
 
 É importante perceber que o VB analisa as 
condições lógicas em seqüência, de forma que se 
você quiser que uma determinada ação seja 
tomada quando ocorrer uma situação bastante 
específica, coloque esta condição em primeiro 
lugar na estrutura lf then. 
 
 
 
 
 
 Utilizando apenas uma Linha 
 
 Você também pode definir condições lógicas lfthen utilizando apenas uma 
linha de código, tornando seu código bem compacto, porém menos legível. 
 
 Geralmente, esta opção é mais utilizada durante a fase de testes de 
aplicativos devido sua praticidade, pois
basta acrescentar a palavra REM na 
frente da expressão para que o seu aplicativo simplesmente ignore-a. Já, 
utilizando uma estrutura como a que estudamos no item anterior, teríamos bem 
mais trabalho para torná-la "transparente" para o Visual Basic. 
 
 A sintaxe para esta estrutura não difere muito do que vimos 
anteriormente: 
 
 
 
 lf Condição Then Expressão [Else Expressão] 
 
 
 Um exemplo de utilização desta sintaxe poderia ser a seguinte condição: 
Microsoft Visual Basic 4.0 56
 
 íf Teste = 'Sim' Then A = 1 Else A = O 
 
 Note que o VB operaria da mesma forma que na estrutura completa, 
avaliando primeiramente se a condição proposta é verdadeira. Em caso 
afirmativo, seria atribuído à variável A o valor 1, caso contrário a mesma 
receberia o valor zero. 
 
 Você também pode executar mais de um comando associado ao IF ou ao 
Else quando utiliza esta estrutura em uma única linha basta separá-los pelo 
sinal de dois pontos entre um e outro, como no exemplo a seguir: 
 
 
 lf Teste = "Sim' Then A = l : Nome = "João” Else A = O: Nome = "Nulo" 
 
 
 
 O único cuidado a ser tomado é que todos os componentes da expressão 
devem estar numa mesma linha e separados pelo sinal de dois pontos ( : ) um 
do outro. 
 
 
 
 
4.4 Estrutura Select Case 
 
 
 Você também pode selecionar um determinado grupo de comandos 
simplesmente avaliando o valor de uma expressão através da estrutura Select 
Case. 
 
 Este comando possui a seguinte sintaxe: 
 
 Select Case Expressão 
 
 [Case condição-n 
 [Bloco de Código1]... 
 
 [Case Else 
 [Bloco de Códígon] 
 
 End Seíect 
 
 
 
 Detalhes: 
Microsoft Visual Basic 4.0 57
 
• Expressão - É qualquer expressão numérica ou de string avaliada pelo 
Visual Basic. 
 
 
• Condição-n - É a condição lógica a ser avaliada pelo VB. O índice n 
indica que você pode inserir quantas condições lógicas quiser, 
bastando para isso repetir a instrução Case. 
 
• Case Else - O bloco de código associado a esta instrução só será 
executado caso nenhuma das condições lógicas anteriores tenha sido 
verdadeira. 
 
• End Seiect - Indica o final da estrutura de controle Select Case. 
 
 
Descrição: 
 
 Inicialmente, é necessário definir a expressão que será avaliada pela 
estrutura Case, atribuindo a mesma à instrução Select Case. 
 
A partir daí o Visual Basic compara o valor desta expressão com a 
primeira instrução Case existente na estrutura de controle. Se os valores de 
ambas forem iguais, o Visual Basic executará o bloco de código associado à 
condição Case avaliada, e ao final desta passará o controle do programa para a 
primeira linha de código logo abaixo da instrução End Seiect. 
 
 Caso o valor da instrução Case seja diferente da expressão associada ao 
Select Case, o Visual Basic passará para a próxima instrução Case da estrutura, 
repetindo o processo até encontrar uma instrução que satisfaça a condição 
lógica definida. 
 
 
 
Se não existir nenhuma instrução na estrutura de 
 controle que satisfaça esta condição proposta, o VB 
 poderá adotar dois caminhos: executar a instrução 
Case Else caso a mesma exista, ou simplesmente 
encerrar a execução da estrutura. 
 
 
 
 
 A instrução Case Else será executada sempre que todas as demais 
condições existentes resultarem em False na comparação com a expressão 
definida em Select Case. 
Microsoft Visual Basic 4.0 58
 Você entenderá melhor o que queremos dizer, observando na prática o 
funcionamento desta estrutura. 
 
 
 
 
 Prática 11 
 
 
 
 Faça a seguinte alteração no código associado ao botão "iniciar" do nosso 
aplicativo: 
 
 
Rem Estudo de Select Case 
 
Dim Inicio As lnteger 
 
Inicio = Txtlnlcio. TEXT 'lnicializa variável com o valor do controle 
 
Select Case Inicio 'Avalia a expressão 
 
Case 1 'Verifica se Início = 1 
 TxtAção.TEXT = "Você escolheu o número 1 " 
 
Case 2 'Verifica se Inicio = 2 
 TxtAção.TEXT = "Você escolheu o número 2” 
 
Case 5 'Verifica se Início = 5 
 TxtAção. TEXT = "0 número 5 foí a sua escolha!" 
 
Case Else 'Se as condições anteriores forem Falsas 
 TxtAção. TEXT = "Você não escolheu 1, 2 ou 5. " 
 
End Select I 
 
 
 Necessitamos ainda de um outro pequeno ajuste em nosso 
formulário. 
 Altere a rotina Form_load conforme abaixo: 
 
 
LblTítulo.Caption = "CASE SELECT" ' Altera o título da janela 
 
TxtPasso.Enabled = False 'Desabilita a TextBox Passo 
 
Microsoft Visual Basic 4.0 59
TxtLimite.Enabled = False 'Desabilita a TextBox Limite 
 Como você pode reparar, apenas quando o valor de entrada for igual a 1, 
2 ou 5 é que o VB emitirá uma mensagem específica. 
 Para todos os demais valores informados o Visual Basic exibirá a 
mensagem associada à instrução Case Else. 
 
 Execute agora o seu aplicativo e entre com o valor 1 na caixa de texto 
Início. 
 
 
 
Definindo Faixas de Valores 
 
 
 No exemplo que criamos, todas as instruções Case estão vinculadas à 
ocorrência de um número ou string predeterminado, porém você pode definir 
que ações serão tomadas para determinadas faixas de valores. 
 
 Você pode fazer isto simplesmente definindo a condição Case da 
seguinte forma: 
 
 
 
 Case i To j 
 
 Onde i é o valor inicial e j o valor final da faixa avaliada. 
 
 
 
 
 Prática 12 
 
 
 
 Encerre a execução de seu aplicativo e faça uma rápida alteração na 
estrutura Select Case: 
 
Select Case Inicio 'Avalia a expressão 
 
Case 1 To 4 'Verifica se Inicio está entre 1 e 4 
TxtAção.TEXT = "Você escolheu um número entre 1 e 
4" 
 
Case 5 'Verifica se Início = 5 
 TxtAção.TEXT = "0 número 5 foi a sua escolha! " 
 
Microsoft Visual Basic 4.0 60
Case 6 To 8 'Verifica se Inicio está entre 6 e 8 
 TxtAção.TEXT = "Você escolheu um número entre 6 
e 8 " 
 
Case Else 'Se as condições anteriores forem 
Falsas 
 TxtAção.TEXT = "0 número escolhido é maior que 
8! " 
 
End Select 
 Execute seu aplicativo novamente e entre com alguns valores entre 1 e 
10 e veja como o VB interpreta seus dados. 
 
 Você perceberá que esta característica é muito útil quando os valores 
avaliados podem ter determinadas tolerâncias, pois permite que você torne seu 
código bem mais compacto do que definir uma condição Case para cada valor a 
ser avaliado. 
 
 
 Utilizando Operadores de Comparação 
 
 Você também pode utilizar operadores de comparação com a instrução 
Case, basta acrescentar o operador ls na expressão lógica definida por você, 
como por exemplo em: 
 
 Case ls >= 20 
 
 Altere o código de seu aplicativo acrescentando mais uma instrução Case 
na estrutura de controle, logo abaixo da última instrução Case definida por você 
e antes da instrução Case Else: 
 
Case ls > 20 
 TxtAção.TEXT = "Você escolheu um número maior que 20 " 
 
 Execute o seu aplicativo e entre com qualquer valor acima de 20 para ver 
o que acontece. 
 
 
 
 Avaliando Expressões do Tipo String 
 
 
 Até agora em nossos exemplos, sempre utilizamos valores numéricos para 
estudar o comportamento da estrutura Case, porém o Visual Basic também 
permite que você utilize valores do tipo String em suas expressões. 
 
Microsoft Visual Basic 4.0 61
 Vamos alterar um pouco o código de nosso aplicativo, alterando os 
valores analisados nas instruções Case para dados do tipo string, como 
mostramos a seguir: 
 
 
Rem Estudo de Select Case 
 
Dim Inicio As String 
 
Início = Txtinlcio.TEXT 'lnicializa variável com o valor do controle 
 
Select Case Inicio 'Avalia a expressão 
 
Case "José " 'Verifica se Inicio é igual a José 
TxtAção.TEXT = "José foi escolhido " 
 
Case "João " 'Verifíca se Início = João 
 TxtAção.TEXT
= "0 nome é João!" 
 
Case "Maria " 'Verifica se Inicio = Maria 
 TxtAção.TEXT = "Você dígitou Maria" 
 
Case Else TxtAção.TEXT = "Nenhum nome foí selecionado! 'Se as 
condições anteriores são False 
 
End Select 
 
 
 Coloque seu aplicativo em execução e entre com os nomes José, jose, 
João e joao e repare como o VB trata cada um destes nomes. Note que nesta 
comparação de strings, o Visual Basic diferencia palavras acentuadas ou não e 
palavras grafadas em maiúsculas e minúsculas, por isso tome muito cuidado ao 
realizar comparações de strings, pois seu programa pode apresentar um 
comportamento bastante estranho apesar de você ter a certeza de que tudo está 
em perfeito estado. 
 
 
 Vamos estudar agora a estrutura For Next, que é uma outra instrução 
muito utilizada na programação em Visual Basic. 
 
 
 
 
 4.5 Estrutura For Next 
 
 
Microsoft Visual Basic 4.0 62
 Este comando repete um mesmo bloco de código um determinado 
número de vezes independentemente de qualquer condição lógica. 
 
A sintaxe deste comando é a seguinte: 
 
For Contador = Valorinicial To ValorFinal [Step Passo] [Bloco de Código] [Exit 
For] 
[Bloco de Código] 
Next [Contador] 
 
 
 
 Detalhes: 
 
• Contador - É uma variável de memória numérica que será utilizada para 
controlar o número de execuções do bloco de código. 
 
• Valorlniclal - Valor de inicialização do contador. Você pode iniciá-lo 
com o valor zero, um ou mesmo qualquer outro que julgue necessário. 
 
• ValorFinal - É o valor final que a variável Contador assumirá antes de 
encerrar a execução do loop. 
 
• Passo - Você pode determinar se a variável contador será incrementada 
de um em um ou de dois em dois por exemplo. 
 Caso você não informe este parâmetro, o Visual Basic considera que o 
incremento será positivo de uma em uma unidade. Você também pode 
definir números negativos para esta opção. 
 
• Exit For - Você pode interromper a execução do loop através desta 
instrução. Ao encontrá-la no meio de seu bloco de código, o loop é 
interrompido. Esta instrução normalmente está associada à ocorrência de 
uma determinada condição lógica. 
 
 
 
 Descrição 
 
 Para utilizar esta estrutura de controle você necessitará de uma variável 
de memória para ser o contador do número de repetições que a estrutura fará. 
 
 Esta variável é inicializada com o valor especificado por você em 
Valorlnicial e é feita uma comparação de seu valor com o valor definido por você 
em ValorFinal. 
Se o valor do Contador é menor do que o valor de ValorFinal, o bloco de 
código localizado entre as declarações For e Next é executado uma vez. 
Microsoft Visual Basic 4.0 63
 
 Ao final da execução do bloco de código, o Visual Basic incrementa a 
variável de controle o número de unidades especificado em Passo. 
É feita uma nova comparação, e se o contador ainda for menor que a 
variável ValorFinal, o ciclo se repete. 
 Quando o contador atinge um valor maior que a variável limite, a 
execução do loop é encerrada e o Visual Basic passa para a linha 
imediatamente seguinte à declaração Next. 
 Vamos aprender na prática como se comporta um loop do tipo For Next 
através do aplicativo que criamos no início deste módulo. 
 
 
 
 
 Prática 13 
 
 
 
 Alterando o Aplicativo Estruturas de Controle. 
 
 Selecione o botão "Iniciar" e dê dois cliques sobre o mesmo para ter 
acesso à janela de código. 
 
 Entre com as seguintes instruções neste arquivo: 
 
 
 
 
Vamos considerar que o sinal @ indica que o comando 
 continua na mesma linha, que por questões de editoração da 
apostila, o mesmo foi dividido em duas ou mais linhas. 
 
 
 
 
 Rem Estudo de For Next 
 
 Dim Contador As integer, Inicio As integer, Limite As integer, @ 
Passo As integer, Vezes As integer 
 
 Início = Txtinlcio.TEXT 'lnicializa vanável com o valor do controle 
 Limite = TxtLimite.TEXT 'Idem 
 Passo = TxtPasso.TEXT 'Idem 
 Vezes =0 'lnicializa a vanável Vezes com zero 
 
Microsoft Visual Basic 4.0 64
 LblMsg.Captfon = " Enquanto Contador for menor ou igual a " & 
Limite @ 
& " o bloco de código será executado! " 
 
 
 
LblMsg.Refresh 'Atualiza o controle LblMsg 
For Contador = inicio To Limite Step Passo 
 
Vezes = Vezes +1 
TxtValorAtual. TEXT = Contador 
TxtValorAtual.Refresh 'Atualiza o controle 
TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & @ 
“ a. vez” 
TxtAção.Refresh 'Atualiza o controle 
 
Next 
 
Rem Depois de executar o loop o controle do programa passa para esta 
linha: 
 
 
 
 TxtAção.Text = "0 bloco de código foí executado " & Vezes & " vezes!" 
 
 
 
 
 Faça um ajuste na procedure Form-load, deixando apenas as seguintes 
linhas de código: 
 
 
 
LblTítulo.Caption = "FOR NEXT” ‘ Altera o titulo da janela 
LblAção.Caption = "Valor Atual do Contador" 
 
 
 Execute o aplicativo e entre com os valores 1 para Inicio, 10 para Limite e 
1 para Passo. 
 
 
 Clique sobre o botão "iniciar" e veja o que ocorre. 
 
 Dependendo da velocidade de seu microcomputador, você só conseguirá ver a 
última mensagem exibida na tela após o término do loop. 
Microsoft Visual Basic 4.0 65
 
 Na prática, o que o sistema faz é exibir na tela os valores das variáveis 
definidas por nós conforme a instrução For Next vai alterando as mesmas. 
 
 Para facilitar a sua vida vamos fazer uma pequena alteração em nosso 
aplicativo, incluindo mais algumas linhas de código a fim de "desacelerarmos" nosso 
computador. 
 Acrescente as seguintes instruções logo abaixo da linha TxtAção.Refresh, de 
modo a deixar sua rotina com a seguinte aparência: 
 
 
 For n = 1 To 100000 
 REM Este loop não faz nada! 
 Next 
 
 
 Na verdade, o que fizemos foi nada mais do que acrescentar um outro loop 
dentro do já existente, para fazer com que o Visual Basic gaste um determinado tempo 
entre uma atualização de tela e outra, e assim podermos ver o conteúdo das variáveis 
envolvidas no loop. 
 
 
 
 Saiba que o valor de 100000 foi obtido experimentalmente, e dependendo 
da velocidade de seu computador, você terá que aumentar ou reduzir este valor 
até obter o intervalo desejado entre uma exibição e outra em seu monitor. 
 
 
 
 
 
 
Saindo de um Loop For Next 
 
 Como já vimos no item anterior, sempre que você inicia a execução de 
um loop For Next, ele somente encerra sua operação quando o contador atingir 
um valor maior do que o valor final do loop. 
 Na verdade, você pode interromper a execução do mesmo, utilizando 
para isso o comando Exit For. 
 Geralmente, este comando é utilizado em conjunto com uma instrução lf, 
como a que vimos no início deste capitulo. 
 
 Vamos supor que você deseja executar um bloco de código um 
determinado número de vezes ou até que um dado valor seja atingido. Este 
valor tanto pode ser proveniente do cálculo de uma fórmula qualquer como de 
uma variável de memória existente. 
Microsoft Visual Basic 4.0 66
 
 
 Você poderia, por exemplo, definir esta condição da seguinte maneira: 
 
 lf Vezes = Limite / 2 Then 
 Exit For 
 End lf 
 
 
 Como a variável Vezes é incrementada em uma unidade a cada execução 
do loop, você pode definir que assim que o valor da mesma for igual ao valor da 
variável Limite dividido por dois, o loop será encerrado. 
 É claro que neste caso, seria mais fácil definirmos logo de início o valor 
adequado para a variável Limite ao invés de acrescentarmos uma cláusula Exit 
For, mas como estamos apenas querendo mostrar a você o mecanismo desta 
instrução Exit, vamos aproveitar as variáveis de memória que já existem em 
nosso código, evitando assim termos que fazer mais alterações na rotina 
existente. 
 
 
 
 Utilizando Instruções For Next Aninhadas 
 
 No exemplo anterior, utilizamos duas instruções
For Next aninhadas, isto 
é, uma dentro da outra. Veja a seguir, um fragmento do código que utilizamos 
em nosso exemplo: 
 
 For Contador = Inicio To Limite Step Passo 
 
 Vezes = Vezes + 1 
 TxtValorAtual.TEXT = Contador 
 
 For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next 
 
 Next 
 
 Até que olhando desta forma não há muitas dúvidas sobre que instrução 
Next está relacionada à primeira instrução For, mas e quando suas rotinas forem 
ficando cada vez maiores complexas? 
 
Ao analisar seu código, você pode ser levado a concluir erroneamente 
que um determinado Next está associado a uma instrução For, quando na 
verdade ambas não têm nada a ver uma com a outra, o que fatalmente o levará 
a cometer um erro de avaliação de sua rotina. 
Microsoft Visual Basic 4.0 67
 
Outro ponto importante é que se por um erro seu, uma instrução Next for 
encontrada antes da instrução For correspondente, o VB apresentará um erro 
em tempo de execução, paralisando a execução de seu aplicativo. 
 
Este tipo de erro bastante comum pode ser evitado, bastando para isso 
declarar junto à instrução Next o nome da variável de memória que é utilizada 
como contador pelo Visual Basic, como no exemplo a seguir: 
 
 
For Contador = Inicio To Limite Step Passo 
 
 Vezes = Vezes + 1 
 TxtValorAtual.TEXT = Contador 
 For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next n ‘Incrementa a variável n 
 Next Contador ‘Incrementa a variável Contador 
 
 
 
Para evitar erros de execução ao utilizar 
 instruções For aninhadas, você sempre deve declarar a 
instrução acompanhada do nome da respectiva 
 variável utilizada como contador do loop. 
 
 
 
 
 Um último comentário sobre a estrutura For Next: 
 
 Como você pode observar nos exemplos que criamos, o valor do contador 
sempre é armazenado em uma variável de memória, e por isso mesmo sempre 
é possível modificarmos o seu valor, alterando o comportamento do loop. Isto 
tanto pode ser um importante recurso de programação como uma fonte de 
dores-de-cabeça, dependendo da forma como você utilize esta possibilidade e 
da complexidade de seu código. 
 
 A utilidade deste recurso é que você pode repetir a execução do loop 
indefinidamente até que uma determinada condição desejada seja obtida. 
 Na verdade, existem outras formas mais adequadas de se fazer isto, 
porém não podemos deixar de considerar a possibilidade de realizarmos esta 
tarefa com a estrutura For Next. 
 
Microsoft Visual Basic 4.0 68
 O ponto negativo é que alterando o valor do contador do loop durante a 
execução, você pode levar o seu programa a entrar num loop infinito caso a 
meta definida por você não possa ser atingida, além de tornar o seu aplicativo 
mais difícil de entender e depurar. 
 
 Só para ter uma idéia do que queremos dizer, imagine que seu aplicativo 
faça uso do seguinte bloco de código: 
 
 Private Sub BtniniciaLClíckO 
 
 Rem Estudo de For Next com alteração do Contador durante a 
execução 
 Dim Contador As integer, Resultado As Single, Vezes As integer 
 
 Resultado = 100 ‘ lnicializa a variável com o valor 100 
 
 For Contador = 1 To 10 
 
 Resultado = Resultado + (1.005 ^ 2) 'Fórmula a ser calculada 
 Vezes = Vezes + 1 'Número de execuções 
 
 TxtValorAtual. TEXT = Resultado 'Exibe o resultado na 
Textbox 
 TxtValorAtual.Refresh 'Atualiza o controle 
 
 For n = 1 To 100000 'Loop para desacelerar o programa 
 Rem Este loop não faz nada! 
 Next n 
 
 lf Resultado < 120 And Contador = 10 Then Contador 
=1'Ajusta valor do Contador Para o valor 1 
 
 
 Next Contador 
 
Rem Depois de executar o loop o controle do programa 
Rem passa para esta linha: 
 
 TxtAção. TEXT = "0 bloco de código foí executado ". & Vezes & " vezes!" 
 End Sub 
 
 Note que o ponto crítico é a linha que analisa o valor atual da fórmula. Em nosso 
exemplo, sabemos que num determinado momento o valor da fórmula será maior que 120, 
fazendo com que o loop deixe de ser executado. 
Microsoft Visual Basic 4.0 69
 Mas e quando os valores são definidos no decorrer do programa com valores 
entrados pelo usuário? Dependendo dos dados entrados pelo usuário, pode ser bastante 
complicado estimar se uma determinada condição irá ocorrer ou não, comprometendo o 
funcionamento de seu aplicativo. 
 
 
 
 
A nossa sugestão é que você evite alterar o valor do 
contador do loop durante a execução deste, se não 
tiver a certeza de que o valor limite para o encerramento 
do loop será atingido em um determinado momento da execução. 
 
 
 
 
 Aliás, se você executar o aplicativo acima, verá que o valor limite para o 
encerramento do loop será atingido após 28 execuções, isto é, o contador mesmo foi 
reiniciado duas vezes após a execução inicial. 
 
 
 
 4.6 Estrutura DO...LOOP 
 
 
 Este comando repete a execução de um bloco de código enquanto uma 
determinada condição for verdadeira, ou até que uma condição especificada 
torne-se verdadeira. 
 
 Este comando pode ser declarado de duas formas distintas: 
 
 
 Do [{While I Until} Expressão] 
 [Bloco de Código] 
 [Exit Do] 
 [Bloco de Código] 
 Loop 
 
 
 Ou se você preferir, da seguinte maneira: 
 
 Do 
 [Bloco de Código] 
 [Exit Do] 
 [Bloco de Código] 
 Loop [{While I Until} Expressão] 
Microsoft Visual Basic 4.0 70
 
 
Detalhes: 
 
• Expressão - É qualquer expressão numérica ou de string avaliada pelo 
Do While / Do Until. Utilizando o comando While o bloco de código 
associado ao loop é executado enquanto a expressão definida for 
verdadeira. Quando isto não mais ocorrer, o Visual Basic passará o 
controle do programa para instrução imediatamente seguinte à 
instrução Loop estrutura de controle. Já, utilizando a sintaxe Do Until, 
o bloco de código será executado até que uma determinada situação 
torne-se verdadeira, ou seja, enquanto a expressão especificada for 
falsa. 
 
• Exit Do - Você pode interromper a execução do loop através desta 
instrução. Ao encontrá-la no meio de seu bloco de código, o loop é 
imediatamente interrompido, e a execução do programa passa para a 
primeira instrução abaixo do comando Loop. Esta instrução 
normalmente está associada à ocorrência de uma determinada 
condição lógica. 
 
 
 
 Descrição: 
 
 O funcionamento desta estrutura é bastante simples, mas nem por isso 
menos poderosa que as outras instruções que estudamos anteriormente. 
 
 Como você já deve ter percebido, existem duas formas de utilizarmos 
esta estrutura de controle, de modo que vamos iniciar pela sintaxe Do While 
primeiro. 
 
 Inicialmente, é feita uma avaliação da expressão associada à instrução 
Do While. Se a mesma for verdadeira (resultar em True), o bloco de código 
associado a esta instrução é executado. Ao encontrar a instrução loop, o Visual 
Basic retorna à linha inicial, onde a expressão lógica é novamente avaliada. Se 
a mesma ainda for verdadeira, o bloco de código será executado outra vez, até 
encontrar a instrução loop. Isto se repetirá ininterruptamente enquanto a 
expressão lógica resultar em verdadeira. 
Aliás o nome Do While pode ser traduzido como Faça Enquanto. 
 
 O mesmo ocorre com a expressão Do Until, só que de maneira contrária, 
já que esta expressão pode ser traduzida como Faça Até . 
 
 Neste caso, o bloco de código será executado até que a expressão 
avaliada torne-se verdadeira. 
Microsoft Visual Basic 4.0 71
 
 Como já dissemos a você, existem duas formas diferentes de utilização 
desta estrutura. A primeira, como vimos, parte inicialmente da análise da 
expressão antes da execução do bloco de código. Isto significa que, se a 
expressão lógica for falsa desde a primeira análise, o bloco de código não será
executado uma vez sequer. Já com a segunda sintaxe, antes de mais nada o 
bloco de código será executado, independentemente do resultado da expressão. 
 
 No final do bloco de código, está a instrução Loop While / Loop Until, 
associada à expressão lógica. 
 Mais uma vez, ver na prática é o melhor caminho para entender a 
diferença entre ambas estruturas. 
 
 
 
 
 Prática 14 
 
 
 
 Selecione mais uma vez o aplicativo Estruturas de Controle e faça as 
seguintes alterações no código associado a este projeto: 
 
 Na procedure Form_load( ) altere o código existente para: 
 
 LblTítulo.Caption = "DO WHILE" 'Altera o título da janela 
 TxtPasso.Enabled = False 'Desabilíta a Textbox Passo 
 LblAção.Caption = "Valor Atual de inicio:" 'Exibe a mensagem indicada 
 
 
 Já para a procedure Btnlniciar_Click faça os seguintes ajustes: 
 
 
 Rem Estudo de Do While 
 
 Dim Inicio As integer, Limite As lnteger, Vezes As integer 
 
 Início = Txtlnício.TEXT 'lnicializa variável com o valor do controle 
 Limite = TxtLimite.TEXT 'idem 
 Vezes = 0 'Inicializa a variável Vezes com zero 
 
 
LblMsg.Caption = "Enquanto Inicio for menor ou igual a " & Limite & 
" o bloco de código será executado!” 
LblMsg.Refresh 'Atualiza o controle LblMsg 
Microsoft Visual Basic 4.0 72
Do While Inicio <= Limite 
 
Inicio = Inicio + 1 'lncrementa a variável Início 
Vezes = Vezes + 1 'lncrementa a variável Vezes 
TxtValorAtual.TEXT = Início 
TxtValorAtual.Refresh 'Atualiza o controle 
 
TxtAção.TEXT = "Executando o bloco de código pela " & 
Vezes & "a . vez” 
TxtAção.Refresh 'Atualíza o controle 
 
For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next 
 
 Loop 
 
 Rem Depois de executar o loop, o controle do programa 
 Rem passa para esta linha: 
 
 TxtAção.TEXT = "0 bloco de código foi executado " & Vezes & " 
vezes!" 
 
 
 Execute o aplicativo e veja o que ocorre. 
 
 A princípio, não existe muita diferença entre o comando For Next e a 
rotina que acabamos de desenvolver se você observar apenas a tela de 
resultados, mas lembre-se de que enquanto o For Next repete um bloco de 
código um determinado número de vezes, o comando Do While repete este 
mesmo bloco até que uma determinada condição seja atingida ou enquanto 
determinada situação for verdadeira. 
 
 Faça agora duas pequenas alterações no código associado ao botão 
"Iniciar" para vermos na prática esta condição. Altere a seguinte linha do seu 
código: 
 
 De: 
 LblMsg.Caption = "Enquanto Inicio for menor ou igual a " & Limite & " o 
bloco de código será executado!" 
 
Microsoft Visual Basic 4.0 73
 Para: 
 LblMsg. Caption = "Enquanto Inicio for maior que " & Limite & " o bloco 
de código será executado!" 
 
 Aproveite para alterar as seguintes linhas também: 
 
 De: 
 
 Do While Inicio <= Limite 
 
 Inicio = Inicio + 1 'lncrementa a variável Início 
 
 
 Para: 
 
 Do While Inicio > Limite 
 
 Inicio = Início - 2 'Decrementa a variável Inicio 
 Execute novamente o aplicativo e entre com os valores 20 e 10. 
 
 
Utilizando a Segunda Sintaxe Do While 
 
 Como já havíamos adiantado no início deste módulo, você tanto pode 
definir que o bloco de código associado à instrução Do While seja executado 
somente se a expressão de controle for verdadeira, ou mesmo que o bloco de 
código seja executado uma única vez antes de avaliarmos a expressão de 
controle. 
 Você perceberá a diferença da seguinte forma: 
 Execute o aplicativo que alteramos no item anterior e entre com os 
valores 20 e 20 nas respectivas caixas de texto. Você receberá a mensagem 
que o bloco de código não foi executado uma única vez sequer. 
 
 Isto ocorre porque a avaliação da expressão Início > Limite resulta em 
False, já que 20 não é maior do que 20. Neste caso, o Do While passa o 
controle do programa para a instrução imediatamente seguinte ao comando 
Loop. 
 
 Faça uma pequena alteração no seu código, de modo a deixar a 
avaliação da expressão para depois da execução do loop. Para fazer isto basta 
transferir a palavra While e a expressão associada a esta da linha que contém o 
Do para a linha Loop: 
 
Microsoft Visual Basic 4.0 74
 
 Do 
Inicio = Inicio - 2 'Decrementa a variável inicio 
Vezes = Vezes + 1 ‘Incrementa a variável Vezes 
TxtValorAtual.TEXT = Inicio 
TxtValorAtual.Refresh 'Atualiza o controle 
 
 
 
 TxtAção. TEXT = "Executando o bloco de código pela " & Vezes & 
"a. vez’ 
 TxtAção.Refresh ‘Atualiza o controle 
 
 For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next 
 
 Loop While Inicio > Liniite 
 
 Reexecute o aplicativo e torne a entrar com os valores 20 e 20. 
 
 Note que desta vez o bloco de código foi executado pelo menos uma vez 
antes que o Visual Basic avaliasse a expressão lógica definida por nós. Após a 
avaliação da expressão (que resultará em False), o Visual Basic não mais 
executará o loop, passando para a próxima instrução da rotina. 
 
 
 
 
 4.7 A Estrutura Do Until 
 
 
 Como já havíamos antecipado a você, a diferença entre o Do Until e o Do 
While é o modo com que a estrutura avalia a expressão lógica associada à 
mesma. No caso do Do Until, o Visual Basic executará o bloco de código 
enquanto o resultado da expressão avaliada for False. Quando o mesmo se 
tornar verdadeiro (True), o Visual Basic encerra a execução do bloco de código. 
 
 
 
 Prática 15 
 
 
 
 Vamos aproveitar parte do código que utilizamos para estudar o Do While, 
fazendo apenas algumas rápidas modificações. 
Microsoft Visual Basic 4.0 75
 
 Rem Estudo de Do Until 
 
 Dim Inicio As lnteger, Limite As Integer, Vezes As lnteger 
 
 Inicio = Txtlnício.TEXT 'Inicializa variável com o valor do controle 
 Limite = TxtLimite.TEXT 'Idem 
 Vezes = O 'lnicializa a variável Vezes com zero 
 
 LblMsg.Caption = “Enquanto Início for menor que “ & Limite &” o bloco de 
código será executado!” 
 
 LblMsg.Refresh 'Atualíza o controle LblMsg 
 
 
 
 Do Until Início > Limite 
 Início = Início + 1 'íncrementa a variável Início 
 Vezes = Vezes + 1 'lncrementa a variável Vezes 
 TxtValorAtual.TEXT = Inicio 
 TxtValorAtual.Refresh 'Atualiza o controle 
 
 TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & " 
a .vez" 
 TxtAção.Refresh 'Atualiza o controle 
 
 For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next 
 
 Loop 
 
TxtAção. TEXT = "0 bloco de código foi executado " & Vezes & " 
vezes! " 
 
End Sub 
 
Faça também um rápido ajuste na rotina Form-load( ), alterando a 
seguinte linha: 
 
LblTítulo.Caption = "DO UNTIL" 'Altera o título da janela 
 
Ponha seu programa para rodar e entre com os valores 1 e 10. Note que 
o resultado da expressão Inicio > Limite com estes valores será False, já que 10 
é menor que 20. Mesmo assim o VB executará o bloco de código, sendo que só 
deixará de fazê-lo quando a expressão tornar-se verdadeira, ou seja, quando o 
Microsoft Visual Basic 4.0 76
valor de início for igual a 21, que por sua vez tornará a expressão avaliada 
verdadeira (21 > 20). 
 
Se você entrar com os valores 25 e 20, por exemplo, o Visual Basic não 
executará uma vez sequer o bloco de código, pois desde o início a avaliação da 
expressão associada ao Do Until resulta em Verdadeiro. 
 
 
Para garantir que seu bloco de código será executado pelo menos uma 
vez, faça as seguintes alterações no Código de seu aplicativo: 
 
 
Do 
Início = Início + 1 'lncrementa a varíável início 
Vezes = Vezes + 1 'lncrementa a variável vezes 
TxtValorAtual.TEXT = Início 
TxtValorAtual.Refresh 'Atualíza o controle 
 
 TxtAção.TEXT = "Executando o bloco de código pela “ & Vezes & “ 
a. vez 11” 
 
 TxtAção.Refresh 'Atualiza o controle 
 
 For n = 1 To 100000
Rem Este loop não faz nada! 
 Next 
 
 Loop Until Início > Limite 
 
 Agora é só executar o programa novamente com os valores 25 e 20 e ver 
o resultado obtido. 
 
 
 
 
Saindo do Loop com Exit Do 
 
 Como já vimos anteriormente, você pode encerrar a execução de um loop 
a qualquer momento através da palavra de comando Exit. 
 
 A estrutura Do While/Do Until não é exceção, pois também permite que 
você utilize este recurso sempre que necessitar interromper a execução de um 
loop qualquer. 
 Aproveite o último exercício que criamos e acrescente as seguintes linhas 
antes da instrução Loop Until Início > Limite: 
 
Microsoft Visual Basic 4.0 77
 if Início = 15 Then 
 Exit Do 
 End íf 
 
 Execute novamente o seu aplicativo e entre com os valores 1 e 20 para 
ver o que ocorre. 
 Assim que a variável Início atingir o valor predeterminado, o loop será 
encerrado, e o controle do programa passará para a próxima linha abaixo da 
instrução Loop. 
 
 Note que não existe um número limite para o uso de instruções Exlt Do, 
ou seja, você pode utilizar esta declaração quantas vezes necessitar, como por 
exemplo no código abaixo: 
 
 Do 
 Inicio = Inicio +1 'lncrementa a variável Início 
 Vezes = Vezes + 1 'lncrementa a variável Vezes 
 
 lf Início = 15 Then 
 Exit Do 
 Elseif Início = 1 And seleção = False Then 
 Exlt Do 
 Elseif Início = 1 And Teste = 20 Then 
 Exit Do 
 End lf 
 
 Loop Until Inicio > Limite 
 
 
 Vamos aprender agora uma nova estrutura de controle bastante parecida 
com a estrutura Do Loop que acabamos de estudar, a While... Wend. 
 
 4.8 While Wend 
 
 Este comando repete a execução de um determinado bloco de código 
enquanto uma determinada condição for verdadeira. 
 Este comando possui a seguinte sintaxe: 
 
 While condição 
 [Bloco de Código] 
 Wend 
 
 
 Detalhes: 
 
Microsoft Visual Basic 4.0 78
• Condição - É qualquer expressão numérica ou de string avaliada pelo 
While. 
 
 
 
 
 Descrição: 
 
 O funcionamento desta estrutura é bem simples: se a condição 
especificada for verdadeira, o Visual Basic executará o bloco de código 
associado à estrutura. 
 
 Ao atingir a declaração Wend, o Visual Basic retoma à primeira linha da 
estrutura e reavalia a expressão. Se a mesma ainda for verdadeira, o Visual 
Basic repetirá a execução do código, reiniciando o processo ao alcançar o 
Wend. Quando esta condição de controle tornar-se falsa, a execução do loop 
será interrompida, e o controle do programa passará para a linha imediatamente 
seguinte ao Wend. 
 
 
 Apesar da simplicidade desta estrutura de controle, você deve 
preferencialmente utilizar-se da estrutura Do Loop, já que a mesma oferece uma 
maior flexibilidade na criação de loops, através da possibilidade de encerrá-los a 
qualquer momento. 
 
 
 
 
Na estrutura While... Wend não existe o comando Exit. 
 
 
 
 
 O problema é que se você definir uma expressão de controle que nunca 
resultará em False, seu aplicativo será executado indefinidamente, já que não há 
a possibilidade de utilizar um comando Exit para encerrá-lo após um 
determinado número de execuções, ou da ocorrência de alguma condição que 
indique a anormalidade na execução do código. 
 
 
 Caso você tenha interesse em ver na prática como esta estrutura de 
controle se comporta, faça as seguintes alterações no código de seu aplicativo: 
 
 Rem Estudo de While... Wend 
 
 Dim Início As lnteger, Limite As lnteger, Vezes As lnteger 
Microsoft Visual Basic 4.0 79
 
 Inicio = TxtInício.TEXT 'lnícialíza varíável com o valor do controle 
 Limíte = TxtLimite.TEXT 'Idem 
 Vezes = 0 'Inicializa a variável Vezes com zero 
 
 LblMsg.Caption = "Enquanto Início for menor que " & Limite & ", o bloco 
de código será executado!" 
 
 LblMsg.Refresh 'Atualiza o controle LblMsg 
 
 While Início < Limite 
 lnício = Inicio + 1 'lncrementa a variável 
 Vezes = Vezes + 1 'lncrementa a variável Vezes 
 TxtValorAtual.TEXT = Inicio 
 TxtValorAtual.Refresh 'Atualiza o controle 
 
 TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & " 
a .vez" 
 TxtAção.Refresh 'Atualiza o controle 
 
 For n = 1 To 100000 
 Rem Este loop não faz nada! 
 Next 
 
 Wend 
 
 Rem Depois de executar o loop o controle do programa 
 Rem passa para esta linha: 
 TxtAção.TEXT = "0 bloco de código foi executado " & Vezes & " 
tezes! " 
 End Sub 
 
 Só para deixar bem documentado o que você está fazendo, altere a rotina 
Form-load( ) conforme a seguir: 
 
 LblTítulo.Caption = "WHILE" 'Altera o título da janela 
 
 
 
 Execute o seu aplicativo e repare que ele funciona de maneira idêntica à 
estrutura Do Loop que estudamos anteriormente. 
 
 
 
Microsoft Visual Basic 4.0 80
 4.9 Utilizando Funções 
 
 Nesta seção, aprenderemos o que são Funções e como utilízá-Ias em 
nossos aplicativos. Aprenderemos também o que são argumentos e valores de 
retomo de funções, além de vermos uma listagem completa das funções 
disponíveis no Visual Basic agrupadas de acordo com a sua finalidade. 
 
 
 O Que São Funções ? 
 
 As funções nada mais são do que um determinado tipo de rotina 
(procedimentos) que realiza tarefas específicas dentro de seu aplicativo, 
retomando ao aplicativo um determinado valor resultante ou não da execução 
destas tarefas. 
 
 Basicamente, as funções dividem-se em dois tipos distintos: 
 
 
⇒ Funções definidas pelo usuário, que são as rotinas desenvolvidas por você de 
acordo com as suas necessidades. 
 
⇒ Funções internas do Visual Basic, que foram criadas pela própria equipe de 
desenvolvimento do Software na Microsoft. 
 
 
 Nesta seção, aprenderemos sobre as funções internas do Visual Basic, 
ou seja, sobre aquelas funções que já estão prontas para serem utilizadas por 
você, não necessitando de nenhuma programação adicional. 
 
 Como já adiantamos a você, as funções internas realizam tarefas 
bastante específicas, que podem ser agrupadas em várias categorias conforme 
a sua finalidade. 
 
 Entre as várias categorias existentes podemos citar como exemplo as 
funções matemáticas, financeiras, de data, de manipulação de strings, 
ambientais, de conversão, etc. 
 
 
 Por que Utilizar Funções? 
 
 A grande vantagem da utilização das funções é permitir o 
reaproveitamento de determinadas partes seu código, evitando que você tenha 
que repeti-Ias mesmas várias vezes dentro de seu programa. 
 
 Isto evita que o seu aplicativo fique enorme devido à repetição de várias 
linhas de código sem necessidade, bem como diminuir a possibilidade de 
Microsoft Visual Basic 4.0 81
ocorrerem erros, já que com menos linhas seu código ficará mais fácil de ler e 
de depurar. Além disso, se uma função foi criada e testada adequadamente, as 
chances da mesma apresentar algum problema no futuro são praticamente 
nulas ou muito reduzidas, dando uma maior confiabilidade à sua aplicação. 
 Outra vantagem a ser destacada é que a manutenção de seu código 
ficará bem mais fácil, pois ao invés de corrigir linhas e linhas de comandos basta 
revisar apenas a função que sofreu alterações para atualizar todo o seu código 
de uma só vez. 
 
 Outra vantagem indiscutível das funções é a maior facilidade na criação 
de suas aplicações, pois permite que você utilize não só as funções internas do 
Visual Basic, mas também as funções desenvolvidas por você e mesmo por 
outros programadores, resultando numa maior produtividade por parte do 
programador. 
 
 Aliás foi pensando nisso que a Microsoft desenvolveu as funções internas 
do VB, poupando o seu trabalho de criação de funções básicas como as que 
retomam a data e hora do sistema ou de funções complexas, de difícil criação, 
como as que calculam valores de Seno e Cosseno, por exemplo. 
 
 
 
 Utilizando as Funções Internas do Visual Basic
A utilização das funções internas do Visual Basic é bastante simples, 
basta observar as informações (argumentos) que você deve fornecer ou não à 
função a ser utilizada. 
 
 Você pode utilizar as funções internas do Visual Basic simplesmente 
declarando o nome da função desejada dentro de suas rotinas, como por 
exemplo, no código a seguir: 
 
 Valor = Date 
 
 
 Neste caso, Valor é uma variável que receberá uma resposta vinda da 
função Date. 
 
 O único cuidado a ser tomado na utilização das funções é verificar se a 
função desejada necessita ou não de alguma informação adicional (chamada de 
argumento pelo VB) para conseguir realizar as tarefas às quais esta se propõe. 
Repare que nem todas as funções internas do VB exigem que você forneça esta 
informação adicional, sendo que para muitas delas basta incluir seu nome na 
linha de comando como fizemos no exemplo anterior. 
 
Microsoft Visual Basic 4.0 82
 Vamos aprender agora um pouco mais sobre o que são argumentos e 
sua utilização. 
 
 
 
 Argumentos de Funções 
 
 
 O argumento é uma variável, constante ou mesmo uma expressão que 
você precisa informar à função para que ela possa executar a tarefa à qual se 
propõe. 
 
 Um exemplo de função que necessita de argumento é a função que 
calcula o Cosseno de um determinado ângulo. Neste caso, você deve 
obrigatoriamente informar o valor do ângulo a ser calculado, como no exemplo a 
seguir: 
 
 Valor = Cos(0,785) 
 
 Note que neste caso o argumento deverá ser informado entre parênteses, 
logo após o nome da função. 
 
 O tipo de dado de argumento varia conforme a função escolhida, sendo 
que ele tanto poderá ser do tipo de dados numérico, data, string, lógico, etc. 
 
 
 
 Valores de Retorno 
 
 
 Toda função sempre apresenta um valor de retorno, que nada mais é do 
que o resultado final obtido após a sua execução. 
 Para que entenda melhor, imagine que você necessita calcular a raiz 
quadrada de um número qualquer como 16, por exemplo. Você pode fazer isto 
no Visual Basic através da função Sqr (de square), bastando para isso fornecer 
como argumento o valor a ser calculado, de forma que nossa função ficaria igual 
a Sqr(16). Como todos nós sabemos, a resposta encontrada por esta função 
será o valor 4. Mas fica uma dúvida, como o Visual Basic nos indicaria que esta 
foi a resposta encontrada? 
 
 Como já havíamos adiantado a você, a resposta para esta pergunta é o 
Valor de Retomo. Isto que dizer que sempre que você utilizar uma função 
qualquer para a realização de urna tarefa, deverá associá-la a uma variável de 
memória ou controle de seu formulário, de modo a ter um lugar determinado 
para receber o valor retomado pela função. 
 
Microsoft Visual Basic 4.0 83
 
 
 
 
 
 
 
 
 4.10 Funções Internas do Visual Basic 4.0 
 
 
Funções Matemáticas 
 
Abs Retorna o Valor Absoluto de um Número
Atn Calcula o Arco Tangente de um Número
Cos Calcula o Cosseno de um Número 
Exp Retorna o Valor de e Elevado a uma 
Potência 
Fix Retorna a Parte Inteira de um Número 
Int Retorna a Parte Inteira de um Número 
Log Calcula o Logaritmo Natural de um 
Número 
Rnd Retorna um Número Aleatório 
(Randômico) 
Sgn Retorna um Inteiro Conforme o Sinal do 
Número 
Sin Calcula o Seno de um número 
Sqr Calcula a Raiz Quadrada de um Número
Tan Calcula a tangente de um Número 
 
 
 
 
Funções de Data e Hora 
 
Date Retorna a Data Atual do Sistema 
DateAdd Retorna a Data Especificada Acrescida 
do Intervalo de Tempo Informado 
DateDif Retorna o Intervalo ed Tempo Decorrido 
entre Duas Datas Especificas 
DatePart Retorna a Parte Especificada de uma 
Determinada Data 
DateSerial Retorna uma Data para o Ano, Mês e 
Microsoft Visual Basic 4.0 84
Dia Especificados 
DateValue Retorna uma Data a Partir de uma Data 
na Forma de String 
Day Retorna o Número do Dia de uma Data 
(de 1 a 31) 
Format Formata uma Expressão de Acordo com 
as Instruções Definidas pelo Usuário 
Hour Retorna o Número da Hora (0 a 23) de 
uma Determinada Hora Especificada 
Minute Retorna o Número de Minutos da Hora 
Especificada (0 a 59) 
Mounth Retorna o Número do Mês de uma 
Determinada Data (1 a 12) 
Now Retorna a Data e Hora Atuais do seu 
Sistema 
 
Time Retorna a Hora Atual do Sistema 
Timer Retorna o Número de Segundos 
Decorridos desde 0:00h (de 0 a 59) 
Weekday Retorna o Número do Dia da Semana (1 
- Domingo, ..., 7 - Sábado) 
Year Retorna o Número do Ano de uma 
Determinada Data 
 
 
 
Funções de Sistema Operacional 
 
Command Retorna o Argumento Informado na 
Linha de Comando Utilizado na 
Inicialização do Visual Basic ou de um 
Programa Executável Desenvolvido pelo 
mesmo 
CreateObject Cria um Objeto OLE 
CurDir Retorno a Pasta (ou diretório) Atual 
Dir Retorna o Nome do(s) Arquivo(s) ou 
Diretório(s) que combina(m) com o 
Padrão Especificado ou Atributo de 
Arquivo, ou Volume de um Drive 
DoEvents Interrompe Momentaneamente a 
Execução de seu Aplicativo para que o 
Sistema Operacional possa Processar 
outros Eventos 
Enviroment Retorna a String Associada a uma 
Microsoft Visual Basic 4.0 85
Variável de Ambiente do Sistema 
Operacional (como Path e Prompt, por 
exemplo) 
Error Retorna a Mensagem de Erro que 
Corresponde a um Dado Número de 
Erro 
GetObject Recupera um Objeto OLE de um 
Arquivo 
InputBox Exibe uma Caixa de Dialogo para que o 
Usuário possa Digitar uma Resposta 
Qualquer. Após Escolher um dos Botões 
Disponíveis, o VB Retorna o Valor 
Digitado 
LoadPicture Carrega uma Imagem dentro de uma 
Objeto Form Object, Controle 
PictureBox ou Controle Image 
MsgBox Exibe uma Mensagem em um Quadro 
de Dialogo e Espera que o Usuário 
Escolha um dos Botões Disponíveis. 
Após a Seleção, o VB retorna um Valor 
Indicando o Botão Escolhido 
QBColor Retorna o Valor da Cor RGB 
Correspondente ao Número de Cor 
Informado 
RGB Retorna um Número Representando 
uma Cor do Padrão RGB 
Shell Indica a Execução de um Programa 
Qualquer 
Spc Utilizada com o Comando Print # ou 
com o Método Print para Posicionar a 
Saída de uma Expressão Qualquer 
Tab Utilizada com o Comando Print # ou 
com o Método Print para Posicionar a 
Saída de uma Expressão Qualquer 
 
 
 
 
 
 
 4.11 Procedimentos 
 
 
 Nesta seção, aprenderemos o que são procedimentos, seus tipos e como 
e onde criá-los. 
Microsoft Visual Basic 4.0 86
 Veremos também como os mesmos podem aumentar em muito a nossa 
produtividade no desenvolvimento de aplicativos em Visual Basic. 
 Qualquer necessidade de informações adicionais consulte as referências 
citadas na Bibliografia Básica. 
 
 
 O que são Procedimentos ? 
 
 Os Procedimentos (ou Procedures) nada mais são do que uma 
determinada seqüência de comandos que são executados de uma só vez ao 
serem chamados, operando como um bloco de código para o aplicativo. 
 
 As funções que estudamos na seção anterior não deixam de ser 
procedures, pois apesar de você não poder ver o seu conteúdo, elas executam 
vários comandos internamente para realizarem as tarefas às quais as mesmas 
se propõem. 
 
 
 
Qual a Diferença entre Procedimentos Sub e Function? 
 
 
 A diferença básica entre estes dois tipos de procedimentos é que os 
procedimentos Function podem retomar valores para o aplicativo que solicitou a 
execução do procedimento, enquanto os procedimentos Sub não retomam 
valores. 
 
 Na seção anterior, você viu que ao chamarmos a função Date, obtivemos 
como resposta a data atual do sistema, sendo que esta resposta foi armazenada 
em uma variável de memória. Esta função poderia ser chamada em um 
procedimento como este: 
 
 Private Sub BtnExecutar Click( ) 
 
 Dim Valor As Date 
 
 Valor = Date 'Função Date 
 TxtEntrada. TEXT = "Função Date" 
 TxtResultado. TEXT = Valor 
 BtnExecutar.Enabled
= False 'Desabilita o botão Executar 
 BtnLimpar.Enabled = True 'Habílita o botão Limpar 
 
 End Sub 
 
 Neste caso o valor de retorno da função Date foi armazenado na variável 
de memória Valor. 
Microsoft Visual Basic 4.0 87
 Se você tentasse fazer o mesmo corn uma procedure Sub, receberia a 
seguinte mensagem de erro do Visual Basic: 
 
Expested Function or variable 
 
 
 Isto ocorre pois quando você atribui uma procedure a uma variável de 
memória como em 
 
 NovoValor = Calculaldade(“12/03/65") 
 
você está indicando ao Visual Basic que CalculaIdade é uma procedure do tipo 
Function, e que o valor de retorno gerado pela mesma será armazenado na 
variável de memória NovoValor. 
 Agora que você já sabe a diferença básica entre estes dois tipos de 
procedimento, vamos relembrar um pouco quais as vantagens de utilizarmos 
estes componentes em nossos aplicativos: 
 
 
 Porque Utilizar Procedimentos ? 
 
 
 Já falamos um pouco sobre a vantagem da utilização das funções no dia-
a-dia do programador, mas tendo em vista apenas as funções internas do Visual 
Basic. (Abordaremos os procedimentos desenvolvidos pelo usuário, também 
conhecidos como UDF (de User Defined Functions) ou funções definidas pelo 
usuário (isto no caso das funções) nos exercícios práticos. 
 
 Basicamente, existem três grandes vantagens em utilizarmos os 
procedimentos em nossos aplicativos: 
 
1. A primeira grande vantagem é a possibilidade de reaproveitarmos rotinas 
criadas anteriormente por nós (ou por outros) no desenvolvimento de novas 
aplicações, poupando com isso tempo e esforço. Você pode aproveitar 
Funções e Subs que realizará tarefas bem específicas (como um cálculo 
científico bastante complexo) já existentes em outro aplicativo desenvolvido 
por você, ou mesmo criadas por algum colega que seja especialista no 
assunto. Neste caso, o único cuidado a ser adotado por você é fornecer os 
argumentos corretamente e saber o que esperar como resposta. 
 
2. Outra vantagem indiscutível é a possibilidade de modularização de seu 
código, tornando mais legível e menos sujeito a erros. A modularização 
permite que você divida tarefas complexas em pedaços menores, como as 
Funções ou Subs. Desta forma, quando você tiver a certeza de que um 
determinado procedimento está operando corretamente, menores serão as 
chances de ocorrerem erros de processamento em seu aplicativo. 
Microsoft Visual Basic 4.0 88
 
3. Como vantagem adicional poderíamos citar a possibilidade de um programa 
ser desenvolvido por mais de um programador ao mesmo tempo. Basta 
definir que tarefas cada função deverá realizar, os dados que cada uma irá 
utilizar na entrada e a resposta que deverá ser obtida. Então, é só entregar 
a tarefa de codificação a cada um dos programadores e unir as Funções e 
Subs criadas por cada um deles em um único aplicativo. 
 
 
 
 Isto significa que você pode padronizar determinados procedimentos para 
serem reaproveitados em outros aplicativos, Imagine que você esteja 
desenvolvendo um programa para a sua empresa e que normalmente você 
necessita calcular a média de dois números, por exemplo. 
 Ao invés de reescrever as linhas de código que executam esta tarefa em 
cada um dos seus aplicativos, você poderia criar uma função que realizasse esta 
tarefa e simplesmente copiar o código desta função dentro de cada aplicativo 
quando fosse necessário. 
 
 Uma solução bastante prática seria criar uma função que recebesse os 
dois valores a serem calculados como argumentos, e que a mesma retomasse o 
valor resultante do cálculo da média dos dois números. Desta forma você não 
precisaria perder tempo definindo variáveis ou tipo de dados, simplificando 
bastante o seu trabalho. Um exemplo de como esta função seria utilizada em 
seus futuros aplicativos poderia ser a seguinte linha de código: 
 
 ValorMedio = CalculaMedia(12,5) 
 
 
 Agora que você já sabe as vantagens que a utilização dos procedimentos 
pode trazer aos seus aplicativos, vamos aprender a criar estes componentes na 
prática. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Microsoft Visual Basic 4.0 89
 
 
 
 
 
 Prática 16 
 
 
 
 Crie um formulário como o da figura abaixo : 
 
 
 Funções 
 
 
 
 Entrada 
 
 Resultado 
 
 
 
 Executar Limpar 
 
 
 
 Enabled = False 
 
 
 
 Nomeie os objetos conforme os label’s fornecidos no layout. 
 
 A seguir inclua o código seguinte no evento click do botão executar. 
 
CmdExecutar_click( ) 
 Dim Valor as date 
 Valor = Txtentrada.Text 
 TxtResultado.Text = Month(Valor) ‘esta função 
retorna a ‘parte da data que diz respeito ao mês 
 CmdExecutar.Enabled = False 
 CmdLimpar.Enabled = True 
 
 
 No evento click do objeto botão limpar insira o código: 
 
 TxtEntrada.Text = “” 
Microsoft Visual Basic 4.0 90
 TxtResultado.Text = “ “ 
 CmdLimpar.Enabled = False 
 CmdExecutar.Enabled = True 
 
 
 Execute a aplicação colocando uma data (D/M/A) no campo de 
entrada e pressionando executar. 
 
 
 
 Prática 17 
 
 
 
 Vamos ver agora, utilizando o formulário anterior, como funciona a 
função DATEDIFF, e como fazemos para criar um procedimento nosso. 
 
 Altere o código do evento click do botão executar colocando o 
código. 
 
 Dim Valor as Date, Retorno as Integer 
 
 Valor = TxtEntrada.Text 
 Retorno = Datediff (“d”, #1/1/95#, Valor) ‘Valor - 1/1/95 
 TxtResultado.Text = Retorno 
 CmdExecutar.Enabled = False 
 CmdLimpar.Enabled = True 
 
 
 Agora digite na parte General (declarations) o seguinte 
procedimento 
 
 Sub limpar 
 
 TxtEntrada.Text = “” 
 TxtResultado.Text = “ “ 
 CmdLimpar.Enabled = False 
 CmdExecutar.Enabled = True 
 
 End Sub 
 
 
 obs: Digite tudo. 
 
 
Microsoft Visual Basic 4.0 91
 Depois insira a chamada deste procedimento no evento click do botão 
limpar. 
 
 Sub cdmlimpar_click() 
 
 limpar ‘Chamando procedimento limpar 
 
 End sub 
 
 
 Execute novamente a aplicação e veja os resultados. Consulte a 
tabela de funções e verifique outras funções de manipulação de datas. 
 
 
 Prática 18 
 
 
 
 
 Construir um aplicativo VB que calcule a área de uma determinada 
figura geometrica. Formulário principal deverá conter o seguinte LayOut : 
 
 
 
 
 Cálculo de áreas 
 
 
 Escolha uma Opção 
 Form 
 O Cálculo da Área de um retângulo 
 
 O Cálculo da Área de uma Circunferência 
 
 O Cáluco da Área de um Triângulo 
 Frame 
 
 
 Termina 
 
 
 
Option Control Command 
 
 
 
Microsoft Visual Basic 4.0 92
 
 
 
 
Para cada cáculo de área deverá ser utilizado um formulário separado. 
 
 
 
 
 
 
 
 
 
 
 Exemplo : Cálculo da Área do Triângulo 
 
 
 Cálculo da Área de um Triângulo 
 
 Forneça : 
 
 Base Resultado 
 
 Altura 
 
 Calcular Voltar 
 
 
 
 
 Fórmulas : 
 
 
Área do Triângulo = (Base * Altura)/2 
 
Área do Retângulo = (LadoA * LadoB) 
 
Área da Circunferência = (Π * R2) , com Π = 3.1416 
 
 
 
 
 Este exercício não possui a resolução na apostila, 
tente realmente fazer sozinho!!!
Microsoft Visual Basic 4.0 93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Prática 19 
 
 
 
 Contruiremos um aplicativo bastante simples que nos ensinará a 
trabalhar com o controle Progressbar: 
 
 
 
 
 
 PROGRESSBAR 
 
 
 Crie um formulário com o seguinte conteúdo : 
 
 
 
 Utilizando PROGRESSBAR 
 
 
 
 
 
 
 Inicio Fim 
 
 
 
 
Controle 
Progressbar 
Microsoft Visual Basic 4.0 94
 Command 
 
 
 Depois insira o seguinte código na sua aplicação : 
 
CmdInicio_Click( ) 
 
Dim I as Integer 
For I = 1 to 1000 
 Progressbar.Value = i / 10 
Next I 
 
Cmd_Fim( ) 
End 
 
 Execute sua aplicação e teste novos valores para o laço acima. 
 
 
 
 Prática 20 
 
 
 
 Vamos construir um aplicativo que nos ensine a trabalhar com os 
controles: Lista de Drivers, Diretórios e Lista de Arquivos. 
 
• objetivo do nosso aplicativo é : o usuário “busca” através dos 
controles, um arquivo de figura e após selecioná-lo, o aplicativo 
imprimirá a figura em um segundo formulário. 
 
 Crie um formulário com os seguintes objetos: 
 
 
 Visualização de Figuras 
 
 
 
 Visualizar 
 
 
 
 Encerrar 
 
 
 
 
Microsoft Visual Basic 4.0 95
 
 
 
 
 
Drivers Diretórios FileListBox Command 
 
 
 
 
 Ajuste as seguintes propriedades aos objetos: 
 
 
 
 
 
 
 
Formulário: 
 
Name FrmLista 
Caption visualização de Figuras 
 
 
 
 
 
Command: 
 
Name CmdEncerrar 
Caption Encerrar 
 
Name CmdVisualizar 
Caption &Visualizar 
Default True 
Enabled False 
 
 
Driver: 
 
Name DrvDrives 
 
 
Diretório : 
 
Name DirDiretórios 
Microsoft Visual Basic 4.0 96
 
 
FileListBox : 
 
Name Filarquivos 
Pattern *.bmp (ou Icon) 
 
 
 
 Insira o código: 
 
 
CmdEncerrar_Click( ) 
 
 End 
 
CmdVisualizar_Click( ) 
 
Dim Arquivo as string 
Arquivo = ucase(filarquivos.path + “\”+ Filarquivos.filename) 
FrmVisualização.show 
 FrmVisualização.windowstate = 2 
 FrmVisualização.caption = ärquivo:”+ arquivo 
 FrmVisualização!imgfigura.picture = loadpicture(arquivo) 
 
 
DirDiretórios_change( ) 
 
 Filarquivos.path = disdiretorios.path 
 CmdVisualizar.Enable = false 
 
Drvdrives_change( ) 
 
 Dirdiretorios.path = Drvdrives.drive 
 Cmdvisualizar.enable = false 
 
Filarquivos_click( ) 
 
 Cmdvisualizar.enabled = true 
 
 
 Depois disso abra um novo formulário com a seguinte forma: 
 
 
 
 
Microsoft Visual Basic 4.0 97
 
 
 
 
 
 Image 
 
 
 
 
 
 Retorna 
 
 
 
 
 Command 
 
 
 
 
 
 
 
Propriedades: 
 
Formulário: 
 
Name FrmVisualização 
 
 
Image : 
 
Name ImgFigura 
 
 
 
 
 
Command: 
 
Name Cmdretorna 
Caption &Retorna 
Default True 
 
 
Microsoft Visual Basic 4.0 98
 Depois disto, insira o seguinte código no procedimento 
CmdRetorna_Click(): 
 
 FrmVisualização.WindowState = 0 
 Unload FrmVisualização 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Prática 21 
 
 
 
 Vamos aprender agora como trabalhar com os controles de barras 
verticais e horizontais (Controles ScrollBar). 
 
 Crie um formulário com os seguintes objetos : 
 
 
 
 Animação 
 
 
 
 
 Controle Image 
Microsoft Visual Basic 4.0 99
 (Situar na 
 Posição 1800,600) 
 
 Controle 
Barras 
Verticais 
Controle 
Barras 
Horizontais 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Propriedades: 
 
 
 Formulário : 
 
Name FrmBarras 
BackColor &H00FFFFFF& 
Caption Animação(demonstração scrollBar) 
 
 
 
 
 ScrollBar Vertical: 
 
 
Name VscrEixoY 
LargeChange 500 
Max 2000(tamanho do eixo) 
SmallChange 100(grid) 
 
 
 ScrollBar Horizontal: 
 
 
Name HscrEixoX 
LargeChange 500 
Max 2000 
SmallChange 100 
 
Microsoft Visual Basic 4.0 100
 
 
 
 Image: 
 
 
Name ImgFigura 
Picture (Sugestão : Arquivos de 
programa1\MicrosoftVisualBasic\Bitmap
s\Assorted\Beany 
 
 
 
 
 
 A seguir insira o código: 
 
 HscrEixoX_Change( ) 
 ImgFigura.Left = 1300 + HscrEixoX.Value 
 End Sub 
 
 VscrEixoY_Change( ) 
 ImgFigura.Top = 600 + VscrEixoy_value 
 End Sub 
 
 
 Execute a aplicação e faça alterações nas propriedades dos controles 
de barra para melhor compreendê-los. 
 
 
 
 
Módulo 5 
 
Criando Menus 
Personalizados 
 
 
 Neste módulo, aprenderemos a melhorar ainda mais a interface de nossa 
aplicação com usuário , desenvolvendo menus personalizados para a execução 
de tarefas 
Microsoft Visual Basic 4.0 101
 
 
 
 5.1 Incluindo Menus em nossa Aplicação 
 
 
 O Menu Editor 
 
 
 Criar menus de comandos no Visual Basic é bastante simples, pois o Menu 
Editor encarrega-se da parte gráfica, que sem dúvida alguma é a parte mais 
trabalhosa. 
 
 Você praticamente só irá definir os nomes dos menus, os comandos que 
cada um conterá e os procedimentos que serão executados quando o usuário 
selecionar uma das opções disponíveis no mesmo. 
 O Menu Editor não aparece na caixa de ferramentas junto com os demais 
controles, mas sim na barra de ferramentas do VB. 
 Selecione o ícone correspondente ou a opção Menu Editor no menu 
Tools. 
 
 
 5.2 Criando uma Barra de Menu 
 
 Da mesma forma que nunca devemos iniciar a criação de um aplicativo 
sem termos uma idéia bem-definida do que queremos que ele faça, também no 
caso dos menus é necessário ter em mente as opções que queremos que ele 
assuma, e os comandos que serão executados quando estas opções forem as 
escolhidas. 
 
 Também será necessário definirmos se determinadas opções do menu 
ficarão desabilitadas quando determinados comandos estiverem sendo 
executados pelo usuário. Tudo isso deverá estar definido antes de iniciarmos o 
trabalho de criação dos menus, a fim de evitarmos erros de concepção em 
nosso projeto. 
 
 O primeiro passo para criarmos urn menu é definirmos onde ele será 
incluído. Vamos abrir um novo projeto e deixar um formulário como a janela 
ativa do VB. 
 
 O próximo passo a ser dado é definir o nome que o nosso menu terá, ou 
seja, o nome que será exibido na barra de menu de nosso aplicativo. Em nosso 
exemplo, queremos que o primeiro menu a ser exibido tenha o nome de Arquivo. 
Este nome deverá ser incluído na caixa de texto Caption do Menu Editor. 
 
Microsoft Visual Basic 4.0 102
 Lembre-se de que sempre que você inclui o símbolo “&” antes de uma 
letra, ela é exibida no menu (ou controle) sublinhada, indicando que você pode 
acessá-la através da combinação de teclas ALT mais a letra destacada. 
 
 Em nosso caso, as tecias ALT+A abrirão o menu Arquivo que estamos 
criando. 
 
 Você também pode definir um nome para este menu. Da mesma forma 
como você faz com os controles de seu aplicativo, também é possível 
ajustarmos propriedades dos menus durante a execução de seu programa, 
habilitando e desabilitando opções, modificando nomes, etc. 
 
Este nome não aparece na tela, serve apenas para ser utilizado pelo seu 
código. Da mesma forma como já fizemos com vários controles de seu 
aplicativo, procure utilizar-se das letras mnu antes do nome do controle, a fim de 
facilitar o seu
trabalho de codificação. 
 Dê o nome de mnuArquivo para este controle e pronto, nosso menu já 
está criado, só que sem nenhum comando ainda. Por enquanto você só criou a 
palavra Arquivo no alto de sua tela. 
 
 Clique sobre o botão "OK" para fechar o Menu Editor e veja que o menu 
já foi incorporado ao seu formulário. 
 
 Coloque o seu aplicativo em execução e veja que o VB inclui o menu 
Arquivo, porém ele está vazio, isto é, não possui nenhum comando. 
 Pare a execução do aplicativo e abra novamente o Menu Editor. 
 
 
 
 5.3 Adicionando Itens em um Menu 
 
 
 Vamos incluir um ítem em nosso menu Arquivo. Clique sobre o botão 
“Next” (dentro da janela de Menu) e veja que o VB inclui uma nova linha em 
branco logo abaixo do menu existente, além de limpar os dados da janela. 
 
 Vamos incluir mais um ítem no menu Arquivo, desta vez o comando Sair, 
que encerrará a execução de nosso aplicativo. 
 Abra novamente o Editor de Menus e clique sobre a opção Abrir. A 
seguir, clique novamente sobre o botão "Next" para iniciar uma nova opção de 
menu e digite o comando &Sair. 
 Passe para a caixa de texto Name e dê o nome de MnuArquivoSair para 
este comando. Note que desta vez não é necessário dar um nível para a direita 
ao comando Sair, pois o VB assume que você está indo na seqüência de criação 
do menu Arquivo. 
Microsoft Visual Basic 4.0 103
 Feche a janela com o botão “OK” e dê uma olhada com está ficando o 
seu menu. Realmente está ficando muito bom! 
 
 Só para você ter uma idéia melhor de como funcionam os níveis, abra 
novamente o Editor de Menus e dê mais um nível para a direita no item Sair. 
 
 Feche a janela do Editor e veja que o VB criou um submenu dentro do 
menu Arquivo. 
 
 
 O VB permite que você crie até quatro níveis de submenus em seus 
aplicativos, que cá entre nós, é mais do que suficiente para a maioria das 
aplicações. 
 
 
 
 
 Apesar de termos citado no início deste módulo 
que os menus são importantes recursos para tornar 
 sua aplicação amigável, é bom evitar exageros. 
Nada é mais cansativo do que ter que abrir três 
ou quatro menus em cascata até encontrar o 
comando desejado. O ideal é utilizar menus 
 com no máximo dois níveis hierárquicos. 
 
 
 
 
 Utilize agora o botão com a seta para a esquerda para retomar a opção 
Sair à sua Posição original. 
 
 
 5.4 A Posição dos Itens no Menu 
 
 
 Você pode alterar facilmente a posição de um item no menu através das 
setas que apontam para cima e para baixo. 
 Basta destacar o comando a ser movido e escolher o botão adequado. 
 
 
 
 
 5.5 Incluindo novos Itens 
 
 
Microsoft Visual Basic 4.0 104
 Você pode incluir novos itens em um menu, simplesmente escolhendo o 
botão "lnsert". Basta selecionar um comando do menu e clicar sobre este botão. 
O VB deslocará o comando selecionado (e todos os abaixo deste) em uma linha, 
e você poderá incluir o novo comando em sua posição. Faça isso agora, 
selecionando o comando Sair com um clique e escolhendo o botão "Insert ". 
 
 Dê o Caption de &Imprime a este botão e o Name de 
MnuArquivoImprime. 
 Não se preocupe com este comando, pois vamos apagá-lo em seguida 
inclua mais um comando entre as opções Imprime e Sair, chamado de 
Ferramentas. Ajuste as suas propriedades conforme a seguir: 
 
 Caption: &Ferramentas 
 Name: MnuArquivoTools 
 
 
 
 5.6 Exibindo Separadores 
 
 
 Você já deve ter notado que determinados menus possuem linhas 
separando os seus diversos itens, tornando-os mais organizados. Aliás, quase 
todos os menus do VB possuem um separador de itens, que nada mais é do que 
uma linha que atravessa o menu de lado a lado. 
 
 Você também pode incluir este recurso em seus menus bastando para isso 
digitar na caixa de texto Caption um hífen (-). 
 
 Faça isso agora, selecionando o comando Sair com um clique e 
escolhendo a seguir o botão "lnsert", como você já sabe, será incluída uma nova 
opção entre os comandos lmprime e Sair. Digite o sinal - na caixa de texto 
Caption e dê o nome de MnuSeparador para este controle. 
 
 
 Feche o Menu Editor e veja o resultado obtido. 
 
 
 
Procure agrupar os comandos de 
seus menusdentro de uma determinada 
 lógica. Observe como os produtores de software 
organizam seus menus, separando as operações de acordo 
com a finalidade das mesmas. Isto ajuda muito o usuário 
 e até mesrno quem desenvolve, poistodos os comandos 
 relacionados a uma determinada tarefa ficam juntos, 
permitindo a sua rápida localização. 
Microsoft Visual Basic 4.0 105
 
 
 
 
 
 
 5.7 Eliminando Itens do Menu 
 
 
 Tão fácil quanto incluir é eliminar itens do menu. 
 Selecione o comando Imprime com um clique e em seguida escolha o 
botão "Delete". O item selecionado será eliminado do menu, e todos os itens 
serão reaiocados em suas novas posições. 
 
 
 
 5.8 Criando outro Menu 
 
 Bem, até agora criamos o menu Arquivo e alguns itens debaixo do 
mesmo. Mas, e como podemos criar um novo menu, como um menu Ajuda 
(Help), por exemplo? 
 
 Bem, o procedimento é o mesmo. Selecione o último comando do menu 
Arquivo (o comando Sair) e clique sobre o botão "Next". Como lhe dissemos, o 
VB assume que você pretende continuar criando comandos para o menu arquivo 
e obedece ao último nível existente. 
 
 Neste caso, você pode comunicar ao VB que está criando outro menu, 
simplesmente utilizando-se da tecla com a seta para a esquerda, aumentando o 
nível do menu. Então é só complementar as informações que você deseja. 
 
 Entre com os seguintes dados: 
 
 Caption: A&juda 
 Name: MnuAjuda 
 
 Inclua logo abaixo deste item (porém num nível inferior) o comando Sobre 
com as seguintes especificações: 
 
 Caption: S&obre 
 Name: MnuAjudaSobre 
 
 Pronto, já temos dois menus distintos criados. 
 
 Vamos Incrementá-los um pouco, utilizando mais alguns recursos 
existentes no Menu Editor. 
Microsoft Visual Basic 4.0 106
 
 
 
 
 
 
 
 
 5.9 Teclas de Atalho 
 
 Você já viu que basta utilizarmos o sinal “& antes de uma letra de um 
nome ou comando para criar uma tecla de atalho. Só que esta combinação de 
teclas que criamos refere-se somente ao acionamento da barra de menus. Você 
também pode utilizar o Menu Editor para definir teclas de atalho que executem 
tarefas, sem a necessidade de acionamento dos comandos via menu. 
 
 Um exemplo é o próprio Visual Basic., você pode abrir um projeto 
existente utilizando a combinação de teclas ALT+F (abre o menu File) e em 
seguida teclando “O” (de Open Project) ou sem ter que abrir nenhum menu 
através da combinação de teclas CTRL+O. 
 Note que por coincidência, as duas letras são iguais, mas isto não é uma 
regra obrigatória. Você pode observar isto no menu Tools, na Opção Menu 
Editor. Note que a combinação de teclas para este comando é CTRL+E, e não 
CTRL+M como pode parecer. 
 Repare ainda que a combinação de teclas de atalho é exibida no próprio 
menu ao lado do nome do comando. 
 Vamos fazer isto agora, atribuindo a combinação de teclas CTRL+A à 
tarefa de abrir um arquivo. 
 
 Selecione o comando Abrir no Menu Editor e clique sobre a caixa de 
listagem Shortcut (atalho). 
 Em nosso caso, vamos selecionar a combinação CTRL+A (de Abrir). 
 
 Note que não é necessário efetuar nenhum outro ajuste em seu aplicativo 
para que as teclas de atalho entrem em operação. Basta definir a procedure que 
está associada ao comando do seu menu e sempre que você acionar as teclas 
combinadas, o VB chamará automaticamente o procedimento correto. Perceba 
que a sua escolha passou a ser exibida no menu Arquivo, orientando o usuário 
sobre a nova possibilidade. 
 
 
 
 Uma boa regra para a definição de teclas de atalho é procurar 
associá-las com o nome da tarefa a ser executada. CTRL+A para Abrir um 
arquivo, CTRL+S para Salvar, CTRL+I para Imprimir,
e assim por diante. 
 
Microsoft Visual Basic 4.0 107
 
 
 
 
Outra sugestão é procurar definir as mesmas 
 letras tanto paras as teclas de atalho como para as 
opções dos menus. Note que é mais fácil associar Salvar 
com CRTL+S e Imprimir com CTRL+I, por exemplo, 
do que Imprimir com CTRL+P (de Print). 
 
 5.10 Marcando Opções de Menu 
 
 
 Outro recurso bastante interessante é a característica de acrescentarmos 
uma marca (ou check) em uma opção de menu, indicando a sua seleção ou não. 
 
 Este recurso é muito utilizado para indicar ao usuário as opções que 
estão ativadas ou não no momento, como por exemplo a opção Toolbar do 
menu View do Visual Basic. 
 Se você estiver visualizando a barra de ferramentas do software, a opção 
Toolbar estará marcada com o check, indicando a seleção. Se você clicar sobre 
este comando do menu novamente, apagará o check, e a barra de ferramentas 
deixará de ser exibida na tela. Para tornar a exibi-Ia basta repetir o 
procedimento, e a marca voltará a ser exibida ao lado do comando no menu. 
 
 No nosso aplicativo, o comando Ferramentas no menu Arquivo utilizará 
esta opção. Para isso destaque este comando na janela que mostra a 
hierarquia dos menus e clique sobre a caixa de verificação Checked. 
 Quando você observar o menu Arquivo da próxima vez, verá urna 
pequena marca do lado esquerdo do comando Ferramentas, indicando a sua 
seleção. 
 
 
 
Este recurso é muito interessante para ativar a 
exibição de janelas como caixas de Ferramentas, 
Paletas de Cores, exibir determinadas informaçõesa 
na tela, como a data e hora, por exemplo. 
 
 
 
 
 
 5.11 Desabilitando Opções de um Menu 
 
 
Microsoft Visual Basic 4.0 108
 Você pode criar menus em que determinadas opções estão desabilitadas 
inicialmente, e conforme o usuário vai realizando determinadas tarefas, estas 
opções de menu vão sendo habilitadas. 
 
 
 Este é um recurso super-importante para facilitar a vida dos usuários do seu 
sistema, pois se você deixar todas as opções dos menus habilitadas, pode haver 
casos (quase com certeza) que em determinadas situações, podem causar um 
erro ou pelo menos não executarem nada, deixando seu usuário perdido. 
 
 
 
 
 Um exemplo seria deixar a opção Imprime habilitada antes de o usuário ter 
aberto um arquivo qualquer. Neste caso, ao selecionar o comando Imprime, 
como reagiria o seu aplicativo? Por isso procure sempre ir habilitando as 
opções, conforme forem surgindo condições para a realização das tarefas 
disponíveis nos menus. 
 
 
 Para desabilitar uma opção de menu basta eliminar a marca da caixa de 
verificação Enabled do menu Editor. Mais tarde você poderá tornar esta opção 
ativa através de suas rotinas de código. Aliás, nós faremos o caminho inverso: 
desabilitaremos um comando quando ocorrerem determinadas condições em 
nosso aplicativo. 
 
 
 
 5.12 Ocultando Opções 
 
 
 Outro recurso disponível é a capacidade de ocultarmos comandos em 
nossos menus, ou seja, o comando existe, tem suas propriedades definidas, 
está associado a um evento, porém não aparece no menu. 
 
 Quando for o momento adequado, você altera a sua propriedade Visible e 
ele reaparece no menu, estando pronto para ser utilizado. 
 
 Isto é muito comum em aplicativos bem-planejados, como o Word, por 
exemplo. Se você fechar todas as janelas de documento abertas, o menu 
arquivo do Word exibirá quatro ou cinco opções de comandos. Se você abrir um 
arquivo qualquer, estas opções aumentam para doze comandos disponíveis! 
 
 
 
 
Microsoft Visual Basic 4.0 109
 
 
A grande vantagem deste tipo de recurso é que 
você exibe menus inteligentes, que apresentem 
somente opções aplicáveis à situação que o usuário 
se encontra no momento, tornando seu aplicativo 
mais fácil de ser usado pelos usuários. 
 
 
 
 
 
 
 
 
 
 5.13 Associando Eventos aos Comandos de Menu 
 
 
 Feche a janela do Menu Editor e selecione o menu Arquivo em seu 
formulário. Assim que ele for aberto, clique sobre a opção Sair. 
 O Visual Basic automaticamente abrirá a janela de códigos para que você 
crie os procedimentos que farão o seu aplicativo funcionar. 
 No caso específico da opção Sair do menu Arquivo, queremos que esta 
opção execute a tarefa de finalizar a aplicação. Desta forma vamos solicitar ao 
VB que execute o comando End quando este comando for selecionado no 
menu: 
 
 Private Sub MnuSair 
 End 
 End Sub 
 
 Execute o seu aplicativo e veja que o VB realmente obedece ao comando 
do menu. 
 
Microsoft Visual Basic 4.0 110
Módulo 6 
 
Quadros de Diálogo e 
Uso de Arquivos 
 
 
5.1 Criação de Quadros de Lista 
 
 
 Você usa quadros de lista quando tem uma série de escolhas para 
apresentar ao usuário e deseja limitar as escolhas. Ao contrário, um quadro 
combo é usado mais para escolhas sugeridas; ou seja, os usuários podem entrar 
com sua própria escolha no quadro de texto de um quadro combo, se quiserem. 
Digamos, por exemplo, que você tenha uma lista personalizada de 
aplicações do Windows, às quais o seu programa consegue iniciar; as escolhas 
poderão aparecer em um quadro de lista. Ou então, você pode apresentar as 
várias opções de atributo de arquivo (arquivo simples, leitura, escondido etc.) 
quando gravar em um arquivo. 
Em geral, os quadros de lista podem ser úteis em qualquer lugar onde 
existe uma série de escolhas. E como esses quadros de lista podem ter barras 
de paginação, o número dessas escolhas pode ser muito maior do que você 
pode apresentar em um menu (o que os torna usuais em quadros de diálogo). 
 
 Como exemplo, vamos reunir um programa de minibancos de dados. Os 
bancos de dados normalmente ordenam seus registros de dados de acordo com 
alguma chave. Você pode fazer isso aqui com um quadro de lista. Digamos que 
esse programa de bancos de dados deve acompanhar um inventário de estoque 
numa farmácia ou na sua gaveta de medicamentos. Você poderia querer 
acompanhar coisas como: 
 
 
 Nome do produto 
 
 Quantidade do produto 
 
 Comentários 
 
 
 Por exemplo, se tivéssemos sete vidros de aspirina, cada um com 100 
comprimidos, os dados poderiam ser estes: 
 
 Nome do produto: "Aspirina" 
 
 Quantidade do produto: "7" 
Microsoft Visual Basic 4.0 111
 
 Espaço adicional para comentários: "Vender até quinta-feira." 
 
 Cada um desses itens ("Aspirina", "7" e "Vender até quinta-feira.") é 
chamado campo em um banco de dados . Juntos, eles compõem um registro. 
Para preparar nossa aplicação, podemos incluir um menu à nossa janela 
principal, com um item chamado Find Record... [encontrar registro]; quando 
selecionado, um quadro de diálogo será aberto com um quadro de lista 
mostrando os nomes associados a cada registro - por exemplo, Aspirina, 
Bandagem, Creme para Mãos etc. 
 
 Dando um duplo clique em um desses nomes, o usuário pode fazer 
aparecer o registro correspondente (isto é, o quadro de diálogo desaparece e os 
dados do registro são colocados em quadros de texto na janela principal). Uma 
das propriedades dos quadros de lista que nos ajudará aqui é a propriedade 
Sorted; se for True, o Visual Basic manterá todos os itens no quadro de lista 
ordenados alfabeticamente. Em outras palavras, o Visual Basic cuidará 
automaticamente da ordenação dos nossos produtos. 
 
 Para projetar essa aplicação, inicie o Visual Basic, chame esse projeto de 
Database.vbp e dê ao formulário a legenda "Database". Precisaremos de três 
quadros de texto nesse formulário principal, que podemos chamar Name, 
Number e Comment, aos quais podemos dar os Names NameField, 
NumberField e CommentField. De fato, podemos tornar o quadro de comentário 
um quadro de texto multilinhas, de modo que possamos armazenar bastante 
texto nele. Em seguida, podemos incluir um menu chamado File, com os 
seguintes
itens:Add Item, Find Item..., Save File.... Load File... e Exit. 
 
 Para a primeira escolha de menu, Add Item, vamos usar o Name 
AddAnItem (Addltem é uma palavra reservada, como veremos); esse item está 
disponível para que o usuário possa preencher o banco de dados. 
 
Depois de editar os três quadros de texto, o usuário poderá selecionar 
Add Item para incluir esse dado a um novo registro no nosso banco de dados. 
Podemos usar o Name Findltem para a próxima escolha de menu, Find Item ... ; 
esse item é aquele que abrirá o quadro de diálogo (o quadro de diálogo conterá 
o quadro de lista que mantém os nomes do produto de cada registro, ordenados 
alfabeticamente). 
 
Quando o usuário der um duplo clique em um item na lista, o quadro de 
diálogo desaparecerá e o registro correto aparecerá na janela principal. Você 
aprenderá a incluir o código para os dois itens de menu seguintes, Save File... e 
Load File.... neste módulo sobre arquivos. Enquanto isso, dê-lhes os Names 
Saveltem e Loadltem. 
 
 Vamos escrever primeiro a procedure AddAnltem_Click( ). Acione a 
escolha de menu Add Item, abrindo este gabarito de procedure Sub: 
Microsoft Visual Basic 4.0 112
 
 Sub AddAnItem_Click( ) 
 
 End Sub 
 
 Quando o usuário acionar Add Item, ele desejará que o conteúdo ativo 
dos quadros de texto seja armazenado no banco de dados. Podemos fazer isso 
definindo algumas variáveis globais (observe que elas devem ser variáveis 
globais, e não em nível de formulário, pois nosso quadro de diálogo um 
formulário inteiramente separado - terá que alcançar todas elas) da seguinte 
forma em um módulo chamado Database.Bas (Selecione o ícone de inserção de 
módulos no toolbar): 
 
 Global Names(100) As String 
 Global Numbers(100) As String 
 Global Comments(100) As String 
 Global TotalRecords As Integer 
 
 
 Desse modo, estamos separando espaço suficiente para manter registros 
para 100 produtos. Observe também que estamos registrando o número total de 
registros em um inteiro global chamado TotalRecords. Agora estamos livres 
para preencher esses arrays com dados, pois o usuário colocou os dados de 
que precisamos nos quadros de texto da janela principal antes de acionar Add 
Item. Ou seja, podemos armazenar dados em nossos arrays de bancos de 
dados dessa forma em AddAnItem_Click( ). Observe que incrementamos 
TotalRecords primeiro, pois estamos incluindo um novo registro: 
 
 
 
 Sub AddAnItem_Click( ) 
 
 TotalRecords = TotalRecords + 1 
 Names(TotalRecords) = NameField.Text 
 Numbers(TotalRecords) = NumberField.Text 
 Comments(TotalRecords) = CommentField.Text 
 . 
 . 
 
 End Sub 
 
 
 
 Por exemplo, suponha que estamos para criar o primeiro registro, e estes 
são os dados nos quadros de texto da janela principal: 
 
Microsoft Visual Basic 4.0 113
 
 
 Nome do produto: "Aspirina" 
 
 Quantidade do produto: "7" 
 
 Espaço adicional para comentários: "Vidros com 100 comprimidos 
cada." 
 
 
 Você definiria Names(1) com "Aspirina", Numbers(1) com "7" e 
Comments(1) com "Vidros com 100 comprimidos cada.". Agora que 
armazenamos os dados, temos que incluir o nome desse produto (Aspirina) ao 
nosso quadro de lista organizado em ordem alfabética automaticamente, de 
modo que o usuário possa selecionar com facilidade os registros. Fazemos isso 
com o método AddItem. Observe que este é um método, o que significa que 
temos que conectá-lo ao nome do quadro de lista que queremos mudar. Por 
exemplo, podemos chamar de NameList o quadro de lista que mantém todos os 
nomes de produto, o que significa que incluiríamos essa linha em 
AddAnltem_Click( ): 
 
 
 Sub AddAnItem_Click( ) 
 
 TotalRecords = TotalRecords + 1 
 Names(TotalRecords) = NameField.Text 
 Numbers(TotalRecords) = NunmberField.Text 
 Comments(TotalRecords) = CommentField.Text 
 Form2.NameList.Addltem NameField.Text 
 
 End Sub 
 
 
 Form2 é o nome do segundo formulário, que aparecerá quando o usuário 
quiser selecionar um registro. Em geral, é assim que você usa AddItem no 
Visual Basic: 
 
 
 formulário.quadro_de_lista.Addltem string$ [índice] 
 
O argumento opcional chamado índice especifica a posição da nova 
entrada no quadro de lista, onde 0 (no alto do quadro de lista) é a primeira 
posição, a próxima é 1, e assim por diante. 
 
Microsoft Visual Basic 4.0 114
Como nosso quadro de lista será ordenado automaticamente, não 
especificaremos um índice para nossas entradas. Em contrapartida, para 
remover um item, você poderá usar o método Removeltem: 
 
 
 formuláno.quadro_de_lista.RemoveItem índice 
 
 Aqui, um índice não é opcional. Você deverá usá-lo para especificar qual 
item na lista deverá ser removido. E isso é tudo para a inclusão de um item. 
 
O passo seguinte é encontrar itens conforme a necessidade. Acione a 
escolha de menu Find Item... para fazer surgir este gabarito: 
 
 
 
 Sub FindItem_Click( ) 
 
 End Sub 
 
 
 O trabalho real de encontrar um registro será feito pelo segundo 
formulário, Form2. Agora podemos mostrá-lo na tela. 
 
 
 Sub FindItem_Click( ) 
 
 Form2.Show 
 
 End Sub 
 
 
 
 E isso é tudo para Findltem_ Click( ). Vamos projetar agora o quadro de 
diálogo chamado Form2. 
 
Crie Form2 acionando o item New Form do menu File do Visual Basic, 
dando-lhe uma legenda de Find Item.... Remova os botões Min e Max, dando ao 
formulário uma borda fixa por meio da seleção da propriedade Minbotton, 
Maxbotton e BorderStyle. Em seguida, crie um quadro de lista acionando a 
ferramenta de quadro de lista na caixa de ferramentas. Dê a esse quadro de 
lista o Name que já usamos, NameList. Defina a propriedade Sorted para True, 
de modo que as entradas nele apareçam em ordem alfabética. 
 
Observe que o Name, NameList, aparece no quadro de lista; ele 
desaparecerá em tempo de execução. Não existem barras de paginação nessa 
Microsoft Visual Basic 4.0 115
lista, mas elas aparecerão automaticamente se a lista for muito longa para o 
quadro. 
 
 Agora inclua os dois botões de controle normais para um quadro de 
diálogo, OK e Cancel, com os Names OKButton e CancelButton. É sempre bom 
tornar o botão OK o padrão (isto é, definir sua propriedade Default para True). 
Como antes, é fácil escrever a procedure CancelButton - tudo que precisamos 
fazer é esconder Form2 da seguinte forma: 
 
 
 Sub CancelButton_Click( ) 
 
 Form2.Hide 
 
 End Sub 
 
 
 Agora vamos trabalhar com a procedure OKButton_Click( ) do quadro de 
diálogo: 
 
 
 OKButton_Click( ) 
 
 End Sub 
 
 
 Quando o usuário acionar o botão OK - ou der duplos cliques em um item 
no quadro de lista, ele terá selecionado um item no quadro de lista, e deveremos 
mostrar o registro correspondente. 
 
 Então acionar em Aspirina preencherá os quadros de texto da janela 
principal com os dados que já armazenamos usando Add Item: 
 
 
 Nome do produto. "Aspirina" 
 Quantidade do produto: “7" 
 Espaço adicional para comentários: “Vidros com 100 comprimidos 
cada." 
 
 
 
 Em geral, podemos determinar qual o item selecionado em um quadro de 
lista (um item sempre está selecionado em quadros de lista) usando estas 
propriedades do quadro de lista: 
 
 
Microsoft Visual Basic 4.0 116
 
 Text O item atualmente selecionado 
 
 List Array de string contendo todos os itens 
 
 Listlndex O índice do item selecionado (base O) 
 
 ListCount Número total de itens na lista 
 
 
 
 A propriedade mais usada é Text, um string que mantém o item 
atualmente selecionado. No entanto, os outros também são muito úteis (e 
poderíamos notar que Text = List(Listlndex)). 
 
No nosso caso, teremos que encontrar o registro correspondente à 
seleção e exibi-lo. Podemos encontrar o registro correto com um loop, em 
OKButton_click(
), da seguinte forma: 
 
 
 Sub OKButton_click( ) 
 
 For loop_index = 1 To 100 
 
 If Names(loop_index) = NameList.Text Then Exit 
For 
 
 Next loop_index 
 . 
 . 
 
 Aqui estamos apenas comparando o nome do produto selecionado com 
os nomes de produto de cada registro. Quando encontrarmos o que queremos 
(ele deverá estar na lista, pois o quadro de lista simplesmente mostra esses 
nomes), saímos do loop com o comando Exit For do Visual Basic. Nesse ponto, 
podemos preencher os campos corretamente no formulário principal e esconder 
Form2 da seguinte forma: 
 
 
 Sub OKButton_click( ) 
 
 For loop_index = 1 To 100 
 If (Names(loop_index) = NameList.Text) Then Exit 
For 
 Next loop_index 
 
Microsoft Visual Basic 4.0 117
 Form1.NameField.Text = Names(loop_index) 
 Form1.NumberField.Text = Numbers(loop_index) 
 Form1l.CommentField.Text = Comments(loop_index) 
 
 Form2.Hide 
 
 End Sub 
 
 
 
 Devemos observar que os eventos importantes para quadros de lista são 
Click, quando o usuário faz uma seleção, e DblClick, quando o usuário faz uma 
escolha. Isso significa que dar um duplo clique em um item é o mesmo que 
acionar o botão OK, de modo que podemos incluir a mesma procedure: 
 
 
 Sub NameList_DblClick( ) 
 
 For loop_index = 1 To 100 
 If (Names(loop_index) = NameList.Text) Then Exit 
For 
 Next loop_index 
 
 Form1.NameField.Text = Names(loop_index) 
 Form1.NumberField.Text = Numbers(loop_index) 
 Form1.CommentField.Text = Comments(loop_index) 
 
 Form2.Hide 
 
 End Sub 
 
 A única coisa restante a fazer é tornar o item Exit ativo no menu da janela 
principal, o que fazemos pelo modo comum, com o comando End do Visual 
Basic: 
 
 
 Sub ExitItem ( ) 
 
 End 
 
 End Sub 
 
 
 Você irá utilizar o programa acima digitando dados nos quadros de texto 
da janela principal. Quando você quiser ler um registro, poderá selecionar Find 
Item... no menu File para gerar nosso quadro de diálogo na tela. Selecione o 
Microsoft Visual Basic 4.0 118
item no quadro de lista e acione o botão OK, ou então dê um duplo clique no 
item do quadro de lista, e os registros desse item aparecerão na janela principal. 
 
 Entretanto, poderíamos observar que tivemos que duplicar o mesmo 
código em NameList.DblClick( ) e OKButton_Click( ) - isto é, os dois mostram os 
registros do produto selecionado. Uma maneira de evitar isso é colocar esse 
código em um módulo, e chamá-lo a partir dessas duas procedures. 
 
Por exemplo, se criássemos uma procedure Sub contendo todo esse 
código, chamada GetItem( ), poderíamos mudar NameList.DbiClick( ) e 
OKButton_Click( ) para: 
 
 
 
 Sub NameList.DblClicko 
 GetItem 
 End Sub 
 
 
 Sub OKButton_Click( ) 
 Getltem 
 End Sub 
 
 
Com GetItem igual a: 
 
 
Sub Getltem( ) 
 
For loop_index% = 1 To 100 
 If (Names(loop_index%) = Form2.NameList.Text) Then 
Exit For 
Next Ioop_index% 
 
Form1.NameField.Text = Names(loop_index%) 
Form1.NumberField.Text = Numbers(loop_index%) 
Form1.CommentField.Text = Comments(loop_index%) 
Form2.Hide 
 
End Sub 
 
 
 
Os arrays globais Names( ), Numbers( ) e Comments( ), logicamente, não são 
ligados a formulário algum. Esse módulo é como qualquer outro arquivo 
associado ao projeto ativo; ou seja, ele é salvo e carregado junto com os outros. 
Microsoft Visual Basic 4.0 119
 
 
 5.2 Criação dos nossos próprios Tipos De Dados 
 
 
 Como o programa de bancos de dados se encontra, estamos 
mantendo três arrays de dados: 
 
 Global Names(100) As String 
 Global Numbers(100) As String 
 Global Comments(100) As String 
 
 
 Na verdade, campos como estes são normalmente reunidos no seu 
próprio tipo (e isso nos leva a um poderoso conceito no Visual Basic). Em geral, 
esse tipo de declaração (que ocorre sempre no módulo global) se parece com 
isto: 
 
 
 
 Type nometipo 
 nomeelemento As tipovariável 
 [nomeelemento As tipovariável] 
 [nomeelemento As tipovariável] 
 . 
 . 
 End Type 
 
 Por exemplo, podemos criar um tipo Record para nosso banco de 
dados da seguinte forma: 
 
 
 Type Record 
 Name As String * 50 
 Number As String * 20 
 Comment As String * 200 
 End Type 
 
 
 Esse código define um novo tipo de dados, Record, que contém os 
campos individuais, como mostramos acima. Observe que estamos dando a 
cada string um tamanho definido - isso é o que significam os caracteres * 50, *20 
e * 200. Name As String * 50 significa que o string chamado Name terá 
exatamente 50 caracteres de extensão. Podemos declarar um array desse tipo 
chamado, digamos, TheData( ), da seguinte forma: 
 
Microsoft Visual Basic 4.0 120
 
Type Record 
Name As Stririg * 50 
Number As String * 20 
Comment As String * 200 
End Type 
 
 Global TheData(100) As Record 
 
 
 
Podemos alcançar qualquer um deles usando o operador ponto (.) (assim 
como fazemos para alcançar uma propriedade do Visual Basic): 
 
 
TheData(3).Name = "Cenoura" 
TheData(3).Number = "287" 
TheData(3).Comment = "Preço muito alto?" 
 
 
Vamos usar esse novo array na nossa aplicação de bancos de dados 
para combinar todos os três arrays separados, Names( ), Numbers( ) e 
Comments( ), juntos em um array - Database( ). 
 
Depois de definir o tipo do novo registro, Record, e o array desse tipo, 
Database( ), temos que mudar as referências correspondentes no nosso 
programa. Por exemplo, Names(TotalRecords) torna-se 
TheBase(TotalRecords).Name. 
 
Existem apenas duas procedures Sub para mudar, a procedure em que 
armazenamos os dados e a procedure em que os recuperamos. Em Form1, a 
procedure para incluir um item deverá ser mudada disto: 
 
 
Sub AddAnItem_Click( ) 
 
TotalRecords = TotalRecords + 1 
Names(TotalRecords) = NameField.Text 
Numbers(TotalRecords) = NumberField.Text 
Comments(TotalRecords) = CommentField.Text 
Form2.NameList.AddItem NameField.Text 
 
End Sub 
 
 
para isto: 
Microsoft Visual Basic 4.0 121
 
Sub AddAnItem_Click( ) 
 
TotalRecords = TotalRecords + 1 
TheData(TotalRecords).Name = NameField.Text 
TheData(TotalRecords).Number = NumberField.Text 
TheData(TotalRecords).Comment = CommentField.Text 
 
Form2.NameList.AddItem NameField.Text 
 
End Sub 
 
Aqui, apenas mudamos Names(TotalRecords) para 
TheData(TotalRecords).Name, e assim por diante. 
 
Além disso, no nosso módulo, temos que mudar a procedure para 
pesquisar um item, Getltem( ), disto: 
 
 Sub GetItem( ) 
 
For loop_index = 1 To 100 
 If (Names(loop_index%) = Form2.NameList.Text) Then 
Exit For 
Next loop_index 
 
Form1.NameField.Text = Names(loop_index) 
Form1.NumberField.Text = Numbers(loop_index) 
Form1.CommentField.Text = Comments(loop_index) 
 
 Form2.Hide 
 
End Sub 
 
 
 
para isto: 
 
Sub GetItem( ) 
 
For loop_index = 1 To 100 
lf (Rtrim$(TheData(loop_index).Name) = 
 Rtrim$(Form2.NameList.Text)) Then Exit For 
Next loop_index 
 
Form1.NameField.Text = TheData(loop_index).Name 
Form1.NumberField.Text = TheData(loop_jndex).Number 
Microsoft Visual Basic 4.0 122
Form1.CommentField.Text = TheData(loop_jndex).Comment 
 
Form2.Hide 
 
End Sub 
 
 
Observe que estamos usando um string de tamanho fixo para todos os 
campos. Como o Visual Basic completa esses strings com espaços à direita, 
tivemos que remover esses espaços com a função Rtrim$( ) do Basic; seu 
correspondente para retirar espaços à esquerda é Ltrim$( ). A função Rtrim$( ) 
simplesmente retira quaisquer espaços do lado direito dos strings antes de 
compará-los com os itens no quadro de lista. 
 
 
 
 5.3 Criação de Quadros Combo 
 
A diferença entre quadros combo e quadros de lista é que os quadros 
combo combinam um quadro de lista com um quadro de texto
(motivo pelo 
qual eles são chamados quadros combo), de modo que os usuários possam 
digitar seu próprio texto se não quiserem selecionar urna das escolhas 
oferecidas. Existem três estilos diferentes de quadros combo. 
 
O primeiro deles (estilo 0) é o quadro combo padrão, onde a seta fica 
separada do quadro de texto. Quando o usuário acionar a seta, a lista de itens a 
escolher cairá. O segundo estilo (estilo 1) é o mesmo, exceto que o quadro de 
lista é sempre mostrado. O terceiro estilo (estilo 2), com a seta conectada, não 
é realmente um quadro combo: é um quadro de lista (chamado quadro de lista 
suspensa). Esse é o mesmo que o quadro de lista normal (ou seja, o usuário 
não pode editar as seleções conforme pode em um quadro combo), exceto que 
a lista fica escondida até que o usuário acione a seta. 
 
Como os quadros combo em estilo 2 são realmente quadros de lista, nós 
os veremos antes de trabalhar com os quadros combo reais. 
 
 É fácil adaptar nossa aplicação de bancos de dados para usar quadros de 
lista suspensa em vez de quadros de lista normais. Tudo que precisamos fazer 
é excluir o quadro de lista chamado NameList em Form2 e substituí-lo por um 
quadro combo, estilo 2, chamado NameList. Para fazer isso, acione o quadro de 
lista original e selecione Cut no menu Edit. Em seguida, acione na ferramenta 
de quadro combo na caixa de ferramentas (em seguida à ferramenta de quadro 
de lista), selecione o estilo 2 e posicione-o corretamente. 
 
 Como você pode ver, isso permite que o quadro de diálogo Find Item... seja 
muito mais compacto. Usar um quadro de lista suspensa é fácil. 
Microsoft Visual Basic 4.0 123
 
Agora vejamos os próprios quadros combo. Como o usuário pode mudar ou 
editar o item no quadro de texto que faz parte do quadro combo, os dois eventos 
importantes conectados aos quadros combo são Click e Change (o evento Change 
ocorre quando o texto no quadro é alterado). Além disso, um quadro combo simples 
(estilo 1, e não um quadro suspenso) reconhece o evento DblClick, mas o outro quadro 
combo (estilo 0), não. Aqui estão as propriedades associadas aos quadros combo: 
 
Text O item atualmente selecionado 
List Array de String contendo todos os itens 
 
Listlndex O índice do item selecionado (base 0; -1 se o usuário entrou 
com texto em vez de selecionar um item) 
 
ListCount Número total de itens na lista 
 
 
 
Na verdade, as propriedades de um quadro combo são muito parecidas com as 
propriedades de um quadro de lista, mas com uma diferença: se o usuário digitou a 
seleção ativa em vez de selecioná-la pela lista disponível (uma opção que não existe 
com quadros de lista), então a propriedade ListIndex é definida em -1. 
 
Quanto ao restante dos detalhes dos quadros combo - manter o texto 
selecionado, marcar o texto e assim por diante -, o Visual Basic cuida disso para você. 
 
Para ver como isso funciona, vamos alterar nosso programa de bancos 
de dados para mostrar seus nomes de produto em um quadro combo em vez de 
um quadro de lista. 
 
A vantagem é que o usuário poderá simplesmente digitar o nome do 
produto que está procurando em vez de pesquisar por uma lista que poderia ser 
muito longa. Infelizmente, há a possibilidade de a entrada selecionada não 
corresponder a registro algum (isto é, no caso de o usuário ter errado na 
digitação do nome do produto). 
 
Isso é algo que teremos que verificar quando o usuário acionar o botão 
OK. 
 
Enquanto isso, abra a aplicação de bancos de dados no Visual Basic e 
selecione o quadro de lista suspensa que acabamos de incluir nele. Como o 
Visual Basic o trata como um quadro combo de estilo 2, podemos mudá-lo para 
outro tipo de quadro combo sem substituí-lo. Vamos usar o estilo de quadro 
combo 0. Embora devamos renomeá-lo de NameList para NameCombo, é mais 
Microsoft Visual Basic 4.0 124
conveniente deixar o nome como NameList, pois o código já se refere a ele 
dessa forma. 
 
 
Agora temos que nos assegurar de que a seleção realmente corresponde 
a um dos registros. Para isso, podemos incluir este código em nossa procedure 
Sub Getltem( ): 
 
 
Sub GetItem( ) 
 
Matched = False 
For loop_index = 1 To 100 
lf (Rtrim$(TheData(loop_index).Name) = 
Rtrim$(Form2.NameList.Text)) Then 
Matched = True 
Exit For 
End If 
Next loop_index 
 
lf (Matched) Then 
Form1.NameField.Text = TheData(loop_index).Name 
Form1.NumberField.Text = TheData(loop_index).Number 
Form1.CommentField.Text = 
TheData(loop_index).Comment 
Form2.Hide 
 Else 
MegBox “Sorry, I cannot find the record.”, 48, 
“Database” 
End If 
 
End Sub 
 
 
Aqui, se não pudermos achar o registro que foi digitado, geramos um 
quadro de mensagem de erro e deixamos o usuário começar de novo. Depois 
dessa mudança, o programa funciona como antes, exceto que agora o usuário 
pode digitar o nome do registro que está procurando como um atalho. No 
entanto, se o usuário entrar com o nome de um registro que não combine com 
um dos registros existentes, aparecerá um quadro de erro. 
 
 
 
 5.4 Uso de Arquivos 
 
 
Microsoft Visual Basic 4.0 125
 Nesta seção você verá como trabalhar com arquivos no Visual Basic. O 
modo mais comum de manter seus dados após o término de um programa é 
armazená-los em arquivos. Esta seção discute essa importante habilidade, além 
dos seguintes tópicos: 
 
• Criação, abertura e fechamento de arquivos 
 
• Leitura e gravação de arquivos 
 
• As funções de fim de arquivo (EOF) e tamanho de arquivo (LOF) 
 
• Arquivos seqüenciais 
 
• Arquivos de acesso aleatório 
 
• Quadros de lista de diretório 
 
• Quadros de lista de arquivo 
 
• Quadros de lista de unidade 
 
• O comando Seek 
 
• Os comandos Get e Put 
 
• Como cuidar de erros de arquivo 
 
 
 
 Você também incluirá capacidades de manipulação de arquivos a alguns 
dos programas que já desenvolveu, sobretudo nos programas Editor e 
Database. 
 
 A maior parte dos programas do Windows usa arquivos de algum tipo, de 
modo que a capacidade de uso de arquivos será importante para todos os tipos 
de programas: programas gráficos, processadores de textos, programas de 
bancos de dados etc. 
 
 Você deve se lembrar de que nosso programa Editor tinha duas escolhas 
de menu que nunca foram usadas: Load File... e Save File.... Até agora, todos 
os dados que nossos programas usaram foram temporários. 
 
 Quando a aplicação terminava, eles desapareciam. Os arquivos, é claro, 
são o meio mais comum de armazenar dados no PC, de modo que são 
vitalmente importantes à maior parte das aplicações do computador. 
 
Microsoft Visual Basic 4.0 126
O sistema de comandos de manipulação de arquivos no Visual Basic é 
muito semelhante ao que existe em outros Basics; logo, se você estiver 
acostumado com Open, Close, lnput$ e Seek, já terá um bom ponto de partida. 
No entanto, como você já deve imaginar, as coisas são muito diferentes quando 
se trata da interação com o usuário. 
 
 Por exemplo, o usuário normalmente seleciona nomes de arquivo para 
carregar ou salvar dados por meio de quadros de diálogo em aplicações do 
Windows (o que, a propósito, é o motivo para vermos os quadros de diálogo 
antes dos arquivos), e veremos como fazer isso nesta seção, à medida que 
prepararmos nosso quadros de diálogo de arquivo. 
 
 Dois desses quadros de diálogo serão para os itens Save File... e Load 
File... da nossa aplicação Editor. Além disso, também veremos como trabalhar 
com arquivos estruturados, onde os dados são divididos em registros 
específicos, como a nossa aplicação de bancos de dados na seção anterior. De 
fato, poderemos modificar essa aplicação nesta seção de modo que ele possa 
salvar seus dados no disco. Com isso e outros tópicos que irão aparecer,
por 
que não começar imediatamente? 
 
 
 
 
 
 
 Gravação de dados em um Arquivo 
 
 
 Se quisermos incluir suporte para arquivo à nossa aplicação de editor, 
poderemos começar com o item Save File... (afinal, temos que criar e salvar 
arquivos antes de lê-los de volta). 
 
 Quando você selecionar o item Save File.... poderá gerar um quadro de 
diálogo na tela com um quadro de lista e dois botões: OK e Cancel. Você 
poderia então digitar o nome do arquivo em que deseja salvar seu documento, e 
o seu programa criaria o arquivo com esse nome (se necessário) e depois 
armazenaria lá o documento. 
 
Para colocar isso em prática, inicie o Visual Basic e abra o projeto Editor. 
Se você der uma olhada no menu File, verá que o item Save File... já existe. 
Acione-o com o mouse para gerar o seguinte gabarito: 
 
 
Sub SaveItem_Click( ) 
 
 
Microsoft Visual Basic 4.0 127
End Sub 
 
 
 Para salvar o documento ativo, você deverá colocar o quadro de diálogo 
Save File... na tela. Vamos nomear o quadro de diálogo com SaveForm. Para 
apresentá-lo, tudo o que precisamos fazer é isto: 
 
 
Sub SaveItem_Click ( ) 
 
 SaveForm.Show 
 
End Sub 
 
 
 
 Em seguida, devemos montar esse quadro de diálogo (ainda no projeto 
Editor), nomeando-lhe SaveForm, dando uma legenda Save File..., e salvar 
nosso trabalho como, digamos, SaveForm.Frm. Além disso, temos que incluir 
um quadro de texto a esse novo formulário; colocar um label acima do quadro de 
texto, com os dizeres Save File As... (de modo que o usuário saiba que deverá 
entrar com um nome de arquivo), incluir um botão OK com sua propriedade 
Default em True, e um botão Cancel. 
 
 Finalmente, como esse é um quadro de diálogo, podemos remover os 
botões Min e Max. 
 
 
 
 A procedure do botão Cancel é muito fácil, de modo que poderemos fazer 
isso primeiro. Tudo que precisamos fazer se o usuário decidir cancelar é ocultar 
novamente o formulário, e, para tanto, colocaremos isto em CancelButton_Click( 
): 
 
 
 
Sub CancelButton-Click ( ) 
 
 SaveForm.Hide 
 
End Sub 
 
 
 
 O serviço real é feito quando você aciona o botão OK. Acione esse botão 
para abrir a procedure click do botão OK, da seguinte maneira: 
 
Microsoft Visual Basic 4.0 128
 
 
Sub OKButton_Click ( ) 
End Sub 
 
 Quando atingirmos esse ponto no programa, poderemos supor que o 
texto em FilenameBox contém um nome de arquivo e que deveremos salvar o 
documento ativo - ou seja, o string chamado Form1.display.Text - a este arquivo. 
 
 Existem três passos nesse processo: abrir o arquivo (ou criá-lo, se ainda 
não existir), gravar os dados no arquivo e fechá-lo. Podemos dar uma olhada 
em cada um desses três passos em ordem enquanto montamos OKButton-
Click(); cada passo nos dirá algo sobre o sistema de arquivo do Visual Basic. 
 
 
 
 Abertura de Arquivos no Visual Basic 
 
 Para abrir ou criar um arquivo no Visual Basic, basta você usar o 
comando Open. No entanto, temos que considerar algo a respeito do 
modo como abrimos ou abrimos ou criamos esse arquivo. 
 
 
 
 
 
 
 
 
 Tipos de Arquivo no Visual Basic 
 
 
 Os três primeiros modos têm a ver com arquivos seqüenciais. Os 
arquivos seqüenciais normalmente são usados para arquivos de texto, onde 
você grava o arquivo do início ao fim e o lê da mesma maneira; ou seja, você 
não salta de um lugar para outro dentro do arquivo. Trabalhar com arquivos 
seqüenciais é como usar fitas cassete; se você quiser ouvir algo no final da fita, 
terá que passar primeiro por tudo que esteja na frente. Da mesma forma, se 
você quiser algo do texto no final de um arquivo aberto com acesso seqüencial, 
terá primeiro que ler todo o texto que vem antes dele. 
 
 Se os arquivos de acesso seqüencial são como fitas cassete, os arquivos 
de acesso aleatório são como discos de pickups. Ao contrário de uma fita, em 
um disco você pode movimentar à vontade, sem ter que passar por todas as 
Microsoft Visual Basic 4.0 129
faixas intermediárias. Da mesma forma, você pode movimentar-se à vontade 
em um arquivo de acesso aleatório, retirando dados de qualquer local onde 
desejar. O preço a ser pago é que os dados em um arquivo de acesso 
aleatório devem ser cuidadosamente seccionados em registros, de modo que 
você saiba exatamente onde estão os dados que deseja obter. 
 
 Por exemplo, se os registros que desenvolvemos na nossa aplicação de 
bancos de dados fossem todos do mesmo tamanho, eles funcionariam 
perfeitamente em um arquivo de acesso aleatório; quando quiséssemos o 
vigésimo registro, poderíamos simplesmente saltar sobre os 19 primeiros e 
então começar a leitura. No entanto, o texto - como armazenamos na 
aplicação Editor - não é seccionado corretamente em registros do mesmo 
tamanho, e por isso colocaremos o texto que estamos para salvar em um 
arquivo seqüencial. 
 
O terceiro tipo de arquivo são os arquivos binários; aqui o Visual Basic não 
interpreta o conteúdo do arquivo de forma alguma. Por exemplo, os arquivos 
executáveis (.Exe) são arquivos binários, e nós os tratamos numa base byte a 
byte no Visual Basic. Para copiar um arquivo desses, precisamos ler cada byte 
do arquivo original (o arquivo de origem) e depois enviá-los para um novo 
arquivo (o arquivo de destino). Embora possamos definir a quantidade de dados 
que queremos ler sob arquivos seqüenciais ou aleatórios, os arquivos binários 
são sempre tratados byte a byte. 
 
Cada um desses três tipos de acesso ao arquivo possui seu próprio conjunto 
de comandos no Visual Basic, como veremos neste capítulo. Como podemos 
nos confundir, você encontrará uma coleção dos comandos mais comuns de 
manipulação de arquivo do Visual Basic, organizados por tipo de arquivo, na 
tabela. 
 
 
 
 
 
 
 
Comandos de Arquivo do Visual Basic. 
 
Acesso Comandos Comuns do Visual Basic 
 
Seqüencial Open, Line lnput #, Print #, Write #, Input$, Close 
 
Aleatório Type... End Type, Open, Put #, Len, Close, Get # 
 
Binário Open, Get #, Put #, Close, Seek, lnput$ 
 
Microsoft Visual Basic 4.0 130
 
 
 Nossa tarefa aqui é salvar o documento ativo do Editor, e faremos isso 
abrindo um arquivo seqüencial (embora realmente pudesse ser tratado como 
arquivo binário). Existem três maneiras de abrir arquivos seqüenciais: para 
entrada (Input), saída (Output) e acréscimo (Append). 
 
 Abrimos um arquivo para entrada se queremos ler algo dele, para 
saída se queremos gravar nele, e para acréscimo se queremos incluir algo 
ao seu final. 
 
 Esses três modos são coerentes com a idéia de abrir o arquivo e depois 
trabalhar com os dados do início ao fim. Por exemplo, se abrimos um arquivo 
para saída seqüencial, gravamos nele um string, e depois o seguimos por um 
segundo string, este vai diretamente após o primeiro, e assim por diante para 
strings subseqüentes, um após o outro. Se quiséssemos lê-los novamente 
teríamos que fechar o arquivo e abri-lo para entrada, e depois poderíamos ler os 
dados de volta, do início ao fim. 
 
Os arquivos aleatórios, onde você poderá movimentar-se à vontade pelo 
arquivo, não possuem qualquer uma dessas restrições. Quando você abre um 
arquivo para acesso aleatório, ele está preparado para entrada e saída (por 
outro lado, lembre-se de que, nos arquivos aleatórios, você precisa seccionar os 
dados em registros). 
 
Nesse caso, quando estivermos gravando nosso documento do Editor no 
disco, abriremos nosso arquivo para saída seqüencial. Em geral, o comando 
Open do Visual Basic será este: 
 
 
 
Open fff$ [For mmm][Access aaa] [111] As [#] nnn% [Len = rrr%] 
 
 
 
 
 
 
 
 
 Onde os argumentos possuem este significado: 
 
 
fff$ O nome de arquivo (incluindo um caminho
opcional) 
 
 
Microsoft Visual Basic 4.0 131
mmm Modo: pode ser Append, Binary, lnput, Output ou 
Random 
 
 
aaa Acesso: pode ser Read, Write ou Read Write 
 
111 Lock: restringe o acesso de outras aplicações 
 
nnn% Número do arquivo (1-255): o número que usaremos 
para nos referir a esse arquivo daqui em diante, 
 
 
rrr% Tamanho do registro para arquivos aleatórios, ou 
tamanho do buffer que você quer que o Visual 
Basic use para arquivos seqüenciais 
 
 
 No nosso caso, o usuário deseja gravar no arquivo agora existente em 
FilenameBox.Text, de modo que poderemos usar este comando Open para abrir 
o arquivo: 
 
 Open FilenameBox.Text For Output As # 1 
 
 De fato, esse arquivo poderia nem mesmo existir; o usuário poderia 
querer que o criemos. Isso é feito automaticamente pelo comando Open: se o 
arquivo não existir e estivermos tentando abri-lo para algo diferente de lnput, o 
Visual Basic criará o arquivo para nós. Por outro lado, observe que quando 
abrimos um arquivo já existente para saída e depois gravamos algo nele, o 
conteúdo original do arquivo é destruido. (Se quiser incluir algo ao final de um 
arquivo seqüencial e manter o que já existe antes, abra o arquivo para 
Append.) Agora podemos iniciar o quadro de diálogo Save File... com esta linha 
na procedure click do botão OK: 
 
Sub OKButton_Click( ) 
 
Open FilnameBox.Text For Output As # 1 'Abre arquivo 
 . 
 . 
 
 End Sub 
 
 Assim como no Basic normal, poderemos nos referir a esse arquivo como 
arquivo # 1 quando quisermos gravar nele ou fechá-lo. No entanto, temos que 
notar que existe a possibilidade de erro quando abrirmos um arquivo dessa 
maneira: o usuário pode ter especificado um caminho inválido, por exemplo, ou 
Microsoft Visual Basic 4.0 132
errado na digitação do nome do arquivo. Para cuidar desses erros, podemos 
incluir um comando On Error GoTo, da seguinte forma: 
 
 
Sub OKButton_Click( ) 
 
On Error GoTo FileError 
Open FilenameBox.Text For Output As # 1 'Abre arquivo 
. 
. 
. 
 
 
 
 Isso funciona da seguinte maneira: se houver um erro, o programa saltará 
imediatamente para o label FileError, onde poderemos colocar um quadro de 
mensagem na tela e depois executar um comando Resume, que salta de volta à 
linha que causou o erro, permitindo que o usuário tente novamente. 
 
 
 
Sub OKButton-Click( ) 
 
On Error GoTo FileError 
Open FilenameBox.Text For Output As # 1 'Abre arquivo 
 . 
 . 
Exit Sub ‘ Sai da rotina e pula o tratamento de erro 
 
FileError: 
MsgBox “File Error", 48. "Editor" 'MsgBox para erro de 
arquivo 
 
End Sub 
 
 
Como tratar de erros “acusáveis" 
 
Se não tivéssemos colocado esse comando no código, não 
poderíamos apanhar esses erros - chamados erros "acusáveis". 
Nesse caso o próprio Visual Basic avisaria sobre o erro 
diretamente, com um quadro de mensagem, o que não 
 é desejado na maior parte das aplicações. 
 
Microsoft Visual Basic 4.0 133
 
 
 
 
 Em outras palavras, se o nome do arquivo for válido e o arquivo 
correspondente puder ser aberto ou criado, faremos isso. Se houver um 
problema, indicaremos o fato e permitiremos que o usuário mude a 
especificação de arquivo para outra tentativa. Nesse ponto, então, o arquivo 
estará aberto; o próximo passo é gravar nele o nosso documento. 
 
 
 
 Gravação em Arquivos no Visual Basic 
 
 O modo normal de gravar em um arquivo seqüencial é usar os comandos 
Print # ou Write #. Veja como podemos usá-los: 
 Print # nnn%, expressionlist 
 Write # =%, expressionlist 
 
 
 Aqui, nnn% é o número do arquivo (1 para o nosso caso), e expressionlist 
é uma lista das variáveis (incluindo strings) que você deseja gravar no arquivo. 
Os dois comandos, Print # e Write #, são diferentes; Write # insere vírgulas entre 
os itens separados na expressionlist, à medida que os grava no arquivo, coloca 
aspas ao redor dos strings e insere uma nova linha (em branco) ao final do 
arquivo. Como não queremos qualquer um desses caracteres adicionais, 
usaremos Print # em vez disso. De fato, só desejaremos enviar um único string 
ao arquivo: Form1.display.Text, de modo que nosso comando Print # estará 
como neste trecho: 
 
 
 
Sub OKButton_Click() 
 
On Error GoTo FileError 
 
Open FilenameBox.Text For Output As # 1 'Abre arquivo 
Print # 1, Form1.PadText.Text 'Grava documento 
 . 
 . 
 . 
Exit Sub 
 
Microsoft Visual Basic 4.0 134
FileError 
 
MsgBox "File Error", 48, "Editor" 'MsgBox para erro de 
arquivo 
 
End Sub 
 
 
 
 E isso é tudo para gravar o texto no arquivo. Fechar o arquivo não é 
muito mais dificil; use o comando Close, como vemos aqui: 
 
 
 
Sub OKButton_Click( ) 
 
On Error GoTo FileError 
 
Open FilenameBox.Text For Output As # 1 'Abre arquivo 
 
 
 
 Print # 1, Form1.PadText.Text 'Grava documento 
 Close #1 'Fecha o arquivo 
. 
. 
. 
Exit Sub 
 
File Error 
 
MsgBox "File Error", 48, "Editor" 'MsgBox para erro de 
arquivo 
 
End Sub 
 
 
 
Close # 1 fecha o arquivo número 1, que é o arquivo em que estamos 
trabalhando. Depois de fechar o arquivo, teremos terminado, de modo que 
saímos da procedure Sub com um comando Exit Sub. Nesse ponto, o arquivo 
foi gravado com sucesso no disco, ou, se não, alertamos o usuário para o 
fato.(Saltamos para o label FileError e geramos nosso quadro de mensagem na 
tela, como antes.) 
 
 
Microsoft Visual Basic 4.0 135
 
 
 
 
Fechando todos os arquivos ao mesmo tempo 
 
Se você usar o comando Close sem qualquer número 
de arquivo, então oVisual Basic fechará de uma 
só vez, todos os arquivos que a sua aplicação abriu. 
 
 
 
 
 
 O passo final, se a manipulação de arquivo tiver sido tranqüila, é 
esconder o quadro de diálogo Save File... (isto é, SaveForm) da seguinte forma: 
 
 
 
Sub OKButton-click( ) 
 
On Error GoTo FileError 
Open FilenameBox.Text For Output As # 1 'Abre arquivo 
 
 
 
Print # 1, Form1.display.Text 'Grava documento 
Close #1 'Fecha o arquivo 
SaveForm.Hide 
 
Exit Sub 
 
 
FileError: 
MsgBox "File Error", 48, "Editor" 'MsgBox para erro de 
arquivo 
 
End Sub 
 
 
Microsoft Visual Basic 4.0 136
 Para ver isso em ação, faça as mudanças acima e tente digitar algumas 
linhas de texto no Editor e depois salvá-las. Quando o fizer, verá que o texto é 
gravado no disco, no arquivo escolhido. 
 
 
Observe que o texto no arquivo é simplesmente armazenado como uma 
longa cadeia de texto sem carriage returns [ou Enter] - a menos que estejam 
presentes no documento original -, pois o próprio quadro de texto principal o 
armazena dessa maneira. E isso termina nosso item Save File.... Pudemos 
gravar um arquivo de texto seqüencial no disco, e nossa aplicação Editor tornou-
se ainda mais sofisticada. No entanto, o próximo passo correspondente é ler os 
arquivos de volta no item Load File... do Editor. Veremos esse processo em 
seguida. 
 
 
 
 
 
 
 
 Uso de Controles de Arquivos no Visual Basic 
 
 
 O primeiro passo na leitura do conteúdo de um arquivo é obter o nome 
desse arquivo. No entanto, isso não é uma simples questão de pedir ao usuário 
para digitar o nome em um quadro de texto. Temos que ter a capacidade de 
procurar no disco (assim como outras aplicações semelhantes Windows) e 
permitir que o usuário selecione a partir do que já existe lá. O Visual Basic 
oferece três controles especiais para fazer exatamente isso, e estes são quadros 
de lista de disco, quadros de lista de diretório e quadros de lista de arquivo. 
As ferramentas para criar esses controles de arquivo aparecem no final da 
caixa de ferramentas do Visual Basic. Acontece que esses controles
farão 
grande parte do trabalho para nós. A caixa de ferramentas pesquisará 
automaticamente unidades e diretórios, e poderemos trabalhar com as várias 
propriedades associadas com eles. 
 
 
 
 
Esta caixa de diálogo já foi criada em nosso curso, 
vamos agora utiliza-la para manipular nossos arquivos! 
Se você salvou o formulário que corresponde 
a essa caixa de diálogo, reaproveite-º 
Caso contrário, crie um novo. 
 
Microsoft Visual Basic 4.0 137
 
 
 
 
 Vamos iniciar esse processo projetando um quadro de diálogo para a 
opção Load File.... que poderemos chamar LoadForm e salvá-lo como 
Loadform.Frm. Primeiro, vamos conectá-la ao item de menu Load File... 
acionando esse item no menu File do Editor: 
 
 
 Para mostrar o quadro de diálogo Load File... (LoadForm), podemos 
simplesmente mostrá-lo da seguinte forma: 
 
 Sub LoadItem 
 
LoadForm.Show 
 
End Sub 
 
 
 Para projetar LoadForm, use o item New Form do menu File do Visual 
Basic. Para criar o formulário, dê a ele um Name de LoadForm; use, Load File... 
como legenda; remova os botões Min e Max; mude a propriedade de 
BorderStyle para dupla fixa; e inclua os botões OK e Cancel. 
 Em seguida, inclua um quadro de lista de unidade com um clique duplo na 
ferramenta de lista de unidade na caixa de ferramentas, que está próxima à 
ferramenta do temporizador. Observe que o quadro de lista de unidade é um 
quadro de lista suspensa, o que nos economizará algum espaço. Também 
precisamos de um quadro de lista de diretório e um quadro de lista de arquivo, e, 
portanto, acione com um clique duplo também essas ferramentas (que se 
encontram no final da caixa de ferramentas), e arrume-as como você desejar no 
quadro de diálogo. 
 
 
O usuário poderá carregar qualquer arquivo existente dessa maneira, por 
meio da combinação dos quadros de unidade, diretório e lista de arquivos. Ele 
pode usar o quadro de lista de unidade para especificar a unidade, o quadro de 
lista de diretório para especificar o diretório nessa unidade, e o quadro de lista 
de arquivos para indicar o arquivo real que deseja abrir. 
 
Esse arquivo pode ser aberto de duas maneiras: dando um duplo clique no 
nome do arquivo no quadro de lista de arquivo ou selecionando-o (destacando-
o) no quadro de lista de arquivo e acionando o botão OK. 
 
E, como sempre, ativar o botão Cancel é muito fácil. Basta esconder o 
quadro de diálogo quando esse botão for acionado: 
Microsoft Visual Basic 4.0 138
 
Sub CancelButton_Click( ) 
 
 LoadForm.Hide 
 
End Sub 
 
 Agora vamos passar aos controles de arquivo. Nesse ponto, os três 
quadros de lista (de unidade, diretório e arquivo) não estão se comunicando um 
com o outro; ou seja, eles estão apenas mostrando informações independentes 
para o diretório ativo no disco. Se tivéssemos que rodar esse programa e mudar 
o disco no quadro de lista de disco, os outros dois quadros não responderiam à 
mudança. Para que possam se comunicar, temos que saber um pouco mais 
sobre os eventos importantes para cada um deles, e veremos isso em seguida. 
 
 
 Quadros de Lista de Unidade 
 
 O quadro de lista de unidade é um quadro de lista suspensa. A unidade 
ativa é indicada nela. 
 Quando o usuário aciona a seta conectada, o quadro de lista desce, 
mostrando que outras unidades estavam disponíveis para escollia. Quando o 
usuário escolher uma, um evento Change ocorrerá no quadro de lista. Como 
não definimos o nome para nosso quadro de lista de unidade, ele ainda possui o 
nome original de Drive1 (a definição básica para os quadros de lista de unidade), 
de modo que a procedure de evento é Drive1_Change( ). A propriedade do 
nosso quadro Drive1 que mantém a unidade é simplesmente Drive1.Drive, e 
nossa próxima tarefa é passar essa nova unidade adiante para o quadro de lista 
de diretório, que ainda possui o nome original Dir1 (como é normal para quadros 
de lista de diretório). Para fazer isso, só precisamos passar a propriedade 
Drive1.Drive para a propriedade Dir1.Path: 
 
 
 Podemos fazer isso acionando o quadro de lista de unidade com o 
mouse, o que faz surgir a procedure Drive1_Change. Basta atribuir a 
propriedade Drive de Drive1 à propriedade Path de Dir1, da seguinte forma: 
 
 
Sub Drive1_Change( ) 
 
Dir1.Path = Drive1.Drive 
 
End Sub 
 
 
Microsoft Visual Basic 4.0 139
 E isso é tudo que precisamos fazer para conectar os quadros de unidade 
e diretório. De fato, podemos rodar o programa nesse ponto. Quando o 
fizermos, poderemos acionar o item Load File... do menu File do Editor. O 
quadro de diálogo que projetamos, LoadForm, aparece em seguida, mostrando 
a unidade ativa, diretório e arquivos nesse diretório. Se acionarmos o quadro de 
unidade, a lista suspensa de todas as unidades no sistema aparecerá. 
Acionando uma dessas unidades, passaremos para essa unidade, e a mudança 
também afeta o quadro de lista de diretório, que também muda para listar os 
diretórios nesse novo disco. O próximo passo no nosso programa é conectar o 
quadro de lista de diretório ao quadro de lista de arquivo, de modo que, quando 
o diretório for alterado, os arquivos mostrados sejam os arquivos nesse diretório. 
 
 
 
 Quadros de Lista de Diretório 
 
 
 O quadro de lista de diretório mostra os diretórios disponíveis em uma 
certa unidade. Ele é um quadro de lista simples - ou seja, é sempre mostrado, e 
não um quadro de lista suspensa. A unidade de trabalho é mostrada na linha 
superior, e os diretórios dessa unidade aparecem logo abaixo. Se houver mais 
diretórios do que o espaço permitido, uma barra de paginação vertical aparecerá 
à direita do quadro. O diretório ativo aparecerá como uma pasta aberta 
sombreada; seus subdiretórios aparecerão como pastas fechadas (sem sombra) 
logo abaixo dele. Quando o usuário mudar de diretório, acionando um novo 
diretório, um evento Dir1_Change será gerado, e o novo caminho será colocado 
em Dir1.Path. Além disso, pelo modo como preparamos as coisas, quando o 
usuário mudar de unidade, Drive1.Drive será carregado em Dir1.Path, que 
também gera um evento Dir1_Change. Em outras palavras, o único evento com 
que precisamos nos preocupar aqui é Dir1_Change, que agora cuida das 
mudanças de unidade e diretório. 
 Quando ocorrer esse evento, precisamos dar a notícia ao quadro de lista 
de arquivo, o que pode ser feito passando adiante a propriedade Dir1.Path à 
propriedade Path do quadro de lista de arquivo. Como essa lista ainda é 
chamada File1 (a definição original para quadros de lista de arquivo), podemos 
fazer isso. 
 
 
 
Sub Dir1_Change( ) 
 
 File1.Path = Dir1.Path 
 
End Sub 
 
Microsoft Visual Basic 4.0 140
 
 Desse modo, toda vez que houver uma mudança no diretório de trabalho 
- ou unidade de trabalho -, o quadro de lista de arquivo saberá disso. 
 
 Se fizermos essa mudança e depois iniciarmos o programa, poderemos 
ver que agora todos os quadros de lista estão conectados. Por exemplo, 
podemos acionar o quadro de lista de unidade para mudar a unidade, e a 
mudança automaticamente será comunicada ao quadro de lista de diretório, cuja 
lista de diretórios é alterada de acordo. Essa mudança, por sua vez, também é 
comunicada ao quadro de lista de arquivo, que mostra os arquivos no novo 
diretório de trabalho. 
 
 Por conseguinte, se mudarmos o diretório de trabalho no quadro de lista 
de diretório, essa mudança também será comunicada ao quadro de lista de 
arquivo, que mostrará os arquivos no novo diretório. Em outras palavras, os 
eventos importantes foram Drive1_Change e Dir1_Change, e as propriedades 
importantes que tiveram que ser transferidas foram Drive1.Drive → Dir1.Path, e 
Dir1.Path → File1.Path. Para realmente lermos o nome do arquivo que o usuário 
deseja carregar, teremos que verificar a propriedade FileName de
File1 - ou 
seja, File1.FileName - da, seguinte forma: 
 
 
 
 Unidade Diretório Arquivo 
 
 Drive1.Drive Dir.Path Arquivo1.Path Nome do 
 File1.FileName Arquivo 
 
 
 
Também poderíamos notar que, embora você possa selecionar uma nova 
unidade com um único clique do mouse, são necessários dois cliques para 
selecionar um novo diretório no quadro de lista de diretório. Essa diferença tem 
a ver com a diferença entre os arquivos de lista suspensa e simples. 
 
O motivo para precisar de dois cliques no quadro de listas de diretórios é 
para que os usuários possam se movimentar para cima e para baixo nas listas 
usando as teclas de direção sem mudar o diretório de trabalho para cada 
entrada destacada durante o percurso; ou seja, a mudança é feita apenas 
quando ele chegar ao diretório que deseja. 
 
 
 
 Leitura de Arquivos no Visual Basic 
 
 
Microsoft Visual Basic 4.0 141
 
 Os comandos-padrão de leitura de um arquivo seqüencial no Visual Basic 
são lnput #, Line lnput # e Input$. Você deverá usá-los da seguinte forma: 
 
 
 
lnput # nnn%, expressionlist 
 
Line lnput # nnn%, stringvariable 
 
Input$ (bbb%, [#] nnn%) 
 
 
 
 Aqui, nnn% é o número do arquivo (isto é, 1 para o nosso caso), bbb% é 
o número de bytes a ser lido, stringvariable é o nome de uma variável de string 
para colocar os dados, e expressionlist é uma lista de expressões onde os 
dados serão colocados. 
 
Por exemplo, se usarmos lnput # para preencher Form1.display.Text, o 
comando poderia ser este: lnput # 1 Form1.display.Text. No entanto, o problema 
com Input # é que ele espera que os itens no arquivo, sejam separados por 
vírgulas, espaços ou mais de uma linha (isto é, um carriage return). Para 
números, isso significa que quando lnput # encontrar a primeira vírgula, espaço 
ou final de linha, ele achará que o número ativo terminou; para strings, lnput # 
termina o string quando alcançar uma vírgula ou o fim de linha. Isso não pode 
ser aceito por nós, pois o texto de um documento que estamos lendo poderá 
conter muitas vírgulas. De fato, o usuário pode ter colocado carriage returns em 
vários pontos do documento (embora não sejam necessários, pois o quadro de 
texto multilinha do Editor possui uma quebra de linha automática), ou então 
podemos estar tentando ler um documento de outra aplicação, que já contenha 
carriage returns. 
 
De maneira semelhante, a função Line lnput# lê strings dos arquivos, até 
encontrar um carriage return, quando termina. Isso significa que teríamos que 
alcançar o final de cada linha do arquivo (se for dividido em linhas) 
separadamente. Uma forma de fazer isso seria a seguinte: 
 
 
 
Do Until EOF(1) 
 
Line Input # 1, Dummy$ 
 Form1.PadText.Text = Form1.PadText.Text + Dummy$ + 
Chr$(13) + Chr$(1O) 
 
Microsoft Visual Basic 4.0 142
Loop 
 
 
 
Os comandos nesse loop, se houver algum, serão executados 
repetidamente até que a condição seja verdadeira, quando a execução 
terminará. (Observe que se a condição for verdadeira no início, os comandos no 
corpo do loop não são executados uma única vez.) No nosso caso, estamos 
usando a função EOF( ) para compor a condição do nosso loop. Essa função 
apanha um número de arquivo como seu argumento (para nós, isso seria 
EOF(1)) e retorna um valor True quando atingirmos o final do arquivo. No loop 
do exemplo acima, então, continuaríamos lendo as linhas do arquivo até 
alcançarmos o final do arquivo. Além disso, toda vez que lemos uma linha, 
incluímos os caracteres carriage return e avanço de linha ao final da linha, da 
seguinte forma: 
 
 
Do Until EOF(1) 
 
Line Input # I, Dummy$ 
Form1.display.text = Form1.display.text + Dummy$ + Chr$(13) + 
Chr$(10) 
 
Loop 
 
 
 
 Aqui, estamos usando a função Chr$(), que retoma o caracter ANSI 
correspondente ao código ANSI passado a ela. Por exemplo, Chr$(13) retorna 
um carriage return. O motivo para incluirmos um par carriage return/avanço de 
linha ao final de cada linha é que Line lnput # trata esses dois caracteres 
simplesmente como delimitadores de string, excluindo-os do texto. Entretanto, 
como eles fazem realmente parte do arquivo, podemos simplesmente colocá-los 
de volta. 
 
 
 Uma opção melhor para nós do que lnput # ou Line lnput # é a função 
lnput$, que é feita especialmente para ler strings, e que não suprime carriage 
returns dos avanços de linha. Para usar essa função, no entanto, temos que 
indicar o número exato de bytes que queremos ler; quando o fizermos, lnput$ 
retomará um string (que podemos atribuir a Form1.display.Text). O número de 
bytes que queremos ler é simplesmente o tamanho do arquivo em bytes; 
podemos usar outra função de arquivo, LOF(), para obter isso para nós. Assim 
como EOF(), LOF() apanha um número de arquivo como argumento. LOF(), no 
entanto, retorna o tamanho do arquivo indicado em bytes (o arquivo deve estar 
Microsoft Visual Basic 4.0 143
aberto para LOF() funcionar), de modo que podemos ler tudo da seguinte forma, 
com a função Input$o: 
 
 
 
Form1.display.Text = Input$(LOF(1), # 1) 
 
 
 
 Limitações de lnput$() 
 
 A função lnput$() é limitada à leitura de arquivos de 32.767 bytes se você 
o abrir para acesso seqüencial ou binário. No entanto, se quiser usar arquivos 
maiores, poderá simplesmente verificar o tamanho do arquivo, LOF(), e depois 
ler o arquivo várias vezes em sucessão até obter todos os dados de que precisa. 
 
 
 
De fato, como você especifica o número de bytes a serem lidos, poderá 
também usar esse comando para ler dados de arquivos binários. Podemos 
incluir nosso comando lnput$ a OKButton_Click() da seguinte forma, onde 
colocamos o string lido (isto é, o conteúdo inteiro do arquivo) diretamente no 
quadro de texto do Editor (Form1.display.Text): 
 
 
 
Sub OKButton_Click () 
 
On Error GoTo FileError 
If (Right$(Dir1.Path,1) = "\") Then Filename = Dir1.Path + 
 File1.Filename 
Else 
 Filename = Dir1.Path + "\" + File1.Filename 
End If 
 
Open Filename For Input As # 1 
 
 
 
Form1.display.text = lnput$(LOF(1), # 1) 
close #1 
loadform.hide 
 
Microsoft Visual Basic 4.0 144
Exit Sub 
 
FileError: 
 
MsgBox "File Error", 48, "Editor" 'MsgBox para erro de 
arquivo 
 
End Sub 
 
 
 Agora o quadro de diálogo Load File... está completo. Para usá-lo, basta 
iniciar o programa e selecionar o item Load File... no menu File. 
 O quadro de diálogo Load File... é mostrado na tela. Como você pode ver, 
o quadro de lista de arquivo apresenta os nomes de arquivo em ordem 
alfabética. Para abrir um deles, basta dar um duplo clique no seu nome ou 
selecioná-lo e acionar o botão OK. Quando o fizer, a procedure 
OKButton_Click() será executada, o arquivo será aberto e lido para o Editor. 
Nesse ponto, você poderá editá-lo e depois gravá-lo no disco novamente com a 
opção Save File.... 
 
 
 
 
 
 Uso de Arquivos de Acesso Aleatório no Visual Basic 
 
 
 Estamos prontos para passar de arquivos de acesso seqüêncial para 
arquivos de acesso aleatório. Esses tipos de arquivos normalmente dividem 
seus dados em registros, todos eles contendo o mesmo formato, mas 
(normalmente) com dados diferentes. E, como você deve se lembrar, 
preparamos os dados no nosso programa de bancos de dados anteriormente 
exatamente para os tipos de registros, da seguinte forma: 
 
 
 
Type Record 
 
Name As String* 50 
Number As String * 20 
Comments As String * 200 
 
End Type 
 
 
Microsoft Visual Basic 4.0 145
 
 Global TheData(100) As Record 
 
 
 
 
 
 Gravação de Arquivos de Acesso Aleatório 
 
 
 Podemos começar gravando
o arquivo depois que o usuário selecionar o 
item Save File... no menu File. O Name desse item é Saveltem. Podemos abrir 
Saveltem_Click() acionando o item do menu. 
 
 
 Quando o usuário acionar esse item, ele poderá salvar o banco de dados 
em um arquivo particular, de modo que precisamos gerar um quadro de diálogo 
semelhante àquele que projetamos anteriormente para o nosso Editor. De fato, 
podemos usar aqui o mesmo quadro de diálogo. Para carregar esse 
formulário, basta abrir o menu File do Visual Basic, selecionar o item Add File... 
e dar o nome do formulário Save File... (usamos Saveform.Frm no exemplo 
anterior). Esse arquivo é automaticamente carregado - dessa forma, você 
poderá trocar formulários como quadros de diálogo entre projetos, 
economizando muito tempo durante o projeto, e fazendo com que suas 
aplicações se tornem mais uniformes. Agora podemos gerar esse quadro de 
diálogo na tela da seguinte forma em Saveltem_Click(): 
 
Sub Saveltem_Click() 
 
SaveForm.Show 
 
 End Sub 
 
 
 
 Em seguida, temos que fazer algumas mudanças no código de SaveForn, 
pois está preparado para armazenar arquivos seqüenciais. Basta passar para 
esse formulário usando a janela de projeto, e acionar na procedure 
OKButton_Cllck(), que atualmente contém o seguinte código: 
 
 
 
Sub OKButton_Click () 
 
On Error GoTo FileError 
Open Filenamebox.text For Output As#1 
Microsoft Visual Basic 4.0 146
 
Print # 1, Form1.display.text ‘Grava documento 
Close # 1 'Fecha o arquivo 
SaveForm.Hide 
Exit Sub 
 
 File error: 
 MsgBox “File Error”, 48, “Database” 
 
End Sub 
 
 Como estamos usando um arquivo de acesso aleatório com registros 
dessa 
vez, e não um arquivo seqüencial de texto, abrimos o arquivo como Random: 
 
 
 
Sub OKButton_Click( ) 
 
On Error GoTo FileError 
 
Open FilenameBox.Text For Random As #1 Len = 
Len(TheData(1)) 
Print # 1, Form1.display.Text 'Grava o documento 
Close # 1 'Fecha o arquivo 
SaveForm.Hide 
Exit Sub 
 
 
 
FileError: 
MsgBox "File Error", 48. "Database" 'MsgBox para erro no 
arquivo 
 
End Sub 
 
 
 
Aqui, estamos indicando que o tamanho de registro que iremos usar é 
Len(TheData(1)), que retorna o tamanho (em bytes) do nosso registro. Em 
seguida, queremos gravar o array de registros inteiro, Database(), nesse 
arquivo, de modo que deveremos ver as opções para gravação de arquivos de 
acesso aleatório. 
 
Microsoft Visual Basic 4.0 147
Os comandos comuns de I/0 para arquivos binários e de acesso aleatório 
são Get# e Put #; esses comandos podem obter ou colocar registros no arquivo. 
Nesse caso, usaremos Put #, cuja sintaxe é a seguinte: 
 
 
 
Put [#] nnn%, [rrr%], vvv% 
 
 
Aqui, nnn% é um número de arquivo, rrr% é o número de registro que você 
quer colocar no arquivo, e vvv% é a variável que queremos colocar lá. Se não 
especificarmos um número de registro, o Visual Basic simplesmente coloca um 
registro após o últirno no arquivo. O número total de registros é armazenado no 
inteiro global TotalRecords, de modo que possamos gravar esse número de 
registros da seguinte forma (observe que nenhum registro é gravado se 
TotalRecords for 0): 
 
 
 
Sub OKButton_Click ( ) 
 
On Error GoTo FileError 
Open FilenameBox.Text For Random As # 1 Len = Len(TheData(1)) 
 
For loop_index = 1 To TotalRecords 
Put # 1, TheData(loop_index) 
Next loop_index 
 
Close # 1 'Fecha o arquivo 
SaveForm.Hide 
Exit Sub 
 
 
 FileError: 
 
MsgBox "File Error", 48, “Database" 'MsgBox para erro no 
arquivo 
 
 
End Sub 
 
 
 
 E é isso aí. Agora podemos usar a opção Save File... do aplicativo 
Database. 
 
Microsoft Visual Basic 4.0 148
 
 
 Nesse ponto, o arquivo é gravado no disco. (Observe que também 
devemos mudar o quadro de mensagem de erro na seção FileError do código, 
dando-lhe o título "Database" em vez de "Editor".) Se quiséssemos, 
poderíamos ter gravado qualquer registro no lugar de todos eles especificando 
um número de registro em particular, da seguinte maneira: 
 
 
 Put # 1, 5, TheData(23) 
 
 
Isso grava no registro 5 do arquivo, preenchendo-o com o registro 
TheData(23). Desse modo, o acesso aleatório é verdadeiramente aleatório, 
pois ternos acesso a todos os registros do arquivo. Em outras palavras, 
podemos nos movimentar à vontade no arquivo, gravando registros em 
qualquer ordem. Isso funciona de forma semelhante com Get #, como 
veremos em seguida, ao lermos os registros do arquivo. 
 
 
 
 
 
 
 
 Leitura de Arquivos de Acesso Aleatório 
 
 
 Já copiamos o quadro de diálogo Save File da aplicação Editor para o 
nosso banco de dados, e podemos também copiar o quadro de diálogo Load 
File. Mais uma vez, selecione o item Add File no menu File do Visual Basic, 
 e depois inclua o arquivo Frm contendo o quadro de diálogo Load File... (nós 
o chamamos Loadform.Frm anteriormente). Em seguida, ative o item Load File 
no menu File do Database da seguinte forma: 
 
Sub Loadltem -ClickO 
 
Loadform.show 
 
End Sub 
 
 
 
 
 
Microsoft Visual Basic 4.0 149
 Agora acione o botão OK desse novo formulário, LoadForm, para mostrar 
a procedure mais importante, OKButton_Click(), que atualmente é a seguinte: 
 
 
 
Sub Okbotton_Click( ) 
 
On Error GoTo FileError 
 
If (Right$(Dir1.Path,1 ) = " \") Then 'Obtém nome do arquivo 
Filename = Dir1.Path + File1.FileName 
Else 
Filename = Dir1.Path + "\" + File1.Filename 
 
End if 
 
 
Open Filename For Input As # 1 
Form1.display.Text = Input$(LOF(1), # 1)'Lê o arquivo 
Close # 1 'Fecha o arquivo 
 
'Abre o arquivo 
 
 
 
Exit Sub 
 
 
FileError: 
MsgBox ”File Error",48,”Editor" 'MsgBox para erro 
 
 
End Sub 
 
 
 
 Mais uma vez, abrimos o arquivo como antes, para acesso aleatório: 
 
 
 
Sub OKButton_Click( ) 
 
On Error GoTo FileError 
. 
Microsoft Visual Basic 4.0 150
. 
. 
 
Open Filename For Random As # 1 Len = 
Len(TheData(1)) 
 
Form1.display.Text = Input$(LOF(1), # 1)'Lê o arquivo 
 
Close # 1 'Fecha o arquivo 
LoadForm.Hide 'Esconde o quadro de diálogo 
 
 
 
Exit Sub 
 
FileError: 
MsgBox "File Frror", 48. "DataBase" 
End Sub 
 
 Agora temos que obter os registros do arquivo usando Get #, que você 
usa para ler a partir de arquivos aleatórios e binários, e cuja sintaxe é a 
seguinte: 
 
 Get [#] nnn%, [rrr%], vvv% 
 
 
 
 Assim como em Put #, nnn% é o número do arquivo, rrr% é o número do 
registro que você quer obter do arquivo, e vvv% é a variável queremos colocar 
os dados. Se não especificarmos um número de registro o Visual Basic 
simplesmente apanhará o próximo registro da posição ativa no arquivo. Nossa 
primeira tarefa aqui é descobrir quantos registros existe no arquivo, e podemos 
fazer isso simplesmente dividindo o tamanho arquivo pelo tamanho de cada 
registro. Depois disso, podemos ler os dados da seguinte forma, registro por 
registro: 
 
 
 
Sub OKButton_Click ( ) 
 
On Error GoTo FileError 
 
Microsoft Visual Basic 4.0 151
Open Filename For Random As # 1 Len = 
Len(TheData(1)) 
NumberFileRecords = LOF(1)/ Len(TheData(1)) 
 
For loop_index =1 To NumberFileRecords 
 Get # 1, TheData(loop_index) 
Next loop_index 
 
 
 
Close # 1 'Fecha o arquivo 
LoadForm.hide 'Esconde o quadro de diálogo 
 
 
 
Exit sub 
 
FileError: 
MsgBox "File Error", 48, "Database" 'MsgBox para 
erro de arquivo 
 
End Sub 
 
 
 
(Observe que, mais uma vez, mudamos o nome do título do quadro na seção 
FileError do código de "Editor" para "Database"). 
 
 
 
No entanto, simplesmente carregar um arquivo não torna o banco de dados 
ativo. Além disso, temos que carregar os nomes de registro que lemos ao nosso 
quadro de lista ordenado
do banco de dados, onde podem ser selecionados pelo 
usuário. Esse quadro de lista é mantido no quadro de diálogo Find Item... do 
banco de dados. Para carregar os nomes de registro para esse quadro de lista, 
temos primeiro que apagar todas as entradas ativas (usando o método 
Removeltem do Visual Basic), e depois podemos recarregá-las de TheData(), 
usando o método Addltem: 
 
 
 
Sub OKButton_Click ( ) 
 
 
On Error GoTo FileError 
 
Microsoft Visual Basic 4.0 152
 
If (Right$(Dir1.Path, 1) = "\") Then 'Obtém nome do arquivo 
Filename = Dir1.Path + File1.FileName 
Else 
Filename = Dir1.Path + "\" + File1.FileName 
 
End If 
 
open Filename For Random As # 1 Len = Len(TheData(1)) 
NumberFileRecords = LOF(1) / Len(TheData(1)) 
 
For loop_index = 1 To NumberFileRecords 
 
 Get # 1, , TheData(loop_index) 
 
Next loop_index 
 
 
close # 1 'Fecha arquivo 
 
 
For loop_index = 1 TO TotalRecords 
 
 Form2.Namelist.Removeitem 0 
 
Next loop_index 
 
 
 
TotalRecords = NumberFileRecords ‘ Depois de ler o arquivo 
 com segurança 
 
For loop_index = 1 To TotalRecords 
Form2.NameList.AddItem TheData(loop_index).Narne 
Next loop_index 
 
 
Form1.NameField.Text = TheData(1).Name 
Form1.NumberField.Text = TheData(1).Number 
Forml.CommentField.Text = TheData(1).Comment 
 
 
Microsoft Visual Basic 4.0 153
 
LoadForm.Hide 'Esconde quadro de diálogo 
 
Exit sub 
 
FileError: 
 
MsgBox "File Error", 48, "Database" ‘MsgBox para erro 
 
 
End Sub 
 
 
 
 
 
 Uso do Comando Seek 
 
 
 Esse comando pode ser extremamente útil, pois nos permite especificar 
qual o registro que será lido ou gravado em seguida. Sua sintaxe é a seguinte: 
 
 
 Seek [#] nnn%, PPP& 
 
 Aqui, nnn% é o número do arquivo, e ppp& (um inteiro longo) é a nova 
posição no arquivo; para arquivos seqüenciais, ppp& é medido em bytes; para 
arquivos aleatórios, em números de registro. Em outras palavras, esta linha: 
 
 Get # 1, loop_index, TheData(loop_index) 
 
 é o mesmo que as linhas: 
 
 Seek # 1, loop_index 
 Get # 1, TheData(loop_index) 
Microsoft Visual Basic 4.0 154
 
 
 
 
 Crie um pequeno banco de dados para controlar as operações dos 
clientes de uma suposta Locadora de Vídeo. O registro de cada cliente deverá 
ser composto por 
 
 Nome 
 Endereço 
 Fitas alugadas 
 Observações 
 
 O mini-banco deverá conter um Menu principal com os Itens: Arquivo 
(Sub-itens Abrir, Salvar e Sair), Clientes (Sub-itens Adicionar e Remover). 
 
 No canto do formulário principal deverá aparecer o número de clientes 
cadastrados. 
 
 Dica: Utilize as caixas de diálogos (Save e Open) criadas nas aplicações 
anteriores. 
 
 
Prática