10/22|類別與建構子(Ch 6–7)

中山大學 C 程式設計自學指南 Ch 6–7:建構子、初始化列表、預設建構子消失的原因、解構子與 static 成員,以 BankAccount 為完整範例,附練習題。

發布
更新
字數
5,841
閱讀
約 15 分鐘
瀏覽
91
系列與本頁目錄
  1. 總覽
  2. 環境設置:把工具鏈準備好
  3. 09/10|課程介紹與環境暖身
  4. 09/17|C++ 基礎(Ch 1)
  5. 09/24|流程控制與函式基礎(Ch 2、Ch 3)
  6. 10/01|參數傳遞與函式重載(Ch 4)
  7. 10/08|陣列(Ch 5)
  8. 10/15|結構與類別(Ch 5–6)
  9. 10/22|類別與建構子(Ch 6–7)
  10. 10/29|vector 與運算子重載入門(Ch 7)
  11. 11/05|期中上機考(範圍 Ch 1–6)
  12. 11/12|運算子重載、friend 與 string(Ch 8、Ch 9)
  13. 11/19|指標、動態記憶體與 C 風格字串(Ch 9、Ch 10)
  14. 11/26|分離編譯與命名空間(Ch 11)
  15. 12/03|檔案輸入輸出(Ch 12)
  16. 12/10|繼承(Ch 14)
  17. 12/17|期末筆試(範圍 Ch 1–12、Ch 14)
  18. 12/24|期末上機考(範圍 Ch 1–12、Ch 14)
  19. 附錄:編譯選項、Makefile、錯誤訊息與名詞速查
  1. 建構子在解決什麼問題
  2. 初始化列表(member initializer list)
  3. 自己寫了建構子,預設建構子就沒了
  4. 一個完整的例子:BankAccount
  5. 成員也可以是另一個類別的物件
  6. 解構子:物件消失時自動呼叫
  7. static 成員:屬於「類別」而不是「物件」
  8. 本週重點回顧
  9. 本週練習題

← 10/15|結構與類別(Ch 5–6) | 回總覽 | 10/29|vector 與運算子重載入門(Ch 7) →

這週要會什麼

Text
建構子 → 重載建構子 → 初始化列表 → 預設建構子與委派 → 組合(成員是物件)→ 解構子 → static 成員

建構子在解決什麼問題

上一週的 Circle 有個隱患:

C++
Circle c;
cout << c.area();     // 忘了 setRadius,r 是垃圾值 → 印出垃圾

建構子(constructor) 就是為了保證「物件一出生就處於合理狀態」而存在的。

它有三個特徵:

  1. 名字必須與類別完全同名。
  2. 沒有回傳型別(連 void 都不能寫)。
  3. 建立物件時自動被呼叫。Circle b(5); 的 (5) 就是交給建構子的引數;建構子只在物件誕生的那一刻自動跑一次,之後不能像一般成員函式那樣寫 b.Circle(); 再叫它一次。
C++
#include <iostream>
using namespace std;

class Circle {
private:
    double r;

public:
    Circle() { r = 1.0; }                  // 預設建構子(無參數)
    Circle(double x) { r = (x >= 0) ? x : 0; }   // 帶一個參數的建構子

    double area() const { return 3.14159265358979 * r * r; }
};

int main() {
    Circle a;          // 自動呼叫 Circle()   → r = 1
    Circle b(5);       // 自動呼叫 Circle(5)  → r = 5
    cout << a.area() << '\n';     // 3.14159
    cout << b.area() << '\n';     // 78.5398
    return 0;
}

輸出:

Text
3.14159
78.5398

同一個類別可以有好幾個建構子,靠參數的個數與型別決定用哪一個——這就是 10/01 學過的函式重載,只是套用在建構子上。

雷區 ①:建立無參數物件時不要加括號

C++
Circle a();      // 這不是建立物件!編譯器認為你在「宣告一個回傳 Circle 的函式 a」
Circle a;        // 正確

