C - Dynamic String Freeing and dynamic arrays

Question

I have an issue that is related to my programming project this semester. I have a dynamic array that has a structure, that structure contains a parameter for a string. The thing is I need to change that string from being static , to dynamic. I have written the function that asks for the string and stores it in a dynamic array and then returns it. Later in the program I will need to write the info from the arrays (in which the dynamic string is stored) to a binary file. How can I achieve this and how can I know when and how I am properly freeing the memory of that dynamic string? If I free the array in which the string is stored, do I also free the memory in which the string itself is stored?

My array which will store the string:

inspections *inspectionsArray;


char* dynamicString(){
    char *stringPointer = NULL,*paux = NULL, char;
    int stringSize = 1,stringEnd = 0,i;
    stringPointer = (char*)malloc(sizeof(char)); 
    if (stringPointer == NULL) {
        printf("\nError alocating memory");
    }else{
        printf("\nEnter String: ");
        while (char != EOF && char != '\n') {
            char = getc(stdin); //Obter o char do stding
            paux = realloc(stringPointer, stringSize*sizeof(char));
            if (paux != NULL) {
                stringPointer = paux;
                stringPointer[stringEnd] = char; //meter o char na string
                stringSize++; //incrementar o tamanho da string
                stringEnd++;
            }else{
                printf("\nErro a realocar memoria para a string");
            }
        }
        stringPointer[stringEnd] = '\0';
        printf("\nString: %s", stringPointer);
    }
    return stringPointer;
}

The Structure in which I will have my string stored in.

typedef struct
{
    //A bunch of parameters in here
    char *dynamicString;

} inspection;


enter code here

Function I use to store data to array:

inspectionArray* registerInspection(inspection *inspectionArray){
    char *string;
    //I removed a bunch of code to not confuse things
    string = dynamicString;

    return inspection;
}

Function to save file:

void saveBinaryFile(inspection *inspections, int inspectionCounter)
{
    FILE * inspectionArrayFile;


    fileInspections = fopen("inspections.dat","wb"); 


    if (fileInspections == NULL)
    {
        perror("\nError opening the file");
    }
    else
    {
        fwrite(&inspectionCounter, sizeof (int), 1, inspectionArrayFile);
        fwrite(inspections, sizeof(tipoVeiculo), inspectionCounter, inspectionArrayFile);
        // I write a bunch of stuff and verify it properly
        fclose(inspectionArrayFile);

    }
}

How do I properly read and free the string ?

I tried this:

void freeArrayStrings(inspections *inspectionsArray,int counter){
    int i;
    for (i=0; i<counter; i++) {
        free(inspectionArray[i].dynamicString);
    }
}

Answer 1

You should show your code in order to increase a chance of apt answer. If you ask about freeing of memory that stores pointers to another memory get from malloc like in this example:

struct str_wrap
{
    char *str;
    int  strlen;
};

int main()
{
    struct str_wrap *sw = malloc(sizeof *sw);
    if (sw == NULL) return -1;

    sw->str = malloc(strlen);
    if (sw->str == NULL)
        // handle
    sw->strlen = strlen;
    // many things with sw...

then yes, you have to call free twice (note: the same number of times you have called malloc):

    // free the memory
    free(sw->str);
    free(sw);
}

Answer 2

Unless you have some specific reason for using character-oriented input for the dynamicString() function, you can greatly simplify your life by using one of the line-oriented input functions provided by the standard C library (e.g. fgets or getline). Also, in C, you traditionally you avoid the use of camelCase names and instead use lower-case for all variable and function names.

In the case of the dynamicstring() function, using getline your function reduces to:

char *dynamicstring (inspection *i)
{
    char *line = NULL;  /* buffer for input                 */
    size_t n = 0;       /* alloc size 0 - getline decides   */
    ssize_t len = 0;    /* no. of character read (or EOF)   */

    printf("\nEnter String: ");

    len = getline (&line, &n, stdin);   /* read input   */

    if (len <= 1) {  /* line contains only '\n', 0, EOF */
        free (line);
        return NULL;
    }

    while (len > 0 && line[len-1] == '\n') /* remove '\n'  */
        line[--len] = 0;

    i->dstring = line;    /* assign pointer to dstring  */

    return line;
}

(note: above i use dstring for your char *dynamicString; member)

You can refine the memory allocation size from the default allocated by getline to only that amount required for the input string by taking the length of the final line, allocating that amount of memory (+1 for the nul-terminator), and copying line to the new block of memory. You can do it all at once with the strdup function. For example, you could add the following to the function above and then return str:

    char *str = NULL;   /* pointer for final string storage */
    ...
    str = strdup (line);  /* refine allocation size     */
    free (line);

    i->dstring = str;     /* assign pointer to dstring  */

    return str;

Even with the refinement, the completed function is far simpler than your original. Now note: regardless whether you assign the return or not, since the function only returns an allocation if the input is not empty, there is a chance that some of your array of inspection string members will be allocated and some empty. Therefore, you will need to check before freeing the memory. e.g.:

    if (ia->dstring)
        free (ia->dstring);

As always, when allocating memory dynamically, use a memory error checker (like valgrind on Linux) to confirm the correct use and freeing of the memory you allocate. A short example of the use of this input function would be:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char *dstring;
} inspection;

char* dynamicstring (inspection *i);

int main (void) {

    inspection *ia= NULL;

    if (!(ia= malloc (sizeof *ia))) {
        fprintf (stderr, "error: virtual memory exhausted.\n");
        return 1;
    }

    if (dynamicstring (ia)) {
        printf ("\n inspectionArray->dynamicstring : %s\n\n", ia->dstring);
        if (ia->dstring)
            free (ia->dstring);
    }
    free (ia);

    return 0;
}

char *dynamicstring (inspection *i)
{
    char *str = NULL;   /* pointer for final string storage */
    char *line = NULL;  /* buffer for input                 */
    size_t n = 0;       /* alloc size 0 - getline decides   */
    ssize_t len = 0;    /* no. of character read (or EOF)   */

    printf("\nEnter String: ");

    len = getline (&line, &n, stdin);   /* read input   */

    if (len <= 1) {  /* line contains only '\n', 0, EOF */
        free (line);
        return NULL;
    }

    /* using shorthand 'len' instead of 'len > 0'
       both test false when 'len' is 0  */
    while (len && line[len-1] == '\n') /* remove '\n'  */
        line[--len] = 0;

    str = strdup (line);  /* refine allocation size     */
    free (line);

    i->dstring = str;     /* assign pointer to dstring  */

    return str;
}

Give it a try and let me know if you have questions.

Answer 3

1. You have an error: stringPointer = (char*)malloc(sizeof(char)); You need stringPointer = (char*)malloc(sizeof(char *)); sizeof(char) is probably 1 bytes; sizeof(char *) is probably 4. You might get away with it because some memory systems always allocate at least 32 bytes...

2. Don't realloc on every input character. Instead, declare char buf[255] or some other maximum size, keep a size index, assign your input char to the end, and then at the end do stringPointer = malloc(isize+1) and strcpy(stringPointer,buf); If you really might need a huge input buffer, start at 4K or 1M and then reallocate when you fill that space.