Ementrio O ambiente de desenvolvimento A linguagem Pascal

Ementário • • • O ambiente de desenvolvimento A linguagem Pascal, Programação Orientada a Objetos Visual Components Library Banco de dados: abordagem I e II Componentes Quick. Report Dynamic Link Library Help Install. Shield Express Delphi e Pascal Avançado Programando para Internet

Subprogramas • Em geral: – problemas complexos = programas complexos • Mas sempre é possível dividir: – problemas grandes e complicados em problemas menores e de solução mais simples • Programa complexo = Subprograma 1 + Subprograma 2 +. . . + Subprograma N

Definição • Um subprograma, é um nome dado a um trecho de um programa mais complexo e que, em geral, encerra em si próprio um pedaço da solução de um problema maior o programa a que ele está subordinado. • São sinônimos: Módulo, Subrotina e Subalgoritmo e são conceitos da ciência conhecida com engenharia de software.

Método de Refinamentos Sucessivos • dividir uma subrotina em outras tantas quantas forem necessárias, buscando uma solução mais simples de uma parte do problema maior • técnica de programação estruturada – dividir-para-conquistar

Em Resumo • subdivisão de programas complexos – facilita o entendimento (partes independentes) • estruturação de programas – detecção de erros e documentação de sistemas • modularização de sistemas – manutenção de software e a reutilização de subprogramas

A questão é: “Reutilização de Software” Objetivo: Economia de tempo e trabalho. Princípio: Um conjunto de subprogramas destinado a solucionar uma série de tarefas bastante corriqueiras é desenvolvido e vai sendo aumentado com o passar do tempo, com o acréscimo de novos subprogramas. A este conjunto dá-se o nome de biblioteca. No desenvolvimento de novos sistemas, procura-se ao máximo basear sua concepção em subprogramas já existentes na biblioteca, de modo que a quantidade de software realmente novo que deve ser desenvolvido é minimizada.

Mecanismo de Funcionamento Um programa completo é dividido em programa principal e diversos subprogramas (tantos quantos forem necessários e/ou convenientes). O programa principal é aquele por onde a execução da aplicação sempre se inicia e ele pode eventualmente invocar os demais subprogramas. O corpo do programa principal é sempre o último trecho do código de um programa em pascal. As definições dos subprogramas estão sempre colocadas na região de declaração do programa.

program Nome. Do. Programa; cabeçalho do programa uses Nome. Da. Unit; label Nome. Do. Rótolo; const Nome. Da. Contante = Valor. Da. Constante; type Nome. Do. Tipo. Construído = Tipo. De. Dados. Primitivo; var Nome. Da. Variável : Nome. Do. Tipo; procedure Nome. Do. Procedimento( < Lista. De. Parâmetros > ); begin { Corpo do Procedimento } end; região de declarações function Nome. Da. Função( < Lista. De. Parâmetros > ) : Tipo. De. Retorno; begin { Corpo da Função } end; begin { Corpo do Programa Principal } end. ações (o que é executado)

Subprogramas (ou subrotinas) • trecho de código (módulo, rotina, processo): – procedure – function (retorna valor) • unit – biblioteca, ou unidade de códigos: conjunto de procedure’s e function’s

Definição de Procedimento e Função O procedimento é uma parte separada do programa, e somente é executado quando o seu nome é chamado dentro do programa principal ou por outro subprograma que esteja em execução. A função funciona de forma similar, com a diferença de que esta retorna com um valor através do seu nome. O nome de um subprograma é um identificador pelo qual ele será referenciado numa sentença de chamada.

Estrutura de subprogramas • um cabeçalho, onde estão definidos o nome e o tipo do subprograma (procedure ou function), bem como os seus parâmetros e declarações locais (uses, const, type, var e subprogramas subordinados); • um corpo, onde se encontram as instruções (comandos) do subprograma.

Procedimento (procedure) • são subrotinas, que realizam uma tarefa e não retornam valor procedure Nome. Do. Procedimento( <Lista. De. Parâmetros> ); { declarações locais do procedimento: uses, const, type, var, procedure e function } begin { corpo do procedimento } end;

