Bagaimana cara menginisialisasi peta const statis pribadi di C ++?

Saya hanya perlu kamus atau array asosiatif string=> int.

Ada tipe peta C ++ untuk kasus ini.

Tetapi saya hanya membutuhkan satu peta untuk semua contoh (-> statis) dan peta ini tidak dapat diubah (-> const);

Saya telah menemukan cara ini dengan perpustakaan boost

 std::map<int, char> example = 
      boost::assign::map_list_of(1, 'a') (2, 'b') (3, 'c');

Apakah ada solusi lain tanpa lib ini? Saya telah mencoba sesuatu seperti ini, tetapi selalu ada beberapa masalah dengan inisialisasi peta.

class myClass{
private:
    static map<int,int> create_map()
        {
          map<int,int> m;
          m[1] = 2;
          m[3] = 4;
          m[5] = 6;
          return m;
        }
    static map<int,int> myMap =  create_map();

};

#include <map>
using namespace std;

struct A{
    static map<int,int> create_map()
        {
          map<int,int> m;
          m[1] = 2;
          m[3] = 4;
          m[5] = 6;
          return m;
        }
    static const map<int,int> myMap;

};

const map<int,int> A:: myMap =  A::create_map();

int main() {
}

Standar C ++ 11 memperkenalkan inisialisasi seragam yang membuatnya lebih sederhana jika kompiler Anda mendukungnya:

//myClass.hpp
class myClass {
  private:
    static map<int,int> myMap;
};

//myClass.cpp
map<int,int> myClass::myMap = {
   {1, 2},
   {3, 4},
   {5, 6}
};

Lihat juga bagian ini dari Professional C ++ , di unordered_maps.

Saya melakukannya! :)

Bekerja dengan baik tanpa C ++ 11

class MyClass {
    typedef std::map<std::string, int> MyMap;

    struct T {
        const char* Name;
        int Num;

        operator MyMap::value_type() const {
            return std::pair<std::string, int>(Name, Num);
        }
    };

    static const T MapPairs[];
    static const MyMap TheMap;
};

const MyClass::T MyClass::MapPairs[] = {
    { "Jan", 1 }, { "Feb", 2 }, { "Mar", 3 }
};

const MyClass::MyMap MyClass::TheMap(MapPairs, MapPairs + 3);

Jika Anda merasa boost::assign::map_list_ofberguna, tetapi tidak dapat menggunakannya karena alasan tertentu, Anda dapat menulis sendiri :

template<class K, class V>
struct map_list_of_type {
  typedef std::map<K, V> Map;
  Map data;
  map_list_of_type(K k, V v) { data[k] = v; }
  map_list_of_type& operator()(K k, V v) { data[k] = v; return *this; }
  operator Map const&() const { return data; }
};
template<class K, class V>
map_list_of_type<K, V> my_map_list_of(K k, V v) {
  return map_list_of_type<K, V>(k, v);
}

int main() {
  std::map<int, char> example = 
    my_map_list_of(1, 'a') (2, 'b') (3, 'c');
  cout << example << '\n';
}

Sangat berguna untuk mengetahui bagaimana hal-hal seperti itu bekerja, terutama ketika mereka sangat pendek, tetapi dalam kasus ini saya akan menggunakan sebuah fungsi:

a.hpp

struct A {
  static map<int, int> const m;
};

a.cpp

namespace {
map<int,int> create_map() {
  map<int, int> m;
  m[1] = 2; // etc.
  return m;
}
}

map<int, int> const A::m = create_map();

Pendekatan berbeda untuk masalah ini:

struct A {
    static const map<int, string> * singleton_map() {
        static map<int, string>* m = NULL;
        if (!m) {
            m = new map<int, string>;
            m[42] = "42"
            // ... other initializations
        }
        return m;
    }

    // rest of the class
}

Ini lebih efisien, karena tidak ada salinan satu tipe dari tumpukan ke heap (termasuk konstruktor, penghancur pada semua elemen). Apakah ini penting atau tidak tergantung pada kasus penggunaan Anda. Tidak masalah dengan string! (tetapi Anda mungkin atau mungkin tidak menemukan versi "lebih bersih" ini)

Jika peta hanya berisi entri yang diketahui pada waktu kompilasi dan kunci peta adalah bilangan bulat, maka Anda tidak perlu menggunakan peta sama sekali.

char get_value(int key)
{
    switch (key)
    {
        case 1:
            return 'a';
        case 2:
            return 'b';
        case 3:
            return 'c';
        default:
            // Do whatever is appropriate when the key is not valid
    }
}

Anda bisa mencoba ini:

MyClass.h

class MyClass {
private:
    static const std::map<key, value> m_myMap; 
    static const std::map<key, value> createMyStaticConstantMap();
public:
    static std::map<key, value> getMyConstantStaticMap( return m_myMap );
}; //MyClass

