Initialisierung std :: shared_ptr <std::map<>> mit verspannten-init

Question

Ich habe folgend shared_ptr zu einem map:

std::shared_ptr<std::map<double, std::string>> 

und ich würde es initialisieren wie verspannt-init. Ist es möglich?

Ich habe versucht:

std::string s1("temp"); 
std::shared_ptr<std::map<double, std::string>> foo = std::make_shared<std::map<double, std::string>>(1000.0, s1); 

aber das gibt den folgenden Fehler, wenn 6.3 unter Verwendung von Xcode kompiliert:

/usr/include/c++/v1/map:853:14: Candidate constructor not viable: no known conversion from 'double' to 'const key_compare' (aka 'const std::__1::less<double>') for 1st argument 

ich andere Variationen des ersten Parameters versucht haben (1000.0) ohne Erfolg .

Kann jemand helfen?

Answer 1

std::map eine Initialisierer-Liste Konstruktor hat:

map (initializer_list<value_type> il, 
    const key_compare& comp = key_compare(), 
    const allocator_type& alloc = allocator_type()); 

Wir diesen Konstruktor erstellen können ganz einfach eine Karte mit:

std::map<double,std::string> m1{{1000.0, s1}}; 

Um es in make_shared zu verwenden, müssen wir die Instanziierung angeben von initializer_list wir bieten:

auto foo = std::make_shared<std::map<double,std::string>> 
      (std::initializer_list<std::map<double,std::string>::value_type>{{1000.0, s1}}); 

---

Das sieht wirklich tollpatschig aus; aber wenn Sie dies regelmäßig benötigen, können Sie es aufzuräumen mit Aliasnamen:

#include <string> 
#include <map> 
#include <memory> 

std::string s1{"temp"}; 

using map_ds = std::map<double,std::string>; 
using il_ds = std::initializer_list<map_ds::value_type>; 

auto foo = std::make_shared<map_ds>(il_ds{{1000.0, s1}}); 

---

Sie könnten stattdessen lieber eine Template-Funktion definieren, um den Anruf zu wickeln:

#include <string> 
#include <map> 
#include <memory> 

template<class Key, class T> 
std::shared_ptr<std::map<Key,T>> 
make_shared_map(std::initializer_list<typename std::map<Key,T>::value_type> il) 
{ 
    return std::make_shared<std::map<Key,T>>(il); 
} 

std::string s1{"temp"}; 
auto foo = make_shared_map<double,std::string>({{1000, s1}}); 

Answer 2

Someting ähnlich wie diese es tun sollten ...

std::string s1("temp"); 

std::map<double, std::string> *m = new std::map<double, std::string>{{100., s1}}; 

auto foo = std::shared_ptr<std::map<double, std::string>>(m); 

oder als oneliner

auto foo2 = std::shared_ptr<std::map<double, std::string>>(new std::map<double, std::string>{{100., s1}}); 

(Sorry, zunächst die Forderung nach Initialisiererliste verpasst)

Answer 3

Ändern Sie den Schlüssel des Art.

double ist ein falscher Typ für Schlüssel, da es kein operator== für es gibt und verschiedene Bytefolgen den gleichen Gleitkommawert darstellen können.

Answer 4

Ihr Problem besteht darin, dass Sie in Ihrem Initialisierer keine geschweiften Klammern eingefügt haben. Ich brauchte die folgende, um es zu arbeiten: me

auto foo = std::make_shared<std::map<double, std::string> >(
         std::map<double, std::string>({{1000.0, s1}}) 
      ); 

Die Doppel std::map<double, std::string> Bugs. Es sollte wirklich in der Lage sein, einen von ihnen mit dem anderen auszuarbeiten ... aber gcc 5.3.0 würde keinen Ball spielen.

Sie werden auf jeden Fall die Doppelstreben brauchen. (Einmal sagen Sie, dass Sie eine Karte initialisieren, einmal um jeden Eintrag zu begrenzen.)

Answer 5

Sie es tun können ohne std::make_shared:

std::shared_ptr<std::map<double,std::string>> ptr(new std::map<double,std::string>({{1000.0, "string"}}));