2024-02-11

Android 更換 line 的通知鈴聲方法

本篇介紹 Android 更換 line 的通知鈴聲方法。

2024-02-08

Android 手機月曆顯示農曆/農民曆方法

本篇介紹 Android 手機月曆顯示農曆/農民曆方法，在 Google 日曆中預設不會顯示農曆，但如果有需要看農民曆可以直接在Google 日曆查看不用再去網路上搜尋了唷！只要經過幾個步驟設定即可。

2024-01-21

JavaScript 中使用 swap 函式來交換值的用法

本篇介紹如何用 JavaScript 中使用 swap 函式來交換值的用法，在網頁開發中，我們經常需要操作 DOM 元素。有時，我們需要交換兩個 DOM 元素的值，這可能是為了改變 UI，或者根據用戶的需求進行排序和過濾。在這篇文章中，我們將介紹如何使用 JavaScript 中的 swap 函式來輕鬆地實現這個任務。

在 JavaScript 中，你可以使用多種方法來實現兩個變量的交換。以下是其中幾種方，使用暫存變量來交換兩個變量的值，

let a = 1;
let b = 2;

let temp = a;
a = b;
b = temp;

console.log("a:", a); // 應該輸出 2
console.log("b:", b); // 應該輸出 1

當然也可以寫成一個 swap 函式來方便使用，請以下閱讀 swap 介紹。

什麼是 swap 函式？

swap 函式是一個通用的函式，它可以接受兩個參數並返回一個包含這兩個參數值的陣列，但是交換了位置。這個函式對於交換任何類型的值都是有效的，包括數字、字串、物件等等。讓我們首先來看一下 swap 函式的基本結構：

function swap(a, b) {
    return [b, a];
}

let x = 1;
let y = 2;

[x, y] = swap(x, y);

console.log("x:", x); // 應該輸出 2
console.log("y:", y); // 應該輸出 1

這就是 swap 函式的全部內容。這個函式將兩個參數 a 和 b 作為輸入，在呼叫 swap 函式後，使用解構賦值來更新原始的變數值。然後返回一個陣列，該陣列包含 b 和 a 的值。這樣，我們就實現了這兩個值的交換。

使用 swap 函式交換 DOM 元素的值

現在我們瞭解了 swap 函式的工作原理，讓我們看看如何將它應用於交換 DOM 元素的值。我們將使用 JavaScript 來操作 DOM，並在網頁上演示這個功能。

HTML 結構

首先，我們需要在 HTML 中定義兩個 DOM 元素，我們將它們設置為 <input> 元素，並分別設置了 ID 為 input1 和 input2。另外，我們新增了一個按鈕，當按鈕被點擊時，將呼叫 JavaScript 中的 swapInputValues 函式。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Swap Input Values</title>
</head>
<body>
    <input type="text" id="input1" value="Input 1">
    <input type="text" id="input2" value="Input 2">
    <button onclick="swapInputValues()">Swap Input Values</button>

    <script src="script.js"></script>
</body>
</html>

JavaScript 代碼

現在，讓我們來實現 swapInputValues 函式，這個函式將使用 swap 函式來交換兩個 <input> 元素的值：

script.js

function swap(a, b) {
    return [b, a];
}

function swapInputValues() {
    // 獲取 input 元素
    let input1 = document.getElementById('input1');
    let input2 = document.getElementById('input2');

    // 調用 swap 函式交換兩個 input 的值
    [input1.value, input2.value] = swap(input1.value, input2.value);
}

在這個 JavaScript 代碼中，我們定義了 swap 函式，就像之前介紹的一樣，然後我們實現了 swapInputValues 函式。這個函式首先獲取兩個 <input> 元素，然後調用 swap 函式來交換它們的值。

現在，當我們在網頁上點擊按鈕時，就會觸發 swapInputValues 函式，它將交換兩個 <input> 元素的值。這樣，我們就成功地實現了使用 swap 函式來交換 DOM 元素的值。

總結

在這篇文章中，我們介紹了 swap 函式的概念，並展示了如何在 JavaScript 中使用它來交換 DOM 元素的值。swap 函式是一個非常有用的工具，它可以幫助我們簡化代碼並提高效率。通過了解和應用 swap 函式，我們可以更好地處理 DOM 操作，從而實現更加動態和互動性的網頁應用程式。希望這篇文章能夠幫助你更好地理解 JavaScript 中的 swap 函式，並在你的項目中發揮作用。

