3. Klasse umbauen, damit man mehrere Instanzen anlegen kann

Klasse umbauen, damit man mehrere Instanzen anlegen kann

  • C

    Wie kann ich die hier stehende Klasse umbauen, dass ich Daten für mehrere Personen eingeben kann ?

    #include <string>
using namespace std;

class Person
{
  private:
    string vorname;
    string nachname;
    string strasse;
    string ort;

  public:
    bool eingeben(string& vorname1, string& nachname1, string& strasse1, string& ort1);
    void PersonenDatenAnzeigen();
};
    0
  • ?

    würd ich nicht umbauen

    du kannst eine klasse

    Personen machen die jeweils ein vector der daten beinhaltet und beim

    NeuePersonEingeben() immer ein pushback oder nach index ( max personen ) einfügt

    das ist aber IMHO mist sowas.

    lass deine klasse Person und pack die daten in einer "über"klasse
    z.b. RegisterPersonen

    oder Personen die z.b. einen vec hat von std::vector<Person> m_vecPersonen;

    in dieser "kartei" oder wie auch immer kannst du dann deine personen reinspeichern

    vorteil du kannst deine klasse Person auch für andere Design verwenden. z.b. für DB oder wie auch immer

    stichwort für dein ausbauen wäre dann

    Design Patterns

    0
  • C

    Und wie erschaffe ich dynmaisch Instanzen der Person, wenn ich vorher noch nicht ihre Anzahl weiß ?

    Weil ich muss im späteren Verlauf der Programmierung aus einer Datei auslesen und dann die Personen anlegen. Am Besten wäre dies in Instanzen denk ich mal !

    Zudem dachte ich auch daran mit der StringList zu arbeiten *war ein Tipp vom Chef*....

    Da gibts auch einen Befehl "AddObject", den ich benutzen kann.... hat damit schon jemand mal was gemacht ?

    0
  • H

    über verkettete Listen sollte dies gut möglich sein

    oder

    newkid_ schrieb:

    oder Personen die z.b. einen vec hat von std::vector<Person> m_vecPersonen;

    mit Vektoren arbeiten

    0
  • A
     

    std::vector<Person*> personen;

// Nachfolgendes kannst du so oft machen wie du willst:
Person* p = new Person();
personen.push_back(p);

    Du solltest dich mit den Containern der STL beschäftigen, da die STL einfach jeder C++ Programmierer kennen muß.

    0
  • H

    Artchi schrieb:

    std::vector<Person*> personen;
// Nachfolgendes kannst du so oft machen wie du willst:
Person* p = new Person();
personen.push_back(p);

    Warum denn mit Pointern?

    std::vector<Person> personen;
// Nachfolgendes kannst du so oft machen wie du willst:
Person person("Hans", "Meyer");
personen.push_back(person);

