Read one character at a time (using getc(stdin)) and grow the string (realloc) as you go.

Here's a function I wrote some time ago. Note it's intended only for text input.

char *getln()
{
    char *line = NULL, *tmp = NULL;
    size_t size = 0, index = 0;
    int ch = EOF;

    while (ch) {
        ch = getc(stdin);

        /* Check if we need to stop. */
        if (ch == EOF || ch == '\n')
            ch = 0;

        /* Check if we need to expand. */
        if (size <= index) {
            size += CHUNK;
            tmp = realloc(line, size);
            if (!tmp) {
                free(line);
                line = NULL;
                break;
            }
            line = tmp;
        }

        /* Actually store the thing. */
        line[index++] = ch;
    }

    return line;
}

NOTE: My examples are not checking for NULL returns from malloc()... you really should do that though; you will crash if you try to use a NULL pointer.

First you have to create an array of char pointers, one for each string (char *):

char **array = malloc(totalstrings * sizeof(char *));

Next you need to allocate space for each string:

int i;
for (i = 0; i < totalstrings; ++i) {
    array[i] = (char *)malloc(stringsize+1);
}

When you're done using the array, you must remember to free() each of the pointers you've allocated. That is, loop through the array calling free() on each of its elements, and finally free(array) as well.

Your allocation is not the best, and printf argument arr[i] expects a char* but you pass it an int (a char if you'd like).

Here is how you should do it, with comments:

Live demo

#include <stdio.h>
#include <stdlib.h> //for malloc

int main(){
    int n;
    int i;
    
    printf("Give me a number:");
    scanf("%d", &n);

    //declare a variable of pointer to pointer to char
    //allocate memory for the array of pointers to char, 
    //each one capable of pointing to a char array
    char **arr = malloc(n * sizeof *arr);

    if(arr == NULL){ //check for allocation errors
        perror("malloc");
        return EXIT_FAILURE;
    }

    //allocate memory for each individual char array
    for(i = 0; i < n; i++){
        arr[i] = malloc(40); //char size is always 1 byte

        if(arr == NULL){ //check for allocation errors
            perror("malloc");
            return EXIT_FAILURE;
        }
    }

    for (i = 0; i < n; i++){
        printf("Give me a word: ");
        //limit the size of read input to 39 charaters to avoid overflow, 
        //a nul character will be added by scanf
        scanf("%39s", arr[i]);
    }

    for (i = 0; i < n; i++){
        printf("%s\n", arr[i]);
       
    }
     
    for(int i = 0; i < n; i++){ //free the memory for each char array
        free(arr[i]);
    }
    free(arr); //free array of pointers

    return 0;
}

You can also do this with less code using a pointer to array of 40 chars, this will simplify the memory allocation and deallocation:

Sample with comments:

Live demo

#include <stdio.h>
#include <stdlib.h> //for malloc

int main(){
    int n;    
    int i;

    printf("Give me a number:");
    scanf("%d", &n);

    //declare a pointer to array of chars and
    //allocate memory for all the char arrays
    char (*arr)[40] = malloc(n * sizeof *arr);

    if(arr == NULL){ //check for allocation errors
        perror("malloc");
        return EXIT_FAILURE;
    }

    for (i = 0; i < n; i++){
        printf("Give me a word: ");
        scanf("%39s", arr[i]);
    }

    for (i = 0; i < n; i++){
        printf("%s\n", arr[i]);
    }

    free(arr); //free allocated memory

    return 0;
}

What you can and should do is use std::string and initialize it from a literal like

 std::string mystring{"Hello"};

When you do that, mystring is allocated on the stack and its content is initialized from "Hello" (perhaps by copying it, but read about small string optimization, or short string optimization).

When that string is destroyed (e.g. at the end of the containing block), its storage (and perhaps the internal copy, if one was made) will be released.

If you insist for having a pointer to a heap-allocated C string, you could use strdup (then release it with free, not delete); if you want a raw array of char, you could use

 char* p = new char[sizeof("Hello")]; // or new char[6]
 strcpy(p,"Hello");

but this works only for literal strings like "Hello" and you should use the same literal string "Hello" twice (or use strlen("Hello")+1 instead of sizeof("Hello"), which is 6, because of the terminating zero byte).

Notice that in all cases you never dynamically allocate a string literal. A compiler is permitted to (and often does) put the literal string in the read-only code segment of the produced binary executable. What you can do is allocate in heap a memory zone filled with a copy of that literal string (or use a pointer const char* pc = "hello";)

char *s;       
s = malloc(1024 * sizeof(char));

The above declares the variable s and assigns to it the address of a dynamically allocated chunk of memory large enough to hold 1024 chars. However, no error checking is performed, so s may be NULL at this point.

scanf("%s", s);

This reads data from the input stream until a whitespace is encountered (or input terminates) and stores it in the allocated chunk of memory whose address is contained in s , appending a '\0' after the data that is read. If there is more than 1023 bytes of data or if the previous malloc returned NULL, undefined behavior occurs. (This is bad.)

s = realloc(s, strlen(s) + 1);

This is an attempt to shrink the amount of memory being used so that s now points to a smaller chunk of memory which is just big enough to hold the string that was read. The +1 is in the 2nd argument to realloc because C stores strings as null terminated arrays, and it takes an extra character to store that terminator. This is possibly a memory leak, since realloc can return NULL, in which case the original memory is lost and the program hasn't stored that value anywhere so cannot free it.

Do not ever use "%s" in a call to scanf. If you have allocated N bytes for an array, use a width modifier of N - 1. Often this means dynamically generating the format string, but often it is as simple as:

char s[32]; scanf("%31s", s); 

Always check the value returned by malloc, realloc, and scanf.

You allocate memory but then you leak that pointer by replacing it with a new pointer value. Presumably word is an array on the stack or similar.

// Stores a pointer
wordList[i] = (char *)malloc(columns + 1);

// Stores a new pointer (discards previous value)
wordList[i] = word;

So now, not only have you leaked a whole lot of memory by throwing away pointers, you have also changed every word to point to your word buffer. That's why you see the output contains only the last word repeated.

What you need to do instead is copy the string. Provided you know that the word is no longer than columns in length, you can do:

strcpy(wordList[i], word);

Note there's no obvious relationship between columns and MAX_CHARS so it's hard to advise further on the safety of your memory allocation. I do wonder why you allocate the strings up-front. Why not just allocate them as needed?

wordList[i] = malloc(strlen(word) + 1);
if (wordList[i] != NULL) {
    strcpy(wordList[i], word);
}

How does std::string in c++ allocate memory?

as needed, transparently to the user.

i know of the 'new' keyword in c++ and 'malloc' in c but when i try something like this, my program stops working.

char* str = new char[strlen(str) + 1];
cin>>str;

Well ... yeah; strlen counts the consecutive characters at the provided address, until it encounters a zero. In your case, the specified address is not set (it will be set after strlen is evaluated) so you are effectively calling strlen with some random input - there is no way that would work.

I also know of vectors in C++ but not a big fan of using them,

You really really (really really really) should be. They are an extremely thin (read: fast) wrapper over creating dynamic contiguous memory blocks (exactly what you are trying to solve), that provide type safety, memory bounds safety and automatic memory management.

i would like to know if there's a way to dynamically allocate memory without having to allocate a size before

No.

something close but not as sophisticated as the string.h library.

The string.h is not able to allocate memory without knowing the size. It computes the size every time it needs to allocate memory, at a runtime cost (by, for example, using strlen when needed).

How does the string library get unlimited input from user without the programmer specifying buffer size?

It doesn't. What it does (in rough pseudocode) is this:

• compute the size of the input (probably requesting it from the input steam through an API)
• compute the new size the string should have after reading
• allocate memory (depending on new size), if required
• copy data in new memory
• delete old memory and use new instead (if any old memory/value was set)

A number of issues:

1. memory size is one too small.

2. while(c!='\n') first test c even though it is uninitialized.

3. string() should pass the address of a char * as in string(char **)

4. Better to use size_t rather than int when working with strlen().

Minor:

5. EOF is not detected. Use int c rather than char c to aid in detection.

6. Certainly inefficient to realloc() each loop.

7. Casting of malloc()/realloc() unnecessary.

8. Good to check for out-of-memory.

9. Use int main(void) rather than int main() for portability.

   size_t string(char **str) {
     assert(str);
     int c; 
     size_t i = 0;
     size_t size = 0;
     *str = NULL;
   
     printf("Enter String : ");
     while((c = getc(stdin)) !='\n' && c != EOF) {
       if (i == size) {
         size *= 2 + 1;         // double the size each time
         *str = realloc(*str, size);
         assert(*str);
       }
       (*str)[i] = c;           // store read character by making pointer point to c
       i++;
     }
     *str = realloc(*str, i+1); // right-size the string
     assert(*str);
     (*str)[i] = '\0';          // at the end append null character to mark end 
     printf("\nThe entered string is : %s",*str);
     return i;    
   }
   

C is willing to automatically size, allocate, and initialize arrays for you. With one exception, however, there is no way to automatically initialize a pointer that points to some other array.

Here is automatic sizing and allocation of an array:

int a[] = {1, 2, 3};

The brackets [] are empty -- you don't have to explicitly specify the size -- because the compiler can see from the initializer that the array should have size 3.

Here is another example, using char:

char s1[] = {'H', 'e', 'l', 'l', 'o', 0};

Here is a much more convenient shortcut form:

char s2[] = "world";

Here is the exception I was talking about:

char *s3 = "hidden";

In this case, the compiler allocates a hidden, unnamed array containing the string "hidden", then initializes s3 to point to it. This is just about perfectly equivalent to the more explicit setup

char a2[] = "hidden";
char *s3a = a2;

except for the visibility of the intermediate array a2.

Putting all this together, you can initialize an array of pointers to char like this:

char *strarray[] = { "Hello", "world" };

This is equivalent (again, except for the visibility of the actual arrays holding the strings) to the more explicit

char a3[] = "Hello";
char a4[] = "world";

char *strarray2[] = { a3, a4 };

But you can not directly do anything along the lines of

char **dynstrarray = { ... };

The reason you can't do it is because dynstrarray is fundamentally a pointer, and there's no general mechanism in C to automatically allocate something for a pointer like this to point to. Again, the only time C will automatically allocate something for a pointer to point to is the special case for pointer to char, as demonstrated by s3 above.

So if you want to initialize a pointer like dynstrarray, your only choice is to do it explicitly, yourself. You could initialize it to point to an array of pointers to char that you had already constructed, like this:

char a3[] = "Hello";
char a4[] = "world";
char *strarray2[] = { a3, a4 };
char **dynstrarray[] = strarray2;

Or, more commonly, you would use malloc to dynamically allocate some memory for dynstrarray to point to. In that case (but only in that case) you would also have the option of resizing dynstrarray later, using realloc.