模板化的多堆栈实现 - 如何实现?
Templated multistack implementation - how?
我需要一个 'MultiStack' 获取不同类型的对象,将每种类型放在一个单独的堆栈中。
这是目前的样子。开放的问题是:如何处理多个不同 T
的容器
class MultiStack
{
public:
template<typename T>
const T& Get()
{
return Container<T>.back();
}
template<typename T>
void Push( const T& t )
{
Container<T>.push_back( t );
}
template<typename T>
void Pop( const T& /*t*/ )
{
Container<T>.pop_back();
}
private:
// this does not make sense, we obv. need one stack for each T
// template<typename T>
// std::vector<T> Container;
};
现在,我可以使用老办法,将 Container 放在成员函数中,例如
template<typename T>
auto GetContainer()
{
static std::vector<T> C;
return C;
}
但在多线程时代我不喜欢这样了。是'dangerous'对吧!?
有没有更好更优雅的方式?可以想象我事先知道允许的类型,如果这有助于实现它。
but I don't like this anymore in the age of multi-threading. It is 'dangerous', right!?
问题不在于多线程。初始化就好了。
不过,您仍然需要 protect/synchronize 访问权限,就像常规的多线程代码一样。
问题是容器不是 MultiTask
的每个实例,因为它是静态的。
这主要就好像 MultiTask
是一个单身人士。
It is conceivable that I know the allowed types beforehand, if that helps realizing it.
这很有帮助,然后你可以使用 std::tuple
,类似于 (C++14):
template <typename ... Ts>
class MultiStack
{
public:
template<typename T>
const T& Get() const
{
return GetContainer<T>().back();
}
template<typename T>
void Push(const T& t)
{
GetContainer<T>().push_back(t);
}
template <typename T>
void Pop()
{
GetContainer<T>().pop_back();
}
private:
template <typename T>
const std::vector<T>& GetContainer() const { return std::get<std::vector<T>>(Containers); }
template <typename T>
std::vector<T>& GetContainer() { return std::get<std::vector<T>>(Containers); }
private:
std::tuple<std::vector<Ts>...> Containers;
};
我需要一个 'MultiStack' 获取不同类型的对象,将每种类型放在一个单独的堆栈中。
这是目前的样子。开放的问题是:如何处理多个不同 T
的容器class MultiStack
{
public:
template<typename T>
const T& Get()
{
return Container<T>.back();
}
template<typename T>
void Push( const T& t )
{
Container<T>.push_back( t );
}
template<typename T>
void Pop( const T& /*t*/ )
{
Container<T>.pop_back();
}
private:
// this does not make sense, we obv. need one stack for each T
// template<typename T>
// std::vector<T> Container;
};
现在,我可以使用老办法,将 Container 放在成员函数中,例如
template<typename T>
auto GetContainer()
{
static std::vector<T> C;
return C;
}
但在多线程时代我不喜欢这样了。是'dangerous'对吧!?
有没有更好更优雅的方式?可以想象我事先知道允许的类型,如果这有助于实现它。
but I don't like this anymore in the age of multi-threading. It is 'dangerous', right!?
问题不在于多线程。初始化就好了。 不过,您仍然需要 protect/synchronize 访问权限,就像常规的多线程代码一样。
问题是容器不是 MultiTask
的每个实例,因为它是静态的。
这主要就好像 MultiTask
是一个单身人士。
It is conceivable that I know the allowed types beforehand, if that helps realizing it.
这很有帮助,然后你可以使用 std::tuple
,类似于 (C++14):
template <typename ... Ts>
class MultiStack
{
public:
template<typename T>
const T& Get() const
{
return GetContainer<T>().back();
}
template<typename T>
void Push(const T& t)
{
GetContainer<T>().push_back(t);
}
template <typename T>
void Pop()
{
GetContainer<T>().pop_back();
}
private:
template <typename T>
const std::vector<T>& GetContainer() const { return std::get<std::vector<T>>(Containers); }
template <typename T>
std::vector<T>& GetContainer() { return std::get<std::vector<T>>(Containers); }
private:
std::tuple<std::vector<Ts>...> Containers;
};