How can i do a double pointer (char **ptr) like an array of infinity pointers (pointers with no length limit)?

Sorry for my bad English. I have an exercise from school. I need to teach my friends to work with pointers in C. So i want to narrate them about a double pointer (type **ptr). I tried to write a code to create no length limit array of pointers with no length limit by using char **ptr.

When i run my code and enter more then 32 simbols in VSCode it’s no errors, but after some time i have a segmentation fault in

ptr[n][i-1] = a;

because of realloc returning NULL

There is my code:

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#define MAX_SIZE 50

int main(){
    int n = 0;
    int choice;
    char random;
    char a;
    char **ptr;
    do{
        int i = 0;
        ptr = (char**)malloc((n+1)*sizeof(char*));
        int k = 32;
        ptr[n] = (char*)malloc(sizeof(char));
        do{
            if(i == 0){
                printf("Enter ptr: ");
            }
            a = getchar();
            if(a != 'n'){
                i++;
                if(i == 32){
                    k*=2;
                    ptr[n] = (char*)realloc(ptr[n], k*sizeof(char));
                }
                if(ptr[n] == NULL){
                    printf("i: %d", i);
                }
                ptr[n][i-1] = a;
            } 
        }while(a!='n');
        printf("Do you want to enter another string? Enter 1 if yes else enter 0: ");
        scanf("%d", &choice);
        random = getchar();
        if(choice == 0){
            break;
        }
        n++;
    }while(1);
    puts(ptr[0]);
}

i tried to use

ptr[n] = (char*)realloc(ptr, k*sizeof(char));

this instead of

ptr[n] = (char*)realloc(ptr[n], k*sizeof(char));

but got a unknown error. I think because of i realloc to pointer (*ptr) double pointer(**ptr)

So i dont’t know what to do. Please help me and if you can say something interesting about pointers

Thanks

How can i do a double pointer (char **ptr) like an array of infinity pointers (pointers with no length limit)?

You can use a char ** to point to a statically or dynamically allocated array of char * of unspecified size, but any C object whose address you can convey via such a pointer has a particular, fixed size. C does not have infinitely large objects, of course, and it also does not have objects whose sizes change during their lifetime.

I tried to write a code to create no length limit array of pointers with no length limit by using char **ptr.

You can write code that uses char ** to work with arrays of different numbers of char *, but each such array has a specific length that does not change. Your particular program can, in fact, allocate many such arrays during a run.

after some time i have a segmentation fault in
ptr[n][i-1] = a;
because of realloc returning NULL

malloc() and realloc() can fail, and your program should check for that and respond appropriately if it happens. But it’s unlikely that that’s the cause of your segfaults. There are at least three more plausible explanations:

You initially allocate enough space for only one char for each ptr[n], and you do not attempt to reallocate until you have read and stored 31 characters, overrunning the initial allocation by 30 characters. You probably meant …
```
    ptr[n] = (char*)malloc(sizeof(char));
```
… to be …
```
    ptr[n] = malloc(k);
```
(Note that sizeof(char) == 1 by definition, and that you should not cast the result of malloc.)
The condition for reallocating the individual char arrays provides for only one reallocation, though the intent appears to have been to provide for an unbounded number of them. You probably meant the …
```
            if(i == 32){
```
… condition to be …
```
            if (i == k) {
```
, though personally, I would use >= instead of ==.

In the original code, if any line of input is long enough to require two or more reallocations then the program will run off the end of the only-once-reallocated array.
As @TedLyngmo observed, you malloc() memory for ptr on every loop iteration, more and more of it, but each allocation is fresh, losing the data stored in the previous *ptr (and leaking the data to which the pointers there point). That leaves the final puts(ptr[0]) dereferencing an uninitialized pointer.

You could instead initialize ptr to NULL and use realloc() for it instead of malloc():
```
    char **ptr = NULL;

    do {
        int i = 0;
        ptr = realloc(ptr, (n + 1) * sizeof(*ptr));
```
When its first argument is a null pointer, realloc() is equivalent to malloc().

Additional issues include:

You fail to add string terminators to the data you read. That’s not a problem as long as you don’t treat the data as strings, but puts(ptr[0]) does attempt to treat the data to which ptr[0] points as a string. And since you don’t have explicit lengths for any of the lines, it’s hard to see how you would use the other data without terminating each line to make it amenable to treatment as a string.
getchar() returns int, and you need to receive it into an int, not a char, to be able to recognize its failure / EOF return code (-1).
You should be checking for getchar() returning that code, and providing appropriate handling if it is observed.
Do not cast the return value of malloc(), calloc(), or realloc() in C. The void * return type of those functions will be converted automatically to any object pointer type, and the explicit cast can mask a certain class of programming errors.

