Always keep a beginne|
收藏闪存小组博问

Yasuo_Hasaki

园龄：1年1个月粉丝：2关注：0

2024-02-16-物联网C语言(1-数据类型与语句)

合集 - 物联网(25)
1.2024-02-16-物联网C语言(1-数据类型与语句)
2.2024-02-17-物联网C语言(2-数组)3.2024-02-17-物联网C语言(3-函数)4.2024-02-17-物联网C语言(4-预处理)5.2024-02-17-物联网C语言(5-指针)6.2024-02-18-物联网C语言(6-动态内存申请)7.2024-02-18-物联网C语言(7-字符串处理函数)8.2024-02-18-物联网C语言(8-结构体、共用体、枚举)9.2024-02-19-物联网C语言(9-链表)10.2024-02-20-物联网C语言(10-文件)11.2024-02-21-物联网系统编程(1-Shell语言)12.2024-02-21-物联网系统编程(2-系统调用)13.2024-02-22-物联网系统编程(3-进程)14.2024-02-23-物联网系统编程(4-信号)15.2024-02-24-物联网系统编程(5-管道、命名管道)16.2024-02-27-物联网系统编程(6-消息队列)17.2024-02-27-物联网系统编程(7- 共享内存)18.2024-02-27-物联网系统编程(8-线程)19.2024-02-28-物联网系统编程(9-多任务互斥与同步)20.2024-02-29-Linux高级网络编程(1-计算机网络概述)21.2024-02-29-Linux高级网络编程(2-UDP编程)22.2024-02-29-Linux高级网络编程(3-UDP编程-TFTP、广播、多播)23.2024-02-29-Linux高级网络编程(4-TCP编程)24.2024-03-01-Lniux高级网络编程(5-网络通信过程)25.2024-03-01-Linux高级网络编程(6-原始套接字)
收起

1.第一个C语言程序

#include <stdio.h>
int main() {
    printf("hello world");
    return 0;
}

输出结果

PS D:\04_Dev\05_C\01数据类型与语句\output> & .\'01_first.exe'
hello world

1.1关键字

c语言已经定义好的名字，直接拿过来用即可

1.1.1 数据类型相关的关键字

作用：用来定义变量类型

char，short ，int ，long，float，double

struct，union，enum，signed，unsigned，void

  1. char， 字符型，用char定义字符型变量，占用1个字节

    		// 占用1个字节，即8个位
    		// 有符号: -2^7 ~ 2^7 -1 ,即 -128 ~ 127
    		// 无符号: 0 ~ 2^8 -1 ,即 0 ~ 255
    		 
    		char ch1 = 'a'; // 正确，只能表示一个字符
    		char ch2 = '1223' // 错误，字符型变量不能表示多个字符

  2. short，短整型，用来定义短整型变量，占用2个字节

    		// 占用2个字节,即16位，表示范围
    		// 有符号: -2^15~ 2^15-1,即 -32768~32767
    		// 无符号: 0 ~ 2^16-1,即 0 ~ 65535
    		short int a = 11;

  3. int ，整型，用来定义整型变量，占用4个字节

    		// 占用4个字节,即32位，表示范围
    		// 有符号: -2^31~ 2^31-1,即 -21亿 ~ 21亿
    		// 无符号: 0 ~ 2^32-1,即 0 ~ 42亿
    		int a = 12;

  4. long，长整型，用来定义长整型变量，32位（及32位以下）的机器占用4个字节，64位的机器占用8个字节。

    		long a = 12;

  5. float，浮点型，用来存储浮点型数据，占用4个字节

    		float a = 3.8;

  6. double，双浮点型，用来存储双浮点型数据，占用8个字节

    		double a = 3.8;

  7. signed，有符号数据，用来定义有符号的数据，代表数据可以保存正数，也可以保存负数;

    		// 用来修饰char,int,short,long
    		// 默认情况下省略，因为默认就是有符号的数据
    		signed int a = -10;

  8. unsigned，无符号数据，只能保存正数和0

    		// 用来修饰char,int,short,long
    		unsigned int a = 0;

  9. void，空类型的关键字

    		// void是用来修饰函数参数或者返回值，代表函数没有参数或者没有返回值
    		void func(){
    		    
    		}

  10. struct，与结构体有关的关键字，用来定义结构体类型

  11. union，与共用体有关的关键字

  12. enum，与枚举相关的关键字

