//.h
struct st
{
   static int arr[3];
};

//.cpp
int st::arr[3] = {1, 2, 3};

int st::arr[3] = {1, 2, 3}// — это я писал в методе, а надо было написать вне метода

class st
{
   static int arr[3];
};
int st::arr[3] = {1, 2, 3};

int <имя класса>::arr[3] = {1, 2, 3};

//.hpp
class SomeClass{
public:
    SomeClass(int i){}
}

class Foo{
    public:
static const N = 10;
        static SomeClass someArray[N]; 
};
//.cpp init someArray

class SomeClass{
public:
    SomeClass(int i){}
}

template <int N>
class Foo{
    public:
        static SomeClass someArray[N]; 
};

class SomeClass{
public:
   SomeClass(int i){}
}

template <int N>
class Foo{
    public:
        static SomeClass someArray[N]; 
private:
static int m_dummy; 

   int Initialize_someArray()
   {
     for(int i = 0; i < N; ++i)
         someArray[i] = SomeClass(i);
   }
};

template <int N>
int Foo<N>::m_dummy = Initialize_someArray();

class SomeClass{
public:
   SomeClass(int i){}
   SomeClass(){}
}

template <int N>
class Foo{
public:
        static SomeClass someArray[N]; 

private:
static int m_dummy; 

static  int Initialize_someArray()
   {
     for(int i = 0; i < N; ++i)
         someArray[i] = SomeClass(i);
   }
};

template <int N>
int Foo<N>::m_dummy = Foo<N>::Initialize_someArray();

А>class SomeClass{
А>public:
А>   SomeClass(int i){}
А>   SomeClass(){}
А>}

А>template <int N>
А>class Foo{
А>public:
А>        static SomeClass someArray[N]; 

А>private:
А>static int m_dummy; 

А>static  int Initialize_someArray()
А>   {
А>     for(int i = 0; i < N; ++i)
А>         someArray[i] = SomeClass(i);
А>   }
А>};

А>template <int N>
А>int Foo<N>::m_dummy = Foo<N>::Initialize_someArray();
А>

class SomeClass{
public:
   SomeClass(int i){}
   SomeClass(){}
}

template <int N>
class Foo{
public:
        typedef SomeClass SomeClassArrayType[N];
        static SomeClassArrayType &someClassArray; 

private:
  

static  SomeClassArrayType & Initialize_someClassArray()
   {
     static SomeClassArrayType _someClassArray;
     bool bFirstTime = true;

     if(bFirstTime){
        for(int i = 0; i < N; ++i)
           _someClassArray[i] = SomeClass(i);
        bFirstTime = false;
     }

     return _someClassArray;
   }
};

template <int N>
Foo<N>::SomeClassArrayType & Foo<N>::someClassArray = Foo<N>::Initialize_someClassArray();

А>static  SomeClassArrayType & Initialize_someClassArray()
А>   {
А>     static SomeClassArrayType _someClassArray;
А>     bool bFirstTime = true;
А>   }
А>};

А>class SomeClass{
А>public:
А>   SomeClass(int i){}
А>   SomeClass(){}
А>}

А>template <int N>
А>class Foo{
А>public:
А>        static SomeClass someArray[N]; 

А>private:
А>static int m_dummy; 

А>static  int Initialize_someArray()
А>   {
А>     for(int i = 0; i < N; ++i)
А>         someArray[i] = SomeClass(i);
А>   }
А>};

А>template <int N>
А>int Foo<N>::m_dummy = Foo<N>::Initialize_someArray();
А>

Unless a member of a class template or a member template has been explicitly instantiated or explicitly specialized, the specialization of the member is implicitly instantiated when the specialization is referenced in a context that requires the member definition to exist; in particular, the initialization (and any associated side-effects) of a static data member does not occur unless the static data member is itself used in a way that requires the definition of the static data member to exist.