常用拷貝和替換算法

copy——容器內(nèi)指定范圍的元素拷貝到另一容器中

函數(shù)原型

• copy(iterator beg, iterator end, iterator dest);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回結(jié)束迭代器位置

  // beg 開始迭代器

  // end 結(jié)束迭代器

  // dest 目標(biāo)起始迭代器

注意——利用copy算法在拷貝時，目標(biāo)容器要提前開辟空間

示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> source {1, 2, 3, 4, 5};
    std::vector<int> destination(5);  // 提前開辟目標(biāo)容器空間

    std::copy(source.begin(), source.end(), destination.begin());

    // 輸出目標(biāo)容器中的內(nèi)容
    for (auto i : destination) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：1 2 3 4 5

在上面的示例中，我們首先創(chuàng)建了一個源容器source，其中包含了一些整數(shù)。然后，我們創(chuàng)建了一個與源容器相同大小的目標(biāo)容器destination，并且提前開辟了空間。

接下來，我們使用std::copy算法將源容器中的元素拷貝到目標(biāo)容器中。通過傳遞源容器的迭代器source.begin()和source.end()以及目標(biāo)容器的起始迭代器destination.begin()作為參數(shù)，實現(xiàn)了拷貝操作。

最后，遍歷目標(biāo)容器，并打印其中的元素

replace——將容器內(nèi)指定范圍的第一個舊元素修改為新元素

函數(shù)原型

• replace(iterator beg, iterator end, oldvalue, newvalue);

  // 將區(qū)間內(nèi)舊元素 替換成 新元素

  // beg 開始迭代器

  // end 結(jié)束迭代器

  // oldvalue 舊元素

  // newvalue 新元素

注意——replace只會替換區(qū)間內(nèi)滿足條件的第一個舊元素

示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec {1, 2, 3, 4, 5};

    std::replace(vec.begin(), vec.end(), 3, 9);

    // 輸出修改后的容器內(nèi)容
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
1 2 9 4 5

在上面的示例中，我們首先創(chuàng)建了一個整數(shù)向量vec，其中包含了一些整數(shù)。然后，我們使用std::replace算法將容器中的舊元素3替換為新元素9。

通過傳遞容器的起始迭代器vec.begin()和結(jié)束迭代器vec.end()作為參數(shù)，以及要替換的舊元素3和新元素9，實現(xiàn)了替換操作。

最后，我們遍歷容器，并打印其中的元素，可以看到被替換的元素已經(jīng)被修改為新元素。

replace_if——在指定范圍內(nèi)將所有舊元素修改為新元素

函數(shù)原型

• **replace_if(iterator beg, iterator end, _pred, newvalue); **

  // 按條件替換元素，滿足條件的替換成指定元素

  // beg 開始迭代器

  // end 結(jié)束迭代器

  // _pred 謂詞,謂詞函數(shù)是一個返回布爾值的函數(shù)，用于確定元素是否滿足某個條件。

  // 注意謂語是返回bool的仿函數(shù)，是謂詞，是一個類，不是函數(shù)，但是可以當(dāng)函數(shù)用
  // 因此可以利用仿函數(shù)靈活篩選滿足的條件

  // newvalue 替換的新元素

注意——replace會替換區(qū)間內(nèi)滿足條件的所有舊元素

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec {1, 2, 3, 4, 5};

    std::replace_if(vec.begin(), vec.end(), [](int num){ return num == 3; }, 9);

    // 輸出修改后的容器內(nèi)容
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
1 2 9 4 5

在這個示例中，我們使用了一個匿名的lambda函數(shù)作為謂詞函數(shù)來判斷元素是否需要被替換。lambda函數(shù)接受一個整數(shù)參數(shù)num，并返回一個bool值，判斷這個整數(shù)是否等于3。如果等于3，則將其替換為新元素9。

通過使用lambda函數(shù)作為謂詞函數(shù)，我們可以自定義替換的條件。在上述示例中，我們使用等于3的元素作為替換的條件。

需要注意的是，replace_if函數(shù)只會替換滿足條件的第一個元素，如果想要替換所有滿足條件的元素，可以考慮使用std::replace_copy_if或自定義循環(huán)進(jìn)行處理。

swap——互換兩個容器的元素

函數(shù)原型

• swap(container c1, container c2);

  // 互換兩個容器的元素

  // c1容器1

  // c2容器2

注意——swap交換容器時，注意交換的容器要同種類型

交換不同類型的容器，將會導(dǎo)致編譯錯誤。

類型要匹配

