首页 > 其他分享 >C语言（不完善）

C语言（不完善）

时间：2023-08-08 10:59:58浏览次数：38  
标签：语句 完善 int C语言 ++ printf main 指针

C语言程序设计

分支和循环语句

C语句可分为以下五类：
表达式语句、函数调用语句、控制语句、符合语句、空语句

选择语句

if语句

  • 如果表达式的结果为真，则语句执行。（0为假，非0为真）
  • else的匹配：else是和它离的最近的if匹配的。
语法结构：
if(表达式)
{
    语句;
}

if(表达式)
{
    语句1;
}
else
{
    语句2;
}

//多分支    
if(表达式1)
{   
    语句1;
}
else if(表达式2)
{
    语句2;
}
else
{
    语句3;
}

例：

#include <stdio.h>
//代码1
int main()
{
	int age = 0;
    scanf("%d", &age);
    if(age<18)
    {
        printf("未成年\n");
    }
}
//代码2
#include <stdio.h>
int main()
{
 int age = 0;
    scanf("%d", &age);
    if(age<18)
    {
        printf("未成年\n");
    }
    else
    {
        printf("成年\n");
    }
}
//代码3
#include <stdio.h>
int main()
{
 int age = 0;
    scanf("%d", &age);
    if(age<18)
   {
        printf("少年\n");
   }
    else if(age>=18 && age<30)
   {
        printf("青年\n");
   }
    else if(age>=30 && age<50)
   {
           printf("中年\n");
   }
    else if(age>=50 && age<80)
   {
        printf("老年\n");
   }
    else
   {
        printf("老寿星\n");
   }
    
}

switch语句

  • 用于多分支的情况
  • 当switch（n）中n得出几，则使用case几，如果case之后没有break进行跳出，则执行下一条case
  • break：把语句列表划分为不同的分支部分。
  • default：switch 表达式的值并不匹配所有 case 标签的值， default 子句后面的语句就会执行。（只能出现一条dafault子句；可以放在任意位置）
switch(整型表达式)
{
    case 整形常量表达式:
       语句;
       break; /* 可选的 */
    case 整形常量表达式:
       语句;
       break; /* 可选的 */
  
    /* 您可以有任意数量的 case 语句 */
    
    default : /* 可选的 */
       语句;
}

例：

#include <stdio.h>
int main()
{
    int n = 1;
    int m = 2;
    switch (n)
    {
    case 1:
        m++;
    case 2:
        n++;
    case 3:
        switch (n)
        { // switch允许嵌套使用
        case 1:
            n++;
        case 2:
            m++;
            n++;
            break;
        }
    case 4:
        m++;
        break;
    default:
        break;
    }
    printf("m = %d, n = %d\n", m, n);
    return 0;
}

循环执行语句

while语句

  • C语言的switch中case只支持单个值，不支持范围【例如：case 1...10:】
  • break：跳出（终止）循环
  • continue：跳过本次循环
while(表达式){
	循环语句;
}

示例：

#include <stdio.h>
int main()
{
    char ch = '\0';
 while ((ch = getchar()) != EOF)
 {
     if (ch < ‘0’ || ch > ‘9’)
        continue;
     putchar(ch);
 }
 return 0;
}
//这个代码的作用是：只打印数字字符，跳过其他字符的、

for语句

  • 建议for语句的循环控制变量的取值采用“前闭后开区间”写法。
for(表达式1; 表达式2; 表达式3){
	循环语句;
}
/*
表达式1
表达式1为初始化部分，用于初始化循环变量的。
表达式2
表达式2为条件判断部分，用于判断循环时候终止。
表达式3
表达式3为调整部分，用于循环条件的调整。
*/

示例：

#include <stdio.h>
int main()
{
 	int i = 0;
 //for(i=1/*初始化*/; i<=10/*判断部分*/; i++/*调整部分*/)
 for(i=1; i<10; i++)//”前闭后开“写法
 {
	 printf("%d ", i);
 }
 	return 0;
}

do ... w hile

do
{
 	循环语句;
}while(表达式);

练习：