Na sintaxe de definição de um procedimento temos que: Nome. Do. Procedimento é o nome simbólico pelo qual o procedimento é invocado, ou chamado Lista. De. Parâmetros dados recebidos ou enviados pelo procedimento ao módulo chamador Declarações locais definições locais do procedimento (uses, var, type, . . . ) Corpo do procedimento conjunto de instruções que serão executadas pelo procedimento toda vez que o mesmo é invocado

Manipulação de procedimentos • O procedimento é uma parte separada do programa, e somente é executado quando o seu nome é chamado dentro do programa principal ou por outro subprograma que esteja em execução. • O nome de um procedimento é um identificador pelo qual ele será referenciado numa sentença de chamada (ou ativação). • Ao término do procedimento o controle de execução é devolvido ao módulo chamador.

program Principal; ; ; ; procedure PRIMEIRO; ; ; ; procedure SEGUNDO; ; ; ;

program Multiplicacao_Atraves_De_Somas_Sucessivas; var X, Y, Z, U: integer; procedure Mult; { X * Y } begin Z : = 0; U : = 0; repeat Z : = Z + Y; U : = U + 1; until U = X; end; begin X : = 2; Y : = 4; Mult; writeln(X, ‘*’, Y, ‘=’, Z); X : = 5; Y : = 3; Mult; writeln(X, ‘*’, Y, ‘=’, Z); end.

Função (function) • são muito semelhantes a procedimentos, a única diferença é que as funções retornam com um valor através do seu nome function Nome. Da. Função( <Lista. De. Parâmetros> ): Tipo. Do. Retorno; { declarações da função: uses, const, type, var, procedure e function } begin. . . Nome. Da. Função : = Expressão. De. Retorno; . . . end; { corpo da função }

Na sintaxe de definição de uma função temos que: Nome. Da. Função é o nome simbólico pelo qual a função é invocada Lista. De. Parâmetros dados recebidos pela função do módulo chamador Tipo. Do. Retorno é o tipo de dado da informação retornada pela função ao módulo chamador Declarações locais definições locais da função (uses, var, type, . . . ) Corpo da função conjunto de instruções que serão executadas pela função toda vez que a mesma é invocada Expressão. De. Retorno valor retornado pela função

Manipulação de funções • A função funciona de forma similar ao funcionamento de um procedimento, com a diferença de que uma função sempre retorna com um valor através do seu nome. • A função é executada e, ao seu término, o trecho do comando que a invocou é substituído pelo valor da expressão atribuído ao nome da função.

program Multiplicacao_Atraves_De_Somas_Sucessivas; var X, Y, Z, U: integer; function Mult: integer; { X * Y } begin Z : = 0; U : = 0; repeat Z : = Z + Y; U : = U + 1; until U = X; Mult : = Z; { retorna o valor } end; begin X : = 2; Y : = 4; writeln(X, ‘*’, Y, ‘=’, Mult); X : = 5; Y : = 3; writeln(X, ‘*’, Y, ‘=’, Mult); end.

Conceitos • O escopo de uma variável ou sua abrangência está vinculada a sua visibilidade (Global ou Local) em relação aos subprogramas de um programa, sendo que a sua visibilidade está relacionada a sua hierarquia. • Variável Global: pode ser usada pelo programa e por todos os subprogramas • Variável Local: pode ser usada somente pelo subprograma em que ela foi definida e pelos seus descendentes

Escopo de Variáveis Programa Principal A, B Subprograma 1 A, X Subprograma 1. 1 W Subprograma 1. 2 Y Subprograma 2 M Subprograma 2. 1 X as variáveis A e B, são globais aos subprogramas 1 e 2, porém dentro da subprograma 1, a variável A é definida novamente assumindo assim um contexto local para este subprograma B- variável global A e X- variáveis locais B, A e X- variáveis globais W- variável local B, A e X- variáveis globais Y- variável local A, B- variáveis globais M- variável local A, B e M- variáveis globais X- variável local

