{ALGO[1]}

Lecturer: 蔡嘉晉 aka 明世宗 aka 世宗大王 aka 小菜 aka c++殭屍 aka 失蹤 aka cjtsai aka 西追蔡

你爽就好

建北電資聯合演算法小社課[1]

INDEXINDEX

  • I/O優化

我推的戰棋 Fire Emblem Three HousesFire\:Emblem\:Three\:Houses

  • 指標
  • 參考
  • 位元運算
  • 函式
  • 遞迴
  • struct

其實我是連結喔

其實我覺得今天的內容放在第二堂語法蠻燒ㄉ

大家有問題都可以直接問喔

{I/O優化}

讓我們從簡單一點的東西開始

IO優化

  • Input / Output Optimization 輸入輸出優化
  • IO優化之輸入輸出流
    • c++有兩種輸入系統 stdiostdio iostreamiostream
    • 為了避免混用 c++會將這兩種輸出系統同步
    • 但這樣會使效率降低 且打競程不會出現混用的情況 
    • ios_base::sync_with_stdio(false);
    • 這樣之後就不能用 scanf printf 囉
#include <bits/stdc++.h>
using namespace std;
int main(){
    ios_base::sync_with_stdio(false);
}

IO優化

  • IO優化之清空緩衝區
    • 在cin的使用上 會把輸出的緩衝區清空 以讓使用者可以即時看到反應
    • 但在競程不需要這種東西 而且一直清空緩衝區很花時間
    • 還可以順便把輸入輸出分開 檢查輸出結果很方便
    • cin.tie(0);
  • 寫題目的時候記得在main函數最前面加上這個 沒加吃TLE很小丑
#include <bits/stdc++.h>
using namespace std;
int main(){
    cin.tie(0);
}

IO優化

#include <bits/stdc++.h>
using namespace std;
int main(){
    ios_base::sync_with_stdio(false);cin.tie(0);
}

反正背起來就好

為甚麼第一個是false第二個是0?我也不知道欸

反正意思是一樣的

但這樣看起來很舒服

{位元運算}

熟悉的那份簡報

位元運算?

  • 為甚麼要學位元運算?
    • 想要偷學長模板但裡面一堆位元運算我都看不懂​​​ 就是brineTW
    • 位元是電腦存數字最基本的單元
    • 位元運算速度很快
    • 在某些情況下可以加快算法實作
    • 或是apcs說他會考

程式怎麼存數字?

  • 二進位制
  • 每個位數只有0和1
  • 第 i 位數代表2i−1 2^{i-1}
value 128 64 32 16 8 4 2 1
0 0 0 0 0 0 0 0 0
93 0 1 0 1 1 1 0 1
255 1 1 1 1 1 1 1 1
  • 93(10)=01011101(2) 93_{(10)}=01011101_{(2)}
  • 這就是一個八位元的數字 能夠儲存0-255的所有數字
  • 上次說過int有範圍就是因為int是個32位元的數字
  • 如果你好奇為甚麼剛剛的"或"要用兩個"||"
  • 因為 ∣| 被"位元或"(bitwise or) 佔走了
  • 所以甚麼是位元或?
  • 對兩個數的每個位元進行一次或運算
value 128 64 32 16 8 4 2 1
178↓ 1 0 1 1 0 0 1 0
bitwise or 1 1 1 1 0 1 1 0
84  ↑ 0 1 0 1 0 1 0 0
  • 10110010(2)∣01010100(2)=11110110(2)=246(10)10110010_{(2)} | 01010100_{(2)}=11110110_{(2)}=246_{(10)}

位元邏輯運算?

位元算術運算?

  • >> n 位元右移運算子
    • 將一數字所有位元右移n格
    • aka 除 2n2^n
  • << n 位元左移運算子
    • 將一數字所有位元左移n格
    • aka 乘 2n2^n
  • 不是 cin cout 的那個喔 雖然長一樣

位元運算表

英文 符號 範例 結果
位元或 bitwise or | 6 | 11 15
位元和 bitwise and & 6 & 11 2
位元互斥或 bitwise xor ^ 6 ^ 11 13
左移運算 left shift << 5 << 3 40
右移運算 right shift >> 1243 >> 3 155