1. 计算 n的阶乘。
2. 计算 1!+2!+3!+……+10!
3. 在一个有序数组中查找具体的某个数字n。（讲解二分查找）
4. 编写代码，演示多个字符从两端移动，向中间汇聚。
5. 编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码正确则
提示登录成，如果三次均输入错误，则退出程序。
image-20230719160443452

image-20230719160540457image-20230719160555781image-20230719160606380

goto

  • 终止程序在某些深度嵌套的结构的处理过
    程（例如：一次跳出两层或多层循环）。

示例：

for(...)
    for(...)
   {
        for(...)
       {
            if(disaster)
                goto error;
       }
   }
    …
error:
 if(disaster)
         // 处理错误情况
  • continue
  • return

函数

  • 函数就是：子程序。
  • 是一个大型程序中的某部分代码， 由一个或多个语句块组 成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。
  • 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软 件库。

库函数

自定义函数

返回类型 函数名(函数参数,函数参数)
{
	语句项；
}

示例：交换两个整型变量的内容

//正确的版本
void Swap2(int* px, int* py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}
int main()
{
    int num1 = 1;
    int num2 = 2;
    //Swap1(num1, num2);
    //printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
    Swap2(&num1, &num2);
    printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
    return 0;
}

数组

定义数组

int arr[10]={1,2,3,4,5,6,7,8,9,10};//定义一个10个元素的整形数组

数组的访问及下标

  • 下标：从0开始

![屏幕截图 2023-07-18 155754](D:\markdown笔记\考研\考研笔记\专业课\C语言.assets\屏幕截图 2023-07-18 155754.png)

  • 访问数组元素
arr[0]=50;//将50赋值给下标为0的数组元素

数组的使用

#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	for(i=0; i<10; i++)
{
    printf("%d ", arr[i]);
}
	printf("\n");
    return 0;
}

操作符详解

算术操作符

+ //加
- //减
* //乘
/ //除
% //取模（取整）

移位操作符

<<
>>

位操作符

&
|
^【强调差异性】【存在交换律和结合律】【a^a=0;0^a=a】
    例：用异或来交换两个变量的值？
    int a=3,b=5;
	a=a^b;	//差异的部分赋值到a里面
	b=b^a;	//用b 和 差异的部分->a并赋值给b
	a=a^b;	//用原a的值(也就是现在的b变量) 和 差异的部分-> b赋值给a

赋值操作符

a=50 //“左值=右值”讲50赋值给a
+=
-+
*=
/=
&=
^=
|=
>>=
<<=

单目操作符

!           //逻辑反操作
-           //负值
+           //正值
&           //取地址
sizeof      //操作数的类型长度（以字节为单位）
~           //对一个数的二进制按位取反
--          //前置、后置--
++          //前置、后置++
*           //间接访问操作符(解引用操作符)
(typedef)       //强制类型转换

单目运算符：一个操作数
双目运算符：两个操作数
三目运算符（也称三元运算符）：表达式1? 表达式2:表达式3

关系操作符

>
>=
<
<=
!=   	//用于测试“不相等”
==      //用于测试“相等”

逻辑操作符

&&     		//逻辑与
||          //逻辑或
“ && ”的短路特性：左边为假，右边不算
“ || ”的短路特性：左边为真，右边不算
    
