【C语言】小知识点（函数，浮点数，作用域）

1、函数

返回类型 函数名(参数)
{
    函数体
}

① 没有参数，没有返回值：都使用void

// 函数名为func，没有参数，没有返回值
void func(void)
{
    ...
}

② 没有参数，有返回值：参数使用void，返回类型为返回值的数据类型

// 函数名为func，没有参数，返回int类型的值
int func(void)
{
    ...
    return 返回值(int类型);
}

③ 有参数，没有返回值：返回类型使用void，参数需声明类型

// 函数名为func，两个参数（int类型的m,int类型的n），没有返回值
void func(int m, int n)
{
    ...
}

主函数：main

① 没有参数，返回int类型（默认return 0;）

int main(void)
{
    ...
}

完整规范写法：（编程前期养成良好规范习惯，有利于后期项目开发）

int main(void)
{
    ...
    return 0;
}

② 命令行参数（TERMINAL）

1.  code 文件名.c                      // 打开文件
2.  make 可执行文件名              // 编译并链接成可执行文件(.exe)，WINDOWS系统
3.  ./可执行文件 命令行参数1 命令行参数2          // 执行可执行文件

// func.c
#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("argc's number is %d\n", argc);    // 获取命令行参数个数，包括程序名
    for(int i = 0; i < argc;i++)
    {
        printf("%s\n", argv[i]);              // 输出命令行参数
    }
    return 0;
}

// TERMINAL 输入：
make func
./func hello world         // 命令行参数

// 结果为：
argc's number is 3         // 命令行参数个数argc为3个，包括程序名
M:\Program_C\func.exe      // argv[0]
hello                      // argv[1]
world                      // argv[2]

2、浮点数

整数除以整数，结果是小数全部舍去的整数。即使结果变量声明为浮点数，也是整数转为浮点数（即小数部分全为0）。

#include <stdio.h>

int main(void)
{
    int m = 5;
    float x = m / 3;
    printf("%d / 3 = %.2f\n", m, x);
    return 0;
}

// 结果为：
5 / 3 = 1.00

.方法一：其中一个整数改为浮点数（即 3 改为 3.0 ）

#include <stdio.h>

int main(void)
{
    int m = 5;
    float x = m / 3.0;
    printf("%d / 3 = %.2f\n", m, x);
    return 0;
}

// 结果为：
5 / 3 = 1.67

 方法二：其中一个整数前加上浮点类型（即 3 改为 (float)3 ）

#include <stdio.h>

int main(void)
{
    int m = 5;
    float x = m / (float)3;
    printf("%d / 3 = %.2f\n", m, x);
    return 0;
}

// 结果为：
5 / 3 = 1.67

3、作用域

函数内的变量默认为局部变量，只在函数内有效。函数开始时创建，函数结束时销毁。

#include <stdio.h>

void swap(int a, int b);

int main(void)
{
    int x = 1, y = 2;                    // 局部变量x,y，只在该函数内有效
    printf("x = %d, y = %d\n", x, y);
    swap(x, y);                          // 调用函数,x,y作为参数传入函数
    printf("swapped. x = %d, y = %d\n", x, y);
    return 0;
}

void swap(int a, int b)
{
    int tmp = a;                        // 局部变量tmp,a,b，只在该函数内有效
    a = b;
    b = tmp;
}

// 结果：
x = 1, y = 2
swapped. x = 1, y = 2

方法一：全局变量，在整个该文件中的函数中都可以使用。

#include <stdio.h>

void swap(void);

int x = 1, y = 2;            // 全局变量x,y，在整个该文件的函数中都可以使用

int main(void)
{
    printf("x = %d, y = %d\n", x, y);
    swap();
    printf("swapped. x = %d, y = %d\n", x, y);
    return 0;
}

void swap(void)
{
    int tmp = x;             // 修改全局变量x,y的值
    x = y;
    y = tmp;
}

// 结果：
x = 1, y = 2
swapped. x = 2, y = 1

方法二：指针变量。指向内存地址，修改内存地址中的内容。

&变量：获取变量的内存地址。

基类型 *指针变量名：声明指针变量。用于保存其它变量的内存地址。

*指针变量名：获取指针指向的其它变量的值。

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x = 1, y = 2;          // 局部变量x,y
    printf("x = %d, y = %d\n", x, y);
    swap(&x, &y);              // 将x,y的内存地址作为参数传入函数
    printf("swapped. x = %d, y = %d\n", x, y);
    return 0;
}

void swap(int *a, int *b)
{
    int tmp = *a;            // 局部变量tmp的值为指针变量a指向的内存地址中的值
    *a = *b;                 // 指针变量a指向的内存地址中的值为指针b指向的内存地址中的值
    *b = tmp;                // 指针变量b指向的内存地址中的值为变量tmp的值
}