嵌入式LinuxC语言数据类型-创新互联

计算机是如何给人类解决问题?
答:
问题域的数据保存起来,然后通过某些运算从而得到结果。
程序 = 算法 + 数据结构
首先考虑保存数据,在保存数据之前要先知道数据的大小、范围、属性等
即数据类型

创新互联10多年企业网站设计服务;为您提供网站建设,网站制作,网页设计及高端网站定制服务,企业网站设计及推广,对成都广告推广等多个领域拥有多年建站经验的网站建设公司。

1.数据类型

typeof(x) =>求对象x的类型
typeof(3) =>int
typeof(3.0) =>double

#includeint main()
{
    typeof(1) a;  //int a
    return 0;
}

在C语言中,有如下数据类型

  1. 基本类型:C已经定义好的类型,主要用来保存整数/小数/浮点数
整数:
        (signed可省略) char/unsigned char  字符型 保存的时ASCII码值(即整数值)
        short/unsigned short 短整型
        int/unsigned int 整型
        long/unsigned long 长整型
        ......
        上面都是用来描述整数
        区别:
            a、signed/unsigned
                有符号(signed):
                    符号位(最高位) + 数值位
                    1 -->负数
                    0 -->正数/0
                无符号(unsigned):
                    所有bit位全部都是数值位(直接参与运算)

整数用8bit来表示:
1111 1110
=>无符号:254
1111 1110
+1
----------
1111 1111
+1
----------
10000 0000
=>2^8 - 2
有符号:
负数 =>|负数| ==>取反+1 ==>负数补码
负数补码 ==>-1 ==>取反 ==>|负数| ==>负数
1111 1110
-1 : 1111 1101
~ : 0000 0010
|负数| : 2
负数 : -2

b、char/short/int/long/....
            所占的内存的空间大小不一样
            char ->8bits
                取值范围:[-128,127]
                1000 0000 -- 01111 1111
            unsigned char ->8bits
                取值范围:[0,255]
                0000 0000 -- 1111 1111
            short/unsigned int  在32bits机器下面,一般为32bits
                                在64bits机器下面,一般为32bits
            long/unsigned long  在32bits机器下面,一般为32bits
                                在64bits机器下面,一般为64bits

        c、在不同的编译器下面,同一类型的范围也不一样
            如:
                keil
                    int 16bits
                unbuntu 18.04
                    int 32bits
            sizeof(x) 求类型x的所占的字节数,默认长整型(%ld)
                1Byte = 8bits
            一般符号:
                sizeof(long) >= sizeof(int) >= sizeof(short) >= sizeof(char)

        d、在gcc编译器中,整数默认类型时 int
            typeof(3) =>int
            typeof(3 + 4) =>int
            typeof(3 + 4.0) =>double

小数(浮点数):
    float       :单精度浮点型
    double      :双精度浮点型
    long double :长双精度浮点型

    区别:
        a、类型不同,所占空间不同,保存精度也不同
            一般来说:
                sizeof(float)  =>4bits
                sizeof(double)  =>8bits
                sizeof(long double)  =>16bits(64bits机器下)

        b、在gcc编译器中,浮点数默认类型为 double
            typeof(2.0) ==>double
            typeof(2.0f) ==>float
            typeof(2) ==>int
            typeof(2u) ==>unsigned int
            typeof(2.0 + 3) ==>double
  1. 构造类型:自定义类型
数组:一组相同类型元素的数据集合。
        eg:
            int a[10];  //定义一个数组,数组名为a,含有10个int类型的元素
            定义变量:变量类型 + 名字
            定义一个像a一样类型的对象m:
            typeof(a) m;

    结构体
    联合体(共用体)
    枚举
  
  1. 指针类型

  2. void类型

void在C语言中,有三个作用:
       1. void*
           通用指针,用来存放任何数据类型的引用(指针)
           不清楚所需指针类型时使用
           void*
               char *
               int *
               short *
               ....
           eg:
               malloc(100); //与C++中new相同 返回void*类型指针,占空间用
               

       2. void当作函数的参数
           表示此函数没有参数,不需要传参。
           eg:
               int func(void){}
           调用:
               函数名(实参)
               func(3,4)  //ERROR
               func(); //TRUE

       3.void当多函数的返回值类型
           表示函数没有返回值,不需要返回值
           如:
                void func(int m, int n)
                {
                   return ;  //退出函数
                   return 0; //ERROR 退出函数 并返回0
                }