#include <stdio.h>
int main()
{
    int i = 0,a=1,b=2,c =3,d=4;
    //i = a++ && ++b && d++;
    i = a++ || ++b || d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

条件操作符

exp1 ? exp2 : exp3

逗号表达式

先执行逗号前再执行逗号后；整个表达式的结果为最后一个表达式的值。

example1, example2, example3, …exampleN

下标引用、函数调用和结构成员

[] () . ->

指针

  • 地址：计算机程序在内存中运行，内存划分为一个个单元，每个内存单元都有编号，称为地址（0x开头的）。一个内存单元大小为1个字节
  • 指针是内存中一个最小单元的编号，也就是地址
  • 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

image-20230718205707571

取地址符和取值符

取地址符（&）【通过变量访问地址】

&num; //取出的为num占内存中四个字节的第一个字节的地址

image-20230718210015222

解引用（间接）符（*）【通过地址访问变量】

*p；//取出指针变量p内所存地址对应的值
/*
“*”的作用是引用指针指向的变量值，引用就是取地址(&)。
	“解"就是把该地址对应的东西解开，解出来，就像打开一个包裹一样，那就是该变量的值了，所以称为"解引用”。
    也就是说，解引用是返回内存地址中保存的值。
*/

指针类型

  • 指针类型决定了指针在被解引用的时候有多大权限（能操作几个字节）。
int * pa=&a;
/*
例: 
	如果是char*的指针，解引用访问1个字节
    如果是int*的指针，解引用访问4个字节
    如果是double*的指针，解引用访问8个字节
推广到其他类型*/

定义指针变量

  • 指针是一种复合类型，比如int* 是指向int的指针，对每个指针变量名，都需要使用一个 *
int num = 10;//type * pa= &variable //定义一个type类型的指针指向一个名为variable的变量。
int *p;  //p为一个整形指针变量
p = &num;

野指针

  • 指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因

  • 声明指针变量但未初始化
#include <stdio.h>
int main()
{
 int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
 return 0;
}
  • 指针越界访问
#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
   }
    return 0;
}
  • 指针指向的空间释放（为了避免使其置于NULL）
#include <stdio.h>
int main()
{
    int *p = NULL;
    //....
    int a = 10;
    p = &a;
    if(p != NULL)
   {
        *p = 20;
   }
    return 0;
}

指针运算

指针变量加减整数

  • 指针的类型决定了指针向前或者向后走一步有多大（距离）

例一：

#include <stdio.h>
int main()
{
 int n = 10;
 char *pc = (char*)&n;
 int *pi = &n;

 printf("%p\n", &n);
 printf("%p\n", pc);
 printf("%p\n", pc+1);
 printf("%p\n", pi);
 printf("%p\n", pi+1);
 return  0;
}
//结果：
000000900257F6C4		&n
000000900257F6C4		pc
000000900257F6C5		pc+1	pc地址加了一个字节的大小
000000900257F6C4		pi
000000900257F6C8		pi+1	pi地址加了一个字节的大小

例二：

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}

//两种形式：
//第一种形式：vp指向的地址自增1个字节
*vp++=0；	vp++为先使用vp，再vp自增
解析：
*vp=0；		第一步，对vp解引用，并把0赋值给指针变量vp指向地址的参数。
vp++；		第二步，指针变量vp指向的地址自增1一个字节
//第二种形式：vp指向地址所在的值自增1个数值
(*vp)++		
解析：
*vp			第一步，取出指针变量vp指向地址的值
(*vp)++		第二步，这个值自增一个数值

指针数组

int* arr[5];

指针变量的大小

  • 指针大小在32位平台是4个字节，64位平台是8个字节。
#include <stdio.h>
/*
指针变量的大小取决于地址的大小
32位平台下地址是32个bit位（即4个字节）
64位平台下地址是64个bit位（即8个字节）
一个字节=8bit
*/
int main()
{
    printf("%d\n", sizeof(char *));
    printf("%d\n", sizeof(short *));
    printf("%d\n", sizeof(int *));
    printf("%d\n", sizeof(double *));
    return 0;
}

结构体

  • 目的：描述复杂类型（如描述学生包含：名字+年龄+性别+学号这几项信息。）
  • struct、结构体标签、变量列表。结构体标签和变量列表至少要有一个。
struct Stu//stu为结构体类型名，可替换
{
    char name[20];//名字
    int age;      //年龄
    char sex[5];  //性别
    char id[15]； //学号
}s1,s2,s3;//变量列表（在main外创建则为全局变量）

结构体初始化

/*
为了减少开销：结构体传参的时候，要传结构体的地址。
    函数传参的时候，参数是需要压栈的。
    如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
*/
#include<stdio.h>
struct book
{
    //结构体的成员（变量）
    char name[20];
    char id[20];
    int price;
}s1,s2;

int main(){
    struct book philosophy={"C语言","C12682378",20};
    //结构体变量名.成员名
    printf("书名：%s\n",philosophy.name);
    printf("书号：%s\n",philosophy.id);
    printf("定价：%d\n",philosophy.price);
    return 0;
}

