如何生成一个动态数组？

[cdo]

在C里面不能生成一个大小未知的数组，但又经常经到这样的问题。（比如要把一个字符串中的字符放到数组中去，在不确定字符串长度时，也不知道要定义多大的数组。我以前都是直接定义一个1024大小的数组，但这样并不好）。

请问大家是如何解决这样的问题的呢？

[zez]

没有办法,只能这样 !!

如果自己管理动态数组,实现一个类似 vectore的东西, 受累不讨好

[寻开心]

用指针啊

char * pChar;

// 分配
pChar = (char *) malloc(char[xyz]);

// 使用

// 释放
free(pChar);

[屋顶上的老猫]

不可以定义动态数组，这是语法错误，不被编译器允许！

方法一、使用指针，利用realloc()函数更改分配内存的大小；
方法二、使用链表进行动态储存；

[oyljerry]

可以在文件外面用const定义数组的长度啊。
或者动态分配

[megaboy]

动态数组可以如下这样建立，以二维为例：

//iRow、iColumn为第一维、第二维上界

char **p = (char**)malloc(iRow*sizeof(char*));
for(i=0; i<iRow; ++i) p[i] = (char*)malloc(iColumn*sizeof(char));

//这样就可以p[i][j]的形式使用了

如果是一维，直接char *p = (char*)malloc(iColumn*sizeof(char));就得了，同样可以p[i]的形式使用。

要注意的是，动态数组并不是VLA（可变长数组），两者是有本质区别的，C99实现的是可变长数组（C89不支持），不是动态数组。

[duduhaha]

按照楼主的意思并不是需要二维动态数组。
#define INIT_SIZE 100
char *p = (char *)malloc(sizeof(char) * INIT_SIZE);
当觉得大小不够用的时候，利用realloc函数可以增大空间。realloc函数的使用是需要注意的。

realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；可如果数据后面的字节不够的话，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上。

网上找的，呵呵。就是说你不要这么用。
char *p = (char *)malloc(sizeof(char) * INIT_SIZE);
q = p;
p = (char *)realloc(p,sizeof(char) *INIT_SIZE *2);
q[1] = 'a';//对q[1]的访问可能出问题。

[dragonzxh]

在C++中实现变长数组


1.变长一维数组

这里说的变长数组是指在编译时不能确定数组长度，程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组，你可以这样做：

//文件名: array01.cpp
#include<iostream>
using namespace std;

int main()
{
int len;
cin>>len;
//用指针p指向new动态分配的长度为len*sizeof(int)的内存空间
int *p=new int[len];
...........
delete[] p;
return 0;
}

注意int *p=new int[len];这一句，你不能这样做：
int p[len];
C++编译器会报错说len的大小不能确定，因为用这种形式声明数组，数组的大小需要在编译时确定。而且这样也不行：
int p[]=new int[len];
编译器会说不能把int*型转化为int[]型，因为用new开辟了一段内存空间后会返回这段内存的首地址，所以要把这个地址赋给一个指针，所以要用int *p=new int[len];

array01.cpp实现了一个变长的一维数组，但是要养成一个好习惯，就是注意要注销指针p，使程序释放用new开辟的内存空间。
当然使用C++标准模版库（STL）中的vector（向量）也可以实现变长数组：

//文件名: array02.cpp
#include<iostream>
#include<vector>
using namespace std;

int main()
{
int len;
cin>>len;
vector<int> array(len);//声明变长数组

for(int i=0;i<len;i++)
{
array[i]=i;
cout<<array[i]<<"\t";
}
return 0;
}

这里的变长数组让我联想到了java的java.util包中的vector和C#中的ArrayList，它们也可以在各自的语言中实现变长数组。不过C++中的vector不能像C#一样有托管的垃圾回收机制回收被占用的内存空间，但是你可以在使用完vector后调用~vector()析构函数释放内存。

2.变长n维数组
变长的n维数组实现起来有些麻烦，但是在工程与软件设计应用中常使用的是二维数组，所以在这里着重介绍变长的二维数组，变长的n维数组可以按照类似的方法实现。首先看一个经典的用C实现变长二维数组的例子：

//文件名: array03.c
#include <stdio.h>
#include <malloc.h>

void main()

{
int x,y,i,j;
float **a,*b;
printf("请输入你所求解的线性方程组的行数x：x=");
scanf("%d",&x);
printf("请输入你所求解的线性方程组的列数y：y=");
scanf("%d",&y);

a=(float **)malloc(sizeof(float *) *x);
b=(float *)malloc(sizeof(float) *x);
for(i=0;i<x;i++)
{
*(a+i)=(float *)malloc(sizeof(float) *y);
}

/*读入数据*/

printf("请按行的顺序依次输入系数的值(共%d项)：",x*y);
for(i=0;i<=x-1;i++)
for(j=0;j<=y-1;j++)
scanf("%f",&a[i][j]);
printf("请按列的顺序依次输入常数的值(共%d项)：",x);
for(j=0;j<=x-1;j++)
scanf("%f",&b[j]);

printf("您输入方程组的增广矩阵为：\n");
for(i=0;i<=x-1;i++)
{
for(j=0;j<=y-1;j++)
printf("%.5f ",a[i][j]);
printf("%.5f ",b[i]);
printf("\n");
}
free(b);
for(i=0;i<x;i++)
free (*(a+i));

}

