关于数组动态分配空间的问题（在线等）

[hejialin666]

问题：
数组的下标需要在程序运行的才能算出来，并且是个结构体数组。
struct PEOPLEINFO
{
long lID;
char cName[100];
int nAge;
char cSex;
};
PEOPLEINFO p[m];//这肯定编译不过的
查了一些资料后觉得要用下面的方式解决：
PEOPLEINFO* p=new PEOPLEINFO[m];
可是我不理解这是怎么回事？还有给结构体数组中的lID，cName[100]怎么赋值呀？
谢谢了！

[xhs_lh04]

PEOPLEINFO* p=new PEOPLEINFO[m];
动态分配了大小为m的结构体数组,首地址为p
可以用
p->cName来访问成员

[wuyu637]

new之后，先是调用内存的分配函数，给一块大小为100×struct大小的内存。
然后对这里的100个对象都调用默认的构造函数，如果没有默认构造函数，那么编译器会给你自动添加上一个什么都不做的构造函数
就是说，这里的成员变量都是0，null，一堆的空内存。

[Leejun527]

1，PEOPLEINFO p[m];这编译肯定通不过；
这种方式为静态分配，在编译期间必须指明数组的大小。所以不用变量m做数组长度。
2，PEOPLEINFO* p=new PEOPLEINFO[m];而这种就属于动态内存分配。
由程序自己控制在堆上分配多大空间，当然空间释放也得自己处理。
3，还有给结构体数组中的lID，cName[100]怎么赋值呀？
p->lID= 100;
strcpy(p->cName,"sfsdf");

[rzhangww]

[Quote=引用楼主 hejialin666 的帖子:]
问题：
数组的下标需要在程序运行的才能算出来，并且是个结构体数组。
struct PEOPLEINFO
{
long lID;
char cName[100];
int nAge;
char cSex;
};
PEOPLEINFO p[m];//这肯定编译不过的
查了一些资料后觉得要用下面的方式解决：
PEOPLEINFO* p=new PEOPLEINFO[m];
可是我不理解这是怎么回事？还有给结构体数组中的lID，cName[100]怎么赋值呀？
谢谢了！
[/Quote]

PEOPLEINFO p[m];//这肯定编译不过的 这种申请方式要求必须用常量 不能用变量m
new动态申请的时候可以用变量作为参数
p[m].lID = ....
p[m].cName = ......

[zuojianyou]

struct PEOPLEINFO
{
long lID;
char cName[100];
int nAge;
char cSex;
};
const int m = 10;
PEOPLEINFO p[m];
这样就可以了，如果m是个变量，不知道给p分配多大的空间。new的话是动态分配的。
如果是这样定义，可以这样调用p.cName;
如果是指针，p->cName

[lc19890326]

p[m]编译不过是因为m是要到运行期确定，而数组的大小应该在编译期确定
如果是p[5]p[10]这样的当然就可以了

PEOPLEINFO* p=new PEOPLEINFO[m];
这个就是动态分配 是在运行期算出了m的值再进行分配了。

赋值可以自己写一个构造函数，或者按照3楼讲的方法赋值

[hejialin666]

int m=5;
FILEINFO a=new FILEINFO[m];
(a+0)->lID=100;
(a+1)->lID=2;
cout<<(a+2)->lID;

输出结果为1094932293，请问这是怎么回事？不是调用构造函数都已经初始化了吗？

[wind1373290]

动态分配的时候值是随机给的

你上面的语句并没给(a+2)->lID赋值 所以它的值是不可预知的

[colourfuldavid]

[Quote=引用 7 楼 hejialin666 的回复:]
int m=5;
FILEINFO a=new FILEINFO[m]; // 你这里new了5个对象出来放在名字为FILEINFO的数组里
(a+0)->lID=100; // 给数组的第一个对象的lID成员变量赋值
(a+1)->lID=2; // 给数组的第二个对象的lID成员变量赋值
cout < <(a+2)->lID; // 输出数组第三个对象的lID成员变量的值

输出结果为1094932293 【你没有给(a+2)指向的对象的lID成员变量赋值,你new完之后，数组中这个成员变量的内存空间是个随机值，所以输出这样一个值】，请问这是怎么回事？不是调用构造函数都已经初始化了吗？
[/Quote]

[elmnd]

动态的在HEAP,非动态的在STACK...

#include <cstdlib>
#include <iostream>
struct PEOPLEINFO
{
long lID;
char cName[100];
int nAge;
char cSex;
};

