class bla
{
  int* ptr;
  public:
    bla : ptr(new ptr[3]), ref(ptr[0]){};
    ~bla(){delete[] ptr];
    int& ref;
};

hi, ist das hier legaler cpp code?

Nein, der Code ist illegal. Bitte keinen gesetzlich verbotenen Code posten.

@Polizei: musste so lachen

Was soll ref(ptr[0]) heißen?

Na, dass sich ref auf ptr[0] bezieht.

[Rewind] schrieb:

@Polizei: musste so lachen

Ja, der war echt gut!

class bla
{
  int& ref;
  int* ptr;
  public:
    bla : ptr(new int[3]), ref(ptr[0]){};
    ~bla(){delete[] ptr};
};

So ging es nicht.

class bla
{
  int& ref;
  int* ptr;
  public:
    bla : ptr(new int[3]), ref(ptr[0]){};
    ~bla(){delete[] ptr};
};

Es kompiliert, aber es sauft ab, meinst du?
Die Member der Klasse werden in der Reihenfolge ihrer Dekleration in der Klasse und nicht in der Reihenfolge in der Initialisierungsliste initialisiert. ref erhält also den Wert ptr[0] bevor ptr überhaupt einen Wert hat. Folge: ref zeigt ins Nirvana.
Einfach in der Klasse die Deklerationen von ref und ptr vertauschen, dann funktioniert das auch.

[Rewind] schrieb:

@Polizei: musste so lachen

Ja, der war echt gut!

ich auch :DDD
und ich bin immer noch dran

class bla
{
    int& ref;
    int* ptr;

public:
    bla()
    :ptr(new int[3])
    ,ref(ptr[0])
    {}

    ~bla()
    {
        delete[] ptr;
    }
};

Auch ein Konstruktor darf Argumente übernehmen, und eine Anweisung endet mit ';'. Kann es sein, dass dir Klassen noch neu sind?

int& ref;
    int* ptr;

Ach ja, die Deklarationen noch vertauschen. Sonst gibt es meines Wissens Probleme, weil die Referenz nach nirgendwo zeigt, weil trotz der Reihenfolge der Zuweisung die Deklaration entscheidend ist. Die Referenz bekommt einen (fehlerhaften) Wert, dann bekommt der Zeiger seinen Speicher, und die Referenz hat das nachsehen.

Aber wenn ich du wäre, würde ich den Quatsch mit der Referenz sein lassen. Was hält dich davon ab,

ptr[0]

zu schreiben?