C语言（符号，量，输入输出，垃圾字符回收，语句结构）

如果对你有帮助，请点个免费的赞吧，谢谢汪。（点个关注也可以！）

如果以下内容需要补充和修改，请大家在评论区交流~

1.符号

1.1分隔符

print输出时的分隔符号的使用：

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int a = 5,b = 5;
    printf("%d%d\n",a,b);
    return 0;
}
//输出55

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int a = 5,b = 5;
    printf("%d %d\n",a,b);
    return 0;
}//输出5 5

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int a = 5,b = 5;
    printf("%d%d\n",a,b);//输出55
    printf("%d %d\n",a,b);//输出5 5
    printf("%d\t%d\n",a,b);//tap，输出5		5
    printf("%d\n%d\n",a,b);
    return 0;
}

1.2 转义字符

/101 == A八进制

/字符后面默认是八进制

2.变量

程序运行过程中可以发生变化的量

格式定义：

存储类型 数据类型 变量名

auto

存储类型代表变量存储在什么类型的空间中，局部变量默认存在栈区，所以可以不写auto

数据类型决定变量实际开辟的空间大小。

变量名：遵循标识符命名规则。

2.1 数据类型

	名称	所开辟字节大小	描述
char	字符
int	整
数据类型	描述
short	短整型，通常占用2字节（16位），表示范围大约是 -32,768 到 32,767。
long	长整型，通常占用4字节（32位）在某些语言中（如C、C++），表示范围大约是 -2,147,483,648 到 2,147,483,647；在其他语言中（如Java、Python），长整型可能占用8字节（64位），范围约为 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。
float	单精度浮点型，通常占用4字节（32位），可以存储大约6-7位有效数字，范围大约是 1.4e-45 到 3.4e+38。
double	双精度浮点型，通常占用8字节（64位），可以存储大约15-16位有效数字，范围大约是 4.9e-324 到 1.8e+308。在大多数语言中，double类型提供了比float更高的精度和更大的数值范围。

2.2 sizeof

sizeof 是一个在C和C++等编程语言中使用的运算符，它用于计算特定数据类型或变量在编译时占用的内存字节数。这个运算符非常重要，因为它帮助程序员了解数据结构的大小，从而优化存储和处理数据的方式。sizeof 不会实际执行计算，而是在编译阶段由编译器确定大小，这意味着它可以被用在表达式中而不用担心运行时的性能开销。
使用 sizeof 的基本语法如下：

• 对于数据类型：sizeof(data_type)
• 对于变量：sizeof(variable_name)
  例如：

int a;
printf("Size of int is %zu bytes\n", sizeof(int));
printf("Size of variable 'a' is %zu bytes\n", sizeof(a));

在这个例子中，第一行声明了一个整型变量 a。接下来的两行使用 sizeof 运算符分别打印出 int 类型所占的字节数以及变量 a 所占的字节数。注意，在C99标准之后，推荐使用 %zu 作为 size_t 类型的格式化字符串，以确保正确地打印出结果。
值得注意的是，sizeof 运算符不改变操作数的值，也不需要操作数必须是可计算的表达式，这意味着你可以对表达式使用 sizeof，如 sizeof(2 + 2)，但请注意这并不会执行加法操作，而是计算表达式类型（在这种情况下通常是 int）的大小。
此外，当应用于数组时，sizeof 返回整个数组占用的总字节数，而不是单个元素的大小。例如，对于一个整型数组 int arr[10];，sizeof(arr) 将返回整个数组占用的字节数，即 10 * sizeof(int)。
总之，sizeof 是一个强大的工具，它使开发者能够理解并管理程序中的内存使用，这对于编写高效、健壮的代码至关重要。

2.3局部变量和全局变量的区别

	局部变量	全局变量
定义位置	函数体内部	函数体外部
未初始化	值随机	0
生命周期	随着所在的函数体共存亡	函数结束后出栈
作用域（作用范围）	函数体内	整个程序
存储位置	默认栈	全局区

3 常量

程序运行过程中不会变化的量，赋值运算符右边的部分

3.2 标识常量

宏定义

#define 宏名 常量值 表达式 函数

格式： 宏定义

#define 宏名 常量值或表达式或函数

宏名：一般用大写，为了和普通变量区分开

特点：先进行单纯的替换，最后再执行。

#include<stdio.h>