較新的 g++(11 以上)會先給警告 warning: empty parentheses were disambiguated as a function declaration [-Wvexing-parse](虛擬機的 g++ 9 沒有這個警告),接著在用到 a 的地方報 error: request for member 'area' in 'a', which is of non-class type 'Circle()'。看到 non-class type 'Circle()' 這種帶括號的型別名,就是踩到這個坑了。課本上的名稱是 most vexing parse。

初始化列表(member initializer list)

建構子還有一種寫法:在大括號之前就把成員的值交代掉。在大括號裡寫 r = x; 是「先生出一個 r,再把 x 蓋上去」;初始化列表 : r(x) 是「直接拿 x 把 r 生出來」,少一個步驟——而且有兩種成員只能這樣寫(等一下說)。

C++
class Circle {
    double r;
public:
    Circle(double x) : r(x) { }      // 冒號到大括號中間,就是初始化列表
};

多個成員用逗號隔開。成員是 int、double 這類內建型別時兩種寫法效果一樣,但建議一律用初始化列表——習慣養成了,之後遇到下面幾種成員才不會卡住;成員是物件(例如 string owner)時差別才明顯:{ owner = name; } 是先做一個空字串、再整個蓋掉,: owner(name) 是直接用 name 生出字串。

有兩種成員不能在大括號裡用 = 指派,只能靠初始化列表決定初值:

  • 成員是 const(常數一旦生成就不能指派)
  • 成員是參考(int&,參考必須在誕生時就決定綁誰)
C++
class Config {
private:
    const int maxUsers;
public:
    Config(int m) : maxUsers(m) { }      // 唯一可行的寫法
};

雷區 ②:初始化順序看的是「宣告順序」,不是你寫的順序

C++
class Box {
    int w;        // 先宣告
    int h;
public:
    Box(int a, int b) : h(b), w(a) { }   // 寫的順序相反
};

實際初始化順序永遠是 w 然後 h(依宣告順序)。-Wall(實際觸發的旗標叫 -Wreorder)會給你 warning: 'Box::h' will be initialized after ...——上機考這就是 2 分。解法:讓初始化列表的順序跟成員宣告順序一致。

自己寫了建構子,預設建構子就沒了

規則:只要你自己寫了任何一個建構子,編譯器就不再幫你生成無參數的預設建構子。

C++
class Circle {
private:
    double r;
public:
    Circle(double x) : r(x >= 0 ? x : 0) { }   // 只有這一個
};

Circle a;          // 編譯錯誤:no matching function for call to 'Circle::Circle()'
Circle arr[10];    // 也錯,訊息一模一樣:陣列要建 10 個元素,每個都得呼叫預設建構子

什麼時候一定要有預設建構子?兩種情況:(1) 要宣告陣列,像 Circle arr[10];;(2) 這個類別被當成別的類別的成員,而對方的建構子沒在初始化列表裡寫它。除此之外不補也活得下去(後面 Car 裡的 Engine 就是靠初始化列表活下來的)。要補就加一行 Circle() : r(1.0) { }。

也可以改用預設引數,一個建構子兼兩用:

C++
Circle(double x = 1.0) : r(x >= 0 ? x : 0) { }

但用了這招就不要再留一個無參數建構子,否則 Circle a; 兩個都配得上,編譯器會報 error: call of overloaded 'Circle()' is ambiguous。二選一。

更漂亮的做法:建構子委派(C++11)——讓一個建構子去呼叫另一個,共用的邏輯只寫一次:

C++
class Circle {
    double r;
public:
    Circle() : Circle(1.0) { }                 // 委派給下面那個建構子
    Circle(double x) : r(x >= 0 ? x : 0) { }   // 檢查負數的邏輯只寫在這裡
};

