eine Karte erstellen, aus zwei Vektoren

Wenn ich zwei stl-Vektoren vect1, vect2 und ich produzieren möchten von Ihnen eine Karte, so erste element aus vect1, entsprechen einem ersten element in vect2 und so weiter.
Wie kann ich tun, dass in den meisten einfachen Weg?

Was wollen Sie passieren, wenn Sie verschiedene Größen haben?

InformationsquelleAutor lital maatuk | 2011-02-09

c++map stl vector

9
```
std::vector<int> a, b;
//fill vectors here...
std::map<int, int> m;
assert(a.size() == b.size());
for (size_t i = 0; i < a.size(); ++i)
    m[a[i]] = b[i];
```
- Das funktioniert auch, aber ich würde ersetzen, die assert mit einer Ausnahme oder sowas. Niemand mag einen library-call durch, der hält Ihr Programm!
- Was passiert, wenn a Duplikate enthält ? Sie möchten if (m.find(a[i]) != m.end()) m.insert(a[i]) else throw ....
- C. insert zurück-pair-Mädchen mit einem iterator zu dem element und einem booleschen Wert, der angibt, ob es eingefügt wurde, oder es schon vorhanden war. Es gibt keine Notwendigkeit zu tun, die Vorherige Suche.
- Ich sollte die Dokumentation Lesen, manchmal! Vielen Dank für diese. Also mein Kommentar sollte gelesen werden if (!m.insert(std::make_pair(a[i], b[i])).second) throw ...
- geltend machen ist in der Regel ignoriert in release-builds
- das ist ein zusätzlicher Grund es nicht zu benutzen, soweit ich betroffen bin. Jemand im Zusammenhang mit geltend machen, um "das tragen einer Sicherheitsweste während der Kanu nahe dem Ufer und entfernen Sie es vor dem ausgehen in die Mitte des Sees".
- Wenn es einen doppelten Schlüssel, diese version wird überschrieben, so dass es einen Wert haben wird, der Letzte Auftritt.
InformationsquelleAutor Ferruccio
7

Hier ist eine Lösung unter Verwendung von standard-Bibliotheks-Funktionen (und C++0x-Lambda-Ausdrücke).
```
const int data1[] = { 0, 2, 4, 6, 8 };
const int data2[] = { 1, 3, 5, 7, 9 };
std::vector<int> vec1(data1, data1 + 5);
std::vector<int> vec2(data2, data2 + 5);
std::map<int,int> map;

//create map
std::transform(vec1.begin(), vec1.end(), vec2.begin(), std::inserter(map, map.end()), [](int a, int b)
{
    return std::make_pair(a, b);
});

//display map
std::for_each(map.begin(), map.end(), [](const std::pair<int,int>& p)
{
    std::cout << p.first << "," << p.second << "\n";
});
```
Hinweis: Dies setzt Voraus, vec1.size() ist nicht größer als vec2.size().
- Sie brauchen nicht die Lambda-Ausdrücke, die folgende funktioniert genauso gut in C++03 std::transform(vec1.begin(), vec1.end(), vec2.begin(), std::inserter(my_map, my_map.end()), std::make_pair<int, std::string>);
- Vielleicht ist es nur mich, aber MSVC++ nicht akzeptieren std::make_pair als ein binäres Funktionsobjekt.
- haben Sie versucht, std::make_pair<int, int> ? make_pair ohne seine Vorlage Argumente würden nicht aufgelöst werden.
- Ja, aber es würde immer noch nicht kompilieren. Ich habe auch versucht, wickeln Sie es mit std::bind mit dem gleichen Ergebnis. Lambdas wieder zu gewinnen.
InformationsquelleAutor Blastfurnace
5

Verwenden wir die version von std::transform, dass dauert 2 input-Sequenzen. (Nicht so bekannt ist, erscheint es als die eine, eine einzige Sequenz).

Können Sie in std::make_pair<v1::value_type, v2::value_type> als Ihr Transformator (op), also in deinem Fall
```
std::vector<int> vec1, vec2;
std::map< int, int > mergedMap;
std::transform( vec1.begin(), vec1.end(), vec2.begin(), 
       std::inserter(mergedMap, mergedMap.end() ), std::make_pair<int const&,int const&> );
```
Habe ich getestet, der code und kompiliert er fein mit GNU-4.3.2

(Habe ich auch getestet, jetzt mit C++11. Es funktioniert, wenn ich geändert make_pair zu nehmen, int const& statt int).

