11/26|分離編譯與命名空間(Ch 11)

中山大學 C 程式設計自學指南 Ch 11:為什麼要拆檔、把類別拆成 .h 與 .cpp、include guard、多檔案編譯與 Makefile,以及命名空間,附本週練習題。

發布
更新
字數
4,576
閱讀
約 11 分鐘
瀏覽
9
系列與本頁目錄
  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. 把 Circle 拆成三個檔案
  3. 角括號 vs 雙引號,以及 #include 放哪個檔
  4. Include guard:#ifndef / #define / #endif
  5. 多檔案怎麼編譯
  6. 多檔案的 Makefile
  7. 命名空間(namespace)
  8. namespace 跨檔案怎麼寫
  9. 未命名的命名空間
  10. 巢狀命名空間
  11. 本週重點回顧
  12. 本週練習題

← 11/19|指標、動態記憶體與 C 風格字串(Ch 9、Ch 10) | 回總覽 | 12/03|檔案輸入輸出(Ch 12) →

對應課本習題:Ch11: 1, 3

這幾題各要用到什麼(動手前先看)

主課的上機考幾乎就是這些題目,所以每一題都自己寫過。下表是每題需要的東西(我的歸納,不是題目本文)與本系列對應的練習:

課本題號 要用到的東西 先練
Ch11-1 兩個函式各自拆成 .h/.cpp、放在同一個 namespace,main.cpp 只 include 需要的檔 Q4(幾乎同一題型)
Ch11-3 把一個類別整個放進 namespace,不用檔案層級的 using namespace Q1、正文〈三種使用方式〉

這週要會什麼

Text
header 檔與實作檔 → include guard → 多檔案編譯與連結 → Makefile 增量編譯 → namespace

為什麼要拆檔

當程式長到幾百行,全部塞在 main.cpp 會有三個問題:

  1. 改一個小地方就要重編整份,很慢。
  2. 多人合作時同時改同一個檔,一定衝突。
  3. 寫好的類別想在別的專案重用,只能複製貼上。

解法是把每個類別拆成兩個檔案:

  • Circle.h(header,標頭檔)放宣告:類別有哪些成員、每個函式長什麼樣,等於這個類別的說明書。
  • Circle.cpp(實作檔)放定義:每個函式實際怎麼做。

講白一點:header 放的就是 09/24 學過的函式原型(只有簽名、結尾分號),只是現在連類別一起放進去;.cpp 放帶大括號的本體。別人(或未來的你)只要 #include "Circle.h",看宣告就知道有哪些函式能呼叫,不必翻 Circle.cpp。

把 Circle 拆成三個檔案

Circle.h

C++
#ifndef CIRCLE_H
#define CIRCLE_H

class Circle {
private:
    double r;

public:
    Circle();
    explicit Circle(double x);
    double area() const;
    double perimeter() const;
    void   setRadius(double x);
    double getRadius() const;
};

#endif

最外面的 #ifndef / #define / #endif 三行叫 include guard,每個 header 都要寫,等一下的〈Include guard〉那一節會解釋它在擋什麼——先照抄。單參數建構子加 explicit 是 11/12 講過的習慣,只寫在 header 這一邊。

Circle.cpp

C++
#include "Circle.h"

const double PI = 3.14159265358979;

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

double Circle::area() const      { return PI * r * r; }
double Circle::perimeter() const { return 2 * PI * r; }
void   Circle::setRadius(double x) { r = (x >= 0) ? x : 0; }
double Circle::getRadius() const   { return r; }

建構子寫在類別外面長這樣:建構子的名字就是類別名,所以會寫成 Circle::Circle()——看起來像重複兩次,其實左邊 Circle:: 是「屬於哪個類別」、右邊才是函式名。建構子沒有回傳型別,所以 Circle:: 前面什麼都不寫,跟 double Circle::area() 前面要寫 double 不一樣。另外初始化列表只能寫在定義這一邊,header 裡的 Circle(); 後面不可以掛 : r(1.0)。

main.cpp

C++
#include <iostream>
#include <iomanip>
#include "Circle.h"
using namespace std;

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

