数组与函数

数组常见错误：

① float a[0];      /* 数组大小为0没有意义 */

② int b(2)(3);   /* 不能使用圆括号 */

③ int k, a[k];   /* 不能用变量说明数组大小*/    

一维数组：

 

#include <stdio.h>

int b[5];    //未初始化的全局变量是0

int main()
{
    int i;
    //int array[5];   //未初始化的局部变量是垃圾值
    //int array[5] = {1, 2, 3, 4, 5};
    //int array[5] = {1, 2};   //对部分元素初始化，其他未初始化元素为0
    int array[] = {1, 2, 3, 4 ,5};

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

    printf("%p\n", &array[0]);    //数组首元素地址，单位是4字节
    printf("%p\n", array);        //array是数组名，同时也是数组首元素地址，单位是4字节
    printf("%p\n", &array);       //数组的地址，单位是一个数组，20字节

    printf("*****************\n");

    printf("%p\n", &array[0] + 1);
    printf("%p\n", array + 1);
    printf("%p\n", &array + 1);

    return 0;
}
 

二维数组：

赋初值：

{
    int i, j;
    //int a[4][3];
    //int a[4][3] = {1, 2, 3, 4, 5 ,6, 7, 8, 9, 10, 11, 12};
    //int a[4][3] = {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {7, 9, 8}};
    //int a[4][3] = {1, 2};
    //int a[4][3] = {{1}, {2, 3}, {3, 4}, {5}};
    //int a[][3] = {1, 2, 3, 4, 5 ,6, 7, 8, 9, 10, 11, 12};
    int a[4][3] = {0};

    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 3; j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
 printf("%p\n", &a[0][0]);    //首元素的地址，单位4字节
 printf("%p\n", a[0]);        //首行首元素地址，单位4字节
 printf("%p\n", &a[0]);       //首行的地址，单位12字节
 printf("%p\n", a);           //首行的地址，单位12字节
 printf("%p\n", &a);          //数组的地址，单位48字节

printf("%p %p\n", a[1], *(a + 1));  //[x]   ======== *(a + x)

PS冒泡排序：

#include <stdio.h>

void GetArray(int a[], int length)
{
    int i;
    printf("Please input:\n");
    for (i = 0; i < length; i++)
    {
        scanf("%d", &a[i]);
    }
}

void sort(int a[], int length)
{
    int i, j, tmp;

    for (i = 0; i < length - 1; i++)
    {
        for (j = 0; j < length - i - 1; j++)
        {
            if (a[j + 1] < a[j])
            {
                tmp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

void print(int a[], int length)
{
    int i;
    for (i = 0; i < length; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main()
{
    int i, j, tmp;
    int a[10] = {0};
    int length = sizeof(a) / sizeof(a[0]);

    GetArray(a, length);

    sort(a, length);

    print(a, length);

    return 0;
}
 

 

字符串：

#include <stdio.h>
#include <string.h>

int main()
{
/*
    char str[20] = "hello";
    char ptr[20] = "world";

    strcat(str, ptr);        //将字符串ptr连接到str后面

    printf("%s\n", str);*/

/*    char str[20] = "helloworld";
    char ptr[20] = "world";

    //strcpy(str, ptr);    //字符串拷贝函数 把ptr指向的字符串拷贝到str里 包含'\0'
    strncpy(str, ptr, 3);
    printf("%s\n", str);*/

    //字符串赋值
    /*1、char str[20] = "hello";
    2、char str[20];
    str[0] = 'h';
    str[1] = 'e'
    ...
    3、strcpy(str, "hello");

    错误：char str[20];
    str = "helloworld";*/

    char str[20] = "hello";
    char ptr[20] = "world";

    if (strcmp(str, ptr) == 0)
    {
        printf("字符串相等\n");
    }
    else if (strcmp(str, ptr) > 0)
    {
        printf("%s 大于 %s\n", str, ptr);
    }
    else if (strcmp(str, ptr) < 0)
    {
        printf("%s 小于 %s\n", str, ptr);
    }

    if (strncmp(str, ptr, 1) < 0)
    {
        printf("%s 小于 %s\n", str, ptr);
    }

    return 0;

形参实参：

 

#include <stdio.h>

void print();      //函数声明

int add(int x, int y)  //有返回值 有形参  1、形参个数和实参对应 2、类型对应  3、名字可以不一致
{                    
    int result;     
    result = x + y;

    return result;     //return 返回结果，函数里面一旦遇到return，函数调用立马结束
    //exit(1);         //任何函数里面，遇到exit(), 程序终止。
}                   

int main()
{
    int a = 1, b = 2, result;
    print();
    result = add(a, b);       //实参（实际参数）
    printf("result = %d\n", result);
    printf("%p\n", add);     //函数名就是地址

    return 0;
}

void print()     //没有返回值 没有形参
{
    printf("helloworld\n");
}

一、通过函数名找到函数的入口地址（函数名就是地址）

二、给形参分配空间    三、传值（把实参传给形参）（值传递、地址传递）

四、执行函数体   /五、返回     六、释放空间（释放的是栈空间）

变量：

对于使用频繁的变量，可以使用register声明为寄存器变量，其值存储在CPU中，加快了运行速度。

static修饰全局变量：改变变量的作用域，只能在当前文件被调用，其他文件中不能调用

static修饰函数：改变函数的作用域，只能在当前文件中被调用

extern声明一个外部变量  声明不用分配空间  定义需要分配空间