[Delphi] Hab ein paar Fragen zur Sprache

var
  Button: TButton;
begin
  Button:=TButton.Create(Form1);
  try
    with Button do 
    begin
      Parent:=Self;
      Left:=Random(Form1.ClientWidth-Width);
      Top:=Random(Form1.ClientHeight-Height);
      Caption:='Button';
    end;
  except
    Button.Free;
  end;
end;

[b]procedure[/b] tudas;
[b]begin[/b]
[COLOR=royalblue]//Das soll das Prog machen, wenn ich tudas aufrufe:[/COLOR] 
Form1.Color:=clred;
[b]end;[/b]

[b]procedure[/b] TForm1.Button1Click(Sender: TObject);
[b]begin[/b]
tudas; [COLOR=royalblue]// jetz wird das gemacht, was in der Prozedur tudas steht, wenn ich den Button1 klicke [/COLOR]
[b]end;[/b]

void main()
{
   for(...)
   {
       ...
   }
}

#define begin {
#define end }

void main()
begin
   for(...)
   begin
      ...
   end
end

#define SECUREFREE(x) free(x); x = NULL

#define SECURESIZEOF(x) sizeof(x) / sizeof(TCHAR)

// allocate 100 bytes
void* p = malloc(100);
// do something with the mem
...
// free the mem
SECUREFREE(p);  // the preprocessor will replace this with free(p); p = NULL;
// p is now NULL

class a
{
...
}

class b
{ 
...
}

class c : public a, public b
{
... // alles von a
... // alles von b
... // neues, was wir in c dazuimplementieren
}

c = class(a)

so:
TClasssC = class
  A: TClassA;
  B: TClassB;
end;

oder so:
TClassC = class(TClassA)
  B: TClassB;
end;

type NewType = array[a..b] of array[c..d] of int;

var
  Button: TButton;
begin
  Button:=TButton.Create(Form1);
  try
    with Button do 
    begin
      Parent:=Self;
      Left:=Random(Form1.ClientWidth-Width);
      Top:=Random(Form1.ClientHeight-Height);
      Caption:='Button';
    end;
  except
    Button.Free;
  end;
end;

// Ist jetzt halt nur 2D

interface

type RSchlumpf = record
  Name : string;
  Alter: integer;
end;

type TSchluempfe = array [0..10] of RSchlumpf;

implementation

procedure test(iSchluempfe: TSchluempfe);
begin
end;

a=class
  ...
end;

b=class
  ...
end;

// Wenn wir die nun beide in C implementieren wollen und das so machen würden

c=class
  ca: a;
  cb: b;
end;

// Haben wir ein Problem, wenn Funktionen von A auf Funktionen von C zugreifen sollen
// Ergo müssen wir erstmal noch haufenweise abgeleitete Klassen von A/B erstellen, so ungefähr

a1=class(a)
  parent: c;
  // Funktionen und deren Implementierung, wie wir es normalerweise in "class c: public a, public b" gemacht hätten
end;

b1=class(b)
  parent: c;
  // nochmal das selbe
end;

// und nun die endültige Implementierung bzw. die eigentlich richtige vererbung:
c=class
  ca: a1;
  cb: b1;
end;

interface a
{
  public:
    void x();
    void y();
};

class a
{
  public:
    virtual void x();
    virtual void y();
};
[/code

In C++. Nur implementiert man eben in Java ein Interface, und in C++ vererbt man die Klasse.
In Java kann man mehrere Interfaces implementieren, und in C++ kann man eben mehrere Klassen implementieren. Beide Varianten implementieren eine Schnittstelle, und keinerlei Code - anders als mit Mehrfachvererbung geht das in C++ nicht, genauso wie es eben nur über das Implementieren von mehreren Interfaces in Java geht. Desswegen hat die Mehrfachvererbung in C++ durchaus ihren Sinn.