C語言基礎總結 分類： iOS學習 c語言基礎 2015-06-11 10:08 23人閱讀 評論(0) 收藏

  //欲練此功必先自宮!!!  
  //第一天:C語言的基礎
    //進制
    //2進制, 10進制, 8進制, 16進制
    //注:8進制數前加0, 16進制數前加0x
    
    //進制轉換:
    //10 -> n: 連除到取餘
    //n -> 10: 按權求和法(基數, 位權)
    //n -> n: 1個8進制位 = 3個2進制位, 1個16進制位 = 4個2進制位
    
    //字節
    //1字節 = 8位2進制
    
    //單行註釋: //
    //多行註釋: /* */
    //注:註釋不參與程序編譯, 能夠出如今任何位置
    
    //main函數: 是程序入口, 只能有一個
    
    //數據類型
    //基本類型: 1.整型: short int long 2.浮點型: float double 3.字符型: char
    //構造類型: 1.數組[] 2.結構體struct 3.枚舉enum
    //指針類型: *
    //空類型: void
    
    //變量
    //定義: 數據類型 變量名 = 初值
    //注: 變量要先定義, 才能使用
    
    //變量名的命名規範
    //1.由數字, 字母, 下劃線構成, 不能以數字開頭
    //2.在同一做用域內, 不能重名
    //3.不能用系統的關鍵字(看顏色)
    //4.見名知意(不用使用拼音, 漢字, 中英交叉)
    //5.小駝峯法
    
    //常量
    //1, 19.9, 'c', "abc"
    
    //運算符(單目, 雙目, 三目)
    //1.賦值運算符: =
    //2.算術運算符: +, -, *, /, %, ++, --
    //3.複合運算符: +=, -=, *=, /=, %=
    //4.邏輯運算符: &&, ||, !
    //5.關係運算符: >, >=, <, <=, ==, != (BOOL)
    //6.條件運算符: ? :
    
    //表達式 = 變量 + 常量 + 運算符
    
    //語句: 程序執行的最小單元(見到;即語句)
    
    //printf("Hi");
    //printf("%d", a);
    
    //格式化輸出符
    //char           %c    %d
    //short          %hd
    //int            %d
    //long           %ld
    //float          %f
    //double         %lf
    //BOOL           %d
    //字符串          %s
    //unsigned int   %u
    //unsigned long  %lu
    //八進制          %o
    //十六進制        %x
    //指針            %p
    //以回車結束輸入    %[^\n]
    //%-10.2f:
    
    //轉義字符
    //換行  \n
    //tab  \t
    //%    %%
    //"    \"
    // \   \\
    
    //scanf("%d", &a);
    //注: ""內不能加\n, 後面寫變量的地址
    
    //次日: 分支結構
    //C語言的三大結構: 順序結構, 分支結構, 循環結構
    
    //if
    //第一種形式
    /*
     if (<#condition#>) {
     <#statements#>
     }
    */
    
    //第二種形式
    /*
    if (<#condition#>) {
        <#statements#>
    } else {
        <#statements#>
    }
    */
    
    //第三種形式
    /*
    if (<#condition#>) {
        <#statements#>
    } else if (<#expression#>) {
        <#statements#>
    } else {
        <#statements#>
    }
    */
    
    //注: 三種形式能夠相互嵌套使用


    //enum
    enum 枚舉名{
枚舉值1,
        枚舉值2,
…
    }
    枚舉值:枚舉值默認從零開始,也能夠指定數值;
    枚舉值常與switch合用
    
    //switch
    
    /*
    switch (<#expression#>) {
        case <#constant#>:
            <#statements#>
            break;
        case <#constant#>:
            <#statements#>
            break;
        default:
            break;
    }
    */
    //注:1.switch後的表達式是整型表達式
    //2.case後面的值是常量
    //3.case和default中須要加break
    //4.若是在case中定義變量, 須要case內部添加括號
   /*
    int a = 10;
    switch (a) {
        case 10:
        {
            int b = 100;
            break;
        }
        default:
            break;
    }
    */
    
    /*
    //const用於修飾那一部分不能修改
    //判斷步驟
    //1.去掉數據類型
    //2.const後的就是不能修改的部分
    int a = 10;
    int b = 100;
    const int *p1 = &a;//*p1不能修改
    int const *p2 = &a;//*p2不能修改
    int * const p3 = &a;//p3不能修改
    const int * const p4 = &a;//p4和*p4不能修改
    */
    
    /*
    int max = 0, a = 5, b = 10;
    max = a > b ? a : b;
    
    if (a > b) {
        max = a;
    } else {
        max = b;
    }
    */
    
    //第三天:循環結構
    
    //for循環
    /*
    for (<#initialization#>; <#condition#>; <#increment#>) {
        <#statements#>
    }
     */
    
    //while循環
    /*
    while (<#condition#>) {
        <#statements#>
    }
    */
    
    //do...while循環
    /*
    do {
        <#statements#>
    } while (<#condition#>);
    */
    
    //知道循環的次數, 使用for循環
    //知道循環結束的條件, 使用while循環
    //do...while循環使用比較少
    
    //隨機數公式[a, b]
    //arc4random() % (b - a + 1) + a
    
    //break: 跳出本層循環
    //continue: 跳出本次循環, 加速循環的執行
    //return: 跳出函數, 返回數值
    
    //第四天:數組
    //用於存儲多個相同數據類型的有序隊列
    
    //數據類型 數組名[元素個數] = {};
    //注: 元素個數能夠省略, 由後面賦值來決定元素個數
    
    //數值的使用
    //1.數組不可以直接參與運算
    //2.數組中的元素能夠參與運算
    
    //元素的訪問
    //1.經過下標訪問數組元素
    //2.下標從0開始, 到(元素個數 - 1)結束
    
    //遍歷數組
    //遍歷n維數組, 要嵌套n層for循環
    
    //冒泡排序
    /*
    int array[5] = {12, 20, 3, 48, 5};
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    */
    
    //字符數組 = 字符串
    //打印字符串: %s
    
    //字符串函數
    //strlen: 字符串長度
    /*
    char string[10] = "iPhone";
    printf("%lu\n", strlen(string));//長度:6
    printf("%lu\n", sizeof(string));//字節數:10
    */
    //strcpy: 字符串拷貝
    //strcat: 字符串拼接
    //strcmp: 字符串比較
    
    /*
    int c = 5;
    int array[c] = {};//數組定義時, 元素個數不能使用變量
    */
    
    //第五天: 多維數組
    //定義
    //數據類型 數組名[維度1][維度2][...] = {};
    
    //字符數組, 一維數組
    //字符串, 一維數組
    //字符串數組, 二維數組
    
    /*
    char string[5][20] = {"zhangsan", "lisi", "asan", "erhu", "guangtouqiang"};
    //冒泡排序(a-z)
    
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - 1 - i; j++) {
            if (strcmp(string[j], string[j + 1]) > 0) {
                char temp[20] = {0};
                strcpy(temp, string[j]);
                strcpy(string[j], string[j + 1]);
                strcpy(string[j + 1], temp);
            }
        }
    }
    */
    
    //第六天: 函數
    //具備特定功能的代碼段
    
    //一個嚴格的函數包括
    //1.函數聲明
    //2.函數定義
    //3.函數調用
    
    //函數定義
    /*
    返回值類型 函數名(參數類型 參數名, ...) {
    
    }
    */
    //注: 1.沒有返回值, 使用void
    //2.沒有參數, 括號不能省略
    //3.參數類型相同, 類型不能省略
    //4.函數之間是並列的關係, 不能嵌套定義
    
    //函數調用
    //函數名(實參, ...)
    
    //實參: 函數調用時的參數
    //形參: 函數定義時的參數
    //注: 函數調用時, 把實參的值拷貝給形參
    
    //主調函數: 在函數a中調用了函數b, 函數a就稱爲函數b的主調函數
    
    //局部變量: 定義在函數體內部的變量
    //全局變量: 定義在函數體外部的變量
    //注: 儘可能不要使用全局變量
    
    //函數能夠嵌套調用
    
    //遞歸函數, 必定要有出口
    
    //*.h中寫 函數聲明
    //*.m中寫 函數定義
    //若是在其餘文件使用函數, 須要引入頭文件
    
    //數組做爲函數的參數
    //1.,數組名[],數組的元素個數省略
    //2.多添加一個參數, 用於傳遞數組元素個數
    
    //第七天: 結構體
    //結構體是用戶自定義的數據類型
    
    //結構體聲明
    /*
    struct <#struct name#> {
        <#struct fields#>
    };
    */
    //注:1.結構體名字用小駝峯法
    //2.每個成員變量以分號結束
    //3.結構體聲明寫在.h中
    
    //結構體變量
    //struct 結構體名 變量名 = 初值
    //注: 1.結構體變量能夠直接參與運算
    //2. 結構體變量不可以直接打印
    
    //結構體變量的成員變量
    //使用點語法訪問
    
    //使用typedef對結構體重命名
    //typedef 原結構體名 新結構體名
    //注: 新結構體名要是大駝峯法
    
    //結構體所佔的字節數
    //1.最大數據類型的倍數
    //2.交換成員變量的位置, 會影響結構體所佔的字節數
    
    //char   1
    //short  2
    //int    4
    //long   4或8
    //float  4
    //double 8
    //指針    4或8
    
    //結構體和數組相互嵌套使用
    //1.結構體聲明時, 成員變量是數組類型
    //2.數組內存放的都是結構體類型的變量(結構體數組)
    
    //第8天: 指針
    //內存的地址編號
    
    //&: 取地址運算符
    //%p 打印地址
    
    //指針變量: 用於存儲地址
    //數據類型 *變量名 = NULL
    //注:1. 指針變量所佔的字節數和數據類型無關, 只有操做系統的位數相關
    //2.數據類型決定*p取內容時, 取多少個字節
    //3.數據類型決定p + 1時, 跳轉多少個字節
    
    //*: 取值運算符
    
    //指針變量被從新賦值, 意味着指針變量重定向
    
    //指針的運用
    //指針在數組中的運用
    
    //數組的名字就是數組的首地址