執行順序是:先整個跑完 Circle(double),回來才跑 Circle() 自己的大括號。委派時初始化列表裡不能再寫別的成員,Circle() : Circle(1.0), r(2.0) { } 會報 error: mem-initializer for 'Circle::r' follows constructor delegation。

三個做法怎麼選:兩個建構子有共同邏輯就用委派;沒有共同邏輯,補一個獨立的預設建構子最單純;預設引數只適合完全同一套邏輯的情況。

補充:類別的大括號裡是一個整體。成員函式(含建構子)彼此可以互相呼叫,不受先後順序限制,也不必像 09/24 那樣另外寫原型——上面 Circle() 委派給寫在它下面的 Circle(double) 完全合法。而且呼叫同類別的其他成員函式不用寫「物件.」,直接寫函式名就好,它會作用在「呼叫我的那個物件」身上,跟直接寫成員變數名是同一回事(Q2 的建構子就這樣呼叫 addSeconds)。

一個完整的例子:BankAccount

C++
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

class BankAccount {
private:
    string owner;
    double balance;

public:
    BankAccount() : owner("unknown"), balance(0.0) { }
    BankAccount(const string& name, double init)
        : owner(name), balance(init > 0 ? init : 0) { }

    void deposit(double x) {
        if (x > 0) balance += x;
    }

    bool withdraw(double x) {                 // 回傳是否成功
        if (x <= 0 || x > balance) return false;
        balance -= x;
        return true;
    }

    double getBalance() const { return balance; }
    string getOwner()   const { return owner; }

    void print() const {
        cout << owner << ": " << fixed << setprecision(2) << balance << '\n';
    }
};

int main() {
    BankAccount acc("Yilin", 1000);
    acc.deposit(500);
    if (!acc.withdraw(2000)) cout << "餘額不足\n";
    acc.withdraw(300);
    acc.print();
    cout << acc.getOwner() << " 的餘額是 " << acc.getBalance() << '\n';
    return 0;
}

輸出:

Text
餘額不足
Yilin: 1200.00
Yilin 的餘額是 1200.00

1000 存 500 再領 300,所以是 1200。注意 withdraw 的設計:用回傳值告訴呼叫者成功與否,而不是直接印錯誤訊息。這樣同一個類別在不同程式裡都能用——要印中文、印英文還是寫 log,交給呼叫者決定。回傳值也可以不接:acc.withdraw(300); 這一行就是知道一定成功,直接把回傳的 bool 丟掉,語法上完全合法,-Wall 也不會唸(它只管沒用到的變數,不管沒用到的回傳值)。

另外注意:print() 裡的 fixed << setprecision(2) 會一直留在 cout 上(09/17 講過),所以最後一行的 getBalance() 也印成 1200.00。不想影響後面就補一句 cout << defaultfloat << setprecision(6);——defaultfloat 是 fixed 的反向開關,6 是 cout 原本的預設有效位數;只寫 defaultfloat 不夠,留著的 setprecision(2) 會把 1200 印成 1.2e+03。

補充:inline。寫在 class 定義裡面的成員函式(像上面的 deposit、withdraw)自動算 inline——編譯器可以把函式內容直接展開在呼叫處。現在只要認得這個名詞,11/26 講 header 檔時會用到一次。

成員也可以是另一個類別的物件

資料成員不一定是 int、double,也可以是別的類別的物件:

C++
#include <iostream>
#include <string>
using namespace std;

class Engine {
private:
    int horsepower;
public:
    Engine(int hp) : horsepower(hp) { }
    void start() const { cout << horsepower << " 匹馬力,引擎發動\n"; }
};

class Car {
private:
    string name;
    Engine engine;               // Car 裡面「有一個」Engine
public:
    Car(const string& n, int hp) : name(n), engine(hp) { }   // 用初始化列表建構成員
    void start() const { cout << name << ":"; engine.start(); }
};

int main() {
    Car c("Civic", 180);
    c.start();
    return 0;
}

輸出:

Text
Civic:180 匹馬力,引擎發動

