C++ / Delphi

[rüdiger]

Ich muss zZ. auch mit Object Pascal arbeiten. Also wenn du C++ programmieren kannst, ist es leicht mit Object Pascal zu arbeiten, du musst dir nur mal die Hilfe angucken, da steht alles drin was du brauchst (wenn du vorher schon mit dem BCBuilder gerabeitet hast, sollte es wohl noch leichter sein, denke ich). Du musst dich nur öfter mal mit den unzulänglichkeiten von Delphi rumprügeln, die IMHO Delphi für größere Projekte ungeeignet erscheinen lassen bzw. ganz andere Konzeptionierung verlangen, aber für ein "mal eben ne GUI für mein schickes C++ BackEnd", finde ich es ganz praktisch.

(einige Dinge die mich stören:

-Variablen müssen zu Begin einer Funktions/Procedut Definition deklariert werden (man kann wohl auch keine neuen Scopes eröffnen, wie es ADA anbietet )
-IDE Dominanz (alles muss man über die IDE machen, für die OP Klassen gibt es sogar ein "Zugriffsregulator" um damit die IDE zu steuern )
-Durch die fehlenden geschweiften klammern geht die Übersicht IMHO schnell verloren
-Man kann den Iterator in for Schleifen nicht manipulieren
-Die Semikolons werden nicht konsequent durchgesetzt

if bla=blub then
tue //kein ; !
else
mache;

-Bei Funktionsaufrufen ohne Argument muss man keine leeren () setzen, was es IMHO wieder unübersichtlicher macht
-Zuweisungsoperator ist := und nicht =, dabei werden Zuweisungen viel heufiger benutzt als Vergleiche!
-Es gibt keinen speziellen Operator für inkrementieren und dekrementieren (ich hasse es wenn man folgendes schreiben muss variable := variable + 1;)
-Mit Klassen habe ich noch nicht gearbeitet, aber man muss AFAIK den Konstruktor und den Destruktor explizit aufrufen!
...)

[Taurin]

Original erstellt von Luckie:
**@Taurin: Ich weiß nicht, eas du hast. Was sollte den deiner meinung nach sonst rauskommen? Du weißt zum Schluß dem ersten Element von von a2 5 zu. Was soll also rauskommen, als a[0] := 5; ?
**

Das ist so auch richtig. Ich weise bloß an einer Stelle a2[0] den Wert 3 zu,
und siehe da, a1[0] bekommt diesen Wert auch....

kingruedi:
Es gibt keinen speziellen Operator für inkrementieren und dekrementieren (ich hasse es wenn man folgendes schreiben muss variable := variable + 1]

Wie wärs mit inc(Value) und dec(Value) bzw. inc(Value,n) und inc(Value,n) ?
Das entspricht Value++, Value--, Value += n, Value -= n. Auch wenn ich die
C++ Variante ein wenig hübscher finde, ist doch immer noch besser als Value := Value + n, oder?

Der := Operator ist übrigens aus der Mathematik geklaut, wo er eben für Zuweisungen gebraucht wird.

Ansonsten beschreibst du ziemlich genau meine Vorbehalte gegen Delphi. Vor allem
die "Oberflächlichkeit" der IDE. Alles geht von der Form aus, der Code rückt
stellenweise in den Hintergrund.

Wie wärs mit dem Beitrag für die FAQ, viel kann man zum Thema "Delphiübersicht für C++'ler" nicht mehr sagen, oder?

[japro]

ich hab mich mal auf ne diskussion mit ein par pascal fans über objpascal vs c++ eingelassen, es kam ungefähr das raus (ich war in unterzahl ):

Original erstellt von kingruedi:
**
-Variablen müssen zu Begin einer Funktions/Procedut Definition deklariert werden (man kann wohl auch keine neuen Scopes eröffnen, wie es ADA anbietet )
**

das machte laut denen den code wartbarer weil man genau weiss wo man was nachschauen muss.
[/QB][/QUOTE]

**
-IDE Dominanz (alles muss man über die IDE machen, für die OP Klassen gibt es sogar ein "Zugriffsregulator" um damit die IDE zu steuern )
-Durch die fehlenden geschweiften klammern geht die Übersicht IMHO schnell verloren
**

