This line arr = (char*)malloc (2 * sizeof (char)); will allocate memory for 2 bytes only. But you are overwriting the memory by accessing the more 8 or more than 8 byes. If you access more than two byes means, it will give some unpredictable issue. In case you want more memory please follow the below code.

#define USER_SIZE 10
arr = (char*)malloc ( USER_SIZE * sizeof (char));

Assign the value in USER_SIZE macro and then allocate the memory as much as you want.

Example for 2D pointer ( 5 X 10 )

#define ROW 5
#define COLUMN 10
main()
{
  unsigned char **p = NULL, colum = 0;
  p = malloc ( ROW * sizeof ( unsigned char *) );
  for (;colum< ROW; ++colum )
  {
    p[colum] = malloc (COLUMN * sizeof (unsigned char  ));
  }
}

In C a string is a char*. A dynamic array of type T is represented as a pointer to T, so for char* that would be char**, not simply a char* the way you declared it.

The compiler, no doubt, has issued some warnings about it. Pay attention to these warnings, very often they help you understand what to do.

Here is how you can start your testing:

char **aPtr;
int len = 1; // Start with 1 string
aPtr = malloc(sizeof(char*) * len); // Do not cast malloc in C
aPtr[0] = "This is a test";
printf("%s",aPtr[0]); // This should work now.

you need triple pointer *** (wrrrr.....) or just return realloced pointer back.

char ** push_back(char **arr, char *element, int *counter) {
    *counter += 1;

    arr = realloc(arr, *counter * sizeof(char *));
    arr[*counter - 1] = element;
    return arr;
}

int main() {
    char **arr = NULL;
    int counter = 0;

    arr = push_back(arr, "element", &counter);
    arr = push_back(arr, "element2", &counter);
    arr = push_back(arr, "element3", &counter);
    arr = push_back(arr, "element4", &counter);
    arr = push_back(arr, "element5", &counter);
    arr = push_back(arr, "element6", &counter);

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

    free(arr);
    return 0;
}

You do not need to malloc and then check the value of the counter. https://godbolt.org/z/xnaxKo

PS Yuo shiuld always check the result of the malloc (and friends).

You have to allocate memory and then reallocate. Here an example:

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

int main(void) {

    //allocate a buffer of 10 pointers
    size_t array_size = 10;
    char ** array=(char **)malloc(array_size * sizeof(*array) );
    if (!array)
        return -1;

    //now allocate the 10 pointers with a buffer to hold 42 characters
    for (int i = 0; i < array_size; i++) {
        array[i]= (char *)malloc( 42 * sizeof (*array[i]) );
        if (!array[i])
            return -1;
        strcpy(array[i], "10");
    }

    //for some reason we need to increase array size by 1
    ++array_size;
    array = (char **)realloc(array, array_size * sizeof(*array) );
    array[array_size-1] = (char *)malloc(42 * sizeof(*array[array_size-1]) );
    if (!array[array_size-1])
        return -1;
    strcpy(array[array_size-1], "12");
}

The problem is you are dereferencing an uninitialized variable. You need to allocate memory for str somehow.

Fortunately for you, there is a function that does this for you, called getline().

char * get_info(char *ch) {
  char *str;

  printf("Enter a sentence to seach: ");
  str = NULL;
  getline(&str, NULL, stdin);
  printf("Enter a character to search for: ");
  *ch = getchar();

  return str;
}

This:

realloc(input, (sizeof(char)));

is wrong. The realloc() function doesn't modify the given pointer (it can't!), it returns the new pointer. It can also fail, and return NULL.

Also, the second argument doesn't make any sense at all, it should be the new desired total size of the previously allocated buffer, but you're always passing (a very obscure) 1. It's not "grow this by this amount", it's the rather more low-level "attempt to grow this to this new size, and return the new location of the grown buffer".

Please read the documentation very carefully.