sizeof为什么不能计算被动态分配的数组

sizeof()只是符号表,是编译的时候确定大小的。动态分配是运行过程中得到大小的。甚至new也可能分配失败。
[int占4字节,short占2字节]

1.0 回答下列问题:

1. sizeof(char) =                           
2. sizeof 'a' =                           
3. sizeof "a" =                        
4. strlen("a") =

  如果你答对了全部四道题,那么你可以不用细看下面关于sizeof的论述。如果你答错了部分题目,那么就跟着我来一起探讨关于sizeof的用法了。  

  对于前面的题目,我想一般有一定C基础的同志应该不会答错1和4题。至于第2题,我想应该要清楚sizeof是求字符串所占的内存。"a"在内存中的表现为a\0,别忘了末尾的\0也占一个字节呢。至于第2题,可能有些人会惊讶了。C 语言中,字符常数是int 型, 因此 sizeof('a') 是 sizeof(int)
-----答案:
1,4,2,1

1.1 回答以下题目

short (*ptr[100])[200];

1. sizeof(ptr) =
2. sizeof(ptr[0]) =
3. sizeof(*ptr[0]) =
4. sizeof((*ptr[0])[0])) =   

  是不是又开始晕了。这里我们定义了一个100个指针数组,每个指针均指向有200个元素的数组,其内存占用为200*sizeof(short)字节。那么这100个数组指针的大小sizeof(ptr)为100*sizeof(short*)。接着,指针数组的第一个指针ptr[0]指向第一个数组,所以这个指针ptr[0]的大小实际上就是一个普通指针的大小,即sizeof(short*)。*ptr[0]指向第一个数组的起始地址,所以sizeof(*ptr[0])实际上求的是第一个组的内存大小200*sizeof(short)。(*ptr[0])[0])是第一个数组的第一个元素,因为是short型,所以这个元素的大小sizeof((*ptr[0])[0]))等价于sizeof(short)。
-----答案:
400,4,400,2

1.2 回答以下题目[答案在文章末尾]

#include <stdio.h>
#pragma pack(push)
#pragma pack(2)

typedef struct _fruit
{
  char apple;
  int banana;
  short orange;  
  double watermelon;
  unsigned int plum:5;
  unsigned int peach:28; 
  char* tomato;
  struct fruit* next;  
} fruit;

#pragma pack(4)
  
typedef struct _fruit2
{
  char apple;
  int banana;  
  short orange;
  double watermelon;
  unsigned int plum:5;
  unsigned int peach:28;  
  char* tomato;
  struct fruit2* next;  
} fruit2;  

#pragma pack(pop)

int main(int argc, char *argv[])
{
  printf("fruit=%d,fruit2=%d\n",sizeof(fruit),sizeof(fruit2));
}

问题:打印结果为什么呢?

如果你回答错误,那么你对数据结构的对齐还没有吃透。这里#pragma pack(2)强制设置编译器对齐属性为2,所以第一个数据结构以2对齐,sizeof(fruit)=(sizeof(apple)+1)+sizeof(banana)+sizeof(orange)+sizeof(watermelon)+((plum:5bit+peach:28bit+15bit)/8bit)+sizeof(tomato)+sizeof(next)(注意式子中1 和 15bit 表示补齐内存,使其以2对齐,),既sizeof(fruit)=(sizeof(char)+1)+sizeof(int)+sizeof(short)+sizeof(double)+sizeof(char*)+sizeof(struct fruit*)。第一个数据结构声明完了之后,又使用#pragma pack(4)强制设置编译器对齐属性为4,所以同理,可以得到sizeof(fruit2)=(sizeof(char)+3)+sizeof(int)+(sizeof(short)+2)+sizeof(double)+((5bit+28bit+31bit)/8bit)+sizeof(char*)+sizeof(struct fruit2*)。

-----答案:
 fruit=32,fruit2=36


"这里我们定义了一个100个指针数组,每个指针均指向有200个元素的数组,其内存占用为200*sizeof(short)字节。那么这100个数组指针的大小sizeof(ptr)为100*sizeof(short*)。"

这里有错误,应该是定义了一个指针数组,该数组有100个元素,其中每一个元素都是一个指针,每个指针指向一个含有200个元素的数组。
在C语言中,动态数组通常通过`malloc()`函数来分配内存。由于数组长度不能直接存储为指针,你需要先确定数组的大小,然后利用这个大小来调用`malloc()`. 下面是一个简单的例子: ```c #include <stdlib.h> // 包含malloc和free函数 // 定义结构体来保存数组的信息 typedef struct { int size; // 数组长度 int *array; // 指向数组指针 } DynamicArray; // 动态创建数组 DynamicArray* create_array(int length) { if (length <= 0) { printf("Error: Array length must be positive.\n"); return NULL; } DynamicArray *da = (DynamicArray*) malloc(sizeof(DynamicArray)); // 分配空间给结构体 da->size = length; da->array = (int*) malloc(length * sizeof(int)); // 分配数组空间 // 如果内存分配成功,返回动态数组结构 if (da->array != NULL) { return da; } else { free(da); // 释放结构体的空间 printf("Memory allocation failed.\n"); return NULL; } } // 使用动态数组 void use_array(DynamicArray *da) { for (int i = 0; i < da->size; i++) { da->array[i] = i; // 初始化数组元素 // ... 对数组进行其他操作 } } // 释放数组空间 void destroy_array(DynamicArray *da) { free(da->array); free(da); } // 示例 int main() { DynamicArray *my_array = create_array(5); if (my_array != NULL) { use_array(my_array); // ... 其他处理 destroy_array(my_array); // 销毁数组时别忘了释放内存 } return 0; } ``` 在这个示例中,我们首先创建了一个结构体`DynamicArray`,其中包含数组长度`size`和指向数组指针`array`。`create_array()`函数用于根据传入的`length`动态分配数组,并在`use_array()`函数中可以访问和操作数组。使用完毕后记得调用`destroy_array()`函数释放内存
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值