20160123.CCPP詳解體系(0002天)

程式片段(01):字元.c
內容概要: 轉義字元

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <Windows.h>

//01.getchar();&putchar();成對使用:
//  (1).使用方式分析:
//      getchar();獲取(命令列|控制檯|螢幕->檔案->網頁)單個字元
//      putchar();輸出(命令韓|控制檯|螢幕->檔案->網頁)單個字元
//  (2).使用注意事項:
//      1).getchar();只要接受到一個字元就立即停止獲取
//          getchar();函式並沒有形式引數,直接呼叫,直接返回值
//      2).putchar();和printf();一樣,不會輸出自動輸出換行符,但是
//          puts();會自動輸出換行符
//      3).putchar();列印的是單個字元,單個字元采用單引號''標識
int main01(void)
{
    char ch = getchar();//獲取一個字元
    putchar(ch);//輸出一個字元
    //printf("");
    //puts("");

    system("pause");
    return 1;
}

//02.兩種讓命令列視窗等待的方式:
//  (1).getchar();等待
//      沒有提示,只要一旦感測到單個字母,立即吸收單個字元並且返回,
//          而且立即結束等待模式
//  (2).system("pause");等待
//      具有提示,提示資訊為"請按任意鍵退出.."
//03.在這裡的字元吸收特點:
//  scanf();吸收了單個整數
//  getchar();吸收了單個字元'\r'-->'\r\n'
//      圖形化特點吸收,圖形化特點列印
//04.將應用程式的執行結果匯入到檔案的特點:
//  匯入的結果為程式生成的結果,而不是使用者輸入程式的結果
int main02(void)
{
    int num = 0;
    scanf("%d", &num);

    getchar();//回車算一個字元,吸收一個回車字元

    //getchar();//吸收一個字元
    system("pause");
    return 1;
}

//04.字元'\a'是一個警告音:
//  (1).警告音不可過快的發出,否則無效
//  (2).具體的警告音由作業系統以及使用者設定有關
//  (3).時間間隔執行採用執行緒睡眠函式Sleep();單位是毫秒(ms)
//      加上迴圈結構可以實現規律間隔的執行某段兒操作
int main03(void)
{
    while (-1)//0與非0
    {
        putchar('\a');//發聲音
        Sleep(1000);
    }

    system("pause");
    return 1;
}

int main04(void)
{
    printf("鋤禾日當午, \n吳偉來跳舞! \n");

    system("pause");
    return 1;
}

//05.採用系統函式system();執行系統當中的應用程式時候:
//  需要注意是否是(x86)標識的資料夾,如果是(x86)標識的資料夾
//  那麼說明該作業系統是x64位的作業系統,因此路徑(x86)前面應當
//  填充一個空格,否則不能正常的執行某個程式
int main05(void)
{
    system("D:\\ProgramFiles\\KuGou\\KGMusic\\KuGou.exe");

    system("pause");
    return 1;
}

//06.   空字元:
//  (1).空字元-->'\0'|''|' '-->同屬於是不可見字元
//      但是'\0'|' '列印效果為一個空格
//      ''列印效果沒有空格-->putchar();不能這麼寫-->至少得是一個空字元
//  (2).'0'-->不是空字元-->屬於可見字元
int main06(void)
{
    //putchar('\0');//空字元,沒有列印效果
    //putchar('');-->不能這麼寫,編譯報錯,至少得是一個空字元
    putchar(' ');//空字元-->putchar('\0');|putchar(' ');效果一致
    putchar('0');

    system("pause");
    return 1;
}

//07.putchar();輸出字元特點分析:
//  (1).進位制字元:
//      '\???'-->字元的ASCII碼值(八進位制)-->實際字元
//      '\x???'-->字元的ASCII碼值(十六進位制)-->實際字元
//  (2).特殊字元的ASCII碼值:
//      '0'-->48
//      'A'-->65
//      'a'-->97
//  (3).單個大小寫英文字母的轉換方式
//      大寫轉小寫:
//          大寫+32
//      小寫轉大寫:
//          小寫-32
int main07(void)
{
    putchar('\101');//\101-->表示八進位制的101-->1*8^0+0*8^1+1*8^2=65
    putchar('\x42');//\x42-->表示十六進位制的42-->2*16^0+4*16^1=66
    //'0'-->48
    //'A'-->67
    //'a'-->97

    system("pause");
    return 1;
}

