3. Array vom Typ Klasse?

Array vom Typ Klasse?

  • T

    Nexus schrieb:

    Thilo87 schrieb:

    Übrigens musst du, wenn du ein Array mit "typ identifier[] ;" deklarierst, zur Laufzeit noch Speicher allozieren mit "identifier = new typ[ dim ] ;" und nicht vergessen, den Speicher wieder freizugeben mit "delete[] identifier ;", wenn du ihn nicht mehr brauchst.

    Nein. Arrays und Zeiger sind komplett verschiedene Dinge. Das Resultat von new[] wird Zeigern zugewiesen, nicht Arrays.

    Fast vollständig "doch". Nur dass man "typ identifier[] ;" kein Array nennt, sondern einen Zeiger. Ein dynamisches Array wird aus dem Speicher, wo der Zeiger *identifier hinzeigt, wenn man es alloziert.

    Damit sind 2 Aussagen von mir richtig, und eine Bezeichnung falsch. Die Antwort "Nein." passt da nicht. Besser wäre es gewesen, wenn du auf meine falsche Bezeichnung hingewiesen hättest, dann wäre deine Antwort auch konstruktiv etwas wert gewesen.

    0
  • N

    Supercomputer schrieb:

    Mir wurde in einem anderen Forum gesagt, dass Vektoren langsamer als Arrays sein, stimmt das?

    Da es bei einer Physikengine bei einer zunehmenden Anzahl an Objekten immer noch schnelle Berechnungen geben sollte.

    Das Problem an solchen Mythen ist, dass man Bruchstücke davon mitbekommt, und dann ohne die Hintergründe zu verstehen irgendwelche total fragwürdigen Entscheidungen trifft. Wie du z.B. Arrays statt den sinnvolleren STL-Containern einsetzen willst, obwohl sie kein bisschen für deinen Einsatzzweck geeignet sind, nur weil du mal was gehört hast.

    Wenn du eine Physikengine schreibst, dann befasse dich bitte ernsthaft mit den zugrunde liegenden Mechanismen. Kenntnisse der STL und Datenstrukturen im Allgemeinen ist absolut unumgänglich bei einem solchen Unterfangen.

    Thilo87 schrieb:

    Nur dass man "typ identifier[] ;" kein Array nennt, sondern einen Zeiger.

    Falsch. Einzig und allein in Parameterlisten trifft das zu, aber definitiv nicht als Member.

    Thilo87 schrieb:

    Ein dynamisches Array wird aus dem Speicher, wo der Zeiger *identifier hinzeigt, wenn man es alloziert.

    Es ging aber um statische Arrays. Geht es eigentlich immer, wenn man nichts dazu sagt, der Begriff "Array" ist genügend klar im Standard definiert.

    Thilo87 schrieb:

    Damit sind 2 Aussagen von mir richtig gewesen

    Nein, sorry. Die Aussage zur manuellen Speicherverwaltung mag zwar stimmen, ging aber am Thema vorbei.

    0
  • N

    Thilo87 schrieb:

    Nexus schrieb:

    Thilo87 schrieb:

    Übrigens musst du, wenn du ein Array mit "typ identifier[] ;" deklarierst, zur Laufzeit noch Speicher allozieren mit "identifier = new typ[ dim ] ;" und nicht vergessen, den Speicher wieder freizugeben mit "delete[] identifier ;", wenn du ihn nicht mehr brauchst.

    Nein. Arrays und Zeiger sind komplett verschiedene Dinge. Das Resultat von new[] wird Zeigern zugewiesen, nicht Arrays.

    Fast vollständig "doch".

    Fast vollständig nicht.
    Die einzige Gemeinsamkeit ist operator[].

    Nur dass man "typ identifier[] ;" kein Array nennt, sondern einen Zeiger.

    typ identifier[] nennt man auch nicht Zeiger, das nennt man illegal.

    §3.9/5 schrieb:

    A class that has been declared but not defined, or an array of unknown size or of incomplete element type, is an incompletely-defined object type.
    Incompletely-defined object types and the void types are incomplete types (3.9.1). Objects shall not be defined to have an incomplete type.

    0
  • S

    Dann ist die Frage geklärt.
    Ich wollte jetzt keine Diskussion oder gar einen Streit auslösen.

    Verstehe ich das richtig, dass Vektoren immer dynamisch sind?
    Und was gibt es da besonders zu beachten (Initialisierung, Zugriff usw.)? 😕

    Mit freundlichen Grüßen
    Supercomputer

    0
  • N

    Supercomputer schrieb:

    Verstehe ich das richtig, dass Vektoren immer dynamisch sind?

    Ja.

    Und was gibt es da besonders zu beachten (Initialisierung, Zugriff usw.)? 😕

    Nichts, das ist ja das tolle.
    Du musst lediglich beim Zugriff im definierten Bereich bleiben, wie sonst auch, aber ansonsten erledigt der alles für dich.
    Beispiel:

    // Erstelle ein vector von 5 ints, die mit 0 initialisiert werden.
