要素を探索する | Programming Place Plus　新C++編

条件に合わない要素を探す (std::find_if_not関数)

条件に合わない要素を探す std::find_if_not関数もあります。条件の意味が逆になる以外の違いはありません。

細かい仕様や、ここで紹介していない機能については、リファレンスサイト（cpprefjp、cppreference.com）で確認してください。

次のサンプルプログラムは、std::vector から、値が 5 の倍数 “ではない” 要素を探索しています。

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

int main()
{
    std::vector<int> v {25, 16, 40, 22, 39};

    auto it = std::find_if_not(std::cbegin(v), std::cend(v), [](int e){ return e % 5 == 0; });
    if (it == std::cend(v)) {
        std::cout << "not found.\n";
    }
    else {
        std::cout << "found: " << *it << "\n";
    }
}

実行結果：

found: 16

条件式の意味を逆にすれば、std::find_if関数で同じ結果を得られます（std::find_if(std::cbegin(v), std::cend(v), [](int e){ return e % 5 != 0; });）。

条件に合う要素の個数を調べる (std::count_if関数)

１番の「該当する要素が何個あるか知りたい」については、std::count_if関数を使うと簡単に実現できます。

細かい仕様や、ここで紹介していない機能については、リファレンスサイト（cpprefjp、cppreference.com）で確認してください。

２つのイテレータで探索範囲を、ラムダ式で条件を指定すると、一致する要素の個数が得られます。

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

int main()
{
    std::vector<int> v {8, 11, -10, 0, -5, 13};

    auto count = std::count_if(std::cbegin(v), std::cend(v), [](int e){ return e < 0; });
    std::cout << count << "\n";
}

実行結果：

2

特定の値を持った要素の個数を探す、std::count関数もあります。

// 8 の個数を返す
auto count = std::count(std::cbegin(v), std::cend(v), 8);

条件に合うすべての要素を書き換える (std::transform関数)

２番の「該当する要素の値を書き換えたい」場合には、std::transform関数が使えます。

細かい仕様や、ここで紹介していない機能については、リファレンスサイト（cpprefjp、cppreference.com）で確認してください。

std::transform関数の主要な用途は、名前のとおり「トランスフォーム（変身）」です。指定範囲内の要素の値を変換して、新たな要素の並びを作り出します。そのため、新たな配列を作り出すという用途で使えるものですが、元の配列の要素を上書きするという使い方もできます。

たとえば、負の値を持った要素をすべて探し出して、符号を反転して正の値に変換するプログラムを次のように作成できます。

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