Comunicação entre Subprogramas • Parâmetros são canais pelos quais se estabelece uma comunicação bidirecional entre um subprograma e o módulo chamador (o programa principal ou outro subprograma). • Dados são passados pelo módulo chamador ao subprograma, ou retornados por este ao primeiro por meio de parâmetros.

Parâmetros • são variáveis opcionalmente passadas a um subprograma • uma procedure ou function podem ter zero ou mais parâmetros • são definidos no cabeçalho do subprograma

Tipos de parâmetros • Parâmetros Formais são os nomes simbólicos introduzidos no cabeçalho dos subprogramas. Dentro de um subprograma trabalha-se com estes nomes da mesma forma como se trabalha com variáveis locais ou globais. • Parâmetros Reais (ou argumentos) são aqueles que se associam aos parâmetros formais quando da chamada de um subprograma.

program Tipos_De_Parametros; function Divisao(N, D: integer): real; begin if D = 0 N e D- parâmetros then Divisao : = 0 else Divisao : = N / D; formais (definição) end; var A, B, C: integer; begin writeln(‘Digite o 1º Valor ‘); readln(A); writeln(‘Digite o 2º Valor ‘); readln(B); A e B- parâmetros reais, ou argumentos (valores) C : = Divisao(A, B); writeln(A, ‘ / ’, B, ‘ = ‘, C); end.

Finalidade dos parâmetros • Através da passagem de parâmetros é feita a transferência de informações entre os módulos sejam: constantes, variáveis, ou expressões, ao invés de somente o valor de variáveis globais. • Esta utilização formaliza a comunicação entre módulos. • Existem dois tipos de passagem de parâmetros: – Tipo Valor ou Constante (cópia) – Tipo Variável ou Referência

Parâmetros por valor • os parâmetros reais (módulo chamador) são calculados e os parâmetros formais (subprograma) correspondentes recebem uma cópia dos valores resultantes • a variável passada se comporta como uma variável local, ou seja, alterações nos parâmetros formais não afetam os parâmetros reais

Ativando uma function: Program Soma. Numeros; function Soma(A, B: integer): integer; begin Soma : = A + B; parâmetro por valor end; var Resultado: integer; begin Resultado : = Soma(2, 3); writeln(Resultado); { ou } writeln(Soma(2, 3)); end. ativa a função

Parâmetros por referência (var) • Os parâmetros reais (módulo chamador) compartilham seu espaço de memória com os parâmetros formais (subprograma). • Portanto, alterações nos parâmetros formais afetam os parâmetros reais. • O subprograma recebe uma referência à variável passada ou, em outras palavras, a própria variável.

Parâmetros por referência (var) • Com esse tipo de passagem de parâmetros, o subprograma pode alterar diretamente a variável passada. • Para especificar a passagem por referência, deve-se usar a palavra-chave var antes do nome do parâmetro.

Ativando uma procedure: Program Soma. Numeros; Procedure Soma(A, B: integer; var C: integer); begin parâmetro C : = A + B; por valor por referência end; var Resultado: integer; begin. . . Soma(2, 3, Resultado); writeln(Resultado); . . . end. ativa o procedimento

Funcionamento de Subprogramas: Os módulos utilizam objetos (variáveis, pôr exemplo) declarados em seu corpo, mas podem também utilizar os objetos declarados níveis mais externos, chamados globais. O uso de variáveis globais dentro do subprograma serve para implementar um mecanismo de transmissão de informações de um nível mais externo para um mais interno. A utilização de variáveis globais não constitui, no entanto, uma boa prática de programação (escopo muito grande). Assim, todo módulo ao ser implementado deve utilizar variáveis locais, e a transmissão de informações para dentro e fora dos procedimentos deve ser feita através dos parâmetros de transmissão. As variáveis locais são criadas e alocadas quando da ativação e automaticamente liberadas quando do seu término.