// 测试数据类型占用的空间大小
#include <stdio.h>
int main() {
    char a;
    short b;
    int c;
    long d;
    float e;
    double f;
 
    printf("char   -> %d\n",sizeof(a));
    printf("short  -> %d\n",sizeof(b));
    printf("int    -> %d\n",sizeof(c));
    printf("long   -> %d\n",sizeof(d));
    printf("float  -> %d\n",sizeof(e));
    printf("double -> %d\n",sizeof(f));
    return 0;
}

输出结果：

char   -> 1
short  -> 2
int    -> 4
long   -> 4
float  -> 4
double -> 8

1.1.2 存储相关的关键字

register、static、const、auto、extern

  1. register

    register是寄存器的意思，用来修饰的寄存器变量。即在编译的时候，告诉编译器这个变量是寄存器变量，尽量将其存储空间分配在寄存器中。

    注意：

    • 定义的变量不一定真的存放在寄存器中（当寄存器空间不足时，是不会存放数据到寄存器的)
    • cpu取数据的时候去寄存器中拿数据比从内存拿数据要快
    • 因为寄存器比较宝贵，所以不能定义寄存器数组
    • register只能修饰字符型和整型数据，不能修饰浮点型数据
    • 因为register修饰的变量可能在寄存器中，也可能在内存中，所以不能对寄存器变量取地址，因为只有内存的中的数据才有地址。
    		register char ch;
    		register short int b;
    		register int c;
    		register float d;

  2. static

    static可以修饰全局变量、局部变量和函数

  3. const

    const是常量的意思，用来修饰只读的数据

    		const a = 111;
    		// 赋初始值为111后，a就不能被修改了。

  4. auto

    这个变量基本不用了

  5. extern

    一般用于函数和全局变量的声明

1.1.3 控制语句相关的关键字

if ，else， break，continue，for，while，switch，case，goto，default

  1. 条件控制语句

    		if else
    		switch case default

  2. 循环控制语句

    		for while do goto

  3. 辅助控制语句

    		break continue

1.1.4 其他关键字

sizeof，typedef，volatile

  1. sizeof

    用来计算变量数组占用的存储空间大小（字节数）

    		int a = 10;
    		int num;
    		num = sizeof(a);
    		printf("num- %d", num)

  2. typedef

    重命名数据类型名，给一个已有的类型，重新取一个类型名

    		unsigned short int a = 10;
    		// 1. 用想取名的类型定义一个变量
    		short int a ;
    		// 2. 用新的类型替代变量名
    		short int INT16;
    		// 3.在最前面加上typedef
    		typedef short int INT16;
    		// 4. 就可以使用新的类型名定义变量了
    		// INT16 b 和short int b 是一个效果

  3. volatile

    易改变的意思；用vilatile定义的变量是易改变的，即告诉cpu每次用volatile变量的时候，重新去内存中取；保证最新的值，而不是寄存器中的备份；

    volatile关键字现在较少使用。

1.2 数据类型

1.2.1 基本类型

char ，short ，int， long ，float，double

#include <stdio.h>
int main(){
    // 定义一个char类型变量并赋值，使用%c输出
    char a = 'w';
    printf("a = %c\n", a);
 
    // 定义short类型的变量，使用%d输出
    short b = 123;
    printf("b = %d\n", b);
 
    
    // 定义int类型的变量
    int c = 234;
    printf("c = %d\n", c);
 
 
    // 定义long类型的数据
    long d = 2341321;
    printf("d = %d\n", d);
 
    // 定义float类型的数据，默认保存小数点后6位，四舍五入，使用%f输出
    float e = 3.146625;
    printf("e = %f\n", e);
 
    // 定义double类型的数据,默认保存小数点后6位，四舍五入，使用%lf输出
    float  f = 2.3541646546;
    printf("f = %lf\n", f);
 
   return 0;
}