想不到吧位元運算也有題單

 

  • 話說 codeforces 這 oj 很常有比賽 雖然時間比較死人
  • 但真的很推薦常常去打比賽練手感
  • 或是可以打時間比較正常的atcoder

{指標}

要開始燒雞ㄌ

一個指向別的變數的東東

  • 因為我想不到要怎麼開頭 所以來看定義吧
  • wikipedia
    • 在電腦科學中，指標（英語：Pointer），是程式語言中的一類資料類型及其物件或變數_(程式設計)，用來表示或儲存一個記憶體位址，這個位址的值直接指向（points to）存在該位址的對象的值。
  • 重點
    • 一個變數
    • 存的值是一個記憶體位址
    • 指向另外一個變數

先來看看電腦是怎麼存變數的

  • 每個變數都會有對應的位址 並在那個位址儲存該變數的值
  • 透過取址符號 & 可以得到一個變數的位址
    • 雖然跟位元and同個符號 但用的地方不一樣就是不同意思
名 var_a var_b var_c var_d
型態 int long long string char
值 0 1 "cjtsai" 'r'
位址 0x8071 0x8072 0x8073 0x8074 
int main(){
    int var_a=0;
    cout<<var_a; //0;
    cout<<&var_a; //0x8071;
    var_a=101;
    cout<<var_a<<' '<<&var_a; // 101 0x8071
} //我只是想說變數位址跟他自己的值沒關係

每次執行的變數都會存在不同位址

不同電腦也都會有些差異喔

但格式都差不多

所以我要怎麼指別人

  • 我要知道一個變數現在的值
  • 還要知道他在被改動之後變成甚麼值
  • 怎麼做
  • 知道他的位址就好了
  • 宣告指標變數!

int* a = &b

  • b 的型態要是int   a 的型態就變成了 指向整數的指標 簡稱 int*

