数组作为函数参数

数组元素作函数实参

由于实参可以是表达式，而数组元素可以是表达式的组成部分，因此数组元素可以作为函数的实参，与用变量作实参一样，是单向传递，即“值传送”方式。

数组名作函数参数

可以用数组名作函数参数，此时形参应当用数组名或用指针变量

说明:
(1)用数组名作函数参数，应该在主调函数和被调用函数分别定义数组，分别在其所在函数中定义，不能只在一方定义。

(2)实参数组与形参数组类型应一致，如不一致，结果将出错。

(3)在被调用函数中声明了形参数组的大小为10，但在实际上,指定其大小是不起任何作用的，因为C语言编译对形参数组大小不做检查，只是将实参数组的首元素的地址传给形参数组。

(4)形参数组可以不指定大小，在定义数组时在数组名后面跟一个空的方括号。有时为了在被调用函数中处理数组元案的需要，可以另设一个形参，传递需要处理的数组元素的个数。

在传递时，传的a是数组首元素的地址，在64为架构下，长度为8个字节

数组在作为参数传递时，因为传的是地址（指针传参），所以主函数中的数组的值会因为背调函数中做的改变而改变，数组函数作为参数传递可以实现被调函数修改主调函数

数组在作为参数传递时，不是复制一遍传递给被调函数，而是把首元素的地址传递给了被调函数，数组传递比值传递效率更高

const修饰的量不可以更改，对于strcpy来讲，目标地点的值是要被更改的

去掉变量名，剩下类型名

二维数组在作为参数传递时，依然传递的是数组首元素的地址

这里算不出来行数，就是因为a是首元素的地址，而地址是8个字节，然后a[0]是一行，这里一行有4个元素，且每个元素都是Int型的，所以是16个字节

8/16 = 0.5，因为是int，所以取证整为0

一维数组相关练习