以上就是 JavaScript 中使用 swap 函式來交換值的用法介紹，
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

2023-09-28

5 種 Linux 比對文字檔工具

本篇介紹 5 種 Linux 比對文字檔工具，想要在 Linux 比對文字檔可以使用命令列指令也可以使用圖形介面的比對工具，在本篇將會介紹這些常見的工具，在 Linux 下比對文字檔的常用工具有 diff、colordiff、vimdiff 與 meld 等等工具。

以下 Linux 比對文字檔工具將分為這幾部分介紹，

linux diff 指令比對文字檔
linux colordiff 指令比對文字檔
linux vimdiff 指令比對文字檔
linux gvimdiff 指令比對文字檔
linux meld 指令比對文字檔

那我們開始吧！

linux diff 指令比對文字檔

linux 下可以 diff 指令來比對兩個文字檔，以下 diff 指令將會顯示兩個文字檔案之間的差異，如果是相同的沒有差異的話則不會有任何輸出。

1	diff file1.txt file2.txt

是否能夠告訴我比對結果不同即可，不要輸出差異呢？
那麼可以使用 -q 選項，這將僅顯示文字檔是否不同而不顯示實際的差異，
如果只關心文字檔是否不同，而不需要知道具體的差異，這樣可以提高效率。

1	diff -q file1.txt file2.txt

相同的話則沒有任何輸出，不相同的話則會輸出這樣的訊息，

1	Files file1.txt and file2.txt differ

diff 指令也可以像圖形化介面一樣並排分兩欄輸出，可以使用--side-by-side（或-y）選項。這將在輸出中以並排方式顯示兩個文字檔的差異，並在相同行上顯示差異，左邊顯示file1.txt的內容，右邊顯示file2.txt的內容，差異之處將以符號表示。

diff --side-by-side file1.txt file2.txt

# 或使用簡寫
diff -y file1.txt file2.txt

# 將diff的輸出通過管道傳遞給less查看結果
diff -y file1.txt file2.txt | less

如果想要忽略不顯示相同的部分，您可以使用--suppress-common-lines（或-s）選項。這將只顯示不同的行，而忽略不顯示相同的部分。

diff --side-by-side --suppress-common-lines file1.txt file2.txt

# 或使用簡寫
diff -y -s file1.txt file2.txt

# 將diff的輸出通過管道傳遞給less查看結果
diff -y -s file1.txt file2.txt | less

linux colordiff 指令比對文字檔

如果嫌棄 diff 的輸出只有單一顏色，想要有顏色的輸出方便觀察差異的話可以使用 colordiff 指令，執行指令如下，

1	colordiff file1.txt file2.txt

linux vimdiff 指令比對文字檔

linux vimdiff 指令比對文字檔將以 Vim 的方式顯示兩個檔案的差異，並允許你進行交互式編輯，

1	vimdiff file1.txt file2.txt

vimdiff 預設會 folder 折疊兩文字檔中相同的部分，只顯示不同的區域，

