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

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

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

1
2
3
4
5
6
7
8
9
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 函式的基本結構:

1
2
3
4
5
6
7
8
9
10
11
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 函式的全部內容。這個函式將兩個參數 ab 作為輸入,在呼叫 swap 函式後,使用解構賦值來更新原始的變數值。然後返回一個陣列,該陣列包含 ba 的值。這樣,我們就實現了這兩個值的交換。

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

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

HTML 結構

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!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
1
2
3
4
5
6
7
8
9
10
11
12
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 按讚支持一下!

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的內容,差異之處將以符號表示。

1
2
3
4
5
6
7
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)選項。這將只顯示不同的行,而忽略不顯示相同的部分。

1
2
3
4
5
6
7
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 常用指令教學懶人包

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 在關閉時會卡在進度讀取條不會完整關機,

1
sudo halt

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

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)陷阱

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#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)或其他同步機制來確保多線程操作共享資源的安全。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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; // 使用硬編碼的數值
}

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

1
2
3
4
5
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是否成功。

1
2
3
4
5
6
7
8
9
10
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,修正空指針陷阱後的程式碼如下,

1
2
3
4
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 用法與範例

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

本篇 ShengYu 介紹 C/C++ 程式的常見陷阱與範例,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是空指針

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

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

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

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

記憶體洩漏(Memory Leaks)陷阱

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

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

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

忘記釋放動態分配的記憶體可能導致記憶體洩漏。使用newdelete(C++程式)或mallocfree(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)陷阱

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

1
2
3
4
5
try {
// ...
} catch (std::exception& e) {
// 未處理異常
}

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

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

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

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

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

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

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
1
2
3
4
5
6
7
8
9
// 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 中的元素

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

std-pair2.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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;
}

輸出如下:

1
2
3
4
100
Tom
100
Tom

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

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

std-pair3.cpp
1
2
3
4
5
6
7
8
9
10
11
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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;
}

輸出如下:

1
相等

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

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

std-pair5.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 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 按讚支持一下!

其它相關文章推薦
C/C++ 新手入門教學懶人包
std::string 用法與範例
std::vector 用法與範例
std::sort 用法與範例
std::map 用法與範例
std::set 用法與範例

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
1
2
3
4
5
6
7
8
9
10
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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;
}

輸出如下:

1
2
3
4
3
1
2
3

取得 std::array 大小

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

std-array3.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 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;
}

輸出如下:

1
2
3
4
5
6
1
2
3
1
2
3

修改元素

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

std-array5.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 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 按讚支援一下!

其它相關文章推薦
C/C++ 新手入門教學懶人包
std::string 用法與範例
std::vector 用法與範例
std::sort 用法與範例
std::map 用法與範例
std::set 用法與範例

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
1
2
3
4
5
6
7
8
9
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 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;
}

輸出如下,

1
2
3
4
5
6
100
3.14
hello world
100
3.14
hello world

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

1
2
3
4
5
6
7
8
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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
1
2
3
4
5
6
7
8
9
10
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 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 按讚支持一下!

其它相關文章推薦
C/C++ 新手入門教學懶人包
std::string 用法與範例
std::vector 用法與範例
std::sort 用法與範例
std::map 用法與範例
std::set 用法與範例