Inizializzazione di uno std :: map <int, int> in C ++ statico


447

Qual è il modo giusto di inizializzare una mappa statica? Abbiamo bisogno di una funzione statica che la inizializzerà?

Risposte:


619

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');

115
Ogni volta che vedo qualcosa di simile fatto con C ++, penso a tutto il codice modello orrendo che deve esserci dietro. Buon esempio!
Greg Hewgill,

34
La bellezza di tutto l'orrendo codice modello che implementa queste utilità è che è incapsulato in modo ordinato in una libreria e l'utente finale raramente ha bisogno di gestire la complessità.
Steve Guidi,

45
@QBziZ: Se la tua azienda rifiuta l'utilizzo di Boost per il fatto che non è "abbastanza standard", mi chiedo quale libreria C ++ sarebbe "abbastanza standard". Boost è il compagno standard per il codificatore C ++.
DevSolar,

47
Il mio problema con Boost (qui e altrove) è che spesso puoi andare avanti senza di essa (in questo caso con C ++ 11 o prima di C ++ 11 con una funzione ). Boost aggiunge un notevole sovraccarico di tempo di compilazione, aveva tonnellate di file da parcheggiare nel tuo repository (e da copiare / zip / extract se stai facendo un archivio). Questo è il motivo per cui provo a non usarlo. So che puoi scegliere quali file includere / non includere, ma di solito non devi preoccuparti delle dipendenze incrociate di Boost con se stesso, quindi ti basta copiare tutto.
bobobobo,

7
Il mio problema con Boost è che spesso ha diverse nuove dipendenze di libreria, il che significa generalmente PIÙ pacchetti che devono essere installati per funzionare correttamente. Abbiamo già bisogno di libstdc ++. Ad esempio, la libreria Boost ASIO richiede almeno 2 nuove librerie (probabilmente più) che devono essere installate. C ++ 11/14 rende molto più semplice non aver bisogno di Boost.
Rahly,

135

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();

18
Perché questo è il "migliore"? Perché ad esempio è meglio della risposta di @ Dreamer?
Marchese di Lorne,

6
Penso che sia "il migliore" perché è davvero semplice e non dipende da altre strutture esistenti (come Boost :: Assign o una sua reimplementazione). E rispetto alla risposta di @ Dreamer, beh, evito di creare un'intera struttura solo per inizializzare una mappa ...
PierreBdR,

3
Nota che qui c'è un pericolo . externle variabili non avranno i loro valori corretti in questo "prima del costruttore principale di runtime" se il compilatore ha visto solo la externdichiarazione, ma non ha ancora incontrato la definizione della variabile effettiva .
bobobobo,

5
No, il pericolo è che non vi sia nulla da dire in quale ordine debbano essere inizializzate le variabili statiche (almeno tra le unità di compilazione). Ma questo non è un problema legato a questa domanda. Questo è un problema generale con variabili statiche.
PierreBdR,

5
nessuna spinta E nessun C ++ 11 => +1. Si noti che la funzione può essere utilizzata per inizializzare un 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())
ribamar

115

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_valuesclasse 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 #############################


3
Sto usando il tuo primo campione come <int, string> per associare i numeri di errore (da un enum) ai messaggi - funziona come un incantesimo - grazie.
slashmais,

1
operator[]accetta solo un singolo argomento.
dalle

1
@dalle: buona cattura! Per qualche ragione ho pensato che operatori sovraccarichi [] avrebbero potuto accettarne di più.
Vite Falcon,

2
Questa è una risposta fantastica È un peccato che l'OP non ne abbia mai selezionato uno. Ti meriti mega oggetti di scena.
Thomas Thorogood,

map_add_values ​​non funziona in gcc, il che si lamenta: error: conflicting declaration ‘map_add_values<int, int> my_map’ error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’
Martin Wang

42

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} };

25

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
        };
}; 

24

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.


1
Sono con te su questo. È anche un po 'più veloce :)
QBziZ il

2
Un po 'più veloce di cosa? Una statica globale con un inizializzatore? No, non lo è (ricorda di RVO).
Pavel Minaev,

7
Bella risposta. Sarei felice se vedessi il vero codice di esempio
Sungguk Lim,

18

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;

2
questo non funziona per oggetti senza costruttore predefinito, metodo di inserimento dovrebbe essere preferito IMHO
Alessandro Teruzzi

16

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
Non è possibile utilizzare elenchi di inizializzatori con tipi non aggregati prima di C ++ 11, nel qual caso è possibile utilizzare la sintassi più breve {1, 2}anziché std::pair<int, int>(1, 2).
Ferruccio,

9

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);

12
Probabilmente non sarebbe stato copiato comunque.
GManNickG,

2
ma in questo modo la mappa non potrebbe essere const statica, vero?
xmoex,

6

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 ] ) ] );

-4

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.


8
Le prestazioni non sono l'unico motivo per l'utilizzo di una mappa. Ad esempio, ci sono molti casi in cui si desidera collegare i valori insieme (ad esempio un codice di errore con un messaggio di errore) e una mappa rende l'utilizzo e l'accesso relativamente semplici. Ma un link a questi post di blog può essere interessante, forse sto facendo qualcosa di sbagliato.
MatthiasB,

5
Un array è molto più semplice e offre prestazioni più elevate se è possibile utilizzarlo. Ma se gli indici (chiavi) non sono contigui e ampiamente distanziati, è necessaria una mappa.
KarlU,

1
A 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.
einpoklum,

3
La tua risposta non tenta di rispondere alla domanda valida, e invece specula sui limiti della lingua, propone soluzioni a diversi problemi, quindi downvote. Uno scenario reale: mappatura (continua o no) dei codici di errore della libreria su stringhe di testo. Con l'array, il tempo di ricerca è O (n), che può essere migliorato mappando staticamente su O (log (n)).
Tosha,

2
Se davvero "non c'è alcuna buona ragione per usare mai una mappa statica ..." allora è molto strano che la sintassi (elenchi di inizializzatori) che li rende facili da usare sia stata aggiunta in C ++ 11.
Ellisbben,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.