程式片段(02):data.c
內容概要:變數記憶體原理

#include <stdio.h>

int main01(void)
{
    int a = 10;
    printf("%p \n", &a);//檢視變數a的記憶體地址
    printf("%d", a);

    system("pause");
    return 1;
}

//01.變數表的概念:
//  (1).在宣告變數之前的時候,系統會為應用程式建立一張變數表
//  (2).所有在應用程式當中宣告的變數都會被註冊到變數表當中
//  (3).凡是需要使用到變數的時候,都會去變數表當中查詢該變數
//      如果該變數被註冊了,並且初始化了,則可以進行使用,否則不行
//          如果沒有被初始化,將會讀取到一個被編譯器賦予預設垃圾值的資料
//          作業系統預設情況之下是不會自動清空內容當中的垃圾資料的
//          編譯器檢測到為初始化的變數,就會為變數賦予一個編譯器指定的垃圾值
//              負號(-)表示垃圾,數值過大表示異常資料
//      如果該變數沒有被註冊,也就不能使用,編譯報錯
int main02(void)
{
    int a, b, c;//建立變數表,管理所有的變數

    //不能引用未曾宣告的變數,也就是變數表當中的變數
    //printf("%d \n", d);

    system("pause");
    return 1;
}

//02.在暫存器當中所執行的操作:
//  (1).常量的生成:
//      1).這裡的常量不是const常量(常變數),本質還是變數,表象為常量,處於記憶體當中
//      2).該常量處於程式碼區的符號表當中,生成流程為
//          (1.CPU讀取程式碼區符號表當中的常量
//          (2.在CPU的暫存器當中生成該常量
//  (2).所有的運算操作
//  (3).所有的賦值操作
int main03(void)
{
    int a = 1;
    int b = 2;
    int c;
    printf("a = %p, b = %p, c = %p", &a, &b, &c);

    c = a + b;

    system("pause");
    return 1;
}

//03.賦值操作的特點:
//  (1).賦值的物件必須是變數(C語言)
//      組合語言的賦值物件可以是暫存器
//  (2).變數都是處於在記憶體當中,也就是所謂的操作記憶體
int main04(void)
{
    int a = 3;//初始化:第一次的賦值操作,只能給變數進行賦值操作,變數處於記憶體當中
    //a + 1 = 4;//a+1處於暫存器當中,C語言沒有操作許可權,組合語言具備操作許可權

    int b = 0;
    printf("%p", &b);

    b = a + 1;
    b = a + 2;

    system("pause");
    return 1;
}

//03.所有的常量使用特點:
//  (1).所有的常量起源於程式碼區當中的符號表
//  (2).生成於CPU的暫存器當中
//  (3).C語言不具備操作暫存器的特權,所有無法採用取地址符進行操作
//      C語言當中可以採用內嵌彙編技術
int main05(void)
{
    int a;
    printf("%p \n", &a);
    //變數賦值,都是在暫存器當中的完成

    //a = 10;//程式碼區當中的常量符號表10,100
    //printf("%p", &10);//10這個常量在被操作的時候,其實是出於在暫存器當中
    //由於C語言不具備操作暫存器的特權,所以取地址符無法進行操作

    //組合語言解釋特點:
    __asm
    {
        mov eax, 10//將程式碼區符號表當中的常量移植到暫存器當中
        mov a, eax//在暫存器當中完成賦值操作,用於將暫存器當中的常量賦值給記憶體當中的變數
    }
    printf("a = %d \n", a);

    __asm
    {
        mov eax, a//將記憶體當中變數a的資料讀取到CPU的暫存器當中
        add eax, 5//將暫存器當中讀取到的資料與從程式碼區符號表當中移植進暫存器的資料進行加法操作
        mov a, eax//將暫存器當中進行加法操作之後的最終資料賦值給記憶體當中的變數a
    }
    printf("a = %d \n", a);

    system("pause");
    return 1;
}

程式片段(03):定義變數.c
內容概要:定義變數

#include <stdlib.h>

//01.VC編譯器支援採用中文作為識別符號
//  但是隻支援字串形式的中文
void 鋤禾日當午(){}