-----------------------

宏定义和定义常量

#define MAX 1000 //define定义标识符常量

#define AA sturct aa//通过#define这个指令将“struct aa”这个结果体类型命名为AA；以后直接在代码中使用AA代替struct aa

#define ADD(x, y) ((x)+(y)) //define定义宏

#include <stdio.h>
int main()
{
    int sum = ADD(2, 3);
    printf("sum = %d\n", sum);
    
    sum = 10*ADD(2, 3);
    printf("sum = %d\n", sum);
    
    return 0;
}
/*
结果：
sum = 5
sum = 50 */

细节：

进制

介绍

  • 二进制 B (binary)

【0、1】组成（逢二进一）

  • 八进制 O (octal)

【0-7】组成（逢八进一）
【0开头】

  • 十进制 D (decimal)

【0-9】组成（逢十进一）
【1-9开头】

  • 十六进制 H (hexadecimal)

【0-9、A-F】组成（逢十六进一）（A-F表示10-15）
【0X开头】

1 十六进制数字=4 *二进制位
1 byte=2 *十六进制数字

进制转换方法

2、8、16进制->10进制
  • 2进制->10进制

aHR0cHM6Ly9zMS5heDF4LmNvbS8yMDIwLzA1LzMxL3QxdHQ3bi5wbmc

  • 8进制->10进制

2

  • 16进制->10进制

3

10进制->2、8、16进制
  • 10进制->2进制

4

  • 10进制->8进制

5

  • 10进制->16进制

6

2进制->8、16进制；8进制->16进制
  • 2进制(100010)->8进制

方法：将每3个二进制数分为一组（从左至右），不够时补0

7

  • 2进制(100111010)->16进制

方法：将每4个二进制数分为一组（从左至右），不够时补0

8

  • 8进制(1325)->16进制

方法：
八进制数无法直接转换为十六进制，
需2进制->10进制->16进制。
答案：2D5

特殊情况：小数点的处理

例：十进制（23.76）如何转换？

9

进制转换快速查表

​ 不同数制之间的对应及转换关系

10

编辑器、编译器、链接器

150244824

编辑器：敲代码
编译器：编译源代码文件为01机器语言（二进制）
链接器：链接库文件（二进制）并生成可执行文件

变量名

  • 变量名只能是英文字母(A-Z,a-Z)和数字(0-9)或者下划线()组成。
  • 第一个字母必须是字母或者下划线开头。
  • 变量名区分大小写。
  • 不能使用关键字命名

数据类型

类型 存储大小 值范围
char 1 字节 -128 到 127 或 0 到 255
unsigned char 1 字节 0 到 255
signed char 1 字节 -128 到 127
int 2 或 4 字节 -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647
unsigned int 2 或 4 字节 0 到 65,535 或 0 到 4,294,967,295
short 2 字节 -32,768 到 32,767
unsigned short 2 字节 0 到 65,535
long 4 字节 -2,147,483,648 到 2,147,483,647
unsigned long 4 字节 0 到 4,294,967,295 
int a;
char b;
float c;
double d;
a=520;
b=F';
c=3.14;
d=3.141592653;
printf("鱼C工作室创办于2010年的%d\n",a):
rintf("I Love %cishC.com!\n",b);
printf("圆周率是：%.2f\n",c);
//%.2f表示小数点之后有两位
printf("精确到小数点后9位的圆周率是：%11.9f\n",d);
//%11.9f表示小数点之后有9位，双精度浮点型变量一共有11位

&6d：整数输出，宽度是6位，不足左边补空格
%06d：整数输出，宽度是6位，不足左边补数字0
%-6d：整数输出，宽度是6位，不足右边补空格
    
printf("%03s,%7.2s,%.4s,%-5.3s\n","CHINA","CHINA","CHINA","CHINA"); 
%3s,       格式输出字符串，右对齐，超出3个长度的，就全部输出;不够三位数，左补0；
%7.2s,     输出字符串占7个位置，右对齐，左补空格，输出2个字符；
%.4s,      仅输出4个字符，占位4个位置，右对齐；
%-5.3s:    输出3个字符，占位5个位置，左对齐右补空格。

