วิธีที่ถูกต้องในการเริ่มต้นแผนที่แบบคงที่คืออะไร? เราจำเป็นต้องมีฟังก์ชั่นคงที่จะเริ่มต้นมันได้หรือไม่
วิธีที่ถูกต้องในการเริ่มต้นแผนที่แบบคงที่คืออะไร? เราจำเป็นต้องมีฟังก์ชั่นคงที่จะเริ่มต้นมันได้หรือไม่
คำตอบ:
ใช้ 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');
วิธีที่ดีที่สุดคือใช้ฟังก์ชั่น:
#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
ตัวแปรจะไม่ได้มีค่าที่ถูกต้องของพวกเขาในเรื่องนี้ "ก่อนหลักคอนสตรัคเวลาทำงาน" ถ้าคอมไพเลอร์เท่านั้นที่เห็นextern
การประกาศ แต่ไม่ได้ใช้เป็นคำนิยามตัวแปรที่เกิดขึ้นจริง ๆ
const map<int,int> m = create_map()
(และอื่น ๆ เริ่มต้นสมาชิก const ของชั้นเรียนในรายการเริ่มต้น:struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map())
ไม่ใช่ปัญหาที่ซับซ้อนในการสร้างสิ่งที่คล้ายกับการเพิ่มประสิทธิภาพ นี่คือคลาสที่มีเพียงสามฟังก์ชันรวมถึงตัวสร้างเพื่อทำซ้ำสิ่งที่การเพิ่มประสิทธิภาพทำได้ (เกือบ)
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 ###########################################################################################################################
operator[]
ใช้เวลาโต้แย้งเพียงครั้งเดียว
error: conflicting declaration ‘map_add_values<int, int> my_map’
error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’
นี่เป็นอีกวิธีหนึ่งที่ใช้ตัวสร้างข้อมูล 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} };
ตัวอย่างเช่น:
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
};
};
ฉันจะห่อแผนที่ภายในวัตถุคงที่และใส่รหัส initialisation แผนที่ในตัวสร้างของวัตถุนี้ด้วยวิธีนี้คุณจะแน่ใจว่าแผนที่ถูกสร้างขึ้นก่อนที่จะมีการประมวลผลรหัสเริ่มต้น
แค่ต้องการแชร์ 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;
คุณสามารถลอง:
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}
std::pair<int, int>(1, 2)
สิ่งนี้คล้ายกับ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);
หากคุณติดอยู่กับ 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 ] ) ] );
คุณมีคำตอบที่ดีมากที่นี่ แต่ฉันกับฉันดูเหมือนว่า "เมื่อคุณรู้ว่าเป็นค้อน" ...
คำตอบที่ง่ายที่สุดว่าทำไมไม่มีวิธีมาตรฐานในการเริ่มต้นแผนที่แบบคงที่ไม่มีเหตุผลที่ดีที่จะใช้แผนที่แบบคงที่ ...
แผนที่เป็นโครงสร้างที่ออกแบบมาสำหรับการค้นหาอย่างรวดเร็วขององค์ประกอบที่ไม่รู้จัก หากคุณรู้องค์ประกอบก่อนมือเพียงใช้ C-array ป้อนค่าในลักษณะที่เรียงลำดับหรือเรียกใช้เรียงลำดับหากคุณไม่สามารถทำได้ จากนั้นคุณจะได้รับประสิทธิภาพการทำงานของ log (n) โดยใช้ฟังก์ชั่น stl :: เพื่อวนลูปอัพ เมื่อฉันทำการทดสอบก่อนหน้านี้พวกเขามักจะทำงานเร็วกว่าแผนที่อย่างน้อย 4 เท่า
ข้อดีคือหลายเท่า ... - ประสิทธิภาพที่เร็วขึ้น (* 4 ฉันวัดจำนวนซีพียูได้หลายประเภทมันอยู่ที่ประมาณ 4) - การดีบักที่ง่ายขึ้น มันง่ายกว่าที่จะเห็นสิ่งที่เกิดขึ้นกับเค้าโครงเชิงเส้น - การใช้งานการคัดลอกเล็กน้อยซึ่งจำเป็นต้องมี - ไม่มีการจัดสรรหน่วยความจำในขณะใช้งานดังนั้นจะไม่มีข้อยกเว้น - เป็นอินเทอร์เฟซมาตรฐานและง่ายต่อการแชร์ข้าม DLL หรือภาษา ฯลฯ
ฉันสามารถไปต่อได้ แต่ถ้าคุณต้องการมากกว่านี้ทำไมไม่ลองดูบล็อกมากมายของ Stroustrup ในเรื่องนี้
map
ยังเป็นรูปแบบที่มีประโยชน์สำหรับการแสดงฟังก์ชั่นบางส่วน (ฟังก์ชั่นในความหมายทางคณิตศาสตร์; แต่ยังชนิดของในแง่การเขียนโปรแกรม) อาร์เรย์ไม่ทำเช่นนั้น คุณไม่สามารถพูดข้อมูลการค้นหาจากอาร์เรย์โดยใช้สตริง