兩件事要記住:

  1. 成員物件會先被建構,才輪到外層類別建構子的大括號。所以 Car 建構子的大括號裡可以放心用 engine(例如直接呼叫 engine.start()),它已經初始化完畢。物件消失時順序相反:先跑外層 Car 的解構子,才輪到成員 engine(解構子是下一節的主題)。
  2. 上面的 Engine 只有帶參數的建構子、沒有預設建構子,所以 Car 一定要在初始化列表裡寫 engine(hp),不能省略——因為編譯器不知道該怎麼生出那個成員。

這種「A 裡面有一個 B」的寫法叫組合(composition),講繼承那一節會拿它跟繼承比較。

解構子:物件消失時自動呼叫

解構子(destructor) 的名字是 ~ 加上類別名(~Widget()),沒有參數、沒有回傳型別,一個類別只能有一個;物件生命結束時(離開所在區塊、或程式結束)自動被呼叫,就像區域變數離開區塊就消失一樣。下一節先拿它做「物件消失時計數減一」,真正重要的用途(歸還記憶體)留到指標那一節。

static 成員:屬於「類別」而不是「物件」

C++
#include <iostream>
using namespace std;

class Widget {
private:
    static int count;              // 宣告:所有物件「共用」這一個變數

public:
    Widget()  { count++; }         // 每建立一個物件,就把共用的 count 加 1
    ~Widget() { count--; }         // 解構子:物件消失時自動呼叫,count 減 1
    static int getCount() { return count; }
};

int Widget::count = 0;             // 定義:寫在類別外面,整個程式只寫一次

int main() {
    cout << Widget::getCount() << '\n';     // 0(不需要物件就能呼叫)
    Widget a, b;
    cout << Widget::getCount() << '\n';     // 2
    {
        Widget c;
        cout << Widget::getCount() << '\n'; // 3
    }                                       // c 在這裡消失,count 減回 2
    cout << Widget::getCount() << '\n';     // 2
    return 0;
}

輸出:

Text
0
2
3
2
  • 一般成員每個物件各有一份;static 成員整個類別只有一份,所有物件共用。典型用途是「統計目前有幾個物件」「產生不重複的流水號」。
  • 為什麼要在類別外面多寫 int Widget::count = 0;?因為 class 只是藍圖,不會真的配置記憶體;static 資料成員必須在檔案最外層(不能寫在 main 裡)安排真正的位置並給初值,整個程式只寫這一次,而且這一行不可以再寫一次 static。它雖然寫在類別外面,卻是這個成員的定義,所以是 private 的唯一例外,不會被權限擋下來——在 main 裡寫 Widget::count 才會報 is private within this context。
  • static 成員函式:函式前面加 static(例如 getCount())。它不是對著某個物件呼叫的,裡面沒有「我是哪個物件」這個資訊,所以只能碰 static 成員;好處是不必先有物件,寫成 Widget::getCount()。(成員函式寫在類別裡就結束了,不用像資料成員那樣在類別外再定義一次。)
  • 這個計數器有個盲點:Widget d = a; 這種複製不會經過 Widget(),count 不會加,但 d 消失時解構子照樣減,就會數錯。複製走的是「拷貝建構子」,Q4 會先補一個最簡單的版本,11/19 再完整講。

本週重點回顧

  • 建構子與類別同名、沒有回傳型別、建立物件時自動呼叫;同名不同參數就是重載。
  • Circle a(); 是宣告函式,不是建立物件;無參數就寫 Circle a;。
  • 初始化列表優先,const 與參考成員不能在大括號裡指派、只能用它;初始化順序依宣告順序(寫反會有 -Wreorder 警告)。
  • 自己寫了任何建構子,預設建構子就沒了;要宣告陣列或被別人當成員時記得補一個(或用建構子委派共用邏輯)。
  • 成員可以是別的類別的物件(組合):成員先建構,才輪到外層建構子的大括號;解構順序相反。
  • 解構子 ~類別名() 在物件生命結束時自動呼叫。
  • static 資料成員全類別共用、這門課的寫法是在類別外定義一次;static 成員函式不必有物件就能呼叫,但只能碰 static 成員。

