Você está na página 1de 296

© 1997, 1998, 1999 GRIAULE

© 1997, 1998, 1999 GRIAULE Delphi 4 Total

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Delphi Total

© Direitos Autorais 1997, 1998 para Griaule (razão social: I.A. Pesquisa & Desenvolvimento de Sistemas Ltda.)

Nenhuma parte desta publicação poderá ser reproduzida ou transmitida, no todo ou em parte, em qualquer forma ou meio, seja eletrônica ou mecânica, seja qual for o propósito, sem a expressa autorização por escrito da Griaule.

Delphi, Borland, ReportSmith, dBASE e InterBase são marcas registradas da Borland International, Inc.

Microsoft, MS, Windows, Windows 95, Microsoft SQL Server são marcas comerciais ou marcas registradas da Microsoft Corporation.

Paradox é uma marca registrada da Ansa Software, uma empresa da Borland.

TrueType é uma marca registrada da Apple Corporation.

Oracle é uma marca registrada da Oracle Corporation.

Todas as outras marcas e nomes de produtos são de propriedade de seus respectivos portadores.

Conteúdo:

Márcio Pontes Marla C. Ávila

Conversão para mídia eletrônica: Renato de A. Martins

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Capítulo 1 Iniciando o Delphi

1

Princípios da Programação Windows

2

Iniciando o Delphi

3

Criando um Primeiro Programa

5

Propriedades do Formulário

5

Colocando Componentes

5

Alterando as Propriedades dos Componentes

7

Respondendo a Eventos

7

Testando o Programa

8

Salvando o Programa

8

Capítulo 2 Noções Básicas

Ambiente de Programação

Programação Orientada a Objeto (POO)

9

10

10

Eventos e Procedimentos

11

Componentes

12

Visão Geral dos Componentes

12

Propriedades

14

Métodos

15

Object Pascal e Bibliotecas

16

VCL - Visual Component Library

17

Objetos

18

Resumo

19

Projetos

20

Salvando o Projeto em Disco

20

Comandos para trabalhar com Projetos

21

Grupos de Projetos

Comandos para tabalhar com grupos de projetos

Edições do Delphi

Capítulo 3 Exemplos Adicionais

Exemplo: Calculadora

23

23

24

25

26

Criando os Componentes

26

Tratando os Eventos

27

Executando o Programa

29

Melhoras de Interface

29

Salvando o Projeto

30

Capítulo 4 Variáveis e Tipos de Dados

Tipos de Dados

Tipos Numéricos

Delphi 4 Total

31

32

32

© 1997, 1998, 1999 GRIAULE

O

tipo Char

34

O

tipo String

35

O

tipo Boolean

36

O

tipo

TDateTime

37

Funções de Conversão

38

Operações Aritméticas

40

Tipos Ordinais

42

Escopo de Variáveis

44

Variáveis Locais

44

Variáveis Globais da Unidade

44

Variáveis Globais do Projeto

45

Constantes

Capítulo 5 Estruturas de Controle

46

48

Inserindo comandos com o CodeInsight

49

Estruturas de Decisão

50

O

Comando if

then

else

50

O

Comando case

of

51

Estruturas de Laços

53

O

comando for

53

O

comando while

do

54

O

comando repeat

until

54

Outros Comandos

55

Comandos para sair de laços

55

O

comando exit

55

Capítulo 6 Propriedades e Eventos Comuns

56

Tipos de Propriedades

57

Propriedades Mais Usadas

59

Propriedades para Todos os Componentes

59

Propriedades de Tamanho e Posição

59

Propriedades do Formulário

59

Propriedades de Controles

61

Eventos Comuns

 

63

Eventos

de

Mouse

63

Eventos

de

Teclado

63

Eventos do Formulário

65

Outros Eventos

65

Detalhes do Tratamento de Eventos

67

Tratando um Evento para Vários Controles: OnKeyPress

67

Renomeando um Procedimento de Evento

68

Associando um Procedimento Existente

68

Eliminando um Procedimento de Evento

69

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Capítulo 7 Usando Vários Formulários

70

Caixas de Diálogo

71

Funções de Mensagem

72

Mensagens

Informativas

72

Mensagens de Confirmação

72

Exemplo: CalcData

75

Pedindo Confirmação ao Usuário

76

Criando um Novo Formulário

77

Salvando o Projeto

78

Executando um

Arquivo

78

Gerenciando os Arquivos do Projeto

81

Usando a Speedbar ou Menus

81

Usando o Project Manager

82

Definindo o Formulário Principal

Capítulo 8 Estrutura das Unidades

85

86

Estrutura Geral das Unidades

87

O Código Gerado pelo Delphi

88

Seção de Interface

88

Unidades Associadas e Independentes

90

Compilação de Unidades

91

Usando uma Unidade

92

Resolvendo Conflitos de Nomes

94

Arquivo de Projeto

95

Capítulo 9 Outros Tipos de Dados e Depuração

Tipos Enumerados

97

98

Operações com Ordinais

98

Tipos Enumerados no Delphi

99

Tipos Faixa

Opção "Range Checking"

Vetores

100

100

102

Vetores Estáticos

102

Verificação de Faixa para Vetores

102

Usando Outros Tipos de Índice

103

Vetores Dinâmicos

104

Vetores

Multidimensionais

104

Exemplo: Cálculo de Média

106

Declarando o Vetor

106

Adicionando um Elemento

107

Limpando a Lista

107

Calculando a Média dos Elementos

107

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Testando o Programa

108

Salvando o Projeto

108

Conjuntos

109

Verificando Elementos

109

Operações com Conjuntos

110

Propriedades de Conjunto

111

Depuração

112

Colocando um Ponto de Parada

112

Executando Passo a Passo

112

Executando Até o Cursor

113

Vendo Valores de Variáveis

113

Monitorando o Valor de uma Variável Dinamicamente

114

Forçando a Finalização do Programa

115

Outras Ferramentas de Depuração

115

Capítulo 10 Procedimentos e Funções

Procedimentos Gerais

Criando um Procedimento Geral

Unidades Independentes

116

117

117

119

Criando uma Unidade Independente

119

Transferindo o Procedimento

119

Usando a Unidade no Mesmo Projeto

120

Usando a Unidade em Outros Projetos

120

Gerenciando um Projeto com Unidades Independentes

121

Criando uma Biblioteca de Rotinas

121

Funções

123

Criando uma Função

123

Retornando um Valor

123

Chamando a Função

124

Passagem de Parâmetros

125

Declaração de Parâmetros e Argumentos

125

Tipos de Passagem

126

Capítulo 11 Objetos

128

O Que Contém um Objeto

129

Classes e Objetos

130

Herança

131

Hierarquia de Classes do Delphi

131

O

Object Browser

132

Simplificando o Acesso aos Campos

132

Formulários como Objetos

133

A

Classe de Formulário

133

Procedimentos na classe de formulário

134

Variáveis de Objeto

136

Listas de Strings

140

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Propriedades da String List

140

Métodos da String List

140

Criando String Lists Independentes

141

Objetos Predefinidos

143

O

Objeto Application

143

O

Objeto Clipboard

143

O

Objeto Screen

144

Code Explorer

145

Programação Orientada a Objetos

147

Capítulo 12 Aplicações de Banco de Dados

149

Termos Usados

150

Desktop x Cliente/Servidor

151

Formatos de Bancos de Dados

153

Criando Tabelas

154

Definindo um Diretório de Trabalho

154

Definindo a Estrutura dos Campos

154

Salvando

a Tabela

155

Entrando com Dados

155

Exemplo: Criando um Formulário "Manualmente"

157

A

Página Data Access

157

Criando os Controles de Dados

157

Adicionando o DBNavigator

159

a Testando o Programa

Ativando

Tabela

160

160

Exemplo: Usando o Database Form Wizard

162

Criando um campo autoincremento

162

Criando um Formulário para Acessar a Tabela com Form Wizard

162

Testando o Programa

163

Salvando o Projeto

164

Resumo dos Componentes de Dados

165

Apelidos de Bancos de Dados

166

Capítulo 13 Recursos Adicionais

Definindo Tabelas

169

170

Reestruturando a Tabela "Cliente"

171

Criando um Índice Secundário

171

Criando a Tabela "Venda"

172

Criando

Integridade

Referencial

172

Criando a Tabela de Itens

173

Criando a tabela Fornecedores

173

Criando o Menu Principal

175

O

MenuDesigner: criando menus

175

Tratando Eventos de Menus

178

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Teclas de Acesso e Teclas de Atalho

Alterando o Menu Principal

179

181

Alterando Propriedades

181

Acrescentando os formulários anteriores

181

Associando os formulários aos itens de menu

181

Usando o Controle DBGrid

183

Criando os Componentes de Dados

183

Manipulando dados no DBGrid

183

Usando o Editor de Campos

184

Alterando a Máscara de Edição

185

Capítulo 14 Validação e Pesquisas

186

Exemplo: Cliente por Estado

187

Exemplo: Clientes - Alterando

189

Validação de Campos e Registros

190

Validando Campos

190

Validando Registros

192

Tratamento de Exceções

194

Visualizando Informações sobre Exceções

195

Classes de Exceções

196

Pesquisas na Tabela

197

Adicionando um DBGrid

197

Utilizando um Índice Secundário

198

Pesquisando pelo Nome

199

Pesquisando pelo Código

199

Blocos Protegidos

201

Usando Outros Controles de Dados

202

Usando o DBComboBox

Capítulo 15 Acesso s/ Controle de Dados

202

204

Estados de uma Tabela

205

Métodos para Percorrer Dados

206

Métodos de Abertura e Fechamento

206

Métodos para Percorrer Registros

206

Exemplo: Percorrendo a Tabela de Itens

208

Métodos para Modificar Dados

210

Editando Registros

210

Acrescentando Registros

211

Excluindo Registros

212

Outros Métodos

212

Eventos dos Componentes de Dados

Eventos do Componente Table

Manipulação de Datas

Delphi 4 Total

214

214

216

© 1997, 1998, 1999 GRIAULE

Exemplo: Criando formulário sem utilizar o dbNavigator

218

Tratamento do Erro 'Key violation.'

224

Usando um Controle DBLookupComboBox

225

Capítulo 16 Utilizando Mestre/Detalhe

Criando um Formulário Mestre/Detalhe

227

228

Usando o DFW para criar o formulário

228

