How to initialize string with only spaces and no trash at all?

Question

My goal in the code is to initialize string with 80 chars, and only when the user typing char that is not '\0' ,' ' ,'\t' ,'\n' . to print "illegal command".

Now if the user typing for example 3 chars of space and press enter . the output is (80-4)=76 times "illegal command". and it does not need to print it at all because all the chars that the user typed was one of '\0', ' ', '\t', '\n'.

Please help me in that case.

The code :

void main() {
  int i;
  char str[80]="";
  gets_s(str, sizeof(str));
  for (i = 0; i < 80; i++)
  {
    if ((str[i] != '\n' && str[i] != '\0' && str[i] != '\t' && str[i] != ' '))
    {
      printf_s("illegal character: %c\n", str[i]);
    }
  }
}

Answer 1

My goal in the code is to initialize string with 80 chars, and only when the user typing char that is not \0 , ,\t ,\n . to print "illegal com

It appears that if the user only enters '\0', ' ', '\t', '\n', no message is printed.

char str[80]=""; is specified to initialize the entire array, yet may not be OP's problem.

Yet it is the footnote¹ and comment that may explain OP's unexpected output.

---

What makes this challenging is that user input may contain null characters, and not just the appended one.

Using getchar() would be a direct approach.

int ch;
while ((ch = getchar()) != '\n' && ch != EOF) {
  if (ch != ' ' && ch != '\t' && ch != '\0') {
    printf_s("illegal character code: %d\n", ch);
  }
}

---

gets_s(); is trickier to use for the task as it does not return the length read and input may consists of embedded null characters.

To detect embedded null characters, the buffer will not end with a '\n' and it is hoped (though not specified.¹) that the unused portion remain unchanged. So by pre-filling with '\n' code can distinguish between the appended null characters and one that is read.

int main(void) {
  int i;
  char str[80];
  memset(str, '\n', sizeof str);

  if (gets_s(str, sizeof str)) {
    int length = sizeof str;
    while (length > 0) {
      length--;
      if (str[length] == '\0') break;  // found appended null character
    }
    for (int i=0; i<length; i++) {
      if (str[i] != '\0' && str[i] != '\t' && str[i] != ' ') {
        printf("illegal character code: %d\n", str[i]);
      }
    }  
  }
}        

I prefer the getchar() approach.

---

¹ The value of the buffer after the appended null character is not specified to be unchanged - yet that is the common case. Hmmmm, but if it was changed, that would explain OP's problem. So another reason to avoid gets_s(); here.

Answer 2

When you said

char str[80] = "";

it looks like you did not actually initialize all 80 characters. You explicitly initialized the first character to '\0', but it looks like your compiler left the other 79 with random values. (More on this point later.)

When you said

for (i = 0; i < 80; i++)

you are asking to loop over all 80 characters in the array -- but this does not make sense. The gets_s function filled in only some characters -- as many characters as the user typed, plus one trailing '\0'. If the user typed fewer than 79 characters, many of the characters in str are still untouched (and perhaps still random).

Try changing the loop to

for (i = 0; str[i] != '\0'; i++)

or if you want to be on the safe side

for (i = 0; i < 80 && str[i] != '\0'; i++)

Because your program uses uninitialized memory, its behavior might be different on different systems. When I ran your program on my computer, evidently all 79 were also 0, meaning that I saw no extra error messages. (So at first I couldn't understand what you were talking about.) But it sounds like, on your system, they actually had random, nonzero values. You can see this if you change your error message to

printf("illegal character: 0x%02x\n", str[i]);

This will print the (hexadecimal) representations of all the "illegal" characters you saw. My guess is they'll be more or less random numbers.

(As chux points out in a comment, your compiler should have initialized those other 79 characters to 0, also, so it sounds like your compiler might be an older one, and buggy in this regard.)

Two other things you could try would be:

1. Move the declaration of str[] outside of main(). If you do that, all of it will be initialized to 0, and your program will behave more as you expected it to.

2. Change the declaration of str to char str[80] = " ";, where there are exactly 79 spaces between the "".

But neither of those changes is a particularly good idea. If the user types 6 characters, you really want to check only the 6 characters he explicitly typed, not all 80 of the characters that you initially allocated.