T* a = &b

  • b 的型態要是T   a 就變成了指向 b 的神奇指標型態 T*
  • (T的意思是template 這邊大概是要寫個標準表達式的概念

然後呢

  • 於是int*這種型態的變數存的值便會是一串代表一個記憶體位址的東西
  • 所以我指到別人了 要怎麼知道我指的那個位址所存的值?
  • 取值符號!
  • 在指標變數前面放一個* (就是宣告時用的那顆) 就會得到該記憶體位址的值囉
名 var_a pt_a var_c pt_c
型態 int int* string string*
值 0 0x8071 "cjtsai" 0x8073
位址 0x8071 0x8072 0x8073 0x8074 
int main(){
    int var_a=0;
    int* pt_a = &var_a;
    cout<<var_a; //0
    cout<<pt_a; //0x8071
    cout<<*pt_a; //0
}
int main(){
    std::string var_c="cjtsai";
    std::string* pt_c = &var_c;
    cout<<var_c; //"cjtsai"
    cout<<pt_a; //0x8073
    cout<<*pt_a; //"cjtsai"
}

複習一下

  • 宣告指標變數: *
  • 取 址 符號: &
  • 取 值 符號: *

指標的指標的指標的指標的指標?

  • 再看一下剛剛這張表
  • 指標變數也是有位址的
  • 畢竟只要是變數都會有自己的位址
  • 所以可以幹嘛?
名 var_a pt_a var_c pt_c
型態 int int* string string*
值 0 0x8071 "cjtsai" 0x8073
位址 0x8071 0x8072 0x8073 0x8074
  • 拿一個指標的指標指向這個指標
  • 或是拿一個指標的指標的指標指向剛剛那個指標的指標
  • 或是拿一個指標的指標的指標的指標指向剛剛那個指標的指標的指標?
  • 沒 不要做這種事 有夠讀

{參考}

持續燒雞中

一個參考別人的值的東東

  • 可是指標我還要甚麼取址 宣告指標 取值
  • 好麻煩喔
  • 可不可以讓這個變數的值直接跟別的變數同步阿
  • 宣告 參考 ! (reference
int main(){
    int var_a=0;
    int& ref_a=var_a;
    cout<<ref_a<<' '<<var_a; //0 0
    ref_a=10;
    cout<<ref_a<<' '<<var_a; //10 10;
}

int& a = b

T& a = b

兩個變數var_a 跟 ref_a 的值同步了!

變簡單了欸

  • 再看回來這張表
名 var_a pt_a var_c pt_c
型態 int int* string string*
值 0 0x8071 "cjtsai" 0x8073
位址 0x8071 0x8072 0x8073 0x8074
  • 參考存的值不是一個位址
  • 他跟他參考的東西是同個物體
  • 下面的程式 ref_a 該放在上表哪裡?
int main(){
    int var_a=0;
    int& ref_a=var_a;
}

ref_a

變簡單了欸

  • 再看回來這張表
名 var_a pt_a var_c pt_c
型態 int int* string string*
值 0 0x8071 "cjtsai" 0x8073
位址 0x8071 0x8072 0x8073 0x8074
  • 參考存的值不是一個位址
  • 他跟他參考的東西是同個物體
  • 下面的程式 ref_a 該放在上表哪裡?
int main(){
    int var_a=0;
    int& ref_a=var_a;
    cout<<ref_a; //0
    cout<<&var_a<<' '<<&ref_a; //0x8071 0x8071 一樣欸
}//再次複習 & 是用來取得某個變數的記憶體位址喔

ref_a

他們的記憶體位址

輸出後是同個欸

再來複習一次

  • 宣告參考: &
  • 宣告指標變數: *
  • 取 址 符號: &
  • 取 值 符號: *

 

  • 對 C++就是一個這麼破的語言
  • 一個符號可以擁有很多種意思
  • 在不同地方會自己變換喔
  • 就像*還可以順便當運算子作為乘法
  • 如果在寫函式的話我們叫這個多載

感覺好像不會用到阿

  • 聽完指標跟參考的介紹後
  • 會不會覺得我平常好好地寫扣為甚麼要用
  • 接下來就會知道ㄌ

測驗

  1. cout << a;
  2. cout << &a;
  3. cout << b;
  4. cout << *b;
  5. cout << &b;
  1. cout << c;
  2. cout << &c;
  3. cout << *c;
  4. cout << d;
  1. 10
  2. 0X8701
  3. 0X8701
  4. 10
  5. 0x8702
  1. cout << *d;
  2. cout << **d;
  3. cout << &d
  4. cout << &*d
  5. cout << &**d
  1. 10
  2. 0X8701
  3. CE
  4. 0x8702
  1. 0X8701
  2. 10
  3. 0x8703
  4. 0x8702
  5. 0x8701
int a = 10;
int *b = &a;
int &c = a;
int **d = &b;

參考自AaW建中店言大赦課簡報

{函式}

函式是什麼

  • 一個自己定義好的程式碼區塊讓你能多次呼叫相同的功能
    • 你在程式想要多次得到兩個數中比較大的那個
    • 但是每次都這樣寫很麻煩
    • 所以函式就出現了
int bigger_one;
if(a>b) bigger_one=a;
else bigger_one=b;
int get_bigger_one(int num1, int num2){
    if(num1>num2){
        return num1;
    }else{
        return num2;
    }
}

return type

回傳型別

function name

函式名稱

arguments

參數(們)

return value

回傳值

int main(){
    int a=3, b=4;
    cout<<get_bigger_one(a, b); //4
}

在main呼叫函式:

btw int  main() 也是個函式喔

return 0;就是在回傳值

只是那個回傳值會被當status code處理

函式語法

return type

回傳型別

function name

函式名稱

arguments

參數(們)

return value

回傳值

就是你之後用什麼名字呼叫這個函式

這個函式最後得出的值並回傳的是什麼型別 e.g. int char string long long

比較特別的void 此代表本函式不會回傳任何值

也可以是不同的型別 每個不同的參數用逗號隔開 寫法為 型別 變數名

在這邊對每個參數賦予名字 接下來在函式中便使用此變數名進行運算

此變數名不必與呼叫時傳入之變數名相同

就是函數運算完畢時回傳一個值作為答案

呼叫return xxx; 同時結束此函數的所有運算

若回傳型別為void 亦可寫return; 此處代表結束此函數之執行

型別 變數名

函式範例

  • 有了函式的基礎 我們來寫個可以交換兩個變數的值的函示吧
void swap(int a, int b){
    int c=a;
    a=b;
    b=c;
}
函式名稱 swap 因為目的是交換兩個東西 btw函式名稱請有意義的取
回傳型別 void 因為目的是交換兩個東西 而非對這兩個東西進行運算獲得特別的值
參數們 int a, int b 就是你要交換的兩個變數
回傳值 無 因為是void 自然就沒有回傳值
  • 好像蠻合理的 來執行看看

函式範例

#include <bits/stdc++.h>
using namespace std;

void swap(int a, int b){
    int c=a;
    a=b;
    b=c;
}

int main(){
	int a=10, b=15;
	cout<<"交換前: a="<<a<<", b="<<b<<'\n';
	swap(a, b);
	cout<<"交換後: a="<<a<<", b="<<b<<'\n';
}
  • 好像蠻合理的 來執行看看

???

我不是換掉了嗎

這就必須提到 變數作用域了

再次推vim

變數作用域

  • 變數分為 全域變數 與 區域變數
  • 全域變數
    • 宣告在任何程式碼區塊(e.g. function, struct, namespace)外的變數
    • 不管在哪裡都可以存取這個變數
  • 區域變數
    • 宣告在某個區塊裡面的變數 宣告在main裡面也是喔 因為他是個函式main()
    • 只能在這個區塊裡面存取這個變數

所以這份扣有甚麼問題

  • void swap函式吃到了a, b這兩個變數
    • 他複製了這兩個main裏面的區域變數
    • 存到swap裡面同名的區域變數!
    • 所以在裡面改動的話 只會改到swap的區域變數
    • 最後在main輸出的時候當然吃到的就只是原本沒有經過交換的a, b了
#include <bits/stdc++.h>
using namespace std;

void swap(int a, int b){
    int c=a;
    a=b;
    b=c;
}

int main(){
	int a=10, b=15;
	cout<<"交換前: a="<<a<<", b="<<b<<'\n';
	swap(a, b);
	cout<<"交換後: a="<<a<<", b="<<b<<'\n';
}

#include <bits/stdc++.h>
using namespace std;

void swap(int a, int b){
    int c=a;
    a=b;
    b=c;
}

int main(){
	int a=10, b=15;
	cout<<"交換前: a="<<a<<", b="<<b<<'\n';
	swap(a, b);
	cout<<"交換後: a="<<a<<", b="<<b<<'\n';
}

所以這份扣有甚麼問題

  • 所以我們要在swap函式裡面 直接更動 原本記憶體位址的值
  • 怎麼做?
  • 指標 or 參考
#include <bits/stdc++.h>
using namespace std;

void swap(int &a, int &b){
    int c=a;
    a=b;
    b=c;
}

int main(){
	int a=10, b=15;
	cout<<"交換前: a="<<a<<", b="<<b<<'\n';
	swap(a, b);
	cout<<"交換後: a="<<a<<", b="<<b<<'\n';
}

#include <bits/stdc++.h>
using namespace std;

void swap(int* a, int* b){
    int c=*a;
    *a=*b;
    *b=c;
}

int main(){
	int a=10, b=15;
	cout<<"交換前: a="<<a<<", b="<<b<<'\n';
	swap(a, b);
	cout<<"交換後: a="<<a<<", b="<<b<<'\n';
}

指標式

參考式

{遞迴}

遞迴只應天上有 凡人應當用迴圈

--資訊之芽

資芽你甚麼意思?

  • 解答
    • 函數的呼叫會有操作 stack frame 的執行成本。此外，遞迴不會有迴圈具有的 spatial locality，對於記憶體（其實是 cache）的存取可能比較沒有效率。
  • 但這不是重點 有興趣自己去翻資訊毒芽的講義
  • 其實真的沒什麼差啦 資芽最後也補了
    • 同樣的目的，使用迴圈的效能通常會比使用遞迴來得好一點點
    • 嗯 一點點
    • 遞迴還是一項很重要的技術可以解決很多問題喔

所以甚麼是遞迴

  • 在執行一個函式的時候 呼叫函式本身
    • 有點抽象
    • 看圖 萬年不變的那張
    • 舉個例子
    • 費波納氣數列
    • ai=ai−1+aai−2a_i=a_{i-1}+a_{a_i-2}
    • 先看扣
#include <bits/stdc++.h>
using namespace std;

int fibo(int n){
   if(n==1) return 1;
   if(n==2) return 1;
   return fibo(n-1)+fibo(n-2);
}

int main(){
   cout<<fibo(5); //5
}

遞迴結構

#include <bits/stdc++.h>
using namespace std;

int fibo(int n){
   if(n==1) return 1;
   if(n==2) return 1;
   return fibo(n-1)+fibo(n-2);
}

int main(){
   cout<<fibo(5); //5
}

這裡我們在定義fibo這個函數

但我們在定義的時候使用了fibo這個函數

這就是遞迴函式特殊的寫法

我叫 邊界條件

邊界條件

如果沒有邊界條件 呼叫了 fibo(1) 會發生甚麼事?

fibo(1)會去呼叫 fibo(0)跟fibo(-1) 但這完全不合理

所以我們要設定邊界 適當的邊界能使程式執行成功並且不會吃到一些錯誤

像是maximum recursion depth exceed之類的

注意函式要宣告在main函數外面

但是好像有個東西叫做lambda

你可以輕鬆寫出比這個好很多的fibo函式

但我們先別在意這個問題

模擬一下遞迴

  • main()
    • fibo(5)
      • fibo(4)
        • fibo(3) 
          • fibo(2) return 1;
          • fibo(1) return 1;
        • fibo(2) return 1;
      • fibo(3)
        • fibo(2) return 1;
        • fibo(1) return 1;
#include <bits/stdc++.h>
using namespace std;

int fibo(int n){
   if(n==1) return 1;
   if(n==2) return 1;
   return fibo(n-1)+fibo(n-2);
}

int main(){
   cout<<fibo(5); //5
}

return 2;

return 3;

return 2;

return 5;

順帶一提

不覺得這個遞迴呼叫了很多次相同的東西嗎

如果可以記錄已經算過的項 紀錄狀態

是不是能快很多呢

但這就是以後的事了

遞迴之優劣分析

  • 空間要求很大
    • 可能遞迴太多層就吃MLE了
  • 時間可能也比較慢
    • 一直呼叫函數 執行的指標一直跳來跳去
    • 就跳成TLE了
  • 蛤那遞迴好爛喔
    • 不是欸
  • 可讀性高
    • 可以用遞迴寫的東西常也可以用迴圈寫 但會比較難理解
  • 好寫
    • 可能是你看到題目最先想到的解法
    • 也可以暴力解題目的方式

題單時間

為甚麼我複製你的扣會TLE!

  • 不覺得這個遞迴呼叫了很多次相同的東西嗎
  • 如果可以記錄已經算過的項 紀錄狀態
  • 是不是能快很多呢
  • 如果我開一個陣列紀錄已經算過的值
  • 之後是不是需要取用第x項的值 就可以直接存取而不用重算呢

{struct}

好難用又好好用

wat is struct

  • 自定義資料結構
  • 想像一下你要紀錄一個人的姓名 身高 體重 等資料
  • 怎麼做？
  • 開個陣列紀錄？ 但一個陣列只能存一個資料型態欸 又不是python
  • 開n個變數存？ 也太麻煩
  • struct!
  • 看扣先
struct person{
   string name;
   int seat_no;
   int height;
   int weight;
}; //<-我超重要 一定要加這個分號

就這樣？

  • 先別急 等下他會慢慢增肥
  • 現在宣告的是成員變數
  • 代表你宣告一個資料型態為person的變數後
  • 能夠用{person}.name來取值或賦值
  • 要先賦值再取值喔 不然會戳到怪怪的東西
struct person{
   string name;
   int seat_no;
   int height;
   int weight;
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=200;
    yoyo.weight=10;
    cout<<yoyo.name<<"的身高是: "<<yoyo.height;
}

好像可以幹嘛欸

  • 有了這些資料 我們好像就可算這個人的bmi
  • 怎麼做？
struct person{
   string name;
   int seat_no;
   int height;
   int weight;
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=200;
    yoyo.weight=10;
    cout<<yoyo.name<<"的身高是: "<<yoyo.height;
}

好像可以幹嘛欸

  • 有了這些資料 我們好像就可算這個人的bmi
  • 怎麼做？
  • 出了點小trouble
  • 你執行會發現 他輸出了bmi為0
  • 或是甚至在某些編譯器被噴錯誤
  • 因為bmi這個成員變數
  • 在宣告yoyo這個person的時候便被決定了
  • 也就是他從一個未賦值的情況下去計算bmi
  • 此後對height與weight重新賦值都不會再更新到bmi
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi=weight/(height*height);
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=2.0;
    yoyo.weight=10;
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi;
}

那怎辦

  • 可是我們還是想計算bmi值欸
  • 所以我們需要在每次計算bmi的時候
  • 重新去存取自己的height跟weight
  • 成員函式！
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi=weight/(height*height);
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=2.0;
    yoyo.weight=10;
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi;
}

