printf（）不会在c中打印字符串

Question

我正在尝试在for循环之后打印一个char数组，以查看输出以确保它是正确的。 但是，它不会打印字符串。 为什么不打印字符串？ 我想念什么吗？ 它打印索引println字符串，但不会打印Tag位。 我想念什么？

这是我的代码

char *getTag(char *address){
   char *binary, *resultsIndex, *resultsTag, *resultsOffset;
   char* tags;
   int i, j, t; 

  printf("Get Tag function\n");

  binary = hexToBin(address);
  printf("Binary : %s\n", binary);
  printf("Tag : %i\n", TAG);
  printf("Offset : %i\n", OFFSET);
  /*Seperate index, tag and offset*/

  i = 0;
  resultsIndex = (char * )malloc(sizeof(char) * INDEX);
  for(i = 0; i < INDEX; i++){
     resultsIndex[i] = binary[i];
   }

   resultsTag = (char * )malloc(sizeof(char) * TAG);
   //resultsTag = '\0';
   for(t = INDEX; t < TAG + 1; t++){
      resultsTag[t] = binary[t];
      printf("binary[i] %c\n", binary[t]);
      printf("resultsTag[i] %c\n", resultsTag[t]); //<----prints individual character
   }

  printf("Index bit: %s\n", resultsIndex);
  printf("Tag Bit %s", resultsTag); //<-----Won't print the string
  return resultsTag;
}

我尝试使用Google搜索问题，并尝试了一些方法。 一个使resultTag [t] ='\\ 0'。 我试过了，它仍然无法打印。 我的for循环出了点问题吗？

它在循环内打印单个字符，因此我可以看到它正在存储它，但不会在循环外打印它。 有什么建议可能会有所帮助吗？

Answer 1

您从偏移量INDEX开始写入resultTag ，但尝试从初始化的起始位置开始打印。 如果开始恰好包含零，它将不打印任何内容。

此外，最终的打印不会以换行符结尾 ，并且输出流不会被刷新，因此在某些系统上不会立即显示。

Answer 2

如果我理解正确，您正在尝试在两个定义的点拆分字符串，对吗？ 看来您有一个binary字符串，其格式如下：

XXXXYYYYYYZZZ0
^   ^    ^   ^
|   |    |   \String terminator
|   |    \Offset
|   \Tag
\Index

当然，各个部分的长度只是一个示例，因为我看不到您的常数值。 但是根据我的示例，您可能具有如下定义的变量（在字符串中指定它们的结尾）：

#define INDEX 4
#define TAG 10
#define OFFSET 13

现在，第一个问题是为什么它立即对您不起作用：您没有正确构造resultsTag 。 但是，让我们首先看一下resultsIndex 。

---

resultsIndex可以正常工作，但是也无法正确完成。 我会向您解释原因。 您正在执行此操作：

resultsIndex = (char * )malloc(sizeof(char) * INDEX);
for(i = 0; i < INDEX; i++){
    resultsIndex[i] = binary[i];
}

它能做什么：

• 为结果字符串分配INDEX （在我的示例中为4）字符。
• 仅从0循环到INDEX （4），即包括INDEX - 1 （3），然后复制数据。
  因此， i将在循环期间获得值0..1..2..3。 这意味着它将所有字符从binary 0-3位置复制到resultsIndex 0-3位置。

在这部分之后， resultsIndex定义为4个字符的大小（如果我们继续上面的示例值），看起来像这样：

____ << defined size
XXXX

...这是您复制的字符串的索引部分。 但是，这里的一个错误就是已经没有字符串终止符了！ 它看起来应该像这样：

_____ << defined size
XXXX0
    ^
    \string terminator

字符串终止符可以告诉以后任何人/谁在读字符串，它在此处结束，并且他们必须在该位置停止读取，否则它们将读到结尾以外。

但是，由于没有什么独立存在，而是通常被内存的其他部分包围，所以我想它看起来像这样：

____ << defined size
XXXX00000000000...
^   ^
|   \you were lucky that those null bytes were around
\this part you actually allocated

但是您不应该依赖于此。 它也可能看起来像这样：

____ << defined size
XXXXgarbage...

...那么它将打印XXXXgarbage而不是XXXX 。 要么：

____ << defined size
XXXX| << here the memory block actually ends

...那么它将在尝试打印时崩溃。

因此，要解决此问题，您将不得不再保留一个字节并用零值填充它，该值用作字符串终止符：

resultsIndex = (char * )malloc(sizeof(char) * (INDEX + 1));
for(i = 0; i < INDEX; i++){
    resultsIndex[i] = binary[i];
}
resultsIndex[INDEX] = 0; // string terminator

---

单击确定，现在返回resultsTag 。 在上面的示例中（您似乎在做类似的事情），我的常量TAG被定义为10 ，基本上是标记（索引：4）和标记本身（6）在一起之前的部分的长度。 但是标签本身只有6个字符（= TAG - INDEX ）。

目前，您正在执行此操作（为清楚起见，我删除了一些内容）：

resultsTag = (char * )malloc(sizeof(char) * TAG);
for(t = INDEX; t < TAG + 1; t++){
    resultsTag[t] = binary[t];
    printf("resultsTag[i] %c\n", resultsTag[t]);
}

