Это зависит от того, что имеется в виду под "глобальностью" и "константностью". Какого типа константа? Насколько "тяжел" этот тип?

Для скалярных типов в С++ в .h-файле просто пишется:
const int MY_GLOBAL_CONSTANT = 42;
const char *const MY_GLOBAL_STRING = "Hello";

и все. Вопрос закрыт.

Но если вы где-то в программе будете брать адрес этой константы '&MY_GLOBAL_CONSTANT', то в разных модулях этот адрес будет разным. Это вас волнует? Если волнует, то делать следует так 
показал true_bugmaker. Но в этом случае константа не будет константой времени компиляции в тех модулях, в которых видно только ее объявление.



В языке C++ (в отличие от С) явно инициализированные const объекты целочисленных типов образуют Integral Constant Expressions.
Это настолько ценное свойство целочисленных const объектов, что пожертвовать им мы не можем и ради него будем объявлять такие константы именно так, как я показал.
Разумеется, надо следить за глобальностью констант и ограничивать ее до минимальной необходимости. Т.е. не совать в действительно глобальные заголовки то, что там не нужно.



Я не вижу, какое отношение это может иметь к каким-то "тонкостям проекта". Это фундамент языков С и С++, который всегда присутствует во всех "проектах" без исключения.

Спецификация const объектов целочисленных типов языка С++ специально разработана так, чтобы 'const int N = 42;' при правильном использовании мог выступать в качестве константы времени
компиляции, т.е. в качестве замены для '#define N 42' из языка С. '#define' считается слишком грубым инструментом, так как не поддерживает типизации и не подчиняется областям видимости.

В языке С++ (в отличии от С) разрешается использовать const объекты целочисленных типов, например, для задания меток case, ширин битовых полей, размеров любых массивов, инициализаторов enum
констант и т.п. Но чтобы const объекты можно было использовать в такой роли глобально в проекте, их инициализаторы должны быть видны во всем проекте. Т.е. поступать придется именно так, как
показано в моем примере и платить за это перекомпиляцией всего проекта при изменении значения константы.

А если вам не нужно, чтобы ваша глобальная константа была константой времени компиляции, а была просто "неизменяемой переменной" (как это было в С), то можно пойти по вашему пути через
extern const в .h-файле.


объявление 'static int i = 5;' или 'const int j = 10;' в .h-файле не приводит к нарушению ODR и никогда нарушением ODR не являлось.


TheCalligrapher, вообще подход true_bugmaker более предпочтителен, так как константы обычно заводят для того, чтобы можно было быстренько поменять их значение и проверить работу программы.
И если константа будет определена в .h-файле, то придется перекомпилировать все модули, куда включается этот .h-файл.
А если завести себе отдельный файл config.cpp с константами, то перекомпилять надо будет только его, ну и заново слинковать естественно.



константа, объявленная по методу extern const НЕ является константой вообще. Это "неизменяемая переменная", а не константа. Она не может использоваться там, где язык С++ требует константу.
Она не может использоваться для задания размера массивного типа, она не может использоваться в метках case, она не может использоваться как параметр шаблона, и т.д. и т.п. В дополнение к
этому, extern const значение не может напрямую участововать в оптимизациях времени компиляции. Другими словами в огромном количестве (или даже в подавляющем большинстве) языковых случаев
такая ложная "константа" совершенно бесполезна.

Если же вы работаете над какими-то гигантскими проектами, в которых настоящие константы не нужны, то конечно, для сокращения времени компиляции вам возможно лучше пользоваться подходом с
extern const. Но это какие-то очень специфические проекты. В большинстве реальных С++ проектов нужны настоящие константы, т.е. константы времени компиляции. Такие константы можно получить
только одним способом - определением прямо в .h-файле.

Поэтому рассуждать на тему того, какой способ "предпочтительнее", в большинстве случаев просто не приходится. Если вам нужна настоящая константа в терминологии языка С++, т.е. константа
времени компиляции, то никакого выбора у вас нет - константа определяется именно так, как показал я. А то, что ваш проект будет долго перекомпилирваться - это неизбежные реалии языков С и С++.

В языке С, например, const объекты вообще никогда не являются константами, где их не объявляй. Поэтому в языке С огромное количество именованных констант объявляется через #define.
'#define' и enum - это фактически единственные способы получить именованную константу времени компиляции в С.