成員函式

  • 就像上個部分講到的函式
  • 相同的概念但是被包在struct裡面
  • 呼叫的時候要
  • {struct的名字}.{成員函式的名字}()
    • e.g. yoyo.bmi()
  • 記得要加括號 就像函式那樣
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi(){
     return weight/(height*height);
   }
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=2.0;
    yoyo.weight=10;
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi();
}

還有哪裡可以更好

  • 可是這樣每次宣告一個struct的變數
  • 都要定義每個成員函數
  • 好煩喔
  • 怎麼辦
  • 來寫建構式吧
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi(){
     return weight/(height*height);
   }
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=2.0;
    yoyo.weight=10;
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi();
}

{constructor}

我沒有要講destructor

constructor中間包著一個struct欸

建構式是幹嘛的

  • 每次都要宣告變數後再賦值太麻煩了
  • 那就在宣告的時候順便一起做吧
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi(){
     return weight/(height*height);
   }
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo;
    yoyo.name="甲";
    yoyo.seat_no=32;
    yoyo.height=2.0;
    yoyo.weight=10;
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi();
}

建構式是幹嘛的

  • 在struct裡面開一個無回傳型別的函數 (不是void
  • 此函式名稱要跟struct自定義的名稱一樣
  • 函式的參數就放你宣告變數的時候要輸入的
  • 這樣就可以用一個函式的方式
  • 來宣告變數了 並且有預設值
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi(){
     return weight/(height*height);
   }
   person(string _name, int _seat_no, float _height, float _weight){
       name    = _name;
       seat_no = _seat_no;
       height  = _height;
       weight  = _weight;
   } //其實可以 string name  ... name=name; 但那樣好醜
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo("甲", 32, 2.0, 10.0);
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi();
}

