{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Week12.ipynb","provenance":[],"collapsed_sections":[],"authorship_tag":"ABX9TyONflySfW05a2lNF0FrGdad"},"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/程式設計一/Arrays](https://github.com/htchen/i2p-nthu/blob/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/array/array.md)\n","\n","\n","[https://github.com/htchen/i2p-nthu/tree/master/程式設計一/Pointers](https://github.com/htchen/i2p-nthu/blob/master/%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88%E4%B8%80/pointer/Pointer.md)\n"],"metadata":{"id":"05G1Fqg6GRZX"}},{"cell_type":"markdown","source":["##Example 1\n","###**指標變數**\n","\n","####使用 `&` 符號取得位址\n","\n","指標 (pointer) 是 C 語言裡面的非常重要、同時也最讓初學者感到困擾的概念。如果用最簡單的方式來說明，指標就是一個專門用來儲存位址的變數。\n","\n","我們在使用 `scanf()` 的時候，其實就已經用過位址來當作參數 (變數前面加 `&`)。而任何 C 的 function 如果不想靠 `return` 方式來傳回值，就只能透過位址來取得 function 執行的結果。我們先來探討一下 `&` 符號，以及如何取得位 址的資訊。在變數前面加上 `&`，會得到用來儲存該變數的位址。譬如變數的名稱叫做 `y`，則 `&y` 就是這個變數的位址。 我們可以把位址想成記憶體中的某個位置。\n","\n","輸出的 `&y` 就是位址的十六進位值。能夠取得變數的位址是一個很強大的功能，因為這樣一來我們就可以透過位址來存取和修改變數值，而不再只是透過變數名稱來存取變數值。除此之外，我們也可以把位址當參數傳遞，這一點可以 幫我們做到很多原本做不到的事情。"],"metadata":{"id":"mviKuWaapY32"}},{"cell_type":"code","source":["%%writefile E12_01.c\n","\n","#include <stdio.h>\n","int main(void)\n","{\n","  int y = 5;\n","  double z = 1.2;\n","  char c = 'A';\n"," \n","  printf(\"The value of y is %d; the address of y is %p.\\n\", y, &y); \n","  printf(\"The size of y is %lu bytes; the size of &y is %lu bytes.\\n\", \n","         sizeof(y), sizeof(&y)); \n","\n","  printf(\"The value of z is %5.2f; the address of z is %p.\\n\", z, &z); \n","  printf(\"The size of z is %lu bytes; the size of &z is %lu bytes.\\n\", \n","         sizeof(z), sizeof(&z)); \n","\n","  printf(\"The value of c is %c; the address of c is %p.\\n\", c, &c); \n","  printf(\"The size of c is %lu bytes; the size of &c is %lu bytes.\\n\", \n","         sizeof(c), sizeof(&c)); \n","\n","  return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7ZODSFC-pmP2","executionInfo":{"status":"ok","timestamp":1651575154232,"user_tz":-480,"elapsed":275,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"28d0cb48-0cf1-4da1-b0e3-4be1c67ca463"},"execution_count":58,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_01.c -o E12_01\n","./E12_01"],"metadata":{"id":"HMqFdYymQIzj","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651575164403,"user_tz":-480,"elapsed":248,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"a478c683-cc5b-4805-8dbb-731160449da5"},"execution_count":59,"outputs":[{"output_type":"stream","name":"stdout","text":["The value of y is 5; the address of y is 0x7fff21b4904c.\n","The size of y is 4 bytes; the size of &y is 8 bytes.\n","The value of z is  1.20; the address of z is 0x7fff21b49050.\n","The size of z is 8 bytes; the size of &z is 8 bytes.\n","The value of c is A; the address of c is 0x7fff21b4904b.\n","The size of c is 1 bytes; the size of &c is 8 bytes.\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":59}]},{"cell_type":"markdown","source":["##Example 2\n","我們之前提過每個 function 會有自己的 local variables，不會和外部衝突，而且參數傳入 function 的時候，是把值 複製過去，所以在 function 裡任意修改參數並不會影響到外部的變數。下面的範例就是在說明這個特性。\n","\n","觀察執行結果會發現使用什麼樣的變數名稱在 `main()` 和 `f()` 其實完全無關，而且每個變數的位址也都不一樣。所以 真正能用來區別不同的資料的其實是位址。"],"metadata":{"id":"Mp5lAOxDodYd"}},{"cell_type":"code","source":["%%writefile E12_02.c\n","#include <stdio.h>\n","\n","void f(int);\n","int main(void)\n","{\n","  int y = 2, z = 5;\n","  printf(\"In %s(), y = %d and &y = %p\\n\", __func__, y, &y);\n","  printf(\"In %s(), z = %d and &z = %p\\n\", __func__, z, &z);\n","  f(y); \n","  return 0;\n","}\n","\n","void f(int z)\n","{\n","  int y = 10;\n","  printf(\"In %s(), y = %d and &y = %p\\n\", __func__, y, &y); \n","  printf(\"In %s(), z = %d and &z = %p\\n\", __func__, z, &z);\n","}"],"metadata":{"id":"LZ8575uZo5hG","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651575466553,"user_tz":-480,"elapsed":544,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"334aad93-4b22-42c5-f5a4-70a7d3347686"},"execution_count":60,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_02.c -o E12_02\n","./E12_02\n"],"metadata":{"id":"f1ClwjOzsdsQ","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651575470801,"user_tz":-480,"elapsed":275,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"ee2ee01f-e956-4feb-8698-4283d30de5d7"},"execution_count":61,"outputs":[{"output_type":"stream","name":"stdout","text":["In main(), y = 2 and &y = 0x7fff5103d490\n","In main(), z = 5 and &z = 0x7fff5103d494\n","In f(), y = 10 and &y = 0x7fff5103d474\n","In f(), z = 2 and &z = 0x7fff5103d46c\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":61}]},{"cell_type":"markdown","source":["##Example 3\n","假設我們想要寫一個 function，傳入兩個參數，然後在 function 裡面交換這兩個參數的值，這個程式該怎麼寫呢? 先看看下面這種寫法:\n","\n"],"metadata":{"id":"2HgZZI7vpHFE"}},{"cell_type":"code","source":["%%writefile E12_03.c\n","#include <stdio.h>\n","void swap(int u, int v);\n","int main(void)\n","{\n","  int y = 2, z = 5;\n","  printf(\"Before calling swap(), y = %d and z = %d.\\n\", y, z); \n","  swap(y, z);\n","  printf(\"After calling swap(), y = %d and z = %d.\\n\", y, z); \n","  return 0;\n","}\n","       \n","void swap(int u, int v) \n","{\n","  int tmp;\n","  printf(\"In %s(), before swapping, u = %d and v = %d.\\n\", __func__, u, v); \n","  tmp = u;\n","  u = v;\n","  v = tmp;\n","  printf(\"In %s(), after swapping, u = %d and v = %d.\\n\", __func__, u, v);\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4mllPj9Rt8qF","executionInfo":{"status":"ok","timestamp":1651576099978,"user_tz":-480,"elapsed":236,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"bbbceb98-071e-4905-aca7-bb7c56aea945"},"execution_count":62,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_03.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_03.c -o E12_03\n","./E12_03"],"metadata":{"id":"3yZlwmmjsiKP","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651576106125,"user_tz":-480,"elapsed":671,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"8b4b31a6-8e25-42ad-f037-70b63ad0392c"},"execution_count":63,"outputs":[{"output_type":"stream","name":"stdout","text":["Before calling swap(), y = 2 and z = 5.\n","In swap(), before swapping, u = 2 and v = 5.\n","In swap(), after swapping, u = 5 and v = 2.\n","After calling swap(), y = 2 and z = 5.\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":63}]},{"cell_type":"markdown","source":["上面的結果是 `swap()` 對 `main()` 裡的 `y` 和 `z` 一點效果都沒有。雖然在 `swap()` 裡面，做完下面三行之後 \n","```\n","  tmp = u;\n","  u = v;\n","  v = tmp;\n","```\n","參數確實被交換了，但是跳出了 `swap()` 回到 `main()`，一切都沒變，因為更改的其實是存放在不同位址的變數值。"],"metadata":{"id":"wKxM7pRF-IzY"}},{"cell_type":"markdown","source":["##Example 4\n","\n","###**指標變數**\n","用來記錄記憶體位址的變數。\n","\n","要怎麼才能做到真正把 `main()` 裡的 `y` 和 `z` 交換? 我們要先學會怎麼使用指標變數。\n","\n","假設我們已經有一個指標變數，名字叫做 `ptr`，由於指標變數專門用來儲存位址，所以我們可以寫 \n","```\n","  ptr = &y;\n","```\n","這樣的動作等於把 `y` 的位址用 `ptr` 記下來，通常我們也會把這樣的動作叫做 把 `ptr` 指向 `y`。\n","\n","雖然同樣都代表某個記憶體位址，但是 `&y` 是一個 constant，它的值就是 `y` 的位址，是個固定的值不能改變。但是 `ptr` 是個變數，所以我們可以改變 `ptr` 的值，拿它來記錄別的位址，例如，\n","```\n","  ptr = &z;\n","```\n","假設我們用了上面的程式碼把 `ptr` 的值改設為 `z` 的位址，也就說用 `ptr` 記錄下 `z` 的位址，那麼我們可以對 `ptr` 做所謂 *dereferencing* 的操作，這個操作的作用是把 `ptr` 記錄的位址裡面所儲存的值取出來，例如 \n","```\n","  x = *ptr;\n","```\n","也就是使用 `*` 符號加在指標變數前面，可以取得 `ptr` 代表的位址裡所存放的數值。這兩個動作 `ptr = &z;` 和 `x = *ptr;` 得到的效果相當於\n","```\n","  x = z;\n","```\n","\n","###**如何宣告指標變數**\n","\n","我們知道如何宣告 `int` 變數或是其他型別的變數，但是要怎麼宣告指標變數?難道是用底下這樣:\n","```\n","  pointer ptr; /* not the way to declare a pointer */\n","```\n","並不是這樣，並沒有叫做 `pointer` 的內建型別。而且我們除了要知道 `ptr` 是個用來記錄位址的變數之外，還要知道它所記錄的位址裡，儲存的資料型別是什麼，因為不同型別的資料在記憶體裡面需要的空間不同，而我們除了要靠\n","`ptr` 記錄起始位址之外，還要知道後面涵蓋了多少數量的記憶體空間。所以我們必須有各式各樣的指標類型，類似\n","```\n","  int_pointer ptr; /* not the way to declare a pointer */   \n","  char_pointer ptr; /* not the way to declare a pointer */   \n","  float_pointer ptr; /* not the way to declare a pointer */\n","```\n","不過如果真的是這樣宣告就太麻煩了，因為每個原有的型別都要造出一個對應的指標型別。在 C 語言裡真正的作法是底下這樣的寫法\n","```\n","  int * pi; /* pi is a pointer to an integer variable */ \n","  char * pc; /* pc is a pointer to a character variable */ \n","  float * pf, * pg; /* pf and pg are pointers to float variables */\n","```\n","這樣的宣告表示 `pi` 是指向 `int` 的指標，所以 `pi` 的值是個位址，而這個位址裡存的資料是個整數。同理，`pc` 是指向 `char` 的指標，`pf` 和 `pg` 都是指向 `float` 的指標。\n","\n","前面舉的「每個原有的型別都要造出一個對應的指標型別」的情況，如果真的要這麼做，可以用 `typedef` 來達成（但實際上沒什麼必要這麼做）：\n","```\n","typedef int * int_pointer;\n","typedef char * char_pointer;\n","typedef float * float_pointer;\n","```\n","我們用底下的圖來模擬一下指標的宣告和使用過程中記憶體的狀態 變化:"],"metadata":{"id":"7co6TxbjrUL2"}},{"cell_type":"markdown","source":["![image.png](data:image/png;base64,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)"],"metadata":{"id":"9FuY12t-fxOC"}},{"cell_type":"markdown","source":["當我們在寫程式的時候，每個變數對我們來說具有兩項主要性質: 變數名稱和變數值。\n","\n","當程式經過 compile 然後 load 到記憶體裡準備執行時，電腦認知的變數所具有的性質變成位址和變數值。也就是說電腦是以位址來區別變數。 \n","\n","在許多語言中，位址完全交給電腦負責就好了，但是在 C 語言裡，程式設計者可以用 `&` 符號來取得位址的資訊。我 們就來試試看透過記憶體位址，達到真正交換兩個變數值的效果。"],"metadata":{"id":"zApIumfMf6db"}},{"cell_type":"code","source":["%%writefile E12_04.c\n","#include <stdio.h>\n","void swap(int * u, int * v);\n","int main(void)\n","{\n","  int y = 2, z = 5;\n","  printf(\"Before calling swap(), y = %d and z = %d.\\n\", y, z); \n","  swap(&y, &z);\n","  printf(\"After calling swap(), y = %d and z = %d.\\n\", y, z); \n","  return 0;\n","}\n","       \n","void swap(int * u, int * v)  // u = &y; v = &z;\n","{\n","  int tmp;\n","  printf(\"In %s(), before swapping, u = %d and v = %d.\\n\", __func__, *u, *v);\n","  tmp = *u;\n","  *u = *v;\n","  *v = tmp;\n","  printf(\"In %s(), after swapping, u = %d and v = %d.\\n\", __func__, *u, *v);\n","}"],"metadata":{"id":"bNrwKmsysNfy","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651581503769,"user_tz":-480,"elapsed":278,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"450fecd0-2f69-46b5-9822-2b8925980d09"},"execution_count":78,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_04.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_04.c -o E12_04\n","./E12_04"],"metadata":{"id":"puvNtlHWssLK","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651581508458,"user_tz":-480,"elapsed":261,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"41605e70-374a-4c39-868a-9dedbcb08055"},"execution_count":79,"outputs":[{"output_type":"stream","name":"stdout","text":["Before calling swap(), y = 2 and z = 5.\n","In swap(), before swapping, u = 2 and v = 5.\n","In swap(), after swapping, u = 5 and v = 2.\n","After calling swap(), y = 5 and z = 2.\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":79}]},{"cell_type":"markdown","source":["\n","上面的執行結果，確實把 `main()` 裡的 `y` 和 `z` 的值對調了。在主程式裡呼叫 `swap()` 的方式變成\n","```\n","  swap(&y, &z);\n","```\n","我們傳入的參數不再是 `y` 和 `z` 的值，而是 `y` 和 `z` 的位址。所以在宣告 `swap()` 的 prototype 的時候，參數的型別應該是指標，這樣才能接收位址。而且因為 `y` 和 `z` 是 `int`，所以我們需要指向 `int` 的指標，\n","```\n","void swap(int * u, int * v);\n","```\n","在 `swap()` 的程式碼主體裡，我們宣告 `int tmp;` 因為要用 `tmp` 當作交換時的暫存區。由於 `u` 和 `v` 都是指標變數，\n","它們的值都代表著位址，我們要先把 `u` 所記錄的位址裡儲存的資料值取出來，放入 `tmp` 裡 \n","```\n","  tmp = *u;\n","```\n","(注意，絕對不要寫成 `tmp = u;`，我們要交換的是位址裡儲存的資料，不是要交換位址。) \n","\n","同樣的道理\n","```\n","  *u = *v;\n","```\n","把儲存在 `v` 所記錄的位址裡的資料取出來，把 `u` 所記錄的位址裡面儲存的值蓋掉。\n","\n","如果能把這個範例想清楚，並且把整個寫法弄得很熟，指標的使用對我們來說就不會構成太大的困擾。最好不僅只是把原理都想通，還能熟練到可以反射式地寫出 `tmp = *u;` 或 `*u=*v;` 或 `int * u;` 這些指標的用法。建議大\n","家可以試著先把整個範例弄懂，然後自己重寫整個範例。"],"metadata":{"id":"zI9rD5DOhAZ3"}},{"cell_type":"markdown","source":["##Example 5\n"],"metadata":{"id":"eAEfEJkitIw9"}},{"cell_type":"code","source":["%%writefile E12_05.c\n","#include <stdio.h>\n","#define MAXN 1000000\n","\n","int space[MAXN];\n","\n","int f1(int x) \n","{\n","  x = x + 1;\n","  return x;\n","}\n","\n","void f2(unsigned int index)\n","{\n","  space[index] = space[index] + 1; \n","}\n","\n","int main()\n","{\n","  int x = 100; // space[12345]\n","  int y = 500; // space[67890]\n","  unsigned int px;\n","  unsigned int py;\n","   \n","  x = f1(x);\n","  printf(\"%d\\n\", x);\n","  f1(x);\n","  printf(\"%d\\n\", x);\n","\n","  px = 12345;\n","  space[px] = x;\n","  f2(px);\n","  x = space[px];\n"," \n","  py = 67890;\n","  space[py] = y;\n","  f2(py);\n","  y = space[py];\n","  printf(\"%d %d\\n\", x, y);\n"," \n","  return 0;\n","}"],"metadata":{"id":"CUD4U1iTuWSa","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651561048804,"user_tz":-480,"elapsed":304,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"4e2b664d-42e1-419a-e451-c35ce27e6489"},"execution_count":29,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_05.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_05.c -o E12_05\n","./E12_05"],"metadata":{"id":"dn61T8gVudiD","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1651561053098,"user_tz":-480,"elapsed":262,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"7b8bd6ae-ffe7-4217-fec0-133858c90536"},"execution_count":30,"outputs":[{"output_type":"stream","name":"stdout","text":["101\n","101\n","102 501\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":30}]},{"cell_type":"markdown","source":["# Exercise 1\n","\n","改寫上面的例子，變成用指標變數來實現。"],"metadata":{"id":"7zvidNTJtv9p"}},{"cell_type":"code","source":["%%writefile W12_01.c\n","#include <stdio.h>\n","\n","void f2(int * q)\n","{\n","  *q = *q + 1;\n","}\n","\n","int main()\n","{\n","  int x = 100;\n","  int y = 500;\n","  int * px;\n","  int * py;\n","   \n","  px = &x;\n","  f2(px);\n","  \n","  py = &y;\n","  f2(py);\n","\n","  printf(\"%d %d\\n\", x, y);\n"," \n","  return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"-4dGxug7vapd","executionInfo":{"status":"ok","timestamp":1651582501581,"user_tz":-480,"elapsed":259,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"0bef9afe-70f9-4a10-cdee-3e09263dcda4"},"execution_count":80,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting W12_01.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc W12_01.c -o W12_01\n","./W12_01"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"s4HVR61NvjWu","executionInfo":{"status":"ok","timestamp":1651582506397,"user_tz":-480,"elapsed":271,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"e59942c4-b763-4538-ffe5-cf8ff1fbbef9"},"execution_count":81,"outputs":[{"output_type":"stream","name":"stdout","text":["101 501\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":81}]},{"cell_type":"markdown","source":["# Example 6\n","\n","## 等價的寫法\n","`a[i]`  ⟺ `*(a+i)`\n","\n","`&a[i]`  ⟺ `(a+i)`"],"metadata":{"id":"RekjD2X7xkdD"}},{"cell_type":"code","source":["%%writefile E12_06.c\n","\n","#include <stdio.h>\n","\n","int main(void)\n","{\n","  int a[10] = {1, 2}; // a 陣列名字, 被寫在程式碼裡的時候，會被替換成那個陣列開頭的記憶體位址\n","  int *p;\n","  a[5] = 100;  //1, 2,   0,   0,  0,  100,  0,  0,  0,  0\n"," \n","  printf(\"%lu\\n\", sizeof(a));\n","  printf(\"%p\\n\", a);\n","  printf(\"%3d %p\\n\", a[0], &a[0]);\n","  printf(\"%3d %p\\n\", a[1], &a[1]);\n","  printf(\"%3d %p\\n\", a[5], &a[5]);\n"," \n","  p  = a;\n","  printf(\"%p %p\\n\", a, p);\n","  printf(\"%p %p\\n\", &a[0], p+0);\n","  printf(\"%p %p\\n\", &a[1], p+1);\n","  printf(\"%p %p\\n\", &a[5], p+5);\n","\n","  printf(\"%3d %3d\\n\", a[0], *(p+0));\n","  printf(\"%3d %3d\\n\", a[1], *(p+1));\n","  printf(\"%3d %3d\\n\", a[5], *(p+5));\n","\n","\n","  printf(\"%3d %3d\\n\", p[1], *(a+1));\n","  printf(\"%3d %3d\\n\", p[1], *(1+a));\n","  printf(\"%3d %3d\\n\", p[1], 1[a]);\n","  printf(\"%3d %3d\\n\", 1[p], 1[a]);\n"," \n","  int i = 5;\n","  printf(\"%3d %3d\\n\", i[p], i[a]);\n","  printf(\"%3d %3d\\n\", p[i], a[i]);\n","\n","\n","  return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Q1Tr_qiXyMIr","executionInfo":{"status":"ok","timestamp":1651584149965,"user_tz":-480,"elapsed":323,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"eb49f959-7f51-4293-a29e-37d32568b83a"},"execution_count":86,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_06.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_06.c -o E12_06\n","./E12_06"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"wxVZ1QntzYun","executionInfo":{"status":"ok","timestamp":1651583470820,"user_tz":-480,"elapsed":255,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"e5124fc5-d7e1-4213-9787-d90d43f08680"},"execution_count":85,"outputs":[{"output_type":"stream","name":"stdout","text":["40\n","0x7ffe7d90e690\n","  1 0x7ffe7d90e690\n","  2 0x7ffe7d90e694\n","100 0x7ffe7d90e6a4\n","0x7ffe7d90e690 0x7ffe7d90e690\n","0x7ffe7d90e690 0x7ffe7d90e690\n","0x7ffe7d90e694 0x7ffe7d90e694\n","0x7ffe7d90e6a4 0x7ffe7d90e6a4\n","  1   1\n","  2   2\n","100 100\n","  2   2\n","  2   2\n","  2   2\n","  2   2\n","100 100\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":85}]},{"cell_type":"markdown","source":["# Example 7\n","\n","「傳遞」陣列到函數裡？\n","\n","指標變數和陣列的差別？"],"metadata":{"id":"U87YB0Uk01Dt"}},{"cell_type":"code","source":["%%writefile E12_07.c\n","#include <stdio.h>\n","\n","int f(int *p, int n)\n","{\n","  int i;\n","  int sum = 0;\n","  for (i=0; i<n; ++i) {\n","    sum = sum + p[i];\n","  }\n","  return sum;\n","}\n","\n","/*\n","int f(int *p, int n)\n","{\n","  int i;\n","  int sum = 0;\n","  for (i=0; i<n; ++i, ++p) {\n","    sum = sum + *p;\n","  }\n","  return sum;\n","}\n","*/\n","\n","/*\n","int g(int *p, int *end)\n","{\n","  int sum = 0;\n","  while (p < end)) {\n","    sum = sum + *p;\n","    ++p;\n","  }\n","  return sum;\n","}\n","*/\n","\n","int main(void)\n","{\n","  int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\n","  printf(\"%d\\n\", f(a, 10));\n","  //printf(\"%d\\n\", g(a, a+10));\n","\n","  return 0;\n","}"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7mumElkp3l66","executionInfo":{"status":"ok","timestamp":1651564287219,"user_tz":-480,"elapsed":231,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"eb3496fa-9ccf-43f2-e397-88ea81e3c505"},"execution_count":49,"outputs":[{"output_type":"stream","name":"stdout","text":["Overwriting E12_07.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc E12_07.c -o E12_07\n","./E12_07"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"a6hxGaQz4VTE","executionInfo":{"status":"ok","timestamp":1651563935551,"user_tz":-480,"elapsed":238,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"38627852-1b67-4912-ef3a-6111ccde7743"},"execution_count":48,"outputs":[{"output_type":"stream","name":"stdout","text":["55\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":48}]},{"cell_type":"markdown","source":["# Exercise 2\n","\n","自己寫一個可以計算字串長度的函數\n","```\n","  unsigned long mylen(char *str);\n","```"],"metadata":{"id":"4O77IJid6e78"}},{"cell_type":"code","source":["%%writefile W12_02.c\n","#include <stdio.h>\n","\n","unsigned long mylen(char *str);\n","\n","int main(void)\n","{\n","  char str[] = \"Hello, world!\";\n","  printf(\"%lu, %s\\n\", mylen(str), str);\n"," \n","  return 0;\n","}\n","\n","unsigned long mylen(char *p)\n","{\n","  ???\n","}\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"roozgTUc6HGU","executionInfo":{"status":"ok","timestamp":1651564610468,"user_tz":-480,"elapsed":243,"user":{"displayName":"HT Chen","userId":"17748361917871513601"}},"outputId":"ea285dd3-93f7-496b-ffbe-6ee732a83793"},"execution_count":50,"outputs":[{"output_type":"stream","name":"stdout","text":["Writing W12_02.c\n"]}]},{"cell_type":"code","source":["%%shell\n","gcc W12_02.c -o W12_02\n","./W12_02"],"metadata":{"id":"lV3FoloM7Cbh"},"execution_count":null,"outputs":[]}]}