Zoeken…


std :: for_each

template<class InputIterator, class Function>
    Function for_each(InputIterator first, InputIterator last, Function f);

Effecten:

Geldt f het resultaat van elke iterator dereferentie in het bereik [first, last) vanaf first en gaan tot last - 1 .

parameters:

first, last - het bereik waarop f moet worden toegepast.

f - opvraagbaar object dat wordt toegepast op het resultaat van derefereren van elke iterator in het bereik [first, last) .

Winstwaarde:

f (tot C ++ 11) en std::move(f) (sinds C ++ 11).

complexiteit:

Geldt f precies als last - first keer.

Voorbeeld:

C ++ 11
std::vector<int> v { 1, 2, 4, 8, 16 };
std::for_each(v.begin(), v.end(), [](int elem) { std::cout << elem << " "; });

Past de gegeven functie toe voor elk element van de vector v drukt dit element af naar stdout .

std :: next_permutation

template< class Iterator >
bool next_permutation( Iterator first, Iterator last );
template< class Iterator, class Compare >
bool next_permutation( Iterator first, Iterator last, Compare cmpFun );

Effecten:
Schuif de gegevensreeks van het bereik [eerste, laatste) naar de volgende lexicografisch hogere permutatie. Als cmpFun is opgegeven, is de permutatieregel aangepast.

parameters:
first - het begin van het te permuteren bereik, inclusief
last - het einde van het te permuteren bereik, exclusief

Winstwaarde:
Retourneert true als een dergelijke permutatie bestaat.
Anders wordt het bereik omgezet in de lexicografisch kleinste permutatie en wordt false geretourneerd.

complexiteit:
O (n), n is de afstand van first tot last .

Voorbeeld :

std::vector< int > v { 1, 2, 3 };
do
{
   for( int i = 0; i < v.size(); i += 1 )
   {
       std::cout << v[i];
   }
   std::cout << std::endl;
}while( std::next_permutation( v.begin(), v.end() ) );

print alle permutatiegevallen van 1,2,3 in lexicografisch toenemende volgorde.
output:

123  
132
213
231
312
321

std :: accumuleren

Gedefinieerd in kop <numeric>

template<class InputIterator, class T>
T accumulate(InputIterator first, InputIterator last, T init); // (1)

template<class InputIterator, class T, class BinaryOperation>
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation f); // (2)

Effecten:

std :: accumuleren voert vouwbewerking uit met behulp van de f functie op bereik [first, last) beginnend met init als accumulatorwaarde.

In feite is het equivalent van:

T acc = init;
for (auto it = first; first != last; ++it)
    acc = f(acc, *it);
return acc;

In versie (1) wordt operator+ gebruikt in plaats van f , dus accumuleren over container is equivalent aan som van containerelementen.

parameters:

first, last - het bereik waarop f moet worden toegepast.
init - beginwaarde van de accumulator.
f - binaire vouwfunctie.

Winstwaarde:

Geaccumuleerde waarde van f toepassingen.

complexiteit:

O (n × k) , waarbij n de afstand van first tot last , O (k) is de complexiteit van de f functie.

Voorbeeld:

Eenvoudig somvoorbeeld:

std::vector<int> v { 2, 3, 4 };
auto sum = std::accumulate(v.begin(), v.end(), 1);
std::cout << sum << std::endl;

Output:

10

Converteer cijfers naar nummer:

C ++ 11
class Converter {
public:
    int operator()(int a, int d) const { return a * 10 + d; }
};

en later

const int ds[3] = {1, 2, 3};
int n = std::accumulate(ds, ds + 3, 0, Converter());
std::cout << n << std::endl;
C ++ 11
const std::vector<int> ds = {1, 2, 3};
int n = std::accumulate(ds.begin(), ds.end(),
                        0,
                        [](int a, int d) { return a * 10 + d; });
std::cout << n << std::endl;

Output:

123

std :: vondst

template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);

Effecten

Vindt het eerste optreden van val binnen het bereik [eerste, laatste)

parameters

first => iterator wijzend naar het begin van het bereik last => iterator wijzend naar het einde van het bereik val => De waarde die moet worden gevonden binnen het bereik

terugkeer

Een iterator die verwijst naar het eerste element binnen het bereik dat gelijk is (==) aan val, de iterator wijst naar de duur als val niet wordt gevonden.

Voorbeeld

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

using namespace std;