输出结果

a = w
b = 123
c = 234
d = 2341321
e = 3.146625
f = 2.354165

1.2.2 构造类型

概念： 由若干个相同或者不同数据类型组成的集合，这种数据类型被称为构造类型。

int a[10]

常量：在程序运行过程中，其值不可以改变的量；

// 整形，如100,125等等
// 实型，如 3.14,0.125f,-3.1256
// 字符型，如 'a','b'
// 字符串类型 "acas","1334"

ASCII码表

对于计算机而言，只能识别二进制数据；对于费数值型数据，如果需要用一个数据值进行标识，就需要通过ASCII码表。

img

#include <stdio.h>
 
void main(){
    char ch1 = 'w';
    printf("ch1 = %c ,%d\n",ch1,ch1);
}

输出结果

ch1 = w ,119

变量：其值可以改变的量

// 存储类型 数据类型 变量名 = 变量值或者常量
int a = 100

变量名定义需要满足：

  1. 变量名只能由字母，数字和下划线组成
  2. 首字母不能为数字
  3. 不能与关键字相同

整型数据

  1. 十进制数据：以正常数字1-9开头，如456；
  2. 八进制数据：以数字0开头，如0123；
  3. 十六进制数据：以0x开头，如0x1e；

实型数据

​ 实型常量：十进制常量和指数形式；不以f结尾的为double类型，以f结尾的为float类型（如3.14f）

// 十进制常量
0.0 、0.12 、5.0
// 指数形式
123e3

​ 实型变量：单精度型（float）和双精度型（double）

float：占用4个字节

double：占用8个字节

字符数据

​ 直接常量：用单引号括起来，如'a'，'b'，'0'等

​ 转义字符：使用反斜杠\开头，后跟一个或者几个字符，如\n,\t等

​ 字符变量：使用char进行定义的变量，占用1个字节的存储空间。字符值以ASCII码的形式存储在内存中。

char a = 'w';
char b = '123';

字符串常量

字符串常量使用双引号括起来，如"CHINA","爱我中华"等

字符串常量与字符常量不同：

  1. 字符串常量使用双引号括起来，而字符常量使用单引号
  2. 每个字符串的结尾，编译器会自动添加结果标志位\0；如"a"包含两个字符'a'和'\0'

1.2.3 格式化输出字符

格式化字符 说明
%d 十进制有符号整数
%ld 十进制long有符号整数
%u 十进制无符号整数
%o 八进制整数
%x 十六进制的整数
%f float型浮点数
%lf double型浮点数
%e 指数形式的浮点数
%c 单个字符
%s 字符串
%p 指针的值 
#include <stdio.h>
 
void main(){
    // 输出整数
    int a = 100;
    
    // 输出十进制数，用%d
    printf("十进制数 a = %d \n", a);
 
    // 输出八进制数，用%o,使用%#o,就可以看到以0开头的八进制数
     printf("八进制数 a = %#o \n", a);
 
    // 输出十六进制数，用%x,使用%#x,就可以看到以0x开头的十六进制数
     printf("十六进制数 a = %#x \n", a);
 
    // 输出浮点型数据
    // 默认小数点后保留6位
    float b = 3.1464561;
    double c = 3132.1256456;
    printf("b = %f \n", b);
    printf("b = %lf \n", c);
 
    // 输出字符
    // 可以使用%c输出，也可以使用%d输出
    char d = 'y';
    printf("d = %c %d", d, d);
 
    // 输出字符串
    // 没有专门的变量来保存字符串，一般使用后数组保存
    char e[] = "hello world";
    printf("e = %s\n",e);
 
    // 输出地址,一般地址使用16进制数表示
    int f = 999;
    printf("&f = %p \n",&f);
 
}

输出结果

十进制数 a = 100 
八进制数 a = 0144
十六进制数 a = 0x64
b = 3.146456
b = 3132.125646
d = y 121e = hello world      
&f = 0000004a88bff9ac

