3. Array aus Referenzen erstellen

Array aus Referenzen erstellen

  • M

    Hallo zusammen,

    ich möchte gerne ein Array aus Referenzen erzeugen.
    Wenn ich das so mache klappt es wunderbar

    int * Array[8];
int * p = new int;
Array[0] = p;

    ich möchte aber gerne die Arraygrösse zur Laufzeit bestimmen
    die folgenden Idee funktioniert leider nicht

    int * Array = new int[Knoten];
int * p = new int;
Array [0] = p;

    kann mir jemand einen Tipp geben? Danke schön

    0
  • T
     

    int ** Array = new int*[Knoten];
int * p = new int;
Array [0] = p;
    0
  • W
     

    std::vector<int *> Vektor;
int* p = new int;
Vektor.push_back(p);
    0
  • M

    Perfekt, danke Dir TyRoXx!!
    @wx++ auch nicht schlecht aber der Ansatz von TyRoXx gefällt mir bisschen besser

    0
  • A

    Wie wx++ es gezeigt hat, ist es aber in C++ "richtig".
    Beim ersten Beispiel musst du den Speicher von Array später wieder mit delete[] freigeben, mit vector nicht.
    Die Größe des vectors kannst du dynamisch anpassen, die des Arrays nicht.

    0
  • ?

    meks-r schrieb:

    ich möchte gerne ein Array aus Referenzen erzeugen.

    Der C++ Standard sagt in §1.8 und §3.9 folgendes:

    [...] An object is a region of storage. [Note: A function is not an object regardless of whether or not it occupies storage in the way that objects do.] [...]

    [...] There are two kinds of types: fundamental types and compound types. Types describe objects (§1.8), references (§8.3.2), or functions (§8.3.5) [...]

    Array = ein oder mehrere Objekte desselben Typs, die hintereinander im Speicher stehen. Es gibt keine Arrays aus Referenzen, da Referenzen keine Objekt-Typen sind.

    meks-r schrieb:

    Wenn ich das so mache klappt es wunderbar

    int * Array[8];
int * p = new int;
Array[0] = p;

    ich möchte aber gerne die Arraygrösse zur Laufzeit bestimmen
    die folgenden Idee funktioniert leider nicht

    int * Array = new int[Knoten];
int * p = new int;
Array [0] = p;

    kann mir jemand einen Tipp geben?

    Im zweiten Fall ist Array kein Array sondern vom Typ Zeiger-auf-int. Array[0] dereferenziert diesen Zeiger und Du erhälst einen Lvalue-Ausdruck vom Typ int. Ein int ist aber nicht dazu da, Zeiger zu speichern. Obwohl Dir die weniger elegante Version

    int* * Array = new int*[Knoten];
Array [0] = new int;
...
delete Array[0];
delete[] Array;

    besser gefällt, rate ich Dir dazu, damit nur ein wenig zu experimentieren, bis Du es komplett verstanden hast und dann später folgendes vorzuziehen:

    std::vector<int*> vec;
vec.push_back(new int);
...
delete vec[0];

    Wenn's geht lass das Speichern von Zeigern ganz sein.

    0
  • M

    wieso soll das "richtig" bzw. "richtiger" sein?
    nur weil ich mich um den Speicher nicht mehr kümmern muss?
    oder Vector als eine Liste verwaltet wird?

    es macht mir das leben natürlich einfacher, aber ich sehe nicht was im Hintergrund mit Vector passiert.. deswegen wähle ich lieber die "durchsichtige" Variante

    Edit: Ich werde darüber noch mal nachdenken

    0
  • ?

    Bedauernswert; denn std::vector ist genau das, was Du willst: Ein "Array", dessen Größe zur Laufzeit festgelegt und geändert werden kann. Es besteht kein Grund, mit new[]/delete[]-Gefrickel anzufangen.

    0
  • M

    das geht ja auch mit der anderen Version. Ich würde dir ja zustimmen wenn ich die größe des Array mehrmals anpassen muss. Bei mir bleibt die Länge des Array allerdings immer gleich (nach dem die Grösse zur Laufzeit ermittelt werden ist).

    Wäre das nicht der Fall, so würde ich vector bevorzugen, da ja flexibler!

    0
  • B

    Es gibt überhaupt keinen Grund den vector nicht zu benutzen. Er bietet dir GENAU das gleiche was Dir ein array bietet. Wenn Du Dich mal einen Nachmittag damit beschäftigst, ist da auch überhaupt nichts undurchsichtiges dran.

    0
  • M

    ok werde ich machen! wenn mir das jetzt so viele sagen muss ja was dran sein.
    danke euch allen

    0
  • N

    meks-r schrieb:

    aber ich sehe nicht was im Hintergrund mit Vector passiert.. deswegen wähle ich lieber die "durchsichtige" Variante

    Wieso verwendest du dann std::cout ? Weisst du, wie das funktioniert? Oder kennst du die Implementierung von new ?

    Es ist keine schlechte Idee, von unwichtigen Mittel-zum-Zweck-Details wie manueller Speicherverwaltung zu abstrahieren. Je länger du programmierst, desto mehr wirst du Abstraktion (im Allgemeinen) zu schätzen lernen... 😉

    0
Anmelden zum Antworten