การเริ่มต้นคงที่ std :: map <int, int> ใน C ++


449

วิธีที่ถูกต้องในการเริ่มต้นแผนที่แบบคงที่คืออะไร? เราจำเป็นต้องมีฟังก์ชั่นคงที่จะเริ่มต้นมันได้หรือไม่

คำตอบ:


620

ใช้ C ++ 11:

#include <map>
using namespace std;

map<int, char> m = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};

ใช้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
ทุกครั้งที่ฉันเห็นสิ่งที่ทำด้วย C ++ ฉันคิดถึงโค้ดเทมเพลตที่น่ากลัวที่ต้องอยู่ด้านหลัง เป็นตัวอย่างที่ดี!
เกร็กฮิวกิล

34
ความสวยงามของเทมเพลตโค้ดที่น่ากลัวที่ใช้งานยูทิลิตี้เหล่านี้คือมันถูกห่อหุ้มอย่างเรียบร้อยในห้องสมุดและผู้ใช้มักไม่ค่อยต้องการจัดการกับความซับซ้อน
Steve Guidi

45
@QBziZ: หาก บริษัท ของคุณปฏิเสธที่จะใช้ Boost เพราะเหตุนี้มันไม่ได้เป็น "มาตรฐานเพียงพอ" ฉันสงสัยว่าไลบรารี C ++ จะเป็น "มาตรฐานเพียงพอ" เพิ่มเป็นสหายมาตรฐานของ C ++ coder
DevSolar

47
ปัญหาของฉันเกี่ยวกับ Boost (ที่นี่และที่อื่น ๆ ) คือคุณมักจะสามารถดำเนินการต่อได้โดยไม่ต้องใช้มัน (ในกรณีนี้คือ C ++ 11 หรือก่อนหน้า C ++ 11 ที่มีฟังก์ชั่น ) Boost เพิ่มค่าใช้จ่ายในการคอมไพล์อย่างมีนัยสำคัญมีไฟล์มากมายที่จะนำไปไว้ในพื้นที่เก็บข้อมูลของคุณ (และต้องคัดลอกไปรอบ ๆ / zip / แตกถ้าคุณสร้างไฟล์เก็บถาวร) นั่นคือเหตุผลที่ฉันพยายามไม่ใช้ ฉันรู้ว่าคุณสามารถเลือกไฟล์ที่จะรวม / ไม่รวม แต่โดยปกติคุณไม่ต้องการกังวลเกี่ยวกับการขึ้นต่อกันของ Boost ด้วยตัวเองดังนั้นคุณเพียงแค่คัดลอกทุกสิ่งรอบตัว
bobobobo

7
ปัญหาของฉันกับ Boost คือบ่อยครั้งที่มันมีการอ้างอิงไลบรารีใหม่หลายครั้งซึ่งโดยทั่วไปหมายถึงแพ็คเกจเพิ่มเติมที่ต้องติดตั้งให้ทำงานอย่างถูกต้อง เราต้องการ libstdc ++ อยู่แล้ว ตัวอย่างเช่นไลบรารี Boost ASIO ต้องมีอย่างน้อย 2 ไลบรารีใหม่ (อาจมากกว่า) ที่ต้องติดตั้ง C ++ 11/14 ทำให้ง่ายขึ้นมากโดยไม่ต้องใช้ Boost
Rahly

135

วิธีที่ดีที่สุดคือใช้ฟังก์ชั่น:

#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
ทำไมถึงดีที่สุด? ทำไมตัวอย่างจึงดีกว่าคำตอบของ @ Dreamer?
มาร์ควิสแห่ง Lorne

6
ฉันคิดว่ามัน "ดีที่สุด" เพราะมันง่ายจริงๆและไม่ได้ขึ้นอยู่กับโครงสร้างอื่น ๆ ที่มีอยู่ (เช่น Boost :: Assign หรือการนำไปใช้ใหม่) และเมื่อเทียบกับ @ คำตอบที่โรแมนติกของดีฉันหลีกเลี่ยงการสร้างโครงสร้างทั้งหมดเพียง แต่สำหรับการเริ่มต้นแผนที่ ...
PierreBdR

