Двумерный динамический массив: с каждым шагом создаётся дополнительная ячейка

[0;symbol1]
[0;symbol2]
........
[0;symboln]

#define MAXSIZE_STB 100
#define MAXZISE_STRING 1000
...
char buffer[MAXSIZE_STB][MAXSIZE_STRING];
         scanf("%s", buffer[0]);

char *array = NULL;

size_t actual_size, max_size;

if(actual_size == max_size)

if(actual_size == max_size)
{
    max_size = calculate_extra_size(max_size);
    array = realloc(array, max_size * sizeof *array); /* Важно: при ошибке realloc потеряется array.
                                                       * Если это критично, то нужно присваивать результат realloc
                                                       * вспомогательной переменной
                                                       */
}

....
//объявили указатель(?правильно?) tempstring
//записываем массив чисел
    while (string[position] != '\0') //перебираем строку
    {       
        while (string[position]>= '0' && string[position]<= '9')//берём чисто циры
        {
            /*1-создаём вспомогательную динамическую строку tempstring
            *записываем символ в tempstring если он проходит через while*/  
        }   
        while (!(string[position]>= '0' && string[position]<= '9'))
            break;
    }
    //2-сформированную строку tempstring переводим в число через atof()
    //3-это число записываем в второй динамический двумерный массив digits...
    //типа [1;числоА][1;числоБ][1;числоВ]...[1;числоN]
....

char *tempstring = NULL;

....
while (string[position]>= '0' && string[position]<= '9')//берём чисто циры
    {
    int position_tstr = 0;   //счётчик для tempstring
    *tempstring = (char*) (realloc(tempstring, sizeof(char) + (sizeof *tempstring)));
    tempstring[position_tstr++] = string[position];
    }
....

....
number = atof (tempstring);
....

int **digits = NULL;

....
            break;
    }
    //2-сформированную строку tempstring переводим в число через atof()
    number = atof (tempstring);
    //3-это число записываем в второй динамический двумерный массив digits...   
    //типа [1;числоА][1;числоБ][1;числоВ]...[1;числоN]
    /******************************
    ******************************
    *****ВОТ ТУТ КРИК О ПОМОЩИ!****
    ******************************/
....

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* Функция mystrdup возвращает динамическую строку,
 * являющуюся копией своего аргумента, или NULL, если
 * не удалось выделить память.
 * Это буквальная реализация функции strdup, которая не является
 * стандартной, но доступна в POSIX-системах.
 */
char *mystrdup(const char *str)
{
    char *result = malloc(strlen(str) + 1);
    if(result != NULL)
        strcpy(result, str);
    return result;
}
 
int main(void)
{
    char **lines = NULL;        /* Массив строк */
    size_t actual_size = 0;     /* Количество введенных строк */
    size_t max_size = 0;        /* Количество строк, под которые
                                 * выделена память */
    size_t i = 0;               /* Вспомогательная переменная для
                                 * подсчета размера новой памяти */
    char buf[BUFSIZ];           /* Вспомогательный буфер */
 
    size_t alloc_count = 0;     /* Количество операций выделения памяти */
 
    int ret = EXIT_FAILURE;     /* Код возврата программы */
    
    puts("Enter lines (Press Ctrl+D on Linux, Ctrl+Z on Windows to stop):");
        
    /* fgets возвращает NULL при конце ввода или ошибке */
    while(fgets(buf, BUFSIZ, stdin) != NULL)
    {
        char *nl;
        
        /* Проверка, нужно ли выделять еще память */
        if(actual_size == max_size)
        {
            char **tmp;            
            /* Вычисляем новый размер */
            max_size = 1 << ++i; /* Это выражение каждый раз  будет
                                  * возвращать вдвое большее значение 
                                  * (степени двойки с натуральными показателями) */
 
            /* Выделяем память */
            tmp = realloc(lines, max_size * sizeof *lines);
 
            /* Если не удалось выделить память */
            if(tmp == NULL)
            {
                perror("realloc");
                goto handle_error;
            }
 
            lines = tmp;
            ++alloc_count;
        }
 
        /* Копируем введенную строку */
        lines[actual_size] = mystrdup(buf);
 
        /* Ошибка создания динамической копии строки */
        if(lines[actual_size] == NULL)
        {
            perror("mystrdup");
            goto handle_error;
        }
 
        /* Убираем из строки символ перевода строки,
         * если он там есть */
        if((nl = strchr(lines[actual_size], '\n')) != NULL)
            *nl = '\0';
        
        ++actual_size;
    }
 
    if(ferror(stdin))
    {
        perror("stdin");
        goto handle_error;
    }
 
    if(actual_size != 0)
        puts("The lines reversed:");
    
    /* Ошибок не было, печатаем результаты */
    for(i = 0; i < actual_size; ++i)
        printf("%s\n", lines[actual_size - i - 1]);
 
    printf("Lines total: %d; the number of allocations: %d\n",
           (int) actual_size, (int) alloc_count);
    
    ret = EXIT_SUCCESS;
    
handle_error:
    for(i = 0; i < actual_size; ++i)
        free(lines[i]);
    free(lines);
    
    exit(ret);
}

int k = 0, i = 0 ,number=0;
    int *(*mass) = NULL;
    int size = (sizeof(int));
    while (-10 < k )
    {
        mass = (int**) realloc(mass, (sizeof(mass)) + 2 * size);
        for(i;i<20;i++)
        {
            mass[i]=(int*)realloc(mass[i],2 * size);
            mass[i][0]=1;
            mass[i][1]=number;
        }
        k++;
    }