//02.C語言當中的識別符號命名規範:
//  1.識別符號的組成元素:
//      下劃線("_")+數字+字母(大小寫)
//  2.識別符號命名法則:
//      (1).見名知其意
//      (2).不能以數字作為開頭
//      (3).不能是關鍵字本身(但可以有關鍵字組成)
//      (4).遵循軟體工程規範
int main(void)
{
    int a;
    const int data;

    //int void
    int main;//建議不要和函式名重名
    int new;//C語言當中允許使用,但是C++當中不允許
    int _ad;

    int c;
    int C;//大小寫不同

    int _;
    int __;
    int ___;
    //識別符號當中的特殊字元只有下劃線("_")
    //int !a;

    char charnum;
    int intnum;
    int a1;
    double a2;
    char a3;//遵循軟體工程規範,一看就懂

    int 從前有一個很噁心的面試官搞的我痛不欲生 = 5;//VC支援中文,但是隻支援字串的中文

    system("pause");
    return 1;
}

程式片段(04):main.c
內容概要:變數為何一定要初始化

#include <stdio.h>
#include <stdlib.h>

//01.變數為何一定要初始化?
//  1.使用未初始化的變數特點:
//      (1).宣告變數的含義:
//          1).軟體程式向作業系統申請記憶體使用許可權
//          2).作業系統為軟體程式賦予記憶體使用許可權
//      (2).作業系統只會負責記憶體使用許可權的分配
//          作業系統不會對記憶體資料進行清理
//          編譯器會檢測是否對變數進行初始化,如果
//          沒有進行初始化,那麼分編譯器特點:
//          VC6.0會賦予一個垃圾數值(負的很大值),定值
//          VS2015會賦予一些隨機值,不定值
//      (3).所謂的記憶體釋放特點:
//          並不是清空記憶體當中的資料,而是軟體程式
//          將對某塊兒記憶體的使用許可權回交給作業系統
//  2.不進行初始化,就會使用到前期程式使用記憶體之後
//      遺留下來的垃圾值,或者編譯器指定的垃圾值
int main01(void)
{
    int num;
    num += 1;

    //error C4700: 使用了為初始化的區域性變數 “num”
    //新老編譯器,新編譯器提示錯誤,老版本不會進行提示
    //垃圾資料

    system("pause");
    return 1;
}

程式片段(05):main.c
內容概要:變數初始化注意事項

#include <stdio.h>
#include <stdlib.h>

//01.未初始化的變數特點:
//  1.C語言老版本的編譯器會編譯通過
//  2.GCC如果沒有開啟C++11支援,會編譯通過
//  3.VC2010之前的版本,會編譯通過
int main(void)
{
  int a = 10;//C語言,老版本的編譯器,GCC如果沒有開啟C++11支援,VC2010之前的版本
  printf("Hello World!!! \n");

  int c = 10;
  return 0;
}

void go()
{
  int a, b, c;//C語言定義變數
  int a1;
  int b1;
  int c1;
  int a2 = 10;
  int a3 = 10, b3 = 20, c3 = 40;
}

程式片段(06):常量.c
內容概要:常量

#include <stdio.h>
#include <stdlib.h>

//01.常量內容解析:
//  1.常量深度解剖:
//      巨集常量(#define)是真正意義上的常量
//          由於其不具備變數層意義,所以一旦定義就不可修改
//      常變數(const)不是真正意義上的常量
//          常變數內部具有變數的含義,加上const
//          只能限制直接意義上的賦值,而不能限制間接意義上的賦值
//  2.注意地址型別的區別:
//      (1).常量地址和變數地址的特點
//      (2).內容的可修改性
//          常量地址所指向的變數不可進行修改
//          變數地址所指向的變數可以進行修改
int main01(void)
{
    const int 吳偉的顏值 = 99;

    //吳偉的顏值 = 67;不能直接進行修改
    printf("%d \n", 吳偉的顏值);
    printf("%p \n", &吳偉的顏值);

    //星號(*)用於根據地址取出指標指向的變數內容
    //(const int *)常量地址型別轉化為變數地址型別
    //方可根據該地址所指向的變數當中的資料
    *(int *)(&吳偉的顏值) = 98;//不算真正意義上的常量
    printf("%d \n", 吳偉的顏值);

    system("pause");
    return 1;
}

