C ++ 'da özel bir statik sabit haritası nasıl başlatılır?

Sadece sözlüğe veya ilişkisel dizi string=> ihtiyacım var int.

Bu durum için tip eşlemi C ++ vardır.

Ancak tüm örnekler için (-> statik) yalnızca bir haritaya ihtiyacım var ve bu harita değiştirilemez (-> const);

Bu yolu destek kitaplığı ile buldum

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

Bu kitaplık olmadan başka bir çözüm var mı? Bunun gibi bir şey denedim, ancak her zaman harita başlatma ile ilgili bazı sorunlar var.

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() {
}

C ++ 11 standardı, derleyiciniz destekliyorsa bunu çok daha basit hale getiren tek tip başlatma getirmiştir:

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

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

Unordered_maps üzerinde Professional C ++ 'dan bu bölüme de bakın .

Yaptım! :)

C ++ 11 olmadan sorunsuz çalışır

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

boost::assign::map_list_ofYararlı bulursanız , ancak herhangi bir nedenle kullanamazsanız, kendinizinkini yazabilirsiniz :

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

Bu tür şeylerin, özellikle çok kısa olduklarında nasıl çalıştığını bilmek yararlıdır, ancak bu durumda bir işlev kullanırım:

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

Soruna farklı bir yaklaşım:

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
}

Yığından öbeğe tek tip kopya olmadığından bu daha verimlidir (yapıcı, tüm öğelerdeki yıkıcılar dahil). Bunun önemli olup olmadığı kullanım durumunuza bağlıdır. Dizelerle önemli değil! (ancak bu sürümü "daha temiz" bulabilir veya bulamayabilirsiniz)

Harita yalnızca derleme zamanında bilinen girişleri içerecekse ve haritanın anahtarları tamsayı ise, o zaman bir harita kullanmanıza gerek yoktur.

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

Bunu deneyebilirsin:

Sınıfım.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

Sınıfım.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

Bu uygulama ile sınıflarınız sabit statik haritası özel bir üyedir ve genel bir get yöntemi kullanarak diğer sınıflar tarafından erişilebilir. Aksi takdirde, sabit olduğundan ve değiştirilemeyeceğinden, public get yöntemini kaldırabilir ve map değişkenini sınıflar public bölümüne taşıyabilirsiniz. Bununla birlikte, miras ve / veya çok biçimlilik gerekliyse createMap yöntemini özel veya korumalı olarak bırakırdım. İşte bazı kullanım örnekleri.

 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.

Orijinal gönderimi düzenledim, onun için derlediğim, oluşturduğum ve doğru şekilde çalıştırdığım orijinal kodda yanlış bir şey yoktu, sadece bir cevap olarak sunduğum ilk sürümüm, haritanın herkese açık olarak ilan edilmesi ve haritanın sabit ancak statik değildi.

Hala evrensel başlatmayı desteklemeyen bir derleyici kullanıyorsanız veya Boost'u kullanmak için rezervasyonunuz varsa, başka bir olası alternatif aşağıdaki gibi olacaktır.

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

Bir işlev çağrısı sabit bir ifadede görünemez.

bunu deneyin: (sadece bir örnek)

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

Sık sık bu kalıbı kullanıyorum ve sizin de kullanmanızı tavsiye ediyorum:

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;

Elbette çok okunabilir değil, ancak diğer kitaplıklar olmadan yapabileceğimiz en iyi şey bu. Ayrıca girişiminizdeki gibi bir haritadan diğerine kopyalamak gibi gereksiz işlemler olmayacaktır.

Bu, işlevlerin içinde daha da kullanışlıdır: Bunun yerine:

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

Aşağıdakileri kullanın:

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

Artık boole değişkeniyle uğraşmak için burada ihtiyacınız yok, aynı zamanda işlev içindeki statik değişkenin başlatıcısı zaten çağrıldıysa, kontrol edilen gizli global değişkene sahip olmayacaksınız.