zi：切換folder折疊的功能
]c：跳至下一個改動，這裡的 c 表示 change
[c：跳至上一個改動

linux gvimdiff 指令比對文字檔

如果你想要一個圖形化介面 vimdiff 的話，那麼你可以使用 gvimdiff 來比對文字檔，使用方式跟 vimdiff 大同小異，但圖形化介面多了一些選單可以用滑鼠操作，喜歡圖形化介面的使用者不可錯過唷！

1	gvimdiff file1.txt file2.txt

zi：切換folder折疊的功能
]c：跳至下一個改動，這裡的 c 表示 change
[c：跳至上一個改動

linux meld 指令比對文字檔

如果您喜歡使用圖形化介面，可以考慮使用 meld，它是一個強大的比較和合併工具，在 linux 中是個很熱門的比對工具，

1	meld file1.txt file2.txt

對於大型檔案，使用 meld 可能會讓比較速度變慢，因為它們需要處理大量的資料。對於大檔案的比較，命令行工具可能更為有效或者改用 gvimdiff。

以上就是 5 種 Linux 比對文字檔工具介紹，這些方法的效果可能有所不同，視您的需求而定。diff、colordiff 和 vimdiff提供了基本的命令行界面，而 gvimdiff 和 meld 提供了更視覺化的比較。取決您的個人喜好和工作流程。
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

其它相關文章推薦
Linux 常用指令教學懶人包

2023-09-21

4 種 Ubuntu 關機指令

本篇 ShengYu 要介紹 4 種 Ubuntu 關機指令，有時候會需要在終端機下輸入指令讓 Ubuntu 關機，例如：遠端 ssh 登入時讓 Ubuntu 關機，或者剛好就是在命令列下要直接輸入指令讓 Ubuntu 關機等等情況，以下就來介紹有哪些指令可以讓 Ubuntu 關機。

以下介紹 4種 Ubuntu 關機指令，分別為，

poweroff
shutdown
init
halt

那我們開始吧！

poweroff

在終端機中，您可以使用以下指令 poweroff 關閉 Ubuntu，使用 sudo 是因為這個操作需要管理員權限，

1	sudo poweroff

shutdown

另一個 Ubuntu 關機方法是使用 shutdown 指令，

1	sudo shutdown -h now

或者簡寫下面成這樣指令，這也會立即關閉 Ubuntu，

1	sudo shutdown now

init

還有一個 Ubuntu 關機指令是 init，也可以關閉 Ubuntu，

1	sudo init 0

halt

另一個常見的 Ubuntu 關機指令是 halt，但是我發現 halt 在關閉時會卡在進度讀取條不會完整關機，

sudo halt

以上就是4 種 Ubuntu 關機指令方法介紹，總結來說，以上提到的指令都可以成功地將 Ubuntu 關機(除了halt外)，這些指令都需搭配要以管理員權限 sudo 執行這些指令。
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支援一下！

2023-09-14

C/C++教學

C/C++ 程式的常見陷阱與範例下篇

本篇 ShengYu 介紹 C/C++ 程式的常見陷阱與範例，C/C++ 寫程式時有許多常見的陷阱，以下是一些 C/C++ 常見陷阱的範例，同時也會說明如何避免與一些使用建議。

以下介紹 C/C++ 程式的常見陷阱分為，

線程競爭（Thread Race Conditions）陷阱
不良的記憶體管理（Poor Memory Management）陷阱
硬編碼數值（Hardcoded Values）陷阱
未處理的返回值（Unchecked Return Values）陷阱
錯誤的類型轉換（Incorrect Type Conversions）陷阱

線程競爭（Thread Race Conditions）陷阱

#include <iostream>
#include <thread>

int sharedVariable = 0;

void IncrementSharedVariable() {
    for (int i = 0; i < 10000; ++i) {
        sharedVariable++;  // 非原子操作，可能導致競爭條件
    }
}

int main() {
    std::thread t1(IncrementSharedVariable);
    std::thread t2(IncrementSharedVariable);
    t1.join();
    t2.join();
    std::cout << "Shared variable: " << sharedVariable << std::endl;
    return 0;
}

如何避免：使用互斥鎖（Mutex）或其他同步機制來確保多線程操作共享資源的安全。

#include <iostream>
#include <thread>
#include <mutex>

int sharedVariable = 0;
std::mutex mtx;

void IncrementSharedVariable() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 使用互斥鎖保護共享變數
        sharedVariable++;
    }
}

int main() {
    std::thread t1(IncrementSharedVariable);
    std::thread t2(IncrementSharedVariable);
    t1.join();
    t2.join();
    std::cout << "Shared variable: " << sharedVariable << std::endl;
    return 0;
}

不良的記憶體管理（Poor Memory Management）陷阱

1 2	int* data = new int[10]; // 忘記釋放記憶體

如何避免：使用delete[]來釋放動態分配的記憶體。

1
2
3

int* data = new int[10];
// 使用 data
delete[] data; // 釋放記憶體

硬編碼數值（Hardcoded Values）陷阱

1
2
3

int calculateArea(int length, int width) {
    return length * width * 3.14159;  // 使用硬編碼的數值
}

如何避免：使用常數或宏定義，或更好地命名和組織數值，以提高代碼的可讀性。

const double PI = 3.14159;

int calculateArea(int length, int width) {
    return length * width * PI;  // 使用常數代替硬編碼的數值
}

未處理的返回值（Unchecked Return Values）陷阱

1 2	FILE* file = fopen("example.txt", "r"); fread(buffer, 1, sizeof(buffer), file); // 未檢查fread的返回值

如何避免：始終檢查函數的返回值並處理錯誤情況，例如檢查fread是否成功。

