The code posted is incorrect: a_static and b_static should be defined as arrays.

There are two ways to correct the code:

• you can add null terminators to make these arrays proper C strings:

  #include <stdio.h>
  
  int main(void) {
      char a_static[] = { 'q', 'w', 'e', 'r', '\0' };
      char b_static[] = { 'a', 's', 'd', 'f', '\0' };
  
      printf("value of a_static: %s\n", a_static);
      printf("value of b_static: %s\n", b_static);
      return 0;
  }
  

• Alternately, printf can print the contents of an array that is not null terminated using the precision field:

  #include <stdio.h>
  
  int main(void) {
      char a_static[] = { 'q', 'w', 'e', 'r' };
      char b_static[] = { 'a', 's', 'd', 'f' };
  
      printf("value of a_static: %.4s\n", a_static);
      printf("value of b_static: %.*s\n", (int)sizeof(b_static), b_static);
      return 0;
  }
  

  The precision given after the . specifies the maximum number of characters to output from the string. It can be given as a decimal number or as * and provided as an int argument before the char pointer.

Take a look at description of getline, which tells that it'll only allocate buffer if line passed is NULL. It'll only be NULL the first time and consequently will reuse the buffer or increase it if line doesn't fit.

If you want it to allocate separate buffers for every word, do

printf("%s", line);
words[count] =(unsigned char*) line;
line = NULL;
count++;

and remove the

if (line)
    free(line);

but don't forget to free all non-NULL entries of words somewhere later on.

You declare an array of characters like so:

char foo[size];

You seem to have it mixed up with char *, which is a pointer to a character. You could say

char *bar = foo;

which would make bar point to the contents of foo. (Or, actually, to the first character of foo.)

To then print the contents of the array, you can do one of the following:

// either print directly from foo:
printf("%s", foo);
// or print through bar:
printf("%s", bar);

Note, however, that C performs no initialization of the contents of variables, so unless you specifically set the contents to something, you'll get garbage. In addition, if that garbage doesn't happen to contain a \0; that is, a char with value 0, it will keep on outputting past the end of the array.

You got to understand behavior behind your program. So when you load your program it is given N bytes in memory and that N bytes gets reused many times and not erased. So in first instance your program have loaded some data into spot where s[0] would later reside, where as in second something was loaded where s[2] as well. That is why you are getting different output in these 2 cases.

So to sum it up: Your array is not initiated to 0 or unless you do it your self, it is given memory that have been previously used by the same program. To do it as it was pointed before you have to do this:

char s[10] = "          ";
....

One more thing I see is you were not expecting space before a, in C/C++/Java array indexes start at 0. So if you do:

char s[4];

s[1] = 'a';
s[2] = 'b';
s[3] = '\0';

print ("%s", s);

you would probably get:

@ab

@ comes up because there was nothing written by you as programmer in memory spot where s[0] resides.

Note that every time you have string in C you have to terminate it with '\0' character.

Don't you need to end your strings with \0 in C? ) For example:

char array[randSize + 1];
for (i=0; i < randSize; i++)
   array[i] = 'x';
array[i] = '\0';

(updated this because you indeed probably wanted to get a useful part of string of randSize length).

Given that the code is really simple, I see mostly coding style issues with it.

Instead of this:

char *names[] = {
    "John", "Mona",
    "Lisa", "Frank"
};

I would prefer either of these writing styles:

char *names[] = { "John", "Mona", "Lisa", "Frank" };

// or

char *names[] = {
    "John",
    "Mona",
    "Lisa",
    "Frank"
};

The pNames variable is pointless. You could just use names.

Instead of the while loop, a for loop would be more natural.

This maybe a matter of taste, but I don't think the Hungarian notation like *pArr is great. And in any case you are using this pointer to step over character by character, so "Arr" is hardly a good name. I'd for go for pos instead. Or even just p.

You should declare variables in the smallest scope where they are used. For example *pos would be best declared inside the for loop. In C99 and above, the loop variable can be declared directly in the for statement.

The last return statement is unnecessary. The compiler will insert it automatically and make the main method return with 0 (= success).

Putting it together:

int main(int argc, char *argv[])
{
    char *names[] = { "John", "Mona", "Lisa", "Frank" };
    for (int i = 0; i < 4; ++i) {
        char *pos = names[i];
        while (*pos != '\0') {
            printf("%c\n", *(pos++));
        }
        printf("\n");
    }
} 

Actually it would be more interesting to use argc and argv for something:

int main(int argc, char *argv[])
{
    for (int i = 1; i < argc; ++i) {
        char *pos = argv[i];
        while (*pos != '\0') {
            printf("%c\n", *(pos++));
        }
        printf("\n");
    }
} 

You should use %c format to print characters in C. You are using %s, which requires to use pointer to the string, but in your case you are providing integer instead of pointer.