// oder auch so;
personen.push_back(Person("Hans", "Meyer"));
    0
  • M

    hehejo schrieb:

    Warum denn mit Pointern?

    http://www.cpp-tutor.de/cpp/le18/le18_01.htm

    0
  • C

    Innerhalb der main.cpp erstelle ich eine Instanz von einer Person, wenn ich Person Instanzname mache.

    Person ErstePerson;

    So zum Beispiel.... bis hierhin ist es doch richtig oder ?

    0
  • A

    Das ist falsch! Hast du dir nicht unsere Antworten durchgelesen, wie man das macht??? Bitte nochmal meine Antwort von oben durchlesen.

    0
  • ?

    Artchi schrieb:

    Das ist falsch! Hast du dir nicht unsere Antworten durchgelesen, wie man das macht??? Bitte nochmal meine Antwort von oben durchlesen.

    Ich raffs trotzdem nicht, wieso ist Person p und dann push_back so viel schlechter als Person *ptrP = new Person und dann push_back?!

    Entweder speichert die liste sofort den pointer oder, wenn man eine instanz übergibt, wird speicher geholt und das objekt intern (wieder als pointer) gespeichert.

    Ich hab jetzt keine Lust die ganzen Seiten zu wälzen nur damit ich herausfinde was du meinst.

    0
  • ?

    Kopiererei!
    Zeiger ist kleiner.
    => weniger Kopiererei

    0
  • C
    Mod

    nillable schrieb:

    Kopiererei!
    Zeiger ist kleiner.
    => weniger Kopiererei

    mag sein (wobei man einiges sparen könnte, wenn man move konstruktoren verwendet und push_back mit unbenannten objekten füttert). aber der aufwand, korrekt damit (pointer-vektor) umzugehen ist grösser. und die syntax ist auch hässlich. jede menge sternchen und klammern. zusätzlich besteht das problem, ownership korrekt zu implementieren, so dass theoretisch ein smart-pointer gebraucht wird - was seinerseits zu overhead führen dürfte. solange der erhöhte aufwand beim kopieren kein problem darstellt - und die problembeschreibung lässt das zunächst vermuten - würde ich die finger von pointer-containern lassen.

    0
  • C

    Hat einer von euch, das hier mal benutzt ?

    MeineListe->AddObject(.....);

    Wenn ja, wie hat er es eingesetzt und was weiß er darüber ansonsten. Muss man bestimmte Sachen beachten ?

    0
  • ?

    wenn er jetzt einfach den vector so definiert

    std::vector<&Person> meinePersonen;

Person a;
...

meinePersonen.push_back(a);  // hier ist doch auch nur eine referenz und das objekt ist nicht doppelt, oder? oder geht das nur bei trivialen datentypen
    0
  • ?

    ne, is keine referenz, is ne kopie, auch bei einfachen typen

    probier das mal:

    #include <iostream>
#include <vector>

using namespace std;

int main()
{
	int i=3;
	vector<int> vec;

	vec.push_back(i);
	vec[0]=12;

	cout<<i<<endl;
	cout<<vec[0]<<endl;

	cin.get();
}

    dass das ne kopie ist, steht in dem link http://www.cpp-tutor.de/cpp/le18/le18_01.htm, den miller_m gepostet hat gleich an erster stelle!

    0
  • C
    Mod

    jaaber schrieb:

    wenn er jetzt einfach den vector so definiert

    std::vector<&Person> meinePersonen;

Person a;
...

meinePersonen.push_back(a);  // hier ist doch auch nur eine referenz und das objekt ist nicht doppelt, oder? oder geht das nur bei trivialen datentypen

    das geht nicht. man kann keine referenzen mit stl-containern verwenden - selbst wenn es möglich wäre, wäre das ergebnis hier wohl kaum das, was du willst. a wird ja zerstört wenn der block verlassen wird, die referenz würde länger leben und auf etwas zeigen, das nicht mehr existiert.

    0
  • A

    1. Die Objekte wären nicht polymorphiefähig, was in einigen Situationen nicht gerade hilfreich wäre.
    2. Wen einfache Pointer stören, kann/soll Smartpointer benutzen, z.B. boost::shared_ptr.

    0
  • ?

    an camper:

    Geht folgender code?

    class Person{
 //...
 void print() {std::cout << name ;}
 std::string name;
};

int main()
{
  std::vector< Person > vect;
  {  //Block hier gemacht nur um die Instanz 'p' lokal zu definieren
     Person p("Hans"); 
     vect.push_back(p);
  }
  //hier existiert p("Hans") nicht mehr da es aus seinem Gültigkeitsbereich 
  //raus ist
  std::cout << vect[0].print() << std::endl;

}

    Was druckt dieses Programm aus?
    (Anmerkung: Wir nehmen an die Klasse Person hat einen operator << definiert)

    Antwort: es wird "Hans" audrucken ?
    Warum: vector KOPIERT sich die Instanz der Klasse, und obwohl die Instanz gar nicht mehr existiert, es wird korrekt ausgegeben 😉

    Man kann also ruhig vector <Person > bauen.

    Nik0n

    0
  • O

    ich find kopieren in diesem fall gut 👍

    weniger code, sicherer code, besserer code. und den copy ctor optimiert der compiler eh weg 👍

    0
Anmelden zum Antworten