scanner funtzt nicht

meth

ich will einen scanner schreiben der ein file einliest und die Daten in einem vector von objekten speichert. aber es treten lauter komische fehlermeldungen auf die kein c++ noob interpretieren kann:

#include <string>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <vector>

#ifndef Personen_h
#include "Personen.h"
#define Personen_h 
#endif
#ifndef Scanner_h
#define Scanner_h
#include "Scanner.h"
#endif

using namespace std;

void Scanner::scanfile(char* fname, std::vector <Personen> PersonenVect){       

fstream F (fname, ios::in | ios::out);
char c;
string element;
printf ("file %s\n", fname);

  if (F.fail()) { 
               // perror ("file:" fname " konnte nicht geoeffnet werden, argumente vergessen?");
                 exit (1); }
Personen p =new Personen(); 
 F.get(c);

          int datatype=0;
         int year=0;
         int base=1000;
         int pos=0;
         int x=0;
   while (!F.fail())
   {

               while ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c=='ö' || c=='ä' || c=='ü' || c=='-'){
                     if (datatype==0)datatype=1; //string
                     if (datatype==2) exit(1); //zahl darf im namen nicht vorkommen                   
                       element+=c;
                        F.get(c);                  
               }

               if (c==' ' || c=='\t' || c=='\n'){

                       if (datatype==1){
                           //element+='\0';
                             p.storeStr(pos,element); 
                             pos++;
                             element='\0';
                              datatype=0;}
                           }
                       else if (datatype==2){
                       storeInt(pos,year);
                            year=0;
                             base=1000;
                             pos++;
                              datatype=0;
                            }
                      if (c=='\n'){   
                        pos=0;
                        x++;
                        PersonenVect.push_back(p);
                        p= new Personen();
                         }
                       datatype=0;
                      F.get(c);                        
               }

                 while ( (c >= '0' && c <= '9') && base !=0){
                       if (datatype==0)datatype=2; //zahl
                     if  (datatype==1) exit(1); // buchstabe darf in zahl nicht vorkommen 
                       year += (c-'0')*base; 
                       base=base/10;
                       F.get(c); 
               }       
   }
F.close();
//return 0;
}
}