std::vector<int> vec(5);
// Setze das dritte Element auf 1
vec[2] = 1;
// Füge eine Element hinten an (sehr effizient)
vec.push_back(3);
// Lösche die ersten beiden Elemente (ineffizient)
vec.erase(vec.begin(), vec.begin() + 2);
// Füge vorne eine Element an (ineffizient)
vec.insert(vec.begin(), 1);
// Ändere seine Größe auf 2
vec.resize(2);

    Für weitere Funktionen, siehe hier: http://en.cppreference.com/w/cpp/container/vector

    0
  • S

    Nathan schrieb:

    // Erstelle ein vector von 5 ints, die mit 0 initialisiert werden.
std::vector<int> vec(5);
// Setze das dritte Element auf 1
vec[2] = 1;
// Füge eine Element hinten an (sehr effizient)
vec.push_back(3);
// Lösche die ersten beiden Elemente (ineffizient)
vec.erase(vec.begin(), vec.begin() + 2);
// Füge vorne eine Element an (ineffizient)
vec.insert(vec.begin(), 1);
// Ändere seine Größe auf 2
vec.resize(2);

    Für weitere Funktionen, siehe hier: http://en.cppreference.com/w/cpp/container/vector

    Das mit der Effizienz kannst du dir auch ganz gut merken, Anweisungen, die "aufwendiger" zu schreiben sind (wie etwas Geschichte mit begin() und sonstwas), sind Pi*Daumen ineffizient. Das stimmt natürlich nicht immer. Aber wenn du die STL mal etwas besser kennst und auch die Konzepte dahinter (z.B. Iteratoren) dann kannst du das ganz gut abschätzen.

    0
  • S

    Danke für die Hilfe, Vektoren scheinen perfekt geeignet zu sein.

    Jedoch schaffe ich es nicht, einen Vektor vom Typ einer eigenen Klasse wie mobject an zu legen.

    Obwohl Dinge wie:

    mobject test;
test.methode();

    Funktionieren 😕

    0
  • N

    Es wird dir nicht viel bringen, wenn wir dir die Syntax für ein ganz spezifisches Problem zeigen, solange du die Grundlagen dazu nicht verstehst.

    Wie gesagt:

    Wenn du eine Physikengine schreibst, dann befasse dich bitte ernsthaft mit den zugrunde liegenden Mechanismen. Kenntnisse der STL und Datenstrukturen im Allgemeinen ist absolut unumgänglich bei einem solchen Unterfangen.

    Also nimm dir ein gutes Buch und fange an, du brauchst auch viel weniger Zeit als wenn du hier alles nachfragst 🙂

    0
  • N

    Was heißt "schaffst du nicht"?
    Fehlermeldung? Auf einmal nicht in der Lage die Tastatur zu nutzen, so sehr du es auch versuchst (dann solltest du vielleicht zu einem Psychologieforum wechseln)? Der Rechner geht immer aus? ...?

    0
  • S

    Zunächst ein Denkfehler 😞

    Ich bekomme jetzt den Vektor wie folgt angelegt:

    std::vector<mobject> mobjects(); // Wenn ich in den '()' eine Zahl herein schreibe, erscheint die Meldung: unexpectet token `('

    Lass ich die Klammer leer und versuche nun in der .cpp Datei darauf zuzugreifen, bekomme ich die Meldung: '((phy*)this)->phy::mobjects' does not have class type

    😕

    0
  • K

    Das ist eine Funktionsdeklaration. Mach die Klammern weg.

    0
  • B

    Und was sollen die Klammern da, machst du das bei anderen Variablen auch?

    0
  • S

    Nathan schrieb:

    Du musst lediglich beim Zugriff im definierten Bereich bleiben, wie sonst auch, aber ansonsten erledigt der alles für dich.
    Beispiel:

    // Erstelle ein vector von 5 ints, die mit 0 initialisiert werden.