FILE* file = fopen("example.txt", "r");
if (file != nullptr) {
    size_t bytesRead = fread(buffer, 1, sizeof(buffer), file);  // 檢查fread的返回值
    if (bytesRead == 0) {
        // 處理讀取錯誤
    }
    fclose(file);
} else {
    // 處理文件打開錯誤
}

錯誤的類型轉換（Incorrect Type Conversions）陷阱

1 2	int x = 10; char c = (char)x; // 不恰當的類型轉換

如何避免：謹慎處理類型轉換，確保不會導致數據丟失或不正確的計算結果。使用合適的轉換方法，如static_cast（C++）。

1 2	int x = 10; char c = static_cast<char>(x); // 使用static_cast進行安全類型轉換

空指針（Null Pointers）陷阱

誤用空指針的話將會讓程式crash崩潰，以下為空指針的範例程式碼，

1 2	int* ptr = nullptr; *ptr = 5; // 將導致crash，因為ptr是空指針

如何避免：在使用指針之前，確保它們不是空指針。

未初始化的指針或指向無效記憶體的指針可能導致程式崩潰。務必在使用指針之前進行初始化，並謹慎檢查指針是否為NULL，修正空指針陷阱後的程式碼如下，

int* ptr = nullptr;
if (ptr != nullptr) {
    *ptr = 5; // 不會crash
}

要確保在使用指針之前檢查它們是否為空指針。

以上就是 C/C++ 程式的常見陷阱與範例介紹，這些範例展示了 C/C++ 中的一些常見陷阱，以及如何避免它們。要寫出更健壯和安全的程式，需要謹慎處理這些問題，以確保程式碼的正確性和可靠性。
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

其它相關文章推薦
如果你想學習 C++ 相關技術，可以參考看看下面的文章，
C/C++ 新手入門教學懶人包
 C/C++ fopen 用法與範例
 C/C++ fread 用法與範例
 C/C++ fgets 用法與範例
 C/C++ fputs 用法與範例
 C/C++ fclose 用法與範例

2023-09-07

C/C++教學

C/C++ 程式的常見陷阱與範例

以下介紹 C/C++ 程式的常見陷阱分為，

空指針（Null Pointers）陷阱
記憶體洩漏（Memory Leaks）陷阱
緩衝區溢出（Buffer Overflow）陷阱
未檢查的輸入（Unchecked Input）陷阱
未處理的異常（Unhandled Exceptions）陷阱

空指針（Null Pointers）陷阱

誤用空指針的話將會讓程式crash崩潰，以下為空指針的範例程式碼，

1 2	int* ptr = nullptr; *ptr = 5; // 將導致crash，因為ptr是空指針

如何避免：在使用指針之前，確保它們不是空指針。

int* ptr = nullptr;
if (ptr != nullptr) {
    *ptr = 5; // 不會crash
}

要確保在使用指針之前檢查它們是否為空指針。

記憶體洩漏（Memory Leaks）陷阱

以下為記憶體洩漏的範例程式碼，

1 2	int* data = new int[10]; // 忘記釋放記憶體

如何避免：使用delete[]來釋放動態分配的記憶體。

忘記釋放動態分配的記憶體可能導致記憶體洩漏。使用new和delete（C++程式）或malloc和free（C程式）時，確保釋放記憶體，修正記憶體洩漏後的程式碼如下，

1
2
3

int* data = new int[10];
// 使用 data
delete[] data; // 釋放記憶體

使用new後記得使用delete[]來釋放動態分配的記憶體，以避免記憶體洩漏。

緩衝區溢出（Buffer Overflow）陷阱

以下為緩衝區溢出的範例程式碼，

1 2	char buffer[10]; strcpy(buffer, "This is a long string that overflows the buffer");

如何避免：使用strncpy等函數，或者使用std::string（C++）來處理字串，以確保不會超出緩衝區。

對陣列或緩衝區進行寫入時，超出其邊界可能導致不安全的程式行為。使用標準函數（例如strncpy而不是strcpy）或容器類型（例如std::vector）以避免此問題，修正緩衝區溢出後的程式碼如下，

1 2	char buffer[100]; strncpy(buffer, "This is a long string that won't overflow the buffer", sizeof(buffer));

使用strncpy，並確保不會超出緩衝區的大小。

未檢查的輸入（Unchecked Input）陷阱

以下為未檢查的輸入的範例程式碼，