Testando o Formulário Gerado

229

Analisando o Formulário

230

Alterando Propriedades do Formulário

231

Salvando o Projeto

232

Usando Três Tabelas no Formulário

233

Ligando os Componentes de Dados

233

Criando

Controles de Dados

233

Criando Campos Calculados

234

Usando um campo Lookup

236

Testando e Salvando o Projeto

237

Atualizando Quantidade em Estoque

238

Capítulo 17 Consultas e SQL

Exemplo: Usando Consultas

241

242

Criando o Formulário

242

Obtendo um Resultado Modificável

243

Simplificando o Select

244

Alterando a Consulta

244

Alterando a Consulta Dinamicamente

244

Alterando Outras Partes da Consulta

247

Exemplo: Consultando Várias Tabelas

249

Consulta com Duas Tabelas

249

Consultando Três Tabelas

250

Usando Campos Calculados no SQL

250

Usando

Funções

de Resumo

251

Outros Comandos SQL

253

Testando Comandos SQL

253

Alterando Registros

253

Excluindo Registros

254

Inserindo e Copiando Registros

254

Executando um Comando de Atualização

255

Consultas num Ambiente Cliente/Servidor

256

Métodos e Eventos do Componente Query

257

Capítulo 18 Instalador e Alias Local

Usando um Alias Local

258

259

Usando o Componente Database

259

Alterando os Componentes de Dados

260

Alterando o Caminho em Tempo de Execução

261

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Criando um programa instalador

262

Iniciando o InstallShield

262

Criando um Instalador

263

Definindo as

Opções de Instalação

263

Definindo os Arquivos Utilizados

264

Escolhendo as caixas de diálogo

265

Definindo os Ícones do Programa

266

Gerando os disquetes de instalação

267

A Configuração do BDE

Capítulo 19 Relatórios

Conceitos do QuickReport

268

269

270

A

página

QReport

270

Construindo o Relatório

271

Usando o QuickReport Wizard

273

Imprimindo o Relatório

274

Analisando o Relatório Gerado

274

Criando um Relatório com Várias Tabelas

276

Inserindo um Número de Página

278

Visualizando o Relatório

278

Acrescentando Várias Tabelas ao Relatório

279

Conectando as Tabelas

279

Criando Sub-detalhes para Vendas

280

Criando Sub-detalhes para Itens de Venda

281

Formatando os Campos

282

Criando um Campo Calculado

283

Criando um Sub-total

284

Chamando o Relatório a Partir do Menu

285

Delphi 4 Total

© 1997, 1998, 1999 GRIAULE

Capítulo 1 Iniciando o Delphi

Princípios da Programação Windows Iniciando o Delphi Criando um Primeiro Programa

© 1997, 1998, 1999 GRIAULE

Princípios da Programação Windows

Antes de começar a trabalhar com o Delphi, é importante ter algumas noções do que está envolvido na programação Windows e no Delphi em particular. Algumas coisas tornam a tarefa de programação no Windows bem diferente de outros ambientes:

Independência do Hardware:No Windows, o acesso aos dispositivos de hardware é feito com intermédio de drivers fornecidos pelo fabricante de hardware, o que evita que o programador tenha que se preocupar com detalhes específicos do hardware.

Configuração Padrão: O Windows armazena centralmente as configurações de formato de números, moeda, datas e horas, além da configuração de cores, livrando o programador de se preocupar com esses detalhes específicos.

Multitarefa: No DOS, um programa geralmente toma o controle da máquina só para si, e outros programas não rodam enquanto isso. Já no Windows vários programas são executados de maneira simultânea e não há como evitar isso.

Controle da Tela: No DOS geralmente um programa ocupa todo o espaço de telas, e o usuário vê e interage apenas com aquele programa. Já no Windows [janelas], toda informações mostradas e todas entradas recebidas do usuário são feitas por meio de uma janela, é uma área separada da tela que pode ser sobreposta por outras janelas (de outros programas por exemplo).

Padrões de Interface: No Windows, todos os elementos de interface aparecem para o usuário e interagem da mesma forma. Além disso, existem padrões definidos pela Microsoft que são recomendados para conseguir a consistência entre aplicativos. Falaremos de alguns deles no curso, mas a melhor forma de aprendê-los é praticar com os aplicativos Windows mais usados do mercado.

Cooperação com o Sistema: Num programa DOS, a execução segue uma ordem prestabelecida pelo programador, e o programa só chama o sistema operacional quando precisa de alguma coisa dele. Já no Windows, o programa deve responder a eventos, que são ativados pelo Windows quando alguma coisa acontece externamente (ou seja, uma ação do usuário, ou uma aviso do sistema). Isso, como veremos, afeta radicalmente o estilo de programação e a forma de pensar no programa. A sequência de execução do programa depende da sequencia de eventos.

© 1997, 1998, 1999 GRIAULE

Iniciando o Delphi

© 1997, 1998, 1999 GRIAULE Iniciando o Delphi Inicie o Delphi através do seu ícone programa

Inicie o Delphi através do seu ícone

programa na sua área de trabalho. Senão, clique no menu Programas|Borland Delphi 4|Delphi 4.

no Windows, se você já tiver um atalho para o

4|Delphi 4. no Windows, se você já tiver um atalho para o do Windows e depois

do Windows e depois em

A tela básica do Delphi tem os seguintes elementos:

em A tela básica do Delphi tem os seguintes elementos: Ao pressionar F12 irá aparecer a
em A tela básica do Delphi tem os seguintes elementos: Ao pressionar F12 irá aparecer a
em A tela básica do Delphi tem os seguintes elementos: Ao pressionar F12 irá aparecer a
em A tela básica do Delphi tem os seguintes elementos: Ao pressionar F12 irá aparecer a
em A tela básica do Delphi tem os seguintes elementos: Ao pressionar F12 irá aparecer a

Ao pressionar F12 irá aparecer a seguinte tela:

© 1997, 1998, 1999 GRIAULE

© 1997, 1998, 1999 GRIAULE Nota: para criar um atalho para o Delphi, consulte a documentação

Nota: para criar um atalho para o Delphi, consulte a documentação do Windows. Localize o arquivo executável DELPHI32.EXE sob o diretório de instalação.

• Formulário (Form1): Um formulário é a janela do seu programa, o local onde você projeta

a sua interface com o usuário. Durante o projeto, o formulário aparece de forma

praticamente idêntica ao que o usuário final verá, mas permite que você faça alterações no posicionamento dos componentes (elementos de tela) e em suas propriedades (características);

• Speedbar: Uma barra de botões na janela principal do Delphi, que contém botões para executar os comandos mais usados do Delphi;

Paleta de Componentes: Também na janela principal, é dividida em várias páginas, onde cada uma contém vários tipos de componentes que você pode escolher para colocar no formulário;

Object Inspector: [inspetor de objeto]: Dividido em duas páginas, onde uma contém as

propriedades do componente selecionado, e a outra uma lista de eventos associados a este componente, que define as ações externas as quais você pode tratar;

• Menu Principal: Contém os comandos do ambiente de programação do Delphi, por exemplo, para tratamento de arquivos, definição de opções, etc.

Code Editor: (Aparece atrás do formulário, inicialmente). Contém o código-fonte do

projeto. Com ele, você pode facilmente mudar entre os vários arquivos utilizados no projeto

ou mesmo abrir um arquivo de texto qualquer.

© 1997, 1998, 1999 GRIAULE

Criando um Primeiro Programa

No Delphi você inicia o projeto da sua aplicação escolhendo componentes, que são os objetos de interface com o usuário e alterando as características desses componentes como por exemplo, cor, tamanho, fonte de caracteres, através das propriedades. Por último, você decide quais eventos você quer tratar e escreve o código de programa que é executado por esses eventos.

Nosso primeiro programa irá mostrar uma lista de nomes e permitirá ao usuário adicionar itens na lista, limpar a lista e ordenar a lista em ordem alfabética. O programa terá uma interface como a seguir, com uma lista de itens, um quadro de texto que permite digitar o próximo item da lista, e botões para manipular a lista:

o próximo item da lista, e botões para manipular a lista: Para criá-lo, precisamos alterar propriedades

Para criá-lo, precisamos alterar propriedades do formulário e colocar componentes em cima dele.

Propriedades do Formulário

Propriedades do formulário são as características que definem sua aparência, e algumas vezes, seu comportamento. O Object Inspector lista todas as propriedades do formulário, que são inicializadas com valores padrão quando o projeto é criado. Por exemplo, o título que aparece no formulário (inicialmente Form1) é uma propriedade que você pode alterar no Object Inspector.

uma propriedade que você pode alterar no Object Inspector. Selecione a propriedade Caption no Object Inspector.

Selecione a propriedade Caption no Object Inspector. Clique na coluna da direita (que contém o valor da propriedade) e digite o texto Primeiro Programa Delphi. À medida que você digita, o formulário reflete essa alteração na sua barra de título.

Colocando Componentes

Um formulário vazio não é muito útil, portanto vamos colocar componentes nesse formulário. A Paleta de Componentes contém vários ícones, onde cada um representa um

© 1997, 1998, 1999 GRIAULE

tipo de componente que você pode colocar no formulário. Ela também é dividida em páginas, que podem ser acessadas clicando no marcador de página correspondente. Quando você passa o cursor do mouse por cima de um ícone, ela mostra o nome daquele componente.

por cima de um ícone, ela mostra o nome daquele componente. Clique na página Standard e

Clique na página Standard e depois clique no ícone

Clique na página Standard e depois clique no ícone (Edit). Agora clique no formulário. Vai aparecer

(Edit). Agora clique no

formulário. Vai aparecer um quadro de edição chamado "Edit1". Depois iremos alterar esse nome padrão. Para mudá-lo de posição no formulário, posicione o cursor em cima dele, pressione e segure o botão do mouse, e arraste-o para outra posição, ao arrastar o componente será mostrado as coordenadas (x, y) indicando a posição do componente no formulário . Ou, se preferir, usando o teclado, segure a tecla [Ctrl] e use as teclas de seta

para movimentá-lo.

a tecla [Ctrl] e use as teclas de seta para movimentá-lo. Agora precisamos de um quadro

Agora precisamos de um quadro de lista. Clique no íconea tecla [Ctrl] e use as teclas de seta para movimentá-lo. componentes, na mesma página Standard,

