«шаблонизировать» пространство имен

Question

Я хотел бы построить что-то вроде этого:

File 1:
template<typename Vector>
namespace myNamespace {
  class myClass1{ myClass1(Vector v) {...} }
}

File 2:
template<typename Vector>
namespace myNamespace {
  class myClass2{ myClass2(Vector v) {...} }
}

Конечно, это невозможно, потому что вы не можете шаблонировать пространства имен. Вместо этого я мог бы использовать структуру вместо пространства имен, но тогда я не могу распределить функции пространства имен по нескольким файлам.

Есть ли решение для такой проблемы?

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

Answer 1

После вашего комментария:

Вместо написания

using namespace myNamespace<int>;

Просто используйте шаблонные классы и напишите это (или любой другой вариант):

typedef myNamespace::myClass1<int> myClass1Int;
typedef myNamespace::myClass2<int> myClass2Int;

Я склонен думать, что лучше четко указывать, какие типы используются, а не пытаться делать что-то вроде импорта конкретного экземпляра пространства имен.

Можете ли вы более полно описать проблему, котораязаставляет вас думать, что шаблонные пространства имен были бы полезны?

И помните, что вы всегда можете написать make_myClass1 бесплатную функцию для определения типа шаблона для вас.

Answer 2

Вы не можете сделать это, но вы можете предоставить различные пространства имен и typedefs (не то чтобы я это одобрил).

namespace template_impl {
   template <typename V>
   class myClass1_tmpl {...};
   template <typename V>
   class myClass2_tmpl {...};
}
namespace myns_Vector1 {
   typedef ::template_impl::myClass1_tmpl<Vector1> myClass1;
   typedef ::template_impl::myClass2_tmpl<Vector1> myClass2;
}
void foo() {
   using namespace myns_Vector1;
   myClass1 mc1;
}

Answer 3

Во всяком случае, у моих классов есть несколько параметров шаблона.Теперь я создал этот подход:

#include <string>
#include <iostream>

namespace myNamespace {
  template<typename _integer, typename _string>
  struct s {
    typedef _integer integer;
    typedef _string string;
  };

  template<class T>
  class classA {
  public:
    static typename T::integer intFunc() { return 1; }
    static typename T::string stringFunc() { return "hallo"; }
  };
}


int main() {
  using namespace myNamespace;

  typedef s<int, std::string> types1;
  typedef s<unsigned int, char*> types2;

  std::cout << classA<types1>::intFunc() << std::endl;
  std::cout << classA<types1>::stringFunc() << std::endl;

  std::cout << classA<types2>::intFunc() << std::endl;
  std::cout << classA<types2>::stringFunc() << std::endl;

}

и, думаю, я объединю его с подходом Марка Б.

Ура, ребята!