{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Week16.ipynb","provenance":[],"collapsed_sections":[],"authorship_tag":"ABX9TyMRzIhe2O67lORqjqbLzsbR"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#第十六週上課內容"],"metadata":{"id":"9xoK4OIjIfZA"}},{"cell_type":"markdown","source":["###GitHub 教材參考資料\n","\n","[在程式執行期間取得記憶體](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%201#%E5%9C%A8%E7%A8%8B%E5%BC%8F%E5%9F%B7%E8%A1%8C%E6%9C%9F%E9%96%93%E5%8F%96%E5%BE%97%E8%A8%98%E6%86%B6%E9%AB%94)\n","\n","\n","[在程式執行期間取得記憶體練習](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%201#%E5%9C%A8%E7%A8%8B%E5%BC%8F%E5%9F%B7%E8%A1%8C%E6%9C%9F%E9%96%93%E5%8F%96%E5%BE%97%E8%A8%98%E6%86%B6%E9%AB%94-01)\n","\n","[C Structures](https://github.com/htchen/i2p-nthu/tree/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/Supplementary%20Material%202#c-structures)\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["# Example 1\n","\n","## 在程式執行期間取得記憶體\n","[C reference 對於 malloc 的說明](http://en.cppreference.com/w/c/memory/malloc)  \n","[C reference 對於 free 的說明](http://en.cppreference.com/w/c/memory/free)  \n","\n","有的時候，我們需要在執行的時候動態分配記憶體  \n","此時可以使用`malloc`跟`free`進行記憶體的分配與釋放  \n","\n","`void* malloc( size_t size )`  \n","*   *size*  \n","    要分配的記憶體大小，以 byte 為單位  \n","*   *回傳值*  \n","    如果成功的話，回傳的指標是指向分配的的記憶體的開頭位址  \n","    如果失敗的話，回傳一個空指標 NULL\n","\n","`void free( void* ptr )`  \n","*   *ptr*  \n","    要釋放的記憶體的指標，必須是當初分配某塊空間時拿到的那個位址；如果`ptr`為`NULL`，則此函式不會做任何事情  \n","    譬如呼叫`malloc(16);`以後拿到的位址是`0x8BADF00D`，之後若想要將這塊塊記憶體回收  \n","    在呼叫`free`時必須傳入`0x8BADF00D`，不能是`0x8BADF00F`或其他不是由相關記憶體分配函式所回傳的位址  \n","\n","> Note:  \n","> `void*`的意思是指向不特定的型別，通常用來記錄某個實體是位在記憶體的哪裡  \n","> 所以針對`void*`是不能進行運算及間接引用  \n","> 在轉型時要特別注意，通常是建議如果將`T*`轉為`void*`，最後要間接引用時，應轉回`T*`而非其他型別  \n","> `int*`->`void*`->`int*`會得到與原本相同的位址，最後間接取值時會正確  \n","> `int*`->`void*`->`float*`不一定會得到與原本相同的位址，最後間接取值時的結果也不一定會正確  \n","> [Stack Overflow 關於指標轉換的問答](https://stackoverflow.com/questions/4810417/c-when-is-casting-between-pointer-types-not-undefined-behavior)  \n","> [Stack Overflow 關於 void* 轉換的問答](https://stackoverflow.com/questions/20469958/c-when-is-casting-void-pointer-needed) \n"," \n"],"metadata":{"id":"cTi0xWPLbuIt"}},{"cell_type":"code","source":["%%writefile E16_01.c\n","\n","# include <stdio.h>\n","# include <stdlib.h>\n","int main(void)\n","{\n","   double * ptd;\n","   int array_size, i;\n"," \n","   printf(\"How many doubles do you want? \");\n","   scanf(\"%d\", &array_size);\n","   ptd = (double *) malloc(array_size * sizeof (double));\n","   if (ptd == NULL) {\n","      printf(\"Memory allocation failed.\\n\");\n","      exit(EXIT_FAILURE);\n","   }\n","\n","   for (i = 0; i < array_size; i++) {\n","      ptd[i] = (double) rand() / RAND_MAX;\n","   }\n","   \n","   for (i = 0; i < array_size; i++) {\n","      if (ptd[i] > 0.5)\n","         printf(\"%d: %f\\n\", i, ptd[i]);\n","   }\n","\n","   free(ptd);\n","\n","   return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"CcT38PbomdpD","executionInfo":{"status":"ok","timestamp":1653995492540,"user_tz":-480,"elapsed":527,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"f5444b48-e818-4212-b84b-ff64f1947475"},"execution_count":29,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_01.c -o E16_01 -Wall\n","./E16_01"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"W0zHBHKxmnnh","executionInfo":{"status":"ok","timestamp":1653995523659,"user_tz":-480,"elapsed":4820,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"5f2a9771-e9fc-43d0-8ea7-03ba98e59a0d"},"execution_count":31,"outputs":[{"output_type":"stream","name":"stdout","text":["How many doubles do you want? 100\n","0: 0.840188\n","2: 0.783099\n","3: 0.798440\n","4: 0.911647\n","7: 0.768230\n","9: 0.553970\n","11: 0.628871\n","13: 0.513401\n","14: 0.952230\n","15: 0.916195\n","16: 0.635712\n","17: 0.717297\n","19: 0.606969\n","23: 0.804177\n","28: 0.998925\n","30: 0.512932\n","31: 0.839112\n","32: 0.612640\n","34: 0.637552\n","35: 0.524287\n","37: 0.972775\n","39: 0.771358\n","40: 0.526745\n","41: 0.769914\n","43: 0.891529\n","46: 0.807725\n","47: 0.919026\n","49: 0.949327\n","50: 0.525995\n","53: 0.663227\n","54: 0.890233\n","61: 0.970634\n","62: 0.902208\n","63: 0.850920\n","65: 0.539760\n","67: 0.760249\n","68: 0.512535\n","69: 0.667724\n","70: 0.531606\n","73: 0.931835\n","74: 0.930810\n","75: 0.720952\n","77: 0.738534\n","78: 0.639979\n","80: 0.687861\n","83: 0.880075\n","84: 0.829201\n","87: 0.893372\n","89: 0.686670\n","90: 0.956468\n","91: 0.588640\n","92: 0.657304\n","93: 0.858676\n","95: 0.923970\n","97: 0.814767\n","98: 0.684219\n","99: 0.910972\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":31}]},{"cell_type":"markdown","source":["# Example 2\n","\n","## 動態產生二維陣列\n","\n","![image.png](data:image/png;base64,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)\n","\n","![image.png](data:image/png;base64,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)"],"metadata":{"id":"C-z--s-Bnyef"}},{"cell_type":"code","source":["%%writefile test.c\n","#include <stdio.h>\n","#include <stdlib.h> // malloc, rand\n","\n","int main(void)\n","{\n","    int** a;  // a[0], a[1], ..., a[9]\n","    int * array;\n","    int row, col;\n","    int i, j;\n","    scanf(\"%d%d\", &row, &col);\n","  \n","    /*\n","    row = 5\n","    col = 3\n","    row*col = 15\n","     0  1  2   3  4  5  6  7  8  9  10 11   12 13 14\n","    |1  2  3  |4  5  6 |7  8  9 |10 11 12 | 13 14 15|\n","    */\n"," \n","    array = (int*) malloc(row*col*sizeof(int));\n","    a = (int**) malloc(row*sizeof(int*));\n","    for (i=0; i<row; ++i) {\n","      a[i] = &array[i*col];\n","    }\n"," \n","    for (i=0; i<row; ++i) {\n","        for (j=0; j<col; ++j) {\n","            a[i][j] = i*col + (j+1);\n","        }\n","    }\n","\n","    for (i=0; i<row; ++i) {\n","        printf(\"a[%d]: %p a[%d][0]=%d, a[%d][1]=%d, a[%d][2]=%d %p\\n\", \n","               i, a[i], i, a[i][0], i, a[i][1], i, a[i][2], &a[i][2]);\n","    }\n"," \n","    free(a);\n","    free(array);\n","    \n","    return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"wPtQ5Ne71GOA","executionInfo":{"status":"ok","timestamp":1653999010779,"user_tz":-480,"elapsed":296,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"b56e273a-f365-41c4-eae6-3f925528f4bb"},"execution_count":57,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting test.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc test.c -o test\n","./test"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"EcbSwYmU8Y1O","executionInfo":{"status":"ok","timestamp":1653999018283,"user_tz":-480,"elapsed":3220,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7fbec983-62a8-4919-c0d1-ca05ab62aff3"},"execution_count":58,"outputs":[{"output_type":"stream","name":"stdout","text":["5 3\n","a[0]: 0x5572c7b8e000 a[0][0]=1, a[0][1]=2, a[0][2]=3 0x5572c7b8e008\n","a[1]: 0x5572c7b8e00c a[1][0]=4, a[1][1]=5, a[1][2]=6 0x5572c7b8e014\n","a[2]: 0x5572c7b8e018 a[2][0]=7, a[2][1]=8, a[2][2]=9 0x5572c7b8e020\n","a[3]: 0x5572c7b8e024 a[3][0]=10, a[3][1]=11, a[3][2]=12 0x5572c7b8e02c\n","a[4]: 0x5572c7b8e030 a[4][0]=13, a[4][1]=14, a[4][2]=15 0x5572c7b8e038\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":58}]},{"cell_type":"code","source":["%%writefile E16_02.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","int main(void)\n","{\n","   int *a, **b, i, j, rows, cols;\n","   \n","   scanf(\"%d %d\", &rows, &cols);\n","   a = (int *) malloc(rows * cols * sizeof(int));\n","   for (i = 0; i < rows*cols; i++) a[i] = i;\n","   b = (int* *) malloc(rows * sizeof(int *));\n","\n","   for (i = 0 ; i < rows; i++) b[i] = &a[i*cols];\n","\n","\n","   for (i = 0; i < rows; i++) {\n","      for (j = 0; j < cols; j++) {\n","         printf(\"%3d \", b[i][j]); \n","      }\n","      printf(\"\\n\");\n","   }\n","   \n","   free(b);\n","   free(a);\n","\n","   return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"aTB-qpIBnDu_","executionInfo":{"status":"ok","timestamp":1653975435715,"user_tz":-480,"elapsed":12,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"24189c74-645f-45a4-e94b-418dbccb90eb"},"execution_count":5,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_02.c -o E16_02\n","./E16_02"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"EY89BUJ7nYJ4","executionInfo":{"status":"ok","timestamp":1653975471640,"user_tz":-480,"elapsed":3417,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7153b6bf-b229-47bf-f194-c477b5fde95c"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["3 5\n","  0   1   2   3   4 \n","  5   6   7   8   9 \n"," 10  11  12  13  14 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":7}]},{"cell_type":"markdown","source":["\n","## 關於動態分配記憶體時，可能會犯的一些錯誤：  \n","*   memory leak  \n","    ```C\n","    int* a = malloc(sizeof(int));\n","    *a = 123;\n","    a = malloc(sizeof(int));\n","    *a = 456;\n","    free(a);\n","    ```  \n","    以上例來說，第一次分配到的記憶體就這樣被丟失，沒有被回收，之後也沒有任何方法能夠回收到那塊記憶體  \n","    類似這種狀況，當有記憶體是沒辦法被回收的，就被稱為 memory leak  \n","\n","*   dangling pointer  \n","    ```C\n","    int* ptr = NULL;\n","    {\n","        int a = 0;\n","        ptr = &a;\n","    }\n","    // ptr is a dangling pointer now !\n","\n","    int* f()\n","    {\n","      int x;\n","      x  = 5;\n","      return &x;\n","    }\n","\n","    ptr = f();\n","    ```  \n","\n","    以上例來說，`int a`的生命週期只在那對大括弧內，一旦過了那個大括弧的範圍，`ptr`所指向的位址就是不合法的  \n","    類似這種狀況，當有指標指向的記憶體是已經無效的，該指標就被稱為 dangling pointer  \n","    ```C\n","    int* a = malloc(sizeof(int));\n","    int* b = a;\n","    *a = 123;\n","    \n","    free(a);\n","    a = NULL;\n","    \n","    // b is a dangling pointer now !\n","\n","    ```  \n","    > Note:  \n","    > 對大多數`malloc`和`free`的 implementation 來說，所謂取得和釋放其實只是改變記憶體的使用狀態  \n","    > `malloc`和`free`做的事情只是去記錄哪些記憶體區塊被佔用以及哪些可用  \n","    > 所以呼叫`free(a)`之後，乍看之下可能會覺得沒發生什麼變化，因為原先那些記憶體內的資料可能都還存在  \n","    > 但是無論如何程式都不該再去存取已經被釋放的記憶體內容  \n","\n"],"metadata":{"id":"W8HvTNafnTEo"}},{"cell_type":"markdown","source":["# Example 3\n","\n","## 字元陣列和字串\n","[C reference 對於 string literal in C 的說明](http://en.cppreference.com/w/c/language/string_literal)  \n","[C++ reference 對於 string literal in C++ 的說明](http://en.cppreference.com/w/cpp/language/string_literal)  \n","[Stack Overflow 關於 string literal 在 C 與 C++ 中的說明](https://stackoverflow.com/questions/2245664/what-is-the-type-of-string-literals-in-c-and-c)  \n","\n","字元陣列其實就是一個陣列，其元素為字元  \n","而字串則是一個字元陣列，且其結尾必須是`'\\0'`  \n","通常在傳遞字串時，會用指向字串的第一個字元的指標作為該字串的代表  \n","\n","關於 string literal，有幾個需要注意的地方：  \n","1.  string literal 的型別是 `char[]`  \n","2.  如果是用指標去指向某個 string literal，那麼其指向的內容是不可寫的  \n","    ```C\n","    char* str = \"Test\"; // OK\n","    str[0] = 't'; // 未定義行為，但可以通過編譯，可能在執行時出錯\n","    ```\n","3.  為了避免類似錯誤發生，通常會建議用：  \n","    *   ```C\n","        const char* str = \"string\"; // 如果寫出 str[0]='t'，在編譯時就會出錯\n","        ```\n","    *   ```C\n","        char str[] = \"string\"; // str[0]='S' 是可以的\n","        ```\n","\n","```C\n","const char* str = \"string\";\n","```\n","*   `\"string\"`會在程式被載入的時候，一起被載入到某塊記憶體 (常見的狀況是載入到 data segment)  \n","*   而`str`指向的位址就是`\"string\"`被儲存到的記憶體的開頭位址  \n","*   標準規定對於 string literal 的寫入是未定義行為，實際上也有實作是將`\"string\"`載入到一塊只允許讀取的記憶體  \n","\n","```C\n","char str[] = \"string\";\n","```  \n","*   其實該句等同`char str[7] = \"string\"`，也等同於`char str[7] = {'s', 't', 'r', 'i', 'n', 'g', '\\0'};`  \n","*   相當於把記憶體中`\"string\"`複製一份當作`str`這個陣列的初始值  \n","*   所以`str[0] = 'S';`就合法了  \n","\n","試著執行看看下列的程式碼，並了解`str1`與`str2`之間的差別，以及輸出是否如同預期"],"metadata":{"id":"oJKGP-cvvCkI"}},{"cell_type":"code","source":["%%writefile E16_03.c\n","\n","#include <stdio.h>\n","\n","int main(void)\n","{\n","    char*  str1[] = {\"piece\", \"of\", \"cake\"};\n","\n","\n","    char str2[] [8] = {\"piece\", \"of\", \"cake\"};\n"," \n","    int i, j;\n","\n","    for (i=0; i<3; i++) {\n","        for (j=0; j<8; j++)\n","            printf(\"(%c, %d) \", str1[i][j], str1[i][j]);\n","        printf(\"\\n\");\n","    }\n","\n","    for (i=0; i<3; i++) {\n","        for (j=0; j<8; j++)\n","            printf(\"%c\", str2[i][j]);\n","        printf(\"\\n\");\n","    }\n","\n","    return 0; \n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"k-i5U-W32h4-","executionInfo":{"status":"ok","timestamp":1654002115558,"user_tz":-480,"elapsed":290,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"986f77d2-9ff6-4185-d307-801a909bc962"},"execution_count":75,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_03.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_03.c -o E16_03\n","./E16_03"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9YdPRrTE2sbk","executionInfo":{"status":"ok","timestamp":1654002119116,"user_tz":-480,"elapsed":306,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"13d85a6c-cf61-44a3-bbf1-405b35c7de86"},"execution_count":76,"outputs":[{"output_type":"stream","name":"stdout","text":["(p, 112) (i, 105) (e, 101) (c, 99) (e, 101) (\u0000, 0) (o, 111) (f, 102) \n","(o, 111) (f, 102) (\u0000, 0) (c, 99) (a, 97) (k, 107) (e, 101) (\u0000, 0) \n","(c, 99) (a, 97) (k, 107) (e, 101) (\u0000, 0) ((, 40) (%, 37) (c, 99) \n","piece\u0000\u0000\u0000\n","of\u0000\u0000\u0000\u0000\u0000\u0000\n","cake\u0000\u0000\u0000\u0000\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":76}]},{"cell_type":"markdown","source":["\n","## 雙重指標\n","\n","相當於指標的指標  \n","如果想要透過一個函式更改外面的`int`變數，會有類似底下的寫法  \n","\n","```C\n","void swap(int* a, int* b)\n","{\n","    int temp = *a;\n","    *a = *b;\n","    *b = temp;\n","}\n","\n","...\n","\n","int x = 5, y = 3;\n","swap(&x, &y);\n","```  \n","\n","那如果想要透過一個函式更改外面的`int*`變數呢？  \n","觀察上面的程式，會發現如果要透過函式更改外面的變數，其型別為`T`  \n","那麼在函式的參數，會期待收到一個`T*`的引數，藉此可以透過間接引用的方式改到外面的變數  \n","\n","下例則是表達如果希望藉由函式改變外面的`ptr`，其型別為`float*`  \n","在這裡可以將`float*`理解成`T`，按照上面的推論，那麼必須要傳入型別為`float**`的引數，也就是`&ptr`  \n","才可以在函式裡面藉由`*p`更改`ptr`所指向的位址  "],"metadata":{"id":"idXfAzWSvWNi"}},{"cell_type":"code","source":["%%writefile E16_04.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","float* malloc_float1(size_t sz)\n","{\n","   return (float *) malloc(sz*sizeof(float));\n","}\n","\n","\n","void malloc_float2( float* * q , size_t sz)  // q = &ptr\n","{\n","    *q = (float *) malloc(sz*sizeof(float));  // *q => *&ptr => ptr\n","}\n","\n","int main(void)\n","{\n","    float * ptr = NULL;\n","    int i;\n","    int n = 100;\n","\n","    malloc_float2(&ptr, n);\n","\n","    for (i=0; i<n; i++)\n","        ptr[i] = (float) rand()/RAND_MAX;\n","\n","    for (i=0; i<n; i++)\n","      printf(\"%f\\n\", ptr[i]);\n","    \n","    free(ptr);\n","\n","    return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4GNfr5WZ3Sbv","executionInfo":{"status":"ok","timestamp":1654002367148,"user_tz":-480,"elapsed":285,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"4c0d3bf0-a680-4db2-c94f-39180e893b56"},"execution_count":79,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_04.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_04.c -o E16_04\n","./E16_04"],"metadata":{"id":"1XiEYc9E3Z7g"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# 練習題\n","\n","## 字元陣列和字串-01\n","\n","說明並圖示下面兩種寫法的差異  \n","\n","```C\n","char str1[] = \"piece of cake\";\n","char *str2 = \"piece of cake\"; /* 附註：ANSI C 要求 compiler 可以支援到長度 509 的字串`\n","```\n","\n","## 字元陣列和字串-02\n","\n","假設在`main`裡面有下列三行，請問`str1`、`str2`、`str3`的內容會是什麼？  \n","\n","```C\n","char str1[100];\n","char str2[100] = {'a'}; \n","char str3[100] = \"\";\n","```\n","\n","## 字元陣列和字串-03\n","\n","寫一個 function，傳入一個字串，判斷是否為 palindrome (像是`level`、`wasitacatisaw`)  \n","\n","## 字元陣列和字串-04\n","\n","用圖示表現出下面的字串  \n","\n","```C\n","char *ptrary[] = {\"piece\", \"of\", \"cake\"};\n","```\n","\n","## 字元陣列和字串-05\n","\n","圖示下面兩種寫法的差別  \n","\n","```C\n","char *str1[] = {\"piece\", \"of\", \"cake\"};\n","char str2[][8] = {\"piece\", \"of\", \"cake\"};\n","```"],"metadata":{"id":"b0F4MB9N3wCc"}},{"cell_type":"markdown","source":["## C Structures\n","[The GNU C Programming Tutorial 對於 structures 的解釋](https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Structures)  \n","\n","Structures 是可以由使用者自己定義，由其他型別 (甚至是 structure) 的變數所組成的一個資料型別  \n","這樣的方式在使用上較方便，也會讓程式更簡潔易懂  \n","\n","譬如要描述平面上的點座標，可以用  \n","\n","```C\n","int x, y;\n","```\n","\n","若使用 structures 則可以自定一個叫做`t_point`的資料型態  \n","\n","```C\n","struct t_point {\n","   int x;\n","   int y;\n","};\n","```  \n","\n","關鍵字`struct`後面接著的`t_point`是自己替這個型別取的名字  \n","括號中間就是這個 structure 所包含的資料結構，括號後面要記得加上分號做結束  \n","這邊的`x`和`y`稱做`struct t_point`的成員變數 (member)  \n","\n","定義過 structure 之後，可以用它來宣告變數  \n","\n","```C\n","struct t_point pt;\n","```\n","\n","如果不想每次寫的時候都要有`struct`關鍵字，，可以利用下面這種寫法  \n","\n","```C\n","struct t_point {\n","    int x;\n","    int y;\n","};\n","typedef struct t_point Point;\n","\n","Point pt;\n","```\n","\n","或是這種寫法  \n","\n","```C\n","typedef struct {\n","    int x;\n","    int y;\n","} Point;\n","\n","Point pt;\n","```\n","\n","`pt`會包含`x`和`y`兩個 members，要更改 members 的內容，最直接的方式是使用 member operator `.` 來存取  \n","如果是指標變數，則可以透過`->`來存取  \n","\n","```C\n","Point pt = {5, 7};\n","pt.x = 7;\n","\n","Point *pp = &pt;\n","(*pp).x = 10;\n","pp->x = 10;\n","// 上面兩行是等價的\n","```\n","\n","又，已經宣告過的 structure 可以再拿來當成另一個 structure 的 member  \n","然後用它來產生變數，以及存取 members  \n","\n","```C\n","typedef struct {\n","   Point pt1;\n","   Point pt2;\n","} Rect;\n","\n","Rect screen;\n","printf(\"%d %d\\n\", screen.pt1.x, screen.pt1.y);\n","```\n","\n","\n","底下是一個較完整的範例  "],"metadata":{"id":"lxVlwJHZ3hn-"}},{"cell_type":"code","source":["%%writefile E16_05.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","\n","// 定義一個新的型別\n","// 取名叫做 Point\n","// 裡面包含 x 和 y 兩個 members\n","// 定義過之後 Point 可以被拿來當作一般的型別來使用\n","// 包括宣告新的變數或是宣告 function\n","typedef struct {\n","    int x;\n","    int y;\n","} Point;\n","\n","// ones_vec_1 會傳回某個 Point 結構的位址\n","// 這個位址是由 Point 結構組成的陣列的開頭位址\n","Point * ones_vec_1(int length);\n","\n","// 傳入一個指向 Point* 的指標，ones_vec_2 會把 Point* 的值設定成\n","// 由 Point 結構組成的陣列的開頭位址\n","void ones_vec_2(int length, Point **bp);\n","\n","int main(void)\n","{\n","   Point *a, *b;\n","   int i, length;\n","   \n","   printf(\"The size of a Point is %lu bytes.\\n\", sizeof(Point));\n","    \n","   printf(\"vector length: \");\n","   scanf(\"%d\", &length);\n","\n","   // 利用 ones_vec_1 取得一個陣列\n","   // 陣列的每個元素是一個 Point\n","   // 陣列的開頭位址記錄在指標變數 a 裡面\n","   a = ones_vec_1(length);\n","   \n","   // 指標變數 b 同理\n","   ones_vec_2(length, &b);\n","\n","   // a 是個指標變數，它記錄的是某個陣列的開頭位址\n","   // 陣列的每個元素是 a[i] (型別為 Point)\n","   // 所以有兩個 members 分別是 a[i].x 和 a[i].y\n","   for (i=0; i<length; i++) \n","      printf(\"(%d, %d) \", a[i].x, a[i].y);\n","   printf(\"\\n\");\n","   \n","   // 同理\n","   for (i=0; i<length; i++)\n","      printf(\"(%d, %d) \", b[i].x, b[i].y);\n","   printf(\"\\n\");\n","   \n","   \n","   return 0;\n","}\n","\n","Point * ones_vec_1(int length)\n","{\n","   Point *a;\n","   int i;\n","   a = (Point *) malloc(length * sizeof(Point));\n","   for (i = 0 ; i < length; i++) {\n","      a[i].x = 1;\n","      a[i].y = 1;\n","   } \n","   return a;\n","}\n","\n","void ones_vec_2(int length, Point **bp)\n","{\n","   int i;\n","   \n","   *bp = (Point *) malloc(length * sizeof(Point));\n","   for (i = 0 ; i < length; i++) {\n","      (*bp)[i].x = 1;\n","      (*bp)[i].y = 1;      \n","   } \n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"r8N_QUuG2QfR","executionInfo":{"status":"ok","timestamp":1653979874710,"user_tz":-480,"elapsed":292,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"22485cb9-a912-4d53-b012-8371371957ae"},"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_05.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_05.c -o E16_05\n","./E16_05"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"io5SL0M_4NhH","executionInfo":{"status":"ok","timestamp":1653979888635,"user_tz":-480,"elapsed":7966,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"a592e964-623f-4277-8ff2-cffe207609d6"},"execution_count":19,"outputs":[{"output_type":"stream","name":"stdout","text":["The size of a Point is 8 bytes.\n","vector length: 10\n","(1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) \n","(1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) (1, 1) \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":19}]},{"cell_type":"markdown","source":["# Example 6\n","\n","## Structures + Functions\n","\n","Structures 可以使用的 operator 只有`=`、`&`、`.`、`->`，其他的運算則必須自己寫 functions 來達到我們想要的功能  \n","例如，想要比較兩個 structure 變數相不相等，不能直接用`==`或`!=`，相加`+`和相減`–`也不能用  \n","\n","以下是幾個自訂 functions 的例子  \n","\n"],"metadata":{"id":"5et8ZzeO6c7L"}},{"cell_type":"code","source":["%%writefile E16_06.c\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct t_complex {\n","    double r;\n","    double i;\n","} Complex;\n","\n","void add(Complex a, Complex b, Complex *t)\n","{\n","    t->r = a.r+b.r;\n","    t->i = a.i+b.i;\n","}\n","void set_complex(Complex *p, double r, double i)\n","{\n","    p->r = r;\n","    p->i = i;\n","}\n","void show_complex(Complex t)\n","{\n","    printf(\"%.2f%+.2fi\\n\", t.r, t.i);\n","}\n","\n","int main(void)\n","{\n","    Complex x, y, z;\n","    set_complex(&x, 1, 2);\n","    set_complex(&y, 2, -3);\n","    add(x, y, &z);\n","    show_complex(z);\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"E2TvhOwX6ZdU","executionInfo":{"status":"ok","timestamp":1653980471991,"user_tz":-480,"elapsed":336,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"5365fe4e-2808-4aea-cad2-7a0aef119e9d"},"execution_count":20,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing E16_06.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_06.c -o E16_06\n","./E16_06"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7dsAkCFg6zH0","executionInfo":{"status":"ok","timestamp":1653980496082,"user_tz":-480,"elapsed":234,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"cfda390e-92cd-4772-e675-3ed32104212c"},"execution_count":21,"outputs":[{"output_type":"stream","name":"stdout","text":["3.00-1.00i\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":21}]},{"cell_type":"markdown","source":["# Example 7\n","\n","傳遞 structure 變數到 function，會用 call-by-value 的方式  \n","所以在 function 裡改變 structure 的 members 的值，並不會影響外部的 structure 變數的內容  \n","\n","以`show_complex`為例，會發現這個函式其實只是需要讀取外面變數的值，不需要更改其內容  \n","所以就可以利用 call-by-value 的方式傳入  \n","\n","但以`set_complex`為例，這樣將會是徒勞無功  \n","必須如前文的程式碼，使用指標變數才有辦法更改到外面變數的內容  \n","\n","```C\n","void set_complex(Complex p, double r, double i)\n","{\n","    p.r = r;\n","    p.i = i;\n","    // 這個 p 是複製而來的，並不會改變到外面變數的內容\n","}\n","```\n","\n","> Note:  \n","> 如果是透過 call-by-value，傳遞過程可能需要複製整個變數的內容  \n","> 相較之下效率可能會比較低  \n","\n","底下的程式碼，可以將`DATA`想像成是一個`int`的陣列，並包括長度資訊  \n","其中的`clone_data`是為了實作類似`a = b`的效果，而自己定義出來的 function  \n"],"metadata":{"id":"usMu3U5R69hj"}},{"cell_type":"code","source":["%%writefile E16_07.c\n","\n","#include <stdio.h>\n","#include <stdlib.h>\n","typedef struct t_data {\n","    int size;\n","    int * ptr;\n","} DATA;\n","void create_data(DATA *z, int sz)\n","{\n","    int * t;\n","    int i;\n","    z->size = sz;\n","    z->ptr = (int *) malloc(sz*sizeof(int));\n","    t = z->ptr;\n","    for (i=0; i< sz; i++)  {\n","        t[i] = i;\n","    }\n","}\n","void show_data(DATA d)\n","{\n","    int i;\n","    printf(\"%lu\\n\", sizeof(d));\n","    for (i=0; i<d.size; i++) {\n","        printf(\"%d \", (d.ptr)[i]);\n","        if ((i+1)%10 == 0) printf(\"\\n\");\n","    }\n","}\n","void delete_data(DATA *z)\n","{\n","    free(z->ptr);\n","    z->ptr = NULL;\n","    z->size = 0;\n","}\n","DATA clone_data(DATA x)\n","{\n","    int i;\n","    DATA y;\n","    y.size = x.size;\n","    y.ptr = (int *) malloc(y.size*sizeof(int));\n","    for (i=0; i<y.size; i++) {\n","        (y.ptr)[i] = (x.ptr)[i];\n","    }\n","    return y;\n","}\n","\n","int main(void)\n","{\n","    DATA x , x_clone;\n","    create_data(&x, 100);\n","    show_data(x);\n","    x_clone = clone_data(x);\n","    delete_data(&x);\n","    show_data(x_clone);\n","\n","    return 0;\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1-SRJh1X7gez","executionInfo":{"status":"ok","timestamp":1653980737303,"user_tz":-480,"elapsed":381,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"9c75bbe7-3b38-456f-e215-b2b25293be53"},"execution_count":24,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E16_07.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E16_07.c -o E16_07\n","./E16_07"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"FovQk3in7m5P","executionInfo":{"status":"ok","timestamp":1653980742531,"user_tz":-480,"elapsed":325,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7c0be8af-d063-4811-8476-3f8e735f700f"},"execution_count":25,"outputs":[{"output_type":"stream","name":"stdout","text":["16\n","0 1 2 3 4 5 6 7 8 9 \n","10 11 12 13 14 15 16 17 18 19 \n","20 21 22 23 24 25 26 27 28 29 \n","30 31 32 33 34 35 36 37 38 39 \n","40 41 42 43 44 45 46 47 48 49 \n","50 51 52 53 54 55 56 57 58 59 \n","60 61 62 63 64 65 66 67 68 69 \n","70 71 72 73 74 75 76 77 78 79 \n","80 81 82 83 84 85 86 87 88 89 \n","90 91 92 93 94 95 96 97 98 99 \n","16\n","0 1 2 3 4 5 6 7 8 9 \n","10 11 12 13 14 15 16 17 18 19 \n","20 21 22 23 24 25 26 27 28 29 \n","30 31 32 33 34 35 36 37 38 39 \n","40 41 42 43 44 45 46 47 48 49 \n","50 51 52 53 54 55 56 57 58 59 \n","60 61 62 63 64 65 66 67 68 69 \n","70 71 72 73 74 75 76 77 78 79 \n","80 81 82 83 84 85 86 87 88 89 \n","90 91 92 93 94 95 96 97 98 99 \n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":25}]}]}