int main(int argc, const char * argv[]) {

  //create a vector
  vector<int> intVec {4, 6, 8, 9, 10, 30, 55,100, 45, 2, 4, 7, 9, 43, 48};

  //define iterators
  vector<int>::iterator  itr_9; 
  vector<int>::iterator  itr_43; 
  vector<int>::iterator  itr_50; 

  //calling find
  itr_9 = find(intVec.begin(), intVec.end(), 9); //occurs twice
  itr_43 = find(intVec.begin(), intVec.end(), 43); //occurs once

  //a value not in the vector
  itr_50 = find(intVec.begin(), intVec.end(), 50); //does not occur

  cout << "first occurence of: " << *itr_9 << endl;
  cout << "only occurence of: " << *itr_43 << Lendl;


  /*
    let's prove that itr_9 is pointing to the first occurence
    of 9 by looking at the element after 9, which should be 10 
    not 43
  */
  cout << "element after first 9: " << *(itr_9 + 1) << ends;

  /*
    to avoid dereferencing intVec.end(), lets look at the 
    element right before the end
  */
  cout << "last element: " << *(itr_50 - 1) << endl;

  return 0;
}

uitgang

first occurence of: 9
only occurence of: 43
element after first 9: 10
last element: 48

std :: count

template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type
count (InputIterator first, InputIterator last, const T& val);

Effecten

Telt het aantal elementen dat gelijk is aan val

parameters

first => iterator die naar het begin van het bereik wijst
last => iterator die naar het einde van het bereik wijst
val => Het voorkomen van deze waarde in het bereik wordt geteld

terugkeer

Het aantal elementen in het bereik dat gelijk is (==) aan val.

Voorbeeld

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

using namespace std;

int main(int argc, const char * argv[]) {
  
  //create vector
  vector<int> intVec{4,6,8,9,10,30,55,100,45,2,4,7,9,43,48};
  
  //count occurences of 9, 55, and 101
  size_t count_9 = count(intVec.begin(), intVec.end(), 9); //occurs twice
  size_t count_55 = count(intVec.begin(), intVec.end(), 55); //occurs once
  size_t count_101 = count(intVec.begin(), intVec.end(), 101); //occurs once
  
  //print result
  cout << "There are " << count_9  << " 9s"<< endl;
  cout << "There is " << count_55  << " 55"<< endl;
  cout << "There is " << count_101  << " 101"<< ends;

  //find the first element == 4 in the vector
  vector<int>::iterator itr_4 = find(intVec.begin(), intVec.end(), 4);

  //count its occurences in the vector starting from the first one
  size_t count_4 = count(itr_4, intVec.end(), *itr_4); // should be 2

  cout << "There are " << count_4  << " " << *itr_4 << endl;

  return 0;
}

uitgang

There are 2 9s
There is 1 55
There is 0 101
There are 2 4

std :: count_if

template <class InputIterator, class UnaryPredicate>
typename iterator_traits<InputIterator>::difference_type
count_if (InputIterator first, InputIterator last, UnaryPredicate red);

Effecten

Telt het aantal elementen in een bereik waarvoor een opgegeven predikaatfunctie waar is

parameters

first => iterator wijst naar het begin van het bereik last => iterator wijst naar het einde van het bereik red => predikaatfunctie (retourneert true of false)

terugkeer

Het aantal elementen binnen het opgegeven bereik waarvoor de predikaatfunctie true retourneerde.

Voorbeeld

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

using namespace std;

/*
    Define a few functions to use as predicates
*/

//return true if number is odd
bool isOdd(int i){
  return i%2 == 1;
}

//functor that returns true if number is greater than the value of the constructor parameter provided
class Greater {
  int _than;
public:
  Greater(int th): _than(th){}
  bool operator()(int i){
    return i > _than;
  }
};

int main(int argc, const char * argv[]) {
  
  //create a vector
  vector<int> myvec = {1,5,8,0,7,6,4,5,2,1,5,0,6,9,7};

  //using a lambda function to count even numbers
  size_t evenCount = count_if(myvec.begin(), myvec.end(), [](int i){return i % 2 == 0;}); // >= C++11
  
  //using function pointer to count odd number in the first half of the vector
  size_t oddCount = count_if(myvec.begin(), myvec.end()- myvec.size()/2, isOdd);
  
  //using a functor to count numbers greater than 5
  size_t greaterCount = count_if(myvec.begin(), myvec.end(), Greater(5));

  cout << "vector size: " << myvec.size() << endl;
  cout << "even numbers: " << evenCount << " found" << endl;
  cout << "odd numbers: " << oddCount << " found" << endl;
  cout << "numbers > 5: " << greaterCount << " found"<< endl;
  
  return 0;
}

uitgang

vector size: 15
even numbers: 7 found
odd numbers: 4 found
numbers > 5: 6 found

std :: find_if

template <class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);

Effecten

Zoekt het eerste element in een bereik waarvoor de predikaatfunctie pred true retourneert.

parameters

first => iterator wijst naar het begin van het bereik last => iterator wijst naar het einde van het bereik pred => predikaatfunctie (retourneert true of false)

terugkeer

Een iterator die verwijst naar het eerste element binnen het bereik waarvoor de predikaatfunctie pred waar retourneert. De iterator wijst naar de laatste als val niet wordt gevonden

Voorbeeld

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