在C语言中,数据分为两大类:
变量
常量

变量
什么是变量?
在程序运行期间,可以改变其值的数据对象
存储变脸会对应一个存储单元且存储单元是可写的

变量的定义
    变量在使用之前必须定义
    语法:
        变量类型 变量名(= 初值);
        可赋值也可以不赋值
    
        变量类型
            基本类型、构造类型、指针类型
        变量名
            一个对象的名字,标识符(对象的名字,变量、数组、函数)
            在C中,C语言标识符:只能由字母、下滑写、数字,数字不能开头

            为什么数字不能开头?
            int 2E3; //2E3 科学计数法2000

            int a;
            printf("%d\n", a)  //打印随机值,由编译器决定

变量的属性
    eg:   
        int a = 1024
        int:变量类型
        a:变量名
        1024:变量值(存储空间中保存的内容)
        &a:变量的地址

    变量类型
    变量名
    变量值(保存到存储空间中的内容)
        变量的存储空间里面的内容,不管是否初始化或赋值,空间中一定会有一个值,因为存储空间中所有的bit位都有值(0/1)
    变量的地址:
        在程序运行时,系统会为每一个变量分配一个存储空间,用来保存这个变量的值,且这个存储空间一定会有一个唯一的编号,那么这个编号就是变量的地址。

变量的访问(read/write)
eg: 
    int b, a = 5;
    a = 1024;  // 把1024写到变量a所对应的地址中  将数值写到a的地址  ---- (1)
    b = a*5;   //把a的值乘5,赋值到b  读取变量a的值                ---- (2)

    读(read):从变量的存储单元中读取存储单元中的内容 读变量的值
    写(write):把一个值写到变量所对应的存储单元中 赋值

在c语言中,任何变量有且只有两层含义:
    1. 变量的地址
        lvalue:
            localtion value 可寻址(可写)的值 
            left value 左值
    2. 变量的值
        rvalue:
            readable value 可读的值
            right value 右值
    
    一般情况:
    变量的左值:
        变量的地址,"="的左边
    变量的右值:
        变量的值,"="的右边