角括號 vs 雙引號,以及 #include 放哪個檔

  • #include <iostream>:角括號用於系統/標準函式庫。
  • #include "Circle.h":雙引號用於你自己寫的檔案(先找目前目錄)。

還有一條擺放規則:header 只 include 宣告本身用得到的——資料成員型別是 std::string,.h 就非 #include <string> 不可;只有實作才用到的 <iostream>、<iomanip> 放 .cpp 就好,否則每個引入它的檔案都被迫一起吃進去。

Include guard:#ifndef / #define / #endif

#include 做的事就是把檔案內容原地貼上。如果同一個 header 被貼進來兩次(例如你後來又寫了 Canvas.h 和 Report.h,兩個都 #include "Circle.h",而 main.cpp 把兩個都引進來),類別就會被定義兩次 → error: redefinition of 'class Circle'。

C++
#ifndef CIRCLE_H     // 如果還沒定義過 CIRCLE_H 這個名字
#define CIRCLE_H     // 就定義它

/* ... 類別內容 ... */

#endif               // 結束

第二次引入時 CIRCLE_H 已經存在,整段就被跳過。每個 header 都要寫,#define 後面那個名字通常用檔名大寫加底線。(另外有個一行版的 #pragma once,效果一樣,但課本與考試請寫 #ifndef 三行式。)

guard 擋得住什麼、擋不住什麼:它只保證同一個 .cpp 裡展開一次,擋不住「兩個 .cpp 各含一次」。所以 header 裡只能放「宣告,或寫在 class 大括號裡面的東西」——類別定義(含直接寫在 class 大括號內的成員函式本體,它們自動算 inline,被兩個 .cpp 各引入一次也不會撞,所以 10/15 到 11/12 那種一體成型的類別整個搬進 header 是合法的)、函式原型、const 常數可以;把函式實作(int twice(int x) { return x * 2; })寫進 header,兩個 .cpp 各引入一次再一起連結,就會爆 multiple definition of 'twice(int)',而且 include guard 救不了,因為那是連結階段的錯,不是前置處理階段。(範例把 const double PI 放在 Circle.cpp 而不是 Circle.h,就是因為只有實作用得到。)

多檔案怎麼編譯

手動編譯(了解原理用):

Shell
g++ -c Circle.cpp        # 產生 Circle.o
g++ -c main.cpp          # 產生 main.o
g++ -o app main.o Circle.o    # 連結成執行檔
./app

輸出:

Text
78.5398 31.4159

-c 的意思是「只編譯,不連結」。每個 .cpp 各自變成一個 .o,最後一次連結起來。趕時間時也可以 g++ -o app main.cpp Circle.cpp 一行搞定,但那是整份重編;拆成 .o 的意義是「只有改過的 .cpp 需要重編」——幫你判斷哪些要重編的,就是下一節的 make。

雷區:undefined reference to 'Circle::area() const'
(const 成員函式的訊息尾巴會帶著 const;忘了編 Circle.cpp 時第一行其實是 undefined reference to 'Circle::Circle(double)',缺幾個就印幾行。)
這是連結階段的錯誤,代表「有宣告但找不到實作」。最常見原因:

  1. 忘了把 Circle.cpp 一起編譯(只 g++ -o app main.cpp)。
  2. 定義時忘了寫 Circle::/mathUtil::,變成定義了一個全域函式。(注意分兩種:漏的是 namespace 前綴一定是連結錯;漏的是類別的 Circle::,只有該函式完全不碰資料成員時才會拖到連結,像 area() 要用到 r,編 Circle.cpp 當下就先報 error: 'r' was not declared in this scope,若原本是 const 成員還會多一句 non-member function 'double area()' cannot have cv-qualifier。)
  3. 非成員函式的簽名跟 header 不一致(header 宣告 int twice(int);,cpp 卻定義成 double twice(double))——連結器照著 header 的簽名去找,找不到。(成員函式漏寫 const 則是編譯 .cpp 時就報 no declaration matches,不會拖到連結。)

