最有用或最神奇的STL短行程序 我正在寻找实用的和有教育意义的C++代码/STL代码。我最喜欢的是：

清空向量以释放其保留内存：

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

vector（）.swap（v）

（与临时货币互换）

将贴图复制到向量：

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

map-myMap；
vectormyVec（myMap.begin（），myMap.end（））；
//或
赋值（myMap.begin（），myMap.end（））；

自定义、非增压拆分：

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;
}

vector&mysplit（常量字符串&s、字符delim、vector&elems）{
溪流ss(s);；
字符串项；
while（getline（ss，item，delim））{elems.push_back（item）；}
返回元素；
}

copy（istreambuf_迭代器（cin），istreambuf_迭代器（），
ostream_迭代器（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;
}

#包括
使用名称空间std；
int main（）{
typedef std：：映射LUT；
类型定义LUT:：值\类型LUT \项目\U t；
const LUT_item_t items[]={LUT_item_t（'b'，1），
LUT项目（a'，5）
};
LUT my_映射（项目，项目+项目大小/项目大小[0]）；
返回0；
}

但如果你想要纯粹的魔法，那就看看吧；）样本：

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

向量vp（10）；
排序（vp.begin（），vp.end（），*\u 1>*\u 2）；

-

不是很有用，但很强大：

检查集装箱是否已分拣

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

std:：innect_find（container.begin（）、container.end（）、greater（））==container.end（）

---

还有您和Dirkgent提到的示例。

对于第二个示例，请使用值类型：

Copy a map to a vector:

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

#

将贴图复制到向量：
typedef-map-MyMap；
我的地图；
vectormyVec（MyMap.begin（），MyMap.end（））；

我最喜欢的是将容器复制到输出： 以及将输入流复制到容器中

#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")
             );
}

#包括
#包括
#包括
#包括
int main（）
{
std：：矢量数据；
std:：copy（std:：istream_迭代器（std:：cin），
std:：istream_迭代器（），
标准：背面插入器（数据）
);
std:：copy（data.begin（）、data.end（），
std:：ostream\u迭代器（std:：cout，“\n”）
);
}

实际删除

remove（）

或

remove\u if（）

删除的元素需要以下习惯用法：

向量v； ... v、 擦除（删除（v.begin（），v.end（），42），v.end（））；

---

remove（）

和

remove\u if（）

只需向前滑动未删除的元素，并报告新范围的结束位置——它们不会（也不能）删除它们，因为它们可以处理任意迭代器范围，而不仅仅是容器。

我最喜欢的是在委托中使用bind1st/bind2nd/mem\u

#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")
             );
}

// 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的bind和函数要好得多，但仅使用STL就可以做到这一点，这给人留下了深刻的印象。

我喜欢使用这个函数在文件中的每一行上循环。来自多布斯博士的安德鲁·柯尼格专栏

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

---

将std:：for_与lambda函数结合使用（从C++11开始）

标准：向量v（20）； std:：for_each（v.begin（）、v.end（）、[]（int项） {

---

std：：这里可能存在常见错误。因为istream_迭代器使用了>>运算符，所以将删除空白。为了弥补这一点，您应该使用istream__迭代器确保保留空白。相邻的_find示例非常漂亮。我现在可能会选择您的帖子作为一个可接受的答案。尽管这有点政治性，因为我想通过这个说法来说明的是，boost:：bind在STL刚刚够用的简单情况下被过度使用。一旦有了boost:：bind供您使用，我看不出有任何必要回到原始的STL绑定。它们太原始了。

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

// 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));

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

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;
}