常量：是不变的（比如：圆周率，性别，身份证号码，血型等等）

  • 字面常量
  • const修饰的常变量

  • define定义的标识符常量

  • 枚举常量
#include <stdio.h>

enum Sex
{
 MALE,
 FEMALE,
 SECRET
};
//括号中的MALE,FEMALE,SECRET是枚举常量

int main()
{
    3.14;//字面常量
    1000;//字面常量
    
    //const 修饰的常变量
    const float pai = 3.14f;   //这里的pai是const修饰的常变量
    pai = 5.14;//是不能直接修改的！
    
#define MAX 100//#define的标识符常量
    printf("max = %d\n", MAX);
    
    //枚举常量
    printf("%d\n", MALE);
    printf("%d\n", FEMALE);
    printf("%d\n", SECRET);
    //结果：
    	0
    	1 
    	2
    //注：枚举常量的默认是从0开始，依次向下递增1的
	
    return 0;
}

局部变量和全局变量：可变的（比如：年龄，体重，薪资）。

  • 局部变量：{}内部定义的变量

    ​ 作用域：变量所在的局部范围；

    ​ 生命周期：进入作用域生命周期开始，出作用域生命 周期结束。

  • 全局变量：{}外部定义的变量

    ​ 作用域：整个工程

    ​ 生命周期：整个程序的生命周期

#include<stdio.h>
int b=20;//全局变量

int main(){
	//short age=20;//年龄
	//int high=180;//身高
	//f1oat weight=88.5;/体重
	int a=10;//局部变量
	return 0;
}

当全局变量和局部变量冲突（变量名相同）时：优先局部

#include<stdio.h>
int a=100;

int main(){
	printf("a=%d\n",a);//当全局变量和局部变量名字相同的情况下，局部优先
	return 0;
}

形参和实参

