Delphi vs C++

[nunopicado]

Só curiosidade... Qual o mais legível? 😉

program Project1;

uses
 Vcl.Forms,
 Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

begin
 Application.Initialize;
 Application.MainFormOnTaskbar := True;
 Application.CreateForm(TForm1, Form1);
 Application.Run;
end.




//**************************************************
//**************************************************
//**************************************************



unit Unit1;

interface

uses
 Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
 Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
 TForm1 = class(TForm)
   Edit1: TEdit;
   Button1: TButton;
   procedure FormCreate(Sender: TObject);
   procedure Button1Click(Sender: TObject);
 private
   { Private declarations }
 public
   { Public declarations }
 end;

var
 Form1: TForm1;

implementation

{$R *.dfm}

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

procedure TForm1.FormCreate(Sender: TObject);
begin
    Edit1.Text:='Olá Mundo';
end;

end.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <tchar.h>
//---------------------------------------------------------------------------
USEFORM("Unit1.cpp", Form1);
//---------------------------------------------------------------------------
int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
   try
   {
       Application->Initialize();
       Application->MainFormOnTaskBar = true;
       Application->CreateForm(__classid(TForm1), &Form1);
       Application->Run();
   }
   catch (Exception &exception)
   {
       Application->ShowException(&exception);
   }
   catch (...)
   {
       try
       {
           throw Exception("");
       }
       catch (Exception &exception)
       {
           Application->ShowException(&exception);
       }
   }
   return 0;
}
//---------------------------------------------------------------------------




//**************************************************
//**************************************************
//**************************************************



//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   ShowMessage(Edit1->Text);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
   Edit1->Text="Olá Mundo";
}
//---------------------------------------------------------------------------

Edited February 2, 2013 at 09:51 PM by thoga31
Correcção do GeSHi

[thoga31]

É sabido que Pascal e, por conseguinte, Delphi foram feitos a pensar na sua legibilidade, algo bom para principiantes. Escrevem-se uns quantos begin e end, mas um bom editor de texto também é capaz de tomar bem conta do recado. Na sua essência, um programa nestas LP's permite que seja facilmente lido e interpretado.

Por sua vez, C++, que deriva directamente do C, foi feito a pensar numa sintaxe compacta. A legibilidade fica muitas vezes comprometida, e podem surgir algumas dúvidas em relação a outras coisas devidas a essa "simplicidade".

Alguém que programe em C++ olhará para os códigos e irá perceber melhor o de C++, possivelmente. Mas quem não conhece nem Delphi/Pascal nem C/C++ (esta condição não é comum concretizar-se, penso) poderia ler mais facilmente, talvez, o código em Delphi. Mas isso também iria depender um pouco das LP's a que estivesse habituado.

É uma questão de gostos.

[Rui Carlos]

Não sou especialista em C++, mas parece-me que estão aí coisas que são extensões ao C++ (__classid, __fastcall?).

Suspeito também que isso seja código escrito para uma biblioteca/framework específica (pelo que há sempre a questão de se saber se o problema é da biblioteca/framework, ou do C++). Apesar de tudo, não vejo grande diferença. Estou mais habituado a C, pelo que percebo melhor o C++ que o Delphi.

Para além da utilização abusiva de directivas de pré-processamento que é feita no C++, a única diferença significativa é o try ... catch, que me parece que contribui para tornar explícito o comportamento da função caso ocorra uma excepção (e pergunto-me se não daria para remover esses blocos).

Tem ali o construtor do TForm que está feito de uma forma que eu pessoalmente não gosto muito (mas podia ser mudado).

Também é preciso ter em conta que falta aí o código do .h (o que adicionaria ainda mais código ao C++).

De qualquer modo, devo dizer que acho o C++ uma linguagem demasiado complexa (muito mais complexa que o C, mas também muito mais poderosa), e por isso prefiro usar C sempre que possível, mas acho que esse exemplo não ilustra a complexidade do C++.

[nunopicado]

Rui: Ambos foram "escritos" em Delphi/C++ Builder respectivamente, apenas com a inclusão de um TEdit, um TButton, e a chamada do ShowMessage no evento onclick do TButton. Tudo o resto foi adicionado de raíz pelos respectivos RAD IDE's.

A ideia nem era mostrar a complexidade do C++, embora "todos" saibamos que é grande. Lá está, quem estiver habituado ao C++ possivelmente compreende-o melhor do que ao Delphi, e vice-versa.