啊怎麼連寫建構式都懶

  • 但是要寫一堆 xxx = _xxx 好麻煩喔
  • 直接長到放不下了
  • 但可以在小括號後放個冒號 用『成員變數(值)』來賦值
  • 注意最後還要放個大括號 即使裡面是空的
struct person{
   string name;
   int seat_no;
   float height;
   float weight;
   float bmi(){
     return weight/(height*height);
   }
   person(string _name, int _seat_no, float _height, float _weight):name(_name), seat_no(_seat_no), height(_height), weight(_weight){}
}; //<-我超重要 一定要加這個分號

int main(){
    person yoyo("甲", 32, 2.0, 10.0);
    cout<<yoyo.name<<"的bmi是: "<<yoyo.bmi();
}

往後滑➮

struct應該是不會有題單了啦

  • struct的用途是未來在上到 真正的演算法 與 資料結構 的時候
  • 可以用struct把他包起來方便存取與使用
  • 作為一個模板也很方便

我發現一件很神奇的事情喔

今天講的東西每個都有一句

可以搭配以後的演算法使用

蔗糖小設課叫演算法小設喔

現在只是先在教語法的基礎

之後要趕進度ㄌ湊字數的我

是秋遊

要來欸

報名表單(點我

根據我燒雞的物理段考 我覺得這個可能有點難達到靜力平衡

演算法之語法之一

By cjtsai

Made with Slides.com

演算法之語法之一

  • 476

More from cjtsai