1
2
3

char query[100];
cin >> query;
// 未驗證用戶輸入，可能受到SQL注入攻擊

如何避免：使用參數化查詢或驗證用戶輸入，以避免安全問題。

未驗證用戶輸入可能導致安全問題，如SQL注入或格式化字串攻擊。始終驗證和過濾用戶輸入，並使用參數化查詢來防止SQL注入，修正未檢查的輸入後的程式碼如下，

1
2
3

char query[100];
cin.getline(query, sizeof(query));
// 驗證用戶輸入，以避免安全問題

使用cin.getline等函數來讀取和驗證用戶輸入，以確保安全性。

未處理的異常（Unhandled Exceptions）陷阱

以下為未處理的異常的範例程式碼，

try {
    // ...
} catch (std::exception& e) {
    // 未處理異常
}

如何避免：確保捕獲並處理異常，或者將它們向上拋出以便在適當的地方處理。

處理異常可能導致程式崩潰。使用try-catch區塊來捕獲異常並處理它們，以確保程式的穩定性，修正未處理的異常後的程式碼如下，

try {
    // ...
} catch (std::exception& e) {
    // 處理異常，例如日誌記錄或回報錯誤
}

確保捕獲並處理異常，以確保程式的穩定性。

2023-08-31

C/C++教學

C++ std::pair 用法與範例

本篇 ShengYu 介紹 C++ std::pair 用法與範例，std::pair 是 C++ 標準函式庫中的一個類範本，用於將兩個值捆綁在一起，形成一個有序的對(pair)。std::pair 是一個非常有用的工具，特別是用於將兩個不同類型的值關聯在一起，以便一起傳遞、返回或儲存。接下來看看 std::pair 用法範例。

要使用 std::pair 的話，需要引入的標頭檔: <utility>

C++ 建立 `std::pair`

以下是 C++ 建立 std::pair 的用法，

std-pair.cpp

// g++ std-pair.cpp -o a.out
#include <iostream>
#include <utility>

int main() {
    // 建立一個 std::pair 對象，將整數和字串關聯在一起
    std::pair<int, std::string> myPair(100, "Tom");
    return 0;
}

訪問 `std::pair` 中的元素

你可以使用 first 和 second 成員來訪問 std::pair 中的第一個和第二個元素，

std-pair2.cpp

// g++ std-pair2.cpp -o a.out
#include <iostream>
#include <utility>

int main() {
    std::pair<int, std::string> myPair(100, "Tom");
    std::cout << myPair.first << "\n";
    std::cout << myPair.second << "\n";

    int firstValue = myPair.first; // 取得第一個元素的值
    std::string secondValue = myPair.second; // 取得第二個元素的值
    std::cout << firstValue << "\n";
    std::cout << secondValue << "\n";

    return 0;
}

輸出如下：

100
Tom
100
Tom

使用 `std::make_pair` 建立 `std::pair`

std::make_pair 是一個方便的函數，用來建立 std::pair，它可以自動推斷元素的類型，

std-pair3.cpp

// g++ std-pair3.cpp -o a.out
#include <iostream>
#include <utility>

int main() {
    auto anotherPair = std::make_pair(3.14, "Hello World");
    std::cout << anotherPair.first << "\n";
    std::cout << anotherPair.second << "\n";

    return 0;
}

輸出如下：

1 2	3.14 Hello World

比較 `std::pair`

std::pair 支援比較運算子，你可以使用 ==, !=, <, >, <=, 和 >= 來比較兩個 std::pair 對象，

std-pair4.cpp

// g++ std-pair4.cpp -o a.out
#include <iostream>
#include <utility>

int main() {
    std::pair<int, std::string> pair1(100, "Tom");
    std::pair<int, std::string> pair2(100, "Tom");

    if (pair1 == pair2) {
        std::cout << "相等\n";
    } else {
        std::cout << "不相等\n";
    }

    return 0;
}

輸出如下：

相等

使用 `std::pair` 在容器中儲存關聯資料

std::pair 可以用來在容器中儲存關聯的資料。例如，你可以使用 std::pair 在 std::vector 中儲存 key-value 對。

std-pair5.cpp

// g++ std-pair5.cpp -o a.out
#include <iostream>
#include <utility>
#include <vector>