int add(x,y){//此处x和y为形参
    return x+y;
}
int main(){
    int a=1；
    int b=2;
    int c=3;
    int n=add(a,(b+c);//此处a和表达式(b+c)为实参
    return 0;
}

声明全局变量和函数

  • 当前extern链接其他源文件的全局变量：

image-20230718170922671

  • 当前extern链接其他源文件的函数：

image-20230718173636889

字符

用单引号括起来

'a'	//字符常量a

字符串

默认以转义字符"\0"为结束标志【"\0"不为字符串内容】

"hello world\n"

转义字符

转义字符 释义
? 表示问号，防止他们被解析成三字母词
\0 表示NULL
\' 用于单引号'
\'' 表示双引号（"）
\\ 用于表示一个反斜杠，防止它被解释为一个转义序列符
\a 响铃（BEL）
\b 退格（BS），将当前位置移到前一列
\f 换页（FF），将当前位置移到下页开头
\n 换行（LF），将当前位置移到本行开头
\r 回车（CR），将当前位置移到本行开头
\t 水平制表符（T）
\v 垂直制表符（VT）
\ddd ddd表示1~3个八进制（0-7）的数字（计算时转换为十进制按照ASCII表输出）如： \130表示X
\xdd dd表示2个十六进制数字（计算时转换为十进制，按照ASCII表输出） 如： \x30表示0

注意：

  • 三字母词：为了在一些特定的字符集中，比如一些七位代码集中，解决一些特定字符的输入问题。【如：??= --> ]、??( --> [】

注释：

  • C语言风格的注释

/*xx
xxx
x*/

缺陷：不能嵌套注释。*/与/*为一个注释

/*da
nw/*id
n*/io*/

  • C++风格的注释

//admwodnow大王大王的daw

优点：可以注释一行或多行

自增运算符a++与++a

  • a++：先使用，再自增
  • ++a：先自增，再使用
#include <stdio.h>
#include <string.h>

int main()
{
    int a=0,b=0;
    b=a++;
    printf("%d\n", b);
    return 0;
}
//结果：0

#include <stdio.h>

int main()
{
    int a=0,b=0;
    b=++a;
    printf("%d\n", b);
    return 0;
}
//结果：1

.和->

运算符 名称或含义 使用形式

. 成员选择（对象） 对象.成员名 --

-> 成员选择（指针） 对象指针->成员名

电脑上的存储设备

  • 硬盘-->内存-->高速缓存（cache）-->寄存器（集成在cpu）
  • 造价越来越高，空间越来越小

变量分配空间：堆区，栈区，静态区

堆区，栈区，静态区

image-20230718170049466

代码块

一对 { } 就是一个代码块。

NULL（0）

null就是0

EOF（-1）

ASCII代码值的范围是0~255，不可能出现-1，因此可以用EOF作为文件结束标志。

标准输入、标准输出

键盘输入、屏幕输出

输入缓冲区

image-20230719104045804

清理缓冲区：fflush(stdin) 清空缓存区

常见关键字

auto  break   case  char  const   continue  default  do   double else  enum  
extern float  for   goto  if   int   long  register    return   short  signed
sizeof   static struct  switch  typedef union  unsigned   void  volatile  while

void

声明函数无返回值或无参数，声明无类型指针，显式丢弃运算结果

char

字符型类型数据，属于整型数据的一种

int

整型数据，通常为编译器指定的机器字长

float

单精度浮点型数据，属于浮点数据的一种

double

双精度浮点型数据，属于浮点数据的一

short

修饰int，短整型数据，可省略被修饰的int。

long

修饰int，长整形数据，可省略被修饰的int。

signed

修饰整型数据，有符号数据类型

unsigned

修饰整型数据，无符号数据类型

struct

结构体声明

union

共用体声明

enum

枚举声明

typedef

顾名思义是类型定义，也就是类型重命名。

typedef unsigned int uint_32;//将unsigned int 重命名为uint_32, 所以uint_32也是一个类型名
int main()
{
    //观察num1和num2,这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    return 0;
}

sizeof

得到特定类型（int、float、struct）或特定类型变量（自己定义的变量：a、b、c）的大小

auto

指定为自动变量，由编译器自动分配及释放。通常在栈上分配

static

用来修饰变量和函数。

  1. 修饰局部变量-称为静态局部变量
  2. 修饰全局变量-称为静态全局变量
  3. 修饰函数-称为静态函数

修饰局部变量

  • static修饰局部变量使其出了作用域不销毁
  • static修饰局部变量改变了变量的生命周期，变成和程序的生命周期一样

原代码：

#include <stdio.h>
void test()
{
    int i = 0;
    i++;
    printf("%d ", i);
}
int main()
{
 int i = 0;
    for(i=0; i<10; i++)
   {
        test();
   }
    return 0;
}
//结果：1 1 1 1 1 1 1 1 1 1

static修饰后：

#include <stdio.h>
void test()
{
    static int i = 0;// static修饰局部变量
    i++;
    printf("%d ", i);
}
int main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        test();
    }
    return 0;
}
//结果：1 2 3 4 5 6 7 8 9 10

修饰全局变量

  • static修饰全局变量，使得全局变量的外部链接属性变为内部链接属性。---生命周期变小
  • 外部链接属性：可被其他源文件(.c)声明（如：extern int g_val;）后使用。
  • 内部链接属性：其他源文件(.c)不能再使用到这个全局变量。

只声明不修饰：image-20230718170922671

static修饰后：

image-20230718172843287

修饰函数

  • static修饰函数，使得函数的外部链接属性变为内部链接属性。---生命周期变小
  • 外部链接属性：可被其他源文件(.c)声明（如：extern int g_val;）后使用。
  • 内部链接属性：其他源文件(.c)不能再使用到这个全局变量。

只声明，不修饰【√】：

image-20230718173636889

static修饰后：

image-20230718173834413

register

  • 修饰变量，表示建议将变量优先放到寄存器中（实际由编译器决定）
int main(){
	//寄存器变量
	register int num=3;//建议：3存放在寄存中
	return 0;
}

extern

指定对应变量为外部变量，即在另外的目标文件中定义，可以认为是约定由另外文件声明的对象的一个“引用“

const

与volatile合称“cv特性”，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变）

volatile

