C ++在编译时在两个变量之间交替 [英] C++ Alternating between two variables at compile time
问题描述
假设您有一个对向量进行运算的类:
Suppose you have a class that operates on a vector:
class Foo{
public:
Foo() {
m_dynamic_data.push_back(5);
std::cout << m_dynamic_data[0] << std::endl;
}
private:
std::vector<int> m_dynamic_data;
};
在我的情况下,该类非常丰富,包含2500行附加代码。
此类的行为是动态的(因此 std :: vector
)。但我也想提供一个静态实现(使用 std :: array
)。因此,添加了 std :: size_t N
,它现在应该控制何时使用哪个属性。
In my case this class is huge with 2500 additional lines of code.
This class behaves dynamic (hence std::vector
). But I would also like to provide a "static" implementation (using std::array
). So std::size_t N
is added, which now should control when to use which attribute.
template<std::size_t N>
class Foo{
private:
std::vector<int> m_dynamic_data; //use this, when N == 0
std::array<int, N> m_static_data; //use this, when N != 0
};
我不确定是否可以使用它。使用 #define
不会执行此操作(因为它不能更改)。 constexpr
也不能包装在两个属性中。最好的解决方案可能是提供一个基类,然后从中继承动态和静态的情况。但是在我接下来的几天里这样做之前,我想知道是否还没有一种技术。
I am not sure if I can get this to work. using #define
won't do the job (since it can't alternate). constexpr
can't be wrapped around two attributes either. The best solution is probably to provide a base class and then inherit the dynamic and static case from it. But before I spent the next days doing this, I wonder if there isn't a technique afterall.
我考虑过将两者都放入 std :: unique_ptr
并仅构造相关的数组:
I thought about putting both into a std::unique_ptr
and only constructing the relevant array:
template<std::size_t N>
class Foo {
public:
Foo() {
if constexpr (N) {
m_static_data_ptr = std::make_unique<std::array<int, N>>();
(*m_static_data_ptr)[0] = 5;
std::cout << (*m_static_data_ptr)[0] << std::endl;
}
else {
m_dynamic_data_ptr = std::make_unique<std::vector<int>>(1);
(*m_dynamic_data_ptr)[0] = 5;
std::cout << (*m_dynamic_data_ptr)[0] << std::endl;
}
}
private:
std::unique_ptr<std::vector<int>> m_dynamic_data_ptr;
std::unique_ptr<std::array<int, N>> m_static_data_ptr;
};
我早些时候问过这种情况此处。但这显然不是一个好方法。 (碎片内存,缓存未命中率)。 std :: optional
似乎也很有趣,但是它使sizeof(Foo)超出了我的目标。
I earlier asked about this case here. But apparently this doesn't seem like a good approach. (fragmenting memory, cache miss rate). std::optional
also seems interesting, but it pushes the sizeof(Foo) too far for my goal.
最终,还会使用 void
指针:
template<std::size_t N>
class Foo {
public:
Foo() {
if constexpr (N) {
m_data = malloc(sizeof(std::array<int, N>));
(*static_cast<std::array<int, N>*>(m_data))[0] = 5;
std::cout << (*static_cast<std::array<int, N>*>(m_data))[0] << std::endl;
}
else {
m_data = new std::vector<int>;
(*static_cast<std::vector<int>*>(m_data)).push_back(5);
std::cout << (*static_cast<std::vector<int>*>(m_data))[0] << std::endl;
}
}
~Foo() {
delete[] m_data;
}
private:
void* m_data;
};
但这似乎很脏[...]
所以目标是工作在编译时使用任一数组结构。谢谢您的任何帮助/建议!
But this seems pretty dirty [...] So the goal would be to work with either array structure at compile time. Thanks for any help / suggestion!
推荐答案
R Sahu的答案很好,但是您不需要通过以下方式间接访问容器一个结构。
R Sahu's answer is great, but you don't need to access the container indirectly through a struct.
template<std::size_t N>
struct FooData { using type = std::array<int, N>;};
template <>
struct FooData<0> { using type = std::vector<int>; };
template<std::size_t N>
using FooData_t = typename FooData<N>::type;
template<std::size_t N>
class Foo{
private:
FooData_t<N> data;
};
或者,您也可以使用 std :: conditional_t
:
template<std::size_t N>
class Foo{
private:
std::conditional_t<N==0, std::vector<int>, std::array<int, N>> data;
};
这篇关于C ++在编译时在两个变量之间交替的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!