ในแผนที่ STL ควรใช้แผนที่ :: insert มากกว่า [] หรือไม่

ขณะที่ผ่านมาผมได้มีการพูดคุยกับเพื่อนร่วมงานเกี่ยวกับวิธีการใส่ค่าใน STL เป็นแผนที่ ฉันชอบ map[key] = value; เพราะรู้สึกเป็นธรรมชาติและอ่านง่ายในขณะที่เขาชอบ map.insert(std::make_pair(key, value))

ฉันแค่ถามเขาและพวกเราทั้งสองไม่สามารถจำเหตุผลที่แทรกได้ดีกว่า แต่ฉันแน่ใจว่ามันไม่ใช่แค่การตั้งค่ารูปแบบ แต่มีเหตุผลทางเทคนิคเช่นประสิทธิภาพ อ้างอิง SGI STLบอกว่า "พูดอย่างเคร่งครัดฟังก์ชั่นสมาชิกนี้ไม่จำเป็น: มันมีอยู่เพื่อความสะดวกเท่านั้น"

ใครสามารถบอกเหตุผลนั้นกับฉันหรือฉันแค่ฝันว่ามี?

เมื่อคุณเขียน

map[key] = value;

มีวิธีที่จะบอกได้ว่าคุณไม่แทนที่valueสำหรับkeyหรือถ้าคุณสร้างขึ้นใหม่ด้วยkeyvalue

map::insert() จะสร้างเท่านั้น:

using std::cout; using std::endl;
typedef std::map<int, std::string> MyMap;
MyMap map;
// ...
std::pair<MyMap::iterator, bool> res = map.insert(MyMap::value_type(key,value));
if ( ! res.second ) {
    cout << "key " <<  key << " already exists "
         << " with value " << (res.first)->second << endl;
} else {
    cout << "created key " << key << " with value " << value << endl;
}

map[key] = valueสำหรับส่วนมากของปพลิเคชันของฉันฉันมักจะไม่สนใจว่าฉันกำลังสร้างหรือเปลี่ยนดังนั้นฉันจะใช้ให้อ่านง่ายขึ้น

ทั้งสองมีความหมายต่างกันเมื่อพูดถึงกุญแจที่มีอยู่แล้วในแผนที่ ดังนั้นมันจึงไม่สามารถเทียบเคียงได้โดยตรง

แต่เวอร์ชันตัวดำเนินการ [] ต้องใช้ค่าเริ่มต้นในการสร้างค่าจากนั้นจึงกำหนดค่าดังนั้นถ้าค่านี้มีราคาแพงกว่าให้คัดลอกโครงสร้างแล้วจึงจะมีราคาแพงกว่า บางครั้งการสร้างเริ่มต้นไม่สมเหตุสมผลและจากนั้นก็เป็นไปไม่ได้ที่จะใช้โอเปอเรเตอร์ []

อีกสิ่งที่ควรทราบด้วย std::map :

myMap[nonExistingKey]; จะสร้างรายการใหม่ในแผนที่คีย์ nonExistingKeyเริ่มต้นเป็นค่าเริ่มต้น

นี่ทำให้ฉันกลัวนรกในครั้งแรกที่ฉันเห็นมัน (ในขณะที่ต่อสู้กับข้อผิดพลาดที่น่ารังเกียจ) คงไม่ได้คาดหวัง สำหรับฉันแล้วดูเหมือนว่าจะเป็นการผ่าตัด แต่ฉันไม่ได้คาดหวังกับ "ผลข้างเคียง" ชอบmap.find()เมื่อเดินทางจากแผนที่ของคุณ

หากการตีค่าประสิทธิภาพของคอนสตรัคเตอร์เริ่มต้นไม่ใช่ปัญหาโปรดเพื่อความรักของพระเจ้าโปรดใช้เวอร์ชันที่อ่านได้ง่ายขึ้น

:)

insert ดีกว่าจากจุดยกเว้นด้านความปลอดภัย

การแสดงออกmap[key] = valueเป็นสองการดำเนินงานจริง:

1. map[key] - การสร้างองค์ประกอบแผนที่ที่มีค่าเริ่มต้น
2. = value - คัดลอกค่าลงในองค์ประกอบนั้น

อาจมีข้อยกเว้นเกิดขึ้นในขั้นตอนที่สอง เป็นผลให้การดำเนินการจะทำเพียงบางส่วนเท่านั้น (องค์ประกอบใหม่ถูกเพิ่มเข้าไปในแผนที่ แต่องค์ประกอบนั้นไม่ได้เริ่มต้นด้วยvalue) สถานการณ์เมื่อการดำเนินการไม่เสร็จสมบูรณ์ แต่สถานะของระบบได้รับการแก้ไขเรียกว่าการดำเนินการด้วย "ผลข้างเคียง"

insertการดำเนินการให้การรับประกันที่แข็งแกร่งหมายความว่าไม่มีผลข้างเคียง ( https://en.wikipedia.org/wiki/Exception_safety ) insertเสร็จสิ้นสมบูรณ์หรือออกจากแผนที่ในสถานะที่ไม่ได้แก้ไข

http://www.cplusplus.com/reference/map/map/insert/ :

หากจะใส่องค์ประกอบเดียวจะไม่มีการเปลี่ยนแปลงในคอนเทนเนอร์ในกรณียกเว้น (รับประกันอย่างแน่นหนา)

หากใบสมัครของคุณมีความสำคัญอย่างมากฉันจะแนะนำให้ใช้ตัวดำเนินการ [] เพราะมันจะสร้างสำเนาต้นฉบับทั้งหมด 3 ฉบับโดยที่ 2 นั้นเป็นวัตถุชั่วคราวและไม่ช้าก็เร็วจะถูกทำลายเป็น

แต่ในส่วนแทรก () จะมีการสร้างวัตถุดั้งเดิมจำนวน 4 ชุดโดยที่ 3 ชิ้นเป็นวัตถุชั่วคราว (ไม่จำเป็นต้องเป็น "ชั่วคราว") และถูกทำลาย

ซึ่งหมายถึงเวลาพิเศษสำหรับ: 1. การจัดสรรหน่วยความจำหนึ่งวัตถุ 2. การเรียกตัวสร้างพิเศษหนึ่งครั้ง 3. การโทร destructor พิเศษหนึ่งครั้ง 4. การจัดสรรคืนหน่วยความจำวัตถุหนึ่งชิ้น

หากวัตถุของคุณมีขนาดใหญ่คอนสตรัคเตอร์ก็เป็นแบบปกติ destructors จะช่วยประหยัดทรัพยากรได้มาก เกี่ยวกับความสามารถในการอ่านฉันคิดว่าทั้งคู่มีความยุติธรรมเพียงพอ

คำถามเดียวกันเข้ามาในใจของฉัน แต่ไม่เกินอ่านง่าย แต่ความเร็ว นี่คือตัวอย่างโค้ดที่ฉันรู้เกี่ยวกับประเด็นที่ฉันพูดถึง

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair<int,Sample>( 1, sample) );
    //map[1] = sample;
    return 0;
}

ตอนนี้ใน c ++ 11 ฉันคิดว่าวิธีที่ดีที่สุดในการแทรกคู่ในแผนที่ STL คือ:

typedef std::map<int, std::string> MyMap;
MyMap map;

auto& result = map.emplace(3,"Hello");

ผลจะเป็นคู่กับ:

• องค์ประกอบแรก (result.first) ชี้ไปที่คู่ที่ถูกแทรกหรือชี้ไปที่คู่ด้วยปุ่มนี้ถ้าคีย์มีอยู่แล้ว

• องค์ประกอบที่สอง (result.second) จริงถ้าการแทรกนั้นถูกต้องหรือเท็จสิ่งที่ผิดพลาด

PS: ถ้าคุณไม่กรณีเกี่ยวกับการสั่งซื้อคุณสามารถใช้ std :: unordered_map;)

ขอบคุณ!

