Là thứ tự lặp qua std :: map đã biết (và được đảm bảo theo tiêu chuẩn)?

Ý tôi là - chúng ta biết rằng các std::mapyếu tố của được sắp xếp theo các phím. Vì vậy, giả sử các khóa là số nguyên. Nếu tôi lặp lại từ std::map::begin()việc std::map::end()sử dụng a for, liệu có đảm bảo tiêu chuẩn rằng tôi sẽ lặp lại thông qua các phần tử với các khóa, được sắp xếp theo thứ tự tăng dần không?

Thí dụ:

std::map<int, int> map_;
map_[1] = 2;
map_[2] = 3;
map_[3] = 4;
for( std::map<int, int>::iterator iter = map_.begin();
     iter != map_.end();
     ++iter )
{
    std::cout << iter->second;
}

Điều này có được đảm bảo để in 234hoặc nó được thực hiện được xác định?

Lý do thực tế cuộc sống: Tôi có một std::mapvới intcác phím. Trong các tình huống rất hiếm, tôi muốn lặp lại qua tất cả các yếu tố, với khóa, lớn hơn một intgiá trị cụ thể . Đúng, có vẻ như std::vectorsẽ là lựa chọn tốt hơn, nhưng hãy chú ý "những tình huống rất hiếm" của tôi.

EDIT : Tôi biết, các yếu tố std::mapđược sắp xếp .. không cần phải chỉ ra (đối với hầu hết các câu trả lời ở đây). Tôi thậm chí đã viết nó trong câu hỏi của tôi.
Tôi đã hỏi về các trình vòng lặp và thứ tự khi tôi lặp qua một container. Cảm ơn @Kerrek SB đã trả lời.

Vâng, điều đó được đảm bảo. Hơn nữa, *begin()cung cấp cho bạn phần tử nhỏ nhất và *rbegin()lớn nhất, như được xác định bởi toán tử so sánh và hai giá trị chính avà bbiểu thức !compare(a,b) && !compare(b,a)là đúng được coi là bằng nhau. Hàm so sánh mặc định là std::less<K>.

Thứ tự không phải là một tính năng thưởng may mắn, nhưng đúng hơn, nó là một khía cạnh cơ bản của cấu trúc dữ liệu, vì thứ tự được sử dụng để xác định khi nào hai khóa giống nhau (theo quy tắc trên) và để thực hiện tra cứu hiệu quả (về cơ bản là nhị phân tìm kiếm, có độ phức tạp logarit trong số lượng phần tử).

Điều này được đảm bảo bởi các yêu cầu liên kết container trong tiêu chuẩn C ++. Ví dụ, xem 23.2.4 / 10 trong C ++ 11:

Thuộc tính cơ bản của các vòng lặp của container kết hợp là chúng
Lặp lại qua các thùng chứa theo thứ tự các phím không giảm dần trong đó
không giảm dần được xác định bởi so sánh đã được sử dụng để xây dựng chúng.
Đối với bất kỳ hai trình lặp lặp có thể điều chỉnh i và j sao cho khoảng cách từ i đến j là
tích cực,
  value_comp (* j, * i) == sai

và 23.2.4 / 11

Đối với các thùng chứa kết hợp với các phím duy nhất, điều kiện mạnh hơn giữ,
  value_comp (* i, * j)! = sai.

Tôi nghĩ rằng có một sự nhầm lẫn trong cấu trúc dữ liệu.

Trong hầu hết các ngôn ngữ, a mapchỉ đơn giản là AssociativeContainer: nó ánh xạ khóa tới một giá trị. Trong các ngôn ngữ "mới hơn", điều này thường đạt được bằng cách sử dụng bản đồ băm, do đó không có đơn hàng nào được đảm bảo.

Tuy nhiên, trong C ++, đây không phải là như vậy:

• std::maplà một container kết hợp được sắp xếp
• std::unordered_map là một thùng chứa kết hợp dựa trên bảng băm được giới thiệu trong C ++ 11

Vì vậy, để làm rõ các đảm bảo về đặt hàng.

Trong C ++ 03:

• std::set, std::multiset, std::mapVà std::multimapđược đảm bảo để được sắp xếp theo các phím (và tiêu chí cung cấp)
• trong std::multisetvà std::multimap, tiêu chuẩn không áp đặt bất kỳ sự đảm bảo trật tự nào đối với các yếu tố tương đương (nghĩa là các yếu tố so sánh bằng nhau)

Trong C ++ 11:

• std::set, std::multiset, std::mapVà std::multimapđược đảm bảo để được sắp xếp theo các phím (và tiêu chí cung cấp)
• trong std::multisetvà std::multimap, Tiêu chuẩn áp đặt rằng các yếu tố tương đương (những yếu tố so sánh bằng nhau) được sắp xếp theo thứ tự chèn (đầu tiên được chèn trước)
• std::unordered_*container, như tên ngụ ý, không được đặt hàng. Đáng chú ý nhất, thứ tự của các yếu tố có thể thay đổi khi container được sửa đổi (khi chèn / xóa).

Khi Tiêu chuẩn nói rằng các phần tử được sắp xếp theo cách, điều đó có nghĩa là:

• Khi lặp lại, bạn sẽ thấy các phần tử theo thứ tự được xác định
• Khi lặp lại, bạn thấy các phần tử theo thứ tự ngược lại

Tôi hy vọng điều này sẽ làm sáng tỏ bất kỳ sự nhầm lẫn.

Điều này có được đảm bảo để in 234 hoặc thực hiện được xác định không?

Có, std::maplà một container được sắp xếp , được sắp xếp theo thứ tự được Keycung cấp Comparator. Vì vậy, nó được đảm bảo.

Tôi muốn đi lặp lại qua tất cả các yếu tố, với khóa, lớn hơn một giá trị int cụ thể.

Điều đó là chắc chắn có thể.

Có ... các phần tử trong một std::mapthứ tự yếu nghiêm ngặt, nghĩa là các phần tử sẽ được tạo thành từ một tập hợp (nghĩa là sẽ không có sự lặp lại của các khóa "bằng nhau") và tính bằng nhau được xác định bằng cách kiểm tra trên bất kỳ hai khóa A và B, nếu khóa A không nhỏ hơn khóa B và B không nhỏ hơn A, thì khóa A bằng với khóa B.

Điều đó đang được nói, bạn không thể sắp xếp chính xác các yếu tố của a std::mapnếu thứ tự yếu cho loại đó không rõ ràng (trong trường hợp của bạn, trong đó bạn đang sử dụng số nguyên làm loại khóa, đó không phải là vấn đề). Bạn phải có thể xác định một thao tác xác định tổng thứ tự cho loại bạn đang sử dụng cho các khóa trong std::map, nếu không, bạn sẽ chỉ có một phần thứ tự cho các phần tử của bạn, hoặc poset, có thuộc tính mà A không thể so sánh được với B. Điều thường xảy ra trong kịch bản này là bạn sẽ có thể chèn các cặp khóa / giá trị, nhưng bạn có thể kết thúc bằng các cặp khóa / giá trị trùng lặp nếu bạn lặp qua toàn bộ bản đồ và / hoặc phát hiện "mất tích" cặp khóa / giá trị khi bạn cố gắng thực hiện một std::map::find()cặp khóa / giá trị cụ thể trong bản đồ.

started () có thể cho phần tử nhỏ nhất. Nhưng đó là thực hiện phụ thuộc. Được chỉ định trong tiêu chuẩn C ++? Nếu không, thì thật nguy hiểm khi đưa ra giả định này.