Speicher am Heap in einer Funktion freigeben?



  • Das Vorhaben selbst ist schon nicht gut. Nimm std::vector<int> und alles wird gut:

    #include <vector>
    
    int main()
    {
       int value = 815;
       std::size_t length = 4711;
       
       std::vector<int> my_data( 4711, 815 );
       int* data_ptr = my_data.data();
    }
    

    Die Übergabe von int und unsigned int als (const) Referenz macht keinen Sinn. Sofern sie nicht als Out-Parameter benutzt werden übergibt man atomare Datentypen in den allermeisten Fällen als Kopie. Hier gibt´s keinen Grund für eine Ausnahme.



  • @ledi001 sagte in Speicher am Heap in einer Funktion freigeben?:

    std::vector<int> array_constructor(const int &value, const unsigned int &length)
    {
    	std::vector<int> v( length, value );
    	return v;
    }
    


  • @manni66 sagte in Speicher am Heap in einer Funktion freigeben?:

    unsigned int
    

    std::size_t ftw.

    #include <cstddef>
    #include <vector>
    
    auto foo(int value, std::size_t length)
    {
    	return std::vector<int>(length, value);
    }
    

    Und das Übliche: Ein Pointer ist kein Array. Ein Array ist kein Pointer.



  • Dieser Beitrag wurde gelöscht!


  • @Swordfish
    auf deine Frage: WARUM new??

    Nun so habe ich es gelernt. Mit new wird Speicher am Heap freigegeben. Ist dem nicht so?



  • @ledi001 sagte in Speicher am Heap in einer Funktion freigeben?:

    Mit new wird Speicher am Heap freigegeben.

    Ne, mit new wird Speicher reserviert, mit delete wieder freigegeben. In modernem C++-Code sollte aber beides nicht mehr auftauchen.



  • @Swordfish
    Sorry, hab mich vertan. Ich meinte reserviert...
    Ich bin gerade dabei C++ zu lernen, daher spiele ich derzeit mit Arrays bzw. Array-Pointern herum.



  • @ledi001 sagte in Speicher am Heap in einer Funktion freigeben?:

    Ich bin gerade dabei C++ zu lernen, daher spiele ich derzeit mit Array herum.

    In deinem Code ist kein Array.


  • Mod

    @Swordfish sagte in Speicher am Heap in einer Funktion freigeben?:

    Ne, mit new wird Speicher reserviert, mit delete wieder freigegeben. In modernem C++-Code sollte aber beides nicht mehr auftauchen.

    Und auch in unmordernem C++ nicht. Eine der Hauptmotivationen für das Design von C++ war, die unsägliche manuelle Ressourcenverwaltung von C loszuwerden. Bloß haben dann viele schlechte Lehrer C in C++ programmiert (wenn ich printf mit cout ersetze und malloc mit new ist das doch C++?) und das auch noch weitergegeben. Offenbar auch heute noch.



  • @SeppJ sagte in Speicher am Heap in einer Funktion freigeben?:

    wenn ich printf mit cout ersetze und malloc mit new ist das doch C++?

    Tu die ++ weg.



  • @ledi001 sagte in Speicher am Heap in einer Funktion freigeben?:

    Ich bin gerade dabei C++ zu lernen, daher spiele ich derzeit mit Arrays bzw. Array-Pointern herum.

    Spiele lieber mit std::vector herum! Schau mal hier: https://en.cppreference.com/w/cpp/container/vector
    Ein Pointer ist ein Pointer und kein Array.
    Ein Array ist ein Array und kein Pointer.
    Ein Array kann automatisch in einen Pointer zerfallen (konvertiert werden). Umgekehrt nicht.



  • Und selbst wenn man keinen std::vector möchte, würde man keinen rohen Zeiger nehmen:

    #include <cstddef>
    #include <memory>
    #include <algorithm>
    
    auto foo(int value, std::size_t length)
    {
    	auto bar{ std::make_unique<int[]>(length) };
    	std::fill(bar.get(), bar.get() + length, value);
    	return bar;
    }
    

    Aber wahrscheinlich die Parameter umdrehen und ein Default vorgeben:

    #include <cstddef>
    #include <memory>
    #include <algorithm>
    
    template<typename T>
    auto foo(std::size_t length, T value = T{})
    {
    	auto bar{ std::make_unique<T[]>(length) };
    	std::fill(bar.get(), bar.get() + length, value);
    	return bar;
    }
    

    `



  • @SeppJ sagte in Speicher am Heap in einer Funktion freigeben?:

    Und auch in unmordernem C++ nicht. Eine der Hauptmotivationen für das Design von C++ war, die unsägliche manuelle Ressourcenverwaltung von C loszuwerden.

    Das ist historisch falsch. Die STL wurde erst relativ spät kreiert und wurde dann erst mit C++ 1998 Teil der Sprache. Die Verwendung von new und delete waren also vor C++ 1998 der Standard und nicht die Ausnahme. Da aber die Autopointer Klasse in C++ 1998 kaputt war, musste man noch viele Jahre auf die Verwaltung Resourcen in den eigenen Klassen setzen. Erst das Boost Projekt hat kann funktionierende Smart Pointer geliefert, die dann erst mit C++ 2011 Teil der Sprache wurden.


  • Mod

    @john-0 sagte in Speicher am Heap in einer Funktion freigeben?:

    @SeppJ sagte in Speicher am Heap in einer Funktion freigeben?:

    Und auch in unmordernem C++ nicht. Eine der Hauptmotivationen für das Design von C++ war, die unsägliche manuelle Ressourcenverwaltung von C loszuwerden.

    Das ist historisch falsch. Die STL wurde erst relativ spät kreiert und wurde dann erst mit C++ 1998 Teil der Sprache. Die Verwendung von new und delete waren also vor C++ 1998 der Standard und nicht die Ausnahme. Da aber die Autopointer Klasse in C++ 1998 kaputt war, musste man noch viele Jahre auf die Verwaltung Resourcen in den eigenen Klassen setzen. Erst das Boost Projekt hat kann funktionierende Smart Pointer geliefert, die dann erst mit C++ 2011 Teil der Sprache wurden.

    Und was haben STL und Autopointer damit zu tun? Lies dir die Interviews mit Stroustrup durch, bevor du hier anderen historische Fälschung vorwirfst. Alleine die Möglichkeit, das man in C++ die STL und Autopointer haben kann, zeigt dass die automatischen Destruktoren essentieller Teil des Sprachdesigns sind.



  • @Swordfish sagte in Speicher am Heap in einer Funktion freigeben?:

    std::size_t ftw.

    ...wohl eher ein Designfehler in der C++ Standard Bibliothek :o)



  • @HarteWare Da scheiden sich die Meinungen der Geister.



  • @SeppJ sagte in Speicher am Heap in einer Funktion freigeben?:

    Und was haben STL und Autopointer damit zu tun? Lies dir die Interviews mit Stroustrup durch, bevor du hier anderen historische Fälschung vorwirfst. Alleine die Möglichkeit, das man in C++ die STL und Autopointer haben kann, zeigt dass die automatischen Destruktoren essentieller Teil des Sprachdesigns sind.

    Templates wurden erst mit Cfront 3.0 eingeführt, das ist die letzte Version vor der ISO Norm und Basis der 2. Auflage von „The C++ Programming Language, 1991“. Das wurde aber auch erst Realität, weil unter anderem Alexander Stepanov (der wesentliche Schöpfer der STL) sehr stark darauf hin gearbeitet hat, und Ada artige generische Programmierungsfähigkeiten in C++ haben wollte. Die STL hatte nämlich mit den Booch Components (die Ada 83 Version) so etwas wie einen Vorgänger. D.h. so groß auch die Verdienste von Stroustrup bei der Erschaffung von C++ sind, der ganze Themenkomplex generische Programmierung wurde an ihn heran getragen und ist nicht auf seiner Initiative heraus entstanden.

    D.h. es gab zwar RAII seit der ersten Version von C++ (Cfront 1.0, 1985), aber weder Exceptions noch Templates in dieser frühen Form von C++. D.h. es waren weder Smart Pointer noch Container wie std::vector möglich.

    P.S. Das ist im Buch „Design and Evolution of C++“ nachlesbar, was man eigentlich als C++ Crack schon einmal gesehen haben sollte.



  • @john-0 sagte in Speicher am Heap in einer Funktion freigeben?:

    was man eigentlich als C++ Crack schon einmal gesehen haben sollte.

    Weder @SeppJ noch ich sind "C++ Crack"s. Aber wir wissen meistens, wovon wir reden. Wo du die Grenze zwischen modernem C++ und unmodernem ziehst ist mir herzlich schnuppe.


  • Mod

    @john-0 sagte in Speicher am Heap in einer Funktion freigeben?:

    @SeppJ sagte in Speicher am Heap in einer Funktion freigeben?:

    Und was haben STL und Autopointer damit zu tun? Lies dir die Interviews mit Stroustrup durch, bevor du hier anderen historische Fälschung vorwirfst. Alleine die Möglichkeit, das man in C++ die STL und Autopointer haben kann, zeigt dass die automatischen Destruktoren essentieller Teil des Sprachdesigns sind.

    Templates wurden erst mit Cfront 3.0 eingeführt, das ist die letzte Version vor der ISO Norm und Basis der 2. Auflage von „The C++ Programming Language, 1991“. Das wurde aber auch erst Realität, weil unter anderem Alexander Stepanov (der wesentliche Schöpfer der STL) sehr stark darauf hin gearbeitet hat, und Ada artige generische Programmierungsfähigkeiten in C++ haben wollte. Die STL hatte nämlich mit den Booch Components (die Ada 83 Version) so etwas wie einen Vorgänger. D.h. so groß auch die Verdienste von Stroustrup bei der Erschaffung von C++ sind, der ganze Themenkomplex generische Programmierung wurde an ihn heran getragen und ist nicht auf seiner Initiative heraus entstanden.

    D.h. es gab zwar RAII seit der ersten Version von C++ (Cfront 1.0, 1985), aber weder Exceptions noch Templates in dieser frühen Form von C++. D.h. es waren weder Smart Pointer noch Container wie std::vector möglich.

    P.S. Das ist im Buch „Design and Evolution of C++“ nachlesbar, was man eigentlich als C++ Crack schon einmal gesehen haben sollte.

    Nochmal: Und? Templates haben rein gar nichts mit RAII zu tun, welches, wie du selber bestaetigst, in der ersten Version drin war, und, wie ich dir schon gesagt habe, eine der Hautpmotivationen fuer C++ war.



  • Was aber bestätigt dass man vor der STL jedoch trotzdem das nackte new verwendet hat.


Anmelden zum Antworten