Objeto Pascal

Objeto Pascal
Aula de idioma	linguagem de programação orientada a objetos , linguagem de programação multiparadigma , linguagem de programação imperativa, linguagem de programação estruturada [d] e linguagem de programação
Tipo de execução	compilado
Apareceu em	1986
Desenvolvedor	Tesler, Larry e Niklaus Wirth
Extensão do arquivo	.p, .ppou.pas
Tipo de sistema	estático , dinâmico (matriz de const, RTTI , Variant), estrito
Principais implementações	Delphi ( x86 e CLI ), Oxygene ( CLI ), Free Pascal ( x86 , x86-64 , PowerPC , ppc64 , SPARC e ARM ), Virtual Pascal ( x86 ), TMT Pascal ( x86 ), Turbo51 ( Intel 8051 )
Dialetos	Apple, Turbo Pascal , objfpc, Delphi , Delphi.NET, Oxygene
Foi Influenciado	Pascal e Smalltalk
influenciado	C# , Java , Nim

Object Pascal (do  inglês  -  “Object Pascal”) é uma linguagem de programação desenvolvida na Apple Computer em 1986 por um grupo de Larry Tesler , que consultou Niklaus Wirth . Derivado de uma versão anterior orientada a objetos do Pascal chamada Clascal que estava disponível no computador Apple Lisa .

Mudanças no Object Pascal da Borland comparado ao Turbo Pascal

As mudanças afetaram grupos dos tipos integer, character e string, que passaram a ser divididos em duas categorias:

• Tipos fundamentais . Sua representação na memória (número de bits e presença de um sinal) é estritamente fixa e mantida inalterada em todas as implementações subsequentes do Object Pascal para quaisquer sistemas operacionais e plataformas de computador.
• Tipos genéricos . Sua representação na memória não é fixa e será implementada de maneira otimizada, dependendo da implementação para um determinado sistema operacional e plataforma de computador.

Interfaces

Veja Interfaces: Delphi

Sobrecarga de procedimentos e funções (não-OOP)

Introduziu a sobrecarga de procedimentos e funções que não são membros de um objeto ou classe. Procedimentos e funções que diferem em tipos e número de parâmetros são sobrecarregados (usando a palavra-chave sobrecarga ):

procedimento  Calc ( I :  Integer ) ;  sobrecarga ; 
// ... 
procedimento  Calc ( S :  String ;  J :  Integer ) ;  sobrecarga ;

Matriz dinâmica

Introduzido para eliminar as operações de rotina de alocação e retorno de memória para a área de heap (heap), e para evitar erros aleatórios e vazamentos de memória. Os elementos da matriz devem ser do mesmo tipo. A numeração dos elementos começa do zero.

Exemplo de declaração:

var  MyFlexibleArray :  array  de  Real ;

Uso:

var 
  A ,  B :  array  de  Integer ; 
começar 
  SetLength ( A ,  1 ) ;  //Alocar memória para um elemento 
  A [ 0 ]  :=  1 ;    B  :=  A ; 
  B [ 0 ]  :=  2 ; 
fim ;

Desde o Delphi XE7, as seguintes ações com arrays dinâmicos se tornaram possíveis:

var  M :  array  de  inteiros ; 
começar 
  M  :=  [ 1 ,  2 ,  3 ,  4 ,  5 ] ; 
fim ;

 M  :=  M  +  [ 5 ,  6 ,  7 ] ; 
 Inserir ([ 6 ,  7 ,  8 ] ,  M ,  5 ) ;  // insere array [6, 7, 8], em M, começando no índice 5 
 Delete ( M ,  1 ,  3 ) ;  // remove 3 elementos começando no índice 1 
 Concat ([ 1 ,  2 ,  3 ,  4 ] ,  [ 5 ,  6 ,  7 ])

Ou seja, você pode trabalhar com arrays dinâmicos da mesma forma que com strings.

Em um array dinâmico, também é possível definir um array aberto de parâmetros, mas seu tipo deve ser declarado antes, por exemplo:

tipo  TDynamicCharArray  =  array  de  Char ; 
função  Localizar ( A :  TDynamicCharArray ) :  Integer ;