MyClass.cpp

#include "MyClass.h"

const std::map<key, value> MyClass::m_myMap = MyClass::createMyStaticConstantMap();

const std::map<key, value> MyClass::createMyStaticConstantMap() {
    std::map<key, value> mMap;
    mMap.insert( std::make_pair( key1, value1 ) );
    mMap.insert( std::make_pair( key2, value2 ) );
    // ....
    mMap.insert( std::make_pair( lastKey, lastValue ) ); 
    return mMap;
} // createMyStaticConstantMap

Dengan implementasi ini, peta statis konstan kelas Anda adalah anggota privat dan dapat diakses oleh kelas lain menggunakan metode get publik. Jika tidak, karena konstan dan tidak dapat diubah, Anda dapat menghapus metode get publik dan memindahkan variabel peta ke bagian kelas publik. Namun saya akan membiarkan metode createMap pribadi atau dilindungi jika pewarisan dan atau polimorfisme diperlukan. Berikut beberapa contoh penggunaan.

 std::map<key,value> m1 = MyClass::getMyMap();
 // then do work on m1 or
 unsigned index = some predetermined value
 MyClass::getMyMap().at( index ); // As long as index is valid this will 
 // retun map.second or map->second value so if in this case key is an
 // unsigned and value is a std::string then you could do
 std::cout << std::string( MyClass::getMyMap().at( some index that exists in map ) ); 
// and it will print out to the console the string locted in the map at this index. 
//You can do this before any class object is instantiated or declared. 

 //If you are using a pointer to your class such as:
 std::shared_ptr<MyClass> || std::unique_ptr<MyClass>
 // Then it would look like this:
 pMyClass->getMyMap().at( index ); // And Will do the same as above
 // Even if you have not yet called the std pointer's reset method on
 // this class object. 

 // This will only work on static methods only, and all data in static methods must be available first.

Saya telah mengedit posting asli saya, tidak ada yang salah dengan kode asli yang saya posting untuk itu terkompilasi, dibangun dan berjalan dengan benar, hanya saja versi pertama saya yang saya sajikan sebagai jawaban peta dinyatakan sebagai publik dan peta itu const tetapi tidak statis.

Jika Anda menggunakan kompiler yang masih tidak mendukung inisialisasi universal atau Anda memiliki reservasi untuk menggunakan Boost, alternatif lain yang memungkinkan adalah sebagai berikut

std::map<int, int> m = [] () {
    std::pair<int,int> _m[] = {
        std::make_pair(1 , sizeof(2)),
        std::make_pair(3 , sizeof(4)),
        std::make_pair(5 , sizeof(6))};
    std::map<int, int> m;
    for (auto data: _m)
    {
        m[data.first] = data.second;
    }
    return m;
}();

Panggilan fungsi tidak bisa muncul dalam ekspresi konstan.

coba ini: (hanya sebuah contoh)

#include <map>
#include <iostream>

using std::map;
using std::cout;

class myClass{
 public:
 static map<int,int> create_map()
    {
      map<int,int> m;
      m[1] = 2;
      m[3] = 4;
      m[5] = 6;
      return m;
    }
 const static map<int,int> myMap;

};
const map<int,int>myClass::myMap =  create_map();

int main(){

   map<int,int> t=myClass::create_map();
   std::cout<<t[1]; //prints 2
}

Saya sering menggunakan pola ini dan menyarankan Anda untuk menggunakannya juga:

class MyMap : public std::map<int, int>
{
public:
    MyMap()
    {
        //either
        insert(make_pair(1, 2));
        insert(make_pair(3, 4));
        insert(make_pair(5, 6));
        //or
        (*this)[1] = 2;
        (*this)[3] = 4;
        (*this)[5] = 6;
    }
} const static my_map;

Tentu itu tidak terlalu bisa dibaca, tapi tanpa libs lain yang terbaik yang bisa kita lakukan. Juga tidak akan ada operasi yang berlebihan seperti menyalin dari satu peta ke peta lain seperti dalam upaya Anda.

Ini bahkan lebih berguna di dalam fungsi: Dari pada:

void foo()
{
   static bool initComplete = false;
   static Map map;
   if (!initComplete)
   {
      initComplete = true;
      map= ...;
   }
}

Gunakan yang berikut ini:

void bar()
{
    struct MyMap : Map
    {
      MyMap()
      {
         ...
      }
    } static mymap;
}

Tidak hanya Anda tidak perlu di sini untuk berurusan dengan variabel boolean lagi, Anda tidak akan menyembunyikan variabel global yang diperiksa jika penginisialisasi variabel statis di dalam fungsi sudah dipanggil.