与const合称“cv特性”，指定变量的值有可能会被系统或其他进程/线程改变，强制编译器每次从内存中取得该变量的值

return

用在函数体中，返回特定值（或者是void值，即不返回值）

continue

结束当前循环，开始下一轮循环

break

跳出当前循环或switch结构

goto

无条件跳转语句

if

条件语句

else

条件语句否定分支（与if连用）

switch

开关语句（多重分支语句）

case

开关语句中的分支标记

default

开关语句中的“其他”分治，可选。

for

循环结构，for(1;2;3)4;的执行顺序为1->2->4->3->2...循环，其中2为循环条件

do

循环结构，do 1 while(2);的执行顺序是1->2->1...循环，2为循环条件

while

循环结构，while(1) 2;的执行顺序是1->2->1...循环，1为循环条件

库函数

<assert.h>

<ctype.h>

<errno.h≥

<float.h>

<limits.h≥

<locale.h>

<math.h>≥

<setjmp.h>

<signal.h>

<stdarg.h>

<stddef.h>

<stdio.h>

printf()

  • 格式化【f=format】输出函数
int ch=123;
printf("%d",ch);

scanf()

  • 读取字符串
  • 读取数字时会跳过空格、制表符和换行符。（回车符会残留在缓冲区）
char a,b,c;
printf("请输入三个字符：");
scanf("%c%c%c",&a,&b,&c);

getchar()

  • 读取一个无符号字符
  • 只能输入字符型,输入时遇到回车键才从缓冲区依次提取字符。
  • 返回值为用户输入的ASCⅡ码，出错返回-1（如何出错：ctrl+z）

<stdlib.h>

<string.h>

strlen()

计算字符串 str 的长度，直到空结束字符，包括转义字符（\0），但不包括空结束字符。

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

int main ()
{
   char str[50];
   int len;

   strcpy(str, "This is runoob.com");

   len = strlen(str);
   printf("|%s| 的长度是 |%d|\n", str, len);
   
   return(0);
}
结果：
    |This is runoob.com| 的长度是 |18|

<time.h>

ASCII码表（十进制数字 对应 字符）

20170603162228653

例子：

  • 定义：常量、宏、局部变量、全局变量、重命名变量名、枚举类型
#include <stdio.h>
#include <string.h>
#include <malloc.h>

#define x 5
#define add(x,y) (x+y)	//define定义宏，宏是有参数的，可被替换

typedef unsigned int u_int;

int z = 7;

enum SEX
{
	male,
	female,
	secret
};

int main()
{
	int y = 3;
	u_int d=4;
	enum SEX s = female;

	printf("%d", s); //枚举常量
	printf("%d", x); //自定义标识符
	printf("%d", z); //全局变量
	printf("%d", y); //局部变量
	printf("%d", d); //类型重命名

	return 0;
}

笔记本

输入5个字符串，从中找出最大的字符串并输出。
要求：
用二位字符数组存放着5个字符串
用指针数组元素分别指向这5个字符串
用一个二级指针变量指向这个指针数组

image-20230720144808310

判断100以内的素数

int main() {
	for (int a = 2; a < 100;a++) {
		bool isprime = true;
		for (int i = 2; i < a; i++) {
			if (a % i == 0) {
				isprime = false;//如果能被a整除，就是false
				break;
			}
		}
		if (isprime) {
			printf("%d\n", a);
		}
	}
    return 0;
}

判断是否为闰年

int main() {
	int year;
	while (1) {
		scanf_s("%d", &year);
		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
			printf("%d为闰年\n", year);
		}
		else {
			printf("%d不为闰年\n", year);
		}
	}
    return 0;
}

1000以内的闰年

int main() {
	for (int year = 1; year < 1000; year++) {

		
			if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
				printf("%d为闰年\n", year);
			}
			else {
				printf("%d不为闰年\n", year);
			}

	}
	return 0;
}

有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

int main() {
	int count = 0;//计数器
	for (int i = 1; i <= 4;i++) {
		for (int j = 1; j <= 4; j++) {
			for (int k = 1; k <= 4; k++) {
				if (i != j && i != k && j != k) {
					printf("%d\n", i * 100 + j * 10 + k);
					count++;
				}
			}
		}
	}
	printf("%d", count);
	return 0;
}