A ideia é mais ver a legibilidade por quem não conhece nenhuma. 🙂

[Rui Carlos]

Há pouco enquanto tentava ver de onde vinha o __classid (que apesar de ser fácil prever a sua função, nunca tinha visto antes), cheguei a uma página que falava da Visual Component Library (VCL) e do C++Builder. E a ideia com que fiquei é que o exemplo dado era código feito para usar a VCL, que parece ser escrita em Object Pascal. Ainda não tinha percebido que era código gerado automaticamente.

Posto isto, não sei exactamente qual é a conclusão que pretendes tirar dos resultados que obtiveres, mas assumindo que a informação que obtive está correcta, há aqui três pormenores que me parecem importantes:

- o código C++ é código feito para usar uma biblioteca escrita noutra linguagem (logo é de esperar que tenha complexidade desnecessária relacionada com os bindings, ou com adaptações necessárias para o C++ se adaptar ao "estilo" da outra linguagem);

- código gerado automaticamente não é suposto ser lido, mas sim ser eficiente (pelo que comparar código gerado automaticamente não é uma actividade da qual seja adepto);

- quem desenvolve as ferramentas parecem ser empresas que apostam mais no Pascal/Delphi do que no C++.

Assim, se a ideia for analisar a legibilidade do Delphi e do C++, parece-me que os códigos apresentados vão produzir resultados muito pouco fiáveis.

[apocsantos]

Boa noite,

Consigo ler ambos os códigos sem dificuldade. Estou habituado a Delphi, tal como estou habituado a C++.

Tirando o try catch em C++ que salta à vista e no código Delphi, não está, poderia estar um "try ... finally ... except on E: Exception ...", o resto parece-me demasiado parecido.

Ambos estão feitos para VLC, que é claramente melhor suportada pelo Delphi do que pelo C++, pois foi desenvolvida a pensar no Delphi e no Kylix. De resto ambos os códigos são bastante legiveis. Não sei se para quem não está familiarizado com nenhuma das linguagens ou pelo menos com nenhuma "parecida com C" , o código Delphi, não pareça mais legivel.

Cordiais cumprimentos,

Apocsantos

[nunopicado]

Rui: O C++ Builder existe desde 97 e é, digamos, o descendente directo do Borland Turbo C, onde aqui o Je aprendeu a programar em C (estou a ficar velho hehehe).

Daí que a minha tendencia em IDE/Compilador para C/C++ seja sempre este! 🙂

A VCL é uma framework nativa ao Delphi/C++ Builder, e pode dizer-se que é a base da .NET, uma vez que um dos principais responsáveis por esta última se mudou da Borland para a Microsoft, depois de ter desenvolvido a VCL (Anders Hejlsberg).

Trata-se no fundo de uma Framework de wrappers para os componentes nativos do Windows, e nela assenta quase toda a programação em Delphi/C++ Builder (se bem que nas últimas versões, eles já tenham outras frameworks nativas que supostamente representam o futuro destes dois ambientes RAD - a mim ainda não me convenceram que sejam melhores que a excelente VCL). Visto que o C++ Builder está preparado de raíz para a usar (ao contrário de outros dialetos C++), não me parece que a performance seja um problema.

A ideia de colocar aqui estes dois mini-códigos, é só mesmo mostrar como duas linguagens irmãs (Delphi evoluiu do Turbo Pascal, C++ Builder do Turbo C) conseguem fazer a mesma coisa de forma distinta (no que ao olho humano destreinado diz respeito).

O Delphi baseia-se numa lógica simples e organizada, termos em inglês específicos e legíveis. O C++ é mais técnico, mais exigente, mais símbolos.

Pessoalmente, tendo estudado Pascal e C, e depois apostado no Delphi como linguagem principal, acabei por nunca enveredar pelo C++ (e aqui entre nós, por esquecer muito do que aprendi em C, onde já não programo desde que o Quick C era top), olho agora para estes dois códigos e leio, literalmente, o código Delphi, como se de Julio Verne se tratasse. Já o código C++ dá-me a sensação de estar a ler os Lusíadas, com um olho tapado para melhor encarnar o personagem.

A ideia de meter aqui... Olha, era só para ouvir mais opiniões! 😉 Afinal, sempre mexe o quadro!

Edited February 4, 2013 at 01:14 AM by nunopicado

[apocsantos]

Bom dia,

