C++ std :: transformuj wektor par-> pierwszy na nowy wektor

Question

Przepraszamy za małe pytanie dla początkujących. Istnieje wektor i wektor par

typedef std::vector <int> TItems; 
typedef std::vector < std::pair <int, int> > TPairs; 

Czy istnieje jakiś sposób, aby przekształcić wszystkie pierwsze pozycje w parze z innym wektorze w jednym kroku

int main() 
{ 
TItems items; 
TPairs pairs; 

pairs.push_back (std::make_pair(1,3)); 
pairs.push_back (std::make_pair(5,7)); 

std::transform(items.begin(), items.end(), items.begin(), comp (&pairs)); 

return 0; 
} 

Jak zaprojektować funktor?

class comp 
{ 
private: 
    TPairs *pairs; 

public: 
    comp (TPairs *pairs_) : pairs (pairs_) { } 

    unsigned int operator() (const unsigned int index) const 
    { 
     return (*pairs)[index].second != pairs->end(); //Bad idea 
    } 
}; 

Być może istnieje bardziej przyjazna dla użytkownika metoda bez wyrażeń lambda i pętli. Dzięki za pomoc.

Answer 1

naprawdę chcę do korzystania std::get jako funktora, bo to już przewidziane jako funkcja biblioteki !!

Czy nie byłoby wspaniale, gdybyśmy mogli napisać tę linię?

std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), std::get<0>); 

... Ale to trochę bardziej przerażające. Trzeba disambiguate która get używać:

int main() { 
    std::vector<int> items; 
    std::vector<std::pair<int, int>> pairs; 

    pairs.push_back(std::make_pair(1, 3)); 
    pairs.push_back(std::make_pair(5, 7)); 

    std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), 
       (const int& (*)(const std::pair<int, int>&))std::get<0>); 

    return 0; 
} 

Problemem jest std::getis overloaded wziąć 1. pair& 2. const pair& i 3. pair&& jako parametry, tak, że będzie pracować dla jakiejkolwiek pary jako wejście.Niestety, przeciążenia uzyskać w drodze potrącenia typu szablon dla std::transform, więc nasz oryginalnej linii

std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), std::get<0>); 

plony

error: no matching function for call to ‘transform(std::vector<std::pair<int, int> >::iterator, std::vector<std::pair<int, int> >::iterator, std::back_insert_iterator<std::vector<int> >, <unresolved overloaded function type>)’ 
    std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), std::get<0>); 
                        ^
... 

/usr/include/c++/4.8/bits/stl_algo.h:4915:5: note: template argument deduction/substitution failed: 
note: couldn't deduce template parameter ‘_UnaryOperation’ 
    std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), std::get<0>); 

on nie wie, które przeciążenie std::get prosicie podczas wyciągania szablon dla std::transform, więc musisz określić go ręcznie. Przesyłanie wskaźnika funkcji do odpowiedniego typu informuje kompilator: "Hej, użyj przeciążenia, w którym get pobiera const& i zwraca const&!"

Ale przynajmniej używamy standardowych komponentów biblioteki (yay)?

I pod względem liczby linii, to nie gorzej niż inne opcje: http://ideone.com/6dfzxz

Answer 2

Co powiesz na to?

items.reserve(pairs.size()); 
for (size_t it = 0; it < pairs.size(); ++it) { 
    items.push_back(pairs[it].first); 
} 

Łatwo zrozumieć i debugować.

Answer 3

Przede wszystkim powinieneś użyć back_inserter jako trzeciego argumentu dla transform, aby przekształcone wartości zostały przesunięte do tyłu wektora.

Po drugie, potrzebujesz jakiegoś funktora, który bierze parę int i zwraca pierwszy. Należy to zrobić:

int firstElement(const std::pair<int, int> &p) { 
    return p.first; 
} 

Teraz, aby umieścić kawałki razem:

TPairs pairs; 
pairs.push_back(std::make_pair(1, 3)); 
pairs.push_back(std::make_pair(5, 7)); 

TItems items; 
std::transform(pairs.begin(), pairs.end(), std::back_inserter(items), 
       firstElement); 

Po tym kodzie items zawiera 1 do 5.

Answer 4

Jak na temat korzystania std::bind?

std::transform(pairs.begin(), 
       pairs.end(), 
       std::back_inserter(items), 
       std::bind(&TPairs::value_type::first, std::placeholders::_1)); 

(Wymień std::bind przez boost::bind dla non-kodu C++ 11)

Answer 5

zobaczyć Frerich lub odpowiedź Kotliński dla C++ 03.

C++ 11 Rozwiązanie z lambda:

std::transform(pairs.begin(), 
       pairs.end(), 
       std::back_inserter(items), 
       [](const std::pair<int, int>& p) { return p.first; });