int main() {
    std::vector<std::pair<int, std::string>> keyValuePairs;
    keyValuePairs.push_back(std::make_pair(1, "One"));
    keyValuePairs.push_back(std::make_pair(2, "Two"));
    keyValuePairs.push_back(std::make_pair(3, "Three"));

    for (int i = 0; i < keyValuePairs.size(); i++) {
        std::cout << "key: " << keyValuePairs[i].first
                  << ", value: " << keyValuePairs[i].second << "\n";
    }
    
    return 0;
}

輸出如下：

1
2
3

key: 1, value: One
key: 2, value: Two
key: 3, value: Three

使用 tie 取得回傳 `std::pair` 的元素值

在某些情況函式回傳 std::pair 時，可以使用 std::tie 來接收，這樣可以直接用變數接收 std::pair 的元素值，要用 std::tie 的話要引用 tuple 的標頭檔 <tuple>，

std-pair6.cpp

// g++ std-pair6.cpp -o a.out
#include <iostream>
#include <utility>
#include <vector>
#include <tuple>

std::pair<int, std::string> getStudent() {
    return std::make_pair(100, "Tom");
}

int main() {
    int id;
    std::string name;

    std::tie(id, name) = getStudent();

    std::cout << "id: " << id << ", name: " << name << "\n";
    
    return 0;
}

輸出如下：

1	id: 100, name: Tom

以上就是 C++ std::pair 用法與範例介紹，
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

2023-08-17

C/C++教學

C++ std::array 用法與範例

本篇 ShengYu 介紹 C++ std::array 用法與範例，std::array 是 C++ 標準函式庫提供的一個容器，用於表示固定大小的陣列。可以代替傳統的 C 陣列，它在某些情況下比傳統的 C 陣列更具優勢，因為它提供了更好的性能、更多的安全性與功能。接下來看看 std::array 用法範例。

要使用 std::array 的話，需要引入的標頭檔: <array>

C++ 建立 `std::array`

C++ std::array 的大小在建立時就被固定了，無法改變。這意味著它既提供了陣列的效率，又提供了容器的安全性。
你可以使用不同的方法來建立 std::array，範例如下，

std-array.cpp

// g++ std-array.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray; // 建立一個包含3個整數的陣列
    std::array<double, 3> anotherArray = {1.1, 2.2, 3.3}; // 建立並初始化陣列
    
    return 0;
}

訪問 `std::array` 元素

使用 [] 運算子來訪問該 std::array 的元素，

std-array2.cpp

// g++ std-array2.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray = {1, 2, 3};
    
    int value = myArray[2]; // 訪問第三個元素（索引為2）
    std::cout << value << "\n";

    for (int i = 0; i < myArray.size(); i++) {
        std::cout << myArray[i] << "\n";
    }
    
    return 0;
}

輸出如下：

取得 `std::array` 大小

使用 size() 函數來取得該 std::array 的大小，

std-array3.cpp

// g++ std-array3.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray;
    std::array<double, 3> anotherArray = {1.1, 2.2, 3.3};

    size_t size = myArray.size();
    std::cout << size << "\n";

    size_t size2 = anotherArray.size();
    std::cout << size2 << "\n";
    
    return 0;
}

輸出如下：

1
2

3
3

遍歷 `std::array`

你可以使用 for range 或迭代器來遍歷 std::array，

std-array4.cpp

// g++ std-array4.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray = {1, 2, 3};

    for (const auto& element : myArray) {
        // 使用 element
        std::cout << element << "\n";
    }

    for (std::array<int, 3>::iterator it = myArray.begin(); it != myArray.end(); ++it) {
        // 使用 *it
        std::cout << *it << "\n";
    }
    
    return 0;
}

輸出如下：

修改元素

使用 [] 運算子可以修改該 std::array 的元素，

std-array5.cpp

// g++ std-array5.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray = {1, 2, 3};
    
    myArray[1] = 100; // 修改第二個元素

    for (int i = 0; i < myArray.size(); i++) {
        std::cout << myArray[i] << "\n";
    }
    
    return 0;
}

輸出如下：

1
2
3

1
100
3

檢查是否為空

使用 empty() 函數來檢查該 std::array 是否為空，

std-array6.cpp

// g++ std-array6.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray = {1, 2, 3};
    std::array<double, 3> anotherArray;

    bool isEmpty = myArray.empty();
    std::cout << isEmpty << "\n";

    bool isEmpty2 = anotherArray.empty();
    std::cout << isEmpty2 << "\n";
    
    return 0;
}