//02.巨集常量內容分析:
//  1.所有預編譯指令(井號"#"作為開頭的指令),都沒有分號作為使用結尾
//  2.巨集常量的使用特點:
//      (1).真正意義上的常量
//      (2).修改特點:
//          只有在源頭上面進行巨集常量的修改
//          後期既不能直接修改巨集常量也不能間接修改變巨集常量
//      (3).軟體可擴充性的進行使用
//  3.程式語言的使用特點:
//      C語言操作硬體的級別只能到達記憶體一級
//      組合語言操作硬體的級別可以達到暫存器一級
#define 吳偉的顏值 98
//define不能加分號(";"),加了就會被一起作為整體進行替換
//意義明確,實現批量修改,軟體可擴充一點
int main02(void)
{
    printf("%d \n", 吳偉的顏值);
    //吳偉的顏值 = 100;//對巨集常量進行再次賦值,直接報錯
    //真正意義上的常量,一次賦值,永遠不能直接賦值,也不能間接賦值
    //  只能從源頭進行賦值操作
    //C語言能操作記憶體,不能操作暫存器
    //組合語言同時幹兩個活兒

    system("pause");
    return 1;
}

void go()
{
    printf("%d \n", 吳偉的顏值);
}

程式片段(07):變數交換.c
內容概要:變數交換

#include <stdio.h>
#include <stdlib.h>

int main01(void)
{
    int a = 10;
    int b = 5;

    printf("a = %d, b = %d \n", a, b);

    /*
    //01.這種方式不行:
    //  原因:資料在第一次賦值的時候,就已經發生了資料丟失
    //      變數a的資料完全丟失了,找不回來了,當時有效資料只有變數b
    a = b;
    b = a;
    */

    //02.採用水桶原理進行變數資料交換:
    //  時空複雜度評析:
    //      temp讓空間複雜度+1
    //      三次賦值操作讓時間+3
    //  缺點:
    //      1.資料容易越界
    //      2.非位運算,效率低下
    int temp = a;//temp=10,a=10,b=5
    a = b;//a=5,b=5,temp=10;
    b = temp;//a=5,b=10

    //03.複雜方式,採用a+b記住變數資料原理:
    //  缺點:容易導致資料越界,非位運算效率低下
    a = a + b;
    b = a - b;
    a = a - b;

    //04.最佳方式採用位運算(位移或):
    //  優點:
    //  1.位運算效率高
    //  2.不會出現資料越界
    // 3.沒有增加額外的空間複雜度
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;

    //05.變數資料交換總結:
    //  (+ - * /)會導致資料越界,最安全的做法是採用異或
    printf("a = %d, b = %d \n", a, b);

    system("pause");
    return 1;
}

程式片段(08):進位制.c
內容概要:進位制

#include <stdio.h>
#include <stdlib.h>

//01.整數常量的進製表現形式:
//  預設:十進位制
//  0開頭:八進位制
//  0x|0X開頭:十六進位制
//02.任何進位制形式表現的整數
//  的組成元素不能超過其進位制數
int main01(void)
{
    int num = 012;//整數字首0代表該整數是八進位制形式的整數
    //任何進位制,不允許出現大於或等於進位制數的數字

    int num = 0x12;//整數字首0x代表該整數是十六進位制形式的整數
    printf("%d \n", num);
    printf("%p \n", &num);

    system("pause");
    return 1;
}

程式片段(09):go.c
內容概要:printf();函式解析

#include <stdio.h>
#include <stdlib.h>

//理解語法規則,邏輯嚴密進行
int main01(void)
{
    float fl = 10.9;
    //printf("%d \n", fl);
    //printf();函式不會按格式控制符指定的形式進行型別轉換
    //%d格式控制符表示按照整數的形式解析記憶體中的二進位制資料

    system("pause");
    return 1;
}

int main02(void)
{
    int num = 10;
    printf("%f \n", num);//實數列印

    system("pause");
    return 1;
}

//printf();函式總結:
//  1.理解語法規則,邏輯嚴密進行
//  2.printf();函式不會按照輸出格式控制符所指定的資料形式進行型別轉換
//      不要主觀認為這是由於資料型別轉換導致的結果
//  3.所謂的輸出格式控制符只不過是將記憶體當中的固定二進位制格式資料
//      給按照指定的格式進行資料解析

程式片段(10):二進位制.c+sizeof.c
內容概要:資料型別解析