int main()
{
    std::vector<int> v {8, 11, -10, 0, -5, 13};

    std::transform(std::begin(v), std::end(v), std::begin(v), [](int e){ return (e < 0) ? -e : e; });

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

実行結果：

8
11
10
0
5
13

std::transform関数に渡す情報の１つ目と２つ目は、対象の範囲を表現するイテレータのペアです。３つ目は、各要素に処理を行ったあと、その結果を書き出す先の範囲の先頭を指すイテレータです。４つ目は、各要素に適用する処理を記述したラムダ式です。

探索したい要素の条件は、ラムダ式の中で記述します。これまでにみてきた find系の関数と違って、条件式の記述だけでなく、値の変換のコードまで書く必要があります。つまり、std::transform関数では、ラムダ式の return文に、条件に一致したかどうかをあらわす bool型の値ではなく、変換された後の要素の値を指定します。

探索範囲は、v の先頭から末尾までなので、8, 11, -10, … の順に１つ１つアクセスされ、そのつど値が e にコピーされて、ラムダ式のコードにやってきます。ラムダ式のコードは、e が負数なら符号を反転、負数でなければそのまま return文で返すというものです。返された値は、std::transform関数に渡した３つ目のイテレータが指す先にコピーされます。１つコピーされると、次回のコピー先は１要素分後ろにずらされます。

変換後の値を、変換元とは異なる配列へ書き出す場合、書き込み先の配列の大きさを超えないように注意してください（未解説ですが、std:: back_inserter^{1 2} などの挿入イテレータという仕組みを使うとうまく書けます）。

論理OR

２つの条件のいずれかを満たしている要素を探してみます。たとえば、「値が 100以上、あるいは 5 の倍数」という条件を考えてみます。この場合、15 や 102 は条件を満たしますが、99 は条件を満たしません。また、100 や 105 は条件を満たします（２つの条件を両方ともを満たすケース）。

このような条件は、論理OR や論理和 (logical OR) などと呼ばれます。論理OR は、‘||’ という表記の論理OR演算子 (logical OR operator) を使って記述します。

条件式１ || 条件式２

まず、「条件式１」が評価され、bool型の値に変換されます。これが true だった場合、全体としての結果が true になります。「条件式１」が false に評価された場合には、「条件式２」を評価し、bool型の値に変換され、これが true だった場合、全体としての結果が true に、そうでなければ false になります³。

少々ややこしい書き方をしましたが、簡単にいえば「２つの条件式のどちらか一方だけでもいいので、true ならば true。そうでないなら false になる」ということです。

実際のプログラムでは次のように使えます。

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

int main()
{
    std::vector<int> v {102, 99, 100, 101, 103};

    auto it = std::find_if(std::cbegin(v), std::cend(v), [](int e){ return e >= 100 || e % 5 == 0; });
    if (it == std::cend(v)) {
        std::cout << "not found.\n";
    }
    else {
        std::cout << "found: " << *it << "\n";
    }
}

実行結果：

found: 102

最初に少々ややこしい説明のしかたをしたのには理由があります。きちんと読むと、「条件式１」が true になったときには「条件式２」が評価すらされないことが分かります。「２つの条件のどちらかを満たすかどうか」ということが知りたいわけなので、条件式の一方を調べてみて true なのであれば、もう一方の条件式を調べることに意味がないため、評価自体を省略してしまうのです。このような評価のルールを、短絡評価 (short-circuit evaluation) と呼びます。

短絡評価が行われるため、２つの条件の一方の側が、他方に比べてあきらかに処理に時間がかかるものであるなら、それを「条件式２」に置いたほうが効率的になります。たとえば、std::vector<std::string> から、「ある非常に長い文字列と一致しているか、空文字列である」要素を探したいとします。非常に長い文字列との一致を調べるには、１文字１文字すべて突き合わせる比較が必要なので、（要素の内容次第ですが）時間がかかる可能性があります。一方、空文字列であるかどうかはすぐにわかりますから、「「ある非常に長い文字列と一致しているか」という条件のほうを「条件式２」に置いたほうが効率的になることが期待できます。

条件式を３つ以上組み合わせたい場合は、|| をつなげて条件式を書き並べていけばいいです。たとえば、「値が 100以上、あるいは 5 の倍数、あるいは 7 の倍数」としたければ、e >= 100 || e % 5 == 0 || e % 7 == 0 のように書けます。短絡評価なので、左側の条件式から順番に評価され、true になった時点で、それ以降の条件式は評価されません。

論理AND

２つの条件を両方とも満たしている要素を探してみます。たとえば、「値が 100以上で、かつ、奇数である」という条件を考えてみます。この場合、101 や 103 は条件を満たしますが、99 や 100 は条件を満たしません（99 は奇数だが 100以上ではない。100 は 100以上だが奇数ではない）。

このような条件は、論理AND や論理積 (logical AND) などと呼ばれます。論理ANDは、&& という表記の論理AND演算子 (logical AND operator) を使って記述します。

条件式１ && 条件式２

「条件式１」と「条件式２」それぞれを評価した結果が true になる場合にかぎって、結果が true になります。これ以外のパターンでは false になります。

論理AND演算子にも短絡評価のルールがあります。論理AND演算子では、必ず「条件式１」が先に評価され、もし false であったなら、「条件式２」は評価されません⁴。

実際のプログラムでは次のように使えます。

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

int main()
{
    std::vector<int> v {102, 99, 100, 101, 103};

    auto it = std::find_if(std::cbegin(v), std::cend(v), [](int e){ return e >= 100 && e % 2 != 0; });
    if (it == std::cend(v)) {
        std::cout << "not found.\n";
    }
    else {
        std::cout << "found: " << *it << "\n";
    }
}

実行結果：

found: 101

論理AND演算子における短絡評価は、「条件式１」を満たすことを前提とした「条件式２」を記述することに利用できます。たとえば、std::vector<std::string> から、「先頭の文字が ‘A’ である文字列」を探すことを考えてみます。この条件を e.at(0) == 'A' のように記述できますが、もし値が空文字列な要素が含まれていたら、範囲外アクセスを起こし、プログラムが強制終了してしまいます。そのため、この条件式を評価する前に、空文字列でないことを確認しなければなりません。そこで、短絡評価を利用して、e.empty() == false && e.at(0) == 'A' と記述します。必ず e.empty() == false が先に評価されるため、空文字列でない場合にだけ、e.at(0) == 'A' を評価させることができます。

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

int main()
{
    std::vector<std::string> v {"", "apple", "Apple"};

    auto it = std::find_if(std::cbegin(v), std::cend(v), [](std::string e){ return e.empty() == false && e.at(0) == 'A'; });
    if (it == std::cend(v)) {
        std::cout << "not found.\n";
    }
    else {
        std::cout << "found: " << *it << "\n";
    }
}

実行結果：

found: Apple

論理AND演算子と論理OR演算子が混在した複雑な条件を記述することもできます。たとえば、「値が負の数である。または 100以上で、かつ、奇数である」という場合、e < 0 || e >= 100 && e % 2 != 0 と書けます。演算子の優先順位は、論理OR演算子よりも、論理AND演算子の方が高いです。そのため、このコードは e < 0 || (e >= 100 && e % 2 != 0) と同じです。

演算子の優先順位については、APPENDIX の「演算子の一覧」を参照してください。

演算子の優先順位と、どのオペランドから評価されるかは別の話であることに注意してください。オペランドが評価される順番は、一部の例外的な演算子を除いて、定義されていません⁵。論理AND演算子、論理OR演算子には、短絡評価のルールがあるので、例外的な演算子に当たり、かならず左側のオペランドが先、右側のオペランドが後で評価されます。

さきほどのコードでいえば、|| より && が優先度が高いため、e >= 100 && e % 2 != 0 が優先して評価されそうに思えますが、|| の左側のオペランドが先に評価されます。そうでないと、論理OR演算子の短絡評価のルールに合いません（|| の左側の値が分かる前に、右側を評価するわけにはいかない）。e < 0 が false の場合にのみ、e >= 100 && e % 2 != 0 の評価に進みます。&& の短絡評価のルールに沿って、左側の e >= 100 から評価され、これが true の場合にのみ、右側の e % 2 != 0 が評価されます。

論理否定

最後に、条件を否定する、論理否定（論理NOT） (logical negation、logical NOT) を紹介します。論理AND、論理OR とちがって、登場する条件は１つだけで、その結果を反対にするというものです。

論理否定は、! という表記の論理否定演算子 (logical negation operator) を使って記述します。

!条件式

「条件式」が true の場合は false になり、false の場合は true になります。

これまでのページでも何度か、xxx == false というかたちの条件式を書いたことがありますが、論理否定演算子を使って !xxx のように書けます。

! が目立たず見落としやすいため、! xxx のように、空白をはさむ書き方が好まれることがあります。

次のプログラムは、空文字列でない要素を探しています。

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

int main()
{
    std::vector<std::string> v {"", "", "hello"};

    auto it = std::find_if(std::cbegin(v), std::cend(v), [](std::string e){ return !e.empty(); });
    if (it == std::cend(v)) {
        std::cout << "not found.\n";
    }
    else {
        std::cout << "found: " << *it << "\n";
    }
}

実行結果：

found: hello