Jaka jest twoja ulubiona sztuczka STL?

Question

I już zostały programowania w języku C++ na dłuższą chwilę teraz, ale co jakiś czas, a potem natknąć fragmentu kodu przy użyciu STL, które podjęły sobie sporo czasu i dużo więcej kodu do wykonania.

STL zajmuje sporo czasu, aby się do tego przyzwyczaić, a nie ma tam zbyt wielu zasobów z przykładami, jak z niego korzystać. Proszę, podziel się ze mną swoją ulubioną funkcją STL!

Answer 1

dos2unix.cpp

#include <fstream> 
#include <iterator> 
#include <algorithm> 

bool is_cr(char c) { return c == '\r'; } 

int main(int, char* a[]) 
{ 
    std::ifstream is("/dev/stdin"); 
    std::ofstream os("/dev/stdout"); 
    std::istreambuf_iterator<char> in(is), end; 
    std::ostreambuf_iterator<char> out(os); 
    remove_copy_if(in, end, out, is_cr); 
} 

Answer 2

usuwanie pewnych elementów z wektorem czasie liniowej z wymazaniem remove-idiomu:

vec.erase(std::remove(vec.begin(), vec.end(), is_odd), vec.end()); 

(ręcznie przelotowego wektora i jego usuwanie na zasadzie w przeliczeniu na element będzie wynosić czas kwadratowy.)

Answer 3

Kontenery, iteratory, al gorithms: wszystkie dobre rzeczy. I to naprawdę nie jest sztuczka, per se, ale dla mnie najlepszą rzeczą w STL jest functors. Iteratory mogą być klejem, który trzyma razem samochód STL, ale funktory są silnikiem, który sprawia, że ​​jest on naprawdę oszczędny i lepiej napisać kod. W końcu to jest to, o czym jest STL.

Answer 4

Stosując wektor do bufora. Zamiast:

int size_needed = GetData(NULL, 0); 
char * buffer = new char[size_needed]; 
GetData(buffer, size_needed); 
... 
delete [] buffer; 

Stosując wektor:

int size_needed = GetData(NULL, 0); 
std::vector<char> buffer(size_needed); 
GetData(&buffer[0], size_needed); 

Answer 5

shared_ptr wewnątrz shared_ptr.

Czasami używam niestandardowego destruktora std :: shared_ptr, aby zaimplementować prostą metodę wspólnej puli. Dunno, jeśli liczy się jako "trik".

class Factory 
{ 
    std::queue<std::shared_ptr<Type>> pool_; // Possibly tbb::concurrent_bounded_queue. Could also be contained as a shared_ptr to allow objects to outlive the factory. 
public: 
    std::shared_ptr<Type> create() 
    { 
     std::vector<Type> ptr; 
     if(pool.empty()) 
      ptr = std::make_shared<Type>(); 
     else 
     { 
      ptr = std::move(pool_.front()); 
      pool_.pop(); 
     } 

     return std::shared_ptr<Type>(ptr.get(), [=](Type*){pool_.push(ptr)};); // Put back into pool once destructed 
    } 
} 

Answer 6

Pamiętam, że bardzo lubiłem, kiedy natknął się nad nim (~ 10 lat temu) w comp.lang.c++.moderated:

int main(int argc, char* argv[]) 
{ 
    std::vector arguments(argv+1, argv+argc); 
    // whatever 
} 

Dzisiaj, nie używam już tego. Po co umieszczać materiał w wektorze, który następnie przetwarza się za pomocą iteratorów, skoro na początku są już iteratory? To już nie dotyczy tyle STL jako zbiór pojemników i algorytmów, ale pomysł przyniósł na nas klejenia sekwencje i algorytmy przez iteratory:

template<typename It> 
int process_arguments(It begin, It end) 
{ 
    // whatever we need to do with those arguments... 
} 

int main(int argc, char* argv[]) 
{ 
    return process_arguments(argv+1, argv+argc); 
} 

(Tak, dość często pisać małą konsolę narzędzia.)

Answer 7

Najbardziej podoba mi się używanie STL do kodowania w stylu funkcjonalnym.Na przykład, licząc elementy mniejsze niż 2:

n = std::count_if(v.begin(), v.end(), std::bind2nd(std::less<int>(), 2)); 

Answer 8

Nie jest szczególnie użyteczny, ale I jak udaje std::iota (gdzie C++ 0x nie jest dostępny) o wywołaniu std::partial_sum:

std::vector<int> v(5, 1); // 1, 1, 1, 1, 1 
    partial_sum(v.begin(), v.end(), v.begin()); // 1, 2, 3, 4, 5 

As coś mam faktycznie używane w kodzie produkcji: testowanie czy dwa pliki są identyczne:

if(equal(std::istreambuf_iterator<char>(file1), 
      std::istreambuf_iterator<char>(), 
      std::istreambuf_iterator<char>(file2))) 
    { // files are equal, do whatever 

ogólnie myślę partial_sum i inner_product zasługują na dużo więcej miłości, niż widzą. Przy wystarczająco inteligentnych funktorach potrafią robić wspaniałe rzeczy.

Answer 9

Mój ulubiony trik STL jest unikanie używania

• CRT
• surowe wskaźniki (C++ 0x).

Ekspresyjność kodu STL kontra ekwiwalent brutalnej siły jest niesamowita.