can figure out the problem with my realloc inside the function

I'm writing a program that needs to call a function that adds numbers until -1 is introduced, the problem is that after 3 numbers the program stops and gives segmentation fault:

int leNumeros(int **lista, int *nElem, int *tam)
{
    int op, *temp = NULL;
    *lista = (int*) malloc(*tam * sizeof(int));
    
    if(*lista == NULL)
    {
        printf("memory fail\n");
    } else
    {
        do
        {
            printf("number:\n");
            scanf("%d",&op);

            if(op >= 0)
            {
                if(*nElem >= *tam)
                {
                *lista = (int*) realloc( *lista, *nElem * sizeof(int) );
                
                if(*lista == NULL)
                {
                    printf("memory fail");
                }
                else
                {
                    printf("added: %d bytes total: %d bytes\n",
                            *nElem * sizeof(int), *nElem * sizeof(int) + *tam * sizeof(int));
                    //*lista = temp;
                }
                }
                *lista[*nElem] = op;
                (*nElem)++;
                
                
                
            }
        }while(op >= 0);
    }    
}


int main(int argc, char** argv) {
    
    int *lista = NULL, nElem = 0, tam = 0;
    
    leNumeros(&lista, &nElem, &tam);
    
    return (EXIT_SUCCESS);
}

I'm having trouble understanding what is going on, can anyone help me please?

When leNumeros() is called you attempt to allocate a zero length block - that has implementation defined behaviour.

Then when you enter a number > 0, you attempt to realloc() a zero length block - that behaviour is well defined it frees the original block then returns a null pointer, then at *lista[*nElem] = op; you deference that null pointer rather than aborting the loop.

In any event *lista[*nElem] = op; should be (*lista)[*nElem] = op;

Even if *nElem was non-zero, the line:

*lista = (int*)realloc(*lista, *nElem * sizeof(int));

is bad-practice, because if the reallocation fails the original block will leak because *lista will be come NULL without releasing whatever it previously pointed to. Instead you should (for example):

int* new_block = realloc(*lista, *nElem * sizeof(int));
if( new_block == NULL )
{
    printf( "memory fail\n" ) ;
    break ;
}

*lista = new_block ;

To work at all in main tam must be > 0, and to avoid possible failure due to implementation defined behaviour nElem should also be grater than zero.

I think the tam parameter is probably the block size to allocate. So for example, if tam = 10, allocate space for 10 ints. Then after taking 10 ints, realloc for 10 more.

Also, note that because of operator precedence, *lista[*nElem] = op; is the same as *(lista[*nElem]) = op;. You want to deference the pointer first, then use the brackets: (*lista)[*nElem] = op;

void leNumeros(int **lista, int *nElem, int *tam)
{
    if (*tam <= 0) {
        puts("Error: tam must be > 0");
        return;
    }

	int op;

    // Keep track of how many ints the array can hold
	int items_allocated = *tam;
	*lista = malloc(*tam * sizeof(int));

	if (*lista == NULL)
	{
		printf("memory fail\n");
	}
	else
	{
		do
		{
			printf("number:\n");
			if (1 != scanf("%d", &op)) break;

			if (op >= 0) {
				// Realloc a new block of tam bytes if out of space
				if (*nElem >= items_allocated) {
					items_allocated += *tam;
					int *temp = realloc(*lista, items_allocated * sizeof(int));

					if (temp == NULL) {
						printf("memory fail");
						break;
					}
					else {
                        *lista = temp;
						printf("added: %zu bytes total: %zu bytes\n", *tam * sizeof(int), items_allocated * sizeof(int));
					}
				}
				(*lista)[*nElem] = op;
				(*nElem)++;
			}
		} while (op >= 0);
	}
}


int main(int argc, char** argv) {

	int *lista = NULL, nElem = 0, tam = 5;
	leNumeros(&lista, &nElem, &tam);

	for (int i = 0; i < nElem; i++) {
		printf("%d ", lista[i]);
	}

	return (EXIT_SUCCESS);
}

</details>