Digitação dinâmica

Verificação de tipo dinâmico e operadores de conversão

A linguagem Object Pascal da Borland introduziu a tipagem dinâmica , bem como o operador de conversão dinâmica as e o operador is para verificação de tipo dinâmico. Além disso, tornou-se possível passar parâmetros de vários tipos em uma matriz aberta de parâmetros (parâmetros de matriz aberta variante).

Tipo de variante

A linguagem Object Pascal introduziu um tipo de dados variante ( Variant ), cujo tipo não é conhecido na fase de compilação e pode mudar na fase de execução do programa. No entanto, esse tipo de dados consome mais memória do que as variáveis ​​correspondentes e as operações em dados Variant são mais lentas. Além disso, operações ilegais em dados desse tipo geralmente levam a erros no estágio de execução do programa, enquanto erros semelhantes em dados de outro tipo seriam detectados no estágio de compilação.

Variáveis ​​variantes podem assumir valores diferentes (integer, string, boolean, Currency , strings OLE), ser arrays de elementos do mesmo tipo e um array de valores do tipo variante, e também conter objetos COM e CORBA cujos métodos e propriedades podem ser acessadas através deste tipo. No entanto, uma Variante não pode conter:

• dados do tipo estrutural;
• ponteiros;
• Int64 (a partir do Delphi 6 - pode).

A variante pode ser misturada (em expressões e declarações) com outras variantes, dados numéricos, string e booleanos. Nesse caso, o compilador executa automaticamente a conversão de tipo. Variantes contendo strings, entretanto, não podem ser indexadas (V[i] não é permitido).

var 
  V1 ,  V2 ,  V3 ,  V4 ,  V5 :  Variante ; 
  I :  inteiro ; 
  D :  duplo ; 
  S :  Cadeia _ 
começar 
  V1  :=  1 ;  //valor do tipo inteiro 
  V2  :=  35 9.768 ;  //valor real 
  V3  :=  'Olá mundo!' ;  //valor do tipo string 
end ;

Parâmetros de tipo de matriz aberta variante

Tornou-se possível transferir parâmetros de vários tipos. No original, é chamado de "parâmetros de matriz aberta variante". O tipo de dados é determinado dinamicamente durante a execução do programa. Assim como em um array aberto normal, a função High é chamada para determinar o número de elementos do array. A declaração usa o array de palavras-chave const . Exemplo:

 saída da função ( const  Args :  array  de  const ) :  string ; 
var 
  I :  inteiro ; 
resultado inicial 
  := '' ; for I := 0 to High ( Args ) faça com Args [ I ] do case VType de vtString : Result := Result + VString ^; vtPChar : Resultado := Resultado + VPChar ; vtInteger : Result := Resultado + IntToStr ( VInteger ) ; vtBoolean : Resultado := Resultado + BoolToStr ( VBoolean ) ; vtChar : Resultado := Resultado + VChar ; vtExtended : Result := Resultado + FloatToStr ( VExtended ^ ) ; vtObject : Result := Resultado + VObject . ClassName ; vtClass : Resultado := Resultado + VClass . ClassName ; vtVariant : Resultado := Resultado + string ( VVariant ^ ) ; vtInt64 : Resultado := Resultado + IntToStr ( VInt64 ^ ) ; vtAnsiString : Resultado := Resultado + string ( VAnsiString ) ; vtCurrency : Resultado := Resultado + CurrToStr ( VCurrency ^ ) ; fim ;  
           
      
               
                
              
              
                 
             
               
                
              
                
           
             
    

  Resultado  :=  Resultado  +  ' ' ; 
fim ; 
//...

Saída ([ 'teste' ,  777 ,  '@' ,  True ,  3.14159 ,  TForm ]) ;  //passando um array aberto de parâmetros

A string será retornada: "teste 777 @ T 3.14159 TForm".

Como você pode ver, ele possui uma estrutura interna própria, cujo recurso permite determinar o tipo de dados. Uma matriz é criada na linha de chamada de função usando o construtor de matriz aberta , que usa colchetes.

Diferenças nos modelos de objetos

