DAY3 C基础变量；输入输出函数；运算符（算数、自增自减）

最新推荐文章于 2024-04-20 01:24:09 发布

野猪骑士丶

最新推荐文章于 2024-04-20 01:24:09 发布

阅读量60

点赞数

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/qq_39692490/article/details/130392520

版权

思维导图

一、变量

【1】定义

存储类型数据类型变量名； //在日常写代码的过程中，存储类型一般省略

变量名是一个标识符，要符合标识符的命名规范

标识符的命名规范：

由数字、字母和下划线构成
不能以数字开头
严格区分大小写
不能和C语言的32个关键字重复

数据类型相关的
int        double        float        long        short        char
struct        union        typedef        enum

存储类型相关的
const        static        extern        register
volatile        auto

结构相关的
for        while        do        case        switch
if         else         goto

辅助控制关键词
break         continue         default         return

其他关键词
sizeof

·存储类型

const:        使用const定义的变量，在程序运行的该过程中值不能被修改

static:        定义静态变量

extern:      引入外部文件中的变量

register:    在寄存器中定义变量，不一定会申请成功

volatile: 防止代码优化,每一次都从内存中取变量的值

auto: 自动变量，不写存储类型局部变量默认是auto

【2】变量的初始化和赋值

初始化：在定义的直接给初始值

赋值：先定义后赋值

使用变量前，一定要确保变量已经赋值过

例子：
#include <stdio.h>
int main(int argc, const char *argv[])
{
    int a;     //定义了一个整形的变量a，没有初始化，存的是随机值
    printf("a=%d\n",a);
    int num = 10;  //定义了一个整形变量num初始化为10
    printf("num=%d\n",num);
 a = 100;  //给a赋值为100
    printf("a=%d\n",a);
    int num1 = num;  //使用已有的变量num给num1初始化
    printf("num1=%d\n",num1);
 num1 = a;   //使用已有的变量a给num1赋值
    printf("num1=%d\n",num1);

    return 0;
}
int a;                      //定义了一个整形的变量a，没有初始化，存的是随机值

int num = 10;         //定义了一个整形变量num初始化为10

a = 100;                 //给a赋值为100

int num1 = num; //使用已有的变量num给num1初始化

num1 = a; //使用已有的变量a给num1赋值

【3】类型转换

i）隐式的强制类型转换

转换的过程是编译器做的

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char c = 'a';
    int num = c;  //隐式的强制类型转换，把c变量的ascii赋值给int类型的数据
    printf("%d\n",num);
    unsigned int num1 = 0xFFFFFFFF;  //给四个字节中的每个bit都置1
    printf("%u\n",num1); //4294967295
    unsigned short int num2 = num1;
    printf("%u\n",num2); //65535
    return 0;
}
char c = 'a';

int num = c;         //隐式的强制类型转换，把c变量的ascii赋值给int类型的数据

//char 1Byte             int 4Byte                 小的数据类型向大的数据类型转换，安全

//signed定义有符号数             unsigned定义无符号数

unsigned int num1 = 0xFFFFFFFF;         //给四个字节中的每个bit都置1

//unsigned int num1 = 0xFF113478;

//0b 1111 1111 0001 0001 0011 0100 0111 1000

//把10行的num1转换成short=0x3478;

//unsigned int num1 = 0x11111111;

//unsigned char a = num1;

printf("%u\n",num1); //4294967295

unsigned short int num2 = num1;

printf("%u\n",num2); //65535

//int 4Byte         short 2Byte

//大的数据类型向小的数据类型强转的时候，会发生数据的丢失,不安全

ii）显式强转

格式：(强转的目标类型)强转的数据;

#include <stdio.h>
int main(int argc, const char *argv[])
{
    unsigned int num = 0xFFFFFFFF;
    unsigned short int num1 = (short)num;
    unsigned char a = (char)num;

    //显式的强制类型转换，可以看见强转的过程
    //把int类型的num强转为short类型
    //(强转的目标类型)强转的内容;  通常强转的结果会用对应的数据类型接收
    printf("%#X\n",a); //0xFF,输出一个字节
    printf("%#X\n",num1);  //0xFFFF

    return 0;
}