Most of those are technical issues impacting your program’s correctness. There are additional design and best practices issues, too, but these are largely covered already by your other answers.

The big inner loop should be moved out to a function that does the dynamic memory allocation and returns a pointer to the result. If it fails to allocate memory, return NULL. It could look like this:

char* readLine() {
    size_t len = 0;
    char* res = malloc(len + 1);
    if (res == NULL) return NULL;
    int ch;
    while ((ch = getchar()) != 'n' && ch != EOF) {
        res[len] = ch;
        ++len;
        char* tmp = realloc(res, len + 1);
        if (tmp == NULL) {
            free(res);
            return NULL;
        }
        res = tmp;
    }
    // make the below
    // if (ch == EOF && len == 0) {
    // if incomplete/non-newline terminated last lines should be accepted:
    if (ch == EOF) {
        free(res);
        return NULL;
    }
    res[len] = '';
    return res;
}

The bigger problem is that your outer loop looses the memory it allocated in the previous loop so puts(ptr[0]); at the end will use a pointer that is uninitialized and your program will likely crash. You need to realloc ptr too to make more space while keeping the old pointers.

Example:

int main() {
    size_t n = 0;
    char** ptr = NULL;
    for(;;) {
        // make room for a new char*
        char** tmp = realloc(ptr, (n + 1) * sizeof *tmp);
        if(tmp == NULL) {
            puts("no room for more strings");
            break;
        }
        ptr = tmp; // realloc succeeded, keep the new pointer

        printf("Enter line: ");
        char *line = readLine();
        if (line == NULL) break;
        ptr[n++] = line;

        printf("Do you want to enter another string? [y/n]");
        if(yesOrNoOrTerm() != 'y') { // write this function
            break;
        }
    }
    printAll(ptr, n);                // write this function
    freeAll(ptr, n);                 // write this function
}

If you want to teach someone, teach them good habits. Let’s break this down a bit into functions. For instance, you need to read in a line and you want to dynamically allocate that so it can be as long as it needs to be to accommodate user input. That should be a function. It does one job and can be readily understood.

Please note:

The line grows by a factor of two to avoid a linear number of reallocations.
We check dynamic memory allocations, including assigning the reallocation to a temp variable so that it can be validated before overwriting the original pointer to prevent a memory leak.
If they fail we return NULL to indicate this to the calling function.
If a reallocation fails we free the existing memory and then return NULL to avoid a memory leak.
We could use a final realloc call to shrink the memory line is using to the bare minimum, but I haven’t since that’s more work that I don’t think is worth it.
We could also write to a length parameter to indicate the number of characters read so that that information doesn’t have to be recalculated with strlen.

char *get_line(void) {
    size_t cap = 16;
    char *line = calloc(cap, 1);
    if (!line) {
        return NULL;
    }

    size_t index = 0;
    int ch;
    while ((ch = getchar()) != EOF && ch != 'n') {
        if (index == cap - 2) {
            char *temp = realloc(line, cap * 2);
            if (!temp) {
                free(line);
                return NULL;
            }

            line = temp;
            cap *= 2;
        }

        line[index++] = (unsigned char)ch;
    }

    line[index] = '';

    return line;
}

Now if we want to read repeated lines we can make that a function with similar logic with regards to growth of a dynamic array. That function does not have to handle the logic of reading a line. It can offload that to get_line.

char **get_lines(size_t *lines_read) {
    size_t cap = 16;
    char **lines = calloc(sizeof(char *), cap);
    if (!lines) {
        return NULL;
    }

    size_t index = 0;
    for (;;) {
        if (index == cap - 1) {
            char **temp = realloc(lines, cap * 2 * sizeof(char *));
            if (!temp) {
                for (size_t j = 0; j < index; j++) {
                    free(lines[j]);
                }
 
                return NULL;
            }

            lines = temp;
            cap *= 2;
        }

        lines[index++] = get_line();

        printf("Do you want to enter another string? Enter 1 if yes else enter 0: ");

        int ans;
        if (scanf("%d", &ans) == 1 && ans == 0) {
            break;
        }
    }

    *lines_read = index;
    return lines;
}

Filed under: Kiến thức lập trình - @ 00:38

Thẻ: cpointerscharrealloc

Thiết kế website giá rẻ

Danh mục

How can i do a double pointer (char **ptr) like an array of infinity pointers (pointers with no length limit)?