Question

我熟悉C ++构造函数＆amp;初始化：

class Foo {
   int x;
public:
   Foo(int _x) : x(_x) {}
};

Foo foo1(37);
Foo foo2(104);

我的问题是我必须实现一个具有3x6数组成员的类。我将如何做与上述相似的事情？

class Bar {
   int coeff[3][6];
public:
   // what do I do for a constructor????
};

编辑：对于普通数组，我会做以下操作，我只是不知道如何为一个类做这个：

 static int myCoeffs[3][6] = 
 {{  1,  2,  3,  4,  5,  6}, 
  {  7,  8,  9, 10, 11, 12},
  { 13, 14, 15, 16, 17, 18}};

编辑2：出于各种原因（例如，这是一个有限制的嵌入式系统）我不需要使用Boost，所以如果它提供了解决方案，我就无法使用它。

更新：我没有与初始化程序绑定。可以在构造函数体中执行它，也不必是内联的。我只是在寻找一种正确的方法来构造一个需要系数数组的类的实例，而不会弄乱指针赋值等。

Answer 1

你做不到。在C ++ 03中，您无法在ctor-initalization列表中初始化数组。但是你可以在构造函数体中完成它（技术上它不再是初始化）。

那是

struct x
{
    int a[4];
    x():a({1,2,3,4}) //illegal
    {
        a[0] = 1;
        etc. 
    }
};

问题编辑之后

Edit:这是一种方法

#include <algorithm>
struct x
{
   int arr[3][4];
   x(int (&arg)[3][4])
   {
      std::copy(&arg[0][0], &arg[0][0]+3*4, &arr[0][0]);
   }

};

Answer 2

我不知道这听起来是否太明显，但为什么不只是复制这些值？

class Foo {
    static const int X = 3;
    static const int Y = 6;

    int mCoeff[X][Y];

    void setCoeff(int coeff[X][Y]) {
        for (int i = 0; i < X; i++) {
            for (int j = 0; j < Y; j++) {
                mCoeff[i][j] = coeff[i][j];
            }
        }
    }
public:
    Foo(int coeff[X][Y]) {
        setCoeff(coeff);
    }

};

希望它有所帮助。问候。

Answer 3

你不能（通常）将任意多维数组传递给C或C ++中的函数，就像在Java中一样（我提到Java，因为那是你的问题历史表明你的经验所在。）

在当前标准中，实际上没有办法支持类的数组初始值设定项，尽管有一些计划在下一个版本C ++ 0x中更改它。

如果你想让它具有Java的数组的灵活性（客户端可以改变指向数组的大小，你可以选择一些选项。第一个也是最好用的是std::vector<> ，它可以为您实现动态数组，但您可能会受到嵌入式平台的限制。您也可以将自己实现为一维数组，并接受动态内存块。示例：

class Foo
{
    int *theArray_;
    unsigned int rows_;
    unsigned int cols_;
public:
    Foo(int *theArray, int rows, int cols)
        : theArray_(theArray)
        , rows_(rows)
        , cols_(cols)
    { }
    void UseTheArray()
    {
        //Access array[5][6]
        theArray[5*cols+6];
    }
};

请注意，在这种情况下，被调用者负责处理内存。还要考虑使用上面的std::auto_ptr而不是原始指针来清楚地说明当对象被销毁时谁负责对内存块进行核对。

另请注意，您不应使用名称_x - 以下划线开头的名称附加了大量规则，您可能希望避免考虑这些规则。

编辑：这是我原来答案的一部分;这是错的：

C ++中的多维数组只是一个内存块。只有在一种情况下才可以接受这样的多维数组 - 在这种情况下，您可以事先知道数组中数组的确切尺寸。然后你可以编写类似的东西：

~~class Foo { int coeff[3][6]; public: Foo(int _x[3][6]) : coeff(_x) {} };~~

~~但请注意，数组的大小是固定的，并且您的类的客户端无法更改。~~

Answer 4

在C ++ 03中，由于无法在初始化列表中初始化数组，因此可以编写通用函数模板来填充具有给定数组的数组，如以下示例所示，

template<typename T, size_t N>
void array_fill(T (&dest)[N], T (&src)[N])
{
   for ( size_t i = 0 ; i < N ; i++ )
       dest[i] = src[i];
}
struct A
{
   int a[5];
   A(int (&i)[5]) { array_fill(a, i); }
   void print() 
   {
      for ( int i = 0 ; i < 5 ; i++ ) cout << a[i] << " ";
   }
};
int main() {
        int a[5] = {1,2,3,4,5};
        A obj(a);
        obj.print();
        return 0;
}

输出：

1 2 3 4 5

在ideone上运行：http://ideone.com/pFcrv

嗯，已经有std::copy也可以使用了。

Answer 5

如果你必须采用这种方式，我只需要进行for循环迭代二维数组的元素并初始化它们。或者，如果你想要速度，像memset这样的东西可以解决问题。

memset(&coeff,0,3*6*sizeof(int))

Answer 6

你可以这样做：

#include <algorithm>
class Bar 
{    
    int coeff[3][6]; 
public:    // what do I do for a constructor???? 
    Bar()
    {
        int myCoeffs[3][6] = 
        {
            {  1,  2,  3,  4,  5,  6},    
            {  7,  8,  9, 10, 11, 12},   
            { 13, 14, 15, 16, 17, 18}
        }; 
        std::swap(coeff, myCoeffs);
    }
};

C ++：数组的构造函数/初始化程序？

6 个答案: