C语言之基本数据类型

#include <stdio.h>
#include <limits.h>
​
int main(int argc, const char * argv[]){
    //int 最小值
    printf("INT_MIN = %d\n", INT_MIN);  
    //int 最大值
    printf("INT_MAX = %d\n", INT_MAX);
    //unsigned int的最大值
    printf("UINT_MAX = %u\n", UINT_MAX);
}

short a ;

#include <stdio.h>
#include <limits.h>
​
int main(int argc, const char * argv[]){
    //short 最小值
    printf("SHRT_MIN = %d\n", SHRT_MIN); 
    //short 最大值
    printf("SHRT_MAX = %d\n", SHRT_MAX); 
    //unsigned short最大值
    printf("USHRT_MAX = %u\n", USHRT_MAX);
}

//有符号
long a = 100;
//有符号，加上后缀L，表示一个long类型的字面值
signed long int b = 100L;
​
//无符号
unsigned long a = 100;
unsigned long b = 100L;

#include <stdio.h>
#include <limits.h>
​
int main(int argc, const char * argv[]){
    // long 最小值
    printf("LONG_MIN = %ld\n", LONG_MIN); 
    // long 最大值
    printf("LONG_MIN = %ld\n", LONG_MAX); 
    //unsigned long最大值
    printf("ULONG_MAX = %lu\n", ULONG_MAX);
}

long long a = 100;
//加上LL表示long long类型的字面值
long long b = 100LL;

unsigned long long a = 100;
unsigned long long b = 100LL;

#include <stdio.h>
#include <limits.h>
 
int main(int argc, const char *argv[]){
   //long long类型的最小值
   printf("LLONG_MIN = %lld\n", LLONG_MIN);
   //long long类型的最大值
   printf("LLONG_MAX = %lld\n", LLONG_MAX);
   //unsigned long long类型的最大值
   printf("ULLONG_MAX = %llu\n", ULLONG_MAX);
}

#include <stdio.h>
#include <stdbool.h>
 
int main(int argc, const char * argv[]){
    bool a = true;
    bool b = false;
    
    //声明了一个布尔对象c，并用a与b是否相等的比较结果对它初始化
    bool c = a == b;                       //这里c为假
    printf("c = %d\n", c);                //输出c = 0
    
    //用a ! = b（a不等于b）的比较结果给对象c
    c = a ! = b;  
    printf("a! =b的结果：%d\n", c);        //输出1
    
    c = 10 > 5;
    printf("10 > 5? %d\n", c);           //输出1
    
    c = 10 < 5;
    printf("10 < 5? %d\n", c);           //输出0
    
    //0x10000000不为0，为真，赋值为true
    a = 0x10000000;
    printf("a = %d\n", a);                //输出1
    
    //0==0，为假，赋值为false
    b = 0.0;
    printf("b = %d\n", b);                //输出0
}

char a = 'a';

#include <stdio.h>
#include <limits.h>
 
int main(int argc, const char * argv[])
{
    signed char a = 100;                  //声明了一个带符号8位整数对象a
    signed char b = -10;                  //声明了一个带符号8位整数对象b
    printf("a - b = %d\n", a - b);      //结果输出110
 
    unsigned char c = 200;                //声明了一个无符号8位整数对象c
    unsigned char d = 50;                 //声明了一个无符号8位整数对象d
    printf("c - d = %d\n", c - d);      //输出结果150
 
    //输出signed char的最小值
    printf("SCHAR_MIN = %d\n", SCHAR_MIN);
 
    //输出signed char的最大值
    printf("SCHAR_MAX = %d\n", SCHAR_MAX);
 
    //输出unsigned char的最大值
    printf("UCHAR_MAX = %d\n", UCHAR_MAX);
 
    char ch = 'a';                         //声明一个字符对象ch，并用字符’a’对它初始化
    printf("ch = %c\n", ch);             //输出a
 
    //对于多字符的字符字面量，某些编译器会给出警告
    //这里会将int类型的字符字面量’abc’截取其最低字节’c’给对象ch
    //其他高字节部分被舍弃
    ch = 'abc';
    printf("ch = %c\n", ch);             //输出c
 
    //这里不会有警告，并且
    //字符a位于对象s的最低字节位置，字符\0位于对象s的最高字节位置
    int s = '\0cba';
    printf("s = %s\n", (char*)&s);      //输出abc
 
    //八进制数060相当于十六进制数0x30，对应于ASCII码的罗马数字0
    ch = '\060';
    printf("ch = %c\n", ch);             //输出0
 
    //八进制数0101相当于十六进制数0x41，对应于ASCII码的大写字母A
    ch = '\101';
    printf("ch = %c\n", ch);             //输出A
 
    ch = '\x42';                            //十六进制数0x42对应于ASCII码中的大写字母B
    printf("ch = %c\n", ch);             //输出B
 
    //无效的转义符，在Clang中此时ch的值为'8'
    //因为八进制数中的每一位数都是在0到7的范围内
    ch = '\8';
 
    //无效的转义符，在Clang编译器中直接编译报错
    //因为字母g不是一个能表达十六进制数的有效字符
    ch = '\xg0';
 
    //输出char类型的最小值
    printf("CHAR_MIN = %d\n", CHAR_MIN);
 
    //输出char类型的最大值
    printf("CHAR_MAX = %d\n", CHAR_MAX);
}

