Don't be scared of me! I don't know everything, as I have unfortunately proven in earlier posts in this forum (but I do try to admit when I make mistakes).

Let me expand a little on what dodona and I have said in earlier posts...
Inside a function definition (such as in main() shown in post #1 in this thread), the declarations in main():

Code:

int main()
{
  int iv = 10;
  struct book *mynewbook;
  int len;
  char* words1;
  char* initial_words = "hello_pleased_to_met_you";
  char* tmp = "hello";
  ...
}

create:With most modern compilers the strings mentioned in points 5 and 6 above will be located in read-only memory and will, therefore, generate a segmentation fault if you try to change the data in those strings.

Early C compilers (in the 1970's and 1980's) frequently put these arrays in read-write memory. And when you had code that tried to overwrite these strings, they succeeded. This had the side-effect of turning string constants into variables whose constant string values were not constants while the process was running.

To create an array of characters on the stack that can be read and written instead of a pointer on the stack that points to an array of characters that might be read-only, you need to use a declaration more like:

Code:

  char initial_words_array[25] = "hello_pleased_to_met_you";
  char tmp_array[6] = "hello";

Both of these create arrays of characters on the stack. The constant string initializers will be copied into these arrays (on the stack) every time the function is invoked.

Arrays of characters and pointers to characters are two very different things. An array of characters has a size that is the number of characters that can be stored in it. A pointer to a character (or a pointer to an array of characters) has a constant size (usually 4 bytes per pointer on a system with a 32-bit address space or 8 bytes per pointer on a system with a 64-bit address space). You can increment a pointer to point to the next element in the array to which it points. You can't increment an array (although you can increment elements of an array). Although an array name is not a pointer, C allows an array name used without following square brackets to be used as a synonym for the address of the first element of that array. So, if I had the declarations:

Code:

  char *tmp;
  tmp_array[6] = "hello";

then both of the following lines of code set the pointer tmp to point to the h in the string hello:

Code:

  tmp = &tmp_array[0];
  tmp = tmp_array;

To then update the pointer to point to the next character in the array, you can use any of the following lines of code:

Code:

  tmp++;
  ++tmp;
  tmp = tmp + 1;
  tmp = &tmp_array[1];
  tmp = tmp_array + 1

but you can't use either of:

Code:

  tmp = tmp_array++;
  tmp = ++tmp_array;

because tmp_array is an array; and an array is not a pointer type.