C代码函数调用不工作

好的，我需要编写两个函数迭代和递归来计算数组中的负元素，然后我需要构建main。我只能编写递归函数，但我不能从main调用它，这是一个错误。有人能帮我解决这个问题并用迭代法帮我吗

#include <stdio.h>

main()
{
    int vektor[100];
    int i, madhesia;

    /* Input size of array */
    printf("Madhesia e vektorit: ");
    scanf("%d", &madhesia);

    /* Input array elements */
    printf("Elementet: ");
    for (i = 0; i < madhesia; i++)
    {
        scanf("%d", &vektor[i]);
    }

    int ret = numero(vektor, madhesia);
    printf("\nTotal negative elements in array = %d", ret);

    return 0;
}

int numero(array, size)
{
    int count = 0;
    for (int j = 0; j < size; j++)
    {
        if (array[j] < 0)
        {
            count++;
        }
    }

    return count;
}

#包括
main（）
{
int vektor[100]；
int i，马德西亚；
/*数组的输入大小*/
printf（“Madhesia e vektorit:”）；
scanf（“%d”&madhesia）；
/*输入数组元素*/
printf（“元素集：”）；
对于（i=0；i
一段有效的代码是这样的。你真的需要看看指针及其工作方式。
在这里您可以看到，我在数组的开头有一个指针->指向-<，因此通过传递数组的起始地址和数组的长度，您的函数知道需要做什么

#include <stdio.h>


int numero(int* array, int size);
int* recursive_count(int* array, int size , int* counter );


int main()
{
    int vektor[100];
    int* vekt_ptr = &vektor[0];
    int i, madhesia;
    int counter;
    counter=0;

    /* Input size of array */
    printf("Madhesia e vektorit: ");
    scanf("%d", &madhesia);

    /* Input array elements */
    printf("Elementet: ");
    for (i = 0; i < madhesia; i++)
    {
        scanf("%d", &vektor[i]);
    }

    //int ret = numero(vekt_ptr, madhesia);
    recursive_count(vekt_ptr, madhesia , &counter );
    int ret = counter;
    printf("\nTotal negative elements in array = %d", ret);

    return 0;
}

int numero(int* array, int size)
{
    int count = 0;
    int j;
    for (j = 0; j < size; j++)
    {
        if (array[j] < 0)
        {
            count++;
        }
    }

    return count;
}

int* recursive_count(int* array, int size , int* counter )
{
    size--;
    if(array[size] < 0 )
    {
        (*counter)++;
    }
    if(size==0)
    {
        return NULL;
    }
    return recursive_count(array++, size , counter );
}

#包括
整数（整数*数组，整数大小）；
int*递归计数（int*数组、int大小、int*计数器）；
int main（）
{
int vektor[100]；
int*vekt_ptr=&vektor[0]；
int i，马德西亚；
整数计数器；
计数器=0；
/*数组的输入大小*/
printf（“Madhesia e vektorit:”）；
scanf（“%d”&madhesia）；
/*输入数组元素*/
printf（“元素集：”）；
对于（i=0；i

假设您希望动态创建一个X长度的数组。
编译器将根据长度为数组提供一些内存。
您可以初始化数组，比如说[2][45][1][5][99]
调用函数时，必须传递存储在内存中的位置。
int*vekt_ptr=&vektor[0]-它将以0x56c2e0的形式给出。
这个数字是数组的地址，它是数组起始点的地址。它等于第一个字节的地址。
因此，当函数启动时，它知道数组的启动位置和长度。
这是一段有效的代码。您确实需要了解指针及其工作方式。
在这里您可以看到，我在数组的开头有一个指针->指向-<，因此通过传递数组的起始地址和数组的长度，您的函数知道需要做什么

#include <stdio.h>


int numero(int* array, int size);
int* recursive_count(int* array, int size , int* counter );


int main()
{
    int vektor[100];
    int* vekt_ptr = &vektor[0];
    int i, madhesia;
    int counter;
    counter=0;

    /* Input size of array */
    printf("Madhesia e vektorit: ");
    scanf("%d", &madhesia);

    /* Input array elements */
    printf("Elementet: ");
    for (i = 0; i < madhesia; i++)
    {
        scanf("%d", &vektor[i]);
    }

    //int ret = numero(vekt_ptr, madhesia);
    recursive_count(vekt_ptr, madhesia , &counter );
    int ret = counter;
    printf("\nTotal negative elements in array = %d", ret);

    return 0;
}

int numero(int* array, int size)
{
    int count = 0;
    int j;
    for (j = 0; j < size; j++)
    {
        if (array[j] < 0)
        {
            count++;
        }
    }

    return count;
}

int* recursive_count(int* array, int size , int* counter )
{
    size--;
    if(array[size] < 0 )
    {
        (*counter)++;
    }
    if(size==0)
    {
        return NULL;
    }
    return recursive_count(array++, size , counter );
}

#包括
整数（整数*数组，整数大小）；
int*递归计数（int*数组、int大小、int*计数器）；
int main（）
{
int vektor[100]；
int*vekt_ptr=&vektor[0]；
int i，马德西亚；
整数计数器；
计数器=0；
/*数组的输入大小*/
printf（“Madhesia e vektorit:”）；
scanf（“%d”&madhesia）；
/*输入数组元素*/
printf（“元素集：”）；
对于（i=0；i

假设您希望动态创建一个X长度的数组。
编译器将根据长度为数组提供一些内存。
您可以初始化数组，比如说[2][45][1][5][99]
调用函数时，必须传递存储在内存中的位置。
int*vekt_ptr=&vektor[0]-它将以0x56c2e0的形式给出。
这个数字是数组的地址，它是数组起始点的地址。它等于第一个字节的地址。
因此，当函数启动时，它知道数组的启动位置和长度。
将numero（）的函数原型放在main（）之前，以便能够调用它。声明类型为的函数参数：

int numero(int array[], int size);

int main() {
...

将numero（）的函数原型放在main（）之前，以便能够调用它。声明类型为的函数参数：

int numero(int array[], int size);

int main() {
...

一些可能的实现：

int iterativeCountNegativeIntegers (int *array, int size)
{
    int result = 0;
    for (int i = 0; i < size; ++ i)
         if (array[i] < 0)
             result += 1;
    return result;
}

int recursiveCountNegativeIntegers (int *array, int size)
{
    if (size == 0)
        return 0;

    int partial = *array < 0;
    return partial + recursiveCountNegativeIntegers(array+1, size-1);
}

int迭代计数负整数（int*数组，int大小）
{
int结果=0；
对于（int i=0；i

同样，浓缩：

int iterativeCountNegativeIntegers_1 (int *array, int size)
{
    int result = 0;
    while (--size >= 0)
         result += *array++ < 0;
    return result;
}


int recursiveCountNegativeIntegers_1 (int *array, int size)
{
    return (size == 0) ? 0
      : (*array < 0) + recursiveCountNegativeIntegers_1(array+1, size-1);
}

int iterativeCountNegativeIntegers_1（int*数组，int大小）
{
int结果=0；
而（--size>=0）
结果+=*数组+++<0；
返回结果；
}
int recursiveCountNegativeIntegers_1（int*数组，int大小）
{
返回值（大小==0）？0
：（*array<0）+recursiveCountNegativeIntegers_1（array+1，siz
#include <stdio.h>

#define N   100

size_t iterative_numero( const int array[], size_t size );
size_t recursive_numero( const int array[], size_t size );

int main( void )
{
    int vektor[N];
    size_t madhesia = 0;

    /* Input size of array */
    printf("Madhesia e vektorit: ");
    scanf("%zu", &madhesia);

    if ( N < madhesia ) madhesia = N;

    /* Input array elements */
    printf("Elementet: ");
    for ( size_t i = 0; i < madhesia; i++ )
    {
        scanf( "%d", &vektor[i] );
    }

    size_t ret = iterative_numero(vektor, madhesia );
    printf("\nTotal negative elements in array = %zu\n", ret);
    ret = recursive_numero(vektor, madhesia );
    printf("Total negative elements in array = %zu\n", ret);

    return 0;
}

size_t iterative_numero( const int array[], size_t size )
{
    size_t count = 0;

    for ( size_t i = 0; i < size; i++)
    {
        if ( array[i] < 0 )
        {
            count++;
        }
    }

    return count;
}

size_t recursive_numero( const int array[], size_t size )
{
    return size == 0 ? 0 : ( array[0] < 0 ) + recursive_numero( array + 1, size - 1 );
}

Madhesia e vektorit: 10
Elementet: 0 -1 2 -3 4 -5 6 -7 8 -9

Total negative elements in array = 5
Total negative elements in array = 5

#include <stdio.h>

int main()
{
int vektor[100];
int i, madhesia;

/* Input size of array */
printf("Madhesia e vektorit: ");
scanf("%d", &madhesia);

/* Input array elements */
printf("\nElementet: ");
for (i = 0; i < madhesia; i++)
{
    scanf("%d", &vektor[i]);
}

printf("\nno of elements:%d",madhesia);
printf("\n");

for (i = 0; i < madhesia; i++)
{
    printf("%d", vektor[i]);
}
printf("\n");
i=0;

int ret = numero(vektor,madhesia,0,i);
printf("\nTotal negative elements in array = %d", ret);

return 0;
}

int numero(int array[],int size,int count,int j)
{
 if (j<=size-1)
{
if(array[j]<0)
    {
        count++;
        j++;
        numero(array,size,count,j);
}

else
{
   j++;
   numero(array,size,count,j);

 }
 }

return count;
}

#include<stdio.h>

int numero(int *, int);    //Function Prototype (1)

int main()      //Return Type (2)
{
    int vektor[100];
    int i, madhesia;
    printf("Madhesia e vektorit: ");
    scanf("%d", &madhesia);
    printf("Elementet: ");
    for (i = 0; i < madhesia; i++)
    {
        scanf("%d", &vektor[i]);
    }
    int ret = numero(vektor, madhesia);
    printf("\nTotal negative elements in array = %d", ret);
    return 0;
}

int numero(int* array,int size)        //Parameters Data Type (3)
{
    int count = 0;
    for (int j = 0; j < size; j++)
    {
        if (array[j] < 0)
        {
            count++;
        }
    }
    return count;
}