When you declare your variable as in your original post, the variable gets external linkage (with our without initializer - doesn't matter). This means that the variables are not independent. In both declarations the names refer to the same object. In fact, what you have is a multiple definitions of the same entity with external linkage. This is a violation of C language definition rules, i.e. it is what we usually call an error. Note, that this is an error in any case: with or without initializer.
The reason your code seems to compile fine without an initializer is just a quirk of your compiler.
I can actually guess the rationale behind that quirk. You see, C language has an interesting feature (not present in C++, BTW) called tentative definitions. This feature says that if you declare a variable like that, without initializer
int m_Test; /* no initializer */
you create a tentative definition of that variable. You can declare it in the same way multiple times in the same translation unit
int m_Test;
int m_Test; /* OK in C */
int m_Test; /* OK in C */
(note, again, that this would be illegal in C++). If at some point you provide a non-tentative definition for that variable
int m_Test = 0; /* non-tentative */
the compiler will "merge" all these previous tentative definitions with this one. But if you don't provide a non-tentative definition, the compiler will generate one for you implicitly, and it will be equivalent to
int m_Test = 0; /* implicit definition generated by the compiler */
Note, however, that this only applies within the same translation unit. That means that once you wrote something like that
int m_Test; /* tentative */
it already guarantees that this variable will eventually be non-tentatively defined in this translation unit (by you explicitly, or by the compiler implicitly). If you do the same thing in another translation unit, that variable will be defined there as well, which will violate the one definition rules of C language.
However, the compiler you are using must be treating the tentative definition rules more losely and allows something like "tentative definitions across several translation units". This is why you don't get an error in your first case. However, this is just a quirk of your compiler. It is still illegal in C.
P.S. As it has been noted in one of the linked posts, this behavior is a non-portable "common extension" of C compilers (even mentioned in the informative section of the language standard). I.e. some compilers are known to allow multiple declarations of external objects as long as no more than one of them includes an initializer.
P.P.S. Of course, if you want to have indepedent variables in different translation units, you have to declare them as static
, as others already noted.