Ich schreibe gerade ein Programm und versuche verzeifelt einen Fehler zu beheben.
Googlen hat nichts gebracht...
Ich habe eine Klasse, die einen privaten Vektor hat. Die Klasse hat eine Funktion
search, die auf diesen Vektor zugreift. Hierbei kommt es zu der Fehlermeldung:

HashTable(int Size)
		:HT_Size(Size){
			vector<OPTR> HTab(Size,OPTR());
			cout << HTab[0];

	}

	OPTR search( Key_Type& key) const {
		for(int i=0;i<HT_Size;i++){
			if(key == HTab[i]->key) //hier tritt der Fehler auf
				return HTab[i];
		}
		return  NULL;
	}
//Auszug aus der main
  HashTable HTab(70);  

  OPTR OP;
  Key_Type test(3); 
  HTab.search(test); //Ob test jetzt den richtigen Typ hat weiß ich nicht
                     // in der richtigen main ist das aber anders gelöst und
                     // nicht das Problem

Ich kriege also den Fehler der im Titel steht, und Google sagt, dann wäre
der Speicher des Vektors nicht allokiert. Allerdings habe ich schonmal im
Konstruktor auf den Vektor zugegriffen, das hat funktioniert...

wäre super, wenn mir jemand helfen könnte!

lg bastian

Wenn du diese dereferenzierst, tritt logischerweise ein Fehler auf.

Nun versuchst du in search auf Elemente zuzugreifen, die garnicht vorhanden sind.

Änder mal die Initialisierungsliste des Konstruktors:

HashTable(int Size) : HT_Size(Size), HTab(Size,OPTR()) {
    cout << HTab[0];
}

vector<OPTR> HTab(Size,OPTR(0));

und nicht

vector<OPTR> HTab(Size,OPTR());

hier der Beginn der Klassendefinition:

class HashTable{

	const int HT_Size;
	vector<OPTR> HTab;

Leider heißt die HashTable im Bsp. wie ihr Vector HTab. Hoffe das verwirrt nicht.
Ich habe ein

typedef MyEntry *OPTR;

Hier der Code von MyEntry ( hat ein Objekt von MyKey, deshalb kopier ich das auch mal rein)

struct MyKey {
  int key;
  MyKey(int K) : key(K) {};
  int hash_val(int HT_Size) const {
    return key%HT_Size;
  }
  bool operator==(const MyKey& K) {
    return key == K.key;
  }
friend ostream& operator<<(ostream& OUT, const MyKey& K);
};

struct MyEntry {
  MyKey key;
  MyEntry *Next;
  MyEntry() : key(rand()%200), Next(0) {};
  MyEntry(int K) : key(K), Next(0) {};
  MyKey Key() const { return key; }
  bool operator==(const MyEntry& ME) {
    return key == ME.key;
  }

};

Vllt könnt ihr jetzt beurteilen, ob eure Vermutungen zutreffen, ich kann es leider nicht. Allerdings habe ich ja im Konstruktor darauf zugreifen können, deshalb denke ich nicht, dass es alles Nullpointer sind.