#include<stdio.h>
#include<limits.h>
void main(){
    unsigned  long a = 200 * 300 * 400 * 500;// 12 000 000 000（120亿）
    printf("%lu\n",a);
}    

[root@jordy ~]# gcc -o /tmp/limit /tmp/limit.c 
/tmp/limit.c: In function ‘main’:
/tmp/limit.c:4:42: warning: integer overflow in expression [-Woverflow]
   unsigned long long a = 200 * 300 * 400 * 500;
                                          ^
[root@jordy ~]# 
[root@jordy ~]# /tmp/limit 
18446744072824649728
或者提示
Overflow in expression; result is -884901888 with type 'int' [-Winteger-overflow]


➜  /tmp cat /tmp/ulong.c
#include<stdio.h>
#include<limits.h>
int main(){
	printf("%d\n",(int)sizeof(long));
	printf("%d\n",(int)sizeof(long long));
	printf("%d\n",(int)sizeof(unsigned long long));
}


➜  /tmp gcc -o ulong /tmp/ulong.c
➜  /tmp
➜  /tmp ./ulong
8
8
8


➜  tmp cat char.c
#include<stdio.h>
int main(){
	char i = 128;
	printf("%d\n",i);
}
➜  tmp
➜  tmp gcc -o c char.c
char.c:3:11: warning: implicit conversion from 'int' to 'char' changes value from 128 to -128 [-Wconstant-conversion]
        char i = 128;
             ~   ^~~
1 warning generated.


[root@jordy ~]# gcc -o c /tmp/c.c
[root@jordy ~]# 
[root@jordy ~]# cat /tmp/c.c
#include<stdio.h>
int main(){
    char i = 128;
    printf("%d\n",i);
}
[root@jordy ~]# 
[root@jordy ~]# gcc -o c /tmp/c.c
[root@jordy ~]# 
[root@jordy ~]# 
[root@jordy ~]# ./c
-128

对于有符号的char[-128,127]：   
mac上给赋值128，编译或报错的时候就直接提示越界了，  
但是linux下可以输出结果，本质也是越界了，所以输出-128

#include <bits/wordsize.h>

/* We don't have #include_next.
   Define ANSI <limits.h> for standard 32-bit words.  */

/* These assume 8-bit `char's, 16-bit `short int's,
   and 32-bit `int's and `long int's.  */

/* Number of bits in a `char'.  */
#  define CHAR_BIT  8

/* Minimum and maximum values a `signed char' can hold.  */
#  define SCHAR_MIN (-128)
#  define SCHAR_MAX 127

/* Maximum value an `unsigned char' can hold.  (Minimum is 0.)  */
#  define UCHAR_MAX 255

/* Minimum and maximum values a `char' can hold.  */
#  ifdef __CHAR_UNSIGNED__
#   define CHAR_MIN 0
#   define CHAR_MAX UCHAR_MAX
#  else
#   define CHAR_MIN SCHAR_MIN
#   define CHAR_MAX SCHAR_MAX
#  endif


[root@jordy ~]# getconf WORD_BIT
32
[root@jordy ~]# 
[root@jordy ~]# 
[root@jordy ~]# getconf  LONG_BIT
64
[root@jordy ~]# 
[root@jordy ~]# 
[root@jordy ~]#  uname -r
3.10.0-957.21.3.el7.x86_64

 86 /* Minimum and maximum values a `signed long int' can hold.  */
 87 #  if __WORDSIZE == 64
 88 #   define LONG_MAX 9223372036854775807L
 89 #  else
 90 #   define LONG_MAX 2147483647L
 91 #  endif
 92 #  define LONG_MIN  (-LONG_MAX - 1L)
 93 
 94 /* Maximum value an `unsigned long int' can hold.  (Minimum is 0.)  */
 95 #  if __WORDSIZE == 64
 96 #   define ULONG_MAX    18446744073709551615UL
 97 #  else
 98 #   define ULONG_MAX    4294967295UL
 99 #  endif

#include<stdio.h>
#include<limits.h>
void main(){
    printf("%lu,%lu\n",LONG_MIN,ULONG_MAX);

    printf("%ld,%ld\n",LONG_MIN,LONG_MAX);
}

[root@jordy ~]# ./limit 
9223372036854775808,18446744073709551615
-9223372036854775808,9223372036854775807

#include<stdio.h>
typedef unsigned char *byte_pointer;

void show_bytes(byte_pointer start ,int len) {
    int i;
    for(i=0;i<len;i++){
        printf("%.2x",*(start + i));//*(start + i) 等于 start[i]
    }
    printf("\n");
}
void show_int(int x){
    show_bytes((byte_pointer)&x,sizeof(int));
}

void show_float(float x){
    show_bytes((byte_pointer)&x,sizeof(float));
}

void show_pointer(void *x){
    show_bytes((byte_pointer)&x,sizeof(void *));
}

int main(){
    int a = 5;
    show_int(a);
    float b = 40.2;
    show_float(b);
    int *p = &a;
    show_pointer(p);
}

int bytes_num_of_int_type = sizeof(int);
float bytes_num_of_float_type = sizeof(float); 

typedef INT_POINTER int;
typedef ONLINE_PEOPLE struct OnlinePeople;
struct OnlinePeople{
	char *name;
	int age;
	int online_status;
}

