PROGRAMAÇÃO EM DELPHI PARA INICIANTES

Módulo 1. Apresentando o Delphi. Componentes simples PROGRAMAÇÃO EM DELPHI PARA INICIANTES 1 MÓDULO 1 Sobre o autor...

Author: Yuriy Kalmykov

629 downloads 4334 Views 1MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Módulo 1. Apresentando o Delphi. Componentes simples

PROGRAMAÇÃO EM DELPHI PARA INICIANTES

1

MÓDULO 1

Sobre o autor Yuriy Kalmykov é um especialista renomado em desenvolvimento de software e autor de muitos manuais e publicações sobre programação, incluindo “Teaching Delphi Programming in Schools”. Esse livro é o resultado de 25 anos de orientação de estudantes como membro da faculdade Informatics and Control Processes da National Research Nuclear University MEPhI (Moscow Engineering Physics Institute) e lecionando nas principais escolas preparatórias em Moscou.

Introdução Esse livro foi feito para quem está iniciando no estudo de programação. Porém, isso não quer dizer que todos aqueles que já utilizam Delphi (ou outra linguagem de programação combinada com uma IDE RAD) não possam aproveitar da experiência de Yuri Kalmykov. O Delphi surgiu em 1995 para plataforma Windows e, desde então, se consolidou com uma linguagem dinâmica, moderna e atualizada. E quantas coisas mudaram desde 1995? No Brasil, por exemplo, só em 1995 começou a ser distribuído o acesso à internet. O acesso a computadores era bem restrito ainda, com pouquissimas pessoas possuindo computadores pessoais. Celulares eram um luxo e ainda nem existia a rede 3G (que só foi lançada, no Japão, em 2001). O Delphi acompanhou essa evolução, integrando a seus componentes tudo que foi surgindo ao longo dos anos. Hoje Delphi é utilizado em diversas aplicações de diversos segmentos, tanto no lado cliente como no lado servidor, em aplicações multicamadas e com compatibilidade para diversos bancos de dados. De aplicações médicas, aplicativos para celulares (em Delphi é possível, com um único código, criar aplicativos para Android, IOS e Windows!) passando por estúdios de áudio, modelagem de aplicações geológicas e, até mesmo pesquisa nuclear (afinal, essa é a área do autor do livro!), tudo pode ser desenvolvido em Delphi utilizando sua IDE RAD. A evolução tecnológica não para. Todos os dias surgem novidades, novas ideias e conceitos. O Delphi irá acompanhar essa evolução, sempre proporcionando uma forma simples e intuitiva de ser utilizada. Se você ainda não conhece Delphi, seja bem vindo. Temos certeza que a simplicidade, praticidade e atualidade estarão ao seu lado.


Conteúdo MÓDULO 1. MÓDULO 2. MÓDULO 3. MÓDULO 4. MÓDULO 5. MÓDULO 6. MÓDULO 7. MÓDULO 8. MÓDULO 9. MÓDULO 10. MÓDULO 11. MÓDULO 12. MÓDULO 13. MÓDULO 14. MÓDULO 15. MÓDULO 16. MÓDULO 17. MÓDULO 18. MÓDULO 19. MÓDULO 20. MÓDULO 21. MÓDULO 22. MÓDULO 23. MÓDULO 24. MÓDULO 25. MÓDULO 26.

2

Apresentando o Delphi. Componentes simples ............................... 3 Manipulando um evento de pressionamento de botão .............. 17 Variáveis e tipos de variáveis. Conversão de tipo .......................... 23 Funções matemáticas padrão .............................................................. 30 Expressões lógicas, Variáveis do tipo Boolean e Operações lógicas ......................................................................................................... 33 Execução condicional no programa. Instrução IF…THEN…ELSE37 Instrução If…Then…Else aninhada. Praticando resolução de tarefas.......................................................................................................... 42 Procedimentos.......................................................................................... 45 Funções ....................................................................................................... 52 Gráficos ....................................................................................................... 56 Loops ........................................................................................................... 60 Strings ......................................................................................................... 65 Strings e conversão para e de tipos numéricos.............................. 71 Controle TMemo ...................................................................................... 75 Controle TMemo (continuação) .......................................................... 80 Números, constantes, tipos criados pelo usuário e matrizes aleatórias .................................................................................................... 85 Matriz estática unidimensional............................................................ 89 Classificação da matriz e classificação da seleção ......................... 95 Controle StringGrid ................................................................................. 99 Prática StringGrid................................................................................... 104 Matrizes bidirecionais........................................................................... 111 Data e hora .............................................................................................. 118 Timer .......................................................................................................... 123 Arquivos de texto .................................................................................. 129 Caixas de diálogo de arquivo padrão ..............................................145 Aplicações com Banco de Dados ......................................................151

MÓDULO 1 Módulo 1

Apresentando o Delphi. Componentes simples O desenvolvimento de computadores desktop pessoais levaram a introdução de sistemas operacionais multitarefa e multiusuário como o Microsoft Windows. No entanto, como resultado, o processo de criação de software se tornou muito mais complicado. Os ambientes de desenvolvimento integrado (IDE) visuais e os sistemas de desenvolvimento de aplicativo rápido (RAD) foram criados por líderes de mercado para facilitar a interação com sistemas operacionais, reduzir o tempo de codificação e melhorar a qualidade do código. A programação visual é um processo de criação de aplicativos de software em que um usuário pode projetar, editar, depurar e testar automaticamente o aplicativo usando o IDE visual. Em outras palavras, a programação visual é uma combinação de dois processos interconectados: criação de uma janela de aplicativo visualmente e escrita do código. O Delphi, um poderoso compilador Pascal com várias melhorias significativas para a criação de aplicativos Windows, foi disponibilizado pela primeira vez em 1996. Ele é um sistema de desenvolvimento de software de alto nível com um conjunto de ferramentas integrado para desenvolver aplicativos completos, é uma ferramenta para o desenvolvimento rápido de aplicativos. Os conceitos de programação baseada em eventos e design visual são os pilares da ideologia do Delphi. O uso desses conceitos melhora significativamente os processos de design de aplicativo e reduz bastante o tempo de desenvolvimento. O design visual permite que os usuários projetem o aplicativo e vejam os resultados do processo antes mesmo de iniciar o programa de fato. Há outros benefícios também: para atribuir um valor de propriedade a um controle ou elemento do aplicativo, não é necessário escrever várias linhas de código. É necessário apenas alterar esse valor em uma janela Properties. Essa alteração gerará ou atualizará o código automaticamente.

3


Executando o Delphi

O ambiente de desenvolvimento integrado Delphi é um sistema de várias janelas configurado, definindo os elementos da interface do usuário. Para qualquer ação do programador na janela, o Delphi faz alterações automaticamente no código do programa subjacente. A janela principal do Delphi tem um MainMenu e ToolBar. MainMenu

ToolBar

MainMenu contém tudo o que é necessário para gerenciar o projeto. ToolBar contém botões para o acesso rápido às opções mais populares do MainMenu. 4


Por exemplo, para executar um programa, podemos escolher a opção Run no MainMenu Run suspenso, pressionar a tecla F9 ou clicar em um triângulo verde na ToolBar. Para começar a escrever um novo programa, é necessário selecionar o item New no menu File e, na lista aberta, escolher VLC Forms Application — Delphi.

5


O seguinte layout de janelas do Delphi aparecerá: Visualização Structure

Object Inspector

Designer de Form

Tool Palette

Vamos analisar as janelas. O Delphi é uma linguagem de programação orientada a objeto. Um objeto é uma entidade autocontida que possui propriedades (características ou sinais distintivos) e um conjunto de ações ou comportamentos. O objeto criado pode ser movido de um programa ou outro. O Delphi inclui centenas de objetos prontos para uso (componentes), que são apresentadas na Tool Palette. Esses componentes são agrupados em guias.

6


As principais guias da Tool Palette são: 1.

Standard

2.

Additional

3.

System

4.

Data Access

5.

Data Cоntrols

6.

Dialogs

Por enquanto, trabalharemos com a guia Standard na Tool Palette. Ela contém elementos de interface padrão que a maioria não pode ficar sem.

7


A janela Form é um projeto para o futuro aplicativo. A programação visual permite que você crie programas manipulando componentes e colocando-os em um form. Quando você executa o Delphi pela primeira vez, ele automaticamente sugere um novo projeto com a janela Form chamada Form1. Esse form contém todos os elementos de janela básicos: o título Form1, os botões minimizar, fechar e maximizar e um botão de menu do sistema de janela. Essa é a janela principal do nosso programa. Adicionaremos itens gráficos a partir da Tool Palette aqui. As caixas de texto, botões de comando e outros controles de Form são chamados de componentes (componentes de Form) no Delphi. No programa, o form e os componentes são considerados objetos. Portanto, a janela com as propriedades dos componentes é chamada Object Inspector. A janela Object Inspector tem duas guias. Na primeira guia, você pode ver todas as propriedades disponíveis do componente selecionado. A coluna da esquerda tem uma lista e a coluna da direita contém os valores padrão atuais. A segunda guia, Events, tem possíveis manipuladores de evento para o componente selecionado. As colunas da esquerda contêm nomes, a da direita tem as propriedades ou os procedimentos relevantes. A visualização Structure mostra todos os objetos (componentes) colocados no form.

8


Parar a execução do aplicativo • Clique no botão para fechar • Menu Run — comando Program Reset (Ctrl+F2)

Salvar o projeto Qualquer programa Delphi inclui uma grande quantidade de diversos arquivos como o arquivo do projeto, uma ou várias unidades etc. O arquivo do projeto é gerado automaticamente pelo ambiente Delphi e não está disponível para edição manual. É por essa razão que ele tem uma única extensão (*.dpr) e ela não é exibida no Code Editor. O projeto deve ser salvo usando o comando Save All. Cada projeto deve ser salvo em uma pasta separada. A pasta e os arquivos do projeto devem ser nomeados adequadamente. Você não deve aceitar os nomes padrão. Os nomes de arquivo podem conter somente caracteres latinos. Os numerais podem ser usados em nomes de arquivo começando no segundo caractere. Outros símbolos são inválidos para a nomeação do arquivo. Você deve atribuir nomes únicos aos arquivos Project1.dpr e Unit1.pas (eles são diferentes). Aos outros arquivos serão atribuídos nomes padrão. Ao renomear os arquivos Project1.dpr e Unit1.pas, siga o padrão de código do Delphi, de acordo com o qual todos os arquivos devem ter um prefixo XXX, por exemplo: prjMyTask1.dpr e untMyTask1.pas (ХХХ são as letras correspondentes ao nome abreviado do que você está salvando: Project1 — prj e Unit1 — unt). Essa regra também se aplica ao renomear componentes simples. Isso nos leva a alguns dos componentes simples disponíveis no ambiente Delphi. Esses componentes são considerados simples não apenas porque é mais fácil de usá-los em comparação com outros componentes. Eles são chamados assim porque, durante a criação da interface gráfica do usuário, eles normalmente são usados em combinações bastante complexas com outros componentes. Vamos analisar os seguintes componentes simples: form, rótulo, caixa de texto e botão.

9


Form De todos esses componentes, o form é o único objeto que não está na Tool Palette. Um form é gerado automaticamente ao criar um novo aplicativo. Se você precisar usar vários forms em um aplicativo, pode adicionar mais forms ao projeto. Aprenderemos a fazer isso posteriormente. Ao trabalhar no Delphi, imagine que você é um artista e que o form é sua tela. Você “pinta” a interface gráfica do usuário do aplicativo colocando os componentes no form. Em seguida, alterando as propriedades dos componentes, você altera sua aparência. Depois disso, você trabalhará na interação do componente com o usuário. Interação do usuário significa que os componentes do form reagem às ações do usuário. As propriedades dos componentes são suas características. O nome, a legenda, o tamanho ou a cor do componente e o tamanho ou a cor do rótulo do componente são exemplos de propriedades. Vamos revisar algumas propriedades do objeto Form. Muitas propriedades de diferentes componentes são iguais, mas o Form tem algumas propriedades únicas. A primeira propriedade que examinaremos é a propriedade Name. Todos os componentes devem ter essa propriedade, pois o nome é necessário para chamar o componente no programa. Para o nome, use o prefixo de trigrama descrevendo o tipo de componente. Para o Form, por exemplo, usaremos o prefixo frm (nome mais curto de Form). Se quisermos chamar o Form de My, devemos atribuir o valor frmMy à propriedade Name.

10


Vamos examinar três componentes simples da guia Standard da Tool Palette.

TLabel O componente TLabel é usado para emitir o texto que pode ser alterado pelo usuário (certamente, ele também pode ser alterado por um programa). Vejamos como trabalhar com TLabels em um exemplo concreto. Realize as seguintes etapas: 1.

Crie um novo projeto.

2. Coloque o TLabel no form. Para fazer isso, você precisa clicar duas vezes no ícone TLabel na Tool Palette. Outra maneira de colocar o TLabel no form é clicar uma vez no ícone TLabel e clicar em qualquer lugar no form. Isso é mais conveniente porque o TLabel é colocado onde você deseja. Para excluir o TLabel do form, você precisa selecioná-lo (clique nele com o botão do mouse, pequenos quadrados pretos mostram que ele está selecionado) e pressionar a tecla . Para cancelar a seleção do TLabel, você precisa clicar com o botão do mouse em algum lugar fora do TLabel. Experimente com a colocação e a remoção de TLabels.