特殊格式化应用：

用法 说明
%3d 输出宽度为3，不足3位宽度将以空格补充
%05d 宽度为5，不足的宽度以0补充
%-5d 宽度为5，使用左对齐的方式
%.2f 小数点后保留2位，四舍五入

1.2.4类型转换

数据有不同的类型，不同类型数据之间进行混合运算时，必然涉及到类型转换问题。

转换方法有两种：

  • 自动转换：遵循一定的规则，由编译系统自动完成
  • 强制类型转换：把表达式的运算结果强制转换成新的数据类型

自动转换原则：

  1. 占用内存字节数少的类型，向占用字节数多的类型转换，以保证精度不降低

  2. 转换方向

    		高		double  ←  float
    			        ↑
    				  long
    		     	    ↑
    		   	   unsigned int
    		            ↑
    		低      signed int    ←   char,short 
    		 
    		#include <stdio.h>
    		 
    		int main(){
    		    // 当表达式出现了char、short、int类型中的一种或者多种
    		    // 参加运算的成员全部变成int类型参加运算，结果也是int类型
    		    printf("5/ 2 = %d ",5/2);
    		 
    		    // 当表达式中出现了带有小数点的实数
    		    // 参加运算的成员全部变成double类型参加运算，结果也是double类型
    		    printf("5.0/ 2 = %f" ,5.0/2);
    		 
    		    // 当表达式中有有符号数，也有无符号数
    		    // 参加运算的成员变成无符号，运算的结果也是无符号数
    		    int a = -8;
    		    unsigned int b =7;
    		    if (a + b > 0 ){
    		        printf("a+b >0 \n");
    		    }else{
    		        printf("a+b <0 \n");
    		    }
    		    // 赋值语句中，等号右边的类型自动转换为左边的类型
    		    int m ;
    		    float n = 5.8f;
    		    m = n;
    		    printf(" m = %d \n", m);
    		    
    		    // 强制数据转换
    		    printf("*************\n" );
    		    int x= 10;
    		    int y = 4;
    		    printf("w = %f \n",x / y);
    		    printf("w = %f \n", (float)x / (float)y);
    		    return 0;
    		}

    输出结果:

    		5/ 2 = 2 
    		5.0/ 2 = 2.500000       
    		a+b >0
    		m = 5
    		*************
    		w = 0.000000
    		w = 2.500000

1.3运算符

1.3.1 运算符

​ 用运算符将运算对象连接起来，符合C语法规则的式子，称为C表达式；

1.3.2 运算符分类

	1. 双目运算符：即参加运算的操作数有两个，如`a + b`
	1. 单目运算符：参加运算的操作数只有一个，如`i++`或则`i--`
	1. 三目运算符: 参加运算的操作数有3个，如`a > b ? a = 1 : a = 2`

1.3.3算术运算符

+ - * / += -= *= /=

1.3.4 关系运算符

> < == >= <= !=

1.3.5 逻辑运算符

  1. && 逻辑与
  2. || 逻辑或
  3. ！ 逻辑非

1.3.6 位运算符

  1. & 按位与，任何值与0得0，与1保持不变

    		// 主要功能就是清0
    		0101 1011 &
    		1011 0100
    		----------------------------------------------------
    		0001 0000

  2. | 按位或，任何值或1得1，与0保持不变

    		0101 0011 |
    		1011 0100
    		----------------------------------------------------
    		1111 0111

  3. ~按位取反，1变0,0变1

    		0101 0011 ~
    		----------------------------------------------------
    		1010 1100

  4. ^按位异或，相同为0，不同为1

    		0101 0011 ^
    		1011 0100
    		----------------------------------------------------
    		1110 0111

  5. 移位操作

    >>右移

    << 左移

    		// 右移：逻辑右移
    		// 高位补0，低位溢出
    		0101 1010 >> 3
    		----------------------------------------------------
    		0000 1011
    		    
    		// 右移：算术右移
    		// 高位补符号位，低位溢出
    		1010 1101>> 3
    		----------------------------------------------------
    		1111 0101

