Порядок инициализации статических переменных не определен, поэтому он зависит от вашей конкретной настройки, включая компилятор, компоновщик и порядок связывания.

Уловка с функцией инициализатора

Вы можете использовать уловку с функцией инициализатора, чтобы гарантировать, что что-то инициализируется при необходимости. Я знаю, что это наверняка работает в Windows с компилятором Microsoft C ++ (и провел небольшое тестирование на g ++ с Linux, см. Ниже).

Функция инициализатора

Первый шаг - переместить карту в функцию как статическую переменную и всегда обращаться к карте через эту функцию.

buttonmap_t& buttonMap() {
  static buttonmap_t map;
  return map;
}

использование

Карта создается при первом вызове функции buttonMap(). Если вы получаете доступ к карте через функцию, вы можете быть уверены, что она будет создана.

Controller::Button::Button(int type) :
  type_(type) {
    buttonMap()[type] = this;
}

Важнейшей частью является инициализация глобальной переменной: вы заменяете ее ссылкой и инициализируете ее из функции, которая содержит переменную.

buttonmap_t& map = buttonMap();

Объяснение

При такой настройке порядок инициализации не имеет значения, потому что первый вызов функции будет выполнять инициализацию, а каждый вызов после нее будет использовать инициализированный экземпляр.

Примечание: этот трюк работает для глобальных переменных, поскольку этап инициализации выполняется в одном потоке. Даже если вы не знаете точный порядок инициализации, вы можете быть уверены, что это произойдет последовательно.

Тестирование

Я тестировал это на своем домашнем компьютере с g ++ в Linux, и, похоже, он работает:

$ g++ main.cpp controller.cpp -Wall
$ ./a.out
running...

финальная программа:

// controller.h
#ifndef CONTROLLER_H
#define CONTROLLER_H

class Controller {
 public:
  class Button {
   public:
    Button(int type = -1);

   private:
    int type_;
  };

  Controller();

  Button A;
  Button B;
  Button X;
  Button Y;
};

#endif

// controller.cpp
#include "controller.h"
#include <map>

typedef std::map<int, Controller::Button*> buttonmap_t;

buttonmap_t& ButtonMap() {
  static buttonmap_t map;
  return map;
}

buttonmap_t& map = ButtonMap();

Controller::Controller() :
  A(0),
  B(1),
  X(2),
  Y(3) {
}

Controller::Button::Button(int type) :
  type_(type) {
  ButtonMap()[type] = this;
}

// main.cpp
#include "controller.h"
#include <iostream>
Controller controller;

int main(int argc, const char * argv[]) {
  std::cout << "running..." << std::endl;
  return 0;
}

Когда у вас есть несколько глобальных конструкторов, порядок их выполнения не определен. Если объект controller создается до объекта map, контроллер не сможет получить доступ к этой карте, что приводит к ошибке segfault. Однако, если сначала создается объект map, тогда контроллер может получить к нему доступ.

В этом случае, похоже, это порядок, в котором они появляются в командной строке. Вот почему размещение вашего main.cpp первым вызвало segfault - объект controller создавался первым.

Я бы рекомендовал переместить экземпляр в ваш main, потому что тогда вы можете точно контролировать, как создаются экземпляры и в каком порядке.

Как предложили @Drew McGowen и @jrok, я проверил "фиаско с порядком статической инициализации":
http://www.parashift.com/c++-faq/static-init-order.html
http://www.parashift.com/c++-faq/static-init-order-on-first-use.html

Используя идиому «построить при первом использовании», я внес следующие изменения:

controller.cpp

typedef std::map<int, Controller::Button*> buttonmap_t;
static buttonmap_t& map() // was buttonmap_t map;
{
    static buttonmap_t* ans = new buttonmap_t();
    return *ans;
};

//[...]

Controller::Button::Button(int type) :
type(type)
{
    map()[type] = this;
}

Это работает в соответствии с порядком компиляции и не требует никаких изменений в «controller.h» или «main.cpp».