std::list NullReferenceException

[dertobian]

Hallo,

ich habe eine Liste deklariert:

list<LexValue *> registry;

und bekomme an der Stelle eine NullReferenceException:

this->registry.push_back(object);

Wie bekomme ich diese Exception weg? Also mit new list() hab ich´s auch nicht hinbekommen:

Fehler 1 error C2955: "std::list": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.

Wie würde das hier richtig aussehen?



Gruß Tobian.

 

[Endurion]

Sieht nicht direkt falsch aus. Aber zu prüfen wäre:

Ist this gültig (Ernsthaft, in C++ ist ein this mit NULL durchaus möglich)


Für new müßte das so gehen:
pRregistry = new std::list<LexValue*>();

Nicht das delete vergessen!

 

[dertobian]

Danke für die Antwort! Aber das funktioniert leider auch nicht:

Fehler 1 error C2679: Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'std::list<_Ty> *' akzeptiert (oder keine geeignete Konvertierung möglich)

Was sagt mir das?


Gruß Tobian.

 

[deepthroat]

Was sagt mir das?

Das bei einer Zuweisung die Typen auf beiden Seiten des Operators gleich sein müssen, oder es eine Konvertierung vom rechten in den linken Typ geben muss.

Der Compiler hat dir ja schon gesagt welchen Typ der new Operator zurückliefert. Du solltest sicherstellen, das pRregistry von diesem Typ ist.

Gruß

 

[dertobian]

Aber wenn ich eine Liste

list<LexValue *> registry;

erstelle, dann ist die Antwort von Endurion doch theoretisch richtig? Aber praktisch nicht...


Gruß Tobian.

 

[deepthroat]

Aber wenn ich eine Liste

list<LexValue *> registry;

erstelle, dann ist die Antwort von Endurion doch theoretisch richtig? Aber praktisch nicht...

Der new Operator liefert einen Zeiger auf den neu alloziertern Speicher des neu erzeugten Objektes.

list<LexValue *> *pRegistry;

Gruß

 

[dertobian]

Ja, stimmt. Das sieht gut aus. Ich musste aus

this->registry.push_back(object);

das hier

this->registry->push_back(object);

machen und konnte dann wieder kompilieren.

Aber die NullReferenceException kommt immernoch. Ich verstehs nich...


Gruß Tobian.

 

[deepthroat]

Hi.

Wie Endurion bereits angesprochen hat, wäre zu prüfen ob der this Zeiger null ist.

Dazu müßtest du mal mehr Code posten. Wie du die einzelnen Objekte erstellst.

Gruß

 

[dertobian]

Ja, ich habe mal nachgeschaut und bekomme tatsächlich beim Überwachen die Meldung

Fehler: Der Bezeichner "registry" liegt außerhalb des gültigen Bereichs.

Ok, ich poste einfach mal den Code.

lexvaluefactory.h

//
// lexvaluefactory
//
#pragma once

class LexValueFactory
{
public:
  static LexValueFactory *
  getInstance();
  virtual
  ~LexValueFactory();

  LexValue *
  createLexValue();
  LexValue *
  createLexValue( char * str, char cTok, int line, int col );
  LexValue *
  createLexValue( char * str, int  iTok, int line, int col );

  LexValueFactory();
  void
  registerObject( LexValue * newInstance );

private:
  void
  deleteCreatedObjects();

  static LexValueFactory *       instance;
  list<LexValue *>             * registry;
};

lexvaluefactory.cpp

#include "stdafx.h"

// default constructor
LexValueFactory::LexValueFactory()
{
}

// default destructor
LexValueFactory::~LexValueFactory()
{
  deleteCreatedObjects();
}

LexValueFactory *
LexValueFactory::instance = 0;

LexValueFactory *
LexValueFactory::getInstance()
{
  if( instance == 0 )
  {
    instance = new LexValueFactory;
  }
  return ( instance );
}

LexValue *
LexValueFactory::createLexValue()
{
  LexValue * newLexValue = new LexValue();
  registerObject   ( newLexValue );
  return           ( newLexValue );
}

LexValue *
LexValueFactory::createLexValue( char * str,  char cTok,
				   int    line, int  col  )
{
  LexValue * newLexValue = new LexValue( str, cTok, line, col );
  registerObject   ( newLexValue );
  return           ( newLexValue );
}

LexValue *
LexValueFactory::createLexValue( char * str,  int iTok,
				   int    line, int col  )
{
  LexValue * newLexValue = new LexValue( str, iTok, line, col );
  registerObject   ( newLexValue );
  return           ( newLexValue );
}

void
LexValueFactory::registerObject( LexValue * newInstance )
{
	registry->push_back( newInstance ); // hier kommt dann die Exception, egal ob mit oder ohne this->
}

void
LexValueFactory::deleteCreatedObjects()
{
  list<LexValue *>::iterator i;
  for( i  = registry->begin() ;
       i != registry->end()   ;
       i++                    )
  {
    delete ( *i );
  }
  registry->clear();
}

Aufgerufen wird das Ganze so:

lex_value_factory = LexValueFactory::getInstance();

(Ich bin auch schon den Weg über new gegangen, is egal)

lex_value_factory ist in der stdafx.h definiert:

static LexValueFactory *lex_value_factory = 0;

Nicht über die LexValueFactory an sich wundern, die muss ich so (oder ähnlich) verwenden.

Gruß Tobian.

 

[deepthroat]

Hi.

Ich sehe nirgendwo die Stelle wo Speicher für registry erzeugt wird.

Der Konstruktor wäre eine gute Stelle dafür. Obwohl dieser eher als private deklariert sein sollte.

Gruß