輸出如下：

1
2

0
0

比較 `std::array`

你可以使用 == 或 != 運算子來比較兩個 std::array 是否相等，

std-array7.cpp

// g++ std-array7.cpp -o a.out
#include <iostream>
#include <array>

int main() {
    std::array<int, 3> myArray1 = {1, 2, 3};
    std::array<int, 3> myArray2 = {1, 2, 3};
    std::array<int, 3> myArray3 = {4, 5, 6};
    std::array<int, 3> myArray4;

    if (myArray1 == myArray2) {
        std::cout << "與 myArray2 相等\n";
    }

    if (myArray1 == myArray3) {
        std::cout << "與 myArray3 相等\n";
    }

    if (myArray1 == myArray4) {
        std::cout << "與 myArray4 相等\n";
    }
    
    return 0;
}

輸出如下：

1	與 myArray2 相等

以上就是 C++ std::array 用法與範例介紹，
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支援一下！

2023-08-03

C/C++教學

C++ std::tuple 用法與範例

本篇 ShengYu 介紹 C++ std::tuple 用法與範例，C++ std::tuple 是一個用來存放不同資料類型的容器，該儲存空間可以透過 std::get 來進行存取，例如：對一個 tuple t 變數的話，可以用 get<i>(t) 取得該 tuple 裡各型別的變數，用 get<1>(t) 就取得第一個變數，用 get<2>(t) 就取得第二個變數，依此類推。通常 tuple 用於需要從函數回傳多不同資料類型的情況，接下來看看 std::tuple 用法範例。

要使用 std::tuple 的話，需要引入的標頭檔: <tuple>

C++ 建立 tuple

C++ 的 tuple 它可以容納不同類型的元素。以下是建立 tuple 的範例，

std-tuple.cpp

// g++ std-tuple.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");

    return 0;
}

取得 tuple 元素

C++ std::tuple 可以透過 std::get 來進行存取，範例如下，

std-tuple2.cpp

// g++ std-tuple2.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");
    std::cout << std::get<0>(myTuple) << "\n";
    std::cout << std::get<1>(myTuple) << "\n";
    std::cout << std::get<2>(myTuple) << "\n";
    
    int value1 = std::get<0>(myTuple); // 取得第一個元素
    double value2 = std::get<1>(myTuple); // 取得第二個元素
    std::string value3 = std::get<2>(myTuple); // 取得第三個元素
    std::cout << value1 << "\n";
    std::cout << value2 << "\n";
    std::cout << value3 << "\n";

    return 0;
}

輸出如下，

100
3.14
hello world
100
3.14
hello world

您可以使用 std::get() 或在 C++17 及更高版本中使用結構化綁定來訪問 tuple 的元素，

std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");

// 使用結構化綁定（C++17及更高版本）
auto [a, b, c] = myTuple; // 自動將 tuple 中的元素綁定到變數 x, y, z

std::cout << a << "\n";
std::cout << b << "\n";
std::cout << c << "\n";

修改 tuple 元素

要修改 tuple 元素需要使用 std::get 的方式來進行修改，

std-tuple3.cpp

// g++ std-tuple3.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");
    
    std::get<0>(myTuple) = 123; // 修改第一個元素的值
    std::get<1>(myTuple) = 5.43; // 修改第二個元素的值
    std::get<2>(myTuple) = "world"; // 修改第三個元素的值

    std::cout << std::get<0>(myTuple) << "\n";
    std::cout << std::get<1>(myTuple) << "\n";
    std::cout << std::get<2>(myTuple) << "\n";

    return 0;
}

輸出如下，

1
2
3

123
5.43
world

解包 tuple 元素到變數

使用 std::tie 解包 std::tuple 到變數，

std-tuple4.cpp

// g++ std-tuple4.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");
    int a;
    double b;
    std::string c;
    std::tie(a, b, c) = myTuple;

    return 0;
}

同常使用情況為函式回傳 std::tuple 時，這樣可以直接用 std::tie 將變數接收 std::tuple 的元素值，要用 std::tie 的話也是同樣引用 tuple 的標頭檔 <tuple>，

std-tuple5.cpp

// g++ std-tuple5.cpp -o a.out
#include <iostream>
#include <tuple>

std::tuple<int, int, std::string> getStudent() {
    return std::make_tuple(100, 18, "Tom");
}