要交換的容器類型要相同，或者滿足可以進(jìn)行隱式轉(zhuǎn)換的條件。例如，兩個 std::vector<int> 可以直接交換，但是 std::vector<int> 和 std::vector<double> 之間不能直接交換。

容器的狀態(tài)

交換容器時，要確保容器處于有效狀態(tài)，即它們不應(yīng)被移動、釋放或銷毀。否則，交換操作可能會導(dǎo)致未定義行為。

迭代器的失效

交換容器后，原來容器中的迭代器將會失效。如果有其他依賴于這些迭代器的代碼，則需要謹(jǐn)慎處理，避免使用失效的迭代器。

容器的大小和內(nèi)存開銷

交換容器實際上是交換了它們的內(nèi)部數(shù)據(jù)結(jié)構(gòu)，這意味著會涉及到元素的復(fù)制或移動操作。如果容器的大小較大，交換操作可能會帶來顯著的內(nèi)存開銷和性能損失。

異常安全性

交換容器可能會引發(fā)異常，因此在交換操作之前，要考慮異常安全性，采取適當(dāng)?shù)拇胧﹣硖幚懋惓?，以確保程序能夠正常執(zhí)行。

示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3};
    std::vector<int> vec2 {4, 5, 6};

    swap(vec1, vec2);

    // 輸出交換后的vec1
    std::cout << "vec1: ";
    for (auto i : vec1) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // 輸出交換后的vec2
    std::cout << "vec2: ";
    for (auto i : vec2) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
vec1: 4 5 6
vec2: 1 2 3

在這個示例中，我們創(chuàng)建了兩個vector類型的容器vec1和vec2。
然后，通過調(diào)用swap函數(shù)來交換這兩個容器的元素。最
終，vec1中的元素變成了4, 5, 6，vec2中的元素變成了1, 2, 3。

常用算術(shù)生成算法

注意——算術(shù)生成算法屬于小型算法，使用時包含的頭文件為 #include <numeric>

accumulate—— 計算區(qū)間內(nèi)容器元素累計總和

函數(shù)原型

• accumulate(iterator beg, iterator end, value);

  // 計算容器元素累計總和

  // beg 開始迭代器

  // end 結(jié)束迭代器

  // value 起始值
  //起始值value是可選的，如果不提供該參數(shù)，那么默認(rèn)起始值將是容器中的第一個元素的值。（看下面例子）

注意——如果容器為空，而且沒有提供起始值參數(shù)，則調(diào)用accumulate函數(shù)會導(dǎo)致未定義行為

所以，在使用accumulate函數(shù)時，建議在累加之前檢查容器是否非空，或者提供一個明確的起始值參數(shù)。

示例

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> vec {1, 2, 3, 4, 5};

    int sum = std::accumulate(vec.begin(), vec.end());

    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

輸出結(jié)果為：
Sum: 15

在這個示例中，我們調(diào)用了accumulate函數(shù)來計算容器vec中元素的累計總和，但沒有提供起始值參數(shù)。由于沒有指定起始值，accumulate函數(shù)會使用容器中的第一個元素作為起始值進(jìn)行累加運算。

因此，根據(jù)示例中的容器vec，累計總和仍然是15。

fill——用于將指定范圍內(nèi)的元素都設(shè)置為給定的值

函數(shù)原型

• fill(iterator beg, iterator end, value);

  // 向容器中填充元素

  // beg 開始迭代器

  // end 結(jié)束迭代器

  // value 填充的值

注意——fill函數(shù)會將指點范圍內(nèi)所有元素都填充為給定的值，原本已的值會被覆蓋。

