std::find_end - cppreference.com

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Elemento definito nell'header `<algorithm>`

`template< class ForwardIt1, class ForwardIt2 > ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );`	(1)

`template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );`	(2)

Cerca la sottosequenza ultimo [s_first, s_last) elementi nel [first, last) gamma. La prima versione utilizza operator== di confrontare gli elementi, la seconda versione utilizza il predicato binario dato p.

Original:

Searches for the last subsequence of elements [s_first, s_last) in the range [first, last). The first version uses operator== to compare the elements, the second version uses the given binary predicate p.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parametri

first, last	-	la gamma di elementi da esaminare Original: the range of elements to examine The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
s_first, s_last	-	la gamma di elementi da cercare Original: the range of elements to search for The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
p	-	binary predicate which returns `true` if the elements should be treated as equal. The signature of the predicate function should be equivalent to the following: `bool pred(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`, but the function must not modify the objects passed to it. The types `Type1` and `Type2` must be such that objects of types `ForwardIt1` and `ForwardIt2` can be dereferenced and then implicitly converted to `Type1` and `Type2` respectively.
Type requirements
-`ForwardIt1` must meet the requirements of `ForwardIterator`.
-`ForwardIt2` must meet the requirements of `ForwardIterator`.

Valore di ritorno

Iterator all'inizio [s_first, s_last) sottosuccessione ultima gamma [first, last).

Original:

Iterator to the beginning of last subsequence [s_first, s_last) in range [first, last).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Se non sottosequenza non viene trovato, viene restituito last. (fino al c++11)

Original:

If no such subsequence is found, last is returned. (fino al c++11)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Se [s_first, s_last) è vuoto o se non sottosequenza non viene trovato, viene restituito last. (dal C++11)

Original:

If [s_first, s_last) is empty or if no such subsequence is found, last is returned. (dal C++11)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Complessità

Fa a confronto la maggior parte S*(N-S+1) dove S = distance(s_first, s_last) e N = distance(first, last).

Original:

Does at most S*(N-S+1) comparisons where S = distance(s_first, s_last) and N = distance(first, last).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Possibile implementazione

First version
template<class ForwardIt1, class ForwardIt2> ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last) { if (s_first == s_last) return last; ForwardIt1 result = last; while (1) { ForwardIt1 new_result = std::search(first, last, s_first, s_last); if (new_result == last) { return result; } else { result = new_result; first = result; ++first; } } return result; }
Second version
template<class ForwardIt1, class ForwardIt2, class BinaryPredicate> ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p) { if (s_first == s_last) return last; ForwardIt1 result = last; while (1) { ForwardIt1 new_result = std::search(first, last, s_first, s_last, p); if (new_result == last) { return result; } else { result = new_result; first = result; ++first; } } return result; }

First version

template<class ForwardIt1, class ForwardIt2>
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 s_first, ForwardIt2 s_last)
{
    if (s_first == s_last)
        return last;
    ForwardIt1 result = last;
    while (1) {
        ForwardIt1 new_result = std::search(first, last, s_first, s_last);
        if (new_result == last) {
            return result;
        } else {
            result = new_result;
            first = result;
            ++first;
        }
    }
    return result;
}

Second version

template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 s_first, ForwardIt2 s_last,
                    BinaryPredicate p)
{
    if (s_first == s_last)
        return last;
    ForwardIt1 result = last;
    while (1) {
        ForwardIt1 new_result = std::search(first, last, s_first, s_last, p);
        if (new_result == last) {
            return result;
        } else {
            result = new_result;
            first = result;
            ++first;
        }
    }
    return result;
}

Esempio

Il codice seguente utilizza find_end() per la ricerca di due diverse sequenze di numeri .

Original:

The following code uses find_end() to search for two different sequences of numbers.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

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

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

    result = std::find_end(v.begin(), v.end(), t1.begin(), t1.end());
    if (result == v.end()) {
        std::cout << "subsequence not found\n";
    } else {
        std::cout << "last subsequence is at: "
                  << std::distance(v.begin(), result) << "\n";
    }

    std::vector<int> t2{4, 5, 6};
    result = std::find_end(v.begin(), v.end(), t2.begin(), t2.end());
    if (result == v.end()) {
        std::cout << "subsequence not found\n";
    } else {
        std::cout << "last subsequence is at: " 
                  << std::distance(v.begin(), result) << "\n";
    }
}

Output:

last subsequence is at: 8
subsequence not found

Vedi anche


adjacent_find	trova due identici (o qualche altra relazione) elementi adiacenti l'uno all'altro Original: finds two identical (or some other relationship) items adjacent to each other The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]

find find_if find_if_not (C++11)	trova il primo elemento che soddisfi i criteri specifici Original: finds the first element satisfying specific criteria The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]

find_first_of	searches for any one of a set of elements (funzione di modello) [modifica]

search_n	ricerche di un numero di copie consecutive di un elemento in un intervallo Original: searches for a number consecutive copies of an element in a range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (funzione di modello) [modifica]