durch die vielen sonderzeichen is c++ angeblich unlesbar. begin... end erkennt man viel besser
zitat von keine ahnung wem:"c+ programmierer können ihre programme nur verstehen Pascal programmierer können sie lesen."

**
-Man kann den Iterator in for Schleifen nicht manipulieren
**

die haben mir unbedingt weismachen sollen das das fehlen dieser geschlossenen iteration ein grosser nachteil von c++ ist. hä?

**
-Die Semikolons werden nicht konsequent durchgesetzt

if bla=blub then
tue //kein ; !
else
mache;

-Bei Funktionsaufrufen ohne Argument muss man keine leeren () setzen, was es IMHO wieder unübersichtlicher macht
**

das spart aber tipparbeit...

**
-Zuweisungsoperator ist := und nicht =, dabei werden Zuweisungen viel heufiger benutzt als Vergleiche!
**

das ist mathematisch irgendwie korrekter und liegt wohl dran das der pascal erfinder mathe professor war (oder?)

**
-Es gibt keinen speziellen Operator für inkrementieren und dekrementieren (ich hasse es wenn man folgendes schreiben muss variable := variable + 1;)
**

hmmm also in turbopascal gabs inc() und dec() die genau das gemacht haben aber das is auch zu viel zu schreiben find ich. aber angeblich sind es gerade die vielen operatoren und sonderzeichen die c++ so unlesbar machen...

**
-Mit Klassen habe ich noch nicht gearbeitet, aber man muss AFAIK den Konstruktor und den Destruktor explizit aufrufen!
...)**

edit: n par fehlerkorrigiert....

[ Dieser Beitrag wurde am 05.01.2003 um 15:55 Uhr von japro editiert. ]

[Ein ehemaliger Benutzer]

-Variablen müssen zu Begin einer Funktions/Procedut Definition deklariert werden (man kann wohl auch keine neuen Scopes eröffnen, wie es ADA anbietet )

Das kann so wohl ein Nachteil, als auch ein Vorteil sein. Das mit den neuen Scopes ist natürlich nicht möglich. Aber wie übersichtlich wird eine Funktion, wenn ich innerhalb derselben zwei Variablen deklariere mit gleichen Namen, die sich nur in der Sichtbarkeit unterscheiden?
Desweiteren finde ich es übersichtlicher, wenn die Variablendeklarationen nicht in der ganzen Funktion verstreut sind, aber das ist ansichts Sache.

-Durch die fehlenden geschweiften klammern geht die Übersicht IMHO schnell verloren

Ein fettes begin und end sehe ich aber besser, als so eine mickrige geschweifte Klammer.

-Die Semikolons werden nicht konsequent durchgesetzt

Das stimmt allerdings. Aber Die Entwickler werden eventuell ihre Gründe gehabt haben.

-Bei Funktionsaufrufen ohne Argument muss man keine leeren () setzen, was es IMHO wieder unübersichtlicher macht

Dann mach doch welche. Es hindert dich keiner dran. :p

-Zuweisungsoperator ist := und nicht =, dabei werden Zuweisungen viel heufiger benutzt als Vergleiche!

Was mathematisch auch korrekt ist. Oder könntest du das so stehen lassen:

i = i+1

Das ist schlicht und ergreifent mathematisch falsch, da kannst du mir erzählen was du willst. Desweiteren, wenn man ":=" für eine Zuwseiung nimmt hat man "=" frei für den Vergleich und so wird es auch in der Mathematik verwendet.

-Mit Klassen habe ich noch nicht gearbeitet, aber man muss AFAIK den Konstruktor und den Destruktor explizit aufrufen!
...)

Was spricht da gegen? Im wirklichen Leben entsteht auch nichts aus dem nichts. Bevor ich mit dem Bleistift schreiben kann, muß der auch erstmal hergestellt / erschaffen werden.

-Man kann den Iterator in for Schleifen nicht manipulieren

Womit bei einer for-Schleife eine Gefahrenquelle ausgeschaltet wäre und wenn ich ihn verändern muß, nehme ich eine while-Schleife, wozu sie auch da ist.

[ Dieser Beitrag wurde am 05.01.2003 um 21:11 Uhr von Luckie editiert. ]

[C++arsten]

