Pointer Arrays (Chapter 5.6) example in The C Programming Language

Question

it is my understanding that once a pointer is initialized to a string constant, the string cannot be modified. I've tried performing the modification and the program crashes.

This theory is given at Chapter 5.5 "Character Pointers and Functions" in The C Programming Language by Brian W. Kernighan and Dennis M. Ritchie.

However there is an example of storing pointers in arrays (Chapter 5.6) where the contents of the pointer is modified. The program is as given below:

#include <stdio.h>
#include <string.h>
#define MAXLINES 5000 /* max #lines to be sorted */
#define MAXLEN 1000

char *lineptr[MAXLINES]; /* pointers to text lines */
char *alloc(int);
int readlines(char *lineptr[], int nlines);
int getline(char *, int);
void writelines(char *lineptr[], int nlines);

main()
{
    int nlines; /* number of input lines read */
    if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
        writelines(lineptr, nlines);
        return 0;
    } else {
        printf("error: input too big to sort\n");
        return 1;
    }
}

/* readlines: read input lines */
int readlines(char *lineptr[], int maxlines)
{
    int len, nlines;
    char *p, line[MAXLEN];
    nlines = 0;
    while ((len = getline(line, MAXLEN)) > 0)
    if (nlines >= maxlines)
    return -1;
    else {
        line[len-1] = '\0'; /* delete newline */
        strcpy(p, line);
        lineptr[nlines++] = p;
    }
    return nlines;
}

/* writelines: write output lines */
void writelines(char *lineptr[], int nlines)
{
    int i;
    for (i = 0; i < nlines; i++)
    printf("%s\n", lineptr[i]);
}

int getline(char s[],int lim)
{
    int c, i;
    for (i=0; i < lim-1 && (c=getchar())!=EOF && c!='\n'; ++i)
    s[i] = c;
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';
    return i;
}

The program does not show any warning or error when compiled but crashes after feeding the first line.

Can you please confirm if this is due to modification of a string constant initialized to a pointer? The pointer in question is @ line 28 "char *p" and strcpy performed on it @ line 35. Thank you.

Answer 1

It crashes here

 strcpy(p, line);

because p not points to allocated memory; you should add something like this

p = (char*)malloc(sizeof(char)* MAXLEN);

UPDATE:

Also here

for (i=0; i < lim-1 && (c=getchar())!=EOF && c!='\n'; ++i)

in case of string with length MAXLEN ended with '\n' your i could reach lim value. And then

if (c == '\n') {
    s[i] = c;
    ++i;
}

you will assign '\n' to s[MAXLEN] (lim = MAXLEN) and you will go out-of-bounds. (indexes should be between 0 and MAXLEN - 1.

I suggest to change

for (i=0; i < lim-1 && (c=getchar())!=EOF && c!='\n'; ++i)

to

for (i=0; i < lim-2 && (c=getchar())!=EOF && c!='\n'; ++i)

Answer 2

Content of a memory which a pointer points to CAN be modified
(else it would be useless in the first place).
What you mean is something like

char *p = "hello";

This is a special case where you are not allowed to modify hello, but else...

Your problem: You have no content of the pointer, ie. no assigned memory.
Read about malloc and free.

Answer 3

Your are writing to an unititialized pointer.

Your declare

char *p, line[MAXLEN];

and then you do

strcpy(p, line);   // here p points to invalid memory and therefore the program crashes

You shoud allocate memory for p like shown below

else {
    line[len-1] = '\0'; /* delete newline */
    p = (char*)malloc(len) ;  // <<<<<<<<<<-- add this line
    strcpy(p, line);
    lineptr[nlines++] = p;

BTW: a program that compiles without warnings does mean it cannot crash. And programs that compile with warnings may run perfectly.

Answer 4

The problem that you have is that char *p in readlines() is undefined. As you have it written in your present code example, p is the address at the beginning of some random chunk of memory that is the size of a single char. In the K&R(2nd Ed.) example code, the while loop in readlines() actually looks like this:

while((len = getline(line, MAXLEN)) > 0) {
  if (nlines >= maxlines || (p = alloc(len)) == NULL){
    return -1;
  }
  else {
    line[len-1] = '\0';
    strcpy(p, line); //now this should work
    lineptr[nlines++] = p;
  }
}

By using alloc(), which the authors have defined earlier in chapter 5, or by using the more sensible malloc(), which is defined in <stdlib.h>, you can then define p as something that is both meaningful and safe to use/manipulate.

Answer 5

I know this is a dig and it might not solve your issue, but there is a bug in example here:

 line[len - 1] = '\0';   /* delete newline */

than at the end after the code it points you to the getline() in chapter 1.9 which has following

for(...; ... s[i] != '\n'; ...)
s[i] = '\0';

getline() took care of newline with s[i] = '\0' so line[len - 1] = '\0'; /* delete newline */ is not necessary at all.