The way C++ initializes globals is really weird, and technically the other answers thus far have undefined behavior, though will probably work on your machine/compiler anyway. Basically, the problem is that when the program starts, the implementation is only required to initialize the globals in main.cpp and it's headers. When your code calls a function that's defined in another cpp/header combo (translation unit), only then is C++ required to initialize the globals in that one translation unit.

The easiest (safe) workaround in your particular case, is to simply do the initialization in the header. If a file has include "TypeOne.h", it will initialize Activators[0] itself. To be portable, it's important that the translation unit (cpp file) that contains int main() also includes the headers for all of these that you need to use. Otherwise, you aren't strictly guaranteed that they'll be initialized before main begins.

in TypeOne.h

#include "master.h"

class TypeOne { 
    static std::unique_ptr<TypeOne> Create();
    //stuff
};
static const auto TypeOneInitialized = Activators[0] = &TypeOne::Create;

If you have a cpp who shouldn't depend on TypeTwo, simply don't include it's header.

Assuming that Activators are a polymorhpic (where Type1 and Type2 both derive from Activators) type, I would approach the problem like this.

Activators.h

std::vector<std::unique_ptr>>& activators();

Activators.cpp

std::vector<std::unique_ptr>>& activators()
{
   static std::vector<std::unique_ptr>> the_array(2);
   return the_array;
}

Then in individual compilation units you can assign whatever you want:

Type1.cpp

#include "Activators.h"

struct setup_activator_type_1
{
    setup_activator_type_1()
    {
       activators()[0].reset(new Type1);
    }
};

static setup_activator_type_1 type1_static_initializer;

I would provide a functional interface to add Activators and use it from TypeOne.cpp and TypeTwo.cpp.

In Activators.h:

void addActivator(Activator activator);

In Activators.cpp:

static std::vector<Activator> activators{};

void addActivator(Activator activator)
{
   activators.push_back(activator);
}

In TypeOne.cpp:

struct Initializer
{
   Initializer()
   {
      addActivator(&TypeOne::Create);
   }
};

static Initializer initializer;

In TypeTwo.cpp:

struct Initializer
{
   Initializer()
   {
      addActivator(&TypeTwo::Create);
   }
};

static Initializer initializer;

Yes. Although you need to be very careful.

TypeOne.cpp

namespace {
    class BeforeMain {
        BeforeMain() {
            Activators[0] = &TypeOne::Create;
        }
    };

    BeforeMain obj;
}

TypeTwo.cpp

namespace {
    class BeforeMain {
        BeforeMain() {
            Activators[1] = &TypeTwo::Create;
        }
    };

    BeforeMain obj;
}

Then, other than this, just don't access the array until main() is called.

Personally though, I'd rather see Activators be a std::vector<T>, and then have each BeforeMain use std::vector<T>::push_back().