Thread: Better way to read strings allocating memory?

Why this doesn't work?! It compiles.

Code:

void readString(char *s);

int main() {
    char *str;
    readString(str);
    printf("\n %s \n", str);
        
    fflush(stdin);
    getchar();
    
    return 0;
}


void readString(char *s) {
    char *temp;
    
    // allocate space for temp string
    temp = (char *) malloc(100 * sizeof(char));
    
    // read in temp
    scanf("%s", temp);


    // allocate space in the target string
    s = (char *) malloc( (strlen(temp)+1) * sizeof(char));


    // memcpy temp to the target string
    memcpy(s, temp, strlen(temp)+1);


    // free temp
    free(temp);
}

> readString(&str);
This is good, but you need to fix the prototype and implementation of the function to match.

Plus, get rid of that fflush(stdin)

Originally Posted by Salem

> readString(&str);
This is good, but you need to fix the prototype and implementation of the function to match.

Plus, get rid of that fflush(stdin)

Ok, this worked and I understood why,

Code:

void readString(char **p);
 
int main() {
    char *str;


    // sending the pointer's memory location
    readString(&str);


    printf("\n %s \n", str);
       
    getchar();
    return 0;
}
 
 
void readString(char **p) {
    char *str;
     
    // allocate space for str
    str = (char *) malloc(100 * sizeof(char));
     
    // read in str
    scanf("%100s", str);
 
    // realloc space
    str = (char *) realloc(str, (strlen(str)+1) * sizeof(char));
 
     // pointer's memory location = str's memory location
     *p = str;
}

However, if I don't fflush stdin the last getchar() recieves the \n which lives in the buffer after reading "str" and my program exits. What should I do about that?

Is there any difference, concerning memory, in using a fixed array char str[100] instead of what I am doing?

> What should I do about that?
1. Use fgets()
2. Read the FAQ on good ways to deal with trailing newlines.

Also read the FAQ on not casting the return result of malloc.

> Is there any difference, concerning memory, in using a fixed array char str[100] instead of what I am doing?
Well that depends on where (and how) you declare the array.
There is no issue if the array is declared in main, but if you were to declare it in readString, then it would go out of scope when the function returned.

You could make the array static in readString, but then you couldn't call readString() twice so easily.

Originally Posted by Gaspar Castillo

Ok, this worked and I understood why,

Code:

void readString(char **p) {
    char *str;
     
    // allocate space for str
    str = (char *) malloc(100 * sizeof(char));
     
    // read in str
    scanf("%100s", str);
 
    // realloc space
    str = (char *) realloc(str, (strlen(str)+1) * sizeof(char));
 
     // pointer's memory location = str's memory location
     *p = str;
}

There are two potential issues with this readString function. First, there is a buffer overflow in the line scanf("%100s", str). scanf will read up to 100 characters from stdin into str and then put a '\0' terminator after those 100 bytes (but you currently only allocated 100 bytes). To avoid an overflow you need to allocate one more byte for the '\0' terminator.

2. If malloc fails it returns NULL, so in the same scanf line you will potentially dereference a NULL pointer. A typical way to handle this is to set the pointer to NULL as soon as an allocation failure happens so that the caller knows an allocation error occured.

Code:

void readString(char **p) {
    char *str = malloc(100 + 1); /* 100 characters for str plus '\0' terminator */
    if (!str) {
        *p = NULL; /* failed to allocate memory */
        return;
    }    
    scanf("%100s", str);
    /* ... */
    *p = str;
}

Originally Posted by Gaspar Castillo

I've seen many tutorials in where they always cast malloc(). So, if I don't cast to check errors, I think I should first declare str as void* variable because malloc() is returning a void*

How do you explain, char *str = malloc(100+1);
and not void str* = malloc(100+1) ?

There is an implicit conversion from void* to any pointer to object such as char*. Therefore, it is neither necessary to cast the return value of malloc nor necessary to declare str as void*.

Originally Posted by Gaspar Castillo

Why casting malloc() bypasses errors?

It is bad practice, but it is possible to call a function without declaring it. When you do so, the compiler considers the parameters and return type of the function to default to int, which can cause problems when that is not actually the case. In the event that you cast the return value of malloc and yet fail to #include <stdlib.h>, you may then suppress the warning that a compiler is likely to raise about the apparent return type of malloc being int, and yet the destination is a pointer.

Originally Posted by Al3

In C++ it could be a bonus in some cases, but not in C.

In C++, there is no implicit conversion from void* to a pointer to object, so the cast is not a "bonus": it is a requirement if one wants to write C++ code that uses malloc, or C code that must be compilable as C++.