C++ Memory management via SharedPointer?

Bin gerade dabei (modern) C++ zu lernen und will dabei nun eine Collection erstellen.

Meine Idee war, dass ich eine Linkedlist habe, die auch als Stack etc. verwendet werden kann. Dafür hab ich ein Doppel linked Knoten.

Die Theorie für die Knoten ist soweit kein Problem, eher wie man die nun Modern managen würde. Erste Idee waren Sharedpointer zu verwenden, aber da ich eine Liste auch Klonen will, ohne die Referenzen zu sharen dachte ich eher an Unique Pointer.

Wie würdet ihr das machen? Das Item als Unique Pointer annehmen und dann das Ownership Transferieren? Oder Sharedpointer nutzen? Bin ich auf dem komplett falschen Weg? Bisher hab ich:

template<class T>
class CollectionNode {
private:
    std::shared_ptr<T> item_;
    std::shared_ptr<CollectionNode<T>> next_;
    std::shared_ptr<CollectionNode<T>> prev_;
public:
    explicit CollectionNode(std::shared_ptr<T> item) : item_(item), next_(nullptr), prev_(nullptr) {}

    CollectionNode(std::shared_ptr<T> item, std::shared_ptr<CollectionNode<T>> next,
                   std::shared_ptr<CollectionNode<T>> prev) : item_(item), next_(next), prev_(prev) {}

    std::shared_ptr<T> getItem() { return item_; }

    std::shared_ptr<CollectionNode<T>> getNext() { return next_; }

    std::shared_ptr<CollectionNode<T>> getPrev() { return prev_; }

    void setNext(std::shared_ptr<CollectionNode<T>> next) { next_ = next; }

    void setPrev(std::shared_ptr<CollectionNode<T>> prev) { prev_ = prev; }
};

Wenn wir schon dabei sind, könnte ich sagen, dass T ein bestimmtes "Interface" haben muss?

...zum Beitrag

"Modernes C++" bedeutet meinem Eindruck nach, möglichst auf die Standardbibliothek zurückzugreifen, sofern das Gesuchte denn dort schon implementiert ist. In diesem Fall kann einfach std::list verwendet werden, welche über die Methoden front() und back() verfügt und damit absolut geeignet für Dein Vorhaben ist. Um das Verhalten der Klasse darüber hinaus anzupassen, reicht hier ein Alias aus (C++20):

#include <concepts>
#include <list>

template<typename T> requires std::same_as<T, int>
using MeineListe = std::list<T>;

// MeineListe ist auf den Typ int beschränkt.

Wenn man unbedingt auf eine eigene Implementierung besteht, kann man auch gleich einfach raw pointer verwenden. Der einzige Unterschied ist in den meisten Fällen, dass man daran denken muss, new im Konstruktor und delete im Dekonstruktur aufzurufen:

template<typename T> requires std::same_as<T, int>
class Node
{
public:

    T* pItem;
    // ...
    Node(const T& item) : pItem(new T(item)) // ...

    ~Node() { delete this->pItem; }
}
...zur Antwort

Angesichts der Anzahl an bereits existierenden Frameworks lohnt sich ein solches Unterfangen rein materiell betrachtet sicherlich nicht. Das hat mich persönlich aber nicht davon abgehalten, neben dem Informatikunterricht in der Oberstufe ein solches Projekt zu starten.

Der Grund war simpel: Etwas eigenes zu erstellen ist ganz einfach cooler und verspricht Erfolgserlebnisse.

Und, nun ja, ich sitze jetzt wohl seit etwa 3 Jahren (mit monatelangen Pausen) an diesem Projekt und viel mehr als das Abbilden von Text ist noch nicht möglich. Es ist eben eine Sache, eine Programmiersprache zu verstehen und eine komplett andere, eine umfangreiche Anwendung strukturiert aufzubauen. Wie ich gemerkt habe, tendiert man außerdem auch sehr schnell dazu, das Rad neu zu erfinden, indem man zum Beispiel eine eigene String-Klasse schreibt mit Funktionen, die minimal besser auf die Anwendung abgestimmt sind. So hat man es am Ende womöglich nicht nur mit der Grafikschnittstelle zu tun, sondern auch mit Zeichencodierungen und Weiterem. Das kann sich durchaus als gewinnbringend herausstellen kann, aber trägt erstmal nichts zum Produkt an sich bei.

Sollte das nicht abschrecken, kann ich folgende Empfelungen aussprechen: Den Einstieg erleichterte mir damals die Serie über DirectX 11 von ChiliTomatoNoodle. Daneben hat TheCherno viele gute Erklärungen hinsichtlich der Programmiersprache und OpenGL auf seinem Kanal. Vielleicht erweisen sich diese Videos ja auch für Dich als nützlich. Die wichtigsten Bibliotheken wären wohl FreeType und Assimp. Ich wünsche viel Erfolg. :)

...zur Antwort

Das Buch „The Hate u give“ behandelt die Problematik, dass viele Menschen die Hautfarbe anderer missbrauchen, um Stereotype zu erhalten und thematisiert darüber hinaus Polizeibrutalität. Es geht vordergründig um dunkelhäutige Personen. Auch der Protagonist namens Starr ist dunkelhäutig und wohnt in dem Viertel, das von vielen anderen mit gleicher Hauptfarbe bewohnt wird. Dabei sehen sich diese dem Rassismus entgegengesetzt, der vor allem von Polizisten ausgeht. Der Onkel von Starr ist ein solcher, weswegen ich seine Charaktereigenschaften im Folgenden anhand von Textstellen analysiere.

...zur Antwort

Aus dem Integral dürftest Du den Faktor rausziehen, bevor Du integrierst.



Nach dem Integrieren (dem Bilden der Stammfunktion) geht das aber nicht mehr und es gelten die anderen Regeln, die Du so kennst. In diesem Fall könntest Du 1/3 ausklammern und somit die Klammer auflösen, weil sich dadurch das Ergebnis nicht verändert.

...zur Antwort
A

Person A, weil diese stets das gemacht haben wird, was sie wollte. Bei den anderen Optionen besteht die Möglichkeit, zu etwas gedrängt zu werden und Ähnliches.

...zur Antwort

Vielleicht kann Dir ja ein Arzt eine Aquaphobie attestieren, sodass Du nicht am Unterricht teilhaben musst? ^^

...zur Antwort

Meiner Ansicht nach zeichnet das Spiel eher eine Dystopie, also ein nicht allzu wünschenswertes Zukunftsszenario. Hier müssten also Argumente gefunden werden, weshalb die entsprechende Gesellschaftsordnung erstrebenswert wäre. So besteht im Spiel ein großes Problem im Hinblick auf die Arbeitslosigkeit. Abseits dieser Schwierigkeit ist das aber sicherlich sehr passend.

...zur Antwort

Versteck ihre Schuhe, falls das eine Option ist.

...zur Antwort