सबसे उपयोगी या अद्भुत एसटीएल लघु लाइनर

Question

मैं कुछ लाइनों में सी ++/एसटीएल कोड फिटिंग के व्यावहारिक और शैक्षिक नमूने की तलाश में हूं। मेरे वास्तविक पसंदीदा हैं:

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

(एक अस्थायी साथ स्वैप)

कॉपी एक वेक्टर के लिए एक मानचित्र:

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

1. खाली एक वेक्टर अपनी आरक्षित स्मृति को मुक्त कराने के

2. कस्टम, गैर-बूस्ट विभाजन:

   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

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

भी आप ने उल्लेख किया उदाहरण और dirkgently है।

Answer 2

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 3

अपने दूसरे उदाहरण मान प्रकार उपयोग करें:

#

Copy a map to a vector: 

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

Answer 4

मेरा पसंदीदा उत्पादन के लिए कंटेनर को कॉपी किया जाता है: और एक कंटेनर में इनपुट धारा को कॉपी।

#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 5

निम्नलिखित मुहावरा वास्तव में से remove() या remove_if() हटाया तत्वों को दूर करने की जरूरत है:

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

remove() और remove_if() बस नहीं निकाले गए तत्वों आगे स्लाइड और रिपोर्ट जहां नई रेंज समाप्त होता है - वे उन्हें हटाएं (और नहीं कर सकते) उन्हें हटा दें क्योंकि वे किसी भी मनमाने ढंग से इटरेटर श्रेणी पर काम कर सकते हैं, केवल एक कंटेनर नहीं।

Answer 6

मुझे सबसे ज्यादा पसंद है प्रतिनिधियों के प्रकार में 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)); 

बढ़ावा के बाँध और समारोह का उपयोग करना ज्यादा बेहतर हैं, लेकिन यह प्रभावशाली जो सिर्फ एसटीएल साथ किया जा सकता है।

Answer 7

मुझे यह फ़ाइल में प्रत्येक पंक्ति पर लूपिंग के लिए पसंद है।डॉ। डॉब्स में एक एंड्रयू कोएनिग कॉलम से।

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

Answer 8

एक लैम्ब्डा समारोह के साथ संयोजन में std :: for_each का उपयोग करना (के बाद से सी ++ 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; 
} 

बेहतर छोरों की तलाश के लिए बनाता है।