c - 在标准 C 中使用 char 数组存储多种数据类型

Question

我是一名中级程序员，正在努力学习标准 C。我目前正在努力完成一个类练习，该练习涉及使用指针将不同类型的数据存储到 char 类型的数组中。

假设我有一个大的字符数组:

static char arr[1000];

正如我的教授所解释的那样，我可以将其视为一 block 本地内存，其中数组中的每个元素都具有一个字节的粒度。这似乎很有用。现在假设我想获取前四个字节/元素并存储一个 int:

int a = 100;
int* ptr = (int*)arr;
*ptr = a;

据我了解，第二行创建了一个int*指针，然后指向数组arr的开头。第三行将 a 的值写入该位置。因为 ptr 是一个 int 类型的指针并且因为 arr 有足够的空间，所以这写了四个字节/四个元素的数据，因为 sizeof(int) == 4。通过我的调试器仔细观察似乎证实了这一点。

到目前为止，还不错。现在假设我想扩展这个概念。假设我想按以下顺序将以下内容存储到我的数组中:

int a = 100;
int b = 200;
char* str = “My dog has fleas”
int c = 300;

逻辑上看起来像这样:

00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
--------------------------------------------------------------------------------------
[  100    ] [   200   ]  M  y     d  o  g     h  a  s     f  l  e  a  s \0 [   300   ]

我需要能够以这种方式将数据存储到数组中，然后在事先知道数组结构的情况下，能够读取数组。以下是我的代码和输出，对于较长的长度提前表示歉意。它编译但不起作用。用我的调试器仔细检查它非常困惑；我不知道我会在哪里(以及多久)偏离轨道。如果有人有任何见解或建议，我将不胜感激。

int main(){

   static char arr[1000];

   int a = 100;
   int b = 200;
   char* str = "My dog has fleas";
   int c = 300;

   // Create pointers to load data:
   int* ptrA = arr;                     // points to start of array
   int* ptrB = ptrA + sizeof(int);      // points 4 bytes into array
   char* ptrStr = ptrB + sizeof(int);   // points 8 bytes into array
   int* ptrC = ptrStr + sizeof("My dog has fleas"); // points to after the string
                                       // (I don't know how to use sizeof() to measure the actual length of the string

   // Load data into my array
   *ptrA = a;       // Assign int 100 into the array?
   *ptrB = b;       // Assign int 200 into the array?
   *ptrStr = memcpy(ptrStr, str, sizeof("My dog has fleas"));       // Write "My dog has fleas" into the array?
   *ptrC = c;       // Assign int 300 into the array?

   // Knowing the array's structure, walk it and print results:
   char* walkIt = arr;
   int counter = 0;
   while (counter < 30) {
       if (counter == 0) {
           // we are pointing at what should be the first int
           int* tmpPtr1 = (int*)walkIt;
           printf("%d ", *tmpPtr1);
       }
       else if (counter == 4) {
           // we are pointing at what should be the second int
           int* tmpPtr2 = (int*)walkIt;
           printf("%d ", *tmpPtr2);
       }
       else if (counter == 8) {
           // we are pointing at what should be the string
           printf("%s ", walkIt);
       }
       else if (counter == 25) {
           // we are pointing at what should be the third int
           int* tmpPtr3 = (int*)walkIt;
           printf("%d ", *tmpPtr3);
       }
       walkIt++;        // Continue walking the array
       counter++;       // Don't walk too far
   }
   return 0;
}

输出是这样的:

100  0  0    

Answer 1

首先，您的教授是错误的，虽然在幕后情况确实如此，通过将指针转换为不同类型而获得的指针的取消引用违反了 strict aliasing规则，这是编译器做出的假设，即两个不同类型的指针不能引用同一内存，因此允许对此类指针进行优化。

回到你的代码，问题是你如何计算基地址的偏移量，例如:

int* ptrB = ptrA + sizeof(int); 

现在，ptrA 是int*，并且向指针添加整数偏移量隐式地将偏移量乘以指向的元素的大小。这意味着您不是在添加 sizeof(int) 字节，而是在添加 sizeof(int)*sizeof(int) 字节。

要强制添加特定数量的字节，您必须将指针转换为 char*，以便添加 sizeof(int) 字节只是添加 sizeof(int )*sizeof(char) == sizeof(int)*1 字节。

int* ptrB = (char*)ptrA + sizeof(int);      // points 4 bytes into array

请注意，这段代码是不安全的，它肯定会失败，使用 union 将是更好的解决方案。