É pah somos uma cambada de velhos! Também aprendi C no Turbo C ... e Pascal no Turbo Pascal (que ainda se encontra muito à frente do FreePascal). Quanto à VLC estava com a ideia de que tinha sido feita nativamente para Delphi, apesar de já ter encontrado alguma informação sobre ela em sentido contrário.

De qualquer das formas, se não fosse o try ... catch que no delphi falta o "try ... finally ... except on E: Exception ...", acho que entre um e outro, não se notariam grandes diferenças, a não ser mesmo para quem não está familiarizado com linguagens parecidas com C, que provávelmente acharia mais simples ler o código em Delphi, dadas as suas semelhanças a inglês. Em contra-partida o código em C, seria como ler "Os Lusiadas, traduzidos em latim e com uma pala no olho".

Cordiais cumprimentos,

Apocsantos

[Rui Carlos]

Não percebo muito de C++ (raramente o usei), mas desde a primeira vez que olhei para o código que fiquei com a impressão que tinha lá coisas desnecessárias, que em situações normais, um programador não utilizaria. Não sei se o código Delphi podia também podia ser melhorado, mas o código C++ é mau.

Os 3 pontos que apontei pareceram-me explicações plausíveis para tal situação. Mas mesmo que não sejam essas as explicações, mantenho o meu ponto: o código C++ é mau, e comparações com código mau podem resultar em conclusões erradas. É como comparar a performance de duas linguagens, sem que se use o melhor código em ambas as linguagens.

Um código escrito à mão parece-me que podia ficar muito próximo do código Delphi (o que seria de esperar, para um código tão simples). De um modo geral, acredito que o código Delphi será mais legível que o C++ (é mais verboso).

[nunopicado]

Efectivamente, ambos os códigos podem ser melhorados, pois dada a extrema simplicidade do exemplo, não é necessário tantas units/includes.

No caso do Delphi, ficaria assim:

program Project1;

uses
 Vcl.Forms,
 Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

begin
 Application.Initialize;
 Application.CreateForm(TForm1, Form1);
 Application.Run;
end.


//************************************************************************


unit Unit1;

interface

uses
 Vcl.Forms, Vcl.Dialogs, System.Classes, Vcl.Controls, Vcl.StdCtrls;

type
 TForm1 = class(TForm)
   Edit1: TEdit;
   Button1: TButton;
   procedure Button1Click(Sender: TObject);
 end;

var
 Form1: TForm1;

implementation

{$R *.dfm}

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

end.

E em C++ Builder

#include <vcl.h>
#include <tchar.h>

USEFORM("Unit1.cpp", Form1);

int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int)
{
Application->Initialize();
Application->CreateForm(__classid(TForm1), &Form1);
Application->Run();
return 0;
}



//*************************************************************



#include <vcl.h>
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)
{
}

void __fastcall TForm1::Button1Click(TObject *Sender)
{
ShowMessage(Edit1->Text);
}

Uma coisa me salta à vista porém...

É que no Delphi, os componentes criados na form (neste caso, um TButton e um TEdit) são declarados no próprio código Delphi, enquanto no C++, estes não são declarados, estando criados apenas no Resource File unit1.dfm

Quer isto dizer que, a não ser que edite o DFM, ou se esteja no editor da form (felizmente integrado no IDE), não temos como saber quais os componentes que temos disponíveis para usar, ao passo que em Delphi, basta olhar para a declaração da Form ao inicio, para se conhecer os seus componentes criados em Designtime.

Claro que ninguém é obrigado a usar o Designtime para fazer as forms. Seja em C++ ou em Delphi, tudo pode ser feito em Runtime. Mas perdia-se o conceito RAD.

[Rui Carlos]

Uma coisa me salta à vista porém...

É que no Delphi, os componentes criados na form (neste caso, um TButton e um TEdit) são declarados no próprio código Delphi, enquanto no C++, estes não são declarados, estando criados apenas no Resource File unit1.dfm

Em situações normais, isso fica no .h (que como referi acima, não foi mostrado). Este é um dos pontos que menos me agrada no C++: a separação entre a definição da classe e a implementação dos métodos (e que obriga a colocar o TForm1:: antes de cada método). No C parece-me aceitável, em C++ nem por isso :\ (e em qualquer dos casos, separa coisas que deviam aparecer juntas).

PS: Já dá gosto olhar para o C++ 😄

[nunopicado]

heheheh