它能做什么：

• 为结果字符串分配TAG （在我的示例中为10）字节。
• 仅从INDEX （在我的示例中为4）循环到TAG + 1 （11），即TAG （包括TAG ）（10），因此实际上是在标记末尾一个字符。
  因此，变量t在循环期间将获得值4..5..6..7..8..9..10。
  有效地，这会将数据从binary 中的位置4-10复制到resultsTag位置4-10 。

最后一部分是无法打印的原因（但这不是代码中的唯一问题）。 在此循环之后，从resultsTag所在的位置开始的内存将如下所示：

__________ << defined size
????YYYYYYZ
^   ^     ^
|   |     \this is actually written outside of the allocated block of memory
|   \this are the 6 characters of the tag you copied
\you never wrote to this part, so nobody knows what is there

按照我先前的假设，使用malloc分配的malloc被系统隐式地填充了零字节（同样，您不应该依赖它），它实际上可能看起来像这样：

__________ << defined size
0000YYYYYYZ
^   ^     ^
|   |     \this is actually written outside of the allocated block of memory
|   \this are the 6 characters of the tag you copied
\zero values - remember that they act as string terminator!

那么当您尝试打印resultsTag时会发生什么？ 系统将查看内存并说：好的，让我们打印。 什么是第一个字符？ ...哦，已经是字符串终止符了吗？ 好吧，这很短！ 没什么可打印的！ 晚安。

这样一来，就不会输出任何内容，因为您的字符串以红色标记开头，表示“字符串在此处结束”。 ：P

所以最后一部分有三个问题：

• 您正在分配错误的内存量，然后开始写入中间而不是从头开始。
• 您写的内容超出了结尾（因为循环中为TAG + 1 ）。
• 再次不要终止字符串。

让我修复它：

resultsTag = (char * )malloc(sizeof(char) * (TAG - INDEX + 1));
for(t = INDEX; t < TAG; t++){
    resultsTag[t - INDEX] = binary[t];
    printf("resultsTag[i] %c\n", resultsTag[t - INDEX]);
}
resultsTag[TAG] = 0; // string terminator

为了完整起见，它的作用如下：

• 仅为标签的长度分配内存（不是索引加标签），为字符串终止符加上1个字节。 在我的示例中，它将是6 + 1 = 7个字节。
• 仅从INDEX （在我的示例中为4）循环到TAG （10），即包括TAG - 1 （9），但是我们没有为复制的源和目标使用相同的索引：变量t将获得值4 ..5..6..7..8..9，但目标索引将从0开始而不是从4开始，并且将经过0..1..2..3..4 ..5。
  有效地，这会将数据从binary位置4-9复制到resultsTag位置0-5 。

因此， resultsTag将如下所示：

_______ << defined size
YYYYYY0

如果未将TAG定义为“索引的长度加标签的长度”，而只是将其定义为标签的长度，可能会减少一些混乱，因为那样一来，计算将变得更加简单明了，但我将其保留为练习 ;）

---

我还可以看到您的代码的其他几个问题：

1）您正在泄漏内存，因为resultsIndex没有释放（即free(resultsIndex); resultsIndex = NULL;您在使用结束后。 如果你真的想要得到唯一标签（如函数名getTag建议），你不会需要与整体的一部分resultsIndex可言，不过......我不知道你的价值做什么resultsTag回国后它，但是您必须确保呼叫者也将其释放！

2）实际上， binary气味就像是另一个内存泄漏。 hex2bin如何为返回的字符串分配内存？ 如果它也只是malloc并且没有魔术内存管理，则需要使用free(binary); 最后。

3） i = 0; 是多余的，因为您也将它设置为零，在此位置以下两行。

Answer 3

首先，由于以下条件，您正在访问您的resultTag数组： t < TAG + 1; 您必须循环直到TAG-1才能留出空终止符。 或malloc TAG+1个字节。

其次，您必须在字符串中添加一个空终止符以使其成为C-String。

   resultsTag = malloc(sizeof(char) * TAG+1);
   for(t = INDEX; t < TAG; t++)
   {
      resultsTag[t] = binary[t];
      printf("binary[i] %c\n", binary[t]);
      printf("resultsTag[i] %c\n", resultsTag[t]); //<----prints individual character
   }

   resultsTag[t] = '\0';

对resultsIndex相同考虑

  resultsIndex = (char * )malloc(sizeof(char) * INDEX+1);
  for(i = 0; i < INDEX; i++){
     resultsIndex[i] = binary[i];
   }
   resultsIndex[i] = '\0';

正如Clifford指出的那样，循环开始从INDEX填充您的字符串，然后您必须从该偏移量开始打印字符串。

printf("Tag Bit %s\n", &resultsTag[INDEX]);

或在循环内更改分配：

resultsTag[t-INDEX] = binary[t];

此外，您必须确保binary指向的所有值都是ASCII。

Answer 4

您需要刷新标准输出，或添加\\ n（新行上的标准输出自动刷新）

printf("Tag Bit %s\n", resultsTag); //<-----Won't print the string

fflush (stdout);