printf() won't print string in c - c

Question

I'm trying to print a char array after a for loop to see the output to make sure it's correct. However, it won't print the string. Why won't it print the string? Am I missing something? It prints the index println string but not the Tag bit won't print. What am I missing?
Here is my code
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;
}
I tried googling the problem and have tried some of the methods. One to make resultsTag[t] = '\0'. I tried that and it won't print still. Is something wrong with my for loop that can cause that?
It prints the individual character inside the loop, so I can see that it is storing it but it won't print it outside the loop. Any advice that could be helpful?

Answer 1

You write toresultTag starting from an offset INDEX, but attempt to print it from the initialised start. If the start happens to contain zero, it will print nothing.
Moreover, the final print does not end in a newline and the output stream is not flushed so will not be displayed immediately on some systems.

Answer 2

If I understand correctly, you are trying to split a string at two defined points, right? It appears you have a string in binary which has the following format:
XXXXYYYYYYZZZ0
^ ^ ^ ^
| | | \String terminator
| | \Offset
| \Tag
\Index
The length of the individual parts is of course just an example because I don't see your constant values. But according to my example, you may have the variables defined like this (specifying the end of them in the string):
#define INDEX 4
#define TAG 10
#define OFFSET 13
Now what the first problem is why it immediately doesn't work for you: You are not constructing resultsTag correctly. But let's first take a look at resultsIndex.
resultsIndex kind of works, but it also not done correctly. I'll explain you why. You are doing this:
resultsIndex = (char * )malloc(sizeof(char) * INDEX);
for(i = 0; i < INDEX; i++){
resultsIndex[i] = binary[i];
}
What it does:
Allocate INDEX (4 in my example) characters for the result string.
Loop from 0 to INDEX (4) exclusively, i.e. INDEX - 1 (3) inclusively and copy the data.
So i will get the values 0..1..2..3 during the loop. This means it will copy all characters from positions 0-3 in binary to positions 0-3 in resultsIndex.
After this part, resultsIndex is defined with a size of 4 characters (if we keep to my example values above) and looks like this:
____ << defined size
XXXX
...which is the index part of the string you copied. However, one mistake here is already that there is no string terminator! It should look like this:
_____ << defined size
XXXX0
^
\string terminator
A string terminator is what tells to whatever/whoever is reading the string later that it ends here and they have to stop reading there, otherwise they would read beyond the end.
However, because nothing stands alone but is normally surrounded by other parts of the memory, I guess it happened to look like this:
____ << defined size
XXXX00000000000...
^ ^
| \you were lucky that those null bytes were around
\this part you actually allocated
But you shouldn't rely on that. It might as well have looked like this:
____ << defined size
XXXXgarbage...
...then it would have printed XXXXgarbage instead of just XXXX. Or:
____ << defined size
XXXX| << here the memory block actually ends
...then it would have crashed trying to print it.
So, to fix this, you would have to reserve one more byte and fill it with a zero value, which acts as string terminator:
resultsIndex = (char * )malloc(sizeof(char) * (INDEX + 1));
for(i = 0; i < INDEX; i++){
resultsIndex[i] = binary[i];
}
resultsIndex[INDEX] = 0; // string terminator
OK now back to resultsTag. In my example above (and it looks like you are doing it similarly), my constant TAG was defined as 10, which is basically the length of the part before the tag (the index: 4) and the tag itself (6) together. But the tag itself is only 6 characters (= TAG - INDEX).
At the moment, you are doing this (I removed some things for clarity):
resultsTag = (char * )malloc(sizeof(char) * TAG);
for(t = INDEX; t < TAG + 1; t++){
resultsTag[t] = binary[t];
printf("resultsTag[i] %c\n", resultsTag[t]);
}
What it does:
Allocate TAG (10 in my example) bytes for the result string.
Loop from INDEX (4 in my example) to TAG + 1 (11) exclusively, i.e. TAG inclusively (10), so actually one char after the end of the tag.
So, the variable t will get the values 4..5..6..7..8..9..10 during the loop.
Effectively, this copies the data from positions 4-10 in binary to positions 4-10 in resultsTag.
The last part is the reason why it doesn't print (but that's not the only problem in your code). After this loop, the memory starting at where resultsTag is located will look like this:
__________ << 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
Following my assumption from earlier, that memory you are allocating using malloc is implicitely filled with zero bytes by the system (which, again, is nothing you should rely on), it is likely that it actually looks like this:
__________ << 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!
So what happens when you try to print resultsTag? The system will look at the memory and say: OK, let's print. What is the first character? ...Oh, a string terminator already? Well that was short! Nothing to print! Good night.
And so nothing gets printed because your string starts with a red flag saying "string ends here". :P
So this last part has three problems:
You are allocating the wrong amount of memory and start writing to the middle of it instead of from the beginning.
You write beyond the end of it (because of TAG + 1 in the loop).
You again don't terminate the string.
Let me fix it:
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
For sake of completeness, here is what it does:
Allocate memory for the length of the tag only (not index plus tag), plus 1 byte for the string terminator. In my example it would be 6+1=7 bytes.
Loop from INDEX (4 in my example) to TAG (10) exclusively, i.e. TAG - 1 inclusively (9), but we don't use the same index for source and destination of the copying:
The variable t will get the values 4..5..6..7..8..9 during the loop, but the destination index will start at 0, not 4 this time, and will go through 0..1..2..3..4..5.
Effectively, this copies the data from positions 4-9 in binary to positions 0-5 in resultsTag.
So, resultsTag will look like this:
_______ << defined size
YYYYYY0
It would probably be a bit less confusing if TAG weren't defined as "length of index plus length of tag" but just as the length of the tag, because then the calculations were simpler and more obvious, but I'll leave that as an exercise ;)
I can see several other issues with your code too:
1) You are leaking memory because resultsIndex is not freed (i.e. free(resultsIndex); resultsIndex = NULL;) after you finished using it. If you really want to get only the tag (as the function name getTag suggests), you wouldn't need the whole part with resultsIndex at all, though... I don't know what you do with the value of resultsTag after returning it, but you have to make sure that the caller frees it as well!
2) Actually, binary smells like another memory leak. How does hex2bin allocate the memory for the string it returns? If it's also just malloc and there is no magic memory management, you would need to use free(binary); at the end as well.
3) i = 0; is superflouous because you set it to zero two lines below this as well.

Answer 3

First of all you are accessing your resultTag malloc-ated array out of bounds due to condition: t < TAG + 1; You have to loop until TAG-1 to leave space for null terminator. Or malloc TAG+1 bytes.
Secondly you must add a null terminator to your string to make it a 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';
Same considerations for resultsIndex
resultsIndex = (char * )malloc(sizeof(char) * INDEX+1);
for(i = 0; i < INDEX; i++){
resultsIndex[i] = binary[i];
}
resultsIndex[i] = '\0';
As Clifford points out the loop start filling your string from INDEX, then you must print the string starting from that offset.
printf("Tag Bit %s\n", &resultsTag[INDEX]);
or change the assignment inside the loop:
resultsTag[t-INDEX] = binary[t];
Furthermore you have to be sure that all values pointed by binary are ASCII.

Answer 4

You need to flush stdout, or add a \n (stdout autoflush on new-line)
printf("Tag Bit %s\n", resultsTag); //<-----Won't print the string
fflush (stdout);