本週練習題

Q1. 委派建構子
把 Circle 改寫成:預設建構子用建構子委派呼叫帶參數版本(預設半徑 1,負數視為 0),提供 area() 與 perimeter();在 main 裡分別用預設建構子與半徑 5 各建一個物件,每個物件印出面積與周長各一行,輸出到小數第四位。

Text
輸出:
3.1416 6.2832
78.5398 31.4159
參考解答
C++
#include <iostream>
#include <iomanip>
using namespace std;

class Circle {
private:
    double r;

public:
    Circle() : Circle(1.0) { }                   // 委派給下面那個建構子
    Circle(double x) : r(x >= 0 ? x : 0.0) { }

    double area() const      { return 3.14159265358979 * r * r; }
    double perimeter() const { return 2 * 3.14159265358979 * r; }
};

int main() {
    Circle a;
    Circle b(5);
    cout << fixed << setprecision(4);
    cout << a.area() << ' ' << a.perimeter() << '\n';
    cout << b.area() << ' ' << b.perimeter() << '\n';
    return 0;
}

「負數視為 0」這段共同邏輯只寫在帶參數的建構子裡,預設建構子委派過去就自動享有,不必抄第二遍。

Q2. Time 類別
寫 class Time,存時、分、秒(private)。提供預設建構子(00:00:00)與 Time(int h, int m, int s) 兩個建構子、addSeconds(int n)(加上 n 秒,超過 24 小時自動繞回)、print()(輸出 hh:mm:ss)。輸入四個整數:時、分、秒、要加的秒數。

Text
輸入: 23 59 50 20
輸出: 00:00:10
參考解答
C++
#include <iostream>
#include <iomanip>
using namespace std;

class Time {
private:
    int h, m, s;

public:
    Time() : h(0), m(0), s(0) { }
    Time(int hh, int mm, int ss) : h(0), m(0), s(0) {
        addSeconds(hh * 3600 + mm * 60 + ss);   // 直接借用 addSeconds 的換算
    }

    void addSeconds(int n) {
        int total = (h * 3600 + m * 60 + s + n) % 86400;
        h = total / 3600;
        m = (total % 3600) / 60;
        s = total % 60;
    }

    void print() const {
        cout << setfill('0')
             << setw(2) << h << ':' << setw(2) << m << ':' << setw(2) << s
             << setfill(' ') << '\n';
    }
};

int main() {
    int hh, mm, ss, n;
    cin >> hh >> mm >> ss >> n;
    Time t(hh, mm, ss);
    t.addSeconds(n);
    t.print();
    return 0;
}

技巧:把「時分秒」一律換算成「總秒數」再運算,最後換回來,就不用處理一堆進位的 if。(total % 3600) / 60 的括號其實可以省略(% 和 / 優先順序相同,同一層由左到右算),但加上去比較不會看錯。另外注意建構子直接呼叫了 addSeconds——同一個類別的成員函式互相呼叫不用寫「物件.」,重複的邏輯只寫一個地方。

Q3. Date 類別與合法性檢查
寫 class Date,建構子接受年、月、日,若日期不合法(含閏年判斷)則設為 2000/1/1。提供 print() 輸出 YYYY/MM/DD,以及 isLeapYear()。

閏年規則:是 4 的倍數但不是 100 的倍數,或者是 400 的倍數。

Text
輸入: 2024 2 30
輸出: 2000/01/01
參考解答
C++
#include <iostream>
#include <iomanip>
using namespace std;

class Date {
private:
    int y, m, d;

    static bool leap(int year) {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    }