显式的强制类型转换，可以看见强转的过程

(强转的目标类型)强转的内容; 通常强转的结果会用对应的数据类型接收

iii）有符号和无符号数之间的转换

隐式的强制类型转换，无符号数和有符号数一起运算，强转成无符号数

#include <stdio.h>
int main(int argc, const char *argv[])
{
    unsigned int c = 2;  //无符号数
    signed int a = -3;   //有符号数
    printf("%u\n",a+c); //隐式的强制类型转换，无符号数和有符号数一起运算，强转成无符号数
    if(a+c>0)
    {
    printf("1\n");
    }

    return 0;
}

【4】变量的取值范围

有符号数signed、无符号数unsigned

默认都是有符号数

根据数据的最高位是符号位，0表示是正数，1表示负数

原码、反码、补码

计算机中，数据都是以补码的形式进行存储和运算，都是二进制的

原码

人能看懂的，十进制转换过来的

反码

原码和补码的一个中间状态正数：原码、反码和补码都一样；

负数：原码的除符号位外其他位取反

补码

计算机中存储和运算用的都是补码，正数原码、反码和补码都一样，负数的补码是反码+1

正数的原反补都相同

负数的反码是原码除符号位外取反，补码是反码+1

例子：

有符号数 -123 +123
原码 1111 1011 0111 1011
反码 1000 0100 0111 1011
补码 1000 0101 0111 1011

i）char 1Byte 8bit

取值范围：

无符号数 [0,255]--------[0,2^8-1]
有符号数 [-128,127]----[-2^7,2^7-1]
正数
[0,2^7-1]

复数
[-2^7,0]

1000 0000 ------> 1111 1111 -----> 1 0000 0000

-0的补码 1000 0000

规定 1000 0000 是-128的补码，-128没有原码和反码，-128补码的最高位，既是符号位也是数据位。

计算机中数据存储的时候看的是数值(有无符号)
#include <stdio.h>
int main(int argc, const char *argv[])
{
    signed char c = 129;
    //存储看符号+
    //原码:1000 0001
    //反码:1000 0001
    //补码:1000 0001
    //取出看类型:
    //补码:1000 0001
    //反码:1000 0000
    //原码:1111 1111
    printf("%d\n",c);
    c = 255;
    //存储看符号+
    //原码:1111 1111
    //反码:1111 1111
    //补码:1111 1111
    //取出看类型
    //补码:1111 1111
    //反码:1111 1110
    //原码:1000 0001
    printf("%d\n",c);
    unsigned char p = -1;

    printf("%u\n",p);

 c = 213;
    //存储看符号
    //原码:1101 0101
    //反码:1101 0101
    //补码:1101 0101
    //取出看类型
    //补码:1101 0101
    //反码:1101 0100
    //原码:1010 1011
    printf("%d\n",c);
    return 0;
}

ii）short 2Byte 16bit

无符号数[0,2^16-1]

有符号数 [-2^15,2^15-1]

正数[0,2^15-1]

负数[-2^15,0]

1000 0000 0000 0000

iii）int 4Byte 32bit

无符号数[0,2^32-1]

有符号数 [-2^31,2^31-1]

正数[0,2^31-1]

负数[-2^31,0]

1000 0000 0000 0000 0000 0000 0000 0000

补码是通过模运算得来的。

练习：

124: 原码、反码和补码0111 1100

-35： 1010 0011 ----> 1101 1100 ----->1101 1101

-126： 1111 1110 ----> 1000 0001 -----> 1000 0010

-96： 1110 0000 ----> 1001 1111 -----> 1010 0000

-24： 1001 1000 ----> 1110 0111 -----> 1110 1000

