“шаблонная обработка” пространства имен
Я хотел бы создать что-то вроде этого:
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: Я знаю, что мог обработать классы по шаблону, но затем я должен буду указать, какой тип вектора я хочу использовать каждый раз, когда я создаю новый класс.
3 ответа
В продолжение вашего комментария:
Вместо того, чтобы писать
с использованием пространства имен myNamespace
Просто используйте шаблонные классы и напишите вместо них (или любой другой вариант):
typedef myNamespace::myClass1<int> myClass1Int;
typedef myNamespace::myClass2<int> myClass2Int;
Я склонен думать, что это Лучше четко указать, какие типы используются, чем пытаться сделать что-то вроде импорта конкретного экземпляра пространства имен.
Можете ли вы более полно описать проблему, которая заставляет вас думать, что шаблонные пространства имен были бы полезны?
И помните, что вы всегда можете написать бесплатную функцию make_myClass1 , чтобы определить тип шаблона для вас.
Вы не можете этого сделать, но вы можете предоставить другие пространства имен и определения типов (не то чтобы я это одобрял).
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;
}
и думаю, что объединю его с подходом Марка Б.
Ура, ребята!