首先声明清楚下，在C语言中，char类型可以用来存储单个字符，因为单个字符刚好占用一个字节；所以char类型也可以用来定义单个字节的整型变量，如
//定义一个有符号char变量；取值范围为[-128,127]
char int_var1 = 127;
//定义一个无符号char变量；取值范围为[0,255]
unsigned char int_var2 = 255;
//说实话，C语言虽然不像Java或Go等语言，用额外的一个关键字byte来声明字节变量或数组，而是直接很省事的用char来表示了占用一个字节的变量；
//但对于初学者而已，其实很容易搞混或造成难以理解；就如上面的举例中，好多C语言的教材中会将，可以将单个字符存储在char类型的变量中；
//也可以将单字节的整数存储在char类型的变量中，对于一个初学计算机或编程的人来讲，就会很迷惑，因可以的去区分char到底是字符类型还是整型；
//因为初学计算机的新手，也许刚好是一位还未来得及了解计算机发展历史、CS课程、以及ASCII编码等知识的人。
//这是个人观点，仅供参考！ 
因此这里强制转换的目的在于：无论&x以前是什么类型，这里统统转换为char *类型，这样的话，在循环遍历的时候，指针每加1，就表示移动一个字节长度的地址。   
从而实现了逐个打印出该变量的每个字节的目的。额外记着，上述例子中start[i]等价于*(start + i)，
这是c语言的基础，可以额外补充性学习C语言中数组名称的含义。


#include<stdio.h>
typedef char* byte_pointer;

void show_bytes(byte_pointer obj,int byte_num){
        int i;
        for(i=0;i<byte_num;i++){
            printf("%.2x",obj[i]);
        }
        printf("\n");
}
void show_int(int a){
    show_bytes((byte_pointer)&a,sizeof(int));
}

void show_float(float f){
    show_bytes((byte_pointer)&f,sizeof(float));
}

void show_pointer(void * p){
    show_bytes((byte_pointer)&p,sizeof(void *));
}
int main(){
    int a = 15;
    show_int(a);

    float b = (float)a;
    show_float(b);

    int *p = &a;
    show_pointer(p);
}

 gcc -o /tmp/show_byte  /tmp/show_bytes.c
 
 [root@jordy tmp]# /tmp/show_byte 
0f000000
00007041
fffffffc50ffffff88ffffff92fffffffd7f0000


/*
0f   00  00  00 -> 00 00 00 0f 
00  00  70  41  -> 41 70 00 00   
00000000 00000000 00000000  00001111
0100 0001 01110000   00000000  00000000 
在语言层面，可以很方便开发者玩转二进制的语言中，go语言的binary包提供的功能相当实用，然后开启愉快的钻研之旅吧。
https://golang.org/pkg/encoding/binary 
https://golang.org/pkg/encoding/binary/#ByteOrder

A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.
*/
type ByteOrder interface {
    Uint16([]byte) uint16
    Uint32([]byte) uint32
    Uint64([]byte) uint64
    PutUint16([]byte, uint16)
    PutUint32([]byte, uint32)
    PutUint64([]byte, uint64)
    String() string
}
Example(Get)
package main
import (
	"encoding/binary"
	"fmt"
)
func main() {
	b := []byte{0xe8, 0x03, 0xd0, 0x07}
	x1 := binary.LittleEndian.Uint16(b[0:])
	x2 := binary.LittleEndian.Uint16(b[2:])
	fmt.Printf("%#04x %#04x\n", x1, x2)
}
//Example(Put) 
package main
import (
	"encoding/binary"
	"fmt"
)
func main() {
	b := make([]byte, 4)
	binary.LittleEndian.PutUint16(b[0:], 0x03e8)
	binary.LittleEndian.PutUint16(b[2:], 0x07d0)
	fmt.Printf("% x\n", b)
}
package main
import (
    "encoding/binary"
    "fmt"
)
func main() {
    b := []byte{0xe8, 0x03, 0xd0, 0x07}
    x1 := binary.LittleEndian.Uint16(b[0:])
    x2 := binary.LittleEndian.Uint16(b[2:])
    littleEndian := binary.LittleEndian.Uint32(b[0:])
    bigEndian := binary.BigEndian.Uint32(b[0:])
    fmt.Printf("%#04x %#04x %#08x %#08x\n", x1, x2, littleEndian, bigEndian)
}

#include<stdio.h>
#include<string.h>
typedef char* byte_pointer;
void show_bytes(byte_pointer start,int byte_num){
    int i;
    for(i=0;i<byte_num;i++){
        printf("%.2x",*(start + i));
    }
    printf("\n");
}
void show_int(int x){
    show_bytes((byte_pointer)&x,sizeof(int));
}
void show_float(float y){
    show_bytes((byte_pointer)&y,sizeof(float));
}
void show_pointer(void * p){
    show_bytes((byte_pointer)&p,sizeof(void *));
}
void show_str(char * s){
    show_bytes((byte_pointer)s,strlen(s));
}
void test_show_bytes(int x){
    show_int(x);
    show_float((float)x);
    show_pointer(&x);
}
void test_string_show_bytes(char * s){
    show_str(s);
}
int main(){
    test_show_bytes(12345);
    char *s = "ABCDE";
    test_string_show_bytes(s);
}

#include<stdio.h>
int main(){
    int a = 0x98FDECBA;
    int res = (a | 0xffffff00);
    printf("%x\n",res);
    int res2 = (a & 0xffffff00)  + ~(a & 0xFF);
    printf("%x\n",res2);
    int res3 = (a & 0xffffff00);
    printf("%x\n",res3);
}

#include<stdio.h>
int main(){
    if (-1 < 0U) {
        printf("-1 小于 0 \n");
    }else{
        printf("-1 大于 0 \n");
    }
}