Hier ist ein Vergleich von C++ und Delphi:
[url] http://ourworld.compuserve.com/homepages/praxisservice/kapit0.htm[/url]

[C++arsten]

Im Übrigen bin ich ganz der Ansicht, dass der Delphi-Zuweisungsoperator := sinnvoller ist als das = heitszeichen. Und das = heitszeichen in Delphi ist mathematisch exakter als das doppelte == in C++.

Eine Frage: Kennt Delphi Container, wie etwa den <vector>? Wenn nein, wie wird dort dynamisch Speicher alloziert? Mit new?

[Taurin]

Delphi unterstützt dynamische Arrays:

var a :array of integer;

setlength(a,length(a)+1);

Diese dyn. Arrays verfügen aber nicht über die breite Auswahl an
Hilfsfunktionen wie ein std::vector (Einfügen und Löschen von Elementen,
Iteratorn).
In Delphi gibt es auch keine (mitgelieferte) map-Klasse. Es ist auch nur
sehr schwer, sich eine eigene zu schreiben, da Delphi keine Templates unterstützt.

[frager]

ein riesen prob ist es -> also bei pascal ist das so bei delphi sicherlich! auch
[code]
if a=1 then b:=2; c:=4; <- geht nich...

nur so:

if a=1 then begin b:=2; c:=4; end; <-*igitt*

[Gerard]

@<frager> ist doch gut das es form freie sprache ist

[frager]

Original erstellt von Dimah:
@<frager> ist doch gut das es form freie sprache ist

wie bitte

kann das mal einer auf dumm'sch sprache übersetzten ich kapiers nich

[nep]

Original erstellt von <frager>:
**ein riesen prob ist es -> also bei pascal ist das so bei delphi sicherlich! auch
[code]
if a=1 then b:=2; c:=4; <- geht nich...

nur so:

if a=1 then begin b:=2; c:=4; end; <-*igitt***

lol das geht genauso wenig in c, da müsstest du halt
[cpp]
if (a==1)
{
b=2;
c=4;
}[/code]

schreiben...ausser du machst es halt mit dem sequenz operator, aber das hast du oben sicher nicht gemeint

aber ich finde unter begin/end leidet die übersichtlichkeit schon stark bei richtig verschachtelten ausdrücken

[frager]

ich meinte das man bei mehreren anweisungen hinter "then" immer ein begin..end machen muss.

hab aber ausversehn (jetzt erst gemerkt) gesehn das ich die {} klammern beim ersten vergessen habe

ist aber auch egal da das ja schon jemand gesagt hatte

[nep]

das musst du doch bei c genauso wenn du mehre anweisungen in deinem "then-zweig" hast, nur anstatt begin/end eben {}

[ja]

aber einmal das then ist nicht da und das begin weil das ist sooo groß! und das stört einfach...

BTW: ich sagte doch ich hab die {} vergessen (beim ersten..)

[Th3Law]

Hallo,

als Delphianer muss ich mich jetzt mal einmischen

[quote=japro]
die haben mir unbedingt weismachen sollen das das fehlen dieser geschlossenen iteration ein grosser nachteil von c++ ist. hä?[/quote]

Du wirst mir doch wohl hoffentlich zustimmen, dass es in einer Programmiersprache verschiedene Schleifentypen gibt.

Diese kann man in zwei untergliedern. Nämlich:

• Schleifen mit bekannter Iterationsanzahl (for - schleifen)
• Schleifen mit unbekannter Iterationsanzahl (while - schleifen)

Es dürfte doch wohl einleuchtend sein, dass man bei Schleifen des ersten Typs nicht innherhalb des Anweisungsblocks die vorher bekannte Iterationsanzahl verändern darf. Aber genau dies ist in C++ möglich. Somit existieren in C++ nur Schleifen des zweiten Typs und Schleifen des ersten Typs lassen sich nur emulieren.

Folgendes kannst du nicht 1:1 in C++ übersetzen

var
  I: Integer;
begin
  I := 5;
  for I := 0 to I do
  begin
    // Do Something;
  end;
end;

[quote=Luckie]
Und ich weiß, dass Arrays Pointer sind
[/quote]

Arrays ist ein Felder von Variablen...

