Попытка понять шаблоны переменных и псевдонимы шаблонов для правильного использования

Ранее я задавал эти два вопроса:

• Автоматический вывод типа
• Статические и нестатические функции-члены

Мой вопрос относится к классу, указанному в первом вопросе, который является моим классом Signal.

Идея, которую я пытаюсь донести в классе, заключается в том, что я не хочу, чтобы этот класс был шаблоном. Однако мне нужно сохранить переменную, связанную со временем, но есть два способа ее сохранения; либо как целочисленный тип: «Дискретный», либо как тип с плавающей запятой: «Непрерывный».

Я думал об использовании псевдонимов шаблонов, чтобы упростить код. Как видно из кода:

template<typename T>
using TimeSignal = T;

using DiscreteTime = TimeSignal<std::uint64_t>;
using ContinousTime = TimeSignal<double>;

Вот как я думал об использовании псевдонимов шаблонов.

Затем внутри самого класса без шаблона.

class Signal {
private:
    template<typename T>
    static TimeSignal<T> time_;

    // ...
};

У меня есть переменная шаблона как член Signal. Теперь, чтобы иметь переменную шаблона, она должна быть статической. В целях тестирования класса я в настоящее время использую его конструктор для создания экземпляра и сохранения чего-либо в этой переменной.

class Signal {
public:
    template<typename T>
    explicit Signal( TimeSignal<T> time ) {
        time_<T> = time;
    }
};

Теперь, когда дело доходит до доступа к этой переменной, у меня есть два варианта: я могу получить к ней доступ через статическую функцию, используя оператор разрешения области, или я могу получить к ней доступ через нестатическую функцию-член объекта.

class Signal {
public:
    template<typename T>
    auto atTime() { return time_<T>; }

    // or
    template<typename T>
    static auto atTime() { return time_<T>; }
};

Теперь, чтобы класс правильно скомпилировался и построился, эта строка кода должна быть определена вне класса в каком-то другом CPP-файле, который его использует:

template<typename T>
TimeSignal<T> Signal::time_;

Что понятно, поскольку переменная является статическим членом.

Это должно дать вам представление о текущей структуре моего класса. Есть несколько вещей, которые я хотел бы знать об этом дизайне кода, прежде чем я продолжу добавлять к нему больше.

Первый и более простой вопрос: должен ли мой код оставаться таким, какой он есть; который был бы предпочтительным способом получения переменной:

DiscreteTime t1{ 5 }; // 10 seconds
ContinousTime t2{ 7.9 }; // 7.9 seconds

Signal s1( t1 ); // Signal S1 using Discrete Time intervals
Signal s2( t2 ); // Signal S2 using Continuous Time

// Accessing the member variable: which is preferred:
// via static method and scope resolution?
auto time1 = Signal::atTime<Discreate>();
auto time2 = Signal::atTime<Continuous>();

// or through non static object member?
auto time1 = s1.atTime<Discrete>();
auto time2 = s2.atTime<Continous>();

Следующий вопрос, который немного важнее предыдущего, поскольку он повлияет на все дизайнерское решение, это...

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

Я хочу, чтобы шаблон переменной в классе был либо std::uint64_t, либо double, но я хотел бы использовать приведенные выше имена: DiscreteTime и ContinousTime для представления базовых типов, как если бы они были определениями типов.

Если нет, я хотел бы увидеть другие возможные реализации.