    static bool valid(int year, int month, int day) {
        if (year < 1 || month < 1 || month > 12 || day < 1) return false;
        int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        if (month == 2 && leap(year)) return day <= 29;
        return day <= days[month];
    }

public:
    Date() : y(2000), m(1), d(1) { }
    Date(int year, int month, int day) : y(2000), m(1), d(1) {
        if (valid(year, month, day)) { y = year; m = month; d = day; }
    }

    bool isLeapYear() const { return leap(y); }

    void print() const {
        cout << setfill('0') << setw(4) << y << '/'
             << setw(2) << m << '/' << setw(2) << d
             << setfill(' ') << '\n';
    }
};

int main() {
    int y, m, d;
    cin >> y >> m >> d;
    Date date(y, m, d);
    date.print();
    return 0;
}

leap 與 valid 寫成 private static 成員函式:它們是類別內部的工具,外面不該直接呼叫;寫成 static 是因為它們只靠參數算答案、不必碰任何物件的資料(這兩個函式寫在類別裡就結束了,不用在類別外再定義一次)。

Q4. 物件計數器
寫一個 class Counter,用 static 成員統計「目前存在幾個物件」與「總共建立過幾個物件」,並用一段程式驗證兩者的差別。用 Counter f = c; 複製出來的物件也要算進去。

Text
輸出:
inside : alive=6 created=6
outside: alive=2 created=6
參考解答
C++
#include <iostream>
using namespace std;

class Counter {
private:
    static int alive;      // 目前存在的數量
    static int created;    // 累積建立過的數量

public:
    Counter()  { alive++; created++; }
    Counter(const Counter&) { alive++; created++; }   // 拷貝建構子:用另一個物件複製出新物件時呼叫
    ~Counter() { alive--; }

    static int getAlive()   { return alive; }
    static int getCreated() { return created; }
};

int Counter::alive = 0;
int Counter::created = 0;

int main() {
    Counter a, b;
    {
        Counter c, d, e;
        Counter f = c;                    // 複製:走的是拷貝建構子
        cout << "inside : alive=" << Counter::getAlive()
             << " created=" << Counter::getCreated() << '\n';
    }
    cout << "outside: alive=" << Counter::getAlive()
         << " created=" << Counter::getCreated() << '\n';
    return 0;
}

離開內層區塊時 c、d、e、f 的解構子把 alive 減回 2,但 created 只加不減,所以還是 6。拷貝建構子那行是關鍵:Counter f = c; 不會呼叫 Counter(),而是呼叫「參數是 const Counter&」的那個建構子;編譯器預設會幫你生一個只複製成員的版本,它不會幫你 alive++,於是 f 消失時 alive-- 就多扣了一次。自己寫一個、在裡面計數,數字才對。這是正文 Widget 那個例子的盲點,也是 11/19 三法則的第一次登場。

實驗課題型加練
以下三題的題型取自去年(2025)第 7 週實驗課的課堂練習(今年的投影片還沒出,題目可能會換)。去年這週的三個關鍵字是 const 參考參數、static 成員、把上一題的類別當成員再包一層——三題是一路接著寫的。題目不是我原創的:練的東西跟去年那幾題一樣,但題目本身、規則、範例資料和解答都是我自己重寫的,不是原題。

Q5. 兩個日期是否相同(const 參考參數)
寫 class Date,建構子收年月日,isValid() 檢查日期存在(含閏年二月),sameAs(const Date& other) const 比較是否同一天。讀入兩個日期,任一不合法印 invalid date,否則印出比較結果。

Text
輸入:
2026 9 10
2026 9 10
輸出: 2026/9/10 == 2026/9/10
Text
輸入:
2026 2 29
2026 3 1
輸出: invalid date
參考解答
C++
#include <iostream>
using namespace std;

