函式(function)的概念類似於數學中的函數(function)，一樣都是有輸入、輸出，之中的運作也有一定的關係。

(圖片取自維基百科)

直接看範例
有回傳值：

int add(int a, int b){
    return a+b;
}

函式會在執行完return後直接停止。

無回傳值：

void printmessage(){//沒有輸入小括號還是要留著
  cout << "I'm a function!";
}

#include <iostream>
using namespace std;
 
int f(int a, int b){
    return a*a+5*b+2;
    cout << a;
}
 
void g(int a,int b){
    cout << "a=" << a << " " << "b=" << b << endl;
}
 
int main(){
    int a=3,b=7;
    g(a,b);
    int c=f(a, b);
    cout << c;
}

/*---output
a=3 b=7
46
---------*/

#include <iostream>
using namespace std;
 
int power(int a, int b=2){
    int re=1;
    for(int i=0;i<b;i++){
        re*=a;
    }
    return re;
}
 
int main(){
    cout << power(3) << " " << power(2,3);
}

/*---output
9 8
---------*/

一樣，直接看範例

沒有base case：

#include <iostream>
using namespace std;
 
int f(int a){
    cout << a;
    return f(a);
}
 
int main(){
    cout << f(4);
    cout << "end";
}

一個正確的遞迴(費波那契數)：

#include <iostream>
using namespace std;
 
long long c=0;
int fib(int a){
    if(a==1||a==2){
        return 1;
    }
    return fib(a-1)+fib(a-2);
}
 
int main(){
    cout << fib(6);
}
 
//8

比如說…你沒辦法用一個 2*x 的陣列把不同資料型態的兩個變數綁在一起(例如: int+char)

或者…當兩種以上資料型態相同但「性質不同」的變數綁在一起時，這個情況也不適合用陣列當「複合型別的資料型態」(例如:xyz座標.身高+體重+視力)

你說這些你都可以用(一或多個)一維或二維陣列解決!?

那你就用5*n的(或5個)陣列記錄每個人的身高.體重.視力.年齡.體指率阿😑😑