Para introduzir um novo modelo de objeto, a palavra-chave class é introduzida (no Turbo Pascal , a palavra- chave object ).

Operadores foram introduzidos para verificar e converter as classes is e as dinamicamente durante a execução do programa. Ponteiros de método apareceram, para os quais um novo uso da palavra-chave object foi introduzido :

digite 
  TMyMethod  =  procedimento  ( Remetente  :  Objeto )  do  objeto ;

Mudanças de sintaxe devido a mudanças no posicionamento do objeto

No Turbo Pascal era possível trabalhar com instâncias dinâmicas e estáticas de objetos.

No modelo de objeto Object Pascal, o programador trabalha apenas com instâncias dinâmicas de classes alocadas na área de heap (heap). A este respeito, a sintaxe para acessar campos e métodos de objetos foi alterada.

Anteriormente, para trabalhar com instâncias de objetos dinâmicos inicializadas usando acesso de construtor em combinação com a função New , você precisava usar acesso de ponteiro (^). Agora o tipo de classe também se tornou um ponteiro por padrão.

Exemplo para comparação:

Modelo de objeto em Turbo Pascal :

digite 
  PMyObject  =  ^ TMyObject ; 
  TMyObject  =  objeto  ( TObject ) 
    MyField  :  PMyType ; 
    construtor  Init ; 
  fim ; 
//... 
var 
  MeuObjeto  :  PMMeuObjeto ; 
begin 
  MeuObjeto  :=  Novo ( PMyObjeto , Init ) ; 
  MeuObjeto ^. MeuCampo  :=  //... 
fim ;

Novo modelo de objeto no Object Pascal :

tipo 
  TMyObject  =  class  ( TObject ) 
    MyField  :  TMyType ; 
    construtor  Criar ; 
  fim ; 
//... 
var 
  MeuObjeto  :  TMeuObjeto ; 
begin 
  MeuObjeto  :=  TMeuObjeto . criar ; 
  MeuObjeto . MeuCampo  :=  //... 
fim ;

A convenção de nomenclatura para construtores e destruidores foi alterada. No modelo de objeto antigo, chamar New era responsável por alocar memória e chamar um construtor inicializava a área de memória alocada. No novo modelo, essas ações são executadas pelo construtor Create . A partir da versão do Delphi XE, surgiram os métodos de classe estática.

Agora é possível restringir a visibilidade dos membros da classe (métodos, propriedades), que devem ser usados ​​apenas na implementação de classes derivadas. Isso torna possível proteger o código-fonte da modificação por usuários da classe. Esses métodos estão contidos na seção protegida da declaração de classe.

Programação visual orientada a objetos

Os conceitos de propriedade ( property ) e palavras-chave relacionadas à propriedade read , write , stored , default ( nodefault ), index . As propriedades de objetos visuais visíveis no IDE são declaradas usando a nova palavra publicada como uma seção na declaração da classe que é o objeto visual.

Generalizações

type 
  {declaration} 
  generic  TList < T >  =  class 
    Items :  array  de  T ; 
    procedimento  Add ( Valor :  T ) ; 
  fim ;

implementação 
  {implementação} 
  procedimento  TList . Adicionar ( Valor :  T ) ; 
  begin 
    SetLength ( Itens ,  Comprimento ( Itens )  +  1 ) ; 
    Itens [ Comprimento ( Itens )  -  1 ]  :=  Valor ; 
  fim ;

Uma classe genérica pode simplesmente ser especializada para um tipo específico usando a palavra- chave specialize :

tipo 
  TIntegerList  =  especializar  TList < Integer >; 
  TPointerList  =  especializar  TList < Pointer >; 
  TStringList   =  especializar  TList < string >;

Sobrecarga do operador

Os desenvolvedores do TMT Pascal (uma modificação do Object Pascal) foram os primeiros a introduzir a sobrecarga de operadores completa , que mais tarde foi adotada pelos desenvolvedores de outros dialetos da linguagem: Delphi (desde Delphi 2005), Free Pascal , etc.

Exemplo:

{declaração} 
tipo 
  TVector  =  registro compactado  A , B , C : Double ; procedimento From ( const A , B , C : Double ) ; operador de classe Add ( const Esquerda , Direita : TVector ) : TVector ; operador de classe Implícito ( const v : TVector ) : TPoint ; fim ;
       
         
          
         
  

{implementação} 
implementação 
//... 
  operador de classe  TVector . Adicionar ( const Esquerda , Direita : TVector ) : TVector ; startResult . _ A := Esquerda . A + Certo . A ; resultado . B := Esquerda . B + Direita . B ; resultado . C := Esquerda . C + Direita . C ; fim ;     
  
        
        
        
  

   operador  de classe TVector . Implícito ( const  v :  TVector ) :  TPoint ; 
  startResult 
    . _ A := rodada ( v . A ) ; resultado . B := rodada ( v . B ) ; fim ; //...  
      
  


{uso} 
var 
  v1 ,  v2 :  TVector ; 
iniciar 
  v1 . De ( 20 ,  70 ,  0 ) ; 
  v2 . De ( 15 ,  40 ,  4 ) ; 
  tela . Polígono ([ v1 ,  v2 ,  v1  +  v2 ]) ; 
fim ;

Suporte por vários desenvolvedores

A partir do Delphi 7, a Borland nomeou oficialmente o Object Pascal como Delphi .

A linguagem Object Pascal é mantida e desenvolvida por outros desenvolvedores. As implementações mais sérias do Object Pascal (além do Delphi) são o multiplataforma TopSpeed ​​Pascal (versão em linguagem Turbo Pascal ) do ambiente multilíngue TopSpeed , TMT Pascal , Virtual Pascal , PascalABC.NET , Free Pascal , GNU Pascal . A linguagem de programação Oxygene é um dialeto de Object Pascal para a plataforma .NET e seu desenvolvimento posterior, e os novos recursos da linguagem são o operador ":", chamadas de método assíncronas e diferidas, execução de bloco de código assíncrono, loops paralelos, construtores anônimos, elementos de contrato e programação orientada a aspectos e outros (o compilador é distribuído sem restrições).

Exemplos de Olá, mundo! » em várias extensões de linguagem de objeto

Object Pascal da Apple

programa  ObjectPascalExample ;

digite 
  THelloWorld  =  procedimento de objeto 
    Put ; fim ; 
  

var 
  HelloWorld :  THEelloWorld ;

procedimento  THEloWorld . colocar ; 
begin 
  WriteLn ( 'Olá, Mundo!' ) ; 
fim ;

beginNew 
  ( HelloWorld ) ; _ olá mundo . colocar ; Descarte ( HelloWorld ) ; fim .
  
  

TurboPascal

Delphi (para compatibilidade com versões anteriores) e Free Pascal também suportam essa sintaxe.

programa  ObjectPascalExample ;

typePHelloWorld 
  = ^ THEelloWorld ; _  THelloWorld = procedimento de objeto Put ; fim ; 
    
     
  

var 
  HelloWorld :  PHelloWorld ;  { é um ponteiro para TheloWorld }

procedimento  THEloWorld . colocar ; 
begin 
  WriteLn ( 'Olá, Mundo!' ) ; 
fim ;

beginNew 
   ( HelloWorld ) ; _ ola mundo ^. colocar ; Descarte ( HelloWorld ) ; fim .
   
   

Delphi e Free Pascal

No Free Pascal esta sintaxe está disponível nos modos ObjFpc e Delphi .

programa  ObjectPascalExample ;

digite 
  THelloWorld  =  class                     { definição de classe } 
    procedure  Put ; 
  fim ;

procedimento  THEloWorld . colocar ;                { descrição do procedimento do método Put da classe THelloWorld } 
begin 
  Writeln ( 'Hello, World!' ) ; 
fim ;

var 
  HelloWorld :  THEelloWorld ;                { definição de uma variável de ponteiro para uma instância de uma classe }

begin 
  HelloWorld  :=  THEelloWorld . criar ;       { construtor retorna o valor de um ponteiro para uma instância da classe } 
  HelloWorld . colocar ; 
  olá mundo . Grátis ;                        { destructor destrói a instância da classe e libera a área de memória } 
end .