std::vector<int> vec(5);
// Setze das dritte Element auf 1
vec[2] = 1;
// Füge eine Element hinten an (sehr effizient)
vec.push_back(3);
// Lösche die ersten beiden Elemente (ineffizient)
vec.erase(vec.begin(), vec.begin() + 2);
// Füge vorne eine Element an (ineffizient)
vec.insert(vec.begin(), 1);
// Ändere seine Größe auf 2
vec.resize(2);

    Für weitere Funktionen, siehe hier: http://en.cppreference.com/w/cpp/container/vector

    Schreibe ich es ohne die (),

    std::vector<mobject> mobjects;

    Bekomme ich folgende Meldung raus:
    error: 'mobject' was not declared in this scope
    error: template argument 1 is invalid
    error: template argument 2 is invalid

    Durch die Meldung "'mobject' was not declared in this scope"
    Habe ich folgendes gemacht:

    mobject mOBJECT;
    std::vector<mOBJECT> mobjects;

    Und bekomme diese Meldungen:

    ../phy.h:75:13: error: invalid use of non-static data member 'phy::mOBJECT'
    ../phy.h:76:17: error: from this location
    ../phy.h:75:13: error: invalid use of non-static data member 'phy::mOBJECT'
    ../phy.h:76:17: error: from this location
    ../phy.h:76:17: error: 'phy::mOBJECT' cannot appear in a constant-expression
    ../phy.h:76:24: error: template argument 1 is invalid
    ../phy.h:76:24: error: template argument 2 is invalid

    😮 😕

    0
  • K

    Du hast den Header nicht inkludiert, der mobject definiert.

    0
  • S

    Doch, habe ich

    0
  • N

    Ok, beide Header verwenden die selben include guards.

    0
  • C

    Supercomputer schrieb:

    mobject mOBJECT;
    std::vector<mOBJECT> mobjects;

    Und bekomme diese Meldungen:

    ../phy.h:75:13: error: invalid use of non-static data member 'phy::mOBJECT'
    ..😮 😕

    std::vector<mobject> mobjects;

    In die spitzen Klammern kommt der Typ.

    0
  • S

    Caligulaminus schrieb:

    Supercomputer schrieb:

    mobject mOBJECT;
    std::vector<mOBJECT> mobjects;

    Und bekomme diese Meldungen:

    ../phy.h:75:13: error: invalid use of non-static data member 'phy::mOBJECT'
    ..😮 😕

    std::vector<mobject> mobjects;

    In die spitzen Klammern kommt der Typ.

    Warum funktioniert es dann bei der hervorgehenden Schreibweise nicht?

    #inlcude mobject.h // Enthält die Klasse mobject

    So includiert ist?

    0
  • N
     

    #include "mobject.h"
    0
  • S

    Sorry, vertippt.

    Im original Code steht es richtig.

    Qt meckert nämlich sofort, wenn was nicht stimmt.

    Fehler gefunden 🙂

    Hatte in der mobject.h

    auch einen #include von phy.h drinn.

    Diesen entfernt und es funktioniert

    Danke an alle für die Hilfe

    0
Anmelden zum Antworten