要素を取り除く | Programming Place Plus　新C++編

pop_back関数

末尾の要素を取り除くには、pop_back関数を使います。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {0, 1, 2};

    v.pop_back();

    for (auto e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

0
1

pop_back関数を、要素がない状態で使うことは、未定義動作であることに注意が必要です。

std::vector v {};
v.pop_back();  // 危険

末尾の要素にアクセスする (back関数)

pop_back関数は単に末尾から要素を取り除くだけです。取り除かれた要素の値が何であったか知りたい場合もあると思いますが、その場合は、back関数と併用します。back関数を使うと、末尾の要素にアクセスすることができます（取り除きはしない）。

back関数によって得られるものは、末尾の要素への参照です。参照については「std::vector」のページで取り上げました。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {0, 1, 2};

    while (v.empty() == false) {
        std::cout << v.back() << "\n";
        v.pop_back();
    }
}

実行結果：

2
1
0

back関数も pop_back関数と同様に、要素がない状態で使うことは、未定義動作であることに注意が必要です。このサンプルプログラムのように、empty関数を使って、要素があることを確認するなどして、回避してください。

v.empty() == false は、先のページで解説する ! という演算子を使って !v.empty() とも書けます。

ちなみに、先頭の要素にアクセスする front関数もあります。使い方や注意事項は同じです。

erase関数

任意の要素を取り除くには、erase関数を使います。

【上級】【C++20】std::erase関数が追加されました。使い方は std::vector や std::string が持つ erase関数とは異なり、後で取り上げる std::remove関数と組み合わせた仕様になっています。つまり、特定の値をもった要素を探して削除します。^{1 2}

erase関数には、取り除きたい要素を指し示すイテレータを渡します。正しい要素を指していないイテレータを渡してはなりません。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {0, 1, 2, 3};

    v.erase(std::cbegin(v) + 1);

    for (auto e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

0
2
3

連続している複数の要素をまとめて取り除く

erase関数は、２つのイテレータを使って範囲を表現することにより、連続している複数の要素をまとめて取り除くことができます。範囲の開始位置を１つ目のイテレータで、範囲の終了位置を２つ目のイテレータで指定します。past-the-end イテレータの考え方と同じで、終了位置をあらわすには「１つ後ろ」を指すようにすることに注意してください。

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v {0, 1, 2, 3};

    v.erase(std::cbegin(v), std::cbegin(v) + 2);

    for (auto e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

2
3

先頭の要素を指すイテレータと、そこから２つ先の要素を指すイテレータを指定しました。{0, 1, 2, 3} のうち、0 と 1 の要素が取り除かれます。

std::string では、取り除きたい要素の位置をあらわす添字と、取り除きたい要素の個数（文字数）を指定できます。

#include <iostream>
#include <string>

int main()
{
    std::string s {"abcde"};

    s.erase(3, 2);

    std::cout << s << "\n";
}

実行結果：

abc

位置の方は、有効な添字を渡さなければなりません。文字数の指定が大きすぎて、文字列の終わりを超えてしまうことは問題ありません（末尾の文字まですべて取り除きます）。³

std::remove関数

まず、任意の値と一致する要素を探して取り除く方法です。この場合は、std::remove関数を使います。std::remove関数は、std::vector や std::string 自身が持つ機能ではなく、#include <algorithm> という記述が必要です。

【上級】まったく異なる用途（ファイルを削除する）で使う std::remove関数も存在します（「ファイルシステム」のページを参照）。そちらは <cstdio> で宣言されており、Ｃ言語の remove関数の C++版です。

std::remove関数には、要素を探す範囲をあらわす２つのイテレータと、探したい値を指定します。ほとんどの場合、範囲は配列全体ですから、std::remove(std::begin(v), std::end(v), 99); のような感じになります。なお、constイテレータは受け付けません。

さて、ここからが分かりづらいところですが、std::remove関数は、指定した値に一致する要素を取り除くのではなく、取り除く対象にならなかった要素を先頭付近に集めるという動作になっています。

元の配列が {1, 2, 2, 3, 1, 2} だとして、ここから 2 という値を持った要素を取り除くとします。普通は {1, 3, 1} になることを望みますが、std::remove関数は {1, 3, 1, ?, ?, ?} のようにします（? がどうなるかは実装次第であり、ここに 2 が残されている可能性もあります）。これでも先頭付近の３つだけに注目すれば、{1, 3, 1} なので、この範囲だけを見るようにすればいいというわけです。std::remove関数は、取り除かれなかった要素の範囲（{1, 3, 1}）の末尾の次の位置を指すイテレータを返すので、これを受け取って使えばうまくいきます。

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

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

    // v 全体から 2 を探して取り除く。
    // 取り除かれなかった要素の末尾（の次）を指すイテレータを受け取る。
    auto itEnd = std::remove(std::begin(v), std::end(v), 2);

    // 受け取ったイテレータを使って末尾を判断する
    for (auto it = std::cbegin(v); it != itEnd; ++it) {
        std::cout << *it << "\n";
    }
}

実行結果：

2
3

これでうまくいくものの、色々と不安が残ります。終端のイテレータを std::end関数などを使って取得しなおしてしまう事故はありがちですし、範囲for文が使えない（使うと本当の末尾まで走査してしまう）問題もあります。また、実は要素は取り除かれていないわけですから、要素数も減っていません。

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

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

    auto itEnd = std::remove(std::begin(v), std::end(v), 2);

    // 終端のイテレータを誤る
    for (auto it = std::cbegin(v); it != std::cend(v); ++it) {
        std::cout << *it << "\n";
    }

    // 範囲for文は余計なところまで走査してしまう
    for (auto e : v) {
        std::cout << e << "\n";
    }

    // 要素数は減っていない・・・
    std::cout << "size = " << v.size() << "\n";
}

実行結果：

1
3
1
3
1
2
1
3
1
3
1
2
size = 6

やはり、本当の意味で要素を取り除きたいと思うでしょう。そこで、このページで紹介済みの erase関数と組み合わせます。erase関数には、２つのイテレータを使って要素をまとめて取り除く（こちらは本当の意味で取り除く）機能があるので、これと併用します。

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

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

    // v 全体から 2 を探して取り除く。
    // 取り除かれなかった要素の末尾（の次）を指すイテレータを受け取る。
    auto itEnd = std::remove(std::begin(v), std::end(v), 2);

    // 本当の意味で要素を取り除く
    v.erase(itEnd, std::cend(v));

    // 実際に要素が取り除かれたので、std::cend関数で末尾を判断してかまわない
    for (auto it = std::cbegin(v); it != std::cend(v); ++it) {
        std::cout << *it << "\n";
    }

    // 範囲for文でも問題なくなった
    for (auto e : v) {
        std::cout << e << "\n";
    }

    // 要素数も減っている
    std::cout << "size = " << v.size() << "\n";
}

実行結果：

1
3
1
1
3
1
size = 3

std::remove関数と erase関数を使うところは、次のように１行にまとめてしまえます。変数itEnd も消えるので、まとめたほうがいいでしょう。

v.erase(std::remove(std::begin(v), std::end(v), 2), std::cend(v));

対象範囲が配列全体なのであれば、この１文は定型句のように使えます（2 のところを変えるだけで済みます）。

【C++20】std::erase関数が追加され、std::erase(v, 2); という非常に簡潔なコードで記述できるようになりました。¹

std::remove_if関数

std::remove_if関数を使うと、取り除く要素を条件によって指定できます。値の代わりに、条件を指定すること以外は、std::remove関数と同じです。実際には要素は取り除かれませんが、erase関数との併用で、本当の意味で取り除くことができます。なお、#include <algorithm> が必要です。

例として、奇数の値を持つ要素を取り除いてみます。

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

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

    v.erase(std::remove_if(std::begin(v), std::end(v), [](int e){ return e % 2 != 0; }), std::cend(v));

    for (auto e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

2
2
2

[](int e){ return e % 2 != 0; } が条件の指定ですが、これはここまでに登場していない新しい構文です。この記法はラムダ式 (lambda expressions) と呼ばれるものです。先頭の [] が、全体がラムダ式であることを表しており、その後ろの () と {} の部分から構成されます。詳しい解説はここではしませんが、std::remove_if関数が要素を１つ１つ、変数e に渡してきます（(int e)）。{} の中で、変数e の値を使って条件式を記述し、return文を使って、true か false を返すようにします。std::remove_if関数の場合は、true が返された要素を取り除きます。

【C++98/03 経験者】以前は、条件を記述するために、別の関数や関数オブジェクトを使っていました。今でもその方法は使えますが、ラムダ式を使ったほうが簡潔ですし、離れたところにコードを書かなくてすむ利点もあります。

【C++20】std::erase_if関数が追加され、std::erase_if(v, [](int e){ return e % 2 != 0; }); という非常に簡潔なコードで記述できるようになりました。⁴

ラムダ式の {} の内側で、ラムダ式の外側で宣言されている変数を使いたいときには、[] の内側にその変数の名前を記述します。複数必要なら、[v1, v2, v3] のように書きます。

次のサンプルは、変数value の値の倍数と一致する要素を取り除きます。

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

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

    int value {3};
    v.erase(std::remove_if(std::begin(v), std::end(v), [value](int e){ return e % value == 0; }), std::cend(v));

    for (auto e : v) {
        std::cout << e << "\n";
    }
}

実行結果：

1
2
4
5
7

shrink_to_fit関数

容量を減らすには、shrink_to_fit関数を使います。shrink_to_fit関数は、容量を、現在の要素数と同じになるように減らそうとします。

【C++98/03 経験者】これまで swap技法と呼ばれる方法で実現しましたが、今後は shrink_to_fit関数を使いましょう。shrink_to_fit関数は、要素のコピーを避けられる実装になっているため、効率面でも優れています。

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<int> v {};
    std::string s {};

    for (int i = 0; i < 1000; ++i) {
        v.push_back(i);
        s += "!";
    }

    std::cout << "size = " << v.size() << ", capacity = " << v.capacity() << "\n";
    std::cout << "size = " << s.size() << ", capacity = " << s.capacity() << "\n";

    v.shrink_to_fit();
    s.shrink_to_fit();

    std::cout << "size = " << v.size() << ", capacity = " << v.capacity() << "\n";
    std::cout << "size = " << s.size() << ", capacity = " << s.capacity() << "\n";
}

実行結果：

size = 1000, capacity = 1066
size = 1000, capacity = 1188
size = 1000, capacity = 1000
size = 1000, capacity = 1007

実行結果は、Visual Studio 2015 のものです。必ずこの結果と同じになるわけではありません。

注意しなければならないのは、shrink_to_fit関数の効果にははっきりとした強制力がないという点です。「capacity関数が返す結果を、size関数が返す結果と同じになるように容量を減らす」ということになっていますが、結果は実装に任されています⁵。実際、Visual Studio 2015 の実行結果をみると、std::string の方はきちんと 1000 にならず、1007 という中途半端な結果になっています。

【上級】shrink_to_fit関数は確実でないということで、swap技法という代わりの方法が紹介されることがあります。swap技法は shrink_to_fit関数がなかった古い時代の C++ で使われた方法で、std::string(s).swap(s); のように、元のオブジェクトから一時オブジェクトを作り、元のオブジェクトと交換することで容量の削減を試みます。この一時オブジェクトは、元のオブジェクトと同じ要素を持ちますが、容量は要素数から計算されるため、必要十分な容量だけが確保されます。そのため swap で入れ替えてやれば、容量が減るという寸法です。
しかし、swap技法で減らせるのなら、shrink_to_fit関数でも減らせると思われます。shrink_to_fit関数が、容量を要素数と同じ数にまで減らさないことがあるのは、実装の最適化の都合を許すためであって⁵、単純に要求が無視されることがあるという意味ではないはずです（たとえば、あるバイト数の倍数でなければメモリの確保が行えないシステムでは、要素数99 に合わせて、容量を 99 にはできないかもしれない）。これは swap技法であれば解決できるという問題ではないでしょう。また、swap技法の方が効率が劣るので（コピーしているため、そのコストとデストラクタのコストがかかる。shrink_to_fit関数ならムーブで済む）、少なくとも swap技法でなければならないのかどうか確認して判断するべきです。

なお、容量が減らされた場合、メモリを確保しなおしている可能性があり、そうなった場合には要素が移動しています。既存のイテレータはすべて無効になるものと考えたほうがいいです。

【C++17】イテレータが無効になることが明確にされました。⁶