标签：语句,完善,int,C语言,++,printf,main,指针
From： https://www.cnblogs.com/wj-ive/p/17613569.html

相关文章

  • 2308-初识C语言part2-指针+结构体
    1.指针内存如何编号？答：32位——32跟物理线，有32个长度的二进制序列，共2^32个内存单元，一个内存单元为一字节，2^32byte=4GBintnum为4个字节，故占四个内存，标记为4个中最小的编号（0x0012ff44）指针就是地址 指针的大小是相同的，32位是4，64位是8，不管是char*，int*，long*，float， 1#i......
  • 我的第十二次C语言练习
    //intmain(void)//{// printf("%zd\n",sizeof(int));//4// printf("%zd\n",sizeof(char));//1// printf("%zd\n",sizeof(float));//4// printf("%zd\n",sizeof(double));//8// printf("%zd\n",sizeof(sho......
  • 【C语言】递归和迭代（斐波那契数列问题）
    1.递归算法一般用于解决三类问题：问题解的定义是按递归定义的（如阶乘）。问题解法由回溯算法实现（如数字排列组合问题）。数据的结构形式是按递归定义的（树的遍历，图的搜索、嵌套列表）。2.什么是递归呢？......
  • c语言作业之三个数比大小，从大到小
    #include<stdio.h>intmain()//三个数比大小，从大到小{ inta=0; intb=0; intc=0; scanf("%d%d%d",&a,&b,&c);//输入数字时，两两要有空格为间隙 if(a<b) { inttem=a; a=b; b=tem; } if(a<c) { inttem=a; a=c;......
  • vc++2008通过paho c语言客户端接入MQTT
    因项目需要，IoT平台需要支持vc++2008接入。因为Paho的c++客户端不支持低版本vc++，所以不得不尝试通过c语言的库实现。类库下载从github下载c语言包。例如：eclipse-paho-mqtt-c-win32-1.3.12.ziphttps://github.com/eclipse/paho.mqtt.c/releases类库整合和配置解压出来的c语言......
  • C语言三子棋
    话说自从大一学C语言后用C语言的巅峰也就是第十二届蓝桥杯了，后续开发什么的都是用的java，搞开发java这样的面向对象语言确实用着更顺手方便点。不过C语言YYDS，“C生万物”嘛，哈哈。本文Author：愷龍现在准备考研了，需要考查很多C语言的东西，又开始了重温C语言和复习，在复习了一遍语法后......
  • [系统设计] 计算机系统设计思想：缓存/局部性原理(转载)【待完善】
    1缓存概述缓存思想是计算机系统设计中极为重要的解决手段，其本质原则是————局部性原理在资源有限的情况下，将热点资源、最重要的资源部署到离请求方最近的地方去，以达到性能预期。1.1什么是缓存，为什么要用缓存？缓存就是数据交换的缓冲区（称作Cache），是存贮数据（使用频繁的数据......
  • C语言打卡练习Day4
    1.在一个有序数组中查找具体的某个数字。并将其下标打印出来intmain(){inti=0;intk=5；//要查找的数字intarr[]={1,2,3,4,5,6,7,8,9,10};intnum=sizeof(arr)/sizeof(arr[1]);for(i=0;i<num;i++){if(k==arr[i]){......
  • C语言定义并初始化一个二维数组（利用二级指针）
    C语言定义并初始化一个二维数组（利用二级指针）1.代码如下#include<stdio.h>#include<stdlib.h>intmain(){//m,n表示数组的行数和列数intm,n;scanf("%d%d",&m,&n);//p是一个二级指针，使用malloc函数初始化。注意p指向的是一个指针，所以sizeof操作......
  • c语言作业之猜数字游戏
    //猜数字游戏#include<time.h>#include<stdlib.h>//void表示“无类型”，相应的void*为无类型指针，即1.对函数返回的限定；2.对函数参数的限定//当函数不需要返回值时，必须用void限定例如：voidfunc（inta,char*b）//当函数不允许接受参数时，必须使用void限定例如：intfunc（void）......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99