3. Frage zur Funktion List.push_back()

Frage zur Funktion List.push_back()

  • N

    außerdem fehlt hier das #endif...

    Habs nur nicht mitkopert, da ich die ganzen Methoden nicht mitkopieren wollte ^^ habs übersehen dass es hier im Post fehlt.

    Außerdem: Warum IDs als string speicher?

    Weil die IDs sowieso nur als Vergleich zwischen verschiedenen Objekten dienen und ich diese aus ner Datei als string einlese, und mir die Typenumwandlung sparen wollte ^^.

    Und warum alles englisch außer "soll"? : D

    Weil mir, als ich damals das erste mal diese Klasse erstellt habe, der englische Begriff für "Sollwert" ned eingefallen ist ^^ und sieht ja nacher im Programm eh keiner 😃

    So viele Member-Variablen sind meist ein Indiz dafür, dass man die Klasse noch weiter aufsplitten sollte....

    Man könnte die ganzen Variablen auch mit ner struc lösen, jedoch nutze ich den vorteil von Klassen, um über Polymorphie über die gleiche Methode nen string in eine long long variable umzuwandeln usw.

    Warum ich das weiter aufteilen soll geht mir nicht ein, da die Methoden ja wirklich nur max. 4 Zeilen lang sind, und sich der Aufwand durch mehrere Klassen ja nur erhöht.

    Warum schiebst du bei deinem operator = alles zuerst in einen temporären String?
    Du kannst alles direkt swappen und dann machst du einfach eine Kopie des gesamten Objektes (unter Benutzung des copy-ctor).
    Und rufst dann swap auf.

    Hab mir das aus dem Link auf der ersten Seite abgeschaut, dass das auch mit dem ganzen Objekt geht wusste ich ned.

    Zum using Namespace std; :
    Das ganze Prog ist eigentlich in dem Namespace, und da ich nicht einbinde das nen anderen Namensraum hat, geht es doch so schneller oder? Oder lauf ich dadurch irgendwie in Gefahr?

    Hab die Klasse mal geändert:

    data.h

    #ifndef DATA_H
#define DATA_H

#include <string>

using namespace std;

//Daten, die vom Programm erzeugt/ergänzt werden

class Data{

private:
	string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;

public:
	Data();
	Data(const Data &rhs);	

	Data& operator= (Data const &rhs){
		Data to_swap(rhs);
		swap(to_swap, *this);
		return *this;
	} 
        //jede menge Methoden
};
#endif

    data.cpp:

    #include <string>
#include "data.h"

using namespace std;

Data::Data()
:	quantity(0),soll(0),difference(0),adjusted(false)
{}

Data::Data(const Data &rhs) 
	: itemName(rhs.itemName),
	locationName(rhs.locationName),
	quantity(rhs.quantity),
	soll(rhs.soll),
	difference(rhs.difference),
	groupID(rhs.groupID),
	group(rhs.group),
	categoryID(rhs.categoryID),
	category(rhs.category),
	adjusted(rhs.adjusted) {}