int sumOfTheArray(int a[],int len)
{
    int i,sum = 0;
    for(i = 0;i < len;++i)
    {
        sum += a[i];
    }
    return sum;
}
int maxOfTheArray(int a[],int len)
{
    int max = a[0];
    int i;
    for(i = 1;i < len;++i)
    {
        if(max < a[i])
        {
            max = a[i];
        }
    }
    return max;
}
void printArray(int a[],int len)
{
    int i;
    for(i = 0;i < len;++i)
    {
        printf("%d\n",a[i]);
    }
}
int reverse(int a[],int len)
{
    int i = 0;
    for(i = 0;i < len / 2;++i)
    {
        int t = a[i];
        a[i] = a[len - 1 - i];
        a[len - 1 - i] = t;
    }
    printArray(a,len);
}
void choiceSort(int a[],int len)
{
    int i,j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(a[i] > a[j])
            {
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
}

void bubbleSort(int a[],int len)
{
    int i,j;
    for(j = len - 1;j > 0;--j)
    {
        for(i = 0;i < j;++i)
        {
            if(a[i] > a[i + 1])
            {
                int t = a[i];
                a[i] = a[i + 1];
                a[i + 1] = t;
            }
        }
    }
}

void insertSort(int a[],int len)
{
    int i,j;
    for(i = 1;i < len;++i)
    {
        int t = a[i];
        j = i;
        while(j > 0 && a[j - 1] > t)
        {
            a[j] = a[j - 1];
            --j;
        }
        a[j] = t;
    }
}
int bianaryFinf(int a[],int len,int n)
{
    bubbleSort(a,len);
    int i,j;
    int begin = 0;
    int end = len - 1;
    int mid;
    for(i = begin;i < end;++i)
    {
        mid = (begin + end) / 2;
        if(n > mid)
        {
            begin = mid + 1;
        }
        else if(n < mid)
        {
            end = mid - 1;
        }
        else
        {
            break;
        }
        if(begin <= end)
        {
            return i;
        }
        else
        {
            return -1;
        }


    }
}

int main()
{
    int a[] = {5,4,6,8,9,7,2,1,3,6,0};
    int len = sizeof(a) / sizeof(a[0]);
    //int sum = sumOfTheArray(a,len);
    //int max = maxOfTheArray(a,len);
    //reverse(a,len);
    //printf("%d\n",sum);
    //printf("%d\n",max);
    //choiceSort(a,len);
    //bubbleSort(a,len);
    //insertSort(a,len);
    int t = bianaryFinf(a,len,12);
    if(t > 0)
    {
        printf("found\n");
    }
    else
    {
        printf("not found\n");
    }

    printArray(a,len);
    return 0;
}

二维数组相关练习

void myPuts(char a[])
{
    int i = 0;
    while(a[i] != '\0')
    {
        putchar(a[i]);
        ++i;
    }
    putchar('\n');
}

int Strlen(char s[])
{
    int i = 0;
    while(s[i] != '\0')
    {
        ++i;
    }
    return i;
}

void Strcpy(char dest[],char src[])
{
    int i = 0;
    while(src[i] != 0)
    {
        dest[i] = src[i];
        ++i;
    }
    dest[i] = '\0';
}

void Strcat(char dest[],char src[])
{
    int i = Strlen(dest);
    int j = 0;
    while(src[j] != 0)
    {
        dest[i] = src[j];
        ++j;
        ++i;
    }
    dest[i] = '\0';
}

int Strcmp(char s1[],char s2[])
{
    int i = 0;
    while(s1[i] == s2[i] && s1[i] != 0 && s2[i] != 0)
    {
        ++i;
    }
    return s1[i] - s2[i];
}

int main()
{
    char s[100] = "hello world!";
    //int ret = Strlen(s);
    //printf("%d\n",ret);
    char s2[100] = "china";
    //char a[100];
    //Strcpy(a,s);
    Strcat(s,s2);
    myPuts(s);
    return 0;
}

字符数组相关练习

void PrintArray2d(int a[][4],int rows)
{
    int i ,j;
    int cols = sizeof(a[0]) / sizeof(a[0][0]);
    for(i = 0;i < rows;i++)
    {
        for(j = 0;j < cols;++j)
            {
                printf("%2d ",a[i][j]);
            }
    }
}

int maxOfArray(int a[][4],int rows)
{
    int i,j;
    int cols = sizeof(a[0]) / sizeof(a[0][0]);
    int max = a[0][0];
    for(i = 0;i < rows;++i)
    {
        for(j = 0;j < cols;++j)
        {
            if(max < a[i][j])
            {
                max = a[i][j];
            }
        }
    }
    return max;
}

int sumOfEdgeNumbers(int a[][4],int rows)
{
    int i,j;
    int sum = 0;
    int cols = sizeof(a[0]) / sizeof(a[0][0]);
    for(i = 0;i < rows;++i)
    {
        for(j = 0;j < cols;++j)
        {
            if(i == 0 || j == 0 | i == 2 || j == 3)
            {
                sum += a[i][j];
            }
        }
    }
    return sum;

}

void fn(int a[][4],int rows,float f)
{
    int i,j;
    for(i = 0;i < rows;++i)
    {
        for(j = 0;j < 4;++j)
        {
            a[i][j] *= f;
        }
    }
}

void printStrings(char s[][100],int rows)
{
    int i;
    for(i = 0;i < rows;++i)
    {
        puts(s[i]);
    }
}

void reverseStrings(char s[][100],int rows)
{
    int i;
    for(i = 0;i < rows / 2;++i)
    {
        char t[100];
        Strcpy(t,s[i]);
        Strcpy(s[i],s[rows - i - 1]);
        Strcpy(s[rows - i - 1],t);

    }
}
void sortStrings(char s[][100],int rows)
{
    int i,j;
    int cols = sizeof(s[0]) / sizeof(s[0][0]);
    for(i = 0;i < rows - 1;++i)
    {
        for(j = i + 1;j < rows;++j)
        {
            if(strcmp(s[i],s[j]) > 0)
            {
                int t[100];
                strcpy(t,s[i]);
                strcpy(s[i],s[j]);
                strcpy(s[j],t);
            }
         
        }
    }

}

int main()
{
    int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int rows = sizeof(a) / sizeof(a[0]);
    //int max = maxOfArray(a,3);
    fn(a,3,1.5);
    PrintArray2d(a,3);
    //printf("%d\n",max);
    //int sum = sumOfEdgeNumbers(a,3);
    //printf("%d\n",sum);
    
    return 0;
}