Input array with recursively function without loops (.c)

It is not exactly clear what you are trying to achieve. But I would guess that your array parameter is not correct in the recursive call. Now all calls to getss get same array but different size. (Where does variable i come from? Variable counter does not have much use in posted code.)

I would assume that you need to update the array pointer to point to next element in array in the recursive call. In other words, pass address of second element in the array instead of the first element (current behaviour). That would be in line with the size-1 in the recursive call.

The implementation is trivial but is left as an exercise to the poster as this looks like homework to me.

You have unneeded variables. Is this what you are trying to accomplish:

The following will fill in the array so that the first value read with scanf() will be stored in the last element.

void getss(int array[], int size)
{
    if (size == 0)
        return;
    scanf("%d", &array[size-1]);
    getss(array, size - 1);
    return;
}

The following will fill in the array so that the first value read with scanf() will be stored in the first element.

void getss(int array[], int size)
{
    if (size == 0)
        return;
    scanf("%d", &array[0]);
    getss(&array[1], size - 1);
    return;
}

If you were to do this iteratively, how would you do it? I would assume something like this:

void getss(int array[], int size) {
  int i;
  for (i = 0; i < size; i++) {
    scanf("%d", array[i]);
  }
}

Our i there just serves to count our way through the array, so if we change our function slightly we can get rid of it:

void getss(int* array, int size) {
  for (; size > 0; size--, array++) {
    scanf("%d", array);
  }
}

Now our "counter" is the size variable itself and instead of indexing in our array we just keep stepping forward our pointer to it.

Now this is in a perfect form to be turned into a recursive function. Instead of size-- and array++ we can pass the new values into another call to getss at the end of the function:

void getss(int* array, int size) {
  if (size > 0) {
    scanf("%d", array);
    getss(array + 1, size - 1);
  }
}

So our loop's terminating condition has moved into an if and instead of array++ and size-- we pass in array+1 and size-1 to our next call. It achieves the same result as looping but without an explicit loop construct.

Along with the other problems, what's the point of using counter? It is either 0 or 1 and never passed to the next call. Should it have been declared static?

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

void getss(int* array, int size){
    if (size == 0)
        return;
    scanf("%d", array);
    getss(++array, size - 1);
}

int main(){
    int *array;
    int i, size;

    printf("input array size:");
    scanf("%d", &size);
    array = (int*)malloc(sizeof(int)*size);
    getss(array, size);
    for(i=0;i<size;i++){
        printf("array[%d]=%d\n", i, array[i]);
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int a[100];
void input(int n)
{
    if(n==0)
    {
        return;
    }
    input(--n);
    cin>>a[n];
}
int main()
{
        int n=4;
        input(n);
        for(int i=0;i<n;i++)
        {
            cout<<a[i]<<" ";
        }


} 

void getss(int array[], int size , int counter)
{
    if (size == 0)
        return;
    if (counter < size) {
        scanf("%d", &array[i]);
        counter++;
    }
    getss(array, size - 1, counter);
    }