Trong bản đồ STL, sử dụng map :: insert tốt hơn []?

Cách đây một thời gian, tôi đã thảo luận với một đồng nghiệp về cách chèn giá trị vào bản đồ STL . Tôi thích map[key] = value; bởi vì nó cảm thấy tự nhiên và rõ ràng để đọc trong khi anh ấy thích map.insert(std::make_pair(key, value))

Tôi chỉ hỏi anh ấy và không ai trong chúng tôi có thể nhớ lý do tại sao chèn tốt hơn, nhưng tôi chắc chắn rằng đó không chỉ là một sở thích phong cách hơn là có một lý do kỹ thuật như hiệu quả. Các tài liệu tham khảo SGI STL chỉ đơn giản nói "Nói đúng ra, chức năng thành viên này là không cần thiết:. Nó chỉ tồn tại để thuận tiện"

Bất cứ ai có thể cho tôi biết lý do đó, hoặc tôi chỉ đang mơ rằng có một?

Khi bạn viết

map[key] = value;

không có cách nào để biết bạn thay thế các valuecho key, hoặc nếu bạn tạo ra một mới keyvới value.

map::insert() sẽ chỉ tạo:

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

Đối với hầu hết các ứng dụng của tôi, tôi thường không quan tâm nếu tôi đang tạo hoặc thay thế, vì vậy tôi sử dụng dễ đọc hơn map[key] = value.

Cả hai có ngữ nghĩa khác nhau khi nói đến khóa đã tồn tại trên bản đồ. Vì vậy, họ không thực sự so sánh trực tiếp.

Nhưng phiên bản toán tử [] yêu cầu xây dựng giá trị mặc định, sau đó gán, vì vậy nếu điều này đắt hơn thì sao chép xây dựng, thì nó sẽ đắt hơn. Đôi khi, cấu trúc mặc định không có ý nghĩa, và sau đó không thể sử dụng phiên bản toán tử [].

Một điều cần lưu ý với std::map:

myMap[nonExistingKey];sẽ tạo một mục mới trong bản đồ, được khóa để nonExistingKeykhởi tạo thành giá trị mặc định.

Điều này làm tôi sợ địa ngục ngay lần đầu tiên tôi nhìn thấy nó (trong khi đập đầu vào một lỗi di sản khó chịu). Sẽ không mong đợi nó. Đối với tôi, nó trông giống như một hoạt động có được và tôi không mong đợi "tác dụng phụ". Thích map.find()khi nhận được từ bản đồ của bạn.

Nếu thành tích hiệu năng của hàm tạo mặc định không phải là vấn đề, xin vui lòng, vì tình yêu của chúa, hãy đi với phiên bản dễ đọc hơn.

:)

insert là tốt hơn từ điểm an toàn ngoại lệ.

Biểu thức map[key] = valuethực sự là hai thao tác:

1. map[key] - tạo một yếu tố bản đồ với giá trị mặc định.
2. = value - sao chép giá trị vào phần tử đó.

Một ngoại lệ có thể xảy ra ở bước thứ hai. Kết quả là thao tác sẽ chỉ được thực hiện một phần (một phần tử mới đã được thêm vào bản đồ, nhưng phần tử đó không được khởi tạo với value). Tình huống khi một hoạt động không hoàn thành, nhưng trạng thái hệ thống được sửa đổi, được gọi là hoạt động với "tác dụng phụ".

