“模板化”命名空间

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

你不能这样做，但你可以提供不同的命名空间和类型定义（不是我认可的）。

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;

}

我想我会将其与 Mark B 的方法结合起来！

干杯，伙计们！

Answer 4

...2023 年

namespace ns::nested_ns
{
   template<typename T, typename T2>
   class example_class
   {
   };
} 

using ec = ns::nested_ns::example_class<int, float>;