11


3. Mova o TLabel arrastando e soltando. Para fazer isso, mova o ponteiro até o TLabel e pressione e segure o botão do mouse para “pegar” o TLabel. “Arraste” o TLabel até o local desejado movendo o ponteiro para o novo local. “Solte” o objeto soltando o botão. 4. Altere a propriedade Name do TLabel para lblMyLabel (por padrão, ele chamava Label1). Clique na propriedade Name no Object Inspector e digite lblMyLabel. Certifique-se de alterar a propriedade TLabel, não a propriedade Form (esse é um erro comum de iniciantes). Para este fim, o TLabel precisa ser selecionado. O título da lista na parte superior do Object Inspector dirá Label1 TLabel (assim que você alterar o nome, isso será alterado para lblMyLabel TLabel). Após digitar o novo nome, salve-o pressionando a tecla <Enter>. 5. Verifique se a legenda do TLabel foi alterada para IblMyLabel. Isso acontece porque, por padrão, a legenda do TLabel é seu nome. Altere a legenda. Para fazer isso, selecione a propriedade Caption no Object Inspector, digite a nova legenda “It’s my first label!” e pressione a tecla <Enter>. O novo texto aparecerá em um form. 6. Altere a cor do plano de fundo do TLabel. Selecione a propriedade Color, clique na seta, selecione yellow na lista suspensa e clique nele. 7. Altere a fonte e a cor do texto do TLabel. Selecione a propriedade Font e clique nos três pontos (reticências). Na janela Font, altere a fonte para Arial, o estilo para Bold Italic e o tamanho para 20. Selecione red na lista suspensa e clique no botão OK. 8. Adicione mais um TLabel ao form. Tente utilizar outra maneira dessa vez: clique no ícone TLabel na Tool Palette, mova o ponteiro até qualquer lugar no form e clique novamente. Um novo TLabel deve aparecer. 9. Altere a propriedade Name do novo TLabel para lblAnother e a propriedade Caption para “Another label”. 10. Agora selecione o form. Você pode fazer isso de duas maneiras: clicar em qualquer lugar fora dos rótulos ou selecionar Form1 na visualização Structure. Se o form estiver visível, a primeira maneira é mais conveniente, claro, mas se houver muitos forms no projeto e o form que você precisa estiver coberto por outros, a segunda maneira é melhor. 11. Altere as propriedades do form: configure o valor da propriedade Name como frmLabelExample e o valor da propriedade Caption para “Example of Label”. 12


12. Você acaba de criar um aplicativo simples, que, para dizer a verdade, ainda não faz nada. Execute-o. Você pode fazer isso usando uma das três maneiras: clicar no ícone Run (o triângulo verde), selecionar o comando Run no menu Run ou pressionar a tecla . 13. Clique no botão X no canto superior direito do form para sair do aplicativo.

TEdit O componente TEdit armazena o texto que pode ser colocado no componente durante a criação do aplicativo e durante a execução. O texto visto na caixa de texto vem da propriedade Text. A propriedade MaxLength define o número máximo de símbolos na caixa de texto. O valor MaxLength 0 significa que não há limite para o número de caracteres. A fonte do texto é configurada usando a propriedade Font. Se você definir o valor da propriedade Readonly como True, o usuário não poderá alterar o texto de TEdit. O passo-a-passo a seguir ajudará você a obter um melhor controle da funcionalidade TEdit. 1.


2. Coloque o TEdit no form. Exatamente como o TLabel, você pode fazer isso de duas maneiras: clicando duas vezes no ícone TEdit na Tool Palette ou clicando no ícone TEdit e, em seguida, em qualquer lugar no form. 3. Altere o tamanho do TEdit. Coloque o ponteiro do mouse em um dos pequenos quadrados pretos, pressione e segure o botão esquerdo do mouse e arraste o pequeno quadrado preto (e a borda do TEdit com ele) na direção necessária. Quando estiver no tamanho necessário, solte o botão. Se não houver nenhum pequeno quadrado preto em torno do TEdit, o TEdit não está selecionado. Nesse caso, selecione TEdit clicando nele primeiro. 4. Mova o TEdit para outro lugar usando o recurso de arrastar e soltar. Coloque o ponteiro do mouse no TEdit, pressione e segure o botão esquerdo do mouse e arraste o TEdit para o novo local. Quando TEdit chegar ao local necessário, solte o botão do mouse. 5. Atribua o valor edtMyText à propriedade Name. Clique na propriedade Name no Object Inspector e digite edtMyText. Como para TLabel, certifique-se de alterar a propriedade TEdit, não o form. Na visualização Structure, você verá Edit1: TEdit (assim que você alterar o nome edtMyText: TEdit aparecerá).

13


6. Selecione a propriedade Text no Object Inspector e insira seu novo valor: “This is a text edit control”. Registre o novo nome pressionando a tecla <Enter>. Observe que conforme você insere o texto no Object Inspector, o texto TEdit no form também é alterado. 7. Altere a cor do texto de TEdit para azul. Clique no sinal de + ao lado da propriedade Font. Uma lista de propriedades Font adicionais aparecerá. Selecione a propriedade Color e clique na seta: a lista de cores disponíveis aparecerá. Encontre a cor azul e clique nela. 8. Selecione o form. Você pode fazer isso de uma das duas maneiras: clicar em qualquer lugar no form não coberto pela caixa de texto ou selecionar um nome de form na visualização Structure. Altere a propriedade Name para frmEditBoxExample e a propriedade Caption para “Text Box Example”. 9. Pressione a tecla para executar o novo aplicativo. Experimente com a caixa de texto digitando qualquer texto nela. 10. Para sair do aplicativo, clique no botão X no canto superior direito do form. 11. Defina a propriedade Readonly como True. 12. Pressione a tecla F9 para executar o aplicativo novamente. Tente alterar o texto: como você pode ver, agora é impossível. Você pode imaginar porque precisaria de uma caixa de texto em que não é possível inserir nada. No entanto, posteriormente no manual, você verá que ela é uma ferramenta bastante útil porque você pode alterar um valor da propriedade Readonly programaticamente, permitindo ou não que o usuário insira os dados. 13. Clique no botão X para sair do aplicativo.

TButton O TButton normalmente é usado para iniciar a execução de alguma parte do código ou todo o programa. Em outras palavras, ao clicar no controle TButton o usuário solicita que o programa execute uma determinada ação. Nesse momento, o botão muda para parecer como se estivesse pressionado. Você pode atribuir combinações de teclas de atalho aos botões. Durante a execução, pressionar essas teclas de atalho é equivalente a usar o botão esquerdo do mouse no botão.

14


Execute um conjunto de ações: 1.


2. No Object Inspector, altere a propriedade Name do form para frmButtonExample e Caption para “Button Example”. 3. Coloque o botão no form. Clique duas vezes no ícone TButton na Tool Palette ou clique em seu ícone e clique em qualquer lugar no form. Altere a propriedade TButton para btnMyButton. Clique na propriedade Name no Object Inspector e digite btnMyButton. Certifique-se de alterar a propriedade TButton, não o form. Na visualização Structure, você verá Button1: TButton (assim que você alterar o nome btnMyButton: TButton aparecerá). 4. Altere a propriedade Caption para &Run. Observe que a letra após & está sublinhada (nesse caso é R). 5.

Altere o tamanho e o local do botão.

6.

Pressione a tecla para executar o aplicativo.

7.

Clique no botão. O botão aparece pressionado.

8. Ative o botão pressionando a tecla . Como você pode ver, o botão não parece pressionado ao usar a tecla de atalho para ativá-lo. Enquanto isso, como não há nenhum código do programa conectado ao botão, não vemos nenhuma reação ao botão. No entanto, você pode acreditar que ele está ativado. 9. Clique no botão X no canto superior direito do form para sair do aplicativo. A legenda btnMyButton aparece como Run, não Run. Colocar o símbolo & antes de qualquer caractere da propriedade Caption atribui uma tecla de atalho ao botão. Na legenda do botão, o caractere após & está sublinhado. Isso diz que há uma tecla de atalho conectada ao botão. Os usuários podem ativar o botão pelo teclado pressionando Alt e a tecla com a letra sublinhada. O que fazer se a própria legenda precisar ter &? Depois de tudo, se você colocá-lo na legenda, ele sublinhará a próxima letra e não será visível. Para resolver esse problema, use a seguinte regra: O símbolo & será visto na legenda se a propriedade Caption tiver dois & juntos, isto é, &&. Por exemplo, para criar a legenda This & That, escreva This && That na propriedade Caption. As combinações de teclas de atalho não são atribuídas nessa situação.

15


Como você pode ver, no Delphi é possível criar um form (e um aplicativo) simples rapidamente. As interfaces gráficas do usuário mais complicadas podem ser criadas da mesma forma.

Agora você está familiarizado com as propriedades dos componentes mais populares do Delphi: forms, rótulos, caixas de edição e botões. Para aprimorar seu novo conhecimento, experimente com esses componentes. Tente alterar suas propriedades.

16

MÓDULO 2 Módulo 2

Manipulando um evento de pressionamento de botão Os componentes visuais podem gerar e manipular diversos tipos de eventos: clique do mouse, pressionamento de botão, pressionamento do teclado, abertura de janelas etc. Quando o usuário pressiona qualquer botão do mouse, o Windows envia uma mensagem “This mouse button was clicked” para o aplicativo. Esse programa responderá a esse evento se um programador tiver programado uma reação para ele. A resposta para um evento é o resultado de um evento de sistema ocorrendo. Uma resposta do programa a um evento é programada como uma lista de ações a serem realizadas. Essa lista é inserida na janela Code Editor. Para um programa reagir a um clique de botão do mouse, é necessário escrever um fragmento de programa chamado manipulador de eventos.

Janela Code Editor Essa janela tem o título Unit1 no início. Você pode abrir vários arquivos de código-fonte na janela do editor. Todos os arquivos abertos ocupam suas próprias guias e os rótulos de suas guias exibirão os nomes dos seus arquivos de código-fonte. Haverá três unidades se o programa tiver três janelas. Todas as três unidades serão exibidas no Code Editor fonte. Eventos simples contêm apenas fonte de eventos, apontadas pelo parâmetro Sender no procedimento de manipulador de eventos. Os procedimentos de manipulador de eventos para manipular eventos complexos precisam de parâmetros adicionais, como as coordenadas do ponteiro do mouse. A seleção de um elemento de controle gera um evento OnClick, também chamado de evento de pressionamento. Normalmente ele é originado do clique do mouse em um componente. O evento OnClick é um dos eventos 17

Módulo 2. Manipulando um evento de pressionamento de botão

usados com mais frequência no desenvolvimento de um aplicativo. Para alguns componentes, o evento OnClick pode ser originado de diferentes ações no elemento de controle. Como um exemplo, reescreveremos o manipulador do evento de pressionamento do botão de comando btnMy, colocado no form frmMy: Clique duas vezes nesse botão. O Delphi gera o código automaticamente para minimizar a entrada do teclado, fornecendo o corpo completo do procedimento de pressionamento do botão do mouse. procedure TfrmMy.btnMyClick(Sender: TObject); begin end; O cursor estará localizado entre as palavras-chave inicial e final. Aqui escreveremos uma instrução para fechar programaticamente a janela do form, um análogo completo do botão do sistema no título da janela. Como essa janela é a principal e a única no aplicativo, todo o programa será encerrado. Digite frmMy e adicione um ponto (‘.’). Após alguns momentos, o Delphi mostra as opções de conclusão do código. Essas opções são os métodos e propriedades disponíveis para o componente frmMy.

Podemos encontrar a propriedade ou método adequado navegando na lista. Como a lista é relativamente grande, podemos acelerar a pesquisa inserindo alguns caracteres do nome e o número de elementos na lista diminuirá consideravelmente.

18


Finalizamos a entrada da conclusão do código pressionando Enter. O código final para a resposta ao pressionamento de botão do comando btnMy tem a aparência semelhante a seguinte: procedure TfrmMy.btnMyClick(Sender: TObject); begin frmMy.Close; end; O programa será fechado se você pressionar o botão do comando de pressionamento btnMy após o programa ser executado. Neste exemplo, usamos o método (procedimento) Close. Chamar um método mostra o que será feito com o componente. Você pode ver uma sintaxe de referência do método no exemplo: o nome do componente vem primeiro, em seguida, há um delimitador (ponto) e, por fim, o nome do método especificado após o delimitador. <nome_do_componente>.<método>; Todos os componentes têm seu próprio conjunto de métodos. Às vezes, é possível encontrar métodos idênticos em diferentes componentes. Vamos demonstrar mais um método, Clear. Esse método limpa o conteúdo e pode ser aplicado, por exemplo, ao componente Edit. Edit1.Clear

19