//Jede Menge Methoden
    0
  • N

    Dein swap könntest du effizienter gestalten, indem du die jeweiligen Member einzeln tauschst. std::string zum Beispiel hat ein eigenes swap() implementiert. Das könnte zum Beispiel so aussehen:

    void Data::swap(Data& other)
{
    std::swap(itemName, other.itemName);
    std::swap(quantity, other.quantity);
    // ...
}

    Zudem kannst du noch ein globales swap() für deine Klasse anbieten. Ist zwar etwas Schreibaufwand, aber es ist gut, sich solche Dinge anzugewöhnen, auch später wegen Exceptionsicherheit. Dein Zuweisungsoperator könnte dann so aussehen:

    Data& operator= (const Data& other)
{
    Data(other).swap(*this);
    return *this;
}

    Brauchst du eigentlich long long ? Dieser Typ ist nicht im C++-Standard enthalten. In den meisten Fällen reichen eigentlich int bzw. long . Und IDs würde ich auch eher als Zahlen speichern...

    Zum using namespace std; - ich würde mir generell abgewöhnen, using namespace in Headerdateien zu verwenden. Dadurch wird der gesamte Namensraum in allen inkludierenden Dateien ausgeschüttet, was nicht immer erwünscht ist. Die paar std:: sollten wohl noch drin liegen, soviel Aufwand ist das nicht. Ich gebe bei mir den Namensraum eigentlich immer an, auch in lokalen Funktionen.

    0
  • N

    Ok, danke für die Tipps, werd versuchen sie umzusetzten und mir das mit dem namespace abgewöhnen 😃

    Warum long long. Es kommt vor, dass die Zahlen bis zu einigen Milliarden groß sind (größte was ich gefunden hab waren ~150 Mrd), und das ist zuviel für ne normale long, da diese dann den Bereich überschreitet.

    0
  • N

    Neo Gandar schrieb:

    Warum long long. Es kommt vor, dass die Zahlen bis zu einigen Milliarden groß sind (größte was ich gefunden hab waren ~150 Mrd), und das ist zuviel für ne normale long, da diese dann den Bereich überschreitet.

    Ah, dann ist es okay. Ich hatte nur irgendwie das Gefühl, du hättest mal vorsorglich grosse Typen genommen. 😉

    Du solltest dir einfach im Hinterkopf behalten, dass mit long long nicht mehr ganz standardkonform bist, solltest du zum Beispiel mal eine Portierung oder Ähnliches vorsehen.

    0
  • N

    Gibt es Standartkonforme Lösungen dafür? Da ich das Programm sowieso grad neu schreibe (und vorallem Strukturiere 🙂 ) könnte ich es dann ja auch gleich ändern.

    0
  • N

    Da müsstest du wohl auf externe Bibliotheken zurückgreifen. Solange es nur zur Übung ist oder du dich nicht gross um Portabilität kümmerst, würde ich sagen, lohnt sich der Aufwand einer Umstellung nicht. Eine Bibliothek impliziert nämlich das Suchen, Downloaden, Installieren, Doku-Lesen und Linken. 🙂

    0
  • D

    Neo Gandar schrieb:

    Gibt es Standartkonforme Lösungen dafür? Da ich das Programm sowieso grad neu schreibe (und vorallem Strukturiere 🙂 ) könnte ich es dann ja auch gleich ändern.

    Naja. Ich würde ganz einfach ein typedef machen und dann diesen Typen benutzen. Dann kannst du das, wenn du das portieren willst einen geeigneten Typen suchen und den da anpassen. Dafür eine externe lib zu verwenden finde ich ein wenig übertrieben.

    0
  • U

    Neo Gandar schrieb:

    So viele Member-Variablen sind meist ein Indiz dafür, dass man die Klasse noch weiter aufsplitten sollte....

    Man könnte die ganzen Variablen auch mit ner struc lösen, jedoch nutze ich den vorteil von Klassen, um über Polymorphie über die gleiche Methode nen string in eine long long variable umzuwandeln usw.

    Warum ich das weiter aufteilen soll geht mir nicht ein, da die Methoden ja wirklich nur max. 4 Zeilen lang sind, und sich der Aufwand durch mehrere Klassen ja nur erhöht.

    Es gibt zwischen struct und class fast keine Unterschiede...
    Unterschiede:
    - default access (public vs private)
    - bei templates kann man (neben <typename T> auch) <class T> schreiben aber nicht <struct T>
    - structs können nicht als class vorwärts deklariert werden - gleiches gilt auch umgedreht
    ansonsten gibt es keinen Unterschied (der mir gerade einfallen würde)

    also ist es egal, ob struct oder class - darauf wollte ich auch nicht hinaus, was ich fragen wollte:

    string itemName;
    string locationName;
    long long quantity;
    long long soll;
    long long difference;
    string groupID; //1)
    string group; //1)
    string categoryID; //2)
    string category; //2)

    bool adjusted;

    was ist der unterschied bei 1 und 2? (reicht vll die groupid aus und die group hängt von der groupid ab?)
    wofür willst du deine Klasse Data nehmen? und was genau baust du damit?

    falls du zu allen member-variablen ein paar worte sagen könntest, könnte man das mit sicherheit ein wenig aufsplitten (ich glaube z.bsp., dass adjusted im Ggnsatz zu dem Rest nur etwas über das Design aussagt - und würde es deshalb wohl nicht mit in die Klasse nehmen, die sich eigtl nur um den Inhalt kümmert...
    Jz wirst du dich bestimmt fragen: Wieso? So gehts auch, ich brauch eh alles und so hätte ich viel mehr Arbeit: Ich finde aber, man sollte das Design immer vom Inhalt trennen - z.bsp. ist wahrscheinlich der fkt, die den bb-code durch html-tags ersetzt ziemlich egal, ob die standard-schriftfarbe rot oder gelb ist und wie die standard-text-größe ist...
    Du könntest das Zeugs dann einfach mal viel schöner erweitern und wirst auch später noch gut durchsehen...

    Außerdem würde ich die 3 Zahlen (weil sie alle als einziges was über die Kapazität aussagen), noch mal extra kapseln...

    am ende würde ich wahrscheinlich auf so was in der richtung kommen:

    string itemname; //wobei ich hier wahrscheinlich nur die id oder so was speichern würde und nen singleton oder ne fkt. oder so haben würde, was mir aus ner produktnr. den anzeigename geben könnte - so würde es ja wahrscheinlich auch in der datenbank aufgebaut sein
string locationname; // ---------------------- "" ----------------------
TCapacity capacity; //soll, haben - differenz wird berrechnet, wenn nötig
TGroup group; //falls obige annahme stimmt würde ich hier auch wieder nur die id...
TCategory category; //... speichern und den name wieder über nen singleton oder eben ne einfache fkt raussuchen

    ich hoffe, ich habe dich nicht ganz so verwirrt ^^

    bb

    0
  • N

    Nene, so verwirrt hast du mich ned 🙂 Ich versuch jetz mal grob mein Konzept zu erläutern.

    Das Programm dient als Art Lagerverwaltung. Die Daten dafür kommen aus XML Dateien und einigen Tabellen eines SQL Servers.

    Aufbau ist so:

    Es gibt eine große Klasse Assets. Diese beinhaltet als Membervariablen 2 Listen vom Typ Item. Item ist ne vererbung von der Klasse Data über die wir hier reden. (Einen für den Import von Daten, eine fürs Arbeiten mit den Beständen. Es ist deshalb getrennt, da beide Listen verglichen werden müssen, damit Gegenstände, die beim import nicht mehr vorhanden sind, nicht aus der Liste gelöscht werden.)

    Diese Klasse Assets verwaltet andere Klassen, die Daten aus den SQL Tabellen zur verfügung stellen, ergänzt Daten, die nicht in der XML Datei vorhanden sind, uvm.

    Der unterschied zwischen groupID und group ist der, dass groupID, die ID aus der XML datei enthält über die dann der Name der Gruppe, group, abgefragt und eingefügt werden kann. Das selbe gilt für category / ID.

    Hab versucht das OOP Konzept umzusetzten (war, als ich das Programm das erste mal schrieb, mein erster Versuch mit OOP 😉 )

    Die Idee mit den Stückzahlen (quantity, soll, difference), diese in eine eigene Klasse zu packen, werde ich gleich umsetzten.

    Hier mal ne beschreibung aller Variablen, vielleicht seht ihr ja zusammenhänge die ich (noch) ned sehe.

    //Der erste Block sind Werte, die direkt aus der XML Datei importiert werden
{
	std::string itemID;        //Einzigartige ID des Gegenstandes
	std::string locationID;    //ID des Ortes, an dem der Gegenstand sich befindet
	std::string typeID;        //ID des Types, von dem der Gegenstand ist
	std::string squantity;     //Stückzahl als string (beim import)
	std::string flag;          //Mir noch unbekannt was sie bedeutet
	std::string singleton;     //Mir auch noch unbekannt
	std::string containerID;   //itemID des Behälters in dem sich der Gegenstand befindet.
	bool   contains;           //Gibt an, ob der Gegenstand als Behälter verwendet wird
}
//Die restlichen Variablen werden durch abgleichen der Daten aus den SQL Tabellen ergänzt
        std::string itemName;      //Name des Gegenstandes
	std::string locationName;  //Name des Ortes an dem sich der Gegenstand befindet
	long long quantity;        //Stückzahl
	long long soll;            //Mindeststückzahl
	long long difference;      //Differenz zur Mindeststückzahl
	std::string groupID;       //ID der Gruppe, zu dem der Typ des Gegenstandes gehört
	std::string group;         //Name der Gruppe, zu dem der Typ des Gegenstandes gehört
	std::string categoryID;    //ID der Categorie, zu dem die Gruppe des Gegenstandes gehört
	std::string category;      //Name der Categorie, zu dem die Gruppe des Gegenstandes gehört

	bool adjusted;
//adjusted gibt an, ob der Gegenstand, beim Aktualisieren verändert wurde. 
//Wenn nicht ergibt sich, dass der Gegenstand nicht mehr vorhanden ist, 
//also die Stückzahl auf 0 geändert werden muss.

    #Edit

    Wichtige frage noch.
    Wenn ich z.B. in einer Klasse den wert group über void set_group(std::string &newGroup); ändere, is es dann besser das mit swap() zu machen?

    also

    void Data::set_group(std::string &newGroup){
    std::string to_swap(newGroup);
    swap(to_swap, group);
};

//oder so?
void Data::set_group(std::string &newGroup){
    group = newGroup;
};

    Kommt es zu Problemen, wenn ich die Klasse dann dynamisch erstelle, bei der 2t. Methode?

    0
  • U

    Der unterschied zwischen groupID und group ist der, dass groupID, die ID aus der XML datei enthält über die dann der Name der Gruppe, group, abgefragt und eingefügt werden kann. Das selbe gilt für category / ID.

    Wenn du ohnehin nachgucken musst (bzw. kannst), wieso dann noch mal mit abspeichern?

    Einen für den Import von Daten, eine fürs Arbeiten mit den Beständen. Es ist deshalb getrennt, da beide Listen verglichen werden müssen, damit Gegenstände, die beim import nicht mehr vorhanden sind, nicht aus der Liste gelöscht werden.

    Ist zwar nicht unbedingt für die Aufteilung notwendig, aber iwie hab ich das nicht ganz verstanden:
    Eine für die Teile, die auf der Bestellliste sind und eine für die, die schon verplant sind? und wieso dann nichts löschen oder was? : D

    bool adjusted;
    //adjusted gibt an, ob der Gegenstand, beim Aktualisieren verändert wurde.
    //Wenn nicht ergibt sich, dass der Gegenstand nicht mehr vorhanden ist,
    //also die Stückzahl auf 0 geändert werden muss.

    find ich persönlich eigenartig... aber vll hab ichs auch nicht richtig verstanden...
    warum muss die stückzahl auf 0 geändert werden, wenn hier iwas nicht aktualisiert wurde? Oo

    außerdem würde ich wahrscheinlich nur fkt für itemname etc machen - wenn das performance-technisch zu knapp wird weil jedes mal wieder ne query und du eben 50mal pro sekunde irgend so nen getter aufrufst, würd ich mir vll die letzten query`s + ergebnisse iwo cachen...
    der name gehört iwie nicht zu dem zustand des objektes (ist id 1234 mit name "schraube" was anderes als die id 1234 mit dem veränderten name "Schraube 0815 - super toll im Angebot von Hersteller xyz, genormt nach DIN 456787654678765..."?)
    sieht man bei menschen ja auch schon, dass namen nicht unbedingt perfekt geeignet sind, um sie in listen zu führen sondern eher irgend ne id(steuernr./...) weil Frau Meyer nun mal nach der Hochzeit anders heißt aber trotzdem noch die gleiche ist ^^ (na gut - die Steuer ist hier vll nicht das beste Bsp., weil sich da ja dann schon ne ganze Menge ändert - aber du solltest wissen, worauf ich hinaus will?!)

    bb

    0
  • N

    Ich speicher es deshalb ab, da ansonst bei Suchanfragen jedesmal diese Sachen rausgesucht werden müssen. Es gibt aber über 20.000 Gegenstände im Inventar, über 50.000 Namen für Gegenstände, 12.000 Orte an denen gegenstände sein können, usw.

    Allein nach dem Import die Gegenstände abzugleichen und zu ergänzen, dauerte etwa 15 sekunden bei der letzten Version.
    Es ist viel Laufzeitfreundlicher diese Daten direkt beim Gegenstand zu speichern, um zig Millionen Funktionsaufrufe zu vermeiden 😃

    find ich persönlich eigenartig... aber vll hab ichs auch nicht richtig verstanden...
    warum muss die stückzahl auf 0 geändert werden, wenn hier iwas nicht aktualisiert wurde? Oo

    Ok, ich versuch es mal zu Erklären.
    Sagen wir man hat 10 Gegenstände vom Stück Brot gekauft. Wenn ich also meine Speisekammer abfrage, gibt sie mit zurück, dass 10 Stück Brot da sind, und ich brauche es ned auf die Einkaufsliste zu schreiben

    Ich will aber, dass immer mindestens 5 Stücke Brot da sind, also schreibe ich mir auf, dass vom Gegenstand Brot immer 5 Stück da sein sollen.

    Wenn das Brot alle ist, und ich die Speisekammer wieder abfrage, kann sie mir ja nicht sagen dass kein brot da ist, weil sie kann ja nur zurückgeben was vorhanden ist.

    Also setzte ich auf der Einkaufsliste alle Sachen, die noch vorhanden sind auf true.

    Wenn jetzt irgend ein Gegenstand auf false gesetzt ist, weiß ich, dass mir die SPeisekammer dafür keine Daten geliefert hat, also nichts mehr vorhanden ist.

    😃

    #Edit

    der name gehört iwie nicht zu dem zustand des objektes (ist id 1234 mit name "schraube" was anderes als die id 1234 mit dem veränderten name "Schraube 0815 - super toll im Angebot von Hersteller xyz, genormt nach DIN 456787654678765..."?)

    die typeID ist direkt mit dem Namen verbunden, und wird auch darüber aufgelöst.
    die itemID ist Einzigartig, da ja am Selben Ort, der Gleiche gegenstand, auf verschiedenen Stapeln, oder in verschiedenen Containern sein kann.

    0
  • U

    Wenn das Brot alle ist, und ich die Speisekammer wieder abfrage, kann sie mir ja nicht sagen dass kein brot da ist, weil sie kann ja nur zurückgeben was vorhanden ist.

    wieso kann sie das nicht?

    for each item in speisekammer_inventar_list
   if item.ist_wert < item.soll_wert
      bestelle(item)

    vrmtl würde man dann eine map oder (eher) nen set nehmen und über die ID ordnen lassen...
    Am Anfang würd ich eben sagen, welche IDs in der Inventar-Liste stehen und für die Teile, für die ich Daten habe, änder ich den Eintrag im Container halt...

    zu deinem edit:
    naja - wenns sonst zu langsam ist und du permanent wirklich alle daten brauchst, dann wirst du es wohl so machen müssen...
    das die id einzigartig ist hab ich oben schon gelesen und deshalb ja auch die selbe id genommen - und meinte damit, dass das "Brot" vll morgen in "Schwarzbrot" umbenannt werden muss weil es auf einmal auch "Weißbrot" in der Speisekammer gibt... sich dann aber nichts am Objekt an sich geändert hat sondern nur der Verkaufsname sich geändert hat - die Fkt bestellen bsp.weise interessiert das gar nicht, wie du das teil nennst, was sie unter der nr. x kennt und einfach bestellt, wenn es eben nicht mind. n mal vorhanden ist...

    bb

    0
  • N

    wieso kann sie das nicht?

    Es is ne XML abfrage die das ned kann 🙄 ich hab diese nicht entworfen, sondern greife da lediglich über ne Webabfrage drauf zu.

    vrmtl würde man dann eine map oder (eher) nen set nehmen und über die ID ordnen lassen...

    Ich hab ehrlich gesagt noch nie mit maps oder sets gearbeitet.
    Ordnen brauche ich die Einträge nicht, da sie bereits geordnet als XML geladen werden, und auch in dieser Reihenfolge eingelesen werden.

    und meinte damit, dass das "Brot" vll morgen in "Schwarzbrot" umbenannt werden muss weil es auf einmal auch "Weißbrot" in der Speisekammer gibt... sich dann aber nichts am Objekt an sich geändert hat sondern nur der Verkaufsname sich geändert hat

    Die Namen ändern sich nicht, höchstens es ist denen beim Erstellen ein Fehler unterlaufen (Rechtschreibfehler oder so). Jedoch habe ich die Namen, IDs usw. in einer Datei stehen, ändern sich also nur wenn ich es aktualisiere/ändere. Es kommen aber neue Gegenstände hinzu hin und wieder, jedoch haben die dann Eigene IDs

    0
  • N

    Muss leider doppelposten, da mein Edit ein paar posts vorher wohl untergegangen ist.

    #Edit

    Wichtige frage noch.
    Wenn ich z.B. in einer Klasse den wert group über void set_group(std::string &newGroup); ändere, is es dann besser das mit swap() zu machen?

    also

    void Data::set_group(std::string &newGroup){
    std::string to_swap(newGroup);
    swap(to_swap, group);
};

//oder so?
void Data::set_group(std::string &newGroup){
    group = newGroup;
};

    Kann es zu Problemen kommen, wenn ich die Klasse dann dynamisch erstelle, bei der 2t. Methode?

    0
  • N

    Der Zuweisungsoperator von std::string macht höchstwahrscheinlich selber ein swap() , also kannst du normal zuweisen. Jedoch solltest du den Parameter als Const-Referenz übergeben, wenn du ihn nicht veränderst.

    Edit: Was für Probleme meinst du? Mir fallen da nicht gerade welche ein.

    0
  • N

    Dass sich dann vllt 2 Objekte auf der selben Speicheradresse befinden.

    Irgendwas sagt mir, da ich ja ned mit Zeigern arbeite hier, dass sowas ned passieren kann, aber ich dacht frag ich lieber mal nach 🙄

    #Edit

    Und was ist mit normalen Typen? int, bool usw? sollte ich die sicherheitshalber mit swap() zuweisen?

    0
  • N

    Nein, du musst jetzt nicht in den swap() -Wahn kommen. 🙂

    Du solltest vielleicht bei grösseren Klassen darauf achten, dass du deinen eigenen Zuweisungsoperator über Copy&Swap implementierst (wenn du ihn implementierst), da das oft effizienter und exceptionsicherer ist. Aber bei PODs wie int , die eh keine Exceptions werfen können, ist eine normale Zuweisung ohnehin am schnellsten. Du musst dir nur überlegen, was swap() macht:

    std::swap(a, b); // a, b sind ints

// expandiert zu:
swap(int& a, int& b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

    Also hast du drei Zuweisungen statt einer. swap() wird erst schneller, wenn man sich Kopien sparen kann, zum Beispiel durch Zeigertausch bei Containern.

    Generell musst du dir eigentlich keine Gedanken machen, wenn du andere Klassen zuweist. Du darfst normalerweise davon ausgehen, dass diese den operator= gut implementiert haben. Also weise ruhig zu, wenn du eine Zuweisung benötigst, und benutze swap() , wenn du tauschen willst.

    0
  • N

    😃 Da es hieß das swap() sicherer ist, wollt ich mal "auf nummer sicher" gehen 🙂 aber ok, denk jetzt versteh ich wann ich swap() benutzen kann/soll.

    0
  • N

    Also eines muss ich jetz mal wirklich sagen, DANKE an euch alle 👍

    Der Code ist bis jetzt etwa 10x schneller als der, den ich vorher fabriziert habe, und das nur wegen des Klassendesigns.

    0
Anmelden zum Antworten