[quote=C++arsten]Eine Frage: Kennt Delphi Container, wie etwa den <vector>? Wenn nein, wie wird dort dynamisch Speicher alloziert? Mit new? [/quote]

Natürlich kennt Delphi Container wie z.b. TList, TObjectList, TStringList.

Dynamischer Speicher reserviert man in ObjectPascal (oder neu: Delphi - Language) mit Dynamischen Arrays (bereits erwähnt), GetMem oder mit New:

var
  P: Pointer;
  IntPtr: ^Integer;
begin
  GetMem(P, 20); // Reserveriert 20 Bytes; 

  New(IntPtr); // Reserviert eine IntegerVariable 4 Bytes

  Dispose(IntPtr); // Gibt InegerVariable Frei;

  FreeMem(P); // Gibt dynamischen SpeicherBlock frei

  // Bei dynamischen Arrays muss keine Freigabe erfolgen, da ein Interner
  // Reference Counter mitgeführt wird

[quote=Taurin]Diese dyn. Arrays verfügen aber nicht über die breite Auswahl an
Hilfsfunktionen wie ein std::vector (Einfügen und Löschen von Elementen,
Iteratorn).[/quote]

Dazu fällt mir nur ein: Keine Ahnung haben und trotzdem mitreden wollen.

[quote=frager]ein riesen prob ist es -> also bei pascal ist das so bei delphi sicherlich! auch

if a=1 then b:=2; c:=4; <- geht nich...
nur so:

if a=1 then begin b:=2; c:=4; end; <-*igitt*

[/quote]

Dir ist schon der Unterschied zwischen einer Anweisung und einem Anweisungsblock bekannt?

mfg
Th3Law

[ Dieser Beitrag wurde am 06.01.2003 um 01:58 Uhr von Th3Law editiert. ]

[ Dieser Beitrag wurde am 06.01.2003 um 02:00 Uhr von Th3Law editiert. ]

[WebFritzi]

So. Jetzt muss ich mich hier auch mal einmischen. Scheinbar bist du dir nicht ganz im Klaren, was du da schreibst, Th3Law. Das meiste ist Humbuk.

var
I: Integer;
begin
I := 5;
for I := 0 to I do
begin
// Do Something;
end;
end;

Was ist das denn?! Wenn da I von 0 bis 5 iteriert wird, dann ist das mehr als unlogisch. Da ziehe ich doch

int i;
for(i = 0; i<=5; ++i)
   // Do Something

doch um einiges vor. Und das Ergebnis ist das gleiche. Kommentare werden in Pascal übrigens per {} gemacht!

[quote=Luckie]
Und ich weiß, dass Arrays Pointer sind

Arrays ist ein Felder von Variablen...
[/quote]
Guter deutsch. Egal. Du hast recht und Luckie hat recht. Aber was ist denn ein Feld? Wie sieht denn sowas im Speicher aus? Kannst du mir das verraten? Wahrscheinlich nicht, denn wenn du das wüsstest, dann wüsstest du auch, dass ein Array nichts anderes als ein Pointer ist. Auch in Pascal!

[quote=C++arsten]Eine Frage: Kennt Delphi Container, wie etwa den <vector>? Wenn nein, wie wird dort dynamisch Speicher alloziert? Mit new?

Natürlich kennt Delphi Container wie z.b. TList, TObjectList, TStringList.
[/quote]
Das sind nichts anderes als Listen. Schonmal was von Templates gehört?

[quote=Taurin]Diese dyn. Arrays verfügen aber nicht über die breite Auswahl an
Hilfsfunktionen wie ein std::vector (Einfügen und Löschen von Elementen,
Iteratorn).

Dazu fällt mir nur ein: Keine Ahnung haben und trotzdem mitreden wollen.
[/quote]
Gleichfalls! Wobei das auch auf Taurin zutrifft, denn TList verfügt schon über solche Methoden (Add, Delete, ...).

[quote=frager]ein riesen prob ist es -> also bei pascal ist das so bei delphi sicherlich! auch

if a=1 then b:=2; c:=4; <- geht nich...
nur so:

if a=1 then begin b:=2; c:=4; end; <-*igitt*

Dir ist schon der Unterschied zwischen einer Anweisung und einem Anweisungsblock bekannt?
[/quote]
Ja, genau darum ging es <frager>!

