首页 > 其他分享 >2024-02-16-物联网C语言(数据类型与语句)

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

时间：2024-02-16 23:34:44浏览次数：27  
标签：02 输出 short 16 int float 数据类型 char printf

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

​

标签：02,输出,short,16,int,float,数据类型,char,printf
From： https://www.cnblogs.com/hasaki-yasuo/p/18017624

相关文章

  • 酷睿i5-12450H+16GB内存！神舟战神Mini电脑1899元到手
    神舟战神Minii5迷你台式电脑正在参与京东年货节大促，搭载酷睿第12代i5-12450H处理器，另外还有16GBDDR4内存和512GBPCIe4.0SSD，整机到手价1899元，应该是目前为止相同配置售价最低的品牌迷你主机。酷睿第12代i5-12450H处理器其实是用于笔记本的型号，拥有超低的功耗但是性能却不低......
  • 2024/2/16学习进度笔记
    SparkStreaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象原语如：map、reduce、join、window等进行运算。而结果也能保存在很多地方，如HDFS，数据库等。另外SparkStreaming也能和MLlib（机器学习）以及G......
  • 2024年2月 校内集训
    ......
  • 2.16 闲话 & solution『漆黑的夜中透出了一点点微光/早就应该习惯/忽明忽暗酒阑人散』
    为啥只有我和CuFeO4【数据删除】，别人都没【数据删除】，血亏，下次绝对不【数据删除】了明天有CF，希望能打在写\(\text{NTT}\)惹，但是没有达成写4题呜呜明天有模拟赛唔，首先是朴素\(dp\)骗分，设\(dp_{i,j}\)表示已经取到了\(i\)个，其中取模后结果为\(j\)的方案数，容易有转移\[......
  • Solution Set【2024.2.16】
    A.寄（post）对于点对贡献问题考虑在最近公共祖先处计算答案，称给定的\(m\)个点为关键点，选择的\(k\)个点为选择点。既然我们已经要求了对于每一对关键点和选择点均在其最近公共祖先处计算答案，那么这也就意味着，存在某些节点，其子树中的关键点/选择点不会与其子树内的选择点/关......
  • 力扣递归 广度优先搜索之102. 二叉树的层序遍历
    classSolution{   List<List<Integer>>result=newArrayList<>();   publicList<List<Integer>>levelOrder(TreeNoderoot){       if(root==null){           returnresult;       }       traverse(root,0);    ......
  • AC466A 2024省选联测19 寄（post）
    题意一棵有边权的树，给定\(m\)个关键点，让你选择若干个点，使得每个关键点到你选择的点的距离的最小值之和加上选择的点的个数乘\(C\)最小。求这个最小值。\(n\le3000\)Sol考虑将选择点的个数扔掉，直接考虑对于每个点加上\(C\)的贡献。设\(f_{i,j}\)表示\(i\)的贡献......
  • 闲话2.16
    刚写了个唐氏鞋油，感觉自己跟唐一样......
  • 2024.2.16 そんな凡庸を探して、探している
    Namid[A]me好听呢。可惜了。今天DP专题感觉laofu选的题有点经典，导致我有一半时间在摸鱼，不过还是写了点题的。怎么西工大附中有糖醋茄子这种神秘菜啊。ICPC2020MacauBBoringProblem其实不一定懂完了，试着说一说。显然询问没什么用，问题本质是要求解一个AC自动机上游......
  • 洛谷P6169 [IOI2016] Molecules
    洛谷传送门分析结论：如果存在解，则一定有一个解使得选的数是排序后的一段前缀并上一段后缀。下文所说序列均已排序。引理：对于一个可行解选的某个数，一定可以将其换成序列中的最小数或最大数而使得换完之后还是一个可行解。证明：反证法。假设都不可换。设当前选的所有数的和为\(......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99