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 按讚支持一下！

2023-07-20

Linux crontab 指令用法與範例

本篇介紹 Linux crontab 指令用法與範例，想要在 Linux 電腦中排程工作就可以使用 crontab，讓 Linux 系統定時地自動去執行指定的腳本或程式，詳細內容與範例如下，以下指令適用在 Ubuntu 或其它 Linux，

列出目前自己的 crontab 設定內容，

1	crontab -l

編輯 crontab 內容，

1	crontab -e

以下是 Ubuntu 下 crontab 的範例，

~/bin $ crontab -l
# Edit this file to introduce tasks to be run by cron.
# 
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# 
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# 
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
# m h  dom mon dow   command
*/5 * * * * /home/user/bin/xxx # 每隔 5 分鐘執行一次
59 23 * * * DISPLAY=:0 ~/crontab_script/xxx.sh # 23:59 時執行

其他參考
Linux 設定 crontab 例行性工作排程教學與範例
https://blog.gtwang.org/linux/linux-crontab-cron-job-tutorial-and-examples/

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

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

2023-07-06

Linux shell script 產生隨機亂數指令用法範例

本篇介紹 Linux shell script 產生隨機亂數指令用法範例，只要在 command line 或 shell script 裡印出 $RANDOM 變數就可以了，範例如下，以下指令適用在 linux，也適用於 macOS，

在 shell 中印出 $RANDOM 變數的指令如下，$RANDOM 變數它是一個介於 0~32767 間的亂數，

1	$ echo $RANDOM

如果要 Linux shell 產生 0~99 之間的隨機亂數的話，可以改這樣，

1	$ echo $(($RANDOM % 100))

如果要 Linux shell 產生 0~100 之間的隨機亂數的話，可以改這樣，

1	$ echo $(($RANDOM % 101))

如果要 Linux shell 產生 1~100 之間的隨機亂數的話，可以改這樣，

1	$ echo $(($RANDOM % 100 + 1))

Linux shell 產生 3 位數的隨機亂數

當需要生成 3 位數的隨機整數時(不包含 0-99)，你可以使用下列方式以確保結果在 100 到 999 的範圍內，這將產生一個在 100 到 999 之間的隨機 3 位整數。

1	$ echo $(($RANDOM % 900 + 100))

Linux shell 產生 32767 以上的亂數

如果要產生 32767 以上的亂數呢？如果你需要產生一個大於 32767 的隨機亂數，你可以使用 /dev/urandom，/dev/urandom 這個裝置可以產生更大範圍的隨機亂數。你可以使用 dd 指令來從 /dev/urandom 讀取隨機資料，指令如下，

1	$ echo $(od -An -N2 -i /dev/urandom \| awk '{print $1}')

Linux shell 產生 6 位數的隨機亂數

如果要產生 6 位數的隨機亂數呢？要產生一個6位數的隨機整數，你可以使用 shuf 指令來產生一個 6 位數的隨機整數，範圍從 100000 到 999999。你可以根據需要自訂範圍，確保它是一個6位數，範例如下，

1	$ echo $(shuf -i 100000-999999 -n 1)

在 shell script 中可以這樣寫，

1 2	random_number=$(shuf -i 100000-999999 -n 1) echo $random_number

macOS 沒有 shuf 指令，可以改用 awk 的方式，但需要結合其他指令，如下範例，
這範例是使用 awk 來產生一個 6 位數的隨機整數，範圍從 100000 到 999999。你可以根據需要自訂 min 和 max 的值來產生不同範圍的隨機亂數。

1	$ awk -v min=100000 -v max=999999 'BEGIN{srand(); print int(min+rand()*(max-min+1))}'

以上就是 Linux shell script 產生隨機亂數指令用法範例介紹，
如果你覺得我的文章寫得不錯、對你有幫助的話記得 Facebook 按讚支持一下！

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

2023-06-22

如何在 macOS 上編譯 Java 和執行 Java 程式

本篇 ShengYu 紀錄在 macOS 下用編譯 Java 和執行 Java 程式，macOS 提供了功能齊全的 Java 執行和開發環境，因此您要做的就是編寫 Java 程式並使用內建 Java 工具來編譯和執行它。

首先撰寫一個簡單 Java 程式，

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 比較

Linux shell 產生 3 位數的隨機亂數

Linux shell 產生 32767 以上的亂數

Linux shell 產生 6 位數的隨機亂數

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`