-123： 1111 1011 ----> 1000 0100 -----> 1000 0101

-115： 1111 0011 ----> 1000 1100 -----> 1000 1101

二、标准输入输出函数

【1】printf

1.函数原型

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

printf使用时，需要一个格式符和一个格式符对应类型的数据

printf("占位符/格式符",输出表象); //有一个格式符就要有一个输出表象

printf("%d\n",10); //10就是输出表象，%d就是10对应的格式符

printf("%c",'c'); //字符c时输出表象，%c是字符c对应的格式符

格式符 %u: 无符号数输出的格式符

【2】sacnf

1.函数原型

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

scanf("格式符",变量的地址);

&:取地址符，取变量的地址

scanf以回车作为获取结束的标志，只有缓冲区内的数据>=格式符的个数回车是结束的标志

scanf从缓冲区内获取数据的标志，以空格、tab键和回车作为数据之间间隔的标志

i）scanf在获取多个字符数据时，需要吸收垃圾字符

//scanf在连续获取多个字符类型数据的时候需要吸收垃圾字符

//因为scanf作为数据分隔的标志，空格，tab和回车都是ascii中能查到的字符

1、利用scanf严格控制格式的特点

%c后面的空格起到吸收垃圾字符的作用

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

2、在格式符前面打空格，空格的作用是，吸收输入之前的所有垃圾字符

scanf(" %c",&a);

scanf(" %c",&b);

scanf(" %c",&c);

scanf(" %c",&d);

3、使用getchar吸收垃圾字符

scanf("%c",&a);

getchar();

scanf("%c",&b);

getchar();

scanf("%c",&c);

getchar();

scanf("%c",&d);

4、使用抑制字符 %*c （不建议使用）

%*c一定要吸收掉一个字符，不管字符是否是垃圾字符，不建议使用 scanf("%c%*c%c%*c%c%*c%c",&a,&b,&c,&d);

【3】字符的输入函数getchar()

getchar()从终端获取单个字符

char c;

scanf("%c",&c); //通过scanf终端获取c

c=getchar(); //通过getchar终端获取c

【4】字符的输出函数 putchar()

输出单个字符

#include <stdio.h>
int main(int argc, const char *argv[])
{
    char c = 97;
    putchar(c);   //输出单个字符,不会换行
    putchar(10);  //输出换行
    putchar('1');
    return 0;
}

putchar(10); //输出换行

三、运算符

【1】算术运算符

运算符	作用
+ - *	两数相加、相减、相乘
/	如果左右两个操作数都是整形，就是取整运算，结果就是整形如果有一个操作数是浮点型，结果就是浮点型，除数不能为0
%	要求：两个操作数必须是整形，取余，除数不能为0

【2】自增自减运算符

a++，++a，a--，--a

int a = 10; a++或者是a--表达式的结果仍然为10

++a，结果就是11

如果先看见运算符，结果就是运算后的值

如果先看见变量，结果就还是变量本身

练习：

1、使用带参宏实现，两数相乘*，两数相除/，两数模除%

#include <stdio.h>
#define M(a,b) a*b
#define D(a,b) (float)a/b
#define O(a,b) (int)a%(int)b
int main(int argc, const char *argv[])
{
    printf("%d\n",M(3,4));
    printf("%f\n",D(10,4));
    printf("%d\n",O(10.0,4.0));
    return 0;
}

未学：

【3】赋值运算符

【4】关系运算符

【5】逻辑运算符

【6】条件运算符

【7】逗号运算符

【8】位运算符

【9】sizeof运算符

作业：

1.整理思维导图

2.有以下变量求输出结果

signed char c = 178;

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

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

unsigned char d = -9;

printf("%d\n",d);

printf("%u\n",d);

并写出数据存储和取出的过程

printf("%d\n",c);=-78

接下来三个我做不出啊，等明天老师讲吧

3.求-57的原码、反码和补码

-57

原码：1011 1001

反码：1100 0110

补码：1100 0111