Risposte:
Utilizzando C ++ 11:
#include <map>
using namespace std;
map<int, char> m = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
Utilizzando Boost.Assign :
#include <map>
#include "boost/assign.hpp"
using namespace std;
using namespace boost::assign;
map<int, char> m = map_list_of (1, 'a') (3, 'b') (5, 'c') (7, 'd');
Il modo migliore è usare una funzione:
#include <map>
using namespace std;
map<int,int> create_map()
{
map<int,int> m;
m[1] = 2;
m[3] = 4;
m[5] = 6;
return m;
}
map<int,int> m = create_map();
extern
le variabili non avranno i loro valori corretti in questo "prima del costruttore principale di runtime" se il compilatore ha visto solo la extern
dichiarazione, ma non ha ancora incontrato la definizione della variabile effettiva .
const map<int,int> m = create_map()
(e quindi, inizializzare i membri const di una classe nell'elenco di inizializzazione:struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map())
Non è un problema complicato creare qualcosa di simile per aumentare. Ecco una classe con solo tre funzioni, incluso il costruttore, per replicare ciò che il boost ha fatto (quasi).
template <typename T, typename U>
class create_map
{
private:
std::map<T, U> m_map;
public:
create_map(const T& key, const U& val)
{
m_map[key] = val;
}
create_map<T, U>& operator()(const T& key, const U& val)
{
m_map[key] = val;
return *this;
}
operator std::map<T, U>()
{
return m_map;
}
};
Uso:
std :: map mymap = create_map <int, int> (1,2) (3,4) (5,6);
Il codice sopra funziona in modo ottimale per l'inizializzazione di variabili globali o membri statici di una classe che deve essere inizializzata e non hai idea di quando viene utilizzata per prima, ma vuoi assicurarti che i valori siano disponibili in essa.
Se dico, devi inserire elementi in una std :: map esistente ... ecco un'altra classe per te.
template <typename MapType>
class map_add_values {
private:
MapType mMap;
public:
typedef typename MapType::key_type KeyType;
typedef typename MapType::mapped_type MappedType;
map_add_values(const KeyType& key, const MappedType& val)
{
mMap[key] = val;
}
map_add_values& operator()(const KeyType& key, const MappedType& val) {
mMap[key] = val;
return *this;
}
void to (MapType& map) {
map.insert(mMap.begin(), mMap.end());
}
};
Uso:
typedef std::map<int, int> Int2IntMap;
Int2IntMap testMap;
map_add_values<Int2IntMap>(1,2)(3,4)(5,6).to(testMap);
Guardalo in azione con GCC 4.7.2 qui: http://ideone.com/3uYJiH
############### TUTTO QUESTO È OSSOLETO #################
EDIT : la map_add_values
classe seguente, che era la soluzione originale che avevo suggerito, avrebbe fallito quando si tratta di GCC 4.5+. Si prega di guardare il codice sopra per come aggiungere valori alla mappa esistente.
template<typename T, typename U>
class map_add_values
{
private:
std::map<T,U>& m_map;
public:
map_add_values(std::map<T, U>& _map):m_map(_map){}
map_add_values& operator()(const T& _key, const U& _val)
{
m_map[key] = val;
return *this;
}
};
Uso:
std :: map <int, int> my_map; // Più avanti da qualche parte lungo il codice map_add_values <int, int> (my_map) (1,2) (3,4) (5,6);
NOTA: in precedenza ho usato a operator []
per aggiungere i valori effettivi. Questo non è possibile come commentato da dalle.
##################### FINE DELLA SEZIONE OBSOLETA #############################
operator[]
accetta solo un singolo argomento.
error: conflicting declaration ‘map_add_values<int, int> my_map’
error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’
Ecco un altro modo che utilizza il costruttore di dati a 2 elementi. Non sono necessarie funzioni per inizializzarlo. Non esiste un codice di terze parti (Boost), nessuna funzione o oggetto statico, nessun trucco, solo un semplice C ++:
#include <map>
#include <string>
typedef std::map<std::string, int> MyMap;
const MyMap::value_type rawData[] = {
MyMap::value_type("hello", 42),
MyMap::value_type("world", 88),
};
const int numElems = sizeof rawData / sizeof rawData[0];
MyMap myMap(rawData, rawData + numElems);
Da quando ho scritto questa risposta C ++ 11 è uscito. Ora puoi inizializzare direttamente i contenitori STL usando la nuova funzionalità dell'elenco di inizializzatori:
const MyMap myMap = { {"hello", 42}, {"world", 88} };
Per esempio:
const std::map<LogLevel, const char*> g_log_levels_dsc =
{
{ LogLevel::Disabled, "[---]" },
{ LogLevel::Info, "[inf]" },
{ LogLevel::Warning, "[wrn]" },
{ LogLevel::Error, "[err]" },
{ LogLevel::Debug, "[dbg]" }
};
Se map è un membro di dati di una classe, è possibile inizializzarlo direttamente nell'intestazione nel modo seguente (dal C ++ 17):
// Example
template<>
class StringConverter<CacheMode> final
{
public:
static auto convert(CacheMode mode) -> const std::string&
{
// validate...
return s_modes.at(mode);
}
private:
static inline const std::map<CacheMode, std::string> s_modes =
{
{ CacheMode::All, "All" },
{ CacheMode::Selective, "Selective" },
{ CacheMode::None, "None" }
// etc
};
};
Vorrei avvolgere la mappa all'interno di un oggetto statico e inserire il codice di inizializzazione della mappa nel costruttore di questo oggetto, in questo modo si è sicuri che la mappa venga creata prima dell'esecuzione del codice di inizializzazione.
Volevo solo condividere un puro C ++ 98 in giro:
#include <map>
std::map<std::string, std::string> aka;
struct akaInit
{
akaInit()
{
aka[ "George" ] = "John";
aka[ "Joe" ] = "Al";
aka[ "Phil" ] = "Sue";
aka[ "Smitty" ] = "Yando";
}
} AkaInit;
Puoi provare:
std::map <int, int> mymap =
{
std::pair <int, int> (1, 1),
std::pair <int, int> (2, 2),
std::pair <int, int> (2, 2)
};
{1, 2}
anziché std::pair<int, int>(1, 2)
.
Questo è simile a PierreBdR
, senza copiare la mappa.
#include <map>
using namespace std;
bool create_map(map<int,int> &m)
{
m[1] = 2;
m[3] = 4;
m[5] = 6;
return true;
}
static map<int,int> m;
static bool _dummy = create_map (m);
Se sei bloccato con C ++ 98 e non vuoi usare boost, ecco la soluzione che uso quando devo inizializzare una mappa statica:
typedef std::pair< int, char > elemPair_t;
elemPair_t elemPairs[] =
{
elemPair_t( 1, 'a'),
elemPair_t( 3, 'b' ),
elemPair_t( 5, 'c' ),
elemPair_t( 7, 'd' )
};
const std::map< int, char > myMap( &elemPairs[ 0 ], &elemPairs[ sizeof( elemPairs ) / sizeof( elemPairs[ 0 ] ) ] );
Hai delle ottime risposte qui, ma io sono per me, sembra un caso di "quando tutto ciò che sai è un martello" ...
La risposta più semplice al perché non esiste un modo standard per inizializzare una mappa statica, non c'è una buona ragione per usare mai una mappa statica ...
Una mappa è una struttura progettata per la ricerca rapida, di un insieme sconosciuto di elementi. Se conosci prima gli elementi, usa semplicemente un C-array. Immettere i valori in modo ordinato o eseguirne l'ordinamento, se non è possibile farlo. È quindi possibile ottenere le prestazioni del registro (n) utilizzando le funzioni stl :: per eseguire il looping delle voci, lower_bound / upper_bound. Quando l'ho testato in precedenza, normalmente funzionano almeno 4 volte più velocemente di una mappa.
I vantaggi sono molti ... - prestazioni più veloci (* 4, ho misurato su molti tipi di CPU, è sempre circa 4) - debug più semplice. È più semplice vedere cosa sta succedendo con un layout lineare. - Implementazioni concrete delle operazioni di copia, qualora ciò fosse necessario. - Non alloca memoria in fase di esecuzione, quindi non genererà mai un'eccezione. - È un'interfaccia standard, quindi è molto facile da condividere su, DLL o lingue, ecc.
Potrei continuare, ma se vuoi di più, perché non guardare i molti blog di Stroustrup sull'argomento.
map
è anche una forma utile per rappresentare una funzione parziale (funzione in senso matematico; ma anche, in un certo senso, in senso programmatico). Un array non lo fa. Ad esempio, non è possibile cercare dati da un array usando una stringa.