C++ &引用；模板化；名称空间

我想建造这样的东西：

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

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

文件1：
模板
名称空间myNamespace{
类myClass1{myClass1（向量v）{…}
}
文件2：
模板
名称空间myNamespace{
类myClass2{myClass2（向量v）{…}
}

当然，这是不可能的，因为您不能为名称空间设置模板。 相反，我可以使用结构而不是名称空间，但这样我就不能将名称空间函数分散到多个文件中

这样的问题有什么解决办法吗

---

PS：我知道我可以对类进行模板化，但是我必须在创建新类时指定要使用的向量类型。

跟进您的评论：

而不是写作

使用名称空间myNamespace

只需使用模板类并编写以下内容（或任何变体）：

typedef myNamespace:：myClass1 myclassaint；
typedef myNamespace:：myClass2 myClass2Int；

我倾向于认为，与其尝试导入名称空间的特定实例化，不如明确说明正在使用的类型

您能更全面地描述一下使您认为模板化名称空间有用的问题吗

请记住，您始终可以编写一个
make_myClass1
free函数来为您推断模板类型。
您不能这样做，但您可以提供不同的名称空间和typedef（我并不认可它）

名称空间模板\u impl{
模板
类myClass1_tmpl{…}；
模板
类myClass2_tmpl{…}；
}
名称空间myns\u向量1{
typedef:：template_impl:：myClass1_tmpl myClass1；
typedef:：template\u impl:：myClass2\u tmpl myClass2；
}
void foo（）{
使用名称空间myns_Vector1；
myClass1 mc1；
}
无论如何，我的类有几个模板参数。
现在我创建了这种方法：

#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;

}

#包括
#包括
名称空间myNamespace{
模板
结构{
typedef_整数；
typedef_字符串；
};
模板
甲级{
公众：
静态类型名T:：integer intFunc（）{return 1；}
静态类型名T:：string stringFunc（）{return“hallo”；}
};
}
int main（）{
使用名称空间myNamespace；
类型1；
typedef s types2；
关于你的PS:std：：cout：你认为在实例化类时，使用模板化的名称空间将如何消除指定向量类型的需要？你仍然需要至少类似于（虚构的）的东西
使用名称空间myNamespace；
我同意stakx的观点。你的代码中的
int
是什么？是的，但是你可以这样做：int function1（）{使用名称空间myNamespace；myClass1 c1=myClass1（5）；myClass2 c2=myClass2（2）；}int function2（）{使用名称空间myNamespace；myClass1 c1=myClass1（'a'）；myClass2 c2=myClass2（'b'）；}很抱歉，该int是错误的，我将删除它。如何正确地将代码粘贴到此处？@Mark B我知道这是一个非常古老的问题，但是如果您想要一个只包含静态方法的
Util
类，该怎么办？使用命名空间不是更好吗？
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;
}

#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;

}