#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

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*&)'

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.

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 * ?

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.

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.

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)

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.

Scanner::~Scanner(){
}

delete p funtz nicht weil p ja keine klassenvariable ist.

~bla(){}

zu bieten hat?