#define A 4//宏定义
#define M A + 2
#define NUM A + M/2 +1//宏定义中是单纯的替换:==4+4+2/2+1
#define MAX a>b?a:b//定义表达式
#define MAX2(a,b) a>b?a:b//宏定义函数


int main(int argc, char const *argv[])
{
    int a = A + 1;
    int b = 3;
    printf("%d\n",a);
    printf("%d\n",NUM);
    printf("%d\n",MAX);
    printf("%d\n",MAX2(a,b));
    return 0;
}

4.输入输出

4.1按格式输入输出

printf

int printf(const char *format, ...);

printf:函数名(参数)int:函数的返回值

功能：按格式在终端输出

参数：多参

返回值：输出字符个数

格式：

%d int

%c char

%f float

%lf double

%s 字符串

%p 地址

%o %#o 八进制

%x%#x 十六进制

/4.5f : 4表示位宽（域长），.后面表示精度

scanf

输入函数

int scanf(const char *format, ...);

功能：按格式向终端输入

参数：多参

返回值：正确输入字符个数

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int a = 0,b = 0;
    char c = 0;
    scanf("%d %d %c",&a,&b,&c);
    getchar();
    printf("%d,%d,%c\n",a,b,c);
    return 0;
}

4.2 按照字符输入输出

getchar

int getchar(void);

功能：终端输入一个字符

参数：无

返回值：输入的字符的ASCII码值

putchar

int putchar(int c);

功能：终端输出一个字符

参数：字符的ASCII码值

返回值：字符的ASCII码值

#include<stdio.h>
int main(int argc, char const *argv[])
{
//    getchar();
    putchar(65);
    putchar(10);
    char res = getchar();//输入多个,识别第一个
    putchar(res);//只适用于单个字符输入输出,ascii码值为中间衔接
    putchar(10);//换行
    getchar();//终端输入字符,同时回收一个或者多个空格,验证2是不是字符
    printf("%d",getchar());//回收字符
    putchar(10);
    return 0;
}

scanf("%d %d%*c%c",&a,&b,&c);//%*c可以回收任何一个字符

#include<stdio.h>
int main(int argc, char const *argv[])
{
//    getchar();
    putchar(65);
    putchar(10);
    char res = getchar();//输入多个,识别第一个
    putchar(res);//只适用于单个字符输入输出,ascii码值为中间衔接
    putchar(10);//换行
    getchar();//终端输入字符,同时回收一个或者多个空格,验证2是不是字符
    printf("%d",getchar());//回收字符
    putchar(10);
    //或者
    getchar();
    int res2 = getchar();//直接赋值回收的上一个字符
    printf("%d\n",res2);
    return 0;
}

5.垃圾字符回收

1. 通过空格回收一个或多个空格、tab

char a=0,b=0;

scanf("%c%c",&a,&b);

printf("a:%c b:%d\n",a,b);

2. 通过%*c*抑制符(了解)

回收任意一个字符

char a=0,b=0;

scanf("%c%*c%c",&a,&b);

printf("a:%c b:%d\n",a,b);

3. 通过getchar回收scanf的换行

while(1)

{

char a=0;

scanf("%c",&a);

getchar();

printf("%c\n",a);

}

==============================

char a=0;

scanf("%c",&a);

getchar();

printf("%c\n",a);

char b=0;

scanf("%c",&b);

printf("%c\n",b);

6.分支结构

6.1 if else

基本结构

if(表达式)
{
	语句块1；
}
else
{
	语句块2；
}
===================
if(2>3)
    {
        printf("fangxue\n");
    }
    else
    {
        printf("study\n");
    }

分层结构

if(表达式1)
{
	语句块1；
}
else if(表达式2)
{
	语句块2；
}
else
{
	语句块3；
}

#include<stdio.h>
int main(int argc, char const *argv[])
{   
    int s=0;
    scanf("%d",&s);
    if(s>=90&&s<=100)
    {
        putchar('A');
    }
    else if(s>=80&&s<=89)
    {
        putchar('B');
    }
    else if(s>=70&&s<=79)
    {
        putchar('C');
    }
    else
    {
        printf("bukao");
    }
    putchar(10);
    return 0;
}

嵌套结构

if(表达式1)		s>=0&&s<=100
{
	// ABC
}
else
{
	语句块； ERROR
}

6.2 switch