int main() {
    int id;
    int age;
    std::string name;
    std::tie(id, age, name) = getStudent();

    std::cout << "id: " << id
        << ", age: " << age
        << ", name: " << name << "\n";

    return 0;
}

輸出如下：

1	id: 100, age: 18, name: Tom

取得 tuple 元素數量

你可以使用 std::tuple_size 來取得 tuple 的元素數量。

1	size_t tupleSize = std::tuple_size<decltype(myTuple)>::value;

詳細範例如下，

std-tuple6.cpp

// g++ std-tuple6.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> t1;
    std::tuple<int, double, std::string> t2(100, 3.14, "hello world");

    size_t s1 = std::tuple_size<decltype(t1)>::value;
    size_t s2 = std::tuple_size<decltype(t2)>::value;

    std::cout << s1 << "\n";
    std::cout << s2 << "\n";

    return 0;
}

輸出如下：

1
2

3
3

使用 std::make_tuple 建立 tuple

std-tuple7.cpp

// g++ std-tuple7.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> myTuple(100, 3.14, "hello world");
    auto anotherTuple = std::make_tuple(100, 3.14, "hello world");

    return 0;
}

tuple 比較

如果 tuple 的元素類型支援比較，則 tuple 就可支援比較操作。您可以使用 ==、!=、<、<=、> 和 >= 運算子來比較兩個 tuple，

std-tuple8.cpp

// g++ std-tuple8.cpp -o a.out
#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double> tuple1 = std::make_tuple(100, 3.14);
    std::tuple<int, double> tuple2 = std::make_tuple(100, 3.14);
    std::tuple<int, double> tuple3 = std::make_tuple(100, 4.56);
    std::tuple<int, double> tuple4;

    if (tuple1 == tuple2) {
        std::cout << "與 tuple2 相等\n";
    } else {
        std::cout << "與 tuple2 不相等\n";
    }

    if (tuple1 == tuple3) {
        std::cout << "與 tuple3 相等\n";
    } else {
        std::cout << "與 tuple3 不相等\n";
    }

    if (tuple1 == tuple4) {
        std::cout << "與 tuple4 相等\n";
    } else {
        std::cout << "與 tuple4 不相等\n";
    }

    return 0;
}

輸出如下：

1
2
3

與 tuple2 相等
與 tuple3 不相等
與 tuple4 不相等

以上就是 C++ std::tuple 用法與範例介紹，
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

什麼是 swap 函式？

使用 swap 函式交換 DOM 元素的值

HTML 結構

JavaScript 代碼

總結

linux diff 指令比對文字檔

linux colordiff 指令比對文字檔

linux vimdiff 指令比對文字檔

linux gvimdiff 指令比對文字檔

linux meld 指令比對文字檔

poweroff

shutdown

init

halt

線程競爭（Thread Race Conditions）陷阱

不良的記憶體管理（Poor Memory Management）陷阱

硬編碼數值（Hardcoded Values）陷阱

未處理的返回值（Unchecked Return Values）陷阱

錯誤的類型轉換（Incorrect Type Conversions）陷阱

空指針（Null Pointers）陷阱

空指針（Null Pointers）陷阱

記憶體洩漏（Memory Leaks）陷阱

緩衝區溢出（Buffer Overflow）陷阱

未檢查的輸入（Unchecked Input）陷阱

未處理的異常（Unhandled Exceptions）陷阱

C++ 建立 std::pair

訪問 std::pair 中的元素

使用 std::make_pair 建立 std::pair

比較 std::pair

使用 std::pair 在容器中儲存關聯資料

使用 tie 取得回傳 std::pair 的元素值

C++ 建立 std::array

訪問 std::array 元素

取得 std::array 大小

遍歷 std::array

修改元素

檢查是否為空

比較 std::array

C++ 建立 tuple

取得 tuple 元素

修改 tuple 元素

解包 tuple 元素到變數

取得 tuple 元素數量

使用 std::make_tuple 建立 tuple

tuple 比較

C++ 建立 `std::pair`

訪問 `std::pair` 中的元素

使用 `std::make_pair` 建立 `std::pair`

比較 `std::pair`

使用 `std::pair` 在容器中儲存關聯資料

使用 tie 取得回傳 `std::pair` 的元素值

C++ 建立 `std::array`

訪問 `std::array` 元素

取得 `std::array` 大小

遍歷 `std::array`

比較 `std::array`