Como mencionamos acima, os componentes têm métodos e propriedades. Propriedades são atributos de componentes. As propriedades podem ser alteradas ou especificadas da seguinte forma: primeiro, referenciamos o nome do componente, em seguida, colocamos o delimitador (ponto) e, após o delimitador, especificamos o nome da propriedade (o Delphi nos permite escolher em uma lista de conclusão do código). Depois, colocamos o operador da atribuição, por fim, especificamos o valor da propriedade. <nome_do_componente>.<propriedade>:=; A maioria das propriedades de componente corresponde às exibidas na janela Object Inspector. Também há propriedades que não são refletidas ali, vamos examiná-las posteriormente. Por enquanto, vamos escrever um programa em que o pressionamento do botão do comando preencherá a janela do form com um plano de fundo branco. Nesse programa, precisamos usar a propriedade Color. procedure TfrmMy.btnMyClick(Sender: TObject); begin frmMy.Сolor:=clWhite; end; Podemos não apenas especificar propriedades do componente, mas lê-las também. Um uso dessa capacidade é atribuir um valor de propriedade de um componente a alguma propriedade de outro componente. A sintaxe é semelhante a essa: <nome_do_componente1>.<propriedade1>:=<nome_do_ componente2>.<propriedade2>; Por exemplo: lblMy.Caption:=edtMy.Text; Isso instrui o programa a colocar o texto da caixa de texto edtMy na legenda do rótulo lblMy. Várias ações são separadas por ponto e vírgula. Por exemplo:

20


procedure TfrmMy.btnMyClick(Sender: TObject); begin edit1.Clear; edit1.Color:=clBlue; end; Duas ações serão executadas após o botão ser pressionado: a caixa de texto será limpa e seu plano de fundo será preenchido com azul.

21


Exercícios Exercício 1. Crie um form que contém um rótulo e dois botões. O primeiro botão habilita o rótulo e o segundo desabilita. Exercício 2. Crie um form que contém um rótulo, uma caixa de texto e um botão. Um pressionamento de botão move o texto da caixa de texto para o rótulo e limpa a entrada da caixa de texto. Exercício 3. “Semáforo”: Crie um form que contém três rótulos e três botões. Cada botão deve habilitar um rótulo apropriado e desabilitar os outros rótulos. Exercício 4. Crie um form que contém um rótulo e quatro grupos de botões. Cada grupo contém três botões. O primeiro grupo (três botões) altera a cor do plano de fundo do rótulo. O segundo grupo (três botões) altera a cor da fonte do rótulo. O terceiro grupo (três botões) altera o tamanho da fonte do rótulo. E o grupo de botões final (três botões) muda o nome da família da fonte do rótulo.

22

MÓDULO 3 Módulo 3

Variáveis e tipos de variáveis. Conversão de tipo Para calcular um valor para uma expressão única com certas entradas, e fazer isso apenas uma vez, não é necessário escrever um programa de software completo. No entanto, se o processo dos cálculos precisar ser realizado frequentemente e com diferentes entradas a cada vez, faz sentido automatizar esse processo.

Operador de atribuição Se você deseja converter graus (DEGR) para radianos (RAD), a fórmula de conversão terá a seguinte aparência no Delphi: RAD:= (DEGR ∗ 3.14) / 180; O operador de atribuição é uma instrução muito básica e importante em qualquer linguagem de programação. Ele atribui um valor de uma expressão calculada à direita do símbolo de atribuição := a uma variável à esquerda do símbolo de atribuição. O símbolo de atribuição é composto por dois símbolos separados (: e =), no entanto, eles são interpretados como um único elemento no Delphi. A maneira como funciona internamente é que o valor da expressão à direita do operador de atribuição é calculado primeiro e o valor resultante é atribuído à variável à esquerda do operador de atribuição. O formato do operador de atribuição é o seguinte: <nome da variável>:= <expressão>; Agora, vamos falar sobre as variáveis. Uma variável é um local na memória que tem um nome. O tamanho da memória alocada para uma variável depende do valor a ser escrito nela. Em teoria, seria possível alocar somente grandes “slots” de memória para todas as variáveis. No entanto, se esse fosse o caso, ficaríamos sem memória disponível rapidamente. 23

Módulo 3. Variáveis e tipos de variáveis. Conversão de tipo

Para saber exatamente a quantidade de memória a ser alocada para uma variável, precisamos conhecer seu tipo de dados. Você pode usar variáveis no Delphi para diversas tarefas e motivos. As variáveis precisam ser definidas antes de poderem ser usadas. A palavra-chave var é usada para iniciar uma seção de definições da variável, que está localizado após a definição do procedimento e antes da palavra-chave begin. A seguir está o formato da definição da variável: Var <nome da variável>: ; O nome de uma variável é uma sequência de caracteres com a seguinte sintaxe:

• Pode conter letras, números (0 a 9) ou sublinhado; • Deve começar com uma letra. O nome da variável pode ter qualquer comprimento (o número de caracteres não é limitado) e não diferencia maiúsculas de minúsculas. Ao pensar sobre a nomenclatura de uma variável, observe que você deve evitar nomes de um caractere, exceto para variáveis de contador de loop ou temporárias. As variáveis de contador de loop são os nomes I e J. Outras instâncias de nomes de variáveis de um caractere são S (string) ou R (raio). Os nomes de variáveis de um caractere sempre devem estar em letra maiúscula, mas é sempre preferível usar nomes mais significativos. É recomendável que você não use a letra I como um nome de variável para evitar confusão com o número 1 (um). Exemplo: procedure TfrmMy.btnMyClick(Sender: TObject); Var k: Integer; begin end;

24


Neste exemplo, uma variável k do tipo Integer é declarada. Há muitos tipos de dados no Delphi. Vamos analisar alguns deles. Os inteiros podem ser descritos com os seguintes tipos de dados: Tipo de dados

Intervalo

Representação

Integer

–2.147.483.648 a 2.147.483.647

32 bits, com sinal

Cardinal

0 a 4.294.967.295

32 bits, inteiros positivos

ShortInt

–128 a 127

8 bits, com sinal

SmallInt

–32.768 a 32.767

16 bits, com sinal

LongInt

–2.147.483.648 a 2.147.483.647

32 bits, com sinal

Int64

–263 a 263–1

64 bits, com sinal

Byte

0 a 255

8 bits, sem sinal

Word

0 a 65535

16 bits, sem sinal

LongWord

0 a 4.294.967.295

32 bits, sem sinal

Usaremos principalmente Integer ao longo desse manual. Números reais também podem ser representados por vários tipos de dados. Usaremos o tipo de dados Real. Tipo de dados

Intervalo

Dígitos significativos (precisão)

Bytes

Real48

±2,9 х 10–39 a ±1,7 x 1038

11 a 12

6

Real

±5,0 х 10

15 a 16

8

Single

±1,5 x 10

7a8

4

Double

±5,0 x 10

15 a 16

8

Extended

±3,6 x 10-4951 a ±1,1 x 104932

19 a 20

10

Comp

–263 a 263 –1

19 a 20

8

Currency

–922337203685477,5808 a +922337203685477,5807

19 a 20

8

-324 -45

a ±1,7 x 10

308

a ±3,4 x 10

-324

38

a ±1,7 x 10

308

Você conhece a notação científica normalizada (também conhecida como notação exponencial) para representação de números reais. Por exemplo: 3,28•1017

1,4•10–9

-5,101•104

25


No Delphi, esses números são registrados como: 3.28e+17 328e15 0.328e+18

1.4e-09 0.14e-8 140e-11

-5.101e+4 -5101e+1 -510100e-1

Expressões aritméticas Vamos analisar os operadores de atribuição novamente. O tipo de dados à esquerda deve corresponder ao tipo de dados do valor da expressão aritmética à direita. Uma expressão aritmética é uma expressão matemática legal composta usando constantes, variáveis, funções, operadores aritméticos (como +, *, —, /, exponente e parênteses ( e )) . Operadores usados em expressões aritméticas: Operador

+

-

*

Nome do operador

Adição

Subtração

Multiplicação

Tipos de dados dos operandos

Tipo de dados do resultado

Pelo menos um dos operandos é real

Real

Integer

Integer


Real

Integer

Integer


Real

Integer

Integer

/

Divisão

Real, Integer

Real

Div

Divisão de integer

Integer

Integer

Mod

Resto da divisão de integer

Integer

Integer

26


Exemplos: 13 div 4 = 3 –13 div 4 = –3 13 div –4 = –3 –13 div –4 = 3 0 div 2 = 0 2 div 5 = 0

13 mod 4 = 1 –13 mod 4 = –1 13 mod –4 = 1 –13 mod –4 = –1 1 mod 2 = 1 2 mod 5 = 2

Se o valor da expressão for Integer, ele poderá ser atribuído à variável do tipo de dados Real, mas não vice-versa.

Adicionando dois números Crie o form frmСalc com duas caixas de testo TEdit edtA e edtB, um botão btnAdd e o rótulo lblResult. Defina a propriedade Caption do botão e deixe as propriedades Text das caixas de texto em branco. Clique duas vezes no botão, a janela de código será aberta e poderemos começar a codificar um manipulador de evento de clique do botão. Primeiro, declararemos as variáveis: Var a, b, c: Single; Obteremos os valores a e b das caixas de texto edtA e edtB respectivamente. Observe que inserimos valores de string nas caixas de texto, portanto precisamos convertê-los para o tipo de dados numérico. Usaremos a função StrToFloat (string) para esse fim. Begin a:=StrToFloat(edtA.Text); //coloque o número A b:=StrToFloat(edtB.Text); //coloque o numero B c:=a+b; //faça a adição de A e B lblResult.Visible:=true; //Deixe o label que receberá a resposta visível lblResult.Caption:=FloatToStr(c); //Insira o valor da resposta no label (convertendo para o tipo string antes) end; 27


O resultado da adição de duas variáveis é armazenado em uma terceira variável (c) e esse resultado é convertido novamente em uma string usando FloatToStr (number) e exibido no rótulo lblResult. Para deixar o código ainda mais bonito, vamos escrevê-lo da seguinte forma: lblAnswer.Caption:=edtA.Text+’+’ +edtB.Text+’=’+FloatToStr(c); Ao trabalhar com StrToFloat e FloatToStr no Delphi, é importante se atentar à formatação adequada do separador decimal. No programa (Unidade), somente ponto (“.”) é permitido como separador decimal. No entanto, nas janelas de entrada e saída no form, o separador decimal depende das configurações regionais do Windows. Por exemplo, em muitos países europeus, a vírgula é usada para separar as partes inteiras e fracionárias de um número decimal. As funções IntToStr(integer) e StrToInt(string) são usadas para converter inteiros em strings e strings em inteiros respectivamente.

28


Exercícios Exercício 1. Usando duas caixas de texto, um rótulo e quatro botões, crie uma calculadora para quatro operações aritméticas básicas. Exercício 2. Escreva um programa para converter Fahrenheit em Celsius e vice-versa. (Tf=9/5*Tc+32). Exercício 3. Escreva um programa para converter velocidades de quilômetros por hora em metros por segundo e vice-versa.

29

MÓDULO 4 Módulo 4

Funções matemáticas padrão Em expressões, é possível usar funções matemáticas padrão com operadores e operações padrão. Você deve se atentar ao argumento e tipos de resultado para obter os resultados corretos. Funções padrão na linguagem Delphi Função

Computação

Parâmetros de entrada

Tipo de resultado

Exemplos

ABS(X)

Retorna o valor absoluto de um número.

X — valor REAL ou INTEGER

Igual ao tipo de parâmetro

ABS(2.0) = 2.0000e+00;

SQR(X)

Retorna o quadrado de um número.


Igual ao tipo de parâmetro

SQR(3) = 9; SQR(–2.0)= 4.0000e+00;

SQRT(X)

Retorna a raiz quadrada de um número.


REAL

SQRT(16) =4.0000e+00; SQRT(25.0)=5.0000e+00;

EXР(X)

Retorna a exponenciação de um número.


REAL

EXР(0)=1.00000e+00; EXР(–1.0)=3.67879e-01;

LN(X)

Retorna o logaritmo natural de um número.


REAL

LN(1) = 0.00000e+00 LN(7.5) = 2.01490e+00

SIN(X)

Retorna o seno do X — valor REAL parâmetro. ou INTEGER, em radianos

REAL

SIN(0)=0.00000e+00; SIN(1.0)=8.41471e-01

COS(X)

Retorna o cosseno X — valor REAL do parâmetro. ou INTEGER, em radianos

REAL

COS(0)=1.00000e+00; COS(1.0)=8.41471e-01

ARCTAN(X)

Retorna o arco tangente do parâmetro.

REAL

ARCTAN(0)=0.0000e+00 ARCTAN(–1.0)= –7.8539e-01


30

Módulo 4. Funções matemáticas padrão Função

Computação

ROUND(X)

Arredonda um valor real para o valor inteiro mais próximo (por valor absoluto).

Parâmetros de entrada X — REAL

Tipo de resultado INTEGER

Exemplos ROUND(3.1) = 3; ROUND(–3.1)= –3; ROUND(3.8) = 4; ROUND(–3.8)= –4; Observação: números com partes fracionárias iguais a 0,5 são arredondados para o número par mais próximo. ROUND(3.5) = 4; ROUND(2.5) = 2;

TRUNC(X)

Retorna a parte inteira do parâmetro eliminando sua parte fracionária.

X — REAL

INTEGER

TRUNC(3.1) = 3; TRUNC(–3.1)= –3; ТRUNC(3.8) = 3;

INT(X)

Retorna a parte inteira do parâmetro eliminando sua parte fracionária.