3
หมายเหตุมีอันตรายที่นี่ externตัวแปรจะไม่ได้มีค่าที่ถูกต้องของพวกเขาในเรื่องนี้ "ก่อนหลักคอนสตรัคเวลาทำงาน" ถ้าคอมไพเลอร์เท่านั้นที่เห็นexternการประกาศ แต่ไม่ได้ใช้เป็นคำนิยามตัวแปรที่เกิดขึ้นจริง
bobobobo

5
ไม่อันตรายคือไม่มีสิ่งใดที่บอกว่าควรเริ่มต้นตัวแปรแบบคงที่ (อย่างน้อยในหน่วยการคอมไพล์) แต่นี่ไม่ใช่ปัญหาที่เชื่อมโยงกับคำถามนี้ นี่เป็นปัญหาทั่วไปเกี่ยวกับตัวแปรคงที่
PierreBdR

5
ไม่เพิ่มและไม่มี C ++ 11 => +1 ขอให้สังเกตว่าฟังก์ชั่นสามารถใช้ในการเริ่มต้นconst map<int,int> m = create_map()(และอื่น ๆ เริ่มต้นสมาชิก const ของชั้นเรียนในรายการเริ่มต้น:struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map())
ribamar

115

ไม่ใช่ปัญหาที่ซับซ้อนในการสร้างสิ่งที่คล้ายกับการเพิ่มประสิทธิภาพ นี่คือคลาสที่มีเพียงสามฟังก์ชันรวมถึงตัวสร้างเพื่อทำซ้ำสิ่งที่การเพิ่มประสิทธิภาพทำได้ (เกือบ)

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

การใช้งาน:

std :: map mymap = create_map <int, int> (1,2) (3,4) (5,6);

รหัสข้างต้นทำงานได้ดีที่สุดสำหรับการเริ่มต้นของตัวแปรทั่วโลกหรือสมาชิกคงที่ของชั้นเรียนซึ่งจะต้องเริ่มต้นและคุณไม่มีความคิดเมื่อมันได้รับการใช้ครั้งแรก แต่คุณต้องการให้มั่นใจว่าค่าที่มีอยู่ในนั้น

ถ้าบอกว่าคุณต้องแทรกองค์ประกอบลงใน std :: map ที่มีอยู่เดิมนี่เป็นอีกคลาสหนึ่งสำหรับคุณ

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

การใช้งาน:

typedef std::map<int, int> Int2IntMap;
Int2IntMap testMap;
map_add_values<Int2IntMap>(1,2)(3,4)(5,6).to(testMap);

ดูการทำงานกับ GCC 4.7.2 ได้ที่นี่: http://ideone.com/3uYJiH

############### ทุกสิ่งที่อยู่ด้านล่างนี้เป็น OBSOLETE ##################################

แก้ไข : map_add_valuesชั้นเรียนด้านล่างซึ่งเป็นคำตอบดั้งเดิมที่ฉันแนะนำจะล้มเหลวเมื่อพูดถึง GCC 4.5+ โปรดดูรหัสด้านบนสำหรับวิธีเพิ่มค่าลงในแผนที่ที่มีอยู่


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

การใช้งาน:

std :: map <int, int> my_map;
// หลังจากนั้นบางรหัสตาม
map_add_values ​​<int, int> (my_map) (1,2) (3,4) (5,6);

หมายเหตุ: ก่อนหน้านี้ฉันใช้operator []สำหรับการเพิ่มค่าจริง สิ่งนี้เป็นไปไม่ได้ตามความเห็นของ dalle

##################### ปลายส่วนที่ OBSOLETE ###########################################################################################################################


3
ฉันใช้ตัวอย่างแรกของคุณเป็น <int, string> เพื่อผูกหมายเลขข้อผิดพลาด (จาก enum) กับข้อความ - มันใช้งานได้อย่างมีเสน่ห์ - ขอบคุณ
slashmais

1
operator[]ใช้เวลาโต้แย้งเพียงครั้งเดียว
dalle

1
@dalle: จับได้ดี! ด้วยเหตุผลบางอย่างฉันคิดว่าตัวดำเนินการ [] ที่มากเกินไปอาจยอมรับได้มากกว่านี้
Vite Falcon