using namespace std;

/*
    define some functions to use as predicates
*/

//Returns true if x is multiple of 10
bool multOf10(int x) {
  return x % 10 == 0;
}

//returns true if item greater than passed in parameter
class Greater {
  int _than;

public:
  Greater(int th):_than(th){
    
  }
  bool operator()(int data) const 
  {
    return data > _than;
  }
};


int main()
{

  vector<int> myvec {2, 5, 6, 10, 56, 7, 48, 89, 850, 7, 456};
  
  //with a lambda function
  vector<int>::iterator gt10 = find_if(myvec.begin(), myvec.end(), [](int x){return x>10;}); // >= C++11
  
  //with a function pointer
  vector<int>::iterator pow10 = find_if(myvec.begin(), myvec.end(), multOf10);

  //with functor
  vector<int>::iterator gt5 = find_if(myvec.begin(), myvec.end(), Greater(5));

  //not Found
  vector<int>::iterator nf = find_if(myvec.begin(), myvec.end(), Greater(1000)); // nf points to myvec.end()


  //check if pointer points to myvec.end()
  if(nf != myvec.end()) {
    cout << "nf points to: " << *nf << endl;
  }
  else {
    cout << "item not found" << endl;
  }

  
  
  cout << "First item >   10: " << *gt10  << endl;
  cout << "First Item n * 10: " << *pow10 << endl;
  cout << "First Item >    5: " << *gt5   << endl;
  
  return 0;
}

uitgang

item not found
First item >   10: 56
First Item n * 10: 10
First Item >    5: 6

std :: min_element

template <class ForwardIterator>
ForwardIterator min_element (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Compare>
ForwardIterator min_element (ForwardIterator first, ForwardIterator last,Compare comp);

Effecten

Hiermee wordt het minimumelement in een bereik gevonden

parameters

first - iterator die naar het begin van het bereik wijst
last - iterator wijst naar het einde van het bereik comp - een functiepointer of functieobject dat twee argumenten aanneemt en waar of onwaar retourneert om aan te geven of argument kleiner is dan argument 2. Deze functie mag geen invoer wijzigen

terugkeer

Iterator tot het minimale element in het bereik

ingewikkeldheid

Lineair in één minder dan het aantal vergeleken elementen.

Voorbeeld

#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>  //to use make_pair

using namespace std;

//function compare two pairs
bool pairLessThanFunction(const pair<string, int> &p1, const pair<string, int> &p2)
{
  return p1.second < p2.second;
}

int main(int argc, const char * argv[]) {
  
  vector<int> intVec {30,200,167,56,75,94,10,73,52,6,39,43};
  
  vector<pair<string, int>> pairVector = {make_pair("y", 25), make_pair("b", 2), make_pair("z", 26), make_pair("e", 5) };
  
  
  // default using < operator
  auto minInt = min_element(intVec.begin(), intVec.end());
  
  //Using pairLessThanFunction
  auto minPairFunction = min_element(pairVector.begin(), pairVector.end(), pairLessThanFunction);
  
  
  //print minimum of intVector
  cout << "min int from default: " << *minInt << endl;
  
  //print minimum of pairVector
  cout << "min pair from PairLessThanFunction: " << (*minPairFunction).second << endl;
  
  return 0;
}

uitgang

min int from default: 6
min pair from PairLessThanFunction: 2

Std :: nth_element gebruiken om de mediaan (of andere kwantielen) te vinden

De std::nth_element algoritme duurt drie iterators: een iterator naar het begin, n e plaats, en het einde. Zodra de functie terugkeert, is het n de element (in volgorde) het n kleinste element. (De functie heeft uitgebreidere overbelastingen, bijv. Sommige nemen vergelijkingsfactoren; zie de bovenstaande link voor alle variaties.)

Opmerking Deze functie is zeer efficiënt - het heeft een lineaire complexiteit.

Laten we voor dit voorbeeld de mediaan van een reeks met lengte n definiëren als het element dat zich in positie ⌈n / 2⌉ zou bevinden. De mediaan van een reeks met lengte 5 is bijvoorbeeld het op twee na kleinste element, evenals de mediaan van een reeks met lengte 6.

Om deze functie te gebruiken om de mediaan te vinden, kunnen we het volgende gebruiken. Stel dat we beginnen

std::vector<int> v{5, 1, 2, 3, 4};    

std::vector<int>::iterator b = v.begin();
std::vector<int>::iterator e = v.end();

std::vector<int>::iterator med = b;
std::advance(med, v.size() / 2); 

// This makes the 2nd position hold the median.
std::nth_element(b, med, e);    

// The median is now at v[2].

Om de pde vinden -kwantiel , zouden we een aantal van de lijnen boven te wijzigen:

const std::size_t pos = p * std::distance(b, e);

std::advance(nth, pos);

en zoek de kwantiel op positie pos .



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow