Array erzeugt mit "new" => Realloc (Spielerei)


  • Mod

    camper schrieb:

    Eigentlich verwunderlich, dass das Programm beim delete nicht aussteigt.
    Immerhin zeigt oldArray nicht mehr auf den Anfang des alten Arrays.

    Solange der Wert der paar Bytes die vor der Adresse auf die oldArray zeigt liegen einen sinnvoll kleinen Wert hat, sollte das doch halbwegs gut laufen? Oder terminiert die libstdc++ mit einer Assertion o.ä. wenn das Argument an delete[] nicht in irgendeiner Liste ist?



  • Ok, also beide Versionen so gesehen Schrott.
    Aber das mit den referenzen und den **pointer ist "technisch" richtig?


  • Mod

    cpp_beginner_offl schrieb:

    Aber das mit den referenzen und den **pointer ist "technisch" richtig?

    Welchen Aspekt meinst du? Wie du überhaupt so etwas wie call by reference erreichst? Ja, das hast du richtig gemacht. Aber wenn du für so etwas noch eine Bestätigung brauchst, dann ist dein derzeitiges Projekt recht ambitioniert.

    PS: Das ist kein Vorwurf. Jeder war mal Anfänger. Aber es ist ein ernstgemeinter Hinweis, dass du dich übernimmst.



  • You make my Day !!! (very relaxed Mind "exclamation marks" 😃 )

    Mir war das wichtig, weil ich es alles ausm Kopf gemacht hab, ohne Referenzen usw . Die ** Thematik ist mir lange nicht leicht gefallen, darum freut mich das jetzt schon das es "wirklich" richtig ist.

    PS: Das ist kein Vorwurf. Jeder war mal Anfänger. Aber es ist ein ernstgemeinter Hinweis, dass du dich übernimmst.

    Ich hab das schon richtig verstanden. Und du hast da schon recht.
    Ich bin c++ ganz am anfang, und bin irgendwie drauf gekommen , das mit "realloc" jetzt mal zu probieren.

    Danke an alle die sich die Zeit genommen haben , mal drüber zu sehen!

    Ps.:
    noch eine "Style" Frage:

    newArray[i] = *(oldArray++);
           vs:
    newArray[i] = *oldArray++;
           vs:
    newArray[i] = *oldArray;
      oldArray++;
    

  • Mod

    Keines davon. Viel einfacher:

    newArray[i] = oldArray[i];
    

    Dann löst sich auch von ganz alleine das Problem, auf das camper hingewiesen hat.



  • Wohl war, ginge aber auch wenn ich mir oldArray wegspeichere und dann wieder zusweise, oder statt mit oldArray mit noch nem Zeiger auf oldArray arbeite oder? (Ist jetzt schon ziemlich sinnfrei);

    "Style" technisch (ohne Funktion usw zu berücksichtigen) sagt mir

    *oldArray++

    am besten zu



  • @Skym0sh0 : Danke, werde das die Tage auf jeden Fall testen!


  • Mod

    cpp_beginner_offl schrieb:

    Wohl war, ginge aber auch wenn ich mir oldArray wegspeichere und dann wieder zusweise, oder statt mit oldArray mit noch nem Zeiger auf oldArray arbeite oder? (Ist jetzt schon ziemlich sinnfrei);

    Gehen geht viel. Ob es ein guter Weg ist, ist eine andere Frage.

    "Style" technisch (ohne Funktion usw zu berücksichtigen) sagt mir

    *oldArray++

    am besten zu

    Von den drei Varianten ist das ja auch die kürzeste, ohne unnötiges Drumherum. Man darf durchaus voraussetzen, dass ein Leser die relative Priorität von zwei häufig vorkommenden Operatoren kennt.



  • Man darf durchaus voraussetzen, dass ein Leser die relative Priorität von zwei häufig vorkommenden Operatoren kennt.

    Schon. Naja, schön wärs 🙂 Also ich hatte letztens einen Rüffler wegen fehlender Kommentare bekommen und musste dann so "nachbessern" :

    Step7:

    U #Ini_aktiv  // Abfrage ob Ini aktiv ist
    spbn _N1     // Wenn nicht gehe zu _N1
    L P##Mask_1   // Pointer auf Mask_1 laden
    LAR1   // Lade Pointer Mask_1 ins Adressregister1
    L W[Ar1, P#2.0]   // Offset 2 Wörter
    T #Status _HMI        // Zustand aus Offset in Status anzeige für Bediener laden
    
    _N1: nop 0  // Tue nichts
    

    Leider geht noch keine "Klartextprogrammierung", aber scheinbar kennen nicht alle "Code-Anseher" auch die "gängigen Code Befehle", was sich durch Kommentare nicht ändet.

    Ok, das war jetzt ziemlich off Topic


  • Mod

    cpp_beginner_offl schrieb:

    Leider geht noch keine "Klartextprogrammierung",

    Ich C++ aber schon, daher nicht vergleichbar.



  • Jetzt hat sich doch noch eine Frage, bzw. Bitte aufgetan.

    In der Variante mit der Übergabe des **Pointers habe ich folgende "Variationen" ausprobiert:

    *(newArray+i) = *(*oldArray)++;    //v1
    newArray[i] = *(*oldArray+i);     //v2 
    newArray[i] = (*oldArray)[i];    //v3
    

    Also V1 und V2 hab ich mir selbt hergeleitet wie ich da dereffernzieren muss, und ist mir auch soweit klar.
    V3 hab ich durch probieren rausbekommen. Ist mir nicht ganz so klar.
    Kann mir jmd. mit dem dereferenzieren eines **ptr, bzw. die zusammenhänge bei V3 mal etwas auf die Sprünge helfen? BTW.: Hat jmd. einen Link, Buchvorschlag oder dergleichen wo solche Sachen anschaulich erklärt werden? Gerade bei der Klammerung hau ich oft nen Hund rein.

    Meine Erklärung für mich ist bei
    V1: ich will den Wert * von dem worauf (*oldArray) zeigt zuweisen und dann das, worauf *oldArray zeigt erhöhen.

    V2: ich will den Wert * von dem worauf (*oldArray plus "Offset i" ) zeigt zuweisen usw.

    V3: ich hab solange probiert bis es kompiliert hat und nicht abstürzt.

    (*oldArray)[i]; Mir ist jetzt schon klar das ich damit auf den Wert des "alten Arrays mit dem index i " zugreife, aber ich hatte sehr sehr abenteuerliche Klammersetzungen usw. dabei.....


  • Mod

    Reicht es dir, wenn ich dir sage, dass a[b] das gleiche ist wie *(a+b) ? Damit ist eigentlich alles erklärt, wenn du dich nicht davon abschrecken lässt, dass das "a" hier eben ein mehrteiliger Ausdruck ( *oldArray ) ist. Dass das * hier vor dem + zählt, kannst du in Tabellen zur Operatorpriorität nachgucken.



  • 👍 Danke


Anmelden zum Antworten