O código a seguir parece seguir sempre o ramo verdadeiro.

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

É um comportamento definido para um ponteiro não inicializado apontar paranullptrou um artefato do meu compilador?

Se não, como posso garantir a portabilidade do código a seguir? Atualmente, estou usando lógica semelhante para retornar a instância singleton correta para umlog 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];
}

Uma solução seriausar algo semelhante a este onde você usa uma função especial fornece um valor padrão ao verificar ummap. No entanto, meu entendimento é que isso faria com que a complexidade da pesquisa fosseO(n) ao invés deO(1). Isso não é um problema muito grande no meu cenário (sempre haveria um punhado de logs), mas uma solução melhor seria de alguma forma forçar ponteiros do tipoLog* referenciarnullptr por padrão, assim, fazendo a verificação de pesquisaO(1) e portátil ao mesmo tempo. Isso é possível e, em caso afirmativo, como eu faria isso?