//    int a[5] = {1, 2, 3, 4, 5};
    //*a        a[0]
    //*(a + 1)  a[1]
    //*(a + i)  a[i]
    
//    int *p = a;
    
    //p 和 a 的區別
    //1. 數組的名字a是一個常量指針, 不能重定向(修改)
    //2. sizeof, p: 求指針所佔的字節數; a: 求數組所佔的字節數
    
    //指針在字符串中的運用
//    char string[] = "iOS";
//    printf("%s\n", string);
//    printf("%s\n", string + 1);
//    
//    char *q = string;
//    printf("%s\n", q);
    
    //第9天: 指針高級
    
    //指針數組: 數組中元素類型是指針類型
    int a = 10;
    int b = 20;
    int c = 30;
    
    int *p[3] = {&a, &b, &c};
    //p[0]  &a  *p
    //p[1]  &b  *(p + 1)
    //p[2]  &c  *(p + 2)
    
    //*p[0]  a  *(*p)
    //*p[1]  b  *(*(p + 1))
    //*p[2]  c  *(*(p + 2))
    
    //指針做爲函數的參數
    //做用: 在函數內部修改外部變量的值
    //(int array[], int count)
    //(int *array, int count)
    
    //指針在結構體變量中的使用
    //定義一個結構體指針變量 指向 結構體變量的首地址
    //能夠用->(指向操做符), 訪問結構體的成員變量
    
    //指針在結構體數組中的使用
    struct student {
        char name[20];
        int age;
        float score;
    };
    typedef struct student Student;
    
    Student array[3] = {
        {"zhangsan", 18, 59.9},
        {"lisi", 20, 69},
        {"wangmazi", 40, 30}
    };
    
    //array[0].name  (*array).name
    //array[1].name  (*(array + 1)).name
    //array[2].name  (*(array + 2)).name
    
    //array->name
    //(array + 1)->name
    //(array + 2)->name
    
    //第10天: 動態內存分配
    //內存的五大分區(地址編號由高到底)
    //1.棧區(局部變量, 系統控制)
    
    //2.堆區(由開發人員手動申請, 手動釋放)
    //申請 malloc
    //釋放 free  p = NULL
    
    //3.靜態全局區(全局變量和static修飾的變量, 系統控制)
    //static變量特色
    //a. 存在靜態全局區
    //b. 只能被初始化一次
    //c. 沒有賦初值, 默認爲0
    
    //4.常量區(常量, 系統控制, 常量區的內容是隻讀的)
    
    //5.代碼區(函數,語句, 系統控制)
    
    //第11天: 函數指針
    //函數的名字就是函數的首地址
    
    //函數指針類型肯定的步驟
    //1.把函數名換(*)
    //2.去掉函數體和參數名
    //int (*)(int, int)
    
    /*
    int printHello(int a, int b) {
        
    }
    */
    
    //函數指針變量
    //int (*p)(int, int) = NULL
    //注: 變量名寫在*後面
    
    //使用typedef重命名函數指針類型
    //typedef int (*Type)(int, int)
    //注: 新類型名, 寫在*後面
    
    //Type p = NULL
    
    //指針指向函數的首地址
    //p = printHello;
    
    //printHello(3, 4)
    //p(3, 4)
    
    //回調函數: 使用函數指針變量調用函數
    
    //函數指針變量做爲函數的參數, 函數能夠實現多種功能
    //前提: 函數指針類型相同


    //宏
    //無參宏 只作簡單地替換
    //有參宏 #define kSum(A,B) ((A)+(B))
    //表達式中的每個參數加括號,整個表達式也要加括號


    //條件編譯
    //三種條件編譯
/*
#ifdef   標識符
 代碼段1
 #else 
 代碼段2
 #endif
若是 標識符 被 #define 過 ，編譯器編譯代碼段1，不然編譯代碼段2。


#ifndef   標識符
 代碼段1
 #else
 代碼段2
 #endif
若是 標識符 未被 #define 過 編譯器編譯代碼段1，不然編譯代碼段2。

#if 常量表達式
 代碼段1
 #else
 代碼段2
 #endif
若是 常量表達式結果 非0  編譯器編譯代碼段1，不然編譯代碼段2。
三種形式同樣,之後主要用於版本控制;
*/
    //經前人總結,若不自宮也能成功!!!

版權聲明：本文爲博主原創文章，未經博主容許不得轉載。