using namespace std;

int main(int argc, char *argv[])
{
    int m=10;
    PEOPLEINFO p[m];
    system("PAUSE");
    return EXIT_SUCCESS;
}

这样吗？？这样倒是可以通过。。。

[wzfxyer]

[Quote=引用 3 楼 Leejun527 的回复:]
1，PEOPLEINFO p[m];这编译肯定通不过；
这种方式为静态分配，在编译期间必须指明数组的大小。所以不用变量m做数组长度。
2，PEOPLEINFO* p=new PEOPLEINFO[m];而这种就属于动态内存分配。
由程序自己控制在堆上分配多大空间，当然空间释放也得自己处理。
3，还有给结构体数组中的lID，cName[100]怎么赋值呀？
p->lID= 100;
strcpy(p->cName,"sfsdf");



[/Quote]

[太乙]

PEOPLEINFO p[m];//这肯定编译不过的 
查了一些资料后觉得要用下面的方式解决： 
PEOPLEINFO* p=new PEOPLEINFO[m]; 


可是我不理解这是怎么回事？


这个就是动态分配内存嘛！在运行之前，栈的大小是固定的！也就是已知的！

对于PEOPLEINFO p[m];这样的东西，我们分配的空间是在栈上！那么，在编译的时候，根本不知道m的具体值，你可能在某个地方修改了这个m（编译器这么假设）

所以，根本不能知道应该给分配多大的栈！所以编译不过！可以将m申明为const就行！它是不可修改的，那么编译器就认为你不可能在别的地方修改这个m，所以能通过


那么用new呢？因为我们知道，new、malloc都是在堆上分配大小，在运行前，堆的大小是不知道的，只是在运行的时候，动态的分配！第一次运行程序，new的可能是这个地址，第二次，又可能是另一个地址！

所以可以用new来实现动态分配！

不知道我说明白没？


还有给结构体数组中的lID，cName[100]怎么赋值呀？ 
谢谢了！


这个赋值很简单啊！

因为是结构体，默认方式是public访问，所以可以直接赋值：
long 是long int 的缩写，可以直接

结构体指针->lID = 10;
或者：结构体.lID = 10;

cName可以用memcpy来赋值
比如：

memcpy(结构体指针->cName,"hello");
memcpy(结构体.cName,"hello");
也可以！

[帅得不敢出门]

PEOPLEINFO p[m];//这肯定编译不过的 必须在编译时确定m的大小编译期分配 而m是运行时确定
PEOPLEINFO* p=new PEOPLEINFO[m]; //这个是运行时确定大小并分配空间
可是我不理解这是怎么回事？还有给结构体数组中的lID，cName[100]怎么赋值呀？
谢谢了！
一般是
对象.成员=xx;
指针->成员=xx
如果是数据strcpy(p->cName,"test");

[帅得不敢出门]

[Quote=引用 7 楼 hejialin666 的回复:]
int m=5;
FILEINFO a=new FILEINFO[m];
(a+0)->lID=100;
(a+1)->lID=2;
cout < <(a+2)->lID;

输出结果为1094932293，请问这是怎么回事？不是调用构造函数都已经初始化了吗？
[/Quote]
你没有定义默认构造函数
则由系统生成默认构造函数,但是对成员并没有做初始化操作. 成员值还是undefined的.

[P_ghost]

struct PEOPLEINFO
{
PEOPLEINFO():lID(0L), nAge(0), cSex(_T("男")) { for(int i=0; i<100; ++i)cName[i] = 0; }
long lID;
char cName[100];
int nAge;
char cSex;
};

[cutezjun]

我觉得用vector好些！！

[就呆在云上]

struct PEOPLEINFO 
{ 
	long lID; 
	char cName[100]; 
	int nAge; 
	char cSex; 
}; 
PEOPLEINFO p[m];//这肯定编译不过的 
不见得吧
如果m是常量是可以的，比如，在linux下们的gcc是可以通过的
m = 10;
const int n = n;
PEOPLEINFO p[n];
这个windows下不能通过,呵呵，但是如果之前#define是可以的
#define m 10
PEOPLEINFO p[m];
也是可以的。

其实c或c＋＋标准都规定了数组的定义大小一定要一个常量。

当然下面的肯定是可以的，因为动态分配目标就是动态的分配，不会限制你的分配大小

PEOPLEINFO* p=new PEOPLEINFO[m];