///二進位制.c
#include<stdio.h>
#include<stdlib.h>

void main1()
{
    int num = -1;
    printf("%p", &num);

    getchar();
}

///sizeof.c
#include <stdio.h>
#include <stdlib.h>

//01.資料型別詳解:
//  1.資料型別決定:
//      (1).記憶體容器的寬度
//      (2).資料解析方式
//          例如:負整數-->補碼;實數-->階碼
//  2.記憶體當中的二進位制資料
//      需要按照指定的方式進行解析,得到相應的解析結果
int main01(void)
{
    printf("%d \n", sizeof(char));
    printf("%d \n", sizeof(int));
    printf("%d \n", sizeof(double));

    //資料型別差別,大小不一樣,解析方式不一樣
    //10010101001
    printf("%d \n", sizeof("123"));//4-->\0
    printf("%d \n", sizeof('A'));//1-->VS2015居然它瞄的是4,居然當成整數進行位元組數的求取

    int num = 10;
    printf("%d \n", sizeof(num));//1

    system("pause");
    return 1;
}

程式片段(11):整數.c
內容概要:int資料型別

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>//整型資料的極限標頭檔案

//01.求取整數的範圍:
//  1.標頭檔案:#include <limits.h>
//  2.巨集指令(XXX_MIN|XXX_MAX)
int main01(void)
{
    int num_min = INT_MIN;
    int num_max = INT_MAX;//資料的計算必須處於極限範圍之內

    printf("num_min = %d, num_max = %d \n", num_min, num_max);

    system("pause");
    return 1;
}

//02.資料溢位現象解釋:
//  1.將整數化解為二進位制的表現形式,
//  2.進行按照指定位元組數的截斷操作
int main02(void)
{
    /*
        1111 1111
    +                  1
      10000 0000
    --------------
      10000 0000
    //擷取一個位元組之後是
    0000 0000-->結果為0
    */
    unsigned char chnum = 255 + 1;//8-->2^8=256-->0~255

    printf("吳偉有%d個女友! \n", chnum);

    system("pause");
    return 1;
}

//03.整數和實數的二進位制表示特點:
//  1.儲存原理不同
//      整數採用補碼形式儲存
//      實數採用階碼形式儲存
//  2.最高位表示符號位相同:
//      0代表正數
//      1代表負數
int main03(void)
{
    char ch = -1;//1111 1111-->減一:1111 1110-->取反:0000 0001-->符號位:1000 00001
    char chx = 3;//0000 0011

    printf("%p, %p", &ch, &chx);
    //整數,實數,第一位0代表正數,1代表負數

    system("pause");
    return 1;
}

程式片段(12):int.c
內容概要:資料在記憶體排列

#include <stdio.h>
#include <stdlib.h>

//01.整數的二進位制解析:
//  1.整數在記憶體以二進位制圖形化的形式體現
//  2.二進位制資料的排列規律:
//      電腦,手機:
//          低位在位元組(節約記憶體的儲存)
//          儲存單位優化
//      伺服器Unix:
//          低位在高位元組(定址效率的不同)
//          定址速度提升(先找資料型別單元,再進行資料匹配動作)
int main01(void)
{
    int num = 1;
    printf("%p \n", &num);
    //0000 0000 0000 0000 0000 0000 0000 0001

    //001
    //002

    //0000 0000
    //0000 0000
    //0000 0000
    //0000 0001

    //0000 0001
    //0000 0000 
    //0000 0000
    //0000 0000

    //01//1000 0000 01
    //02//0000 0000 00
    //03//0000 0000 00
    //04//0000 0000 00

    //0000 0001
    //低位在低位元組,高位在高位元組
    //電腦,手機,低位在低位元組,高位在高位元組
    //伺服器Unix低位在高位元組

    system("pause");
    return 1;
}

程式片段(13):run.c
內容概要:補碼

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

//01.負數不能採用無符號型別的變數進行儲存:
//  1.會造成資料被解析的過大
//  2.無符號型別的變數只能儲存正數
// 負數的二進位制通常很大,因為以1作為開頭
//  所以儲存的時候不能用無符號進行儲存
//  否則儲存的資料實體過大
int main01(void)
{
    unsigned int num = -1;//1111 1111 1111 1111 1111 1111 1111 1111
    printf("%u", num);

    for (int i = 0; i < num; i++)
    {//迴圈10次
        printf("你好天朝! \n");
    }

    system("pause");
    return 1;
}