Funcionamento de Subprogramas: O subprograma (filho) é uma parte separada do módulo chamador (pai), e somente é executado quando o seu nome (identificador) for referenciado numa sentença de chamada. A execução do módulo se comporta como se o trecho do subprograma fosse copiado para o ponto onde foi invocado. Existem duas formas de chamada: a) Nome_do_Subprograma; b) Nome_do_Subprograma(Lista_de_Parâmetros_Reais); Os parâmetros reais na lista são separados por vírgula. O 1º parâmetro real é associado ao 1º parâmetro formal; O 2º parâmetro real é associado ao 2º parâmetro formal e assim por diante. O número de parâmetros reais deve ser igual ao número e ao tipo dos parâmetros formais.

Exemplo de Ativação de Módulos: Procedimentos: a) Mult; b) Mult(W, Z); { Módulo declarado sem parâmetros. } { W e Z são parâmetros reais (de transmissão). } Funções: a) Z : = Mult(W, Z); { O valor retornado pelas funções é utilizado em expressões. } b) if Par(Num) = True then writeln(Num, ‘é par. ’) else writeln(Num, ’não é par. ’);

Funcionamento de Subprogramas: Ativação de Subprogramas: quando um subprograma é chamado para execução, três tarefas são executadas: a) criação de um espaço para os objetos (variáveis) locais; b) associação e passagem de parâmetros; c) transferência de controle para o subprograma (módulo chamado). Retorno de Subprogramas: quando a execução do subprograma é concluída, três tarefas são executadas: a) endereço de retorno é restabelecido; b) área do procedimento chamado é liberada; c) transferência de controle para o endereço de retorno (módulo chamador).

Funcionamento de Subprogramas: A área de memória usada na execução de um programa varia dinamicamente durante a execução. A memória é representada graficamente como sendo uma pilha de caixa de variáveis. Cada uma destas caixas contém, pôr sua vez, um escaninho para cada uma das variáveis locais (ou parâmetros). Sempre que um subprograma é chamado, uma caixa contendo espaço para as variáveis é colocada no topo da pilha. Quando o algoritmo principal é iniciado a pilha contém uma caixa para as variáveis globais. Ao terminar um subprograma, sua caixa de variáveis é automaticamente retirada da pilha.

Program P; var X, Y, Z : integer; I Procedure Soma(A, B: integer; var C: integer); begin C : = A + B; end; begin X : = 2; Y : = 3; Soma(X, Y, Z); writeln(‘Soma = ‘, Z); end. I) situação inicial X Y Z caixa do programa principal pilha de memória

Program P; var X, Y, Z : integer; Procedure Soma(A, B: integer; var C: integer); begin C : = A + B; end; begin X : = 2; Y : = 3; II Soma(X, Y, Z); writeln(‘Soma = ‘, Z); end. II) ao fazer as atribuições 2 3 X Y Z caixa do programa principal pilha de memória

Program P; var X, Y, Z : integer; Procedure Soma(A, B: integer; var C: integer); begin C : = A + B; end; begin X : = 2; Y : = 3; III Soma(X, Y, Z); writeln(‘Soma = ‘, Z); end. III) ao chamar o procedimento Soma 2 3 X Y Z caixa do programa principal A B C caixa do procedimento Soma pilha de memória

Program P; var X, Y, Z : integer; Procedure Soma(A, B: integer; var C: integer); begin IV C : = A + B; end; begin X : = 2; Y : = 3; Soma(X, Y, Z); writeln(‘Soma = ‘, Z); end. IV) associação e/ou passagem de parâmetros 2 3 X Y Z caixa do programa principal 2 3 A B C caixa do procedimento Soma pilha de memória

Program P; var X, Y, Z : integer; Procedure Soma(A, B: integer; var C: integer); begin C : = A + B; end; V begin X : = 2; Y : = 3; Soma(X, Y, Z); writeln(‘Soma = ‘, Z); end. V) logo antes do final do procedimento Soma 2 3 5 2 3 X Y Z A B caixa do programa principal C caixa do procedimento Soma pilha de memória

