C++ 如何在C++；上课？ < /P>

我想要一个有5个数组作为字段的类。 这些数组的大小应该是动态初始化的

我已经写了一些代码，但这不起作用，你知道：

class ParsedData {
  public:
    int generators_count;
    double mean_arr[generators_count];
    double variance_arr[generators_count];
    int amount_of_numbers_to_generate_arr[generators_count];
    int intervals_count;
    double interval_begins_arr[intervals_count];
    double interval_ends_arr[intervals_count];
};

ParsedData::ParsedData(int _generators_count, double[] _mean_arr, double[] _variance_arr, int[] _amount_of_numbers_to_generate_arr,
    int _intervals_count, double[] _interval_begins_arr, double[] _interval_ends_arr) {
  generators_count = _generators_count;
  mean_arr = _mean_arr;
  variance_arr = _variance_arr;
  amount_of_numbers_to_generate_arr = _amount_of_numbers_to_generate_arr;
  intervals_count = _intervals_count;
  interval_begins_arr = _interval_begins_arr;
  interval_ends_arr = _interval_ends_arr;
}

编译错误日志：

z01.cpp:53:9: error: invalid use of non-static data member ‘ParsedData::generators_count’
z01.cpp:54:21: error: from this location
z01.cpp:53:9: error: invalid use of non-static data member ‘ParsedData::generators_count’
z01.cpp:55:25: error: from this location
z01.cpp:53:9: error: invalid use of non-static data member ‘ParsedData::generators_count’
z01.cpp:56:43: error: from this location
z01.cpp:57:9: error: invalid use of non-static data member ‘ParsedData::intervals_count’
z01.cpp:58:32: error: from this location
z01.cpp:57:9: error: invalid use of non-static data member ‘ParsedData::intervals_count’
z01.cpp:59:30: error: from this location
z01.cpp:62:56: error: expected ‘,’ or ‘...’ before ‘_mean_arr’
z01.cpp:62:1: error: prototype for ‘ParsedData::ParsedData(int, double*)’ does not match any in class ‘ParsedData’
z01.cpp:51:7: error: candidates are: ParsedData::ParsedData(const ParsedData&)
z01.cpp:51:7: error:                 ParsedData::ParsedData()
z01.cpp: In function ‘ParsedData load_input_data()’:
z01.cpp:102:62: error: no matching function for call to ‘ParsedData::ParsedData(int&, double [(((sizetype)(((ssizetype)generators_count) + -1)) + 1)], double [(((sizetype)(((ssizetype)generators_count) + -1)) + 1)], int [(((sizetype)(((ssizetype)generators_count) + -1)) + 1)], int&, double [(((sizetype)(((ssizetype)intervals_count) + -1)) + 1)], double [(((sizetype)(((ssizetype)intervals_count) + -1)) + 1)])’
z01.cpp:102:62: note: candidates are:
z01.cpp:51:7: note: ParsedData::ParsedData()
z01.cpp:51:7: note:   candidate expects 0 arguments, 7 provided
z01.cpp:51:7: note: ParsedData::ParsedData(const ParsedData&)
z01.cpp:51:7: note:   candidate expects 1 argument, 7 provided

---

有没有办法解决这个问题？

std:：vector

。C样式数组的大小必须是编译时常数。C++中的

，你将使用<代码> STD:：vector < /代码>，并将其初始化为构造函数所需的大小。例如：

#include <vector>

class Foo
{
 public:
  Foo(int i) : intervals_count(i), interval_begins_arr(intervals_count) {}
 private:
  int intervals_count;
  std::vector<double> interval_begins_arr;
};

#包括
福班
{
公众：
Foo（inti）：区间数（i），区间开始数（区间数）{}
私人：
整数区间与单位计数；
std：：向量间隔开始；
};

初始化该类时，generators\u count没有值，这意味着您不能使用它来确定数组的大小。您可以使用std:：vector吗？

使用a或使用

双精度*

然后使用

新

进行分配（仅当初始分配后大小不会改变时）

---

数组要求在编译时知道大小

我建议使用

std:：vector

，如下所示

class ParsedData {
    std::vector<double> mean_arr, variance_arr, interval_begins_arr, interval_ends_arr;
    std::vector<int> amount_of_numbers_to_generate_arr;

    ParsedData(std::vector<double> mean_arr,
            std::vector<double> variance_arr,
            std::vector<double> interval_begins_arr,
            std::vector<double> interval_ends_arr,
            std::vector<int> amount_of_numbers_to_generate_arr)
        : mean_arr(mean_arr), variance_arr(variance_arr)
        , interval_begins_arr(interval_begins_arr), interval_ends_arr(interval_ends_arr)
        , amount_of_numbers_to_generate_arr(amount_of_numbers_to_generate_arr) {}
}

类解析数据{
向量平均值，方差，区间开始，区间结束；
std：：要生成的向量数量；
ParsedData（标准：：向量平均值），
标准：：向量方差，
std：：向量间隔从开始到结束，
标准：：向量间隔结束，
std:：向量数量（生成的数量）
：平均值（平均值）、方差（方差）
，间隔开始（间隔开始），间隔结束（间隔结束）
，数量_的数量_到生成_arr（数量_的数量_到生成_arr）{
}

可以用C++：C++或数组将指针转换为向量：

int count = 5;
int a[count] = {1, 2, 3, 4, 5};
std::vector<int> vec_a(a, a+5);

int计数=5；
int a[count]={1,2,3,4,5}；
std：：向量向量向量a（a，a+5）；

如果编译时已知

生成器\u计数

和

间隔\u计数

[但整个程序没有一个常数]，则可以使用

模板

template <const int T1, const int T2>
class ParsedData {
  public:
    int generators_count;
    double mean_arr[T1];
    double variance_arr[T1];
    int amount_of_numbers_to_generate_arr[T1];
    int intervals_count;
    double interval_begins_arr[T2];
    double interval_ends_arr[T2];
};

模板
类解析数据{
公众：
整数单位计数；
双平均值_arr[T1]；
双方差_arr[T1]；
生成的整数数量[T1]；
整数区间与单位计数；
双间隔开始于[T2]；
双间隔_结束_arr[T2]；
};

否则，如其他地方所建议的，使用

向量

---

我个人喜欢使用一个

struct

保存生成器值，另一个

struct

保存间隔数据的建议-节省向量的数量。[我甚至可能在提出这个结构之前就已经这么做了，因为它使生活更容易看到所有这些都属于一个整体]。

好吧。第一个答案是：您应该尝试

std:：vector.

但是看看你的代码…你的意图是什么

ParsedData

as-is-in-in-your-code只是一种到实际数组的接口，其中包含数据，除了在ParsedData中复制一个引用（实际上是指针）之外，您没有复制任何东西，但是数据在其他地方。这是你的意图吗

如果是，您可以使用simple

double*maen\u arr等

如果没有，你实际上需要一个数据的拷贝，那么请考虑使用<代码>矢量< /代码>。< /p>为什么不使用向量代替？代码>标准：：向量间隔\u开始\u arr

相关：我引用的是他的代码。我意识到它不符合标准。对不起，我今天似乎不能正确阅读。

template <const int T1, const int T2>
class ParsedData {
  public:
    int generators_count;
    double mean_arr[T1];
    double variance_arr[T1];
    int amount_of_numbers_to_generate_arr[T1];
    int intervals_count;
    double interval_begins_arr[T2];
    double interval_ends_arr[T2];
};