那么用C++怎样实现呢？在C++中可以通过new和delete运算符动态开辟和释放空间，其中new与C中malloc函数的功能相似，delete与C中free函数的功能相似。用C++实现变长二维数组时可以采用两种方法：双指针方法和使用STL中vector（向量）的方法。

首先介绍一下双指针方法，在这里双指针就是指像指针的指针，比如你可以这样声明一个数组：
int **p = new int*[num1];
而对每一个*p（一共num1个*p）申请一组内存空间：
for(int i=0; i<num1; ++i)
p[i] = new int[num2];
其中，num1是行数，num2是数组的列数。测试的源程序如下：

//文件名: array04.cpp
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
int num1,//行数
num2;//列数

cout<<"Please enter the number for row and column: "<<endl;
cin >> num1 >> num2;

//为二维数组开辟空间
int **p = new int*[num1];
for(int i=0; i<num1; ++i)
p[i] = new int[num2];

for(int j=0;j<num1;j++)
{
for(int k=0;k<num2;k++)
{
p[j][k]=(j+1)*(k+1);
cout<<setw(6)<<p[j][k]<<':'<<setw(8)<<&p[j][k];
}
cout<<endl;
}

//释放二维数组占用的空间
for(int m=0;m<num1;m++)
delete[] p[m];
delete[] p;

return 0;
}

以下是运行结果：

Please enter the number for row and column:
4 5
1:004915F0 2:004915F4 3:004915F8 4:004915FC 5:00491600
2:00491180 4:00491184 6:00491188 8:0049118C 10:00491190
3:00491140 6:00491144 9:00491148 12:0049114C 15:00491150
4:00491100 8:00491104 12:00491108 16:0049110C 20:00491110
Press any key to continue

程序清单array04.cpp可以显示分配的内存空间单元的地址，大家可以看到，由于数组空间是动态分配的，数组行之间的地址空间是不连续的，因为不同行的数组元素的地址空间是用不同的new来分配的。而每一行之中列之间的地址空间是连续的。

那么用vector（向量）怎样实现二维数组呢？以下给出源程序：

//文件名: array05.cpp
#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
int main()
{
int i,
j,
m, //行数
n; //列数

cout << "input value for m,n:";
cin>>m>>n;

//注意下面这一行：vector<int后两个">"之间要有空格！否则会被认为是重载">>"。
vector<vector<int> > vecInt(m, vector<int>(n));
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
vecInt[i][j] = i*j;

for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
cout<<setw(5)<<vecInt[i][j]<<":"<<setw(9)<<&vecInt[i][j];
cout<<endl;
}

return 0;
}

以下是运行结果：

input value for m,n:3 4
0: 00491180 0: 00491184 0: 00491188 0: 0049118C
0: 00491140 1: 00491144 2: 00491148 3: 0049114C
0: 00491100 2: 00491104 4: 00491108 6: 0049110C
Press any key to continue

大家可以看到，这里vector中元素的内存的地址分配也有同双指针实现的二维数组有同样的特点。不过用vector的方法比使用双指针简单地多，分配内存空间时会更安全，数组初始化代码也更简单，所以本人建议使用STL中的vector来实现变长多维数组。以下是一个变长三维数组：）

//文件名: array06.cpp
#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
int main()
{
int i,
j,
k,
m, //一维坐标
n, //二维坐标
l; //三维坐标


cout << "input value for m,n,l:";
cin>>m>>n>>l;
vector<vector<vector<int> > > vecInt(m, vector<vector<int> >(n, vector<int>(l)));
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
for(k = 0; k < l; k++)
vecInt[i][j][k] = i+j+k;

for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
for(k = 0; k<l; k++)
cout<<setw(5)<<vecInt[i][j][k]<<":"<<setw(9)<<&vecInt[i][j][k];
cout<<endl;
}
cout<<endl;
}

return 0;
}

运行结果：
input value for m,n,l:2 3 4
0: 00492FE0 1: 00492FE4 2: 00492FE8 3: 00492FEC
1: 00492FA0 2: 00492FA4 3: 00492FA8 4: 00492FAC
2: 00492F60 3: 00492F64 4: 00492F68 5: 00492F6C

1: 00492EC0 2: 00492EC4 3: 00492EC8 4: 00492ECC
2: 00492E80 3: 00492E84 4: 00492E88 5: 00492E8C
3: 00492E40 4: 00492E44 5: 00492E48 6: 00492E4C

[FBIq]

malloc+realloc

[cn_archer]

我觉得用链表的形式做比较稳妥。

[healer_kx]

C99支持了... ...

如果你的编译器不支持, 可以参考一下这篇文章.

http://spaces.msn.com/members/healerkx/Blog/cns!1p8Uy5hEQ58U7Y_F2WjxGIeA!237.entry

[iewin]

malloc+realloc

[逸学堂]

自己动态规划内存就可以.
仿照STL中Vector
比如
开始定义
int *p = (int*)malloc(sizeof(int)*2);
当插入数据大于2
int *p1 = p;
p = (int*)malloc(sizeof(int)*4);

memcopy(p,p1);
free p1;

以次论推.这样实现内存动态增长

[gogowhy]

m

[dhongda]

C99中是支持变长数组的

[FreedomAllen]

我还是喜欢用动态链表......

[iamfunction]

学习