示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec {1, 2, 3, 4, 5};

    std::fill(vec.begin(), vec.end(), 10);

    // 輸出填充后的向量
    std::cout << "Filled Vector: ";
    for (auto i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：

Filled Vector: 10 10 10 10 10
在這個示例中，我們有一個包含初始值的向量vec，其中包含了數(shù)字1到5。然后，我們使用fill函數(shù)將容器vec中的所有元素都填充為10。

最終的輸出結(jié)果顯示，原本向量中的元素已經(jīng)被覆蓋，全部變成了10, 10, 10, 10, 10。

因此，需要注意，在使用fill函數(shù)時，如果你希望保留原有元素的值，只填充指定范圍內(nèi)的部分元素，可以使用更具靈活性的方法，如迭代器和算法結(jié)合使用來實現(xiàn)部分填充。

常用集合算法

set_intersection——求兩個容器的交集

set_intersection 函數(shù)通常用于計算兩個有序集合的交集。
但是，它實際上可以用于任何支持隨機訪問的序列容器，而不僅限于集合。

函數(shù)原型

• set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
  // beg1 容器1開始迭代器
  // end1 容器1結(jié)束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結(jié)束迭代器
  // dest 目標(biāo)容器開始迭代器

總結(jié)

• 求交集的兩個集合必須是有序序列
• 目標(biāo)容器開辟空間需要從兩個容器中取小值
• set_intersection返回值既是交集中最后一個元素的位置

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> intersection(std::min(vec1.size(), vec2.size()));

    auto it = std::set_intersection(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), intersection.begin());

    // 輸出交集中的元素
    std::cout << "Intersection: ";
    for (auto i = intersection.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
Intersection: 3 4 5

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數(shù)。我們需要找出這兩個向量的交集。

首先，我們創(chuàng)建了一個目標(biāo)容器intersection，它的大小為兩個輸入容器中較小的那個。

然后，使用set_intersection函數(shù)將兩個輸入容器中的交集復(fù)制到目標(biāo)容器intersection中。set_intersection函數(shù)接受五個參數(shù)，分別是兩個輸入容器的起始和結(jié)束迭代器，以及目標(biāo)容器的起始迭代器。這樣，交集中的元素就會復(fù)制到目標(biāo)容器中。

最后，我們遍歷目標(biāo)容器中的元素，并輸出交集中的值。

set_union——求兩個集合的并集

函數(shù)原型

• set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // beg1 容器1開始迭代器
  // end1 容器1結(jié)束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結(jié)束迭代器
  // dest 目標(biāo)容器開始迭代器

總結(jié)（和set_intersection差不多）

• 求并集的兩個集合必須的有序序列
• 目標(biāo)容器開辟空間需要兩個容器相加
• set_union返回值既是并集中最后一個元素的位置

示例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> unionSet(vec1.size() + vec2.size());

    auto it = std::set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), unionSet.begin());

    // 輸出并集中的元素
    std::cout << "Union: ";
    for (auto i = unionSet.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
Union: 1 2 3 4 5 6 7

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數(shù)。我們需要找出這兩個向量的并集。

首先，我們創(chuàng)建了一個目標(biāo)容器unionSet，它的大小為兩個輸入容器的總大小。

然后，使用set_union函數(shù)將兩個輸入容器中的并集復(fù)制到目標(biāo)容器unionSet中。
set_union函數(shù)接受五個參數(shù)，分別是兩個輸入容器的起始和結(jié)束迭代器，以及目標(biāo)容器的起始迭代器。這樣，并集中的元素就會復(fù)制到目標(biāo)容器中。

最后，我們遍歷目標(biāo)容器中的元素，并輸出并集中的值。

set_difference——求兩個集合的差集

函數(shù)原型

• set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // beg1 容器1開始迭代器
  // end1 容器1結(jié)束迭代器
  // beg2 容器2開始迭代器
  // end2 容器2結(jié)束迭代器
  // dest 目標(biāo)容器開始迭代器

總結(jié)（都差不多）

• 求差集的兩個集合必須的有序序列
• 目標(biāo)容器開辟空間需要從兩個容器取較大值
• set_difference返回值既是差集中最后一個元素的位置

示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec1 {1, 2, 3, 4, 5};
    std::vector<int> vec2 {3, 4, 5, 6, 7};

    std::vector<int> difference(std::max(vec1.size(), vec2.size()));

    auto it = std::set_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), difference.begin());

    // 輸出差集中的元素
    std::cout << "Difference: ";
    for (auto i = difference.begin(); i != it; ++i) {
        std::cout << *i << " ";
    }
    std::cout << std::endl;

    return 0;
}

輸出結(jié)果為：
Difference: 1 2

在這個示例中，我們有兩個有序的向量vec1和vec2，分別包含了不同的整數(shù)。我們需要找出這兩個向量的差集。

首先，我們創(chuàng)建了一個目標(biāo)容器difference，它的大小為兩個輸入容器中較大的那個。

然后，使用set_difference函數(shù)將兩個輸入容器中的差集復(fù)制到目標(biāo)容器difference中。
set_difference函數(shù)接受五個參數(shù)，分別是兩個輸入容器的起始和結(jié)束迭代器，以及目標(biāo)容器的起始迭代器。這樣，差集中的元素就會復(fù)制到目標(biāo)容器中。

最后，我們遍歷目標(biāo)容器中的元素，并輸出差集中的值。文章來源地址http://www.zghlxwxcb.cn/news/detail-654038.html

到了這里，關(guān)于Day 31 C++ STL常用算法（下）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！