传智播客C基础:Day4

传智播客C/C++：尹成C基础

标签（空格分隔）： 传智播客 C

---

Day4

1.数据类型

1.1数据类型的极限和输出

short占用2字节，16位；
long占用4字节，32位；
int占用2或者4字节，16位或32位；
long long占用8字节，64位；

1.1.1整型的极限

min_int = -2147483648
max_int = 2147483647
umin_int = 0
umax_int = 4294967295
min_long = -2147483648
max_long = 2147483647
umin_long = 0
umax_long = 4294967295
min_llong = -9223372036854775808
max_llong = 9223372036854775807
umin_llong = 0
umax_llong = 18446744073709551615

#include  //printf函数
#include  //定义了各个整型数据类型的极限
#include  //system函数

void main()
{
    //INT，无符号数将%d换成%u
    int min_int = INT_MIN;
    int max_int = INT_MAX;
    unsigned int umin_int = 0; //无符号整型的最小值就是0
    unsigned int umax_int = UINT_MAX;

    printf("min_int = %d,max_int = %d\n", min_int, max_int);
    printf("umin_int = %u,umax_int = %u\n", umin_int, umax_int);

    //LONG和INT极限相同，但是输出用ld
    long min_long = LONG_MIN;
    long max_long = LONG_MAX;
    unsigned long umin_long = 0;
    unsigned long umax_long = ULONG_MAX;

    printf("min_long = %ld,max_long = %ld\n", min_long, max_long);
    printf("umin_long = %lu,umax_long = %lu\n", umin_long, umax_long);

    //LONG LONG 用lld输出
    long long min_llong = LLONG_MIN;
    long long max_llong = LLONG_MAX;
    unsigned long long umin_llong = 0;
    unsigned long long umax_llong = ULLONG_MAX;

    printf("min_llong = %lld,max_llong = %lld\n", min_llong, max_llong);
    printf("umin_llong = %llu,umax_llong = %llu\n", umin_llong, umax_llong);

    system("pause");

}

[注]

    int num = 10/3; //经过int，num的类型为int
    printf("%f",num);
    //printf不会进行类型处理，按给定格式打印字符
    //会按照f的方式读取内存，读取失败
    //转换失败就是“0”！！！

//补充例题
/*查看各个数据类型内存占用和取值范围*/
/*32位计算机的机器字长是4字节，short*/

#include 
#include 


int main(void)
{
    /*short类型*/
    printf("sizeof short = %dB 相当于 %dbits\n", sizeof(short),sizeof(short)*8); //2B,16bits  32位系统
    printf("signed short:\n");
    short int short_min = SHRT_MIN;
    short int short_max = SHRT_MAX;
    unsigned short unshort_max = USHRT_MAX;
    printf("short_min = %d\n", short_min);
    printf("short_max = %d\n", short_max);
    printf("unsigned short_max = %d\n", unshort_max);

    putchar('\n');
    /*int类型*/
    /*int类型应该：short<=int<=long*/
    /*32位机器字长位32位，即4字节，int应该为4字节*/
    /*64位int也是占用32位*/
    printf("sizeof int = %dB 相当于 %dbits\n", sizeof(int), sizeof(int) * 8); //4B,32bits  32位系统
    printf("signed int:\n");
    int int_min = INT_MIN;
    int int_max = INT_MAX;
    unsigned int unint_max = UINT_MAX;
    printf("int_min = %d\n", int_min);
    printf("int_max = %d\n", int_max);
    printf("unsigned int_max = %u\n", unint_max); //注意这里用u来表示

    putchar('\n');
    /*long类型*/
    /*long占用32位，但是有些机器int类型占用为16位，所以要表达32位的数字，最好用long*/
    /*为了保证移植到int占用16位的机器上不出问题，最好用ld打印long类型*/
    printf("sizeof long = %dB 相当于 %dbits\n", sizeof(long), sizeof(long) * 8); //4B,32bits  32位系统
    printf("signed long:\n");
    long long_min = LONG_MIN;
    long long_max = LONG_MAX;
    unsigned long unlong_max = ULONG_MAX;
    printf("long_min = %ld\n", long_min);
    printf("long_max = %ld\n", long_max);
    printf("unsigned long_max = %lu\n", unlong_max); 

    putchar('\n');
    /*long long类型*/
    /*long long占用64位*/
    printf("sizeof long long = %dB 相当于 %dbits\n", sizeof(long long), sizeof(long long) * 8); //8B,64bits  32位系统
    printf("signed long long:\n");
    long long llong_min = LLONG_MIN;
    long long llong_max = LLONG_MAX;
    unsigned long long unllong_max = ULLONG_MAX;
    printf("llong_min = %lld\n", llong_min);
    printf("llong_max = %lld\n", llong_max);
    printf("unsigned llong_max = %llu\n", unllong_max);

    getchar();
    return 0;
}

3.4

/*3.4更多printf()的特性*/

#include 
#include 

int main(void)
{
    unsigned int un = 3000000000; //unsigned int为32位可以容纳,int不行
    short end = 200;//一个字节无符号最大是256,，short是两个字节，最大无符号数为65535
    long big = 65537;//4字节
    long long verybig = 1234567890642;

    printf("un = %u and not %d\n", un, un);
    printf("end = %hd and %d\n", end, end);//两个均正常显示
    printf("big = %ld not %hd\n", big, big);//较大的数直接被截断成short
    printf("verybig = %lld and not %ld\n", verybig, verybig);//同上，long long被截断成long

    getchar();

    return 0;
}

1.1.2浮点型的极限

float_min = 1.17549e-38
float_max = 3.40282e+38
double_min = 2.22507e-308
double_max = 1.79769e+308

#include 
#include 
#include  //包含浮点型数据的极限

//浮点数如3.14，没有指定数据类型，则默认为double型
void main()
{
    float float_min = FLT_MIN;
    float float_max = FLT_MAX;
    double double_min = DBL_MIN;
    double double_max = DBL_MAX;
    
    //%g是从%f（小数），%e（指数）中找短的
    printf("float_min = %g\n", float_min);
    printf("float_max = %g\n", float_max);
    printf("double_min = %g\n", double_min);
    printf("double_max = %g\n",double_max);

    system("pause");
}

1.1.3数据类型占用的内存

size of :
char = 1 byte
int = 4 byte
long = 4 byte
long long = 8 byte
float = 4 byte
double = 8 byte

为什么INT和FLOAT占用同样的内存，能表示的极限却不同：
实数：按照指数方式存储
整数：一一对应

#include 
#include 
void main()
{
    printf("size of :\n");
    printf("char = %d byte\n", sizeof(char));
    printf("int = %d byte\n", sizeof(int));
    printf("long = %d byte\n", sizeof(long));
    printf("long long = %d byte\n", sizeof(long long));
    printf("float = %d byte\n", sizeof(float));
    printf("double = %d byte\n", sizeof(double));
    system("pause");
}

1.2字符型数据char

字符常量定义：用单引号括起来的单个字符或者转义字符，其中字符常量的值是该字符对应的ASCII码值。
字符串常量定义：用双引号括起来的一个或者一串字符。其中最后一位为"\0"占一字节，表示字符串结束。
* char的值用%c输出时单个字符，用%d输出时对应的ascii码，str用%s输出是一串字符，用%d输出是一串垃圾值，用%x输出是str的内存地址。*

(1)字符串常量与字符常量的不同

‘A’：表示一个值为65的字符，输出时用%c,占用1字节，
"A"：表示一个A的字符，输出时为%s，占用2字节，为"A"、“\0"。

#include 
#include 
void main()
{
    char ch = 'A';
    char str[] = "A";
    printf("size of char = %d\n", sizeof(ch));
    printf("size of str = %x\n", str);
    system("pause");
}

(2)字符串常量与整数的不同

以字符‘1’和整数“1”为例，字符‘1’占用一个字节，在内存中存储的是对应的ASCII码，即49，内存中存储的也是这个ASCII码，为00110001,而整数1在内存中的存储则是其本身，0000 0000 0000 0001。

(3)宽字符类型wchar_t

char类型的字符占1字节，最多能够表示0-255总共256个字符，而对于非ASCII码的字符，则无法存储，程序无法国际化。故定义了wchart_t类型，占用2字节16位。

#include 
#include 

void main()
{
    char a = 'a';
    wchar_t w_a = L'a';//这里有没有L都行

    printf("size of char = %d\n", sizeof(a));
    printf("size of wchar = %d\n", sizeof(w_a));

    printf("a = %c\n", a);
    printf("w_a = %wc\n", w_a);//%wc,%c都行
    wprintf("w_a = %c\n", w_a);//这里不能用wprintf,wprintf语法不是这样
    
    system("pause");
}

1.3数据类型转换

1.3.1数据类型及变量声明的作用

• 指明数据类型需要的内存大小，sizeof不同
• 指明数据类型极限范围的不同
• 指明同样的二进制数据所表达的不同数值
• 不同的数据类型具有不同的操作
• 告诉编译器该如何处理

1.3.2数据类型转换

(1)“+、-、*、/”的转换

运算符的操作数，只要有一个是浮点型，就自动转为浮点型。
char类型转换成整型。
总的来说，就是向上转换。

(2)printf以及强制数据类型转换

printf本身不进行数据类型转换，并且由于C语言的短路机制，printf第一个类型不匹配，后面的也会失败。所以在必要的时候，要进行强制数据类型转换。

void main()
{
    int x = 10;
    int y = 20;

    printf("%f,%d\n", x, y); //输出的第一个为失败的标准“0.00”
                            //第二个为垃圾值
    printf("%f,%d\n", (float)x, y);//强制类型转换
    printf("%d\n", (int)3.5);

    system("pause");
}

(3)赋值操作的数据类型转换

赋值号会自动将等号右边的值，转换为左边的数据类型

    int x=3/2.0;
    int y=(float)3;
    printf("%d,%d",x,y);
    //会有warning提示：数据类型转换可能会丢失数据

1.4进制转换

void main()
{
    int num;
    scanf("%d", &num);
    char str[32];//int的极限4个字节
    _itoa(num, str, 2);//GCC带不带_都可以，VS不行
    printf("%s\n", str);

    _itoa(num, str, 8);//八进制
    printf("%s\n", str);
    //转换之后就是字符串了，强制转换就是垃圾值
    _itoa(num, str, 8);//八进制
    printf("%d\n", (int)str);
    system("pause");
}