insertHoạt động mang lại sự đảm bảo mạnh mẽ, có nghĩa là nó không có tác dụng phụ ( https://en.wikipedia.org/wiki/Exception_safe ).insertđược thực hiện hoàn toàn hoặc nó rời khỏi bản đồ ở trạng thái không thay đổi.

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

Nếu một phần tử duy nhất được chèn vào, không có thay đổi nào trong vùng chứa trong trường hợp ngoại lệ (bảo đảm mạnh).

Nếu ứng dụng của bạn có tốc độ quan trọng, tôi sẽ tư vấn sử dụng toán tử [] bởi vì nó tạo ra tổng số 3 bản sao của đối tượng ban đầu trong đó có 2 đối tượng tạm thời và sớm muộn bị phá hủy.

Nhưng trong insert (), 4 bản sao của đối tượng ban đầu được tạo ra trong đó 3 bản sao là đối tượng tạm thời (không nhất thiết là "tạm thời") và bị hủy.

Có nghĩa là thêm thời gian cho: 1. Cấp phát bộ nhớ cho một đối tượng 2. Một lệnh gọi hàm tạo thêm 3. Một lệnh gọi hàm hủy thêm 4. Phân bổ bộ nhớ một đối tượng

Nếu các đối tượng của bạn lớn, các hàm tạo là điển hình, các hàm hủy sẽ giải phóng rất nhiều tài nguyên, các điểm trên còn nhiều hơn thế. Về khả năng đọc, tôi nghĩ cả hai đều đủ công bằng.

Câu hỏi tương tự xuất hiện trong đầu tôi nhưng không quá dễ đọc mà là tốc độ. Đây là một mã mẫu mà qua đó tôi đã biết về điểm tôi đã đề cập.

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

Bây giờ trong c ++ 11 Tôi nghĩ rằng cách tốt nhất để chèn một cặp trong bản đồ STL là:

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

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

Các kết quả sẽ là một cặp với:

• Phần tử đầu tiên (result.first), trỏ đến cặp được chèn hoặc trỏ đến cặp có khóa này nếu khóa đã tồn tại.

• Phần tử thứ hai (result.second), đúng nếu phần chèn là đúng hoặc sai thì có gì đó không đúng.

PS: Nếu bạn không đặt trường hợp về đơn đặt hàng, bạn có thể sử dụng std :: unordered_map;)

Cảm ơn!

Một gotcha với map :: insert () là nó sẽ không thay thế một giá trị nếu khóa đã tồn tại trong bản đồ. Tôi đã thấy mã C ++ được viết bởi các lập trình viên Java nơi họ đã mong đợi insert () hoạt động giống như Map.put () trong Java nơi các giá trị được thay thế.

Một lưu ý là bạn cũng có thể sử dụng 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);
}

Đây là một ví dụ khác, cho thấy operator[] ghi đè giá trị cho khóa nếu nó tồn tại, nhưng .insert không ghi đè lên giá trị nếu nó tồn tại.

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

}

Đây là một trường hợp khá hạn chế, nhưng đánh giá từ các ý kiến ​​tôi đã nhận được tôi nghĩ rằng nó đáng chú ý.

Tôi đã thấy những người trong quá khứ sử dụng bản đồ ở dạng

map< const key, const val> Map;

để tránh các trường hợp ghi đè giá trị ngẫu nhiên, nhưng sau đó tiếp tục viết bằng một số đoạn mã khác:

const_cast< T >Map[]=val;

Lý do của họ để làm điều này khi tôi nhớ lại là vì họ chắc chắn rằng trong những đoạn mã nhất định này, họ sẽ không ghi đè lên các giá trị bản đồ; do đó, đi trước với phương pháp 'dễ đọc' hơn[] .

Tôi chưa bao giờ thực sự gặp rắc rối trực tiếp từ mã được viết bởi những người này, nhưng tôi cảm thấy mạnh mẽ cho đến ngày hôm nay rằng rủi ro - dù nhỏ - không nên được thực hiện khi họ có thể dễ dàng tránh được.

Trong trường hợp bạn đang xử lý các giá trị bản đồ tuyệt đối không được ghi đè, hãy sử dụng insert. Đừng tạo ra ngoại lệ chỉ để dễ đọc.

Thực tế là hàm std :: map insert()không ghi đè giá trị được liên kết với khóa cho phép chúng ta viết mã liệt kê đối tượng như thế này:

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

Đây là một vấn đề khá phổ biến khi chúng ta cần ánh xạ các đối tượng không phải là duy nhất khác nhau sang một số id trong phạm vi 0..N. Những id đó có thể được sử dụng sau này, ví dụ, trong các thuật toán đồ thị. Thay thế với operator[]sẽ trông ít đọc hơn theo ý kiến ​​của tôi:

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