Program P; var X, Y, Z : integer; Procedure Soma(A, B: integer; var C: integer); begin C : = A + B; end; begin X : = 2; Y : = 3; Soma(X, Y, Z); VI writeln(‘Soma = ‘, Z); end. VI) logo antes do final do programa P 2 3 5 X Y Z caixa do programa principal pilha de memória

Resumo- ativando rotinas Módulo Chamador (Pai) . variáveis globais. argumentos ou paramêtros efetivos ou reais Módulo Chamado (Filho) . variáveis locais. parâmetros formais

Unidade de códigos (unit) • biblioteca, conjunto de subprogramas (procedures e/ou functions) destinados a solucionar uma série de tarefas bastante corriqueiras – verificação CPF e CNPJ – valor por extenso – operações com data –. . .

Objetivo das bibliotecas (unit’s) • reutilização de código • aumentar com o passar do tempo acrescentando de novos subprogramas de uso comum • no desenvolvimento de novos sistemas, procura-se ao máximo basear sua concepção em subprogramas já existentes na biblioteca, de modo que a quantidade de software realmente novo que deve ser desenvolvido é minimizada

Pascal, Estrutura básica de uma unit (1/2) unit Nome. Da. Unit; interface Cabeçalho da unidade- nome da unit. Deve ter o mesmo nome do arquivo fonte (*. pas). Comunicação entre dois meios (dispositivos). Contêm o cabeçalho dos procedimentos e funções declarados na unit, declaração de objetos globais e o uso de outras unidades. implementation Corpo dos procedimentos e funções anunciados na seção de interface e declarações de objetos locais. Obs não há necessidade da declaração dos parâmetros formais. end.

Pascal, Estrutura básica de uma Unit (2/2) • a primeira linha da unit identifica o nome da unit • deve ser um identificador válido na linguagem Pascal • deve ser igual ao nome dado a unit na hora da gravação unit Geral; unit Op. Data; Geral. Pas Op. Data. Pas

Cláusula Interface (1/2) • começa com a palavra interface e termina imediatamente antes da palavra-chave implementation • contém a definição de todos os tipos, constantes, variáveis, procedures e functions que devem ser "visíveis" (ou acessíveis) para outras units que se referenciem a esta • somente o que estiver definido na parte interface pode ser acessado por outras units

Cláusula Interface (2/2) • units listadas na cláusula uses da interface são geralmente adicionadas pelo próprio Delphi, para fazer referência a units do sistema (predefinidas) • raramente é necessário adicionar manualmente nomes de units a cláusula uses. Para se referenciar a outras units, altera-se a cláusula uses na parte implementation.

Cláusula Implementation • contém todo o código das procedures e functions da unit • pode conter também declarações de variáveis e constantes, mas estas só serão "visíveis" pelo código desta unit. Nenhuma outra unit pode ter acesso às variáveis e constantes declaradas aqui. • as units listadas nessa cláusula são geralmente adicionadas pelo programador, manualmente, ou usando o comando File | Use unit.

unit Geral; Cabeçalho da unidade, deve ser gravada com o nome Geral. pas. interface procedure Box(Li, Ci, Lf, Cf: integer); implementation uses Crt; procedure Box(Li, Ci, Lf, Cf: integer); var i: integer; begin gotoxy(Ci, Li); write(chr(201)); gotoxy(Cf, Li); write(chr(187)); gotoxy(Ci, Lf); write(chr(200)); gotoxy(Cf, Lf); write(chr(188)); for i: =Li+1 to Lf-1 do begin gotoxy(Ci, i); write(chr(186)); gotoxy(Cf, i); write(chr(186)); end; for i: =Ci+1 to Cf-1 do begin gotoxy(i, Li); write(chr(205)); gotoxy(i, Lf); write(chr(205)); end; end. interface, cabeçalho dos subprogramas da unit. implementação, corpo dos subprogramas da unit.

