no code execution after while- or for-loop in C

Question

I’m learning C using Xcode 8 and the compiler doesn’t run any code after a while- or for-loop executes. is this a bug? how can I fix it?

In the example provided below printf("code executed after while-loop"); never executes

#include <stdio.h>

int getTheLine(char string[]);

int getTheLine(char string[]) {

  char character;
  int index;
  index = 0;

  while ((character = getchar()) >= EOF) {

    string[index] = character;
    ++index;
  }

  printf("code executed after while-loop");
  return index;
}

int main(int argc, const char * argv[]) {

  char string[100];
  int length = getTheLine(string);
  printf("length %d\n", length);

  return 0;
}

Answer 1

getchar returns an int not a char, and comparison with EOF should be done with the != operator instead of the >= operator.

...
int character;   // int instead of char
int index;
index = 0;

while ((character = getchar()) != EOF) {  // != instead of >=
...

Answer 2

It's the >= EOF, which will let the condition be always true. The reason is that a "valid" result of getchar() will be a positive integer, and a "non-valid" result like end-of-file will be EOF, which is negative (cf. getchar()):

EOF ... integer constant expression of type int and negative value

Hence, any valid result from getchar will be >EOF, while the end-of-file-result will be ==EOF, such that >= EOF will always match.

Write != EOF instead.

Note further that you do not terminate your string by the string-terminating-character '\0', such that using string like a string (e.g. in a printf("%s",string)) will yield undefined behaviour (crash or something else probably unwanted). So write at least:

while ((character = getchar()) != EOF) {
    string[index] = character;
    ++index;
}
string[index]='\0';

Then there is still the issue that you may write out of bounds, e.g. if one enters more then 100 characters in your example. But checking this is now beyond the actual question, which was about the infinite loop.

Answer 3

The symbolic constant EOF is an integer constant, of type int. It's (usually) defined as a macro as -1.

The problem is that the value -1 as an (32-bit) int has the value 0xffffffff and as a (8-bit) char the same value would be 0xff. Those two values are not equal. Which in turn means that your loop condition will never be false, leading to an infinite loop.

The solution to this problem is that all standard functions that reads characters returns them as an int. Which means your variable character needs to be of that type too.

Important note: It's a compiler implementation detail if plain char is a signed or an unsigned type. If it is signed then a comparison to an int would lead to sign extension when the char value is promoted in the comparison. That means a signed char with the value 0xff would be extended to the int value 0xffffffff. That means if char is signed then the comparison would work.

This means that your compile have char as unsigned char. So the unsigned char value 0xff after promotion to int will be 0x000000ff.

---

As for why the value -1 becomes 0xffffffff is because of how negative numbers are usually represented on computers, with something called two's complement.

---

You also have another couple of flaws in your code.

The first is that since the loop is infinite you will go way out of bounds of the string array, leading to undefined behavior (and a possible crash sooner or later). The solution to this is to add a condition to make sure that index never reaches 100 (in the specific case of your array, should really be passed as an argument).

The second problem is that if you intend to use the string array as an actual string, you need to terminate it. Strings in C are actually called null terminated strings. That terminator is the character '\0' (equal to integer 0), and need to be put at the end of every string you want to pass to a standard function handling such strings. Having this terminator means that an array of 100 characters only can have 99 characters in it, to be able to fit the terminator. This have implications to the solution to the above problem. As for how to add the terminator, simply do string[index] = '\0'; after the loop (if index is within bounds of course).