[C++arsten]

Ich bin sogar der Ansicht, dass ein begin und end deutlicher sein kann als die geliebten Klammern, von denen hier gesprochen wird.

for (int i=0; i<5; i++)
    {
        //tu was
    }

ist doch nicht unbedingt übersichtlicher als (tun wir mal so, als gäb es das)

for (int i=0; i<5; i++)
    begin
        //tu was
    end

Da begin und end bei Delphi etwa fett gedruckt sind, wird die Syntax sogar noch hervorgehoben.

[rüdiger]

Desweiteren finde ich es übersichtlicher, wenn die Variablendeklarationen nicht in der ganzen Funktion verstreut sind, aber das ist ansichts Sache.

ich finde es sehr übersichtlich, wenn ich nicht ständig an den Anfang einer Funktion scrollen musss um zu wissen was für Variablen das sind (kommt mir jetzt nicht mit ungarischer Notation! Da Scroll ich lieber als mir so etwas an zu tun!), vorallem ist es performanter, wenn man nicht 1000 Objekte konstruiert, die man gar nicht braucht im Nachhinein.

Ein fettes begin und end sehe ich aber besser, als so eine mickrige geschweifte Klammer.

Wofür kann man seine Programme einrücken? (BTW. stört mich das die Delphi/Kylix IDE das nicht automatisch macht, ich hab keine Lust die hälfte meiner Arbeit damit zu verbringen die Aufgabe zu erledigen, die eigentlich meine IDE/Editor machen sollte

Dann mach doch welche. Es hindert dich keiner dran. :p

Wenn man pech hat, muss man mal den Code von anderen Leuten lesen und wenn man noch mehr pech hat, wurden die irgend wie dran gehindert diese Klammern zu machen

Was mathematisch auch korrekt ist. Oder könntest du das so stehen lassen:

i = i+1

Das ist schlicht und ergreifent mathematisch falsch, da kannst du mir erzählen was du willst. Desweiteren, wenn man ":=" für eine Zuwseiung nimmt hat man "=" frei für den Vergleich und so wird es auch in der Mathematik verwendet.

Mathematisch wär auch das korrekter 1 : 2 aber da bin ich bei noch einem Punkt der mich an (O)Pascal stört, die Operatoren sind teilweise unterschiedlich, Fließkommazahlen dividier ich mit / und Integers mit div und Mod gibt es nicht für Reals dafür wandelt man mit StrToFloat von String nach Real die Zahlen um (noch mehr )

Was spricht da gegen? confused Im wirklichen Leben entsteht auch nichts aus dem nichts. Bevor ich mit dem Bleistift schreiben kann, muß der auch erstmal hergestellt / erschaffen werden.

ich lass mir die Bleistifte immer Herstellen Aber mal im Ernst, angenommen du verlässt den Scope eines Objektes und du musst immer drauf achten den Destruktor explizit aufzurufen und angenommen du weisst nicht genau ob ein Objekt initalisiert wurde (Weil der Bezeichner existiert ja immer, dank der voraus deklaration).

[Taurin]

Original erstellt von Th3Law:
**
[quote=C++arsten]Eine Frage: Kennt Delphi Container, wie etwa den <vector>? Wenn nein, wie wird dort dynamisch Speicher alloziert? Mit new?**

**

Natürlich kennt Delphi Container wie z.b. TList, TObjectList, TStringList.

Dynamischer Speicher reserviert man in ObjectPascal (oder neu: Delphi - Language) mit Dynamischen Arrays (bereits erwähnt), GetMem oder mit New:

var
  P: Pointer;
  IntPtr: ^Integer;
begin
  GetMem(P, 20); // Reserveriert 20 Bytes; 

  New(IntPtr); // Reserviert eine IntegerVariable 4 Bytes

  Dispose(IntPtr); // Gibt InegerVariable Frei;

  FreeMem(P); // Gibt dynamischen SpeicherBlock frei

  // Bei dynamischen Arrays muss keine Freigabe erfolgen, da ein Interner
  // Reference Counter mitgeführt wird

[quote=Taurin]Diese dyn. Arrays verfügen aber nicht über die breite Auswahl an
Hilfsfunktionen wie ein std::vector (Einfügen und Löschen von Elementen,
Iteratorn).[/quote]

Dazu fällt mir nur ein: Keine Ahnung haben und trotzdem mitreden wollen.
**[/QUOTE]

Und wie willst du in eine TList Integer speichern? Oder Reals? Oder Chars?
Geht nicht. Dafür brauchst du plötzlich dyn. Arrays, die besagte Operationen
nicht direkt unterstützen. Du kannst natürlich Pointer auf Integer in der TList
unterbringen, dann hast du aber wieder ein Stück Speicherverwaltung mehr am
Hals.

Dynamische Arrays sind Pointer. Schaut euch noch mal das Beispiel von mir
ganz oben im Threat an.

Th3Law, hättest du das gelesen und dir die Mühe gamacht, dies zu verstehen,
wär dir das wohl aufgefallen.
Ausserdem würde dir ein etwas höflicherer Ton auch nicht schaden.

Zum Thema Variablendeklaration:
Die Bequemlichkeit mag hier eine Rolle spielen. In Delphi hab ich alle
Deklarationen auf einem Haufen und kann sie mir auf einmal anschauen,
dafür kommt ein Stück Scrollarbeit auf mich zu.
Das ist aber zweitrangig. In C++ wird der Speicher für Variablen erst dann
reserviert, wenn sie gebraucht werden. Nämlich in dem Block, in dem sie
deklariert werden. In Delphi muss zwangsweise bei einem Procedure-Aufrufe
der Speicher für alle Variablen der Procedure belegt werden, auch wenn einige
davon nicht gebraucht werden.

[ Dieser Beitrag wurde am 06.01.2003 um 13:02 Uhr von Taurin editiert. ]

[Th3Law]

Hallo,

Was ist das denn?! Wenn da I von 0 bis 5 iteriert wird, dann ist das mehr als unlogisch

Nein es ist vollkommen logisch. Jeder der auch nur das geringste Ahnung von Informatik hat wird mir hier zustimmen.

Allerdings würde ich folgende Variante vorziehen

for I := 0 to 5 do
begin
  // ...
end;

Kommentare werden in Pascal übrigens per {} gemacht!

Für die, die es noch nicht mitbekommen haben: Wir führen hier keine C / Pascal weder noch eine C++ / Pascal sondern eine C++ / ObjectPascal Diskussion.

Ich frage mich, wie jemand, der nur sehr geringfügige Sprachkenntnisse hat einem, der offensichtlich um einiges mehr an Sprachkenntniss besitzt darauf hinzuweisen, obwohl er nicht die geringste Ahnung davon hat, dass es ein Sprachkonstrukt, was in jedem Quelltext vorkommt, in einer Sprache nicht exisitert, die überhaupt nicht zur Diskussion steht.

Aber was ist denn ein Feld?

Ein Speicherblock bestimmter Größe.

Wie sieht denn sowas im Speicher aus?

Es ist eine kompakte zusammenhängende Datenstruktur (im Gegensatz zu Bäumen oder verketteten Listen)

Das sind nichts anderes als Listen.

std::vector ist doch auch nicht sehr viel anderes als eine Liste.

Schonmal was von Templates gehört?

Ja.

ich finde es sehr übersichtlich, wenn ich nicht ständig an den Anfang einer Funktion scrollen musss um zu wissen was für Variablen

Darüber kann man sich streiten, ich denke beides ist nur reine Gewohnheitssache.

vorallem ist es performanter, wenn man nicht 1000 Objekte konstruiert, die man gar nicht braucht im Nachhinein

Objekte werden in Delphi, eh dynamisch erstellt.

Und wie willst du in eine TList Integer speichern? Oder Reals? Oder Chars?

< 10 Minuten Zeit zum umschreiben benutzen.

Dafür ist im Gegensatz zu Templates höhere Typensichereit gewährleistet.

Geht nicht

*lach*

Dafür brauchst du plötzlich dyn. Arrays

*lach*

Du kannst natürlich Pointer auf Integer in der TList

Was meinst du mit Pointer auf Integer ??

Dynamische Arrays sind Pointer

Arrays sind und bleiben Felder von Variablen.

Nur wurde hier mithilfe eines Pointers, dynamischer speicher reserviert und verändert.

mfg
Th3Law