gotcha พร้อมแผนที่ :: insert () คือมันจะไม่แทนที่ค่าหากคีย์มีอยู่แล้วในแผนที่ ฉันเห็นรหัส C ++ ที่เขียนโดยโปรแกรมเมอร์ Java ที่พวกเขาคาดว่าจะแทรก () เพื่อทำงานในลักษณะเดียวกับ Map.put () ใน Java ที่มีการแทนที่ค่า

One note คือคุณสามารถใช้Boost.Assign :

using namespace std;
using namespace boost::assign; // bring 'map_list_of()' into scope

void something()
{
    map<int,int> my_map = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6);
}

นี่คืออีกตัวอย่างหนึ่งซึ่งแสดงว่าoperator[] เขียนทับค่าสำหรับคีย์ถ้ามีอยู่ แต่.insert จะไม่เขียนทับค่าหากมีอยู่

void mapTest()
{
  map<int,float> m;


  for( int i = 0 ; i  <=  2 ; i++ )
  {
    pair<map<int,float>::iterator,bool> result = m.insert( make_pair( 5, (float)i ) ) ;

    if( result.second )
      printf( "%d=>value %f successfully inserted as brand new value\n", result.first->first, result.first->second ) ;
    else
      printf( "! The map already contained %d=>value %f, nothing changed\n", result.first->first, result.first->second ) ;
  }

  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

  /// now watch this.. 
  m[5]=900.f ; //using operator[] OVERWRITES map values
  puts( "All map values:" ) ;
  for( map<int,float>::iterator iter = m.begin() ; iter !=m.end() ; ++iter )
    printf( "%d=>%f\n", iter->first, iter->second ) ;

}

นี่เป็นกรณีที่ค่อนข้าง จำกัด แต่การตัดสินจากความคิดเห็นที่ฉันได้รับฉันคิดว่ามันควรค่าแก่การสังเกต

ฉันเคยเห็นผู้คนในอดีตใช้แผนที่ในรูปแบบของ

map< const key, const val> Map;

เพื่อหลีกเลี่ยงกรณีของการเขียนทับค่าโดยไม่ตั้งใจ แต่จากนั้นไปข้างหน้าเขียนในรหัสบิตอื่น ๆ :

const_cast< T >Map[]=val;

เหตุผลของพวกเขาในการทำสิ่งนี้ขณะที่ฉันจำได้ก็เพราะพวกเขาแน่ใจว่าในส่วนของรหัสบางส่วนพวกเขาจะไม่ถูกเขียนทับค่าแผนที่ ดังนั้นไปข้างหน้าด้วยวิธีการ 'อ่านได้' []มากขึ้น

จริง ๆ แล้วฉันไม่เคยมีปัญหาโดยตรงจากรหัสที่คนเหล่านี้เขียน แต่ฉันรู้สึกถึงความเสี่ยงอย่างมากจนถึงทุกวันนี้ที่มีความเสี่ยงเล็ก ๆ น้อย ๆ ที่ควรหลีกเลี่ยงเมื่อพวกเขาสามารถหลีกเลี่ยงได้ง่าย

ในกรณีที่คุณจัดการกับค่าแผนที่ที่อย่างจะต้องไม่insertถูกเขียนทับการใช้งาน อย่าสร้างข้อยกเว้นเพียงเพื่อให้สามารถอ่านได้

ความจริงที่ว่าinsert()ฟังก์ชั่นstd :: map ไม่ได้เขียนทับค่าที่เชื่อมโยงกับคีย์ทำให้เราสามารถเขียนโค้ดการแจงนับวัตถุดังนี้:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    dict.insert(make_pair(word, dict.size()));
}

มันเป็นปัญหาที่พบได้บ่อยเมื่อเราต้องการแมปออบเจกต์ที่ไม่ซ้ำกันที่แตกต่างกับ id ของบางคนในช่วง 0..N id เหล่านั้นสามารถใช้ในภายหลังตัวอย่างเช่นในอัลกอริทึมกราฟ ทางเลือกที่มีoperator[]จะดูน้อยอ่านในความคิดของฉัน:

string word;
map<string, size_t> dict;
while(getline(cin, word)) {
    size_t sz = dict.size();
    if (!dict.count(word))
        dict[word] = sz; 
}