另外:永遠不要 #include "Circle.cpp"。#include 只拿 .h;把 .cpp 貼進來再跟它自己一起連結,會得到一整串 multiple definition of 'Circle::Circle()'。

多檔案的 Makefile

Makefile
CC = g++
FLAG = -std=c++11

all: app

app: main.o Circle.o
	$(CC) $(FLAG) -o app main.o Circle.o

main.o: main.cpp Circle.h
	$(CC) $(FLAG) -c main.cpp

Circle.o: Circle.cpp Circle.h
	$(CC) $(FLAG) -c Circle.cpp

clean:
	rm -f *.o app

變數名照〈環境設置〉那篇(也就是助教投影片)的 CC/FLAG。rm -f *.o app 的 * 是「目前目錄下所有 .o 結尾的檔案」;rm 配 * 威力很大,下指令前先 pwd 確認站對資料夾。

為什麼 main.o 要把 Circle.h 列為相依? 因為 main.cpp 引入了它——改了 Circle.h 卻沒重編 main.o,就會編出前後不一致的程式。把 header 列進相依清單,make 才知道要重編。

跟〈環境設置〉「每題兩行」的寫法比,這裡多了一層:每個 .cpp 各自一條 .o 規則,相依清單要把它 #include 的 .h 列進去,改了 header 才會重編;最後一條規則把所有 .o 連結成執行檔。

命名空間(namespace)

當兩個函式庫都定義了 sort 或 Node,名字就會撞在一起。命名空間就是幫名字加上「姓氏」:

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

namespace square {
    double area(double a) { return a * a; }
}

namespace circle {
    double area(double r) { return 3.14159 * r * r; }
}

int main() {
    cout << square::area(3) << '\n';   // 正方形邊長 3
    cout << circle::area(3) << '\n';   // 圓形半徑 3
    return 0;
}

輸出:

Text
9
28.2743

兩邊都合理地把函式取名叫 area,有「姓氏」就不會打架。注意 namespace 的結尾大括號不加分號(跟 class/struct/enum 相反)——它是區塊不是型別定義,if、for、函式的大括號也一樣不加。

三種使用方式:

寫法 意思 建議用在哪
std::cout << "A"; 每次寫全名,最明確 header 檔一律用這個
using std::cout; using 宣告:只把 cout 一個名字拉進來 想少打字又想控制範圍時
using namespace std; using 指令:把整個 std 拉進來,最方便也最髒 只寫在 .cpp 最上面或函式內

兩種 using 都遵守作用域:寫在函式裡就只有那個函式受影響,寫在檔案最上面則是整個檔案。

重要規則:using namespace std; 絕對不要寫在 header 檔裡。
因為所有引入這個 header 的檔案都會被影響,等於強迫別人接受你的選擇,名稱衝突的風險會傳染出去。header 裡請乖乖寫 std::string。

namespace 跨檔案怎麼寫

宣告與定義分家之後,兩邊都要說清楚自己屬於哪個 namespace:

C++
// mathUtil.h —— 宣告包在 namespace 裡
namespace mathUtil { double square(double x); }

// mathUtil.cpp —— 定義也要包在同名 namespace 裡
#include "mathUtil.h"
namespace mathUtil {
    double square(double x) { return x * x; }
}
// 或不開區塊,直接寫 double mathUtil::square(double x) { return x * x; }

兩種寫法效果一樣,後者就像類別的 Circle::area。順便記一條:namespace 跟 class 不同,可以重複打開——.h 開一次放宣告、.cpp 再開一次放定義,編譯器會把同名的合併,不算重複定義。

忘了包(也沒寫 mathUtil::)就會定義出一個全域 square,mathUtil::square 只有宣告沒有實作,連結時報 undefined reference to 'mathUtil::square(double)'——正好是上一節的雷區。

未命名的命名空間

預設情況下,.cpp 裡的全域函式是跨檔可見的——別的 .cpp 寫個宣告就叫得到,也代表兩個 .cpp 各寫一個 helper 會在連結時撞成 multiple definition。包進未命名的命名空間,它就只剩本檔案看得到:

C++
// Circle.cpp
namespace {
    double helper(double x) { return x * 2; }   // 其他 .cpp 看不到這個函式
}