Scanner.cpp In member function void Scanner::scanfile(char*, std::vector<Personen, std::allocator<Personen> >)': 28 Scanner.cpp conversion from \Personen*' to non-scalar type `Personen' requested
66 Scanner.cpp no match for 'operator=' in 'p = (((Personen*)operator new(56u)), (<anonymous>->Personen::Personen(), <anonymous>))'
note Personen.h:4 candidates are: Personen& Personen::operator=(const Personen&)
80 Scanner.cpp expected constructor, destructor, or type conversion before '.' token
80 Scanner.cpp expected ,' or;' before '.' token
82 Scanner.cpp expected declaration before '}' token

firefly

öhm die variable p von type Person muss ein zeiger sein

meth

danke, jetzt funtzen aber wieder einige sachen nicht:

Personen::p.storeStr(pos,element); //50
 // p.storeStr(pos,element);  geht auch nicht 
PersonenVect.push_back(p); //65

50 Scanner.cpp `p' is not a member of `Personen'
65 Scanner.cpp no matching function for call to `std::vector<Personen, std::allocator<Personen> >::push_back(Personen*&)'

Knuddlbaer

Personen p =new Personen();

ersetzen durch

Personen p;

Wie Du jetzt auf Person::p kommst weiß ich nicht.

Schau Dir das Thema Zeiger noch mal an, im geposteten Source hast Du leaks, müsstest bei push_back den Zeiger dereferenzieren (geht einfacher durch Personen p, kein Zeiger, keine Leaks).

Includeguards gehören in den eigentlichen Header, nicht an die Stelle in der die Datei includiert wird.

meth

wird durch Personen p überhaupt ein neues Objekt erzeugt? dazu brauch man doch das new oder? also nur Peronen p fällt aus weil ich bei zeile 66 immer eine neue person erzeuge, und was ich jetzt nicht verstehe ist folgendes:

Personen *p= new Personen();
//...
  p= new Personen(); //funzt
// *p= new Personen(); funzt nicht

p ist doch ein zeiger warum beim zuweisen eines neuen Objekts kein * ?

Artchi

Also durch Personen P; wird sehr wohl ein neues Objekt erzeugt. Nur halt auf dem Stack und nicht auf dem Heap.

Viele Tutorials und Bücher hämmern einem leider immer zuerst und ausführlich das new ein. In 99% der Fällt kommt man ohne new aus. Frage: wie erzeugst du ein neues int?

So:

int i;

oder so:

int *i = new int;

In 99% der Fälle doch eher wie im ersten Fall, oder? Personen und jede andere Klasse, ist in C++ ein Typ. Genauso wie int, char usw. auch Typen sind.
Jetzt vergleich mal die erste Variante mit der:

Personen i;

Hem... sieht gleich aus. Nur ein anderer Typ.

Knuddlbaer

Neue Elemente in den Vector packen - ohne new

std::vector<T> vec;

for(int i = 0;i < 10;++i)
{
    T t;  *1
    t.member1 = 12;
    t.memfunc(iregndwas);

    vec.push_back(t); *2
}

*1
Durch die { } wird t am Ende eines durchlaufes der Schleife stehts zerstört, Du legst also immer ein neues Objekt an.
*2 Von diesem Objekt wird eine Kopie erzeugt.

Nur 1 Objekt anlegen und immer wieder verwenden *1

std::vector<T> vec;

T t;  *2
for(int i = 0;i < 10;++i)
{
    t.member1 = 12;
    t.memfunc(iregndwas);

    vec.push_back(t); *3
}

*1 Das Objekt wird nur einmal angelegt und behält immer die letzen Werte.
So kann man z.B., wenn man nur 2 von 8 Werten ändern muss, vorbelegen
*2 Alle oder die nur gewünschten Werte ändern
*3 push_back erzeugt eine Kopie des Objektes, somit kann man das alte Objekt
wieder modifizieren.

Zeiger:

T * t;  << // Das * sagt, das wir nun einen Zeiger auf den Typ t haben.

t = new T; // t wurde weiter oben als T * (also Zeiger auf t) deklariert. 
           // t ist ein Zeiger und wird auch immer ein Zeiger sein

*t = <...> // Der * vor einem Zeiger dereferenziert. Man kommt also an
           // den "inhalt" des Zeigers herann.

CStoll

Mit "p=..." änderst du das Ziel, auf das der Zeiger verweist (könnte ein Speicherleck geben, wenn niemand anderes auf das alte Ziel zeigt), mit "*p=..." änderst du den Inhalt der Variable, auf die du zeigst.

Und "Personen p;" legt ein neues Objekt an, das von späteren Methodenaufrufen immer wieder aktualisiert wird. (push_back() speichert eine Kopie davon, so daß du es danach neu verwenden kannst)

meth

jetzt tauchen nur noch die fehlermeldungen bei zeile 80 und 82 auf.
einen destruktor hab ich definiert, aber was will der kompiler da innerhalb der methode nachdem Personen p; eh auf dem stak liegt müsste es doch passen oder?

CStoll

meth schrieb:

jetzt tauchen nur noch die fehlermeldungen bei zeile 80 und 82 auf.

Was für Fehler?

einen destruktor hab ich definiert, aber was will der kompiler da innerhalb der methode nachdem Personen p; eh auf dem stak liegt müsste es doch passen oder?

Wo (in welchem Bereich der Klassendefinition) und wie hast du den Dtor angelegt?

PS: Auch Stack-Variablen müssen sauber gelöscht werden, benötigen also Zugriff auf ihren Dtor.

meth

ich hab oben nach using namespace std den destruktor:

Scanner::~Scanner(){
}

delete p funtz nicht weil p ja keine klassenvariable ist.

meth

was simmt bei der anweisung nicht? gibts irgendwo ein anständiges destuktortutorial was mehr als nur

~bla(){}

zu bieten hat?

meth

mit dem destruktor war alles in ordnung eine } zuviel in der methode war schuld.
jetzt läuft das programm liefert abew einen leeren vector zurück warum