1.3.7 条件运算符

() ? () : ()

// A ? B : C
// 如果A成立，执行B
// 如果A不成立，执行C
// 相当于
if (A){
    B
}else{
    C
}

1.3.8 逗号运算符

(... ,... ,...)

// A = (B,C,D)
// B ,C ,D依次执行，最终A的值为D返回的值
    #include <stdio.h>
    int main(){
        int a = 10,b = 20;
        int c;
 
        c = (a += 10,b += 10,a += b);
        printf("a = %d,b = %d,c = %d",a,b,c);
        return 0;
    }

输出结果：

a = 50,b = 30,c = 50

1.3.9 自增自减运算符

// 1. ++i 或者 --i
// 2. i++ 或者 i--
   #include <stdio.h>
    int main(){
        int a = 10;
        int b,c;
        b = a++;
        printf("b = %d\na = %d\n",b,a);
 
        c = ++a;
        printf("c = %d",c);
        return 0;
    }

输出结果：

b = 10
a = 11
c = 12

1.3.10 运算符号优先级

e3efa5fb-205c-44f8-bab3-235b26512281

1.4 控制语句

1.4.1 if 语句

if- else,if - else if - else 

#include <stdio.h>
 
int main(){
    int a =100;
    if (a> 50){
        printf("a >50");
    }else if(a ==50){
        printf("a ==50");
    }else{
        printf("a <50");
    }
    return 0;
}

输出结果：

a >50

1.4.2 switch 语句

switch case

switch (表达式) { // 表达式只能是字符型或者整型（short，int，long）
    case 常量表达式:
        语句1;
        break; // 每一个case后面都要加break，不然不会跳出，会继续执行后面语句块，直到break为止
    case 常量表达式:
        语句2;
        break;
    default:
        语句3;
        break;
}
#include <stdio.h>
 
int main()
{
    int a = 100;
    switch (a)
    {
    case (50):
        printf("a=50");
        break;
    case (100):
        printf("a=100");
        break;
 
    default:
        break;
    }
    return 0;
}

输出结果:

a=100

1.4.3 循环控制语句

for 循环

for (表达式1;表达式2;表达式3){
    语句块
}

执行顺序：

  1. 先执行表达式1，再执行表达式2；如果表达式2成立，则执行语句块；
  2. 语句执行完毕后，执行表达式3；然后再执行表达式2；
  3. 如果表达式2成立，继续执行语句块；依次循环，直到表达式2不成立为止；
#include <stdio.h>
 
int main()
{
    int i ;
    int sum = 0;
    for (i = 1; i<= 100; i++){
        sum += i;
    }
    printf("1+2+3+...+100 = %d",sum);
    return 0;
}

输出结果：

1+2+3+...+100 = 5050

while循环

while和do while,后者就不记录了，直接使用while就行了。

while(条件表达式){
    语句块
}
#include <stdio.h>
 
int main()
{
    int i = 1;
    int sum = 0;
    while (i <= 100)
    {
        sum += i;
        i++;
    }
    printf("1+2+3+...+100 = %d", sum);
    return 0;
}

​ 输出结果：

1+2+3+...+100 = 5050

goto循环

goto主要用于再一个函数里面实现代码的跳转；

由于goto跳来跳去，平时减少使用，以免造成逻辑混乱。

#include <stdio.h>
 
int main()
{
    int i = 1;
    int sum = 0;
 
JOOP:
    sum += i;
    i++;
    if (i<=100){
        goto JOOP;
    }
    printf("1+2+3+...+100 = %d", sum);
 
 
    return 0;
}

输出结果：

1+2+3+...+100 = 5050

​

posted @   Yasuo_Hasaki  阅读(31)  评论(0)  编辑  收藏  举报
    //雪花飘落效果
    点击右上角即可分享
    微信分享提示
    SQL AI 助手
    评论
    收藏
    关注
    推荐
    深色
    回顶
    收起
    ✽
    ✽