Compilação de unit’s • As units não são programas, portanto, não devem ser executadas (run). • As units devem ser compiladas da mesma maneira que os programas, destinando o resultado da compilação para disco (Compile - Destination). • Uma vez compiladas, as units serão armazenadas pelo Turbo Pascal em um arquivo do mesmo nome que a unidade fonte, porém com terminação TPU (Turbo Pascal Unit).

Utilização de unit’s • ao necessitar de algum procedimento ou função contido na unidade, deve-se chamála através da cláusula uses – uses Crt, Geral; • a unit deverá estar presente no diretório onde o programa, que for utilizá-la, for compilado ou no diretório padrão do Turbo Pascal (tp/units)

program Principal; uses Crt, Geral; utilizando a unidade de códigos Geral begin. Box(01, 24, 80); . end. chamando o procedimento Box declarado na unidade de códigos Geral

Delphi, Unidade de códigos (unit) • as Units contêm praticamente todo o código de um aplicativo no Delphi • as Units geralmente são associadas a formulários, mas podem ser criadas de forma totalmente independente – bibliotecas de códigos (reutilização) • File | New | Unit

File | New | Unit unit Unit 1; interface implementation end.

Cláusula Initialization • é opcional, e deve ser usada para declarar e inicializar variáveis • o código nesta parte é executado antes de qualquer outro código na unit • se um aplicativo tiver várias units, a parte initialization (se houver) de cada unit é executada antes de qualquer outro código na unit

Cláusula Finalization • é opcional, e o código nessa parte é executado logo antes do término do aplicativo • essa parte é geralmente usada para realizar "operações de limpeza", como recuperar memória e outros recursos, ao final da execução do aplicativo

Unidades e escopo • Em pascal as unidades são a chave para o encapsulamento e visibilidade. • O escopo de um identificador (tal como uma variável, procedimento, função ou tipo de dados) é a parte do código à qual o identificador está acessível: – Variáveis locais – Variáveis globais ocultas – Variáveis globais

Exemplos de escopos de identificadores: unit Nomeda. Unit; interface uses A, B, C; { outras unidades que são referenciadas } type, const, var { declarações exportadas, ou globais } procedure Meu. Procedimento; implementation type, const, var { declarações globais ocultas, visível somente nesta unit } procedure Meu. Procedimento; type, const, var { declarações locais, válidas somente para o procedimento } begin end; end.

Especificadores de Acesso em Object Pascal (definem a acessibilidade dos elementos do formulário: variáveis, procedimentos e funções, componentes, . . . ) type TForm 1 = class(TForm) private. . . { declarções privadas aqui} protected. . . { declarações protegidas aqui } public. . . { declarações públicas aqui } published. . . { declarações publicadas aqui } end;

Private, Protected e Public • Private – não são acessíveis de fora da unidade do form. • Protected: – somente o form atual e seus descendentes podem acessar os elementos. • Public: – são livremente acessíveis em todas as unit’s do projeto.

Published • um elemento publicado não somente está disponível em tempo de execução, mas também em tempo de projeto • componentes do Delphi têm uma interface publicada que é usada pelo Object Inspector • default

Unit <Nome_da_Unit>; Interface uses <lista_de_units>; type TForm 1 = class(TForm) bt. OK: TButton; . . . private A: <tipo>; public B: <tipo>; end; var Form 1: TForm 1; C: <tipo>; Implementation var D: <tipo>; function Soma(x, y: integer): var B, C, D: <tipo>; begin A : = <valor>; B : = <valor>; Form 1. B : = <valor>; C : = <valor>; D : = <valor>; end; { visível em todas as unit's do projeto } { visível somente nesta unit } integer; { { { Erro de compilação. Identificador ñ declarado } variável B é local (somente na função) } propriedade B do formulário } variável C é local (somente na função) } variável local, impossível acessar D externa } procedure TForm 1. bt. OKClick(Sender: TObject); var C, D: <tipo>; begin A : = <valor>; { propriedade A do objeto Form 1 } B : = <valor>; { propriedade B do objeto Form 1 } C : = <valor>; { variável C é local } D : = <valor>; { variável D é local } { impossível acessar as variáveis C e D externas } end; End.