El siguiente código parece seguir siempre la verdadera rama.

#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;
}

¿Se define el comportamiento para que un puntero no inicializado apunte anullptr, o un artefacto de mi compilador?

Si no, ¿cómo puedo garantizar la portabilidad del siguiente código? Actualmente, estoy usando una lógica similar para devolver la instancia de singleton correcta para unlog 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];
}

Una solución seríausa algo similar a esto donde utiliza una función especial, proporcione un valor predeterminado al verificar unamap. Sin embargo, mi entendimiento es que esto causaría que la complejidad de la búsqueda seaO(n) en lugar deO(1). Esto no es un gran problema en mi escenario (solo habría un puñado de registros), pero una mejor solución sería de alguna manera forzar punteros de tipoLog* referirsenullptr por defecto haciendo así la comprobación de búsquedaO(1) Y portátil al mismo tiempo. ¿Es esto posible y si es así, cómo lo haría?