順帶一提:匿名 namespace 裡的函式如果同一個 .cpp 裡沒人呼叫,-Wall -Wextra 會提醒 warning: 'double {anonymous}::helper(double)' defined but not used [-Wunused-function]。這是正常的——因為編譯器很確定外面也不會有人叫它。把它真的用起來,警告就消失。

巢狀命名空間

命名空間可以包命名空間,做更細的分類:

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

namespace school {
    namespace math {
        double square(double x) { return x * x; }
    }
}
// C++17 才能縮寫成 namespace school::math { ... },這門課用 C++11,不要這樣寫

int main() {
    cout << school::math::square(3) << '\n';
    return 0;
}

輸出:

Text
9

名字一長就很囉唆,這時可以取別名:namespace sm = school::math;,之後寫 sm::square(3) 就好。

本週重點回顧

  • .h 放宣告、.cpp 放定義;class 大括號外的函式實作不要放進 header(寫在 class 裡面的成員函式是例外,自動算 inline,不會撞),兩個 .cpp 一起連結會 multiple definition,include guard 救不了。
  • 每個 header 都要加 include guard(#ifndef / #define / #endif);#include <...> 找系統函式庫,#include "..." 找自己的檔案。
  • undefined reference 是連結階段的錯誤,意思是「有宣告但找不到實作」——通常是少編譯某個 .cpp,或定義時忘了寫 類別名::/namespace 名::。
  • header 裡絕對不要寫 using namespace std;;Makefile 的相依清單一定要含 header,否則改了 header 不會重編。

本週練習題

Q1. 拆解 BankAccount
把 10/22〈類別與建構子〉那篇的 BankAccount(deposit、withdraw、getBalance、getOwner、print)拆成 BankAccount.h、BankAccount.cpp、main.cpp 三個檔案,加上 include guard,並寫一份 Makefile 讓 make 可以編出執行檔、make clean 清乾淨。

參考解答

BankAccount.h

C++
#ifndef BANKACCOUNT_H
#define BANKACCOUNT_H

#include <string>

class BankAccount {
private:
    std::string owner;      // header 裡不要 using namespace std
    double balance;

public:
    BankAccount();
    BankAccount(const std::string& name, double init);

    void deposit(double x);
    bool withdraw(double x);

    double getBalance() const;
    std::string getOwner() const;
    void print() const;
};

#endif

BankAccount.cpp

C++
#include "BankAccount.h"
#include <iostream>
#include <iomanip>
using namespace std;

BankAccount::BankAccount() : owner("unknown"), balance(0.0) { }

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

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

bool BankAccount::withdraw(double x) {
    if (x <= 0 || x > balance) return false;
    balance -= x;
    return true;
}

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

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

header 寫 std::string、.cpp 因為有 using namespace std; 而寫 string,兩者是同一個型別,簽名算一致——編譯器比對的是型別,不是字面上的文字。

main.cpp

C++
#include <iostream>
#include "BankAccount.h"
using namespace std;

int main() {
    BankAccount acc("Yilin", 1000);
    acc.deposit(500);
    if (!acc.withdraw(5000)) cout << "insufficient\n";
    acc.print();
    return 0;
}

Makefile

Makefile
CC = g++
FLAG = -std=c++11

all: app

app: main.o BankAccount.o
	$(CC) $(FLAG) -o app main.o BankAccount.o

main.o: main.cpp BankAccount.h
	$(CC) $(FLAG) -c main.cpp

BankAccount.o: BankAccount.cpp BankAccount.h
	$(CC) $(FLAG) -c BankAccount.cpp

clean:
	rm -f *.o app

Q2. 自己的工具函式庫
建立 utils.h / utils.cpp,放進 namespace utils,包含 gcd、lcm、isPrime、reverseNumber 四個函式,在 main.cpp 用 utils:: 前綴呼叫。規格:參數都是 int,isPrime 回傳 bool、其餘回傳 int;gcd/lcm 要能吃負數(先取絕對值),lcm(0, x) 回傳 0;reverseNumber 保留正負號、反轉後的前導零直接丟掉(-1230 → -321)。main.cpp 請依序各印一行:utils::gcd(24, 36)、utils::lcm(4, 6)、utils::isPrime(97)、utils::reverseNumber(-1230),預期輸出是 12 / 12 / 1 / -321。

參考解答

utils.h

C++
#ifndef UTILS_H
#define UTILS_H

namespace utils {
    int  gcd(int a, int b);
    int  lcm(int a, int b);
    bool isPrime(int n);
    int  reverseNumber(int n);
}

#endif

utils.cpp

C++
#include "utils.h"

namespace utils {

int gcd(int a, int b) {                  // 輾轉相除法(迴圈版)
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    while (b != 0) { int r = a % b; a = b; b = r; }
    return a;
}

int lcm(int a, int b) {
    if (a == 0 || b == 0) return 0;
    if (a < 0) a = -a;                 // gcd 裡取絕對值改的是它自己的複本(10/01 傳值),這裡要再做一次
    if (b < 0) b = -b;
    return a / gcd(a, b) * b;          // 先除再乘,避免中途溢位
}

bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= n / i; i++)
        if (n % i == 0) return false;
    return true;
}