2
นี่คือคำตอบที่ยอดเยี่ยม มันเป็นความอัปยศที่ OP ไม่เคยเลือก คุณสมควรได้รับอุปกรณ์ประกอบฉาก mega
โทมัส Thorogood

map_add_values ​​ใช้งานไม่ได้ใน gcc ซึ่งบ่นว่า: 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

นี่เป็นอีกวิธีหนึ่งที่ใช้ตัวสร้างข้อมูล 2 องค์ประกอบ ไม่จำเป็นต้องใช้ฟังก์ชันใด ๆ ในการเริ่มต้น ไม่มีรหัสบุคคลที่สาม (เพิ่ม) ไม่มีฟังก์ชั่นคงที่หรือวัตถุไม่มีเทคนิคเพียง 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);

ตั้งแต่ฉันเขียนคำตอบนี้ C ++ 11 ออกมา ตอนนี้คุณสามารถเริ่มต้นคอนเทนเนอร์ STL โดยตรงโดยใช้คุณสมบัติรายการตัวกำหนดค่าเริ่มต้นใหม่:

const MyMap myMap = { {"hello", 42}, {"world", 88} };

25

ตัวอย่างเช่น:

const std::map<LogLevel, const char*> g_log_levels_dsc =
{
    { LogLevel::Disabled, "[---]" },
    { LogLevel::Info,     "[inf]" },
    { LogLevel::Warning,  "[wrn]" },
    { LogLevel::Error,    "[err]" },
    { LogLevel::Debug,    "[dbg]" }
};

หาก map เป็นสมาชิกข้อมูลของคลาสคุณสามารถเริ่มต้นได้โดยตรงในส่วนหัวโดยวิธีต่อไปนี้ (ตั้งแต่ 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

ฉันจะห่อแผนที่ภายในวัตถุคงที่และใส่รหัส initialisation แผนที่ในตัวสร้างของวัตถุนี้ด้วยวิธีนี้คุณจะแน่ใจว่าแผนที่ถูกสร้างขึ้นก่อนที่จะมีการประมวลผลรหัสเริ่มต้น


1
ฉันอยู่กับคุณในที่นี้ นอกจากนี้ยังตาดเร็วขึ้น :)
QBziZ

2
ตาดเร็วกว่าอะไร แบบคงที่ทั่วโลกด้วยการเริ่มต้น? ไม่มันไม่ใช่ (จดจำเกี่ยวกับ RVO)
Pavel Minaev

7
คำตอบที่ดี ฉันจะมีความสุขถ้าฉันเห็นรหัสตัวอย่างจริง
Sungguk Lim

18

แค่ต้องการแชร์ C ++ 98 ที่บริสุทธิ์

#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
สิ่งนี้ใช้ไม่ได้กับวัตถุที่ไม่มีตัวสร้างเริ่มต้นควรใช้วิธีการแทรก IMHO
Alessandro Teruzzi

16

คุณสามารถลอง:

std::map <int, int> mymap = 
{
        std::pair <int, int> (1, 1),
        std::pair <int, int> (2, 2),
        std::pair <int, int> (2, 2)
};

1
คุณไม่สามารถใช้การเริ่มต้นรายการที่มีที่ไม่รวมประเภทก่อน C ++ 11 ซึ่งในกรณีนี้คุณอาจรวมทั้งใช้ไวยากรณ์สั้นแทน{1, 2} std::pair<int, int>(1, 2)
Ferruccio

9

สิ่งนี้คล้ายกับPierreBdRโดยไม่ต้องคัดลอกแผนที่

#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
มันอาจจะไม่ถูกคัดลอกอยู่ดี
GManNickG

2
แต่วิธีนี้แผนที่ไม่สามารถคงที่ได้
xmoex

6

หากคุณติดอยู่กับ C ++ 98 และไม่ต้องการใช้การเร่งนี่เป็นวิธีที่ฉันใช้เมื่อฉันต้องเริ่มต้นแผนที่แบบคงที่:

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

คุณมีคำตอบที่ดีมากที่นี่ แต่ฉันกับฉันดูเหมือนว่า "เมื่อคุณรู้ว่าเป็นค้อน" ...

คำตอบที่ง่ายที่สุดว่าทำไมไม่มีวิธีมาตรฐานในการเริ่มต้นแผนที่แบบคงที่ไม่มีเหตุผลที่ดีที่จะใช้แผนที่แบบคงที่ ...

