如何创建一个行为如此的函数？我似乎无法正确声明返回类型.
template <typename C, typename T0, typename T1>
typename C<T1>
convert_container(const C<T0>& container, T1 value) {
C<T1> new_container;
// Do some stuff...
return new_container;
}
std::vector<int> vec0;
const auto& vec1 = convert_container(vec0, float(2.0f)); // Produce a vector of floats
std::list<int> lst0;
const auto& lst1 = convert_container(lst0, float(2.0f)); // Produce a list of floats
使用variadic模板模板参数时,要使用sizeof获取参数数量(...)GCC和Clang有不同的要求.GCC要求您填写可变参数的模板参数,而Clang要求您不要这样做.由于它们都声称符合标准,因此必须有错误或标准必须含糊不清(如果它们应在c ++ 1y中更正).
示例(http://ideone.com/5TWFKY上的完整可编辑示例):
template<template <class> class... T>
struct X
{
/* code goes here */
};
GCC(注意:在这种情况下,Z是任何非模板类):
static const constexpr size_t count = sizeof...(T<Z>);
铛:
static const constexpr size_t count = sizeof...(T);
MSVC 2013(完整性 - 与Clang w/out constexpr相同,不支持):
static const size_t count = sizeof...(T);
所以我有一个表格类:
template <typename T, template <typename T> class Container = std::vector>
class MyArray : Container<T>
{
...
}
现在我试图将其实例化为
template <typename T>
class MyClass
{
MyArray<T> array;
}
这产生了一个错误:
error: type/value mismatch at argument 2 in template parameter list for 'template<class T, template<class T> class Container> class MyArray'
MyArray<T> y;
而它指向>的MyArray<T>.
这有什么不对？为什么我没有默认模板参数？
谢谢.
我有一个traits类,AttributeTraits,它使用智能指针模板类MySmartPointer:
template<typename T>
class MySmartPointer {};
template<template <typename> class SP = MySmartPointer>
struct AttributeTraits {
template <typename T>
using SmartPointerClass = SP<T>;
};
AttributeTraits使用别名来保存它拥有的模板类.现在,我需要获取特征类的Attribute类将使用typedef/alias到智能指针类,例如:
template <typename Traits>
struct Attribute {
typedef typename Traits::SmartPointerClass<int> SmartPointerType; // error: non-template 'SmartPointerClass' used as template
using SmartPointerType2 = typename Traits::SmartPointerClass<int>; // error: expected ';' before '<' token
using SmartPointerType3 = Traits::SmartPointerClass<int>; // error: non-template 'SmartPointerClass' used as template
};
但上面的3个选项都不起作用......
我想为各种类层次结构提供适当的克隆机制.看起来像是一个合理的想法,我拼凑了一个基本的解决方案,使用CRTP clone()在派生类中实现必要的功能.
我进一步使用模板模板参数模板化它以允许策略控制克隆的存储/所有权:
template <typename base, typename derived>
struct clone_raw
{
typedef derived * return_type;
static return_type clone(const base * original) { return new derived(static_cast<const derived &>(*original)); }
};
template <typename base, typename derived>
struct clone_shared
{
typedef std::shared_ptr<derived> return_type;
static return_type clone(const base * original) { return std::make_shared<derived>(static_cast<const derived &>(*original)); }
};
template <typename base, typename derived>
struct clone_unique
{
typedef std::unique_ptr<derived> return_type;
static return_type clone(const base * original) { return std::make_unique<derived>(static_cast<const derived &>(*original)); }
};
// derived …考虑bool技巧来检查一堆类型是否都是相同的类型:
template<typename Type, typename... Types>
static constexpr bool allOf = std::is_same<
std::integer_sequence<bool, true, std::is_same<Type, Types>::value...>,
std::integer_sequence<bool, std::is_same<Type, Types>::value..., true>
>::value;
例如,可以使用它来检查所有参数是否为int值:
template<typename... Args>
void f(Args&&... args) {
static_assert(allOf<int, Args...>, "!");
// ...
}
有没有办法将它与给定模板模板参数的特化一起使用？
例如,使用以下代码:
template<typename> struct S {};
template<typename... Args>
void f(Args&&... args) {
static_assert(allOf<S, Args...>, "!");
// ...
}
该allOf变量应定义为:
template<template<typename> class Type, typename... Types>
static constexpr bool allOf = ???;
我想检查每个T在Types的形式是一个专业化S<U>,不知道什么事U.
可能吗？
我想编写一个函数，该函数采用任何类型的通用容器并打印它。
让我们暂时搁置它不适用于某些关联容器并关注这个问题：
template<template<typename> typename Cont, typename T>
void print(const Cont<T>& cont)
{
for (const auto it : cont)
{
cout << it << " ";
}
cout << endl;
}
int main()
{
vector<string> v;
print(v);
}
错误指出：
template<template<typename> typename Cont, typename T>
void print(const Cont<T>& cont)
{
for (const auto it : cont)
{
cout << it << " ";
}
cout << endl;
}
int main()
{
vector<string> v;
print(v);
}
谁能解释为什么编译器不能在这里推断出类型？
即使我明确声明print<vector<string>>(v)？
我想写这样的代码:
template <typename K, typename T, template <typename, typename> class C>
boost::optional<T> search(const C<K, T>& dict,
const K& key)
{
auto it = dict.find(key);
if (it != dict.end()) {
return it->second;
} else {
return boost::none;
}
}
希望能够(std::[unordered_][multi]map)使用字典界面在各种容器上调用上述函数,如:
std::map<std::string, Foo> strToFoo;
auto val = search(strToFoo);
我知道功能模板不允许使用模板模板参数.但还有另一种方法可以达到同样的效果吗？
我正在尝试制作"复合"模板类型.像这样的东西
template <typename A, typename T>
class configurator
{
public:
configurator(const A<T> & adapter) : m_adapter(adapter) {}
private:
A<T> m_adapter;
};
编译器抱怨
error: expected ')'
configurator(const A<T> & adapter
^
为什么这不起作用？它可以使它工作吗？
在想出正确的术语来充分搜索时遇到了麻烦，但是标准库是否有一些东西可以测试相同的基本模板类型？
template <typename T>
struct foo {};
template <typename T>
struct bar {};
static_assert(std::is_same_base_type<foo<int>, foo<float>>::value == 1);
static_assert(std::is_same_base_type<foo<int>, bar<int>>::value == 0);