整数
    在计算机中整数是以其补码形式进行保存
    正数/0:
        整数的补码就是原码本身
        原码:就是相对应的数值转换位二进制形式
            eg:
                13: int 32bits
                    13 = 8 + 4 + 1
                    000000000 00000000 000000000 00001101<- 13
                int a = 13;
                    a:
                        000000000 00000000 000000000 00001101
    负数:
        负数的补码 其原码的绝对值 取反 +1
        负数 =>|负数| =>取反 =>+1 =>负数补码
            eg:
                -13: int 32bits
                |-13|:000000000 00000000 000000000 00001101
                取反:11111111 11111111 11111111 11110010
                +1:11111111 11111111 11111111 11110011
                -13补码:11111111 11111111 11111111 11110011

        8bits 存储:
            -2:1111 1110
            254:1111 1110

            -3:1111 1101
            253:1111 1101

            -4:1111 1100
            252:1111 1100
            ......
        一个负数会和一个正整数的补码形式一样即存放形式相同
        =>-x 和 (2^n - x)相同 n表示用n个bits存储一个整数

        n=32
            -1 和 2^32 -1 相同

        CPU内无符号位,对CPU来说,所有的bit位都是数值位参与运算。
            eg:
                int a = -13
                //a在计算机中的存放形式为
                //11111111 11111111 11111111 11110011
                printf("%d\n", a);  //-13
                    %d: 有符号数
                        符号位:1
                        负数补码:11111111 11111111 11111111 11110011
                        -1:11111111 11111111 11111111 11110010
                        取反:00000000 00000000 00000000 00001101
                        |-13|:00000000 00000000 00000000 00001101
                        负数:-13
                printf("%u\n", a);  //2^32 - 13
                    %u:无符号数
                        正数/0
                        11111111 11111111 11111111 11110011
                        即是补码,也是原码
                        =>2^32 - 13

            unsigned int a = -1u;
                -1u:
                    111111111 111111111 111111111 111111111
                a:
                    111111111 111111111 111111111 111111111
            printf("%d\n", a); //-1
            printf("%u\n", a); //2^32-1

            insigned int a = 1<< 31;
                1<< 31 左移31位 10000000 00000000 00000000 00000000
            printf("%d\n", a);//-2^31
                %d: 有符号数
                    符号位:1  负数
                    -1:011111111 11111111 11111111 11111111
                    取反:10000000 00000000 00000000 00000000
                    |-2^31|
                    -2^31
            printf("%u\n", a);//2^32-2^31=2^31

        GNU有一个标准头文件 stdint.h
            /user/include/stdint.h

    整数之间赋值
        char a = 127;
        int b = 1024;
        a = b;  //不会报错,会出错
        在C语言中,允许不同类型之间整数相互赋值,不同类型的整数,存储空间大小不同
            char 8bits
            short 16bits
            int 32bits
        C标准建议:
            1.长 ->短
                低字节直接拷贝,高字节部分全部舍弃discard,无法保存
                    int  ->short
                    ....

            2.短 ->长
                低字节直接拷贝
                高字节:如果短的是无符号数,高位全部补0
                        如果短的是有符号数,高位补符号位
                从右往左运算
                
            char a = 127;  //0000000 00000000 00000100 00000000
            int b = 1024; //00000000
            a = b; //00000000
                =>a:32bits
                    00000000 00000000 00000000 000000000
            printf("%d\n", a); //0
            printf("%u\n", a); //0


        char a = 250;
        char d;
        d = a + 8;
            250: 00000000 00000000 00000000 11111010
            a: 11111010  //即表示-6也表示250 char-128~127 此处a值位-6
            a+8: typeof(a) =>char + int =>int
                a int 短变长
            a:11111111 11111111 11111111 11111010
           +8:00000000 00000000 00000000 00001000
           ---------------------------------------
              100000000 00000000 00000000 00000010
            d:00000010
        printf("%d\n", d); //2
            %d: int
                %d : int 
					char d =>int 
						00000000 00000000 00000000 00000010<- 最终在计算机中的存放形式
						符号位: 0 - 正数 
							=>2
        printf("%u\n", d); //2
            %u : unsigned int 
                    char d =>unsigned int 
                        00000000 00000000 00000000 00000010<- 最终在计算机中的存放形式  
                        无符号的数: 所有位数值位 
                            直接运算 =>2 

                unsigned char a = 250; 
				char d;  
				d = a + 8; 
					250: 00000000 00000000 00000000 11111010 
					a  :11111010 
					a + 8  : typeof(a) =>unsigned char + int =>int 
					a ->int : 短 ->长 
					a : 00000000 00000000 00000000 11111010
					+8: 00000000 00000000 00000000 00001000
					-----------------------------------------
					   100000000 00000000 00000001 00000010
					d : 00000010			
				printf("%d\n", d); //2
				printf("%u\n", d); //2

                char a = 250; 
				int d;  
				d = a + 8; 
					250: 00000000 00000000 00000000 11111010 
					a  :11111010  
				a + 8  : typeof(a) =>char + int =>int 
					a ->int : 短 ->长 
					a : 11111111 11111111 11111111 11111010
					+8: 00000000 00000000 00000000 00001000
					-----------------------------------------
					   100000000 00000000 00000000 00000010
					d : 00000000 00000000 00000000 00000010<- d在计算机中的存放形式 			
				printf("%d\n", d); //2
				printf("%u\n", d); //2

				unsigned char a = 250; 
				int d;  
				d = a + 8; 
					250: 00000000 00000000 00000000 11111010 
					a  :11111010  
				a + 8  : typeof(a) =>unsigned char + int =>int 
					a ->int : 短 ->长 
					a : 00000000 00000000 00000000 11111010
					+8: 00000000 00000000 00000000 00001000
					-----------------------------------------
					    00000000 00000000 00000001 00000010
					d: 00000000 00000000 00000001 00000010<- d在计算机中的存放形式
				printf("%d\n", d); //258
				printf("%u\n", d); //258 

3.常量
常量是指在程序运行期间,值不能改变

1.整型常量
    代表整数的常量值。
    八进制常量:以0开头,后接多个0-7字符组成
        0[0-7]+ 正则表达式
        eg:
            0000
            0123
            0923 //ERROR

        int a = 0123;
        printf("%d\n", a); //8进制转换10进制 

    十六进制常量:以0x和0X开头,后面接多个或者一个0-9,a-f,A-F字符
        0[x/X][0-9,a-f,A-F]+
        eg:
            0xF
            012F//ERROR

        int a = 0xf3
        printf("%d\n", a);\\8进制转16进制 253

    十进制常量:
        [0-9]+

2.字符常量
    字符常量是用单引号引起来的一个或多个字符的序列
    eg:
        'a'
        'Z'
        ......
        '\n' 换行
        '\r' 回车
        '\t' 制表
        ......
        '\0' ASCII为0 对应的字符
    在计算机中,保存一个字符,保存的是字符对应的ASCII码值
    ASCII:
        American Standard Code for Information Interchange
        美国把每个字符给一个唯一的整数值来标识,这个整数值就是ASCII码。由于美国使用字符不超过256个,所有只需要8bits就可以保存
    命令:
        man ASCII 可查看相关信息
            Oct: 八进制数
            Dec: 十进制数
            Hex: 十六进制数
            Char: 字符
            "A" - "Z" : 65 - 90
            "a" - "z" : 97 - 122
            "0" - "9" : 48 -57

    int a = 'A';<=>int a = 0101;<=>int a = 0x41;<=>int a = 65;<=>int a = '\101'<=>int a = '\0x41'
    字符分为两类:
        a、普通字符
            可以打印的字符,有形状的字符
        b、特殊字符(转义字符)
            不可以打印的字符
            如:
                '\n': 换行符
                '\r': 回车符
                '\t': 制表符
                ....
                '\000':由\后面接1或2或3个八进制的数字组成,这些八进制数字用来指定所期望的字符的ASCII码值。
                    如:
                        '\101'<=>65<=>0101<=>0x41<=>'A'
                '\x00':由\x后面接1或2个十六进制数字组成。十六进制数字用来指定所期望的字符的ASCII码值。

3.浮点常量
    由整数部分、小数点、小鼠部分、一个e/E、一个可选的带符号的整数指数 和 一个可选的标识类型的后缀(f/F/l/L)组成
        f/F:float
        l/L:long double
        没有后缀:double

        整数部分:可省略
        小数部分:可省略
            但是小数部分 和 整数部分 不能同时省略
        如:
            float f = 2.3E3;  // 2.3*10^3
            float f = .3E3;  // 0.3*10^3
            float f = 5E-5; //5.0*10^-5
            float f = E5; //ERROR 小数和整数部分不能同时省略(与变量无法区分)

4.枚举常量(结构体)
5.符号常量
    宏
        语法:
            #define 宏名 替换对象
        eg:
            #define PI 3.14

总结

  1. 数据类型
基本类型
        整数 char/int/short/long  dif
        浮点数 float/double/long double
    构造类型
        数组
        结构体
        联合体
        枚举
    指针类型
    void
        void*
        函数参数
        函数返回值
  1. 变量
变量定义 变量类型 变量名 = 初值
    变量属性 变量类型 变量名 变量值 变量地址
    变量访问 lvalue/rvalue

3.整数

整数存储问题
            补码 =>逆运算
            结论1:-x = 2^n - x
            结论2:CPU没有符号概念

4.不同类型的整数之间的赋值

长->短
        短->长

5.常量

整数常量
        字符常量
            'a' - 'z'  97 - 122
            'A' - 'Z'  65 - 90
            '0' - '9'  48 - 57
            '\0' =>0
            '\000':0标识一个八进制位
            '\x00':0标识一个十六进制位
        浮点常量
        符号常量
(类型) : 类型的强制转换 
eg: 
	(char)3 :  将int类型的3强制转换为char 
		3 =>int

你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧


文章名称:嵌入式LinuxC语言数据类型-创新互联
分享URL:http://pwwzsj.com/article/eihed.html