包含不同大小静态数组的类的多个实例

Multiple instances of a class containing different-sized static arrays

本文关键字：实例 数组 静态 包含不      更新时间：2023-10-16

我需要有一个类的多个实例。每个实例都应包含一个预定义大小的数组。数组的大小是恒定的，并且在编译时可用，因此我想静态分配它们。

我必须将实例收集在一个"对象数组"中，以便我可以使用迭代器访问它们。我的问题：

  1. 使用构造函数参数的静态分配不起作用。
  2. 循环中对象的实例化不起作用。

下面是我想做的一个示例代码：

//Class definition of buffer
class mybuffertype{    
public:
mybuffertype(int size);
int bufsize;
float *buffer;    
};
//Constructor of buffer
mybuffertype::mybuffertype(int size){
bufsize=size;
buffer=new float[bufsize];      //Dynamic allocation
//float buffer[bufsize];        //This static allocation doesn't work
}
//Class definition of container
class container{    
public:
container();
static const int n_buffers=3;
const int n_sizes[n_buffers]={4,5,6};
mybuffertype mybuffers[n_buffers];     
};
//Constructor of container
container::container(void){      
int i;
for(i=0;i<n_buffers;i++){
mybuffertype mybuffers[i]= mybuffertype(n_sizes[i]);
}      
}
//Main
int main(void){    
container obj;    
int i;
for(i=0;i<obj.n_buffers;i++){
printf("Size: %d t 1st element: %fn",
obj.mybuffers[i].size,
obj.mybuffers[i].buffer[0]);
}
}

最好的方法是什么？

从大小的编译时列表中，可以创建(异类大小(缓冲区的集合。

template <size_t... Sizes>
class Container
{
std::tuple<std::array<double, Sizes>...> buffers;
public:
template<size_t I>
gsl::span<double> get() { return std::get<I>(buffers); }
// etc.
};

通过运行时索引访问缓冲区稍微棘手一些。如果您不在数据指针中包含大小，请将gsl::span<double>切换为double*。

template <size_t... Sizes>
class Container
{
std::tuple<std::array<double, Sizes>...> buffers;
std::array<gsl::span<double>, sizeof...(Sizes)> lookup;
template <size_t... Idxs>
array<gsl::span<double>, sizeof...(Sizes)> make_lookup(std::index_sequence<Idxs...>)
{
return { get<Idxs>(buffers)... };
}
public:
Container() : lookup(make_lookup(std::index_sequence_for<Sizes...>{})) {}
template<size_t I>
gsl::span<double> get() { return std::get<I>(buffers); }
gsl::span<double> operator[](size_t i) { return lookup[i]; }
// etc.
};

您正在将静态概念与实例化混合在一起。不能在构造函数中实例化静态数组或类。

你可以做这样的事情：


#include <cstdio>
using namespace std;
//Class definition of buffer
class mybuffertype{    
public:
mybuffertype(int size) {
bufsize=size;
buffer=new float[bufsize];      //Dynamic allocation
}
virtual ~mybuffertype() {
delete buffer;
}
int bufsize;
float *buffer;
};
class StaticData {
public:
StaticData(int n_buffers): n_buffers(n_buffers) {
mybuffers = new mybuffertype*[n_buffers];
for (int i = 0; i < n_buffers; ++i)
mybuffers[i] = new mybuffertype(3+i);
}
virtual ~StaticData() {
for (int i = 0; i < n_buffers; ++i)
delete mybuffers[i];
delete [] mybuffers;
}
const int n_buffers;
mybuffertype **mybuffers;
};
//Class definition of container
class MyContainer{
public:
static StaticData buffers;
};
StaticData MyContainer::buffers(3);
//Main
int main(int argc, char ** argv){    
for(int i = 0; i < MyContainer::buffers.n_buffers; i++){
printf("Size: %d t 1st element: %fn",
MyContainer::buffers.mybuffers[i]->bufsize,
MyContainer::buffers.mybuffers[i]->buffer[0]);
}
return 0;
}

所有静态缓冲区都在一个新的类StaticData中，该类只会调用构造函数一次，因为它在 MyContainer 中声明为静态。StaticData还利用了类的 C++11 数组初始化。

相关文章：