int reverseNumber(int n) {
    int sign = (n < 0) ? -1 : 1;
    if (n < 0) n = -n;
    int r = 0;
    while (n > 0) { r = r * 10 + n % 10; n /= 10; }
    return r * sign;
}

}  // namespace utils

main.cpp

C++
#include <iostream>
#include "utils.h"
using namespace std;

int main() {
    cout << utils::gcd(24, 36) << '\n';        // 12
    cout << utils::lcm(4, 6) << '\n';          // 12
    cout << utils::isPrime(97) << '\n';        // 1
    cout << utils::reverseNumber(-1230) << '\n';   // -321
    return 0;
}

lcm 寫成 a / gcd(a,b) * b 而不是 a * b / gcd(a,b),是為了避免 a * b 先溢位——但這只擋得住中間的溢位;lcm(100000, 99999) 這種答案本身就超過 int 的函式,回傳型別是 int 就不可能正確,所以規格應該說清楚「結果在 int 範圍內才保證正確」。另一個容易漏的是負數:gcd 裡的 a = -a 改的是它自己的參數複本,lcm 的 a、b 還是負的,不再取一次絕對值的話 lcm(-4, 6) 會回 -12——正是 10/01 傳值的觀念。

Q3. 觀察增量編譯
用 Q1 的專案做實驗:先 make,再只改 main.cpp 裡的一行,重新 make,觀察哪些檔案被重新編譯;接著只改 BankAccount.h,再 make 一次,比較差異並解釋原因。

參考答案
  • 只改 main.cpp:只有 main.o 被重編,BankAccount.o 沒動,最後重新連結。因為 BankAccount.o 的相依檔案都沒有變新。
  • 只改 BankAccount.h:main.o 與 BankAccount.o 都會重編,因為兩條規則都把 BankAccount.h 列為相依。
  • 如果 Makefile 忘了把 header 寫進相依清單,改 header 時 make 會以為沒事做(Q1 的 Makefile 預設目標是 all,所以印的是 make: Nothing to be done for 'all'.;直接下 make app 才會看到 make: 'app' is up to date.),編出來的程式就可能不一致——這是很難查的 bug。

實驗課題型加練
下面這題的題型取自去年(2025)第 10 週實驗課的課堂練習(今年的投影片還沒出,題目可能會換):三個同名函式各放在自己的 namespace 與自己的 .cpp,必須用 Makefile 編譯、執行檔名指定。題目不是我原創的:練的東西跟去年那題一樣,但要做的轉換、檔名、輸出格式和解答都是我自己重寫的,不是原題。這是檢查分離編譯的標準題型,做完就等於期末上機考多檔案題的暖身。

Q4. 三種轉換(namespace + 分離編譯)
讀入一個非負整數,用三種方式輸出:左右反轉(123 → 321)、二進位(123 → 1111011)、八進位(123 → 173)。三個功能分別放在 namespace Reverse、Binary、Octal 裡,函式都叫 show。檔案拆成:formats.h(只放三個宣告)、reverse.cpp、binary.cpp、octal.cpp(各自實作)、main.cpp;Makefile 要能編出名為 convert 的執行檔,make clean 要能清乾淨。