class Date {
public:
    Date(int y, int m, int d) : year(y), month(m), day(d) {}
    bool isValid() const {
        if (month < 1 || month > 12 || day < 1) return false;
        int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        bool leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
        if (leap && month == 2) return day <= 29;
        return day <= days[month - 1];
    }
    bool sameAs(const Date& other) const {           // 只讀對方,所以是 const 參考
        return year == other.year && month == other.month && day == other.day;
    }
    void print() const { cout << year << '/' << month << '/' << day; }
private:
    int year, month, day;
};

int main() {
    int y1, m1, d1, y2, m2, d2;
    cin >> y1 >> m1 >> d1 >> y2 >> m2 >> d2;
    Date a(y1, m1, d1), b(y2, m2, d2);
    if (!a.isValid() || !b.isValid()) {
        cout << "invalid date\n";
        return 0;
    }
    a.print(); cout << (a.sameAs(b) ? " == " : " != "); b.print(); cout << '\n';
    return 0;
}

sameAs 的參數是 const Date&:不複製、也保證不改對方;函式本身也是 const,因為不改自己。這兩個 const 缺一個助教都會問。同一個類別的成員函式可以直接讀另一個物件的 private 成員(other.year),因為 private 是「類別外不能碰」,不是「物件外不能碰」。

Q6. 售票紀錄(static 成員)
寫 class Ticket,private 存活動名稱、座位號、票價,另外用兩個 static 資料成員統計「總共賣出幾張」與「總收入」。反覆讀入「活動 座位 票價」,讀到 end 停止;最後印出所有票、賣出張數與總收入。張數與總收入要透過 static 成員函式 Ticket::count()、Ticket::total() 取得。

Text
輸入:
Concert 12 800
Musical 3 1200
Concert 15 800
end
輸出:
Concert seat 12 $800
Musical seat 3 $1200
Concert seat 15 $800
sold: 3, revenue: 2800
參考解答
C++
#include <iostream>
#include <string>
using namespace std;

class Ticket {
public:
    Ticket() : event("?"), seat(0), price(0) {}              // 陣列需要預設建構子(不計數)
    Ticket(const string& e, int s, int p)
        : event(e), seat(s), price(p) { sold++; revenue += p; }   // 每賣一張就記一張
    void print() const {
        cout << event << " seat " << seat << " $" << price << '\n';
    }
    static int count() { return sold; }
    static int total() { return revenue; }
private:
    string event;
    int seat, price;
    static int sold;                       // 賣出幾張:整個類別共用一份
    static int revenue;                    // 總收入
};
int Ticket::sold = 0;                      // static 資料成員要在類別外定義一次
int Ticket::revenue = 0;

int main() {
    const int MAX = 100;
    Ticket list[MAX];
    int n = 0;
    string event;
    while (cin >> event && event != "end") {
        int seat, price;
        cin >> seat >> price;
        list[n] = Ticket(event, seat, price);   // 建一個暫時物件再指派進陣列
        n++;
    }
    for (int i = 0; i < n; i++) list[i].print();
    cout << "sold: " << Ticket::count() << ", revenue: " << Ticket::total() << '\n';
    return 0;
}

static int sold 屬於整個類別,不屬於任何一張票,所以「每建構一次就 sold++、revenue += p」自然就是總張數與總收入。兩個細節:int Ticket::sold = 0; 這種定義一定要寫在類別外(少了會 linker error);Ticket list[MAX]; 開陣列會對每一格呼叫預設建構子,所以要提供一個不計數的預設建構子,否則 100 格空位也會被算成賣出去的票。

Q7. 氣溫紀錄
寫 class Reading,private 存一個 Date(沿用 Q5 的類別,加一個 before() 比先後、一個 inMonth() 判斷是不是某年某月)與當天量到的氣溫,用 static 成員累計筆數與溫度總和。讀入 n 筆紀錄後:依日期由早到晚印出(同一天依氣溫由低到高)、印出筆數與平均氣溫;再讀入「年 月」,印出那個月的所有紀錄。氣溫一律印到小數一位。

