⑴ c语言中结构体数组的大小如何动态分配
结构体类型数据组就和我们平常定义的基本类型的数组一样，只不过是类型变了。
基本类型数组动态分配大小：
int* a = (int*)malloc(sizeof(int)*10) ; //动态分配10个大小的int类型的内存空间
结构体类型数组分配大小：
struct DIYDEFINE
{
int a;
char ch;
long lnum;
};
DIYDEFINE* pDiy = (DIYDEFINE*)malloc(sizeof(DIYDEFINE)*10); //动态分配10个大小的结构体类型DIYDEFINE的内存空间。
⑵ 怎么实现C语言里面数组的动态分配
1 定义指针。
2 使用malloc函数分配内存。
3 对数组进行访问即可。
对于一维动态数组，直接定义一维指针，并分配内存空间即可。
比如int类型的10个元素动态数组，写作
int *a;
a = (int *)malloc(sizeof(int) * 10);
如果是多维数组，需要从高维向低维逐层分配。如二维数组10*100空间。
int **a;
int i;
a = (int **) malloc(sizeof(int *) * 10); // 先分配10个int*的空间。
for(i = 0; i < 100; i ++)
a[i] = (int *)malloc(sizeof(int) * 100); // 对于每个int*，分配100个元素的空间。
⑶ c语言：怎样用malloc函数动态分配二维数组，使之可输入数组的行数和每行的列数。
这个是可以的，但是和其他网友说的一样，内存是线性的，当你在语言中分配一个多维数组的时候，编译器其实也是分配线性内存的，但是我们可以通过模拟来实现类似数组的操作，下面演示一个分配以及操作数组的实例（列数要固定，这里假设列数为4）：
int _tmain(int argc, _TCHAR* argv[])
{
int (*p)[4] = (int (*)[4])0;
int row = 3;
int (*mem)[4] = (int (*)[4])0; // 定义数组首指针
mem = (int (*)[4])malloc(sizeof(int(*)[4]) * row); // 分配row行， 4列的数组
// 分别为二维数组的第一维各个元素赋值。
mem[0][0] = 1;
mem[0][1] = 2;
mem[0][2] = 3;
mem[0][3] = 4;
// 打印二维数组的各个元素的值
printf("%d, %d, %d, %d", mem[0][0], mem[0][1], mem[0][2], mem[0][3]);
free(mem);
return 0;
}
不过这里列数必须指定，还有一种方法，这种方法可以保证用户输入任意行或列，而不必要将列数定死，演示如下：
int getElement(int* arr, int colNum, int row, int col);
void setElement(int* arr, int colNum, int row, int col, int val);
int _tmain(int argc, _TCHAR* argv[])
{
int *arr = (int*)0;
int row = 3;
int col = 5;
//分配 row 行 col 列的整形数组
arr = (int*)malloc(sizeof(int) * col * row);
// 将最后一个元素值设置为100
setElement(arr, col, 2, 4, 100);
//输出最后一个元素的值
printf("%d", getElement(arr, col, 2, 4));
free(arr);
return 0;
}
//各个参数说明如下：
//arr: 数组首地址
//colNum：数组列数
//row: 要取得的元素所在行
//col: 要取得的元素所在列
int getElement(int* arr, int colNum, int row, int col)
{
return *(arr + sizeof(int) * (row - 1) * colNum + col);
}
// 此函数用来设置指定行和列的元素的值：
//arr: 数组首地址
//colNum：数组列数
//row: 要取得的元素所在行
//col: 要取得的元素所在列
//val: 要设置的值
void setElement(int* arr, int colNum, int row, int col, int val)
{
*(arr + sizeof(int) * (row - 1) * colNum + col) = val;
}
其实归根到底，还是对指针的操作，希望可以帮到你，呵呵。
⑷ C语言如何动态分配二维数组
动态分配二维数组：
void main(int argc, char * argv[])
{
int NC=100, NR=200;
int i,j;
char **a; // a[NR][NC] -- *a[NR] -- a[j][i]
a = (char **) malloc(sizeof(char *) * NR);
for (j=0;j<NR;j++){
a[j] = (char *) malloc(sizeof(char) * NC);
}
// 释放空间: free(a);
编译错误是因为p[j]=(char *)malloc，而不是题目的(char *)malloc(n*sizeof(char))。
(4)c语言怎么分配数组扩展阅读：
二维数组的动态分配
二维数组A[m][n]，这是一个m行，n列的二维数组。设a[p][q]为A的第一个元素，即二维数组的行下标从p到m+p，列下标从q到n+q，按“行优先顺序”存储时则元素a[i][j]的地址计算为：
LOC(a[i][j]) = LOC(a[p][q]) + ((i − p) * n + (j − q)) * t
按“列优先顺序”存储时，地址计算为：
LOC(a[i][j]) = LOC(a[p][q]) + ((j − q) * m + (i − p)) * t
存放该数组至少需要的单元数为(m-p+1) * (n-q+1) * t 个字节。
⑸ C语言：如何动态的内存分配一个数组且数组的元素是指向char类型的字符串的指针
sizeof(a[5])是数组中第6个元素的长度，应该是1。但是你的数组长度为5，最后一个元素是a[4]哦！
要求整个数组的长度直接用数组名就好了，相当于直接把数组的首地址传给函数strlen,
strlen(a)就是求得的整个数组占用的字节长度，而且应该为5而不是7。因为每个char类型的变量只占一个字节！
希望可以帮到你，不会的可以问我。希望采纳嘿嘿
⑹ C语言-二维数组动态分配
pArray2=(int**)malloc(sizeof(int*[3])); //分配了3个int*的空间，32地址环境下指针的长度都是32位的也就是4字节，那3个int*就是12字节，和3个int长度是一样的，凑巧而已
也可以写成这样：
pArray2=(int**)malloc(3*sizeof(int*)); //分配3个int*的空间
现在pArray2指向的有效空间内包含3个指针，这3个指针是int*,也就是指向int的指针，这3个指针的值是随机的，还不能用，先要让它们指向合适的空间才行
于是就有：
for(....)
*(pArray2+i)=(int*)malloc(sizeof(int[3])); //这就是给pArray2指向的空间内的3个指针校正方向，让每一个指针指向由3个int整数组成的数组的首地址，这才是最终的数据空间
和pArray2一样，也可以写成：
*(pArray2+i)=(int*)malloc(3*sizeof(int)); //3个int
⑺ c语言数组在内存中是怎么分配的
C语言中内存为分三类：栈区、堆区、静态数据区。
局部变量在栈上分配，函数调用前的栈指针，要和函数返回后的栈指针一样，否则就会出错。
void test(void)
{
char i,a[10];
printf("0x%x", &i);
printf("0x%x", a);
printf("0x%x", a+1);
printf("0x%x", a+2);
printf("0x%x", a+3);
}
(7)c语言怎么分配数组扩展阅读
c语言数组在内存分配
示例：
#include<stdio.h>
int main()
{
int a[4] = {11,12,13,14};
int b[4] = {21,22,23,24};
int *pa = &a;
int i = 0;
while(i<8)
{
i++;
printf("now *p value = %d and",*pa);
printf("p addr value = %d ",pa);
pa++;
}
return 0;
}
⑻ C语言中怎么动态分配数组
//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *a=NULL;
int i;
a=malloc(sizeof(int)*10);/*动态创建一个有10个int元素的数组*/
if (a==NULL) { /*a==NULL表示空间分配失败*/
fprintf(stderr,"MEMORY ERROR");
return -1;
}
for (i = 0; i < 10; i++) {
a[i]=i; /*对数组进行操作*/
}
free(a);/*动态分配的空间需要用free()函数释放*/
return 0;
}
//---------------------------------------------------------------------------
⑼ C语言二维数组内存是怎么分配的
二维数组在内存中其实是一个平坦的一维数组，下面具体说明：
int
arr[3][5]
和
int
arr[15]
所使用的内存区大小是一样的，都是15*sizeof(int)个字节。
如果你做下面这样一个定义：
union{
int
a[3][5];
int
b[15];
}U;
你会发现
U.a
=
&U.b
U.a[0]
==
&U.b[0]
U.a[1]
==
&U.b[5]
U.a[2]
==
&U.b[10]
&U.a[2][3]
==
&U.b[13]
规律是：
&U.a[m][n]
==
&U.b[m*5+n]，其中5就是数组a的第二维度。
实际上，二维数组在运行时也是用这样的公式转化为对一维数组的访问。
⑽ c语言怎么把一个字符数组分成多个数组
可以使用strtok函数把一个字符数组分解成多个字符数组。
1、strtok函数：
原型：char *strtok(char s[], const char *delim)；
功能：将一个字符串分解为一组字符串，s为要分解的字符串，delim为分隔符字符串；
说明：当strtok函数在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针；
头文件：string.h；
返回值：从字符串s开头开始的一个个被分割的字符串。分割结束时，返回NULL。所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。
2、例程：
#include<stdio.h>
#include<string.h>
intmain(){
charinput[16]="abc,d,ef,g";//待分解字符串
char*delim=",";//分隔符字符串
char*p=strtok(input,delim);//第一次调用strtok
while(p!=NULL){//当返回值不为NULL时，继续循环
printf("%s ",p);//输出分解的字符串
p=strtok(NULL,delim);//继续调用strtok，分解剩下的字符串
}
return0;
}