Der folgende Code scheint immer dem wahren Zweig zu folgen.

#include <map>
#include <iostream>

class TestClass {
  // implementation 
}

int main() {
  std::map<int, TestClass*> TestMap;
  if (TestMap[203] == nullptr) {
    std::cout << "true";
  } else {
    std::cout << "false";
  }
  return 0;
}

Ist es ein definiertes Verhalten, auf das ein nicht initialisierter Zeiger zeigt?nullptroder ein Artefakt meines Compilers?

Wenn nicht, wie kann ich die Portabilität des folgenden Codes sicherstellen? Derzeit verwende ich eine ähnliche Logik, um die richtige Singleton-Instanz für a zurückzugebenlog file:

#include <string>
#include <map>    

class Log {
  public:
    static Log* get_instance(std::string path);
  protected:
    Log(std::string path) : path(path), log(path) {};
    std::string path;
    std::ostream log;
  private:
    static std::map<std::string, Log*> instances;
};

std::map<std::string, Log*> Log::instances = std::map<std::string, Log*>();

Log* Log::get_instance(std::string path) {
  if (instances[path] == nullptr) {
    instances[path] = new Log(path);
  }
  return instances[path];
}

Eine Lösung wäre zubenutze etwas Ähnliches Wenn Sie eine spezielle Funktion verwenden, geben Sie beim Aktivieren von a einen Standardwert anmap. Nach meinem Verständnis würde dies jedoch die Komplexität der Suche beeinträchtigenO(n) anstattO(1). Dies ist in meinem Szenario kein allzu großes Problem (es würde immer nur eine Handvoll Protokolle geben), aber eine bessere Lösung wäre, Zeiger vom Typ zu erzwingenLog* referenzierennullptr Standardmäßig wird somit die Nachschlagprüfung durchgeführtO(1) und gleichzeitig tragbar. Ist das möglich und wenn ja, wie würde ich es tun?