componentes, na mesma página Standard, depois clique no formulário, um pouco abaixo do quadro de texto (não se preocupe com alinhamento). Para aumentar seu tamanho lateral, clique na alça mais à direita, segure o botão do mouse e arraste-o para a direita. Ou,

usando o teclado, segure [Shift] e pressione a seta para a direita.

(ListBox) da paleta de

e pressione a seta para a direita. (ListBox) da paleta de Vamos colocar três botões no

Vamos colocar três botões no formulário. Como são vários controles do mesmo tipo,

no formulário. Como são vários controles do mesmo tipo, (Button) da paleta de podemos fazer o

(Button) da paleta de

podemos fazer o seguinte: segure [Shift] e clique no ícone

componentes. Agora clique três vezes no formulário, colocando um botão abaixo do outro.

Não se preocupe com o alinhamento por enquanto Depois clique no ícone do ponteiro ( . O formulário deve ficar parecido com o seguinte:

)
)
( . O formulário deve ficar parecido com o seguinte: ) Clique no botão (Run) da
( . O formulário deve ficar parecido com o seguinte: ) Clique no botão (Run) da

Clique no botão

deve ficar parecido com o seguinte: ) Clique no botão (Run) da SpeedBar. O Delphi irá

(Run) da SpeedBar. O Delphi irá compilar o programa, gerando um

arquivo executável e vai iniciar sua execução. Durante a execução, você pode digitar texto no quadro de texto, e clicar nos botões. Depois tecle [Alt+F4] para terminar o programa (ou feche a janela com o mouse).

Repare que o Delphi cuida de toda a parte de interface com o usuário. Você não precisa escrever código para mostrar uma janela na tela nem seus componentes. Mas para definir o que o programa vai fazer, isto é, como ele reage aos eventos externos, você precisa escrever código.

© 1997, 1998, 1999 GRIAULE

Alterando as Propriedades dos Componentes

Para mudar a aparência dos componentes, alteraremos suas propriedades. É importante notar que o Object Inspector disponibiliza as propriedades do componente que estiver selecionado, ou seja, com as alças de marcação. Quando você clica em um componente com o mouse, ele é selecionado e você pode alterar suas propriedades. Quando você clica numa região vazia do formulário (ou pressiona [Esc]), você pode alterar as propriedades do formulário.

[Esc]), você pode alterar as propriedades do formulário. Selecione o quadro de texto e depois clique

Selecione o quadro de texto e depois clique na propriedade Text no Object Inspector. Apague o valor atual (que é Edit1). Assim esse componente não vai mais começar mostrando "Edit1" no seu conteúdo.

Agora clique no primeiro botão (Button1) e altere sua propriedade Caption para Adicionar. Isso define o texto do botão.

Clique no segundo botão (Button2) e altere Caption para "Ordenar" e no terceiro botão, altere Caption para "Limpar".

Respondendo a Eventos

Todo o código no Delphi é executado, direta ou indiretamente, em resposta a eventos. Quando você (ou o usuário) clica em um botão por exemplo, isso provoca um evento. Se existir um trecho de programa associado a esse evento (um procedimento de evento), esse trecho será executado. Senão, o evento não vai fazer nada.

Clique no botão Adicionar para selecioná-lo. No Object Inspector, clique no marcador de página "Events". Essa página lista quais eventos são reconhecidos pelo componente. O primeiro deles, OnClick , acontece quanto o botão recebe um clique do mouse. Clique duas vezes na OnClick, acontece quanto o botão recebe um clique do mouse. Clique duas vezes na coluna da direita, e o Delphi vai abrir o editor de código, contendo o seguinte texto:

procedure TForm1.Button1Click(Sender: TObject); begin end;

procedure TForm1.Button1Click(Sender: TObject); begin end; O cursor está posicionado entre os delimitadores begin e

O cursor está posicionado entre os delimitadores begin e end, indicando onde você deve escrever o código, que será executado ao clicar no botão Adicionar. Escreva o seguinte (diferenças entre maiúsculas e minúsculas não importam):

ListBox1.Items.Add(Edit1.Text);

Edit1.Clear;

não importam): ListBox1.Items.Add(Edit1.Text); Edit1.Clear; Pressione a tecla [F12] para voltar ao formulário. Clique

Pressione a tecla [F12] para voltar ao formulário. Clique no botão Ordenar e depois clique duas vezes no valor do evento OnClick. Isso vai gerar um tratador de evento para o botão Ordenar. Escreva o seguinte entre o begin e o end:

© 1997, 1998, 1999 GRIAULE

ListBox1.Sorted := True;

© 1997, 1998, 1999 GRIAULE ListBox1.Sorted := True; Finalmente retorne ao formulário, selecione o botão Limpar

Finalmente retorne ao formulário, selecione o botão Limpar e siga o mesmo processo. Digite o seguinte código:

ListBox1.Clear;

ListBox1.Sorted := False;

Testando o Programa

