Самые полезные или удивительные короткие лайнеры STL

Question

Я ищу практические и учебные примеры подгонки кода C ++ / STL в несколько строк. Мои настоящие фавориты:

1. Очистить вектор, освобождая его зарезервированную память:

   vector <...>().swap (v)
   

   (своп с временным)

2. Скопировать карту в вектор:

   map<T1, T2> myMap;
   vector< pair<T1, T2> > myVec(myMap.begin(), myMap.end());
   // or
   myVec.assign(myMap.begin(), myMap.end());
   

3. Пользовательский сплит без усиления:

   vector<string> &mysplit(const string &s, char delim, vector<string> &elems) {
       stringstream ss(s);
       string item;
       while(getline(ss, item, delim)) { elems.push_back(item); }
       return elems;
   }
   

Answer 1

Мой фаворит копирует контейнеры в вывод: И копирование входного потока в контейнер.

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

int main()
{
    std::vector<int>   data;
    std::copy(std::istream_iterator<int>(std::cin),
              std::istream_iterator<int>(),
              std::back_inserter(data)
             );

    std::copy(data.begin(),data.end(),
              std::ostream_iterator<int>(std::cout,"\n")
             );
}

Answer 2

Следующая идиома необходима для фактического удаления элементов, удаленных с помощью remove() или remove_if():

vector<int> v;
...
v.erase(remove(v.begin(), v.end(), 42), v.end());

remove() и remove_if() просто перемещают невыбранные элементы вперед и сообщают, где заканчивается новый диапазон - они не (и не могут) удалять их, потому что они могут работать в любом произвольном диапазоне итераторов, а не только контейнер.

Answer 3

// std::back_inserter usage ( std::inserter for map )
std::copy( source.begin(), source.end(), std::back_inserter( container ) );  

-

// mem_fun and bind usage (but boost better)
std::some_algorithm(..., std::mem_fun( func ) );  

не очень полезно, но мощно:

проверка отсортирована в контейнере

std::adjacent_find( container.begin(), container.end(), greater<Container::value_type>() ) == container.end()

также примеры, упомянутые вами и непосредственно.

Answer 4

Что мне больше всего нравится, так это использование bind1st / bind2nd / mem_fun в качестве делегатов.

// will call a->func(v[i])
for_each(v.begin(), v.end(), bind1st(mem_fun(&A::func), &a));

// will call w[i]->func(72)
for_each(w.begin(), w.end(), bind2nd(mem_fun(&A::func), 72));

Использование привязки и функции boost намного лучше, но это впечатляет, что можно сделать только с помощью STL.

Answer 5

copy(istreambuf_iterator<char>(cin), istreambuf_iterator<char>(),
     ostream_iterator<char>(cout));

Другая часто используемая идиома - инициализация контейнера из массива:

#include <map>
using namespace std;

int main() {
    typedef std::map<char,int> LUT;
    typedef LUT::value_type LUT_item_t;

    const LUT_item_t items[] = { LUT_item_t('b',1), 
                                 LUT_item_t('a',5) 
                               };

    LUT my_map(items, items + sizeof items/sizeof items[0]);
    return 0;
}

Но если вам нужна чистая магия, посмотрите Boost Lambda Library ;) Пример:

vector<int*> vp(10); 
sort(vp.begin(), vp.end(), *_1 > *_2);

Answer 6

Для вашего второго примера используйте тип значения:

#

Copy a map to a vector:

typedef map<T1, T2> MyMap;
MyMap myMap;
vector< MyMap::value_type > myVec(myMap.begin(), myMap.end());

Answer 7

Использование std :: for_each в сочетании с лямбда-функцией (начиная с C ++ 11)

std::vector<int> v(20);

std::for_each( v.begin(), v.end(), [] (int item)
{
    std::cout << item;
} );

вместо

for(std::vector<int>::const_iterator it = v.begin(); it != v.end(); ++it)
{
    std::cout << *it;
}

делает петли лучше выглядящими.

Answer 8

Мне нравится этот цикл для каждой строки в файле. Из колонны Эндрю Кенига в «Докторе Доббс».

for (string s; getline(stream,s); ) {
  // Process line
}