//e或E都是一样的意思，不同的写法
3e5   =  3*10^5
3E5   =  3*10^5
 
6e-3  =  6*10^-3
6E-3  =  6*10^-3

0x3P2      =  0x3*2^2
0x3.5P-3   =  0x3.5*2^-3

0x30.8p-2
 
0x30.8：这是十六进制下的浮点数表示方式，其中0x表示这是一个十六进制数。30是小数点前的部分，而.8是小数点后的部分。
 
p-2：这是表示指数的部分，其中p代表“power”或“power of”，用于指定指数。这里的-2表示指数是-2。
 
分离整数和小数部分：
 
整数部分：0x30（即十进制的48）
 
小数部分：.8（即十六进制下的0.5，因为8是16的一半）
 
合并并转换为十进制：
 
首先将整数部分和带小数部分的十六进制数合并（不包括前面的0x和后面的p-2）：30.8
 
然后转换为十进制：
 
整数部分：48
 
小数部分：0.5（因为8在十六进制中是16的一半）
 
合并后：48 + 0.5 = 48.5
 
应用指数：
 
根据指数p-2，我们需要将48.5乘以2的-2次方。
 
2的-2次方等于0.25（即1/4）。
 
因此，48.5乘以0.25等于12.125。
 
最终结果
 
所以，0x30.8p-2在十进制下等于12.125。

#include <stdio.h>
#include <float.h>
 
int main(int argc, const char * argv[]){
    //定义一个单精度浮点数对象f
    float f = -3.5E+3f;  //f的值为3.5 * 1000 = -3500.0。这里的+表示正号，可省
    printf("f = %f\n", f);
 
    f = .25f;                       //f的值为0.25
    printf("f = %f\n", f);
 
    f = -0x5p+10f;                 //f的值为-5 * 1024 = -5120
    printf("f = %f\n", f);
 
    //定义了一个双精度浮点对象d
    double d = -100.;             //d的值为-100.0
    printf("d = %f\n", d);
 
    d = -1200e-5;                  //d的值为-1200 * 0.00001 = -0.012
    printf("d = %f\n", d);
 
    d = 0x30.8p-2;                 //d的值为0x30.8 * 0.25 = 48.5 * 0.25 = 12.125
    printf("d = %f\n", d);
 
    //定义一个long double类型的对象g
    long double g = -0x3.5P0L;  //g的值为-0x3.5 * 1 = -3.3125
    printf("g = %Lf\n", g);
 
    g = 0x18.F8P2L * 2E3L;       //(24+0.96875)*4 * 2*1000 = 199750.0
    printf("g = %Lf\n", g);
 
    printf("long double size is: %zu bytes\n", sizeof(g));
 
    //以下都是用浮点数的科学计数法来打印出各种类型浮点数的最大、最小值
    printf("float min value is: %g\n", FLT_MIN);
    printf("float max value is: %g\n", FLT_MAX);
 
    printf("double min value is: %g\n", DBL_MIN);
    printf("double max value is: %g\n", DBL_MAX);
 
    printf("long double min value is: %Lg\n", LDBL_MIN);
    printf("long double max value is: %Lg\n", LDBL_MAX);
}