Agora execute o programa clicando no botãoListBox1.Sorted := False; Testando o Programa quadro de texto, e clicar no botão Adicionar (ou teclar

quadro de texto, e clicar no botão Adicionar (ou teclar [Enter]). O item digitado será acrescentado à lista. Depois de acrescentar alguns itens, clique em Ordenar. A lista será colocada em ordem alfabética. Para esvaziar a lista, clique em Limpar.

ordem alfabética. Para esvaziar a lista, clique em Limpar. . Você pode digitar um valor no

. Você pode digitar um valor no

Salvando o Programa

Limpar. . Você pode digitar um valor no Salvando o Programa Para que você possa usar

Para que você possa usar esse programa mais tarde, clique em File|Save All (menu

esse programa mais tarde, clique em File|Save All (menu File , item Save All ) ou

File, item Save All) ou no botão

arquivo do formulário. Digite AULA1 e clique Ok. Depois o Delphi vai perguntar o nome do

arquivo de projeto. Digite AULA1P e clique Ok (não use o mesmo nome que o formulário).

da SpeedBar. O Delphi vai pedir um nome para o

Nota: Você também pode clicar no formulário ou no editor de código com o mouse, mas geralmente o método mais rápido de alternar entre os dois é usar a tecla [F12].

© 1997, 1998, 1999 GRIAULE

Capítulo 2 Noções Básicas

Ambiente de Programação Eventos e Procedimentos Componentes Propriedades Métodos Object Pascal e Bibliotecas VCL- Visual Component Library Objetos Resumo Projetos Grupos de Projetos Edições do Delphi

© 1997, 1998, 1999 GRIAULE

Ambiente de Programação

O Delphi possui um ambiente integrado de desenvolvimento (IDE - Integrated Development Environment) onde você utiliza a maioria das funções de desenvolvimento. Nesse ambiente você projeta o programa e depois executa o programa para testar o seu funcionamento.

Sempre que você executa o programa, o Delphi compila o programa, isto é, gera um programa executável com código de máquina a partir do programa fonte que você criou. Esses programas executáveis se tornam independentes do Delphi e podem rodar separadamente.

Programação Orientada a Objeto (POO)

Para compreendermos melhor ambiente de desenvolvimento do Delphi é necessário que você entenda os conceitos de Programação Orientada a Objetos(POO).

A POO é um forma de gerenciar a complexidade do programa, de forma que facilite a manutenção e a reutilizacão de partes do programa. O programa é dividido em partes relativamente isoladas que podem ser alteradas de forma independente e podem ser reutilizadas mais facilmente em outros programas.Estas partes são chamadas de Classes (Iremos discutir em Objetos).

© 1997, 1998, 1999 GRIAULE

Eventos e Procedimentos

Programas DOS convencionais seguem um fluxo seqüencial, em que um comando segue o outro de forma definida pelo programador. O usuário deve agir de acordo com os "modos" de operação do programa e saber o momento certo para entrar com comandos.

Programas em uma interface multitarefa, como o Windows, apresentam todas as opções ao usuário, para que ele possa selecioná-los na ordem em que desejar. O Windows intercepta as ações realizadas pelo usuário e informa ao programa onde, como e quando elas acontecem. O programa deve reagir de forma apropriada nos momentos determinados pelo usuário. Cada resultado de uma ação do usuário é chamada de evento, por exemplo: clique do mouse, digitação de uma tecla, etc.

Como conseqüência, o programa não é mais um bloco único, mas é dividido em pequenas seções, cada uma responsável pela tarefa a realizar em resposta a um determinado evento. Essas seções são os procedimentos de evento do Delphi.

Cada evento é associado a um componente e cada componente tem uma lista de eventos que são acionados por ele em situações específicas (o Object Inspector mostra esta lista na página Events). Com isso, o projeto de um programa é feito iniciando pelo projeto de sua interface (seus componentes) e depois escrevendo-se os procedimentos de evento. Não é obrigatório definir todos os eventos para um componente. Se não existe um procedimento para um evento específico, simplesmente não acontece nada para aquele evento.

Como veremos mais tarde, além dos procedimentos de evento, você pode dividir o seu programa, usando rotinas auxiliares.

Nota: para melhor utilização do ambiente de programação e da linguagem, consulte o help do Delphi. Os procedimentos de evento são armazenados na unidade, que é um arquivo de texto associado ao formulário. Você pode editar todas as unidades no editor de código do Delphi.

© 1997, 1998, 1999 GRIAULE

Componentes

© 1997, 1998, 1999 GRIAULE Componentes A paleta de componentes lista tipos de componentes que podem

A paleta de componentes lista tipos de componentes que podem ser utilizados no programa,

como botões de pressionar, barras de rolagem, grades de dados e editores de texto. Para criar um componente, você seleciona o ícone correspondente e depois clica no formulário para colocá-lo. Você também pode criá-lo já com o tamanho desejado, pressionando o botão do mouse sobre o formulário e arrastando para definir o tamanho.

Nota: todos os componentes são descritos em detalhe no Help do Delphi, com todas suas propriedades, métodos e eventos. Clique em um ícone de componente e pressione F1 para ver o texto de help sobre ele.

Note que há mais páginas do que cabe na tela em dado momento. Para ver as páginas

restantes, como Dialogs, Midas, Win 3.1, Samples e ActiveX, clique nos botões ficam na extremidade direita da janela do Delphi.

botões ficam na extremidade direita da janela do Delphi. que Alguns componentes não aparecem para o

que

Alguns componentes não aparecem para o usuário durante a execução do programa, apesar de aparecer no formulário, e serem manipulados pelo código do programa. São os componentes não-visuais (veremos alguns deles no decorrer do curso). Mas a maioria aparece como um objeto de interface durante a execução. São os controles (ou componentes visuais). É importante lembrar que todo controle é um componente, mas nem todo componente é um controle.

O próprio formulário também é considerado um componente, embora seja tratado de forma

diferente, e geralmente contém vários outros componentes.

Visão Geral dos Componentes

A paleta de componentes se divide em várias páginas para facilitar a organização. Nós

veremos alguns deles no curso, mas é importante ter uma noção geral do conteúdo dessas

páginas.

Standard: componentes padrão da interface do Windows, usados para barras de menu, exibição de texto, edição de texto, seleção de opções, iniciar ações de programa, exibir listas de itens etc. Geralmente são os mais usados.

Additional: componentes especializados que complementam os da página Standard. Contém botões com capacidades adicionais, componentes para exibição e edição de tabelas, exibição de imagens, gráficos etc.

© 1997, 1998, 1999 GRIAULE

Win32: componentes comuns de interface que são fornecidos pelo Windows 95/NT para os programas. Contém componentes para dividir um formulário em páginas, edição de texto formatado, barras de progresso, exibição de animações, exibição de dados em árvore ou em forma de ícones, barras de status e de ferramentas etc.

System: componentes que utilizam funções avançadas do sistema operacional, como temporização, multimídia, OLE e DDE.

Internet: componentes para acesso aos recursos e protocolos da Internet, como criação de páginas Web dinâmicas, acesso aos protocolos FTP, NNTP, POP, SMTP, TCP, UDP.

Data Access: componentes para acesso a banco de dados.

Data Controls: componentes visuais para mostrar dados em aplicações de bancos de dados. São semelhantes aos componentes padrão (Standard).

Decision Cube (apenas Delphi Client/Server): componentes para análise multidimensional de dados, com capacidades de tabulação cruzada [crosstab], criação de tabelas e gráficos etc.

QReport: QuickReport é um gerador de relatórios que acompanha o Delphi. Os componentes desta página permitem desenhar o seu relatório dentro do Delphi.

Dialogs: O Windows tem caixas de diálogo comuns, como veremos, que facilitam mostrar uma interface padrão dentro do seu programa para as tarefas comuns, como abrir e salvar arquivos, impressão, configuração de cores e fontes etc. Esta página tem componentes que permitem utilizar essas caixas de diálogo comuns.

Midas (apenas Delphi Client/Server e Enterprise) : componentes utilizados para criar aplicações multi-tiered.

Win3.1: Esta página contém controles considerados obsoletos, que estão disponíveis apenas para compatibilidade com programas antigos. Não crie programas novos que utilizam esses controles.

Samples: contém exemplos de componentes para que você possa estudá-los e aprender a criar seus próprios componentes. O código fonte desses exemplos está no subdiretório SOURCE\SAMPLES do diretório de instalação do Delphi.

ActiveX: um componente ActiveX é um tipo de componente que pode ser criado em outra linguagem e utilizado no Delphi. Esta página contém alguns exemplos de componentes ActiveX prontos para utilizar, que têm funções de gráficos, planilha, etc.

© 1997, 1998, 1999 GRIAULE

Propriedades

Componentes têm propriedades [properties], que definem suas características específicas e eventos, que são acontecimentos externos, geralmente relacionados com ações do usuário. Por exemplo o formulário tem como propriedades o título da janela (Caption), sua cor (Color), sua posição na tela (Left e Top). Um quadro de texto tem uma propriedade que define o texto que este contém (Text), entre outras. Quando o usuário clica com o mouse em um controle, isso causa um evento OnClick, e quando ele pressiona uma tecla, causa um evento OnKeyDown (entre outros).

Para alterar propriedades durante o projeto da interface, você seleciona o componente desejado (por exemplo Edit1), depois seleciona a propriedade desejada (por exemplo, Text) no Object Inspector e digita seu valor. Durante a execução do programa, o código pode alterar uma propriedade dinamicamente (em resposta a um evento). Para isso, basta inserir no código de programa um comando como o seguinte:

Edit1.Text := 'Bem-vindo ao Delphi';

Nota: se você clicar em uma propriedade e teclar [F1], o Delphi mostrará o texto de help relacionado àquela propriedade.

© 1997, 1998, 1999 GRIAULE

Métodos

Métodos são nomes para ações executadas por um componente. No programa anterior, por exemplo, usamos o método Clear, que quando executado, limpa o conteúdo de um controle. Por exemplo, no programa anterior, o procedimento de evento do botão Adicionar faz:

Edit1.Clear;

Quando esse comando é executado, o controle é esvaziado. Repare que todo método é chamado usando-se primeiro o nome do componente, depois o nome do método, da mesma forma que uma propriedade. Métodos só tem utilidade no código do programa, por isso não aparecem no Object Inspector (mas veremos mais tarde que é possível consultar a lista de métodos disponíveis).

© 1997, 1998, 1999 GRIAULE

Object Pascal e Bibliotecas

Todo código de programa no Delphi é escrito em Object Pascal, que é a linguagem de programação usada por ele. Essa linguagem é derivada da linguagem Pascal original, e tem sido aperfeiçoada pela Borland por vários anos, nas diversas versões do Turbo Pascal.

A definição da linguagem contém as regras de sintaxe e os tipos de dados básicos que você pode usar. A maioria das rotinas úteis do Delphi não fazem parte da linguagem em si, mas são implementados pela biblioteca de tempo de execução [run-time library] do Delphi.

© 1997, 1998, 1999 GRIAULE

VCL - Visual Component Library

Os componentes, suas propriedades, eventos e métodos são implementados pela biblioteca visual de componentes [Visual Component Library], também chamada VCL. O código fonte da VCL é fornecido com o Delphi e permite você modificar os componentes ou estudar como eles foram feitos.

Você também pode criar novos componentes, escrevendo-os em Object Pascal. O próprio Delphi foi criado em Delphi, utilizando-se a linguagem Object Pascal e versões sucessivas do ambiente.

Nota: se você digitar apenas o nome do componente e um ponto, o CodeInsight do Delphi mostrará a lista das propriedades e métodos disponíveis. Ao continuar digitando, é feita uma busca incremental nessa lista. Nota: para obter ajuda sobre qualquer elemento do Object Pascal ou da VCL, clique na palavra desejada, no editor de código e pressione a tecla [F1].

© 1997, 1998, 1999 GRIAULE

Objetos

Componentes são apenas um tipo de objetos, que é um termo bastante utilizado no Delphi. O próprio nome Object Pascal indica que se trata de uma linguagem orientada a objetos.

Um objeto, numa definição prática, é uma área de memória separada, contendo dados (variáveis) e o código que manipula esses dados. No caso de um componente, os dados aparecem como propriedades e o código que os manipula é composto de métodos. Basicamente todo objeto contém propriedades e métodos, mesmo que ele não possa ser colocado num formulário e editado. Mais tarde veremos vários exemplos de objetos que não são componentes.

© 1997, 1998, 1999 GRIAULE

Resumo

Para dominar a programação em Delphi, é preciso conhecer os componentes da VCL, os objetos das bibliotecas do Delphi e a linguagem Object Pascal, que é o fundamento no qual tudo se baseia.

© 1997, 1998, 1999 GRIAULE

Projetos

O Delphi trata cada aplicativo que você cria como um projeto, que é uma lista dos arquivos necessários para construir um programa. Para saber quais são os formulários, as unidades correspondentes, etc., o Delphi nos fornece o Project Manager, que pode ser acessado através do Menu View, opção Project Manager. A janela de título do Delphi sempre tem, no título, o nome Delphi - Nome do projeto. Um projeto em Delphi se compõe de:

· Formulários: um formulário é uma janela que projetamos no Delphi. Normalmente toda aplicação contém um ou mais formulários. Cada formulário tem uma unidade associada, que é um arquivo contendo todo o código associado a eventos;

· Unidades independentes: uma unidade independente contém código do Delphi que não está necessariamente associado a nenhum formulário ou controle em particular. Unidades independentes geralmente contém variáveis e rotinas usadas por toda aplicação.

Lembre-se que um projeto é apenas uma lista dos arquivos usados para construir o programa, mas não os contém propriamente.

Salvando o Projeto em Disco

Ao gravar o projeto em disco, o Delphi cria vários arquivos: dois para o projeto em si, e outros para cada formulário e cada unidade independente usada. Os arquivos têm as seguintes extensões:

Projeto:

.DPR e .OPT (opções)

Formulários:

.DFM e .PAS (unidade associada)

Unidades independentes:

.PAS

Além disso, o Delphi gera outros arquivos no diretório do projeto, a maioria deles quando você compila o programa (por exemplo, automaticamente ao executar):

Unidade compilada:

Arquivo de recursos:

Programa compilado:

Arquivos de backup:

nome-da-unit.DCU

nome-do-projeto.RES

nome-do-projeto.EXE

*.~PA, *.~DF, *.~DP

Para salvar o projeto, juntamente com seus arquivos, use o item de menu File|Save All do Delphi. Da primeira vez que você salva o projeto, o Delphi pede o nome do arquivo de formulário (o padrão é "Unit1.PAS") e o nome do arquivo de projeto (o padrão é "Project1.dpr"). Não é necessário digitar as extensões, pois o Delphi cuida de acrescentá- las.

© 1997, 1998, 1999 GRIAULE

Quando você salva um arquivo de formulário, o Delphi salva dois arquivos: a unidade associada ao arquivo [unit], com uma extensão .PAS, que é um arquivo contendo todo o código de programa associado aos eventos, bem como todo o código gerado pelo Delphi, e outro arquivo contendo as propriedades do formulário e de todos os componentes, com o mesmo nome de arquivo, mas com a extensão .DFM. O arquivo de projeto é um arquivo .DPR, que corresponde ao código principal do programa executável. A partir desse arquivo, o Delphi localiza os outros arquivos necessários.

Nota: o nome do arquivo de projeto deve ser diferente de qualquer unidade do projeto.

Comandos para trabalhar com Projetos

Vários comandos do menu File do Delphi são usados para trabalhar com os projetos e os arquivos que fazem parte deles:

New Application Cria

um novo projeto vazio

New Form Cria um novo formulário e sua unidade

Open

Reopen

Save

Save As

Save

Project

As

Save All

Close

Close All

Abre um projeto ou unidade existente.

Mostra os arquivos utilizados recentemente e permite reabrir qualquer um deles.

Salva o arquivo atual (unidade). Se esta é a primeira vez que está sendo salvo, pergunta pelo nome.

Salva uma cópia do arquivo atual com outro nome ou em outro diretório.

Salva o arquivo de projeto. Sempre pede o nome.

Salva todos os arquivos do projeto e o próprio arquivo de projeto. Só pede nomes de arquivos para os que não foram salvos ainda.

Fecha o arquivo atual.

Fecha todos os arquivos e o projeto atual.

Além desses comandos, existem ícones na SpeedBar que podem ser usados para essas tarefas:

ícones na SpeedBar que podem ser usados para essas tarefas: (Open project) Equivale a File|Open ,

(Open project)

Equivale a File|Open, mas mostra apenas os arquivos de projeto.

© 1997, 1998, 1999 GRIAULE

( S a v e a l l ) (Save all)

( O p e n P r o j e c t ) (Open Project)

( S a v e ) (Save )

( A d d f i l e t o p r o j e (Add file to project)

(Remove file from project)) ( A d d f i l e t o p r o j e

O mesmo que File|Save all

O mesmo que File|Open Project

O mesmo que File|Save

Adiciona um arquivo ao projeto atual.

Remove um arquivo do projeto atual.

© 1997, 1998, 1999 GRIAULE

Grupos de Projetos

O delphi 4.0 permite trabalhar com mais de um projeto aberto, esses projetos podem ser definidos em um grupo. No menu View|Project Manager é informado os projetos que pertencem a um determinado grupo.O arquivo de um grupo tem a extensão ".BPG"

Comandos para tabalhar com grupos de projetos

Vários comandos do menu Project são usados para trabalhar com grupos de projetos , os principais são:

Add New

Project

Add Existing

Project

Adiciona um novo projeto ao grupo.

Adiciona um projeto existente ao grupo

(Projeto Compile Atual) Compila somente as units que foram modificadas, do projeto ativo.

Build ( Projeto Atual)

Compila todas as units do projeto ativo, independente se foram ou não modificadas.

Compile All

Compila somente as units que foram modificadas, dos projetos

Projects

pertencentes ao grupo.

Build All

Compila todas as units dos projetos pertencentes ao grupo, independente

Projects

se foram ou não modificadas.

© 1997, 1998, 1999 GRIAULE

Edições do Delphi

O Delphi está atualmente na versão 4. Essa versão é geralmente compatível com programas

desenvolvidos nas versões anteriores, embora alguns necessitem de modificação para

funcionar, especialmente os feitos para a versão 1.0.

É importante saber também que existem várias edições diferentes do Delphi, desde a

Standard (a mais simples), passando pela Professional, que tem mais recursos, até a edição Client/Server Suite, mais sofisticada e com recursos úteis para grandes empresas:

Standard: muito limitada em recursos. Indicada apenas para quem tem interesse em desenvolvimento de pequenos programas ou para fins de aprendizado.

Professional: inclui mais recursos que a edição Standard. Recomendada para desenvolvedores profissionais.

Client/Server : inclui mais recursos que a Professional, especificamente voltados para grandes desenvolvedores que utilizam bancos de dados no padrão cliente/servidor.

Note que o Delphi 4 só funciona para ambientes de 32 bits, ou seja, Windows 95/98/etc. e Windows NT. Se você quiser desenvolver programas compatíveis com Windows 3.x, você deve utilizar a versão 1.0.

© 1997, 1998, 1999 GRIAULE

Capítulo 3 Exemplos Adicionais

Exemplo: Calculadora

© 1997, 1998, 1999 GRIAULE

Exemplo: Calculadora

O nosso objetivo é criar uma calculadora simples, que apenas soma dois números

fornecidos e mostra o resultado, semelhante à figura:

fornecidos e mostra o resultado, semelhante à figura: Criando os Componentes Para começar, inicie o Delphi

Criando os Componentes

o resultado, semelhante à figura: Criando os Componentes Para começar, inicie o Delphi ou, se o

Para começar, inicie o Delphi ou, se o Delphi estiver aberto, crie um novo projeto com File |New Application e altere a propriedade Caption da janela principal (Form1) para "Calculadora". Agora grave o projeto usando File | Save All no menu do Delphi. Dê os nomes de CALC ao formulário e CALCP ao projeto.

Isso vai salvar três arquivos em disco, como já vimos:

CALC.PAS

A unidade unidade associada ao formulário

CALC.DFM Contém a definição do formulário e seus controles.

CALCP.DPR

O arquivo de projeto, que lista os nomes dos outros.

O arquivo de projeto, que lista os nomes dos outros. Dê dois cliques no ícone Edit

Dê dois cliques no ícone EditO arquivo de projeto, que lista os nomes dos outros. até o topo do formulário e

até o topo do formulário e altere a sua propriedade Name, para "editOperando1". A propriedade Name determina o nome que será usado no programa para manipular esse componente, que será usado para receber o primeiro operando digitado.

para criar um quadro de edição no formulário. Mova-o

para criar um quadro de edição no formulário. Mova-o Repita as mesmas ações para criar outro

Repita as mesmas ações para criar outro quadro de texto para o segundo operando. Ele deverá ficar logo abaixo do primeiro. Dê o nome "editOperando2".

© 1997, 1998, 1999 GRIAULE

© 1997, 1998, 1999 GRIAULE Agora crie um botão de comando, com um clique duplo na

Agora crie um botão de comando, com um clique duplo na ferramenta seu tamanho para ficar igual ao dos quadros de texto.

seu tamanho para ficar igual ao dos quadros de texto. . Altere o Nota : Quando

. Altere o

Nota: Quando você cria um componente, ele recebe um nome default como Edit1, Button1, etc. É recomendável dar um nome mais descritivo para que seja mais fácil entender o programa mais tarde.

Nota: No curso adotaremos um padrão para nomes de componentes: um prefixo de três ou quatro letras que diz o tipo de componente (edit para Edit, btn para Button, etc.) seguido de um nome descritivo (no caso, Operando1). Veremos que esse padrão facilita a compreensão dos programas.

Altere sua propriedade Caption para "=" (sinal de igual). Altere Name para "btnCalcula".

Finalmente crie um quadro de texto, posicionando-o abaixo do botão de comando, que vai conter o resultado. Dê o nome de "editResultado".(sinal de igual). Altere Name para "btnCalcula". Agora, para mostrar o sinal de "+" vamos usar

conter o resultado. Dê o nome de "editResultado". Agora, para mostrar o sinal de "+" vamos

Agora, para mostrar o sinal de "+" vamos usar um componente Label (rótulo), que

de "+" vamos usar um componente Label (rótulo), que apenas mostra um texto para o usuário,

apenas mostra um texto para o usuário, não permitindo alteração. Selecione o ícone desenhe um rótulo à esquerda do editOperando2, como na figura. Altere sua propriedade Caption para conter um sinal de +. Para fazer com que esse sinal fique maior, selecione a propriedade Font, que corresponde às características do texto, e clique duas vezes do seu lado direito. Selecione "MS Sans Serif" na lista de fontes e um tamanho maior na lista "Tamanho". Depois clique Ok.

e

Tratando os Eventos

A interface da calculadora está pronta, mas ela ainda não executa a função desejada. Precisamos acrescentar código que leia os dois operandos, some os seus valores e coloque o resultado no último quadro de texto.

Clique duas vezes no botão 'btnCalcula', no formulário. Isso vai criar um tratador de eventos para o evento padrão do botão, que é o evento OnClick. O Delphi vai gerar o seguinte código:

procedure TForm1.btnCalculaClick(Sender: TObject); begin end;

TForm1.btnCalculaClick(Sender: TObject); begin end; Para fazer o cálculo precisaremos de variáveis . Uma

Para fazer o cálculo precisaremos de variáveis. Uma variável é uma área de memória que tem um nome e armazena um determinado valor. No Delphi, toda variável também tem um tipo, que determina quais os valores que ela pode conter. Depois veremos todos os tipos de

© 1997, 1998, 1999 GRIAULE

dados em detalhes, mas por enquanto, usaremos o tipo de dados 'double', que permite armazenar valores numéricos com parte fracionária, com a precisão de 15 a 16 dígitos significativos.

Nota: Você pode também selecionar o evento no Object Inspector e criar o tratador a partir do nome dele, mas para o evento padrão, é mais rápido um clique duplo no próprio componente.

Variáveis são declaradas com a palavra var, informando-se o nome e o tipo das variáveis. Antes da palavra reservada begin, acrescente o seguinte:

var

da palavra reservada begin , acrescente o seguinte: var op1, op2: double; res: double; Isso declara

op1, op2: double; res: double;

Isso declara três variáveis: 'op1', 'op2' e 'res', todas do tipo double. Repare que duas variáveis do mesmo tipo podem ser declaradas separando-as por vírgula antes do tipo ou em uma declaração separada.Não é necessário repetir o var para várias declarações, pois elas terminam quando se encontra o begin.

Agora vamos utilizar essas variáveis para obter os valores digitados pelo usuário. Para ler o valor digitado em um controle Edit, devemos ler a propriedade Text , só que essa propriedade tem um valor alfanumérico (pode conter letras e números), Text, só que essa propriedade tem um valor alfanumérico (pode conter letras e números), logo precisamos convertê-la para numérico. Isso é feito com a função StrToFloat:

op1 := StrToFloat(editOperando1.Text); op2 := StrToFloat(editOperando2.Text);

Depois basta somar as variáveis e mostrar o resultado, utilizando novamente uma função de conversão:

res := op1 + op2; editResultado.Text := FloatToStr(res);

res := op1 + op2; editResultado.Text := FloatToStr(res); O resultado final, com todo o código acrescentado,

O resultado final, com todo o código acrescentado, será o seguinte:

procedure TForm1.btnCalculaClick(Sender: TObject); begin op1 := StrToFloat(editOperando1.Text); op2 := StrToFloat(editOperando2.Text); res := op1 + op2; editResultado.Text := FloatToStr(res);

end;

Repare que foi utilizada a identação (deslocamento à direita) dos comandos, mas isso não é obrigatório no Delphi. Foi utilizado apenas para facilitar a legibilidade.

© 1997, 1998, 1999 GRIAULE

Nota: Nomes de variáveis em Object Pascal podem ter até 63 caracteres e podem conter letras (A-Z, a-z), números e o caractere '_'. O primeiro caractere não pode ser número.

O Object Pascal não diferencia maiúsculas de minúsculas (não é case-sensitive).

Executando o Programa

(não é case-sensitive ). Executando o Programa Execute o programa com o botão ou a tecla

Execute o programa com o botão

). Executando o Programa Execute o programa com o botão ou a tecla [F9]. Digite um

ou a tecla [F9]. Digite um número no

editOperando1 e outro no editOperando2 e depois clique no btnCalcula.

Repare que você pode usar a tecla [Tab] para passar de um controle para outro utilizando o teclado (e não [Enter], como no DOS). O controle que responde às teclas em determinado momento tem o foco de teclado. Cada controle indica o foco de forma diferente. Por exemplo, um controle Edit mostra o cursor de texto quando ele tem o foco, já um controle Button mostra um retângulo tracejado em volta do texto. Como veremos, esta ordem de foco pode ser alterada.

Melhoras de Interface

Alguns detalhes podem ser melhorados: primeiro, o quadro de edição 'editResultado' não deveria receber o foco quando o usuário pressiona [Tab] e não deveria permitir edição do texto, pois não faz muito sentido. Para isso, selecione o controle e altere sua propriedade TabStop para False. Você pode fazer isso selecionando o valor a partir da lista (com TabStop para False. Você pode fazer isso selecionando o valor a partir da lista (com o botão de seta) ou com um clique duplo no valor da propriedade, que alterna de True para False. Essa propriedade, quando é False, faz com que o controle seja "pulado" pela tecla [Tab].

com que o controle seja "pulado" pela tecla [Tab]. Também altere a propriedade ReadOnly para True,

Também altere a propriedade ReadOnly para True, o que faz com que o controle não permita edição de seu valor.

faz com que o controle não permita edição de seu valor. Outra mudança: como o usuário

Outra mudança: como o usuário não usará a tecla [Enter], podemos fazer com que ela acione o botão "=". Basta alterar a propriedade Default do botão 'btnCalcula' para True (verdadeiro). Isso faz com que ele seja o botão default, que é sempre acionado quando o usuário tecla [Enter]. Execute o programa e teste as modificações.

tecla [Enter]. Execute o programa e teste as modificações. Ao executar o projeto podemos observar que

Ao executar o projeto podemos observar que os quadros de edição 'editOperando1', 'editOperando2' e 'editResultado' aparecem com seus respectivos nomes , o ideal seria aparecer inicialmente sem nenhuma informação, para fazer esta modificação vamos retornar ao projeto e alterar a propriedade Text de cada componente edit . É a propriedade Text que indica o conteúdo do componente naquele momento, ao criar o componente edit e modificar a propriedade Name o delphi automaticamente coloca o mesmo conteúdo desta propriedade na propriedade Text, caso esta não tenha sido modificada antes.

© 1997, 1998, 1999 GRIAULE

Salvando o Projeto

Para salvar o projeto e todos os arquivos, basta usar File|Save All ou clicar no botão File|Save All ou clicar no botão

da SpeedBar. Com isso o Delphi vai salvar todas as alterações feitas no projeto, como foi informado o nome do projeto e da unit ele não irá pedir novamente.o Projeto Para salvar o projeto e todos os arquivos, basta usar File|Save All ou clicar

© 1997, 1998, 1999 GRIAULE

Capítulo 4 Variáveis e Tipos de Dados

Tipos de Dados Funções de Conversão OPerações Aritméticas Tipos Ordinais Escopo de Variáveis Constantes

© 1997, 1998, 1999 GRIAULE

Tipos de Dados

Toda variável tem um tipo, que determina quais os valores que você pode colocar nessa variável e quais as operações que podem ser executadas sobre ela. Uma variável de um tipo numérico, por exemplo, só pode receber valores numéricos. Esses valores podem ser constantes, valores de outras variáveis, ou expressões com operações sobre valores. Para colocar um valor em uma variável, usa-se o operador de atribuição: ':=' (dois-pontos- igual), que é lido como "recebe". Por exemplo:

procedure TForm1.Button1Click(Sender: TObject); var

a: integer; { 'a' é uma variável do tipo Integer } b: integer; { 'b' idem } begin

a

:= 2;

b

:= a;

b

:= b + 3;

end;

Geralmente, com algumas exceções, uma variável de um determinado tipo só pode receber valores deste tipo. Não é permitido, por exemplo, o seguinte:

a := 'Nome';

pois

apenas valores numéricos podem ser colocados na variável 'a'.

Existem vários tipos de dados numéricos, e cada um tem uma determinada faixa de valores e ocupa um certo espaço de memória. Não é permitido colocar em uma variável um valor que esteja fora da faixa do seu tipo.

Tipos Numéricos

A linguagem Object Pascal tem vários tipos de dados para variáveis numéricas, que são os seguintes:

Tipo

BytesFaixa de Valores

Precisão(dígitos)

Tipos Inteiros

Shortint

1

-128 a 127

N/A

Byte

1

0 a 255

N/A

Smallint

2

-32768 a32767

N/A

Word

2

Integer

4

Longint

4

Cardinal

4

Longword

4

Int64

8

Tipos Reais

Single

4

Real48

6

Real

8

Double

8

Comp

8

Currency

8

Extended

10

© 1997, 1998, 1999 GRIAULE

0 a 65535

-2 bilhões a 2 bilhões (-2.147.483.648 a 2.147.483.647)

-2.147.483.648 a 2.147.483.648

0 a 4.294.967.295

0 a 4.294.967.295

- 2 63

a 2 63

1.5x10 -45 a 3.4x10 38

2.9x10 -39 a 1.7x10 38

5x10 -324 a 1.7x10 308

5x10 -324 a 1.7x10 308

-2 63 a 2 63

-922337203685477.5808 a 922337203685477.5807

3.6x10 -4951 a 1.1x10 4932

N/A

N/A

N/A

N/A

N/A

N/A

7-8

11-12

15-16

15-16

19-20

19-20

19-20

*Nota: No Delphi 4, o tipo Real é idêntico ao tipo Double. No Delphi 3, o tipo Real tem uma faixa de valore menor que o Double e equivale ao tipo Real48 do Delphi 4. Não é recomendável utilizar Real48, porque ele é muito mais lento para cálculos.

A coluna "bytes" diz quantos bytes de memória são ocupados por uma variável do tipo. Quanto maior a faixa de valores, em geral, maior o espaço de memória.

Os tipos numéricos se dividem em tipos inteiros (ou integrais), que só permitem valores inteiros e tipos reais (ou de ponto flutuante [floating point]), que permitem valores com parte fracionária. Uma forma de entender a diferença é que tipos inteiros são usados para contagem de elementos, enquanto tipos reais são usados para medir alguma coisa. E essa medida nem sempre é exata. Ao fazer cálculos com variáveis reais, nem sempre o resultado é igual ao esperado. Por exemplo:

var

fracao, a, b: real; {'real' é um tipo real}

© 1997, 1998, 1999 GRIAULE

begin

a := 1.0; { o mesmo que 1 } fracao := a / 3;

b := fracao * 3;

if a = b then { faz alguma coisa }

end;

Teoricamente no programa, 'a' é igual a 'b', mas como tipos reais não representam valores

exatos, a igualdade não é exata. A variável 'b' pode ter um valor de 0.99999999 ser comparado, não é igual a 1.0.

, que ao

Cada tipo real tem uma certa precisão, indicada na tabela, que diz quantos dígitos significativos (dígitos excetuando zeros à esquerda e à direita) a variável pode guardar, sem perda de precisão nos cálculos. Assim, é importante lembrar que os valores guardados em um desses tipos nem sempre é exato.

Geralmente os tipos inteiros são mais eficientes para cálculos, e também mantém valores exatos para qualquer operação, desde que o resultado não saia da sua faixa de valores.

Os tipos mais utilizados são smallint, para valores inteiros pequenos, integer ou Longint para valores inteiros maiores, e Double para valores reais com uma precisão razoável. Os tipos Shortint e Byte são utilizados quando é preciso guardar um contador bem pequeno e

é necessário economizar memória.Quando os tipos integer ou longint não são suficientes

podemos usar os tipos

longWord e int64 que existe somente nesta versão.

O tipo Comp é considerado como real, mas ele permite apenas valores inteiros. Ele é útil

para valores monetários.

O tipo Char

O tipo Char permite criar variáveis que guardam caracteres individuais, como letras,

dígitos, sinais de pontuação e caracteres de controle. Cada variável do tipo Char só pode

conter um caractere. Caracteres comuns (imprimíveis) são representados entre aspas simples (apóstrofos):

var minhaVariavel: Char;

minhaVariavel := 'A';

Um caractere também pode ser representado através do código ASCII/ANSI correspondente. Isso é útil principalmente com caracteres de controle, que não podem ser impressos nem digitados normalmente no programa, como caracteres de backspace, fim de linha, retorno de carro etc. Por exemplo, para guardar o caractere 13 (retorno de carro), usa-se a sintaxe:

© 1997, 1998, 1999 GRIAULE

minhaVariavel := #13;

Se o código estivesse numa variável em vez de uma constante, não pode ser usada essa sintaxe. Nesse caso, pode-se usar a função Chr:

codigoASCII := 13; minhaVariavel := Chr(codigoASCII);

Nota: para ver os caracteres da tabela ANSI (exceto os de controle), use o aplicativo Mapa de Caracteres do Windows (em Iniciar | Programas | Acessórios).

O tipo String

Para guardar mais de um caractere, é preciso usar o tipo String. Um valor constante do tipo String é representado entre apóstrofos, como por exemplo:

var nome: string; begin nome := 'João da Silva';

Uma variável string normalmente não tem limite de tamanho definido. O espaço de memória que ela ocupa muda dinamicamente de acordo com o conteúdo atribuído a ela, por exemplo:

nome := '123'; {3 caracteres} nome := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; {26 caracs.} nome := ''; {zero caracteres}

No último caso, tem-se uma string vazia, que é representada por '' (apóstrofos sem caracteres dentro), que ocupa zero caracteres. Ela é usada para "limpar" o conteúdo de uma variável.

Nota: O Windows usa uma tabela de caracteres chamada tabela ANSI, que associa um código numérico a cada caractere.

Nota: o Windows permite caracteres acentuados e especiais, como Â, Ç, ©, ½, «, ¶, etc.

Mas uma variável string pode ser declarada com um tamanho fixo, da seguinte forma:

var

nome: string[50]; telefone: string[10];

Nesse caso, a variável ocupa um espaço fixo de memória, de acordo com o tamanho declarado. No exemplo, nome ocupa 50 caracteres e telefone ocupa 10. Se você tentar atribuir mais caracteres do que cabe na variável, os caracteres restantes são ignorados. Se

© 1997, 1998, 1999 GRIAULE

você atribuir menos, o tamanho lógico da string passa a ser menor que o tamanho físico. O Object Pascal usa um byte a mais para armazenar o tamanho lógico.

Você pode concatenar (juntar) duas ou mais strings com o operador +. Por exemplo:

var prefixo, linguagem, titulo: string; begin prefixo := 'Curso'; linguagem := 'Delphi'; titulo := prefixo + ' de ' + linguagem; { O resultado é uma string 'Curso de Delphi' }

Para obter caracteres individuais de uma string, você pode usar o nome da variável e mais um valor entre colchetes. Por exemplo, se você quiser guardar o 7º caractere do nome numa variável char, basta fazer:

c := nome[7];

Existem várias propriedades que também são do tipo String, como Caption e Text, por exemplo. Assim, é possível atribuir uma constante ou variável do tipo String para elas, por exemplo:

btnIniciar.Caption := '&Iniciar'; memoTempoTotal.Text := s;

Nota: existem várias funções de manipulação de strings, por exemplo, para obter uma parte de uma string. Consulte o help do Delphi e procure por 'String manipulation functions'.

O tipo Boolean

Várias propriedades (e variáveis também) podem conter os valores True (verdadeiro) e False (falso), indicando uma condição lógica ou um "flag" (ligado/desligado, habilitado/desabilitado, sim/não). Para isso utiliza-se o tipo Boolean, que só tem dois valores possíveis: True e False. Por exemplo:

tmrMarca.Enabled := False;

O Delphi também utiliza o tipo Boolean internamente, ao fazer qualquer comparação lógica, em um comando if, por exemplo. E uma variável do tipo Boolean sozinha já é uma condição lógica, portanto pode ser usada em um comando if diretamente, por exemplo:

var ValorCorreto: Boolean; begin

© 1997, 1998, 1999 GRIAULE

if ValorCorreto then

{ Enabled é uma propriedade do tipo Boolean } if tmrMarca.Enabled then

end;

O tipo TDateTime

Para trabalhar com datas em Delphi, você pode usar o tipo TDateTime. Veremos as operações de data mais em detalhe em Manipulação de datas.

© 1997, 1998, 1999 GRIAULE

Funções de Conversão

Qualquer variável numérica pode receber um valor do mesmo tipo ou de um outro tipo numérico, exceto que uma variável inteira (Integer, Longint, Word etc.) não pode receber um valor real, pois este pode conter uma parte fracionária. Por exemplo:

var

a: integer; b: longint; x: double; y: extended; begin

b

:= 10;

a

:= b; {ok: inteiro recebe inteiro}

x

:= a; {ok: real recebe inteiro}

y

:= x; {ok: real recebe real}

x

:= 3.7;

b

:= x; {errado: inteiro recebe real}

end;

Nesse caso é preciso usar uma função de conversão, que ou descarta a parte fracionária (função trunc) ou arredonda o valor (função round):

x := 3.7;

a := trunc(x); {a vai valer 3}

b := round(x); {b vai valer 4}

Existem várias funções que convertem valores de tipos numéricos para o tipo String e vice- versa. Nós já vimos algumas em programas-exemplo:

var

varReal: double; varInteira: integer; varString: string;

begin

{ de String para numérico: }

varReal := StrToFloat(varString);

varInteira := StrToInt(varString);

varInteira64 := StrToInt64(varInteira64);

{ de numérico para String: }

varString := FloatToStr(varReal);

varString := IntToStr(varInteira);

{VarInteira pode ser de

qualquer tipo inteiro,inclusive int64 }

© 1997, 1998, 1999 GRIAULE

end;

Além dessas, existe a função Str, do Pascal padrão, que converte um número qualquer para String, permitindo especificar uma largura de campo (o número é alinhado à direita com espaços) e a quantidade de casas depois da vírgula. Por exemplo:

segundos := 34.749; Str(segundos:7:2, s);

A variável 's' vai ser preenchida com uma string 'oo34.75' (cada o representa um espaço em branco). Ou seja, vai conter no mínimo 10 caracteres, com os dígitos alinhados à direita e duas casas depois da vírgula (casas a mais são arredondadas).

© 1997, 1998, 1999 GRIAULE

Operações Aritméticas

Os tipos de dados inteiros suportam as operações aritméticas usuais:

soma:

a := x + y;

subtração:

a := x - y;

multiplicação:

a := x * y;

divisão:

a := x / y;

Se os dois operandos são do mesmo tipo, o resultado é desse tipo. Se um deles tem uma faixa de valores maior (por exemplo, um Double e um Integer), o resultado será do tipo deste operando (no exemplo, Double).

Para os números inteiros o resultado será do tipo int64 somente se tiver uma variável deste tipo, caso contrário o resultado será do tipo integer.

Se os dois operandos são inteiros, o resultado será inteiro e pode ser atribuído para uma variável inteira. Uma exceção é que no caso da divisão, o resultado sempre é real, mesmo quando os dois operandos são inteiros. Portanto, não é permitido fazer:

a := b / c;

quando 'a' é uma variável inteira. Mas pode-se utilizar uma função de conversão, como trunc:

a := trunc( b /c );

ou usa-se o operador de divisão inteira div (os dois operandos dever ser inteiros), por exemplo:

b := 13;

c := 4;

a := b div c; {retorna a parte inteira da divisão = 3}

Existe também o operador mod, que calcula o resto da divisão:

x := b mod c; {retorna o resto de 13 div 4, que é = 1}

Expressões podem ser combinadas com vários operadores e operandos. Multiplicação e divisão são executadas primeiro, depois soma e subtração, a menos que sejam usados parênteses, por exemplo:

x := a + b * c; {multiplica 'b' e 'c' e soma com 'a'}

y := (a + b)*c; {soma 'a' e 'b' e multiplica por 'c'}

© 1997, 1998, 1999 GRIAULE

© 1997, 1998, 1999 GRIAULE

Tipos Ordinais

Um tipo de dados é considerado um tipo ordinal quando existe uma seqüência definida entre seus elementos, ou seja, a partir de um elemento é sempre possível passar para o próximo elemento do tipo. Os tipos ordinais predefinidos pela linguagem (veremos que você pode criar outros) são:

· Todos os tipos inteiros (Integer, Word, Cardinal, Longint,Enumerados

);

· O tipo Char (os caracteres são ordenados pela tabela ASCII/ANSI);

· O tipo Boolean (só tem dois elementos: False,True nessa ordem).

Notas: Os tipos reais não são considerados tipos ordinais.

Algumas operações podem ser feitas com qualquer tipo ordinal. A função succ retorna o próximo elemento do tipo, enquanto pred retorna o anterior:

var

c1, c2: char; x, y: integer; a, b: boolean; begin

c1 := 'G'; c2 := succ(c1); {vai ser = 'H'} c2 := pred(c1); {vai ser = 'F'}

x

:= 299;

y

:= succ(x); {succ(x) = x + 1 e pred(x) = x - 1}

a

:= False;

b

:= succ(a); {vai ser = True}

end;

Se você chamar succ para o último elemento da seqüência ou pred para o primeiro elemento, isso vai causar um erro de execução (por exemplo, 'succ(True)' não é permitido).

A função ord retorna a posição numérica do elemento dentro do tipo. No caso de um número inteiro, retorna o próprio número, portanto não tem utilidade prática. No caso de um caractere, retorna o código ASCII (ANSI) do caractere, que é sua posição na tabela ASCII (ANSI):

x := ord('G'); {x vai ser 71}

No caso do tipo Boolean, ord(False) = 0 e ord(True) = 1. Isso pode ser usado para converter uma condição lógica em valor numérico.

Mais tarde veremos outras operações que podem ser executadas em tipos ordinais.

© 1997, 1998, 1999 GRIAULE

Notas : As funções succ e pred podem ser utilizadas para variáveis do tipo int64, mas o mesmo não é válido para a função ord.

© 1997, 1998, 1999 GRIAULE

Escopo de Variáveis

O lugar onde é declarada uma variável determina o escopo de uma variável, ou seja, qual a região do programa onde a variável pode ser acessada e o tempo de vida da variável, ou seja, qual o intervalo de tempo durante o qual ela mantém seu valor. Qualquer variável só pode ser utilizada no programa depois do ponto onde foi declarada.

Variáveis Locais

Uma variável declarada dentro de um procedimento é uma variável local. Ela só pode ser utilizada dentro do procedimento (o escopo da variável é o corpo do procedimento).

O tempo de vida de uma variável local é o tempo durante a execução do procedimento. Quando a execução do procedimento é iniciada, a variável está indefinida, ou seja, seu valor pode ser qualquer dado que existia anteriormente na memória. Se esse valor for utilizado, os resultados são imprevisíveis. Depois que o procedimento termina, a memória ocupada pela variável é liberada, e seu valor anterior é perdido.

Como já vimos, variáveis locais são declaradas com a palavra var, logo após o cabeçalho do procedimento, mas antes do begin que inicia os comandos:

procedure btnCalculaClick(Sender: TObject); var op1, op2, res: double; begin

end;

Variáveis Globais da Unidade

Se uma variável precisa ser usada em vários procedimentos, mantendo o seu valor, é preciso declarar a variável como global, ou seja, fora de qualquer procedimento. O escopo dessa variável passa a ser desde o ponto onde foi declarada até o fim da unidade. Por exemplo:

implementation {$R *.DFM} var VariavelGlobal: integer;

Variáveis globais são inicializadas com valores padrão: zero para numéricas, False para booleans, '' (texto vazio) para strings, etc. Elas mantêm seus valores durante toda a execução do programa.

Ao declarar uma variável global, você pode fornecer um valor inicial diferente do padrão. Para isto, a variável deve ser declarada em separado de outras (não em uma lista) e depois

© 1997, 1998, 1999 GRIAULE

do tipo de dados, você deve colocar um "=" e o valor inicial, que deve ser constante. Por exemplo:

var

VariavelGlobal: integer = 1; Titulo: string = 'Título inicial'; AtivaTimer: boolean = true;

Variáveis Globais do Projeto

Uma variável global, se declarada na parte implementation, só pode ser acessada dentro daquela unidade. Se for declarada na parte interface, pode ser usada por outra unidade, desde que essa outra tenha uma cláusula uses para a unidade que contém a variável. Veremos mais sobre isso em Estrutura das Unidades.

© 1997, 1998, 1999 GRIAULE

Constantes

Constantes são valores que podem ser colocados em variáveis, usados em expressões etc. Uma constante literal é um valor sem nome, escrito explicitamente, como os seguintes:

20 3.5 (constantes numéricas - integer e double) 'Testando' (constante do tipo string) False True (constantes do tipo boolean) 'x' #8 (constantes do tipo char)

O tipo de dados de uma constante é determinado pela forma desta. Números sem parte fracionária são considerados constantes inteiras (isso se o número couber na faixa de valores de um tipo inteiro). Uma constante inteira também pode ser especificada como um valor hexadecimal, prefixado por '$', por exemplo:

x := $2F3;

Números hexadecimais contém também os dígitos A até F, além de 0 a 9.

Uma constante real também pode ser escrita em notação científica, especificando-se um valor e uma potência de 10:

y := 3.5e4; { = 3.5 x 10 4 = 35000 }

z := 2.78e-6; { = 2.78 x 10 -6 = 0.00000278 }

Você pode criar constante especificando o tipo que esta constante irá retornar , por exemplo:

const Inteiro64 = int64(17)

Desta forma o tipo que a constante irá retornar é int64.

Você também pode criar constantes nomeadas, que são simplesmente substituídas pelos valores correspondentes durante a compilação do programa. Elas facilitam a manutenção do programa, quando um valor é utilizado em vários lugares. Para isso, usa-se a declaração const:

const TAMANHO = 30; METADE = TAMANHO/2; PI = 3.1415926536; MENS_ERRO = 'Valor incorreto. Digite novamente.'; >

Constantes nomeadas são utilizadas como qualquer outra constante:

x := TAMANHO * 8;

© 1997, 1998, 1999 GRIAULE

angulo := PI*graus/180;

Mas não são variáveis, portanto não podem receber outro valor:

TAMANHO := 15; { erro de compilação }

Da mesma forma que variáveis, uma constante pode ser local (se declarada em um procedimento) ou global (se declarada fora).

© 1997, 1998, 1999 GRIAULE

Capítulo 5 Estruturas de Controle

Inserindo Comandos com o CodeInsight Estruturas de Decisão Estruturas de Laços Outros Comandos

© 1997, 1998, 1999 GRIAULE

Inserindo comandos com o CodeInsight

Para facilitar a digitação dos comandos da linguagem e reduzir os erros, o CodeInsight do Delphi possui um recurso chamado modelos de código [code templates], que permite inserir rapidamente um comando da linguagem contendo apenas a estrutura básica, que depois você pode preencher. Por exemplo, digite casee no editor de código e tecle [Ctrl+J]. O CodeInsight irá inserir um comando case com uma cláusula else e espaços em branco para você completar:

case of

: ;

: ;

else ;

end;

O cursor ficará posicionado entre case e of. Você pode completar com um nome de variável, valores constante e os comandos a serem executados.

Para ver uma lista completa dos modelos de código, tecle [Ctrl+J]. Veja por exemplo, os modelos ife, ifb, ifeb, ifs, forb, fore, whileb, whiles, caseb, cases. Note que os outros usam comandos do Object Pascal que ainda não foram vistos. ]

Nota: você pode alterar os modelos de código ou criar novos. Para isso clique em Tools|Environment Options e na página CodeInsight. Nesta mesma página, você pode também desmarcar a opção "Code Completion" se quiser. Essa opção mostra a lista de propriedades e métodos de um componente quando você digita o nome do componente e um ponto.

© 1997, 1998, 1999 GRIAULE

Estruturas de Decisão

O Comando if

then

else

Nós já vimos o comando if em várias situações. A sua sintaxe básica é:

if condição then comando1 else comando2; { OU sem o else: } if condição then comando1;

A identação de comandos, ou a separação do comando em várias linhas não são obrigatórias em nenhuma situação no Object Pascal. Mas geralmente um comando if é escrito em várias linhas, para maior legibilidade:

if condição then

comando1

else

comando2;

Dica: No editor de código, para identar um bloco de comandos (deslocar à direita), use [Ctrl+Shift+I]. Para deslocar à esquerda, use [Ctrl+Shift+U].

Nessa sintaxe, condição é qualquer expressão que gere um resultado do tipo Boolean (True para verdadeiro, False para falso), podendo ser uma única variável booleana, embora na maioria das vezes seja construída usando operadores de comparação, como '=', '>' etc.

Note que não é permitido o ';' (ponto-e-vírgula) logo depois do then ou logo antes ou depois do else. Só pode haver ';' depois do fim do comando if. Se não houver o else, o ';' é colocado depois do comando1. Por exemplo:

if memoEditor.SelLength <> 0 then menuEdiRecortar.Enabled := True else menuEdiRecortar.Enabled := False;

Quando, em lugar de comando1 ou comando2 é preciso executar vários comandos, usa-se os delimitadores begin e end para criar um comando composto. Um comando composto é tratado pelo Object Pascal como um único comando, por exemplo:

if condição then begin

comando1;

comando2;

end

else

© 1997, 1998, 1999 GRIAULE

begin

comando3;

comando4;

end;

Dentro do comando composto, os comandos são separados por ';', mas fora dele se aplicam as regras do if.

Um comando if pode ser usado dentro de outro, mas isso pode dificultar o entendimento se um deles inclui uma cláusula else. Nesse caso o else fica ligado ao if mais próximo.

Mais de uma condição pode ser usada no if, combinando-as com and (e), or (ou) e not (não). Mas nesse caso, são obrigatórios parênteses em volta das condições:

if (Key < '0') or (Key > '9') then Key := #0;

O operador and tem precedência sobre o or, e o not tem precedência sobre os dois,

portanto é preciso levar isso em conta em condições mais complexas, e utilizar parênteses

para especificar o que se deseja avaliar primeiro:

if ((Key < '0') or (Key > '9')) and (Key <> #8) then Key := #0;

E o operador not pode ser usado para inverter o resultado de uma condição:

if ((Key < '0') or (Key > '9')) and not (Key = #8) then Key := #0;

Dica: para encontrar um fecha-parênteses perdido, coloque o cursor antes do abre- parênteses e tecle [Ctrl+Q+[ ] (ctrl+Q+abre-colchetes).

O Comando case

of

Muitas vezes é preciso comparar uma variável com vários valores. Isso pode ser feito com vários comandos if aninhados:

if dia = 1 then desconto = 30 else if dia = 2 then desconto = 20 else if dia = 3 then desconto = 10;

Mas o mesmo pode ser feito com o comando case, especificando a variável, e seus valores

possíveis:

© 1997, 1998, 1999 GRIAULE

case dia of 1: desconto = 30; 2: desconto = 20; 3: desconto = 10; end;

A sintaxe geral desse comando é:

case expressão of rótulo1: comando1; rótulo2: comando2;

else comandoElse; end;

Onde expressão pode ser qualquer variável ou expressão que retorne um valor de um tipo ordinal. Cada rótulo pode ser uma constante sozinha, várias constantes separadas por vírgulas, ou uma faixa de valores. Por exemplo:

case dia of

1: nome := 'primeiro'; { constante } 2: nome := 'segundo';

10: 3

nome := 'terceiro'; { valores entre 3 e 10 }

11,13,15: nome := 'quarto'; { valores 11, 13 e 15 } end;

Cada comando na sintaxe pode ser um comando simples ou um comando composto formado pelos delimitadores begin e end.

A parte do else é opcional e indica um comando a ser executado se nenhum dos valores

corresponde ao valor da expressão.

© 1997, 1998, 1999 GRIAULE

Estruturas de Laços

Estruturas de laço permitem repetir um conjunto de comandos. Cada um dos comandos de laço especifica uma forma diferente de iniciar e testar o laço.

O comando for

O comando for permite repetir um laço um número especificado de vezes, incrementando

ou decrementando uma variável a cada passagem do laço. Você deve especificar o valor

inicial e final da variável. A forma de uso é a seguinte:

for variável := valor_inicial to valor_final do comando;

O comando, como antes, pode ser um comando simples, ou um comando composto. A

variável, o valor inicial e o valor final devem ser todos de um tipo ordinal. Se no início da execução o valor inicial é maior do que o final, o comando nem chega a ser executado.

O seguinte laço mostra os valores numéricos de 1 até 20 dentro de um componente

ListBox:

var valor: integer; s: string;

begin for valor := 1 to 20 do begin s := IntToStr(valor);

ListBox1.Items.Add(s);

end;

end;

A variável também pode ser do tipo Char, pois este é um tipo ordinal:

for letra := 'A' to 'Z' do

Para decrementar a variável durante o laço, ao invés de incrementar, usa-se downto no lugar da palavra to:

for letra := 'Z' downto 'A' do

for valor := 20 downto 1 do

Note que o incremento ou decremento é sempre 1.

© 1997, 1998, 1999 GRIAULE

O

comando while

do

O

laço while repete um comando enquanto determinada condição é verdadeira. Sua sintaxe

de forma geral é:

while condição do comando;

Por exemplo:

i := valorAnt;

while i < 1000 do begin Processar(i); i := i + incremento;

end;

Antes da primeira iteração do laço, a condição é verificada. Se ela for falsa, o comando não chega a ser executado. Se for verdadeira, o comando é executado, e a condição é verificada novamente e assim por diante.

O

comando repeat until

O

repeat

until

é semelhante ao while, mas testa a condição no final, depois de executar o

comando, e termina a execução se a condição for verdadeira (o contrário do while). Sua

sintaxe geral é:

repeat

comando1;

comando2;

until condição;

Por exemplo:

i := valorAnt;

repeat Processar(i); i := i + incremento; until i >= 1000;

O comando repeat sempre executa uma iteração do laço pelo menos. Note que ele não

precisa de begin e end para delimitar a lista de comandos, pois as próprias palavras repeat e until já formam delimitadores.

© 1997, 1998, 1999 GRIAULE

Outros Comandos

Comandos para sair de laços