Text
輸入:
5
2026 10 3 21.5
2026 9 28 24
2026 10 3 19
2026 9 5 27.5
2026 10 12 18
2026 10
輸出:
2026/9/5  27.5 C
2026/9/28  24.0 C
2026/10/3  19.0 C
2026/10/3  21.5 C
2026/10/12  18.0 C
readings: 5, average: 22.0 C
readings in 2026/10:
2026/10/3  19.0 C
2026/10/3  21.5 C
2026/10/12  18.0 C
參考解答
C++
#include <iostream>
#include <iomanip>
using namespace std;

class Date {
public:
    Date(int y = 1, int m = 1, int d = 1) : year(y), month(m), day(d) {}
    bool before(const Date& o) const {            // 「我比 o 早」
        if (year != o.year)   return year < o.year;
        if (month != o.month) return month < o.month;
        return day < o.day;
    }
    bool sameAs(const Date& o) const {
        return year == o.year && month == o.month && day == o.day;
    }
    bool inMonth(int y, int m) const { return year == y && month == m; }
    void print() const { cout << year << '/' << month << '/' << day; }
private:
    int year, month, day;
};

class Reading {
public:
    Reading() : temp(0) {}
    Reading(const Date& d, double t) : date(d), temp(t) { count++; sum += t; }
    // 排序規則:日期早的在前;同一天溫度低的在前
    bool before(const Reading& o) const {
        if (!date.sameAs(o.date)) return date.before(o.date);
        return temp < o.temp;
    }
    bool inMonth(int y, int m) const { return date.inMonth(y, m); }
    void print() const {
        date.print();
        cout << "  " << temp << " C\n";
    }
    static int total() { return count; }
    static double average() { return count == 0 ? 0 : sum / count; }
private:
    Date date;
    double temp;
    static int count;                             // 幾筆
    static double sum;                            // 溫度總和(算平均用)
};
int Reading::count = 0;
double Reading::sum = 0;

int main() {
    const int MAX = 100;
    Reading log[MAX];
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        int y, m, d;
        double t;
        cin >> y >> m >> d >> t;
        log[i] = Reading(Date(y, m, d), t);
    }
    // 選擇排序,比較規則交給 Reading::before
    for (int i = 0; i < n - 1; i++) {
        int best = i;
        for (int j = i + 1; j < n; j++)
            if (log[j].before(log[best])) best = j;
        Reading t = log[i]; log[i] = log[best]; log[best] = t;
    }
    cout << fixed << setprecision(1);
    for (int i = 0; i < n; i++) log[i].print();
    cout << "readings: " << Reading::total() << ", average: " << Reading::average() << " C\n";

    int y, m;
    cin >> y >> m;
    cout << "readings in " << y << '/' << m << ":\n";
    for (int i = 0; i < n; i++)
        if (log[i].inMonth(y, m)) log[i].print();
    return 0;
}

這題是前兩題的組合:Reading 裡面放一個 Date(10/15 說的 has-a),排序規則交給 Reading::before,而 Reading::before 又把日期的部分交給 Date::before——每個類別只管自己那層的比較。Date 的建構子給了預設值 (1, 1, 1),是為了 Reading() 這個預設建構子能編過(陣列需要它)。平均用 static 函式算,因為它是「全部紀錄」的性質,不屬於任何一筆;排序骨架還是 10/08 的選擇排序,換掉的只有比較條件和交換的型別。


← 10/15|結構與類別(Ch 5–6) | 回總覽 | 10/29|vector 與運算子重載入門(Ch 7) →

最後更新 2026.09.12

Comments

留言

支援 Markdown、程式碼高亮(```cpp)與 LaTeX($E=mc^2$),Ctrl + Enter 送出。頭像會用你的 e-mail 去 Gravatar 找,e-mail 本身不會公開。

載入留言中…

Esc

輸入關鍵字,例如「線段樹」「Makefile」「面試」。

↑ ↓ 選擇Enter 開啟