保證你被一堆索引或零散的陣列搞瘋(╯°□°）╯︵ ┻━┻

struct

是一種複合型別 (derived data type)，在寫程式時可以大幅增加程式的結構與可讀性，減少冗餘，是個很棒的東西。

簡單來說它是一種自創的資料型態(可以將相同或不同資料型態的變數綁在一起)

還可以將不直覺的索引編號用直覺的名字代替(如:x.y)

宣告

• 用法: struct 自訂資料型態{成員1;成員2;...函式1{ }...};

• 說明:
  -資料成員(data member):在某一個struct裡面宣告一些資料型態，而這些宣告的資料型態就是資料成員(類似於陣列中的索引)
  -成員函式(member function):可以想成放在某struct目錄內的函式

• 寫法:等同於在struct區塊宣告變數和函式
• 注意:struct 要在大括號後加分號，函式不用

struct people{
    int height,weight;
    double bmi;
    double get_bmi(){
        return bmi=weight/(height*height/100.0/100);}
};

呼叫

用法: 先宣告一個資料型態為【struct名稱】的變數，再利用 變數名稱.某成員或函式 呼叫該變數的指定成員或函式

int main() {
    people room[50];
    while(cin>>n){
        for(int i=0;i<n;i+=1){
            cin>>room[i].height>>room[i].weight;
            cout<<room[i].get_bmi()<<' ';
        }
    }
}

/*---input
5
160 45
180 70
173 75
164 55
158 63
---------*/

/*---output
17.5781 21.6049 25.0593 20.4491 25.2363 
---------*/

程式內

如果class只是單支程式的一部分的話，它就是能分類成員存取權限的struct
權限分為public、private和protected(這個我們不討論)

• public : 此成員或函式在class內、外都可以使用
• private : 只能在class內使用，或是透過public內的函數使用

透過private可以把資料封在class內(封裝)，讓外界不要隨便存取class的資料

宣告

• 列出成員及函式，為了方便尋找成員和函式，先不寫函式內容，以求簡短
• class中需頻繁使用的變數通常設在private，因為可以設成簡短的變數，不怕和class外的變數重複

class division{
    public:
        void set_a(int n);//set=賦值
        void set_b(int n);
        int get_a();//get=取值
        int get_b();
        double do_div();//相除
    private:
        double a;
        double b;
};

實作

在class外寫函式的內容，記得在函式名稱前面加上所屬class的名稱，並接上 :: ，不然會被認定為一般的function

void division::set_a(int n){
	a=double(n);
}
void division::set_b(int n){
	b=double(n);
}
double division::get_a(){
	return a;
}
double division::get_b(){
	return b;
}
double division::do_div(){
	return get_a()/get_b();
}

呼叫

呼叫就跟struct的用法一樣啦–
先宣告一個資料型態為【class名稱】的變數，再利用 變數名稱.某成員或函式 呼叫該變數的指定成員或函式

int main() {
	int x,y;
	while(cin>>x>>y){
	division ans;
	ans.set_a(x);
	ans.set_b(y);
	cout<<ans.do_div()<<'\n';
	}
}

/*---input
180 70
164 55
158 63
---------*/

/*---output
2.57143
2.98182
2.50794 
---------*/

.h

不常用的零件在程式內額外寫ok
但常用的零件如果每次要用的時候都得花時間寫一次，是不是很麻煩?
就像我們只需要知道電腦要怎麼用就好，不需要知道怎麼裝電腦，更不會在每次開電腦前，就組裝一次電腦

我們可以自己寫一個工具箱，做成.h的標頭檔

實作方式就是–

• 1.宣告 => 將class宣告的部分存成一個.h檔
• 2.實作 => 將實作的部分存成一個同名的.cpp檔
• 3.呼叫 => 再開一個檔案寫你的程式，就可以使用你自製的標頭檔了
• 注意:2.3.的程式要引入第一個檔名做標頭檔，且此標頭檔要用雙引號括住而不是 <>
  如:include"division4"

範例

檔案名稱:division4.h

class division{
    public:
        void set_a(int n);//set=賦值
        void set_b(int n);
        int get_a();//get=取值
        int get_b();
        double do_div();//相除
    private:
        double a;
        double b;
};

檔案名稱:division4.cpp

include"division4"
void division::set_a(int n){
	a=double(n);
}
void division::set_b(int n){
	b=double(n);
}
double division::get_a(){
	return a;
}
double division::get_b(){
	return b;
}
double division::do_div(){
	return get_a()/get_b();
}

檔案名稱:main555.cpp

include<iostream>
incude"division4.h"
using namespace std;
int main() {
	int x,y;
	while(cin>>x>>y){
	division ans;
	ans.set_a(x);
	ans.set_b(y);
	cout<<ans.do_div()<<'\n';
	}
}

最後在terminal同時編譯 division4.cpp main555.cpp 就可以了

建構子(constructor)

剛剛的例子中，每當我們需要將兩個數相除，就得在main裡面用兩個函式來初始化a、b的值，難道我們不能在宣告變數型態時就初始化兩數的值?

可以的，這個方法叫建構函式

建構函式就是寫個與 struct 或 class 同名的函式，在宣告變數的時候就能順便進行這個函式

建構函式:

division::division(int n1,int n2){
    set_a(n1);
    set_b(n2);
}

額外加上函式這個即可

呼叫:

int main() {
	int x,y;
	while(cin>>x>>y){
	division ans(x,y);
	cout<<ans.do_div()<<'\n';
	}
}

少了兩行是不是簡潔許多阿

多載

我們還可以根據輸入資料型態的不同，對應不同的建構函式，這個方法叫多載

呼叫:

int main() {
	division ans(7,2);
    division ans2(6.25,3.11);
	cout<<ans.do_div()<<'\n';
    cout<<ans2.do_div()<<'\n';
	}
}

這樣我們就不用限定輸入的資料型態必須是整數，才能使用這個函式了

我們能方便的呼叫的函式庫裡的函式，正是因為那些函式有經過「建構」與「多載」的處理😁。

在第三次社課時有出現過這張圖，當時是在講變數儲存的方法，而變數所處存的位置(地址)就稱作為指標，指標可以直接讀取記憶體，利用這個特性除了可以讓程式進行得更快速，還可以達成區塊外讀取或更改變數值。

想要取得一個變數的指標可以透過取址運算子(&)來達成，這裡與位元運算子的AND不同，AND是用來運算兩個數字，而取址運算子是加在變數前的。

#include <iostream>
using namespace std;
 
int main(){
    int a=7;
    cout << "a=" << a << "\na的位置：" << &a;
}

/*----output
a=7
a的位置：0x61fe1c
----------*/

指標是由一串16進位的數字組成，這串數字所代表的就是記憶體的位置代碼，沒有其他意義。

#include <iostream>
using namespace std;
 
int main(){
    int a=7;
    int *ptr=&a;
    cout << "The value of a is " << a << endl;
    cout << "The address of a is " << ptr << endl;
    cout << "The value in " << ptr << " is " << *ptr << endl;
    cout << "The address of ptr is " << &ptr << endl;
}

/*----------output
The value of a is 7
The address of a is 0x61fe1c
The value in 0x61fe1c is 7
The address of ptr is 0x61fe10
----------------*/