Möglich std :: map als rvalue zu erstellen?

Question

Ich bin mir nicht sicher, ob dies ein Fehler mit meiner C++ - Syntax ist, oder ob dies überhaupt nicht möglich ist.

Ich möchte eine Klasse definieren, die eine Std :: Map als Konstruktorargument verwendet. Ich möchte dann eine Instanz dieser Klasse erstellen, indem ich ein "temporäres" (passenderweise diesen "rvalue" nennen?) Std :: map übergeben. I.e. Ich möchte nicht einen lvalue std :: map erstellen und dann das an den Konstruktor übergeben.

Kann dies erreicht werden? Ich habe folgendes versucht (kommentierten Zeilen Versuch nicht nachgewiesen)

#include <map> 
#include <string> 
#include <iostream> 

class Test 
{ 
    public: 
     Test(std::map<int,char>& rMap) 
     { 
      std::map<int,char>::iterator iter; 

      for (iter = rMap.begin(); iter != rMap.end(); ++iter) 
      { 
       mMap[iter->first] = mMap[iter->second]; 
      } 
     } 
     virtual ~Test(){} 

    protected: 
     std::map<int, char> mMap; 
}; 

int main() 
{ 
    std::cout << "Hello world!" << std::endl; 

    //Test test({1,'a'});     // Compile error. 
    //Test test(std::map<int,char>(1,'a')); // Also compile error. 
    //Test test(std::map<int,char>{1,'a'}); // Yet again compile error. 

    return 0; 
} 

Das ist mein Compiler:

g++ (GCC) 4.4.7 20120313 (Red Hat 4.4.7-11) 

Kompilieren Fehler auf Anfrage gebucht werden können, aber ich bin nicht sicher, ob sie nützlich wäre, wenn mein Problem syntaktisch ist.

Vielen Dank.

Answer 1

#include <map> 

class Test { 
public: 
    Test(std::map<int,char> const& cMap) 
    { 
     std::map<int,char>::const_iterator iter; 
     for (iter = cMap.cbegin(); iter != cMap.cend(); ++iter) 
     { 
      mMap[iter->first] = mMap[iter->second]; 
     } 
    } 
    virtual ~Test() { } 
protected: 
    std::map<int, char> mMap; 
}; 

int main() { 
    Test test(std::map<int,char>({{1,'a'}, {2, 'b'}})); 
    return 0; 
} 

Einige Erklärungen:

1. Sie benötigen Test(T), Test(const T&) oder Test(T&&) Konstruktor, wenn Sie temporäre Objekt (wie std::map<int,char>()) hinein übergeben möchten . Vergessen Sie nicht, wofür T&& Konstruktoren verwendet werden. Im Zweifelsfall benutze sie nicht.

2. Wenn Sie mit const std::vector/map/list/... arbeiten, können Sie .begin() und .end() nicht verwenden, um Elemente durchlaufen - verwenden. c beginnen() und. c Ende(). Darüber hinaus wird es einfacher mit auto.Versuchen Sie einfach,

   for (auto iter = rMap.cbegin(); iter != rMap.cend(); ++iter) 
   

   statt

   std::map<int,char>::const_iterator iter; 
   for (iter = rMap.cbegin(); iter != rMap.cend(); ++iter) 
   

3. Um std::map Gebrauch "Doppel-Klammer" initializers wie {{1,'a'}, {2, 'b'}} zu initialisieren - {{key, value}, {second_key, second_value}, ...} diese Konstruktion verfügbar ist, weil

   1) std::map diesen Konstruktor hat:

   map(std::initializer_list<value_type> init, 
       const Compare& comp = Compare(), 
       const Allocator& alloc = Allocator()); 
   // see http://en.cppreference.com/w/cpp/container/map/map 
   

   2) innere Klammern {1,'a'} wird als value_type Konstruktoraufruf interpretiert. Und value_type für std::map<int, char> ist std::pair<int, char>.

P. S. vergessen Sie nicht, dass std::map<int,char>() und std::map<int,char>{} Konstruktoraufrufe gleich sind. Das heißt, Sie vorderen Halterungen fallen können: std::map<int,char>({{1,'a'},{2,'b'}}) --> std::map<int,char>{{1,'a'},{2,'b'}}

Answer 2

Ja, aber Ihr Konstruktor verwendet eine lvalue-Referenz. Es muss stattdessen eine Referenz zu const oder eine R-Referenz sein.

Genau wie bei jedem anderen Typ.

Answer 3

Test(std::map<int, char> rMap) : mMap(std::move(rMap)) {} 

oder

Sie

Test(std::map<int, char>&& rMap) : mMap(std::move(rMap)) {} 

oder

Test(const std::map<int, char>& rMap) : mMap(rMap) {} 

vorübergehend nicht const l-Referenzwert nicht binden kann.

Und verwenden Sie es als

Test test({{1,'a'}}); 
Test test2({{1,'a'}, {2, 'b'}}); 

Answer 4

Sie verwenden sollten:

class Test 
{ 
public: 
    Test(const std::map<int,char>& rMap) : mMap(rMap) 
    {} 
    Test(std::map<int,char>&& rMap) : mMap(std::move(rMap)) 
    {} 
    virtual ~Test(){} 
protected: 
    std::map<int, char> mMap; 
}; 

Dies bietet zwei Konstruktoren: eine, die nimmt einen const lvalue Bezug und kopiert den Inhalt in mMap und eine, die einen R-Wert Bezug nimmt und verschiebt seinen Inhalt in mMap. Auf diese Weise können Sie eine Test Instanz konstruieren, indem entweder eine benannte std::map oder eine vorübergehende:

int main() 
{ 
    std::map<int,char> m{{1, 'a'}, {2,'b'}}; 
    Test t1{m}; 
    Test t2{{{1, 'a'}, {2, 'b'}}}; 
} 

Auf diese Weise können Sie unnötige Kopien zu vermeiden, wenn Sie können, aber noch können Sie eine Kopie des map machen, wenn Sie benötigen.