Wenn die beiden Eingabesequenzen unterschiedlich lang, es wird in Ordnung sein, wenn die erste ist kürzer, und spätere Elemente in der zweiten Sequenz wird ignoriert. Wenn der erste länger ist, erzeugt Undefiniertes Verhalten.
- Die standard-Bibliothek bereits eine std::transform Algorithmus, der zwei Sequenzen und eine binäre Funktion Objekt.
- ähm, nicht das Letzte mal, ich sah. std::transform nimmt eine Sequenz und ein output-iterator verwendet wird (wobei das transformierte Ergebnis wird so geschrieben)...
- Es ist dokumentiert auf der MSDN-Website und sgi.com/tech/stl/transform.html. Es gibt zwei Formen der std::transform Algorithmus.
- shikes ich verpasst,!! Thx für den Hinweis!!
- Ich stellte eine Antwort mit std::transform. Auch ich betrogen und benutzt einen C++0x-lambda-Ausdruck, weil es macht die ganze Sache so einfach.
- hehe, es muss nur mir dann, dass der denkt, dass die lambda-version sieht schrecklich... 😉
- Ich mag in der Lage zu definieren, die den code für ein one-off-funktors in den Ort, wo es verwendet wird. Ein lambda-Ausdruck kann auch verstaut werden in einer auto variable, wenn ich übergeben Sie es herum, oder rufen Sie es in mehreren Orten. Sie sind wirklich ordentlich, sobald Sie an Sie gewöhnen.
- Ich sah Sie in der Dokumentation und in der Tat sehen, std::transform mit 2 Eingänge, das heißt, entfernen Sie einfach mir und legte es an seinen Platz. Funktioniert es mit make_pair?
- Ok, getestet, mein code und es funktioniert gut. Also möglich, in einer Anweisung zusammen mit der standard-Bibliothek.
- Dieser Code wird nicht kompiliert mit -std=c++11-option. Ich habe den gleichen Fehler mit g++, clang++ und icpc: /usr/include/c++/4.8.1/bits/stl_algo.h:4988:46: error: cannot bind ‘int’ lvalue to ‘int&&’ Die lambda funktioniert gut und ist wahrscheinlich der Weg zu gehen, wenn es um die c++11.
- Übrigens, wenn Sie diese in eine Vorlage brauchen Sie ein typename vor v1::value_type und v2::value_type.
- Wenn es einen doppelten Schlüssel, hier die erste zählt, und der Wert wird je nachdem, was zuerst kam. Für C++11-Transformation nimmt eine lambda-so verwenden Sie es. Ich bin jedoch überrascht, dass diese nicht kompilieren. Welches bit fehlerhaft ist?
- Dass C++11 brach funktionierenden code ist etwas, was ich brauche, um zu Fragen hier... ich werde prüfen, es war nicht gebrochen vor.
- Übrigens, wenn die Sequenzen unterschiedlich lang sind hier zu verwenden, wird die Länge der ersten Sequenz und UB, wenn der erste länger als die zweite.
InformationsquelleAutor CashCow

Hier ist eine leichte Variante, die verwendet boost ist zip_iterator

#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <vector>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple/tuple.hpp>

//this is our map type
typedef std::map<int, std::string> map_t;

//this functor will be called for each "pair"
struct map_adder :
  public std::unary_function<const boost::tuple<const int&, const std::string&>&, void>
{
  map_adder(map_t& my_map) : _my_map(my_map){}

  void operator()(const boost::tuple<const int&, const std::string&>& t) const
  {
    _my_map.insert(std::make_pair(t.get<0>(), t.get<1>()));
  }

private:
  mutable map_t& _my_map;
};

int main(void)
{
  //test setup
  std::vector<int> keys;
  std::vector<std::string> values;
  keys.push_back(1);
  keys.push_back(2);
  keys.push_back(3);
  keys.push_back(4);

  values.push_back("1");
  values.push_back("2");
  values.push_back("3");
  values.push_back("4");

  std::vector<int>::const_iterator beg1 = keys.begin();
  std::vector<int>::const_iterator end1 = keys.end();
  std::vector<std::string>::const_iterator beg2 = values.begin();
  std::vector<std::string>::const_iterator end2 = values.end();

  //destination
  map_t my_map;

  //functor to actually add
  map_adder adder(my_map);

  //simply iterate over...
  std::for_each(
    boost::make_zip_iterator(
      boost::make_tuple(beg1, beg2)
      ),
    boost::make_zip_iterator(
      boost::make_tuple(end1, end2)
      ),
    adder
  );

  std::cout << "size of map: " << my_map.size() << std::endl;

  return 0;
}

okay, hier ist ein einfacher version mit std::transform ich bin mir nicht bewusst, etwas, das bereits vorhanden ist, die die konvertieren kann eine boost::tuple zu einem std::pair daher meine einfache Funktion...

#include <iostream>
#include <algorithm>
#include <string>
#include <iterator>
#include <map>
#include <vector>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple/tuple.hpp>

//this is our map type
typedef std::map<int, std::string> map_t;

map_t::value_type adapt_tuple(const boost::tuple<const map_t::key_type&, const map_t::mapped_type&>& t)
{
  return map_t::value_type(t.get<0>(), t.get<1>());
}

int main(void)
{
  std::vector<int> keys;
  std::vector<std::string> values;
  keys.push_back(1);
  keys.push_back(2);
  keys.push_back(3);
  keys.push_back(4);

  values.push_back("1");
  values.push_back("2");
  values.push_back("3");
  values.push_back("4");

  std::vector<int>::const_iterator beg1 = keys.begin();
  std::vector<int>::const_iterator end1 = keys.end();
  std::vector<std::string>::const_iterator beg2 = values.begin();
  std::vector<std::string>::const_iterator end2 = values.end();

  map_t my_map;

  //simply iterate over...
  std::transform(
    boost::make_zip_iterator(
      boost::make_tuple(beg1, beg2)
      ),
    boost::make_zip_iterator(
      boost::make_tuple(end1, end2)
      ),
    std::inserter(my_map, my_map.end()),
    adapt_tuple
    );

  std::cout << "size of map: " << my_map.size() << std::endl;

  return 0;
}

Ersetzen wir for_each mit verwandeln, was würde Ihnen eine Lösung ähnlich wie mir?
hier gehen Sie, die std::transform version, die einzige Sache, die ich bin mir nicht bewusst, ist etwas, das kann bereits die Anpassung an die boost::tuple zu einem std::pair, aber wo ist der Spaß konform?? 😉

InformationsquelleAutor Nim

vorausgesetzt, Sie gehen zu ignorieren, die extra (Größe vect1 != Größe vect2), könnte dies eine Lösung sein:

map<T1, T2> target; //vector<T1> vect1, vector<T2> vect2;
vector<T1>::iterator it1 = vect1.begin();
vector<T2>::iterator it2 = vect2.begin();
while(it1 != vect1.end() && it2 != vect2.end())
{
target.insert(std::make_pair(*it1, *it2));
it1++;it2++;
}