แผนที่เป็นโครงสร้างที่ออกแบบมาสำหรับการค้นหาอย่างรวดเร็วขององค์ประกอบที่ไม่รู้จัก หากคุณรู้องค์ประกอบก่อนมือเพียงใช้ C-array ป้อนค่าในลักษณะที่เรียงลำดับหรือเรียกใช้เรียงลำดับหากคุณไม่สามารถทำได้ จากนั้นคุณจะได้รับประสิทธิภาพการทำงานของ log (n) โดยใช้ฟังก์ชั่น stl :: เพื่อวนลูปอัพ เมื่อฉันทำการทดสอบก่อนหน้านี้พวกเขามักจะทำงานเร็วกว่าแผนที่อย่างน้อย 4 เท่า

ข้อดีคือหลายเท่า ... - ประสิทธิภาพที่เร็วขึ้น (* 4 ฉันวัดจำนวนซีพียูได้หลายประเภทมันอยู่ที่ประมาณ 4) - การดีบักที่ง่ายขึ้น มันง่ายกว่าที่จะเห็นสิ่งที่เกิดขึ้นกับเค้าโครงเชิงเส้น - การใช้งานการคัดลอกเล็กน้อยซึ่งจำเป็นต้องมี - ไม่มีการจัดสรรหน่วยความจำในขณะใช้งานดังนั้นจะไม่มีข้อยกเว้น - เป็นอินเทอร์เฟซมาตรฐานและง่ายต่อการแชร์ข้าม DLL หรือภาษา ฯลฯ

ฉันสามารถไปต่อได้ แต่ถ้าคุณต้องการมากกว่านี้ทำไมไม่ลองดูบล็อกมากมายของ Stroustrup ในเรื่องนี้


8
ประสิทธิภาพไม่ใช่เหตุผลเดียวในการใช้แผนที่ ตัวอย่างเช่นมีหลายกรณีที่คุณต้องการเชื่อมโยงค่าต่างๆเข้าด้วยกัน (ตัวอย่างเช่นรหัสข้อผิดพลาดพร้อมข้อความแสดงข้อผิดพลาด) และแผนที่ทำให้การใช้งานและการเข้าถึงค่อนข้างง่าย แต่ลิงก์ไปยังรายการบล็อกเหล่านี้อาจน่าสนใจบางทีฉันอาจจะทำผิดพลาด
MatthiasB

5
อาร์เรย์นั้นง่ายกว่ามากและมีประสิทธิภาพสูงกว่าถ้าคุณสามารถใช้ได้ แต่ถ้าดัชนี (คีย์) ไม่ต่อเนื่องและเว้นระยะห่างกันมากคุณต้องมีแผนที่
KarlU

1
A mapยังเป็นรูปแบบที่มีประโยชน์สำหรับการแสดงฟังก์ชั่นบางส่วน (ฟังก์ชั่นในความหมายทางคณิตศาสตร์; แต่ยังชนิดของในแง่การเขียนโปรแกรม) อาร์เรย์ไม่ทำเช่นนั้น คุณไม่สามารถพูดข้อมูลการค้นหาจากอาร์เรย์โดยใช้สตริง
einpoklum

3
คำตอบของคุณไม่ได้พยายามที่จะตอบคำถามที่ถูกต้องและแทนที่จะคาดเดาเกี่ยวกับข้อ จำกัด ของภาษาเสนอแนวทางแก้ไขปัญหาที่แตกต่างกันดังนั้น downvote สถานการณ์จริง - การแมป (ต่อเนื่องหรือไม่) รหัสข้อผิดพลาดของไลบรารีกับสตริงข้อความ ด้วยอาเรย์เวลาค้นหาคือ O (n) ซึ่งสามารถปรับปรุงได้โดยการแมปแบบสแตติกกับ O (บันทึก (n))
Tosha

2
หาก "ไม่มีเหตุผลที่ดีที่จะใช้แผนที่แบบคงที่ ... " มันแปลกมากที่มีการเพิ่มไวยากรณ์ (รายการตัวเริ่มต้น) ที่ทำให้ง่ายต่อการใช้เพิ่มใน C ++ 11
ellisbben
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.