//02.計算機當中的整數儲存原理:
//  1.所有的整數都採用補碼儲存
//  2.原碼-->反碼-->補碼:
//      正整數的原碼,反碼,補碼一致
//      負整數的原碼,反碼,補碼特點:
//          原碼:該負數所對應的正整數的原碼最高位加符號位(1)
//          反碼:該負數所對應的原碼的符號位不變,其餘為取反
//          補碼:該負數所對應的反碼+1
//  3.採用補碼的優點:
//      提升運算效率,減少不必要的計算操作
//      將以前的多步驟運算進行精簡
//      例如:統一了+-法的差異,全部採用加法,符號位轉到補碼的表示當中
//          舉例:1-1-2-2<==>1+(-1)+(-2)+(-3)-->統一為加法運演算法則
int main02(void)
{
    char ch = -17;//計算機都是補碼儲存,手機,電腦,伺服器也同樣採用補碼進行整數的儲存
    //0001 0001 +17的原碼
    //1001 0001 -17的原碼
    //1111 1110 -17的反碼
    //1111 1111 -17的補碼 EF-->十六進位制
    printf("%p \n", &ch);

    system("pause");
    return 1;
}

//03.有符號和無符號的推理法則:
//  1.-1所對應的記憶體二進位制資料是:
//      1111 1111 1111 1111 1111 1111 1111 1111
//  2.對記憶體二進位制資料的解析方式:
//      %d:按照有符號的解析法則(負數倒推)
//          補碼-->反碼-->原碼-->負數
//          例如:-1的補碼
//              1111 1111 補碼
//              1111 1110 反碼
//              1000 0001 原碼-->就是-1
//      %u:按照無符號的解析法則(整數倒推)
//          補碼=原碼-->證書
//              1111 1111-->就是255
int main03(void)
{
    int num = -1;
    //0000 0000 0000 0000 0000 0000 0000 0001 +1原碼
    //1000 0000 0000 0000 0000 0000 0000 0001 - 1原碼
    //1111 1111 1111 1111 1111 1111 1111 1110 - 1反碼
    //1111 1111 1111 1111 1111 1111 1111 1111 - 1補碼
    printf("%d \n", num);
    printf("%u \n", num);

    system("pause");
    return 1;
}

int main04(void)
{
    printf("INT_MIN = %d, INT_MAX = %d \n", INT_MIN, INT_MAX);

    system("pause");
    return 1;
}

//04.特殊資料的二進位制數值:
//  -1的記憶體二進位制資料全是1
//      按照有符號解析得出-1
//      按照無符號解析就是一個整數最大值
//  越界現象解釋:
//      物極必反的二進位制資料轉換特點
int main05(void)
{
    int num = -1;
    unsigned int data = 42949697295u;//無符號資料 1111 1111 1111 1111 1111 1111 1111 1111全部的是資料,並且按照正整數的方式進行解析
    int num1 = 4294967295u;//等價於32個二進位制的1
    unsigned int data1 = -1;//等價於32個二進位制的1

    printf("%d \n", num);//-1
    printf("%u \n", num);//4294967295
    printf("%d \n", num1);//-1
    printf("%u \n", num1);//4294967295
    printf("%u \n", data);//4294967295
    printf("%d \n", data);//-1
    printf("%u \n", data1);//4294967295
    printf("%d \n", data1);//-1
    printf("%f \n", 1);//printf,不管三七二十一,抓區二進位制資料就解析

    system("pause");
    return 1;
}

int main06(void)
{
    printf("INT_MIN = %d, INT_MAX = %d \n", INT_MIN, INT_MAX);
    printf("INT_MIN = %d, INT_MAX + 1 = %d \n", INT_MIN, INT_MAX + 1);
    printf("INT_MIN - 1 = %d, INT_MAX = %d \n", INT_MIN - 1, INT_MAX);

    printf("UINT_MIN = %d, UINT_MAX = %d \n", 0, UINT_MAX);
    printf("UINT_MIN = %d, UINT_MAX + 1 = %d \n", 0, UINT_MAX + 1);
    printf("UINT_MIN - 1 =%d, UINT_MAX = %d \n", 0 - 1, UINT_MAX);

    system("pause");
    return 1;
}