C++ C++；静态尺寸数组的动态分配数组

我需要创建一个包含可变数量“char[2]”的结构，即2个char的静态数组

我的问题是，如何为x个字符分配内存[2]

我尝试过这样做（假设定义了int x）：

（它不起作用）

我意识到我可以使用std:：vector作为容器，但我很好奇如何使用原始指针

对于C++和尝试学习，我是很新的。

unsigned x=10;
typedef char A2[2];
A2 *m=new A2[x];
m[0][1]='a';
m[9][0]='b';
delete[] m;

C多维数组（除第一个维度外所有维度都是常量）是连续排列的

如果您想要一个（可能是锯齿状的）多维数组，它是由一维数组组成的一维数组，则必须循环：

  char **m=new char *[x];
  for (unsigned i=0;i<x;++i) m[i]=new char[2];
  ...
  for (unsigned i=0;i<x;++i) delete[] m[i];
  delete[] m;

char**m=new char*[x]；
对于（unsigned i=0；i，您将最终确定数组的大小，然后使用new，并将其视为二维数组

但是，为了更好地讨论这一点，您可能需要了解：
在您的代码中，“m”的类型与您的“新”呼叫不匹配。您需要的是：

char (*m)[2] = NULL;
m = new char[x][2];
...
delete [] m;

m是指向2个字符数组的指针，您可以调用new来获得一个2个字符的x数组数组，并在第一个字符处指向m。
我相信下面的代码比
char[n][2]可读性更好。
：

typedef char wchar[2];   // array of two chars
const size_t n = 100;    // some const
wchar* x = new wchar[n]; // array of wchars, where wchar is array of two chars

// here is still a problem that you could write the following
x[5][5] = 0;             // not what you expected?

delete[] x;              // clean up

如果我们了解wchar的内部结构，那么如果我们按照以下方式声明代码，代码将更具可读性：

// using struct is just gives names to chars in wchar, without performance drop
struct wchar {
  char h;
  char l;
};

...

const size_t n = 100;    // some const
wchar* x = new wchar[n]; // array of wchars

x[0].h = 0;
x[0].l = 0;

delete[] x;              // clean up

最后，由于我们使用C++，不需要使用C数组：
const size_t n = 100;    // some const   
typedef std::tr1::array<wchar, n> my_arr;
my_arr* x = new my_arr;

(*x)[0].h = 0;
(*x)[0].l = 0;

delete x;

const size\u t n=100；//一些常量
typedef std:：tr1:：数组我的数组；
my_arr*x=新my_arr；
（*x）[0].h=0；
（*x）[0].l=0；
删除x；

编译时范围检查还有一个非常安全的选项：

template<int n_max>
struct array_n {
    char v[2*n_max];

    template<size_t n, size_t s> 
    char& get() {
        BOOST_STATIC_ASSERT( s < 2 );
        BOOST_STATIC_ASSERT( n < n_max );
        return v[n*2+s];
    };  
};

int main( int argc, char**argv)
{
    const size_t n = 100;    // some const   
    typedef array_n<100> my_arr;
    my_arr* x = new my_arr;

    x->get<10, 1>() = 0;   // ok
    x->get<50, 0>() = 0;   // ok
    x->get<10, 2>() = 0;   // compile time error
    x->get<500, 0>() = 0;  // compile time error

    delete x;
}

模板
结构数组{
字符v[2*n_max]；
模板
char&get（）{
BOOST\u STATIC\u ASSERT（s<2）；
BOOST\u STATIC\u ASSERT（nget（）=0；//确定
x->get（）=0；//确定
x->get（）=0；//编译时错误
x->get（）=0；//编译时错误
删除x；
}
@j_random_hacker，这是一个“指向2个字符数组的指针”。没有数组。“指向2个字符数组的指针数组”看起来像
char（*m[N]）[2]；
，如果你没有N个独立的
新的
调用：）+1@Chris xd，你完全正确——我怎么搞砸了？！我已经删除了那个误导性的评论。虽然使用typedef通常更容易：
typedef char2[2]；char2*m=新字符[x][2]不错。使用
typedef
方法需要注意的一点是，如果您碰巧分配了一个
wchar
（而不是
wchar
——例如
wchar*m=new wchar；
），您仍然必须使用
delete[]m。利特注意到另一根线上有个难看的洞。谢谢你的回答。这些都是更简单的方法。@j_random_hacker，这就是为什么使用
struct
更可取的原因。
template<int n_max>
struct array_n {
    char v[2*n_max];

    template<size_t n, size_t s> 
    char& get() {
        BOOST_STATIC_ASSERT( s < 2 );
        BOOST_STATIC_ASSERT( n < n_max );
        return v[n*2+s];
    };  
};

int main( int argc, char**argv)
{
    const size_t n = 100;    // some const   
    typedef array_n<100> my_arr;
    my_arr* x = new my_arr;

    x->get<10, 1>() = 0;   // ok
    x->get<50, 0>() = 0;   // ok
    x->get<10, 2>() = 0;   // compile time error
    x->get<500, 0>() = 0;  // compile time error

    delete x;
}