X — REAL

REAL

INT(3.1) = 3.00000E+00 INT(–3.1) = –3.00000E+00 INT(3.8) = 3.00000E+00

31

Módulo 4. Funções matemáticas padrão

Exercícios Exercício 1. Dado um número real, mostre suas partes inteiras e fracionárias separadamente. Exercício 2. Supondo que a Terra é uma esfera ideal com o raio R=6350 km, escreva um programa para calcular a distância para a linha do horizonte do ponto de uma determinada altura a partir da superfície da Terra. Exercício 3. Calcule e exiba a soma e o produto de três números inseridos usando o teclado. Exercício 4. O triângulo é especificado pelas coordenadas de seus vértices. Calcule e exiba o perímetro e a área do triângulo. Exercício 5. Calcule a altura da árvore dada a distância até a árvore e seu ângulo de visão. O resultado deve ser exibido da seguinte forma: A altura da árvore é igual a 2 m e 87 cm

32

MÓDULO 5 Módulo 5

Expressões lógicas, Variáveis do tipo Boolean e Operações lógicas O lado direito da instrução de atribuição pode não ser apenas uma expressão aritmética, mas uma expressão de outro tipo, por exemplo, uma expressão lógica. Uma expressão lógica (Boolean) é uma expressão que resulta em um valor de TRUE ou FALSE. O nome Boolean foi escolhido em homenagem ao matemático inglês George Boole que estabeleceu os fundamentos da lógica matemática. Os termos Boolean e lógico normalmente são usados como sinônimos. O valor de uma expressão lógica pode ser atribuído a uma variável Boolean. Exemplo de variável lógica: Var Exist: Boolean; As expressões lógicas podem incluir: expressões aritméticas, operadores relacionais e operadores lógicos.

Operadores relacionais Os operadores relacionais são usados para comparar dois valores. O resultado da comparação tem o valor TRUE ou FALSE. = < >=

33

— — — — — —

igual a diferente de menor que menor ou igual a maior que maior ou igual a

Módulo 5. Expressões lógicas, Variáveis do tipo Boolean e Operações lógicas

Exemplo: Var X: Real; Exist, Ok: Boolean; begin X:= 2.5; Ok:= X > 0; Exist:= X = 3–27; end. Como resultado dessa execução do programa, a variável Ok armazena o valor TRUE e a variável Exist armazena FALSE.

Operadores lógicos Os operadores lógicos são usados com valores lógicos e eles também retornam um valor lógico. Vamos examinar os seguintes operadores lógicos: NOT AND OR Operações lógicas e valores X False

Y False

Not X True

X And Y False

X Or Y False

False

True

True

False

True

True

False

False

False

True

True

True

False

True

True

O valor da expressão é calculado em uma certa ordem.

34

Módulo 5. Expressões lógicas, Variáveis do tipo Boolean e Operações lógicas

Tabela de precedência de operadores Tipo de expressão

Operador

Avaliação em parênteses

()

Avaliação de função

funções

Operadores unários

not, unary ‘-’

Operadores como multiplicação

* / div mod and

Operadores como adição

+ — or

Operadores relacionais

= < > =

Os operadores com a mesma precedência são avaliados da esquerda para a direita de acordo com sua ordem na expressão. Como exemplo, vamos examinar a ordem dos operadores e encontrar o valor da próxima instrução: (a ∗ 2 > b) or not (c = 7) and (d – 1 4) or not (6 = 7) and (4 – 1 4) or not (6 = 7) and (3 –4) and (x Then Else ; A ordem da execução de If…Then…Else: Primeiro, a expressão lógica é avaliada, Se a expressão lógica for avaliada como True, a instrução 1 será executada, Caso contrário (a expressão lógica for avaliada como False), a instrução 2 será executada.

Exemplo 1. Dados dois números inteiros, calcule o valor máximo deles.

Solução: procedure TfrmMy.btnMaxClick(Sender: TObject); var a, b, m: integer; begin a:=StrToInt(edtA.Text); b:=StrToInt(edtB.Text); if a>b then m:=a else m:=b; lblMax.Caption:=IntToStr(m) end;

38

Módulo 6. Execução condicional no programa. Instrução IF…THEN…ELSE

Deve-se observar que a instrução If…Then…Else não precisa de um ponto e vírgula antes da palavra-chave Else, porque ela é uma instrução complexa única e não pode haver Else sem If. Você pode usar instruções compostas quando a linguagem Delphi permite apenas uma única ação, mas é necessário executar várias ações. Uma instrução composta consiste em várias instruções delimitadas nos colchetes do operador begin…end. Por exemplo, se for necessário executar mais de uma única instrução nas ramificações Then ou Else, essas instruções são delimitadas nos colchetes do operador begin…end: … If (x < 0) Then begin y:= 1; k:= k + 1; end Else begin y:= 2 * x; k:= x; end;

instrução composta

instrução composta

39


Às vezes as opções são diferentes:

Essa estrutura é representada pela instrução If…Then mais curta.

Sintaxe: If <expressão lógica> Then ; A versão curta da instrução condicional é executada exatamente como a versão longa. Se a expressão lógica for avaliada como True, a instrução 1 será executada. Caso contrário, nenhuma instrução é executada durante a execução da instrução If…Then.

40


Exercícios Exercício 1. Dois inteiros m e n são inseridos pelo usuário. Se n for divisível por m, o resultado da divisão de m por n deverá ser exibido. Caso contrário, o programa deve exibir a mensagem “n cannot be divided by m”. Exercício 2. Dado um inteiro de três dígitos, decida se ele é um palíndromo, isto é, se ele é lido da esquerda para a direita e da direita para a esquerda. Exercício 3. Encontre o máximo e o mínimo de três números reais diferentes. Exercício 4. Uma casa contém n aposentos numerados sequencialmente, começando com o número a. Descubra se a soma de todos os cômodos é par ou não.

41

MÓDULO 7 Módulo 7

Instrução If…Then…Else aninhada. Praticando resolução de tarefas As instruções após Then e Else também podem ser instruções condicionais. Nesse caso, a instrução If…Then…Else é chamada de uma instrução aninhada. Por exemplo: If <expressão lógica 1> Then Else If <expressão lógica 2> Then Else ; Cada uma das instruções (instrução 1, instrução 2, instrução 3) pode ser composta, isto é, em Then ou Else é possível colocar mais de uma instrução, colocando-os entre colchetes em um bloco begin… end.

42

Módulo 7. Instrução If…Then…Else aninhada. Praticando resolução de tarefas

Por exemplo: If <expressão lógica 1> Then begin If <expressão lógica 2> Then begin end Else ; end Else If <expressão lógica 3> Then Else begin ; ; end; Vamos examinar o próximo fragmento de código: If <expressão lógica 1> Then If <expressão lógica 2> Then Else ; Pode parecer ambíguo, uma vez que não é claro a qual Then Else pertence (ao primeiro Then ou ao segundo Then). Há uma regra em que o Else pertence ao If mais próximo. Para evitar confusão e possíveis erros, é desejável colocar If… Then… Else aninhada no bloco begin… end. 43

Módulo 7. Instrução If…Then…Else aninhada. Praticando resolução de tarefas

Exercícios Exercício 1. Encontre a raiz quadrada da equação quadrática Ax2+Bx+C=0 (A≠0). Se a equação não tiver raízes válidas, mostre a mensagem correspondente. Exercício 2. Descubra se um determinado ano é um ano bissexto. Um ano é um ano bissexto se ele for divisível por 4, mas entre os anos que também são divisíveis por 100, os anos bissextos são apenas os que são divisíveis por 400. Por exemplo, 1700, 1800 e 1900 não são anos bissextos, mas 2000 é bissexto. Exercício 3. Os números reais X, Y (X≠Y) são indicados. Substitua o número menor por sua média aritmética e substitua o número maior com o produto triplo. Exercício 4. O inteiro k (1 =0 then //Se a discriminante >= 0, então begin calc(A, B, D, X1, X2); //compute as raizes x1, x2 de //A, B e Δ prn(X1, X2); //mostre as raízes x1 e x2 end else //senão lblNo.Visible:=true; //Notifique o usuário da falta //de solução end; No corpo do procedimento, vemos os nomes das ações que o programa precisa executar para resolver a tarefa. Essas ações são chamadas de procedimentos, os valores dentro dos parênteses são chamados de parâmetros de procedimento. Quando o Delphi encontra o nome de uma ação que não é uma palavrachave ou uma instrução, ele assume que é a chamada de procedimento. Ele então transfere o controle para o procedimento com um certo nome (em nosso caso, os nomes são coefInput, calc e prn). Após executar as instruções do procedimento, a execução retorna à rotina de chamada e o programa executa a próxima instrução após a chamada de procedimento.

47

Módulo 8. Procedimentos

Sintaxe da chamada de procedimento: <nome do procedimento> (<lista de parâmetros de chamada>); Os procedimentos devem ser definidos na seção Implementation antes de se referir a eles na chamada. Você deve escrever o procedimento antes de chamá-lo.

Sintaxe da definição do procedimento: procedure <nome do procedimento> (<lista de parâmetros formais>); <declarações> begin end; Como vemos, a chamada de procedimento usa os parâmetros de chamada e a definição de procedimento usa parâmetros formais. A lista de parâmetros formais especifica tipos para todos os parâmetros. Há uma correspondência de um para um entre os parâmetros de chamada e parâmetros formais. O número, a ordem e os tipos de chamada e os parâmetros formais devem ser idênticos. Vamos definir nossos procedimentos, começando com o procedimento prn. Nesse procedimento, os parâmetros formais Xf e Xs correspondem aos parâmetros de chamada X1 e X2. Os parâmetros formais Xf e Xs são parâmetros de valor, eles são transmitidos do autor da chamada para Prn e não são retornadas para o autor da chamada. Procedure Prn(Xf, Xs: real); begin frmQuadEq.lblX1.Visible:=true; frmQuadEq.lblX1.Caption:=’x1=’+FloatToStr(xf); frmQuadEq.lblX2.Visible:=true; frmQuadEq.lblX2.Caption:=’x2=’+FloatToStr(xs); end;

48


Aqui tornamos os rótulos com os valores de raiz visíveis e colocamos as respostas lá. Receberíamos um erro se escrevêssemos lblX1.Visible:=true. Nos procedimentos definidos pelo usuário, precisamos escrever o nome completo do componente (especificando a qual form ele pertence, porque pode haver vários forms no programa, em geral). Vamos escrever um procedimento para inserir coeficientes. Precisamos obter os coeficientes das caixas de texto e colocá-las nas variáveis correspondentes. Para os valores de variáveis serem retornados do procedimento para o programa principal, precisamos usar parâmetros de variável. Os parâmetros de variável não apenas transmitem dados para procedimentos, eles também colocam dados nas variáveis do programa principal. Para definir parâmetros como variáveis, precisamos usar a palavrachave var antes delas. Os parâmetros de chamada devem ter variáveis para os parâmetros de variável do procedimento: Procedure coefInput(var k1, k2, k3: real); begin k1:=StrToFloat(frmQuadEq.edtA.Text); k2:=StrToFloat(frmQuadEq.edtB.Text); k3:=StrToFloat(frmQuadEq.edtC.Text); end; Os parâmetros de variáveis formais k1, k2 e k3 correspondem aos parâmetros de chamada a, b e c. Observe o uso da função StrToFloat. Precisamos usá-la porque a propriedade Text de uma caixa de texto é do tipo string e nossas variáveis são do tipo Real. Precisamos converter os tipos usando essa função e o uso da função também permite a conclusão do código para reconhecer adequadamente sua intenção. Vamos definir o procedimento final, como calcular as raízes das equações. Precisamos retornar valores de raiz, portanto os parâmetros formais Xf e Xs serão parâmetros de variável. Não precisamos retornar o primeiro e o segundo coeficientes e valores discriminantes. Eles serão transmitidos como parâmetros de valor. procedure Calc(k1, k2, dis: real; var Xf, Xs: Real); begin Xf:=(–k2+Sqrt(dis))/(2*k1); Xs:=(–k2-Sqrt(dis))/(2*k1); end; 49


Após executarmos o programa e inserirmos os coeficientes, veremos um ou outro conjunto de rótulos no form. Alguns rótulos permanecerão visíveis se inserirmos outro conjunto de coeficientes para gerar outro conjunto de rótulos. Para melhorar o comportamento do programa, definiremos outro procedimento que colocará tudo em um estado inicial limpo. Esse será o procedimento sem parâmetros que chamaremos de Init: procedure Init; begin frmQuadEq.lblX1.Visible:=false; frmQuadEq.lblX2.Visible:=false; frmQuadEq.lblNo.Visible:=false; end;

50


Exercícios Exercício 1. Crie um programa que troque os valores entre as variáveis A e B e troca os valores das variáveis C e D. Defina um procedimento que troque os valores de duas variáveis. Exercício 2. Dados os comprimentos dos lados de dois triângulos, encontre a soma de seus perímetros e seus quadrados. Defina um procedimento para calcular o perímetro e a área de um triângulo se você souber os comprimentos de seus lados. Exercício 3. Encontre o quadrado de um anel com o raio interno R1 e o raio externo R2. Defina e use esse procedimento para calcular a área de um círculo. Exercício 4. Encontre uma área do quadrilátero convexo especificado pelas coordenadas de vértices.

51

MÓDULO 9 Módulo 9

Funções Agora, vamos examinar as funções. Funções são iguais aos procedimentos, exceto que elas retornam um valor além de executar instruções. O Delphi tem muitas funções integradas, mas há muitas situações em que é necessário escrever suas próprias funções. Por exemplo, precisamos resolver uma tarefa usando a função de tangente Tg(A) várias vezes, mas não existe essa função integrada. A seguir está um exemplo simples: Há um triângulo retângulo. O ângulo (em graus) e o comprimento do lado adjacente são indicados. Calcule o outro lado. Clique duas vezes no botão para entrar no editor de código: procedure TfrmCatheti.btnRunClick(Sender: TObject); var a, b.alfa: real; begin alfa:=StrToFloat(edtAlfa.Text); //Set angle alfa a:=StrToFloat(edtAlfa.Text); //Set adjacent leg a b:=a*tg(alfa); //Calculate another leg b lblB.Caption:= FloatToStr(b); //Output b end; Precisávamos apenas descrever nossa função. As funções são descritas na seção Implementation. Quando você declara uma função, especifica seu nome, número e o tipo de parâmetros necessários e o tipo de seu valor de retorno.

52

Módulo 9. Funções

Formato da declaração da função: Function <nome da função> (<lista de parâmetros >): ; <declarações locais> begin end; As funções têm parâmetros de valor e parâmetros de variável. Os parâmetros são governados pelas mesmas regras que se aplicam aos parâmetros do procedimento. As funções devem ter pelo menos um operador de atribuição, que atribui um valor ao nome da função. Function tg(x: real): real; var y: real; Begin y:= x / 180 * pi; tg:= sin(y) / cos(y); End; Aqui usamos uma variável adicional chamada de variável local, ela é declarada dentro da função.

53


Exercícios Exercício 1. Calcule o valor da expressão:

usando a função y

= Exercício 2. Calcule o valor da expressão

usando a

função Exercício 3. Dadas as coordenadas de três vértices de um triângulo, calcule seu perímetro. Exercício 4. O usuário inserirá as variáveis a, b, c. Calcule o valor da expressão , em que as funções min(a, b, c) e max(a, b, c) retornam, respectivamente, o mínimo e o máximo de três números. Exercício 5. Calcule o valor da expressão, em que

54


Exercício 6. As coordenadas dos pontos A, B e C, situados no plano, são inseridas pelo teclado. Descubra se é possível construir um triângulo não degenerado nesses pontos. Se for possível, calcule os comprimentos de seus lados, alturas, área, perímetro e ângulos em graus. Emita os resultados na tela, tendo especificado quais ângulos, lados e alturas foram calculados. Por exemplo, lado AB=…, ângulo BCA=… e assim por diante. Ao escrever o programa, defina funções para calcular o comprimento dos lados, tamanhos de ângulos e alturas. Se o triângulo não puder ser criado, emita a mensagem correspondente.

55

MÓDULO 10 Módulo 10

Gráficos O Delphi tem uma ampla gama de recursos gráficos. Discutiremos alguns deles neste capítulo. Os desenhos serão colocados no objeto TPaintBox. Selecione a guia Additional na paleta de componentes. No menu de ícone dessa guia, selecione TPaintBox. Como um pintor estica a tela sobre a moldura, esticamos nossos componentes no form. Nossa mídia de pintura é a propriedade Canvas do componente. A origem é no canto superior esquerdo do objeto, o X aponta horizontalmente para a direita e o eixo Y aponta verticalmente para a parte inferior. As dimensões da imagem podem ser visualizadas no balão ao lado do cursor do mouse quando ele está sobre o objeto ou elas podem ser consultadas programaticamente pelas propriedades Width e Height do objeto. Podemos alterar o nome do objeto para pbxEx e calcular o centro do componente TPaintBox: x0:= pbxEx.Width div 2; y0:= pbxEx.Height div 2; A imagem Canvas é criada usando várias ferramentas de desenho. Podemos desenhar usando uma caneta, preencher os desenhos com pincéis e exibir o texto usando fontes. Para alterar a cor e a largura das linhas de qualquer figura, usamos o objeto Pen: pbxEx.Canvas.Pen.Color:=clRed; pbxEx.Canvas.Pen.Width:=3; As linhas de figuras serão desenhadas usando vermelho e uma largura um pouco maior do que a largura de linha padrão. O objeto Brush é usado para preencher o espaço interno de figuras fechadas.

56

Módulo 10. Gráficos

pbxEx.Canvas.Brush.Color:=clGreen; A cor do pincel será verde a partir de agora. Um exemplo simples de como definir a cor do pincel para branco e preencher toda a Canvas com a cor branca: pbxEx.Canvas.Brush.Color:= clwhite; pbxEx.Canvas.FillRect(ClientRect; Os estilos de linha e preenchimento podem ser definidos na propriedade Style. Deixaremos para o leitor descobrir os detalhes de trabalhar com o estilo sozinho. Vamos examinar os primitivos gráficos padrão que podem ser colocados na Canvas.

Ponto Para definir um ponto (X, Y) para uma cor específica, usamos a propriedade Pixels[X, Y]: pbxEx.Canvas.Pixels[x, y]:=clRed; Em outras palavras, somente um pixel nos cordões X e Y é configurado para uma cor específica, vermelho aqui.

Linha As linhas podem ser desenhadas com o método LineTo: pbxEx.Canvas.LineTo(X, Y) Uma linha será desenhada da posição atual da caneta para até as coordenadas específicas. O cursor será movido para as coordenadas especificadas.

57


A caneta pode ser movida até o ponto (X, Y) sem nenhum desenho usando o método MoveTo: pbxEx.Canvas.MoveTo(X, Y) Todas as outras figuras não movem a caneta.

Retângulo Para desenhar um retângulo, podemos usar o método Rectangle: pbxEx.Canvas.Rectangle(X1, Y1, X2, Y2 Essa chamada desenhará um retângulo com lados alinhados ao eixo e uma diagonal de (X1, Y1) a (X2, Y2). Os estilos de linha e o pincel de preenchimento atuais serão usados. Por padrão, a cor da linha é preta e a cor de preenchimento é branca.

Elipse Uma elipse é especificada pelo retângulo de circunscrição. Os eixos de elipse são paralelos aos eixos X e Y. Como com o retângulo, a elipse é desenhada preenchida. pbxEx.Canvas.Ellipse(X1, Y1, X2, Y2)

58


Exercícios Exercício 1. Desenhe um boneco de neve. Exercício 2. Desenhe uma casa. Exercício 3. Pense sobre sua própria imagem e desenhe-a em Canvas. Use diferentes primitivos, linhas, larguras de linha e cores de preenchimento.

59


Loops

O Loop é uma sequência de instruções executada repetidamente. Há dois tipos de loop com um loop de precondição (loop While…do…) e um loop de pós-condição (loop Repeat…Until…) O loop de precondição While…do… no Delphi tem o seguinte formato. While <expressão lógica> do ; O loop While…do executará repetidamente a mesma instrução se a expressão condicional for True. Uma expressão condicional normalmente é alterada dentro do loop e é calculada antes da execução da instrução. Se o valor da expressão for False desde o início, a instrução não será executada. Se você precisar executar várias instruções, é necessário usar begin… end após do: While <expressão lógica> do begin ; ; ; end;

60

Fluxograma de While…do

Módulo 11. Loops

O loop de pós-condição Repeat…Until… tem o formato: Repeat ; ; ... ; Until <expressão lógica> Nesse tipo de loop, as instruções do corpo do loop (a parte do programa entre Repeat e Until) são executadas primeiro. Em seguida, a expressão lógica é avaliada: se for False, a execução das instruções será repetida, caso contrário (se a expressão lógica for True), o loop será encerrado. Portanto, em Repeat…Until o corpo do loop sempre é executado pelo menos uma vez e a expressão lógica é a condição da conclusão do loop. Se o número de execuções do loop do corpo for conhecido, você pode usar o loop com um contador For.

Fluxograma de Repeat… Until

Formato: For := To do ; or For := DownTo do ; Em que:

61

Módulo 11. Loops

: variável do tipo Integer, aceitando um valor com inicial a final com um passo de +1 no caso de To e -1 no caso de DownTo. O valor do contador do loop muda automaticamente : qualquer expressão Integer, o valor inicial do contador do loop : qualquer expressão Integer, o valor final do contador do loop : a instrução é executada até o contador do loop não ser maior que (no caso de To) ou menor que (no caso de DownTo) o valor final. Se você precisar executar várias instruções, é necessário usar um bloco begin…end após do. Os valores inicial e final são calculados somente uma vez na entrada do loop. O loop FOR também é um loop de pré-condição.

62

Módulo 11. Loops

Exercícios Exercício 1. Desenhe N linhas horizontais à mesma distância umas das outras. O número N é definido através da caixa de texto. Exercício 2. Desenhe N quadrados com o lado S localizado horizontalmente à mesma distância uns dos outros. Os números N e S são definidos usando caixas de texto. Exercício 3. Desenhe o campo quadriculado composto por N linhas e M colunas. Os números N e M são definidos usando caixas de texto. Exercício 4. Desenhe o tabuleiro de xadrez composto por N linhas e M colunas. Os números N e M são definidos usando caixas de texto. Exercício 5. Desenhe N círculos concêntricos. O raio do menor círculo é r e o raio do maior círculo é R. Os números N, r e R são definidos usando caixas de texto. Exercício 6. Desenhe o círculo composto por N pontos de raio R com as coordenadas definidas do centro Xc, Yc. Todos os parâmetros são inseridos em caixas de texto. As coordenadas de um ponto no círculo são definidas da seguinte maneira: X = Xc + R cos(α)

Y = Yc — R sen α

O ângulo α muda de 0 até 2π com o passo de 2π/n.

63

Módulo 11. Loops

Exercício 7. Dados três números representando os comprimentos dos segmentos, descubra se é possível criar um triângulo com esses segmentos. Se a resposta for sim, crie o triângulo, se for não, forneça uma mensagem de erro adequada. Exercício 8. Desenhe N quadrados aninhados, tendo definido um procedimento para desenhar os quadrados a partir das linhas. Exercício 9. Desenhe um relógio analógico simplificado. O horário é inserido em uma caixa de texto. Quando um botão é pressionado, os ponteiros mostram o horário.

64


Strings Já temos um pouco de experiência com strings no Delphi. Por exemplo, as propriedades como Caption ou Text podem ter apenas valores de string. O que são strings exatamente e como você trabalha com elas? Uma string é uma sequência de símbolos dentro de aspas simples. Para declarar uma variável de string, é necessário usar o tipo String: Var s: String; Essa definição significa que o programa pode usar uma variável de string com um comprimento ilimitado. As strings podem ser concatenadas. A concatenação de strings é denotada pelo sinal de mais. Por exemplo: Var s, st: String; Begin s:=’We learn’; //We put “We learn” into first variable st:=’ Delphi; //We put “ Delphi” into second variable s:=s+st; //Concatenate these two strings. End; Quando o programa for executado, obteremos a string “We learn Delphi” na variável S. As strings podem ser comparadas.

65

Módulo 12. Strings

A comparação é realizada símbolo por símbolo usando a relação de comparação de símbolos (comparando sua representação interna). Os caracteres latinos têm ordenação alfabética e dígitos têm uma ordenação natural em que 0 ‘АBCD’

Vários procedimentos e funções padrão funcionam com strings. A tabela a seguir os resume. Procedimentos e funções de string padrão Procedimentos de string Nome e parâmetros

Tipos de parâmetro

Semântica

Delete(St, Pos, N)

St: string; Pos, N: integer;

Excluir os símbolos N a partir da string St, começando na posição Pos.

Insert(St1, St2, Pos)

St1, St2: string; Pos: integer;

Insira símbolos da string St1 na string St2 a partir da posição Pos.

Funções de string Nome e parâmetros

Tipos de parâmetro

Semântica

Copy(St, Poz, N)

Tipo de resultado: string; St: string; Pos, N: integer;

O resultado é a cópia de N símbolos da string St a partir da posição Pos.

Length(St)

Tipo de resultado: integer; St: string;

Calcula o comprimento (contagem de símbolo) da string St.

Pos(St1, St2)

Tipo de resultado: integer; St1, St2: string;

Procura a primeira ocorrência da substring St1 na string St. O resultado é a posição do primeiro símbolo da substring. Se a substring não foi encontrada, retorna 0.

66

Módulo 12. Strings

Exemplos: Procedimento Delete: Valor de St ‘abcdef’ ‘Turbo-Pascal’

Instrução Delete(St,4,2) Delete(St,1,6)

Valor de St após a execução da instrução ‘abcf’ ‘Pascal’

Procedimento Insert: Valor de St1

Valor de St2

Instrução

‘Turbo’ ‘-Pascal’

‘-Pascal’ ‘Turbo’

Insert(St1, St2,1) Insert(St1, St2,6)

Valor de St2 após a execução da instrução ‘Turbo-Pascal’ ‘Turbo-Pascal’

Função Copy: Valor de St ‘abcdefg’ ‘abcdefg’

Instrução Str:=Copy(St,2,3); Str:=Copy(St,4,4);

Valor de Str após a execução da instrução ‘bcd’ ‘defg’

Função Length: Valor de St ‘abcdefg’ ‘Turbo-Pascal’

Instrução N:=Length(St); N:=Length(St);

Valor de N após a execução da instrução 7 12

Função Pos: Valor de St2 ‘abcdef’ ‘abcdef’

Instrução Valor de N após a execução da instrução N:=Pos(‘de’, St2); 4 N:=Pos(‘r’, St2); 0

Exemplo estendido: A entrada do procedimento é uma string que contém duas palavras delimitadas por um único símbolo de espaço.

67

Módulo 12. Strings

Esse procedimento deve alterar a ordem das palavras. Observação. O símbolo ‘‫ ’ں‬significa espaço. Ele é usado para legibilidade. Procedure Change(var s: String); var s1: string; begin s1:= copy(s,1, pos(‘‫’ں‬, s)-1); // copie a primeira palavra em s (palavra é qualquer // coisa antes de um espaço) delete(s,1, pos(‘‫’ں‬, s)); // delete a primeira palavra (s continuará a conter // a segunda palavra) s:=s+’ ‘+s1; // adicione um espaço e a primeira palavra ao final // de s end;

68

Módulo 12. Strings

Exercícios Exercício 1. Escreva um programa que, após pressionar um botão, troca a segunda e a terceira palavras do texto na caixa do texto. O conteúdo da caixa de texto deve conter exatamente três palavras, separadas por um espaço. Exercício 2. Quando o botão for pressionado, troque todos os espaços em uma caixa de texto por pontos de exclamação. Exercício 3. Conte o número de períodos na string da caixa de texto. Exercício 4. Conte o número de ocorrências da string “abc” no conteúdo da caixa de texto. Exercício 5. Uma string com um parêntese de abertura e um de fechamento é inserido em uma caixa de texto. Emita uma string entre esses parâmetros em uma caixa de texto diferente. Exercício 6. Conte o número de palavras separadas por um espaço em uma string inserida em uma caixa de texto. Exercício 7. Substitua todas as ocorrências da palavra “dog” pela palavra “cat” na caixa de texto.

69

Módulo 12. Strings

Exercício 8. Reverta uma string em uma caixa de texto. Exercício 9. Conte o número de palavras separadas por espaço na caixa de texto. Troque a segunda palavra e a próxima a última.

70


Strings e conversão para e de tipos numéricos O procedimento Val(st, X, code) transforma a string st em um valor inteiro ou real armazenado na variável X. O tipo resultante depende do tipo de X. O parâmetro de variável Code indica o sucesso ou erro. Após o cálculo, se a transformação tiver sido bem-sucedida, a variável Code contém zero e o resultado é colocado em X. Caso contrário, ele contém o índice da posição de um símbolo errado na string st e o valor de X permanece inalterado. A string st pode conter espaços à esquerda ou à direita. Para valores reais, as partes inteiras e fracionárias são delimitadas por um ponto. Exemplo: Para verificar a exatidão de uma entrada de dados numéricos pelo teclado e sua transformação nas variáveis X e Y, usaremos o procedimento Val. As variáveis cx e y será definido como zero, se as strings sx e sy contêm representações de números válidas. Caso contrário, elas terão valores diferentes de zero. Val (sx, x, cx); Val (sy, y, cy); If (cx=0) and (cy=0) Then begin end Еlse begin end

71

Módulo 13. Strings e conversão para e de tipos numéricos

O procedimento Str(X [: Width [: Decimal]], st) transforma o número inteiro ou real X em uma string st. Os parâmetros Width e Decimal controlam a transformação. O parâmetro Width define o comprimento completo da representação de string resultante de X. O parâmetro Decimal define o número de símbolos para a parte fracionária do número e é aplicável apenas aos valores reais. Exemplo: var x: integer; y: real; s: string; begin y:=3.5; Str(y, s); ... .; ... . end; A variável s conterá 3.500000000000000Е+0000. No entanto, se aplicarmos uma transformação como essa str(y:6:2, s);, o resultado será ‫ںں‬3.50. Os símbolos à esquerda (zero) ausentes da parte inteira são substituídos por espaços (denotada pelo sinal ‫)ں‬. Outro exemplo é: Str(12345.6:5:2, s). Nesse caso, a parte inteira é emitida completamente porque a restrição não pode ser satisfeita. O resultado é 12345.6. Um outro exemplo é: Str(12.3456:5:2, s). Nesse caso, a parte fracionária será arredondada para o número especificado de casas decimais. O resultado é 12.35.

72


Exercícios Exercício 1. Uma caixa de texto contém uma string. Exclua todos os dígitos da string e mostre o resultado em um rótulo separado. Exercício 2. Uma caixa de texto contém uma string. Calcule a soma de todos os dígitos na string. Exercício 3. Uma caixa de texto contém uma string com palavras e números, que são separados por um único espaço. Calcule a soma de todos os números. Exercício 4. Uma caixa de texto contém uma string na forma de number1+number2=. Coloque a soma de number1 e number2 após a string igual. Exemplo: Input string: 12.35+7.123= Resulting string: 12.35+7.123=19.473 Exercício 5. Uma caixa de texto contém uma string com um parêntese de abertura e um de saída. Há vários dígitos entre os parênteses. Calcule a média dos dígitos. Substitua os dígitos dentro dos parênteses pelo resultado calculado.

73


Exercício 6. Duas caixas de texto contêm strings na forma de Nome espaço Número, em que Número é a altura de um homem em centímetros. Emita o nome do homem mais alto. Se as alturas forem iguais, emita os dois nomes. Exercício 7. Uma caixa de texto contém um número. Emita esse número em binário. Exercício 8. Uma caixa de texto contém um número. Emita esse número em hexadecimal.

74


Controle TMemo TMemo é uma caixa de edição que gerencia várias linhas de texto. É possível criar o conteúdo de TMemo dinamicamente usando suas propriedades e métodos. As propriedades Font e Readonly de TMemo são iguais às propriedades de TEdit. A propriedade de texto tem todo o texto de TMemo, mas essa propriedade está disponível apenas quando o aplicativo está em execução.

Propriedade Lines O texto do controle TMemo é armazenado na propriedade Lines e representa o conjunto numerado de linhas (a numeração começa em 0), a primeira linha tem um índice 0, a segunda 1 etc. Exemplo: Var s: string; Begin s:= memEx.Lines[2]; //o valor da segunda linha é atribuido a variável s memEx.Lines[3]:=’Hi’; //string constant ‘Hi’is assigned to the 4rd line end; Um programa pode acessar as linhas do controle TMemo dessa forma apenas se as linhas tiverem sido criadas pelo Object Inspector, inseridas pelo teclado durante a execução do programa ou criadas pelo método correspondente. Uma tentativa de acessar uma linha inexistente causará um erro de tempo de execução.

75

Módulo 14. Controle TMemo

Você pode preencher o TMemo usando a propriedade Lines. Para fazer isso, pressione o botão com as reticências na propriedade Lines no Object Inspector. A janela do editor Lines abrirá. Você pode inserir as linhas na janela pressionando <Enter> no final de cada linha. Ao terminar, pressione o botão .

Propriedade Count A propriedade Count retorna o número total de linhas. k:=memEx.Lines.Count; Count é ReadOnly, isto é, não é possível alterá-la/editá-la.

Propriedade WordWrap Se WordWrap for True, o controle de edição quebra o texto na margem direita para que ele caiba na área do cliente.

Propriedade MaxLength MaxLength define o número máximo de caracteres que pode ser inserido no controle de edição. Se o MaxLength for 0, o TMemo não limita o comprimento do texto inserido.

Propriedade ScrollBars A propriedade ScrollBars determina se o controle TMemo tem barras de rolagem. O TMemo ignorará a propriedade MaxLength se ela for vertical ou se as duas barras de rolagem estiverem ativadas.

Propriedade Alignment A propriedade Alignment altera a maneira como o texto é formatado no controle de edição de texto.

76


Métodos Vamos examinar alguns métodos.

Método Delete Este método exclui a linha com o índice especificado. Outras linhas serão automaticamente movidas e renumeradas. memEx.Lines.Delete(0); //deleta a primeira linha, p.e. linha com index 0 Exemplo: Deixar apenas as linhas pares. k:=memEx.Lines.Count; For i:=k-1 Downto 1 Do if (i mod 2) 0 then memEx.Lines.Delete(i);

Método Exchange O Exchange troca as posições de duas linhas com os índices especificados. memEx.Lines.Exchange(0,1); // troca a linha 0 com a linha 1

Método Move Move uma linha para uma nova posição. Exemplo: memEx.Lines.Move(1,5); Durante a execução deste método, a linha com o índice 1 (isto é, a segunda linha, uma vez que a numeração começa em 0) será removida do texto. Todas as linhas após ela serão movidas uma posição para cima e a quinta linha substituirá a linha.

77


Exercícios Exercício 1. Preencha um TMemo. Escreva um programa que, ao clicar no botão, deixe apenas o seguinte no TMemo:

•

As quatro primeiras linhas, se houver mais de quatro linhas.

•

A primeira linha, se houver menos de quatro linhas.

Exercício 2. Preencha um TMemo e edite o texto. Escreva um programa que, ao clicar no botão, emita para o rótulo:

a) O índice da linha no TMemo, que é igual à linha na edição do texto, ou a mensagem de que não existe tal linha.

b) Os índices das linhas que contêm uma combinação de símbolos que foram inseridos na edição do texto ou a mensagem de que não existem tais linhas. Exercício 3. Preencha um TMemo com o texto de algumas linhas. Uma linha deve conter “cat” e outra deve conter “dog”. Escreva um programa para trocá-los. Exercício 4. Preencha um TMemo. Escreva um programa para encontrar a linha mais longa e colocá-la no topo.

78


Exercício 5. Preencha um TMemo com números, um por linha. Escreva um programa que duplique todos os números pares e os move para o segundo controle TMemo. Divida todos os números ímpares por dois e mova-os para o terceiro TMemo.

79


Controle TMemo (continuação) Vamos examinar mais alguns métodos e propriedades úteis.

Clear Limpa completamente o conteúdo TMemo. memEx.Lines.Clear

Métodos Append e Add Se o TMemo estiver vazio ou Clear tiver sido chamado, é possível preencher um TMemo chamando o método Append. O método Append adiciona uma nova linha ao final de um TMemo. Exemplo: Preencha um TMemo com números de 1 a 10, um número por linha. … memEx.Lines.Clear; For i:=1 to 10 do begin memEx.Lines.Append (IntToStr(i)); end; O método Add funciona como o Append. memEx.Lines.Add (‘Esse exemplo usa a Lista de’ + ‘string A.’);

80

Módulo 15. Controle TMemo (continuação)

Como você pode ver, ambos os métodos usam string como parâmetro. Add retorna um índice da nova string. b:=memEx1.Lines.Add(edtEx1.Text); lblEx1.Caption:=IntToStr(b); Neste exemplo, o texto da caixa de texto edtEx1 foi adicionado ao TMemo chamado memEx1. O número da nova linha foi emitido para o rótulo lblEx1. Você pode remover, salvar e recuperar fragmentos de texto do TMemo usando Clipboard.

Método Insert Ele insere uma linha com um índice especificado. Outras linhas serão movidas automaticamente. memEx.Lines.Insert(2,’’); // adiciona uma linha vazia ao lugar da linha com index //2, que é movida e não deletada

Classificação de linhas no TMemo A classificação de linhas pode ser realizada usando o seguinte algoritmo. Encontre o índice de uma linha com o valor mínimo (as strings são comparadas caractere por caractere Am then m:=a[i]; max:=m; end;

92

Módulo 17. Matriz estática unidimensional

procedure TfrmArr.btnClick(Sender: TObject); var rMin, rMax: integer; Amax: integer; A: array_n_elements; begin SetArrayRange(rMin, rMax); //Defina o intervalo dos valores do array FillArray(a, rMin, rMax); //Preencha o array com números do intervalo OutputArray(a, n); //Mostre o array Amax:=max(a); //Encontre o elemento máximo Amax lblAmax.Caption:=IntToStr(Amax); //Mostre Amax end; end.

93

Módulo 17. Matriz estática unidimensional

Exercícios Exercício 1. Preencha uma matriz com números aleatórios do intervalo. Insira os limites do intervalo por meio de caixas de texto.

•

Emita a matriz para um TMemo.

•

Para os rótulos, conte e emita:

•

A soma dos elementos.

•

A média dos elementos.

•

A quantidade de elementos positivos e negativos.

•

Os elementos máximo e mínimo.

•

Divida a matriz em duas matrizes, uma com elementos positivos e outra com os elementos negativos. Emita as matrizes para dois novos TMemos.

94


Classificação da matriz e classificação da seleção O processo de classificação pode ser definido como um processo de ordenação de um conjunto de objetos comparando seus atributos. A classificação da matriz é uma área bem conhecida em ciência da computação e há muitos algoritmos que são usados para classificar as matrizes. Examinaremos um dos algoritmos de classificação de matriz mais simples e compreensíveis, a classificação de seleção. Um algoritmo encontra o menor elemento em uma matriz de elementos N e o troca pelo primeiro elemento na matriz. Em seguida, um algoritmo encontra o menor elemento nos elementos restantes (N-1) e o troca pelo segundo elemento na matriz. A mesma operação é realizada com elementos N-2, elementos N-3 e assim por diante, até haver apenas um elemento restante. Esse elemento é o maior. Um exemplo de execução de algoritmo é mostrado abaixo. Os arcos abaixo do texto mostram as trocas de elementos:

95

Módulo 18. Classificação da matriz e classificação da seleção

Vamos examinar a classificação de uma matriz em ordem ascendente. Primeiro, escrevemos o algoritmo nos comentários. //Insira o valor do intervalo, chB e chE. //Preencha o array A com números no intervalo de chB // até chE (inclusive). //Coloque o array A no primeiro campo do memo. //Organize o array A em ordem ascendente. //Coloque o array A no segundo campo do memo. Em seguida, escrevemos o algoritmo como uma sequência das chamadas de procedimento. procedure TfrmArr.btnGoClick(Sender: TObject); var chB, chE: integer; A: array_n_elements; begin Input(chB, chE); //Insira o valor do intervalo do array, de from chB //para chE (inclusive). FillArr(a, chB, chE); //Preencha o array com números aleatórios no // intervalo de chB até chE OutputArray1(a, n); //Coloque o array A no TMemo 1. SortArr(a); //Organize o array A em ordem ascendente. OutputArray2(a, n); //Colque o array A no TMemo 2. end;

96

Módulo 18. Classificação da matriz e classificação da seleção

Os três primeiros procedimentos foram discutidos no módulo anterior. Aqui, escreveremos apenas o procedimento para classificar a matriz. É quase igual ao procedimento para classificar um TMemo. procedure SortArr(var a: array_n_elements); var i: integer; begin for i:=1 to n-1 do //Para cada elemento no array change(a[i], a[NumMin(a, i)]); //troque o elemento atual pelo último elemento no // intervalo até a última posição de troca end; Antes desse procedimento, escreveremos um procedimento para trocar os dois elementos, dados seus índices e a função, para encontrar o menor elemento, começando na posição especificada: function NumMin(a: array_n_elements; start: integer): integer; var i, m: integer; begin m:=start; for i:=m+1 to n do if a[i] é uma string que contém no máximo 20 símbolos, é uma string que contém quatro símbolos (caractere, ponto, caractere, ponto), é um número de um ou dois dígitos. <sobrenome> e e e são separados por um único espaço. A seguir está um exemplo de uma string de entrada: Smith J. C. 57 Escreva um programa que emitirá para um rótulo o número da escola com o menor número de participantes. Os números de escola devem ser listados e, se houver várias escolas com o mesmo menor número de participantes, eles devem ser separados por uma vírgula. O número de linhas é maior que 1.000.

144


Caixas de diálogo de arquivo padrão No módulo anterior, revisamos a maneira padrão e a típica para trabalhar com arquivos. No entanto, o Delphi tem a opção de trabalhar com arquivos com janelas de diálogo de arquivo, isto é, selecionar arquivos para ler ou gravar por meio de janelas de diálogo de abertura de arquivo e salvamento de arquivo. Os componentes das janelas de diálogo de arquivo padrão são localizados na guia Dialogs na paleta. Quando colocados no form, esses componentes não são visíveis durante a execução do programa. Usaremos o componente OpenDialog (ícone de arquivo aberto) para ler as informações do arquivo (deve haver um arquivo) e SaveDialog (ícone de disco) para gravar no arquivo existente ou em um novo arquivo. O nome do novo arquivo será inserido pelo teclado. Os componentes têm a propriedade FileName e o método Boolean Execute. A seguir está um algoritmo de trabalho com janelas de diálogo de arquivo:

145

Módulo 25. Caixas de diálogo de arquivo padrão

Var Okf1, Okf2: Boolean; StF1, StF2: string; Begin //Arquivo para leitura foi selecionado? Begin//Se o arquivo para leitura foi selecionado, então //Encontre o nome do arquivo no Dialog //Associe o arquivo a uma variável //Abra o arquivo para leitura <process File information: read, process, etc> End; //Feche o arquivo //Arquivo para escrita selecionado? //Se o arquivo para escrita foi selecionado, então Begin //Encontre o nome do arquivo no Dialog //Associe o arquivo a uma variável //Abra o arquivo para escrita <write information to File> //Feche o arquivo End; end; A primeira linha do programa será: Okf1:= OpenDialogEx1.Execute; Quando executarmos o programa, a seguinte OpenDialog de arquivo padrão será exibida. Selecionaremos o arquivo necessário nessa janela de diálogo.

146


Pressionar o botão Open abrirá o arquivo para leitura. O método de execução retornará True e o nome do arquivo será atribuído à propriedade FileName do componente OpenDialogEx1. Vamos continuar o programa: If Okf1 then //se o arquivo para leitura está selecionado, então Begin Stf1:= OpenDialogEx2.FileName; //Pegue o arquivo do Dialog e associe a variável StF1 AssignFile(f, Stf1); //Associe o arquivo a variável Reset(f); //Abra o arquivo para leitura ……………; //Processe os dados no arquivo Closefile(f); // Feche o arquivo End;

147


Neste exemplo, após o arquivo ser aberto, podemos substituir o “……………” por operadores que são necessários para processar os dados para resolver os problemas, ler informações do arquivo, processar os dados etc. Já testamos isso nos módulos anteriores. Para gravar as informações no arquivo: Okf2:=SaveDialogEx2.Execute; //O arquivo está selecionado para escrita? Quando este comando for executado, o diálogo de salvamento de arquivo padrão será exibido. Nele, podemos selecionar um arquivo existente ou digitar o nome de um novo arquivo na caixa de texto “File Name”. O nome do arquivo selecionado (e o caminho para ele) serão atribuídos à propriedade SaveDialogEx1.FileName.

A operação será cancelada se você pressionar o botão Cancel. O código para registrar informações no arquivo será semelhante a esse:

148


Okf2:=SaveDialogEx2.Execute; //Is File selected for Write? If Okf2 then //Se o arquivo para escrever está selecionado, então Begin Stf2:= SaveDialogEx2.FileName; //Selecione o nome do arquivo do Dialog AssignFile(g, Stf2); //Associe o arquivo para a variável Rewrite(g); //Abra o arquivo para escrita …………… .; //Escreva dados no arquivo, processa dados Closefile(g); //Fecha o arquivo End; End; Agora você deve saber como trabalhar com arquivos no modo Dialog.

149


Exercícios Exercício 1. Crie um arquivo de texto no Notepad. Usando caixas de diálogo de arquivo padrão, escreva um programa que copiará todas as strings de comprimentos pares desse arquivo para File 2 e todas as strings de comprimentos ímpares para File 3. Exercício 2. Crie um arquivo de texto no Notepad para que cada linha do arquivo contenha inteiros separados uns dos outros por um ou mais espaços. Usando caixas de diálogo de arquivo padrão, escreva um programa que calculará a soma de todos os números e registrará essa soma em um novo arquivo. Exercício 3. Crie um arquivo de texto no Notepad para que cada linha do arquivo contenha inteiros aleatórios e palavras aleatórias separados uns dos outros por um ou mais espaços. Usando caixas de diálogo de arquivo padrão, escreva um programa que calculará a soma de todos os números e registrará essa soma em um novo arquivo.

150

Módulo 25. Aplicações com Banco de Dados

Aplicações com Banco de Dados

Introdução

Um banco de dados é uma coleção organizada de dados. Na linguagem de computação, um banco de dados é uma coleção de registros (também chamados de linhas - representam um único item de dados, estruturados implicitamente em uma tabela) armazenados em um computador de forma sistemática, de modo que um programa de computador possa consultá-los para responder a perguntas. Para uma melhor recuperação e classificação, cada registro é, normalmente, organizado como um conjunto de elementos de dados (fatos). Os itens recuperados em resposta a consultas tornam-se informações que podem ser usadas para tomar decisões. O programa de computador usado para gerenciar e consultar um banco de dados é conhecido como um sistema de gerenciamento de banco de dados (DBMS). O conceito central de um banco de dados é o de uma coleção de registros ou pedaços de conhecimento. Tipicamente, para uma determinada base de dados, não há uma descrição estrutural do tipo de fatos realizada na base de dados: essa descrição é conhecida como um esquema. O esquema descreve os objetos que são representados no banco de dados e as relações entre eles. Há diferentes formas de organizar um esquema, ou seja, de modelar a estrutura de banco de dados, conhecidas como modelos de banco de dados (ou modelos de dados). Hoje, o modelo em uso mais comum é o relacional, que representa todas as informações sob a forma de várias tabelas relacionadas, cada uma composta de linhas e colunas (a verdadeira definição utiliza a terminologia matemática). Este modelo representa as relações através da utilização de valores comuns a mais de uma tabela. Outros modelos, como o hierárquico e o de rede, usam uma representação mais explícita de relacionamentos.

151

Módulo 25. Aplicações com Banco de Dados Linguagem SQL

SQL (Structured Query Language) é a linguagem mais popular usada para criar, modificar e recuperar dados de sistemas de gerenciamento de banco de dados relacionais. A linguagem evoluiu além do seu propósito original para suportar sistemas de gerenciamento de banco de dados objeto-relacional. É um padrão ANSI/ISO.

O componente DML (Data Manipulation Language) compreende 4 opções básicas: •

UPDATE – Para modificar linhas de uma tabela

•

DELETE – Para remover linhas de uma tabela

•

INSERT – Para adicionar linhas em uma tabela

Os comandos DDL (Data Definition Language) incluem o seguinte: •

CREATE - Para criar um novo banco de dados, tabela, índice ou consulta armazenada

•

ALTER - Modifica a estrutura de uma tabela existente e outros objetos

•

DROP - Para destruir um banco de dados, tabela, índice ou consulta armazenada já existente

Outros comandos comuns: •

SELECT - Para obter dados do banco de dados e impor ordenação sobre ele

•

REVOKE e GRANT - Para dar e receber direitos de acesso a objetos de banco

152

Módulo 25. Aplicações com Banco de Dados Por que Usar Bancos de Dados em Aplicativos?

As bases de dados são utilizadas em muitas aplicações, abrangendo praticamente toda a gama de software de computador. Bancos de dados são o método preferido de armazenamento para aplicações multiusuário, onde é necessária a coordenação entre muitos usuários. Mesmo os usuários individuais os acham convenientes e muitos programas de correio eletrônico e organizadores pessoais são baseados na tecnologia de banco de dados padrão. Ao projetar um aplicativo de banco de dados, você deve entender como os dados são estruturados. Com base nessa estrutura, você pode, então, projetar uma interface para exibir dados para o usuário e permitir ao usuário inserir novos dados ou modificar os existentes. Drivers para acessar bancos de dados estão disponíveis para a maioria das plataformas de banco de dados para que o seu software possa usar a interface de programação (API) para recuperar as informações armazenadas em um banco de dados. Banco de Dados Locais e Remotos

Servidores de banco de dados relacionais variam na forma como eles armazenam informações e, também, na maneira de permitir que vários usuários tenham acesso a essas informações simultaneamente. O RAD Studio fornece suporte para dois tipos de servidores de banco de dados relacionais: Bancos de Dados Locais

Residem em sua unidade local. Eles têm muitas vezes APIs proprietárias para acessar os dados. Quando compartilhados por vários usuários, eles usam mecanismos de bloqueio com base em arquivo. Devido a essa característica, às vezes são chamados bancos de dados baseados em arquivos. As aplicações que utilizam bases de dados locais são chamadas de aplicativos de uma camada, porque a aplicação e o banco de dados residem no mesmo sistema de arquivos.

153

Módulo 25. Aplicações com Banco de Dados Bancos de Dados Remotos

Residem em uma máquina separada. Às vezes, os dados de um servidor de banco de dados remoto nem sequer residem em uma única máquina, mas são distribuídos ao longo de vários servidores. Embora os servidores de banco de dados remotos variem na forma como armazenam informações, eles fornecem uma interface lógica comum aos clientes. Essa interface comum é a Structured Query Language (SQL). Devido ao fato de você acessá-los usando SQL, eles às vezes são chamados de servidores SQL (outro nome é o sistema de gerenciamento de banco de dados remoto, ou RDBMS). Além dos comandos comuns que compõem SQL, a maioria dos servidores de banco de dados remotos suporta um "dialeto" único de SQL. Exemplos de servidores SQL incluem InterBase, Oracle, Microsoft SQL Server, Sybase, Informix, DB2, entre tantos outros. As aplicações que utilizam servidores de banco de dados remotos são chamadas de aplicativos de duas camadas porque o aplicativo e o banco de dados operam em sistemas independentes. Transações e Concorrência

Uma transação é um conjunto de ações que devem ser realizadas com sucesso em uma ou mais tabelas de um banco de dados antes de serem confirmadas (tornadas permanentes). Se qualquer uma das ações do grupo falhar, então todas as ações são revertidas (desfeitas). Em sistemas de banco de dados, as capacidades de lidar com transações permitem ao usuário garantir que a integridade de um banco de dados seja mantida. Uma única operação pode exigir várias consultas, cada qual com leituras/gravações no banco de dados. Quando isso acontece, geralmente, é importante ter certeza de que o banco de dados vai completar todas as operações realizadas. Por exemplo, ao fazer uma transferência de dinheiro, se o dinheiro foi debitado de uma conta, é importante ele também ser creditado na conta de depósito. Além disso, as transações não devem interferir umas nas outras.

154


Uma simples transação, geralmente, é enviada para o sistema de banco de dados em uma linguagem, como SQL, da seguinte forma: •

Início da Transação (Begin Transaction);

•

Executar várias consultas e atualizações (embora todas as atualizações do banco de dados não sejam visíveis para o mundo exterior até o momento);

•

Consolidar a transação (Commit Transaction). Neste momento, as atualizações tornam-se visíveis se a operação for bem-sucedida.

Se uma das operações falhar, o sistema de banco de dados pode reverter toda a operação ou apenas a consulta que falhou. Este comportamento é dependente do SGBD em uso e de como ele está configurado. A transação também pode ser revertida manualmente a qualquer momento antes de sua confirmação. Idealmente, o software de banco de dados deve cumprir as regras ACID (Atomicidade, Consistência, Isolamento, Durabilidade) que garantam sua total integridade. Em caso de sucesso, a transação deve ter todas as suas operações executadas. Em caso de falha, nenhum resultado de alguma operação deve ser refletido sobre a base de dados. Isto é referido como Atomicidade; A execução de uma transação deve levar o banco de dados de um estado consistente a um outro estado consistente, ou seja, uma transação deve respeitar as regras de integridade dos dados (como unicidade de chaves, restrições de integridade lógica, etc.). Isso é referido como a Consistência; Em sistemas multiusuários, várias transações podem acessar simultaneamente o mesmo registro (ou parte do registro) no banco de dados. O isolamento é um conjunto de técnicas que tentam evitar que transações paralelas interfiram umas nas outras. Isso é referido como o Isolamento; Os efeitos de uma transação em caso de sucesso (commit) devem persistir no banco de dados mesmo em casos de quedas de energia, travamentos ou erros. Garante que os dados estarão disponíveis em definitivo. Isso é referido como a Durabilidade. 155

Módulo 25. Aplicações com Banco de Dados Integridade Referencial, Stored Procedures e Triggers

Todos os bancos de dados relacionais têm certas características em comum, que permitem aos aplicativos armazenar e manipular dados. Além disso, bancos de dados, muitas vezes, fornecem outros recursos específicos que podem ser úteis para garantir relações consistentes entre as tabelas em um banco de dados. Integridade Referencial

A integridade referencial fornece um mecanismo para impedir que relações mestre/detalhes entre as tabelas sejam quebradas. A integridade referencial é geralmente executada pela combinação de uma chave primária e uma chave estrangeira. Para que a integridade referencial funcione, qualquer campo de uma tabela que é declarada como uma chave estrangeira poderá conter apenas os valores do campo de chave primária de uma tabela pai. Quando o usuário tenta excluir um campo de uma tabela mestre, que resultaria em linhas filhas órfãs, regras de integridade referencial podem impedir sua supressão ou eliminar automaticamente os registros órfãos. Stored Procedures

Os procedimentos armazenados são conjuntos de instruções SQL, nomeados e armazenados em um servidor SQL. Procedimentos armazenados podem executar tarefas comuns, relacionadas com o banco de dados no servidor, e, às vezes, retornar um conjunto de registros (conjuntos de dados). Usos típicos para procedimentos armazenados incluem a validação de dados. Procedimentos armazenados utilizados para este fim são, frequentemente, chamados de gatilhos (ou triggers). Ou ainda podem encapsular uma API para algum processamento de dados grandes e complexos, tais como manipulação de um grande conjunto de dados para produzir um resultado resumido.

156

Módulo 25. Aplicações com Banco de Dados Triggers

Triggers são conjuntos de instruções SQL executadas automaticamente em resposta a um comando particular. Gatilhos de banco de dados são iniciados quando um INSERT, UPDATE ou DELETE para uma tabela é executado. Um gatilho pode conter várias instruções SQL. Você pode usar gatilhos para verificar se os valores são adequados antes de introduzi-los em uma tabela ou para salvar os valores antes de mudá-los. Ao programar um gatilho, você pode acessar tanto os valores novos, quanto antigos de uma coluna em particular. Se a execução de um gatilho falhar, você pode usar ROLLBACK para redefinir o INSERT associado, UPDATE ou DELETE. Suporte para Banco de Dados no RAD Studio

O RAD Studio possui uma série de Frameworks que permitem acesso aos mais diversos bancos de dados. Ao longo das diversas versões do produto, novas tecnologias foram introduzidas, sendo a mais atual e completa de todas o FireDAC. Existem também frameworks de terceiros, entre produtos comerciais e de código aberto. Dentre as tecnologias pré-existentes no produto para acesso a dados, podemos citar: •

BDE: primeira tecnologia de acesso a dados do RAD Studio, foi amplamente utilizado no passado e, hoje, é uma tecnologia formalmente descontinuada. Aplicações utilizando este framework devem ser migradas para FireDAC.

•

dbGo: representa uma camada de abstração para o ADO e, apesar de suportar diversas tecnologias de banco de dados, é normalmente aplicado apenas ao acesso de soluções baseadas em SQL Server.

•

IBX (Interbase Expresss): trata-se de um conjunto de componentes que permite acesso nativo ao banco de dados Interbase. Possui ótima performance e é amplamente utilizado apenas para aplicações baseadas neste banco de dados.

157


•

DBX (dbExpress): trata-se de um conjunto de drivers de banco de dados leve que fornecem acesso rápido a servidores de banco de dados SQL. Para cada banco de dados suportado, dbExpress provê um driver que se adapta ao software específico do servidor para um conjunto de interfaces dbExpress uniformes. Quando você implanta um aplicativo de banco de dados que usa dbExpress, você deve incluir uma DLL (o driver específico do servidor) na distribuição de sua aplicação.

FireDAC

FireDAC é um conjunto único e universal de componentes para acesso a dados, para desenvolver aplicações de banco de dados multidispositivo para Delphi e C++ Builder. Com sua poderosa arquitetura comum, FireDAC permite o acesso direto de alta velocidade nativa para InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, IBM DB2, SQL Anywhere, Access, Firebird, Informix e muito mais. Baseado em 10 anos de experiência em escrever drivers nativos para banco de dados, o FireDAC foi construído como uma camada de acesso poderosa que suporta todos os recursos necessários para construir aplicações reais de alta performance. FireDAC oferece uma API comum para acessar banco de dados de diferentes plataformas, sem comprometer o acesso a recursos específicos de um determinado banco de dados ou, ainda, seu desempenho. Entre os inúmeros benefícios deste Framework, podemos citar: • FireDAC é o fruto de 10 anos de experiência no desenvolvimento de aplicações de banco de dados reais; • FireDAC permite que o desenvolvedor se concentre no desenvolvimento do aplicativo e não sobre as complexidades de interação com o banco; • FireDAC fornece um moderno conjunto, rico em recursos de componentes para abordar todos os principais ambientes RDBMS; • FireDAC usa um conjunto de componentes para tratar todos os tipos de RDBMS suportados; • FireDAC reduz o custo total de propriedade.

158

Módulo 25. Aplicações com Banco de Dados Prática com Banco de Dados

Neste ponto, você já sabe o que é um banco de dados e alguns detalhes sobre sua estrutura. Assim, para melhor visualizar e entender como trabalhar com um banco de dados, você vai criar um banco de dados simples para testar as operações básicas, tais como inserir, editar e excluir. Se você já tem o Delphi ou o C++ Builder instalados, então seu sistema já conta com uma edição do Interbase para desenvolvimento disponível. O Interbase possui diversas edições e suporte a múltiplas plataformas como iOS, Android, OS X, Linux, além do próprio Windows, distribuídas entre versões Server e embutidas. Para conhecer mais sobre todas as possibilidades, visite este link: https://www.embarcadero.com/products/interbase Inicialmente, verifique se o serviço do Interbase está devidamente ativo, através do gerenciador de serviços do Windows. Se tudo estiver OK, podemos seguir em frente! Este tutorial está dividido em três partes principais: •

Estabelecer a conexão com o banco de dados: como usar Delphi ou C++ Builder para criar um aplicativo que irá conectar-se a um banco de dados;

•

Selecionar linhas do banco de dados: ligar os dados até um Gris e exibi-los em tempo de design;

•

Preparar sua aplicação para distribuição: descrever os passos necessários para fazer com que um aplicativo execute de maneira autônoma em qualquer computador.

Inicie pela criação de uma nova aplicação do tipo “VCL Forms Application”. Arraste um componente TFDConnection para o formulário selecionado a partir da página "FireDAC" do Tool Palette. Este componente é responsável por estabelecer e controlar a conexão com o banco de dados. Através de um double-click sobre este componente, vamos definir a conexão com uma base de dados de exemplo do Interbase, que faz parte dos exemplos instalados em conjunto com o produto. Tudo o que você precisa fazer é: 159


•

Selecionar o Driver “IB” (responsável pela conexão ao Interbase);

•

Informar a propriedade DataBase, apontando-a para o banco de dados de exemplo “EMPLOYEE.GDB”, localizado na pasta Samples de seu produto (normalmente a pasta Samples encontra-se abaixo de “Documentos” ou “Documentos Públicos”, de acordo com o idioma de seu Windows);

•

Informar as propriedades User_Name e Password. Por padrão, caso não tenha sido alterado durante a instalação do produto, o usuário e senha serão os mesmos apresentados na imagem abaixo;

•

Se tudo estiver OK, ao clicar no botão Test, uma conexão com o banco de dados será estabelecida.

160


Vamos agora selecionar alguns dados para exibir em sua primeira aplicação com banco de dados: •

Arraste um componente TFDQuery a partir da paleta "FireDAC" para o formulário. Este componente é responsável pela execução de comandos SQL, para buscar linhas do banco de dados e postar dados alterados de volta para o DB. Defina sua propriedade Connection para “FDConnection1”, caso não tenha sido automaticamente definida.

•

Através de um double-click no componente “FDQuery1”, digite e teste o seguinte comando SQL:

161


•

Se você observou dados sendo exibidos (similar à figura acima), podemos passar agora à configuração da porção visual de sua aplicação.

Para exibir os dados para seus usuários, vamos utilizar um componente do tipo Grid. Siga os seguintes passos para finalizar sua primeira aplicação com banco de dados: •

Localize e arraste para o formulário um componente “TDataSource” (paleta “Data Access”);

•

Configure sua propriedade DataSet para o “FDQuery1”;

•

Arraste um componente “TDBGrid” (paleta “Data Controls”) para o formulário e configure sua propriedade DataSource para o “DataSource1”;

•

Finalmente, configure a propriedade Active do “FDQuery1” para True. Os dados serão exibidos no controle “DBGrid1”.

162


Para encerrar, devemos preparar nossa aplicação para distribuição. Para tal, siga os seguintes passos: •

Arraste um componente “TFDPhysIBDriverLink” (paleta “FireDAC Links”) para o formulário, este componente contém o driver para a conexão com o Interbase;

•

Arraste um componente “TFDGUIxWaitCursor” (paleta “FireDAC UI”) para o formulário, este componente é responsável por exibir o cursor apropriado no momento em que uma operação de banco de dados está sendo executada;

•

Compile sua aplicação e ela está pronta para ser distribuída!

Com isso, encerramos este capítulo sobre aplicações com banco de dados. Para saber mais sobre FireDAC e como conectar outros bancos de dados suportados, você pode acessar esta página que é parte da documentação do produto: http://docwiki.embarcadero.com/RADStudio/Berlin/en/Overview_(FireDAC)

163

PROGRAMAÇÃO EM DELPHI PARA INICIANTES

Love 'Em or Leave 'Em

Vida para consumo a transformação das pessoas em mercadorias

Love 'Em or Leave 'Em

Hold 'Em

Учебник Delphi

Hold 'Em

Tie 'Em Up, Hold 'Em Down

Delphi 5

Essential Delphi

Delphi 6

Delphi 6

Knock 'em Dead

Hold 'Em Hostage

Ride Em Cowboy

Always Leave 'Em Dying

Revolta em 2100

A História em Migalhas

Hook 'Em Snotty!

Em Busca da Política

Always Leave 'em Dying

Crook Em Cowboy

Knock 'em Dead

Cinema em Portugues

Doença Mental em Psicologia

Mundo em Chamas

Texas Hold Em

Aristoteles em Nova Perspectiva

Ride Em Cowboy

Texas Hold 'Em

PROGRAMAÇÃO EM DELPHI PARA INICIANTES

Love 'Em or Leave 'Em

Vida para consumo a transformação das pessoas em mercadorias

Love 'Em or Leave 'Em

Hold 'Em

Учебник Delphi

Hold 'Em

Tie 'Em Up, Hold 'Em Down

Delphi 5

Essential Delphi

Delphi 6

Delphi 6

Knock 'em Dead

Hold 'Em Hostage

Ride Em Cowboy

Always Leave 'Em Dying

Revolta em 2100

A História em Migalhas

Hook 'Em Snotty!

Em Busca da Política

Always Leave 'em Dying

Crook Em Cowboy

Knock 'em Dead

Cinema em Portugues

Doença Mental em Psicologia

Mundo em Chamas

Texas Hold Em

Aristoteles em Nova Perspectiva

Ride Em Cowboy

Texas Hold 'Em

Recommend Documents