Text
輸入: 123
輸出:
reverse: 321
binary:  1111011
octal:   173
參考解答

formats.h

C++
#ifndef FORMATS_H
#define FORMATS_H

// 三個命名空間裡各有一個同名的 show:拆檔後每個放在自己的 .cpp
namespace Reverse { void show(int number); }
namespace Binary  { void show(int number); }
namespace Octal   { void show(int number); }

#endif

reverse.cpp

C++
#include <iostream>
#include "formats.h"
using namespace std;

void Reverse::show(int number) {
    int r = 0;
    while (number > 0) {
        r = r * 10 + number % 10;
        number /= 10;
    }
    cout << "reverse: " << r << '\n';
}

binary.cpp

C++
#include <iostream>
#include <string>
#include "formats.h"
using namespace std;

void Binary::show(int number) {
    string bits;
    if (number == 0) bits = "0";
    while (number > 0) {
        bits = static_cast<char>('0' + number % 2) + bits;   // 餘數接在前面
        number /= 2;
    }
    cout << "binary:  " << bits << '\n';
}

octal.cpp

C++
#include <iostream>
#include <string>
#include "formats.h"
using namespace std;

void Octal::show(int number) {
    string digits;
    if (number == 0) digits = "0";
    while (number > 0) {
        digits = static_cast<char>('0' + number % 8) + digits;   // 跟二進位同一招,只是除以 8
        number /= 8;
    }
    cout << "octal:   " << digits << '\n';
}

main.cpp

C++
#include <iostream>
#include "formats.h"
using namespace std;

int main() {
    int n;
    cin >> n;
    Reverse::show(n);
    Binary::show(n);
    Octal::show(n);
    return 0;
}

Makefile

Makefile
CC = g++
FLAG = -std=c++11

all: convert

convert: main.o reverse.o binary.o octal.o
	$(CC) $(FLAG) -o convert main.o reverse.o binary.o octal.o

main.o: main.cpp formats.h
	$(CC) $(FLAG) -c main.cpp

reverse.o: reverse.cpp formats.h
	$(CC) $(FLAG) -c reverse.cpp

binary.o: binary.cpp formats.h
	$(CC) $(FLAG) -c binary.cpp

octal.o: octal.cpp formats.h
	$(CC) $(FLAG) -c octal.cpp

clean:
	rm -f convert *.o
Shell
$ make
g++ -std=c++11 -c main.cpp
g++ -std=c++11 -c reverse.cpp
g++ -std=c++11 -c binary.cpp
g++ -std=c++11 -c octal.cpp
g++ -std=c++11 -o convert main.o reverse.o binary.o octal.o
$ echo 123 | ./convert
reverse: 321
binary:  1111011
octal:   173

三個 show 同名卻不衝突,就是因為各在自己的命名空間,呼叫時寫 Reverse::show(n)。實作檔裡函式定義寫成 void Reverse::show(int number),跟成員函式的寫法一樣「用 :: 說明它屬於誰」。.h 只放宣告、不放實作,否則三個 .cpp 都 include 它就會重複定義。二進位那段用「餘數接在字串前面」(static_cast<char>('0' + number % 2) + bits),比先存進陣列再反著印少一個步驟;八進位是同一個做法,只是除以 8、餘數是 0–7——兩個幾乎一樣的函式各放在自己的命名空間、各自一個檔案,呼叫端只要看 Binary:: 還是 Octal:: 就知道在用哪一個。Makefile 裡每個 .o 都把 formats.h 列進相依,改了宣告四個檔案才會一起重編(本篇 Q3 的實驗)。


← 11/19|指標、動態記憶體與 C 風格字串(Ch 9、Ch 10) | 回總覽 | 12/03|檔案輸入輸出(Ch 12) →

最後更新 2026.09.12

Comments

留言

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

載入留言中…

Esc

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

↑ ↓ 選擇Enter 開啟