Doc. no. | N3011=09-0201
Date: | 2009-11-08
Project: | Programming Language C++
Reply to: | Howard Hinnant <howard.hinnant@gmail.com>

# C++ Standard Library Active Issues List (Revision R68)

Reference ISO/IEC IS 14882:2003(E)

Also see:

- Table of Contents for all library issues.
- Index by Section for all library issues.
- Index by Status for all library issues.
- Library Defect Reports List
- Library Closed Issues List

The purpose of this document is to record the status of issues which have come before the Library Working Group (LWG) of the ANSI (J16) and ISO (WG21) C++ Standards Committee. Issues represent potential defects in the ISO/IEC IS 14882:2003(E) document.

This document contains only library issues which are actively being considered by the Library Working Group, i.e., issues which have a status of New, Open, Ready, or Review. See Library Defect Reports List for issues considered defects and Library Closed Issues List for issues considered closed.

The issues in these lists are not necessarily formal ISO Defect Reports (DR's). While some issues will eventually be elevated to official Defect Report status, other issues will be disposed of in other ways. See Issue Status.

Prior to Revision 14, library issues lists existed in two slightly different versions; a Committee Version and a Public Version. Beginning with Revision 14 the two versions were combined into a single version.

This document includes [bracketed italicized notes] as a reminder to the LWG of current progress on issues. Such notes are strictly unofficial and should be read with caution as they may be incomplete or incorrect. Be aware that LWG support for a particular resolution can quickly change if new viewpoints or killer examples are presented in subsequent discussions.

For the most current official version of this document see http://www.open-std.org/jtc1/sc22/wg21/. Requests for further information about this document should include the document number above, reference ISO/IEC 14882:2003(E), and be submitted to Information Technology Industry Council (ITI), 1250 Eye Street NW, Washington, DC 20005.

Public information as to how to obtain a copy of the C++ Standard, join the standards committee, submit an issue, or comment on an issue can be found in the comp.std.c++ FAQ.

How to submit an issue

1. Mail your issue to the author of this list.
2. Specify a short descriptive title. If you fail to do so, the subject line of your mail will be used as the issue title.
3. If the "From" on your email is not the name you wish to appear as issue submitter, then specify issue submitter.
4. Provide a brief discussion of the problem you wish to correct. Refer to the latest working draft or standard using [section.tag] and paragraph numbers where appropriate.
5. Provide proposed wording. This should indicate exactly how you want the standard to be changed. General solution statements belong in the discussion area. This area contains very clear and specific directions on how to modify the current draft. If you are not sure how to word a solution, you may omit this part. But your chances of a successful issue greatly increase if you attempt wording.
6. It is not necessary for you to use html markup. However, if you want to, you can <ins>insert text like this</ins> and <del>delete text like this</del>. The only strict requirement is to communicate clearly to the list maintainer exactly how you want your issue to look.
7. It is not necessary for you to specify other html font/formatting mark-up, but if you do the list maintainer will attempt to respect your formatting wishes (as described by html markup, or other common idioms).
8. It is not necessary for you to specify open date or last modified date (the date of your mail will be used).
9. It is not necessary for you to cross reference other issues, but you can if you like. You do not need to form the hyperlinks when you do, the list maintainer will take care of that.
10. One issue per email is best.
11. Between the time you submit the issue, and the next mailing deadline (date at the top of the Revision History), you own this issue. You control the content, the stuff that is right, the stuff that is wrong, the format, the misspellings, etc. You can even make the issue disappear if you want. Just let the list maintainer know how you want it to look, and he will try his best to accommodate you. After the issue appears in an official mailing, you no longer enjoy exclusive ownership of it.

## Revision History

- R68: 2009-11-06 post-Santa Cruz mailing.
  - Summary:
    - 205 open issues, down by 77.
    - 1055 closed issues, up by 120.
    - 1260 issues total, up by 43.
  - Details:
    - Added the following Dup issues: 1230.
    - Added the following NAD issues: 1229, 1236, 1243.
    - Added the following NAD Editorial issues: 1232.
    - Added the following NAD Future issues: 1235, 1242, 1248.
    - Added the following New issues: 1218, 1219, 1221, 1222, 1223, 1224, 1225, 1234, 1240, 1244, 1245, 1246, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260.
    - Added the following Open issues: 1228.
    - Added the following Ready issues: 1227, 1237.
    - Added the following Review issues: 1247.
    - Added the following Tentatively NAD Editorial issues: 1233, 1239.
    - Added the following Tentatively NAD Future issues: 1238.
    - Added the following Tentatively Ready issues: 1220, 1226, 1231, 1241.
    - Changed the following issues from New to NAD: 1132, 1148.
    - Changed the following issues from Open to NAD: 96, 458, 463, 916, 917, 919, 955, 977, 1009, 1020, 1035, 1042, 1051, 1064.
    - Changed the following issues from Review to NAD: 668, 930, 1091, 1102.
    - Changed the following issues from Tentatively NAD to NAD: 588, 617, 971.
    - Changed the following issues from Tentatively NAD Future to NAD: 1062.
    - Changed the following issues from NAD Concepts to NAD Editorial: 1143.
    - Changed the following issues from New to NAD Editorial: 1116, 1117, 1122, 1129, 1145, 1146, 1147, 1155, 1166, 1172, 1174, 1179, 1195, 1196.
    - Changed the following issues from Open to NAD Editorial: 431, 580, 635, 719, 823, 827, 879, 880, 908, 923, 924, 926, 944, 947, 958, 1046, 1048, 1054, 1055, 1075, 1088, 1160, 1161, 1162, 1163, 1165.
    - Changed the following issues from Review to NAD Editorial: 828, 897, 976, 1043, 1047, 1049, 1050.
    - Changed the following issues from New to NAD Future: 1120, 1150, 1184, 1203, 1217.
    - Changed the following issues from Open to NAD Future: 484, 532, 851, 933, 935, 936, 961, 1041, 1053.
    - Changed the following issues from Tentatively NAD Future to NAD Future: 1031.
    - Changed the following issues from New to Open: 1118, 1119, 1151, 1153, 1156, 1171, 1173, 1183, 1191, 1211.
    - Changed the following issues from Ready to Open: 430, 834.
    - Changed the following issues from Review to Open: 397, 408, 835.
    - Changed the following issues from Tentatively NAD to Open: 625.
    - Changed the following issues from New to Ready: 1123, 1134, 1135, 1136, 1144, 1177, 1194, 1204, 1216.
    - Changed the following issues from Open to Ready: 296, 471, 485, 539, 816, 860, 865, 872, 920, 932, 939, 940, 960, 963, 974, 978, 1011, 1030, 1079, 1098.
    - Changed the following issues from Review to Ready: 473, 671, 836, 854, 868, 871, 889, 893, 921, 950, 954, 957, 962, 967, 968, 983, 1052, 1094, 1095, 1097, 1100, 1104, 1157.
    - Changed the following issues from New to Review: 1130.
    - Changed the following issues from Open to Review: 556, 631, 676, 727, 929.
    - Changed the following issues from Open to Tentatively NAD: 1056, 1099.
    - Changed the following issues from New to Tentatively NAD Concepts: 1186.
    - Changed the following issues from New to Tentatively NAD Editorial: 1115.
    - Changed the following issues from New to Tentatively NAD Future: 1121, 1201.
    - Changed the following issues from Open to Tentatively NAD Future: 1112.
    - Changed the following issues from New to Tentatively Ready: 1126, 1138, 1152, 1158, 1189, 1192, 1208.
    - Changed the following issues from Open to Tentatively Ready: 987, 999, 1071, 1090, 1108, 1113, 1114.
    - Changed the following issues from Ready to WP: 149, 419, 498, 564, 565, 630, 659, 696, 711, 716, 723, 788, 822, 838, 847, 857, 859, 876, 881, 883, 886, 934, 1004, 1178.
    - Changed the following issues from Tentatively Ready to WP: 1012, 1019.
- R67: 2009-09-25 pre-Santa Cruz mailing.
  - Summary:
    - 282 open issues, up by 32.
    - 935 closed issues, down by 1.
    - 1217 issues total, up by 31.
  - Details:
    - Added the following New issues: 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217.
    - Changed the following issues from NAD to Open: 296.
    - Changed the following issues from WP to Pending WP: 970.
    - Changed the following issues from Open to Review: 976, 1052.
    - Changed the following issues from Ready to Review: 780.
- R66: 2009-07-31 post-Frankfurt mailing.
  - Summary:
    - 250 open issues, down by 128.
    - 936 closed issues, up by 171.
    - 1186 issues total, up by 43.
  - Details:
    - Added the following NAD issues: 1164.
    - Added the following NAD Concepts issues: 1149, 1167.
    - Added the following NAD Editorial issues: 1168.
    - Added the following New issues: 1144, 1145, 1146, 1147, 1148, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1158, 1159, 1166, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186.
    - Added the following Open issues: 1160, 1161, 1162, 1163, 1165.
    - Added the following Ready issues: 1178.
    - Added the following Review issues: 1157.
    - Changed the following issues from Open to Dup: 750, 895.
    - Changed the following issues from Open to NAD: 111, 128, 138, 190, 219, 290, 309, 342, 343, 382, 394, 398, 417, 418, 421, 459, 466, 492, 502, 503, 546, 573, 582, 585, 597, 606, 614, 632, 721, 747, 751, 833, 941, 992.
    - Changed the following issues from Review to NAD: 1003.
    - Changed the following issues from Tentatively NAD to NAD: 568, 644, 667, 669, 701, 702, 785, 863, 901, 903, 946, 988, 995.
    - Changed the following issues from Tentatively Ready to NAD: 1002.
    - Changed the following issues from New to NAD Concepts: 1124, 1127, 1128, 1139, 1140, 1141, 1142, 1143.
    - Changed the following issues from Open to NAD Concepts: 902, 989, 1000, 1007, 1010, 1015, 1016, 1017, 1018, 1026, 1027, 1028, 1029, 1032, 1036, 1057, 1059, 1072, 1078, 1081, 1082, 1083, 1084, 1085, 1086, 1092, 1096, 1105.
    - Changed the following issues from Review to NAD Concepts: 1001, 1005, 1080, 1087, 1111.
    - Changed the following issues from Tentatively NAD to NAD Concepts: 912, 918, 1074.
    - Changed the following issues from Tentatively NAD Editorial to NAD Concepts: 927, 1109.
    - Changed the following issues from Tentatively Ready to NAD Concepts: 906, 913, 914, 928, 1024, 1063, 1067.
    - Changed the following issues from Open to NAD Editorial: 718, 873.
    - Changed the following issues from Tentatively NAD Editorial to NAD Editorial: 424, 825, 830, 837, 862, 867, 884, 945, 952, 969, 972, 973, 979, 1023, 1058, 1060, 1061, 1077, 1101.
    - Changed the following issues from Tentatively Ready to NAD Editorial: 1013, 1107.
    - Changed the following issues from Open to NAD Future: 255, 423, 523, 708, 760, 839, 877.
    - Changed the following issues from CD1 to Open: 823.
    - Changed the following issues from NAD Editorial to Open: 299, 484, 532, 556, 594, 631, 676, 704, 724, 742, 811, 870, 872.
    - Changed the following issues from Review to Open: 879, 919, 929, 939, 987, 1009, 1093.
    - Changed the following issues from Tentatively NAD to Open: 458.
    - Changed the following issues from Tentatively NAD Future to Open: 96.
    - Changed the following issues from Tentatively Ready to Open: 910, 915, 932, 940, 974, 976, 999, 1011.
    - Changed the following issues from Open to Ready: 149, 419, 430, 498, 564, 565, 630, 659, 696, 711, 716, 723, 788, 834, 838, 847, 857, 859, 876, 881, 883, 886, 1004.
    - Changed the following issues from Review to Ready: 780.
    - Changed the following issues from Tentatively NAD to Ready: 822.
    - Changed the following issues from Tentatively Ready to Ready: 934.
    - Changed the following issues from NAD to Review: 871.
    - Changed the following issues from Open to Review: 397, 408, 473, 671, 836, 868, 889, 893, 930, 954, 962, 967, 968.
    - Changed the following issues from Tentatively NAD to Review: 668.
    - Changed the following issues from Tentatively Ready to Review: 950, 1100.
    - Changed the following issues from Open to Tentatively NAD: 588, 617, 625, 971.
    - Changed the following issues from Open to Tentatively NAD Future: 1031, 1062.
    - Changed the following issues from Open to Tentatively Ready: 1012, 1019.
    - Changed the following issues from Tentatively Ready to WP: 688, 765, 810, 814, 853, 869, 878, 888, 890, 898, 899, 904, 907, 909, 922, 925, 931, 938, 943, 948, 949, 965, 970, 975, 981, 982, 984, 986, 990, 991, 993, 994, 997, 998, 1006, 1014, 1021, 1037, 1038, 1039, 1040, 1044, 1045, 1065, 1066, 1070, 1073, 1103.
- R65: 2009-06-19 pre-Frankfurt mailing.
  - Summary:
    - 378 open issues, up by 32.
    - 765 closed issues, up by 0.
    - 1143 issues total, up by 32.
  - Details:
    - Added the following New issues: 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143.
    - Added the following Open issues: 1112, 1113, 1114.
    - Changed the following issues from Pending NAD Editorial to NAD Editorial: 937.
    - Changed the following issues from New to Open: 696, 716, 727, 865, 900, 911, 916, 917, 920, 933, 935, 941, 947, 951, 953, 954, 955, 956, 977, 978, 985, 989, 996, 1033, 1054, 1056, 1057, 1059, 1062, 1068, 1069, 1071, 1072, 1076, 1090, 1092, 1096, 1098, 1099, 1105, 1106, 1108, 1110.
    - Changed the following issues from Review to Open: 817, 971, 992, 1004, 1010, 1012, 1015, 1019.
    - Changed the following issues from New to Review: 780, 835, 897, 919, 939, 957, 983, 1001, 1080, 1091, 1093, 1094, 1095, 1097, 1102, 1104, 1111.
    - Changed the following issues from Open to Review: 921, 987, 1087.
    - Changed the following issues from New to Tentatively NAD: 568, 701, 702, 785, 863, 903, 912, 918, 946, 995, 1074.
    - Changed the following issues from Open to Tentatively NAD: 458, 644, 667, 668, 669.
    - Changed the following issues from Review to Tentatively NAD: 901.
    - Changed the following issues from Tentatively Ready to Tentatively NAD: 822, 988.
    - Changed the following issues from New to Tentatively NAD Editorial: 837, 862, 867, 927, 945, 952, 969, 972, 973, 979, 1058, 1060, 1061, 1077, 1101, 1109.
    - Changed the following issues from Open to Tentatively NAD Editorial: 424, 825, 830, 884.
    - Changed the following issues from Review to Tentatively NAD Editorial: 1023.
    - Changed the following issues from Open to Tentatively NAD Future: 96.
    - Changed the following issues from New to Tentatively Ready: 810, 898, 906, 910, 913, 914, 915, 925, 974, 976, 981, 982, 984, 990, 998, 999, 1063, 1067, 1070, 1073, 1100, 1103, 1107.
    - Changed the following issues from Open to Tentatively Ready: 688, 814.
    - Changed the following issues from Review to Tentatively Ready: 899, 907, 909, 934, 938, 940, 943, 950, 965, 970, 975, 986, 991, 993, 994, 997, 1002, 1006, 1011, 1013, 1014, 1021, 1024, 1037, 1038, 1039, 1040, 1044, 1045, 1065, 1066.
- R64: 2009-05-01 mid-term mailing.
  - Summary:
    - 346 open issues, up by 19.
    - 765 closed issues, up by 0.
    - 1111 issues total, up by 19.
  - Details:
    - Added the following New issues: 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111.
    - Changed the following issues from DR to CD1: 130, 386, 406, 409, 413, 434, 438, 444, 445, 455, 457, 460, 469, 533.
    - Changed the following issues from Review to New: 1070.
- R63: 2009-03-20 post-Summit mailing.
  - Summary:
    - 327 open issues, up by 96.
    - 765 closed issues, up by 14.
    - 1092 issues total, up by 110.
  - Details:
    - Added the following NAD Editorial issues: 1022.
    - Added the following NAD Future issues: 1025.
    - Added the following New issues: 983, 984, 985, 989, 990, 995, 996, 998, 999, 1001, 1033, 1054, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1067, 1068, 1069, 1071, 1072, 1073, 1074, 1076, 1077, 1080, 1090, 1091, 1092.
    - Added the following Open issues: 987, 1000, 1007, 1008, 1016, 1017, 1018, 1020, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1034, 1035, 1036, 1041, 1042, 1046, 1048, 1051, 1052, 1053, 1055, 1064, 1075, 1078, 1079, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089.
    - Added the following Review issues: 986, 991, 992, 993, 994, 997, 1002, 1003, 1004, 1005, 1006, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1019, 1021, 1023, 1024, 1037, 1038, 1039, 1040, 1043, 1044, 1045, 1047, 1049, 1050, 1065, 1066, 1070.
    - Added the following Tentatively Ready issues: 988.
    - Changed the following issues from New to Dup: 905, 942.
    - Changed the following issues from New to NAD: 980.
    - Changed the following issues from New to NAD Editorial: 874, 875.
    - Changed the following issues from Open to NAD Editorial: 732, 793, 794, 800.
    - Changed the following issues from Pending NAD Editorial to NAD Editorial: 683, 892.
    - Changed the following issues from Ready to NAD Editorial: 803.
    - Changed the following issues from NAD to Open: 466.
    - Changed the following issues from NAD Future to Open: 111, 138, 149, 219.
    - Changed the following issues from New to Open: 880, 891, 893, 902, 908, 921, 923, 924, 926, 930, 936, 944, 958, 959, 960, 961, 962, 963, 964, 966, 967, 968.
    - Changed the following issues from Ready to Open: 788.
    - Changed the following issues from New to Pending NAD Editorial: 937.
    - Changed the following issues from New to Review: 879, 899, 901, 907, 909, 929, 934, 938, 940, 943, 950, 965, 970, 971, 975.
    - Changed the following issues from Open to Review: 817.
    - Changed the following issues from New to Tentatively Ready: 904, 922, 928, 931, 932, 948, 949.
    - Changed the following issues from Open to Tentatively Ready: 890.
    - Changed the following issues from Review to Tentatively Ready: 765, 822, 853, 869, 878, 888.
    - Changed the following issues from Ready to WP: 752, 753, 758, 821, 866, 894.
- R62: 2009-02-06 pre-Summit mailing.
  - Summary:
    - 231 open issues, up by 44.
    - 751 closed issues, up by 0.
    - 982 issues total, up by 44.
  - Details:
    - Added the following New issues: 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982.
- R61: 2008-12-05 mid-term mailing.
  - Summary:
    - 187 open issues, up by 20.
    - 751 closed issues, up by 0.
    - 938 issues total, up by 20.
  - Details:
    - Added the following New issues: 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938.
- R60: 2008-10-03 post-San Francisco mailing.
  - Summary:
    - 167 open issues, down by 25.
    - 751 closed issues, up by 65.
    - 918 issues total, up by 40.
  - Details:
    - Added the following CD1 issues: 882.
    - Added the following New issues: 879, 880, 891, 893, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918.
    - Added the following Open issues: 881, 883, 884, 885, 886, 887, 889, 890, 895, 896.
    - Added the following Pending NAD Editorial issues: 892.
    - Added the following Ready issues: 894.
    - Added the following Review issues: 888.
    - Changed the following issues from New to CD1: 818, 820, 843, 845, 846, 856, 858.
    - Changed the following issues from Ready to CD1: 180, 387, 396, 522, 629, 691, 713, 714, 720, 728, 762, 769, 771, 772, 776, 779, 787, 805, 806, 807, 808, 809, 813, 824, 829, 842, 844, 848, 850, 852.
    - Changed the following issues from Review to CD1: 23, 675, 692, 698, 709, 734, 804, 823.
    - Changed the following issues from WP to CD1: 44, 49, 76, 91, 92, 98, 103, 109, 117, 118, 120, 123, 136, 153, 165, 167, 171, 179, 182, 183, 184, 185, 186, 187, 198, 200, 201, 202, 206, 214, 221, 225, 226, 228, 229, 230, 231, 232, 233, 234, 235, 237, 238, 239, 240, 241, 242, 243, 247, 248, 250, 251, 252, 253, 254, 256, 258, 259, 260, 261, 262, 263, 264, 265, 266, 268, 270, 271, 272, 273, 274, 275, 276, 278, 280, 281, 282, 283, 284, 285, 286, 288, 291, 292, 294, 295, 297, 298, 300, 301, 303, 305, 306, 307, 308, 310, 311, 312, 315, 316, 317, 318, 319, 320, 321, 322, 324, 325, 327, 328, 329, 331, 333, 334, 335, 336, 337, 338, 339, 340, 341, 345, 346, 347, 349, 352, 354, 355, 358, 359, 360, 362, 363, 364, 365, 369, 370, 371, 373, 375, 376, 379, 380, 381, 383, 384, 389, 391, 395, 400, 401, 402, 403, 404, 405, 407, 410, 411, 412, 414, 415, 416, 420, 422, 425, 426, 428, 432, 435, 436, 441, 442, 443, 448, 449, 453, 456, 461, 464, 465, 467, 468, 474, 475, 478, 488, 495, 496, 497, 505, 507, 508, 518, 519, 520, 521, 524, 527, 530, 531, 534, 535, 537, 538, 540, 541, 542, 543, 545, 550, 551, 552, 559, 561, 562, 563, 566, 567, 574, 575, 576, 577, 578, 581, 586, 589, 593, 595, 596, 607, 608, 609, 610, 611, 612, 613, 616, 618, 619, 620, 621, 622, 623, 624, 628, 634, 638, 640, 643, 646, 650, 651, 652, 654, 655, 660, 661, 664, 665, 666, 672, 673, 674, 677, 678, 679, 680, 681, 682, 685, 687, 689, 693, 694, 695, 699, 700, 703, 705, 706, 710, 712, 715, 722, 740, 743, 744, 746, 749, 755, 759, 761, 766, 768, 770, 775, 777, 778, 781, 782, 783, 789, 792, 798.
    - Changed the following issues from Open to Dup: 670.
    - Changed the following issues from New to NAD: 849, 855, 871.
    - Changed the following issues from Open to NAD: 454, 832.
    - Changed the following issues from New to NAD Editorial: 811, 812, 841, 864, 870, 872.
    - Changed the following issues from Open to NAD Editorial: 299, 484, 556, 631, 676, 704, 724, 742.
    - Changed the following issues from Pending NAD Editorial to NAD Editorial: 532, 594, 717, 725, 738.
    - Changed the following issues from New to Open: 721, 751, 814, 816, 817, 819, 827, 836, 838, 847, 857, 859, 860, 861, 868, 873, 876, 877.
    - Changed the following issues from Pending NAD Editorial to Open: 424, 625.
    - Changed the following issues from Review to Open: 851.
    - Changed the following issues from New to Ready: 788, 821, 866.
    - Changed the following issues from Open to Ready: 753.
    - Changed the following issues from Review to Ready: 752, 758, 803.
    - Changed the following issues from New to Review: 765, 822, 853, 854, 869, 878.
    - Changed the following issues from TC to TC1: 1, 3, 5, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 46, 47, 48, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 62, 63, 64, 66, 68, 69, 70, 71, 74, 75, 78, 79, 80, 83, 86, 90, 106, 108, 110, 112, 114, 115, 119, 122, 124, 125, 126, 127, 129, 132, 133, 134, 137, 139, 141, 142, 144, 146, 147, 148, 150, 151, 152, 154, 155, 156, 158, 159, 160, 161, 164, 168, 169, 170, 172, 173, 174, 175, 176, 181, 189, 193, 195, 199, 208, 209, 210, 211, 212, 217, 220, 222, 223, 224, 227.
- R59: 2008-08-22 pre-San Francisco mailing.
  - Summary:
    - 192 open issues, up by 9.
    - 686 closed issues, up by 0.
    - 878 issues total, up by 9.
  - Details:
    - Added the following New issues: 870, 871, 872, 873, 874, 875, 876, 877, 878.
- R58: 2008-07-28 mid-term mailing.
  - Summary:
    - 183 open issues, up by 12.
    - 686 closed issues, down by 4.
    - 869 issues total, up by 8.
  - Details:
    - Added the following New issues: 862, 863, 864, 865, 866, 867, 868, 869.
    - Changed the following issues from Pending NAD Editorial to NAD Editorial: 393, 557, 592, 754, 757.
    - Changed the following issues from Pending WP to Open: 644.
    - Changed the following issues from WP to Ready: 387, 629.
    - Changed the following issues from Pending NAD Editorial to Review: 709.
- R57: 2008-06-27 post-Sophia Antipolis mailing.
  - Summary:
    - 171 open issues, down by 20.
    - 690 closed issues, up by 43.
    - 861 issues total, up by 23.
  - Details:
    - Added the following NAD issues: 840.
    - Added the following New issues: 841, 843, 845, 846, 847, 849, 853, 854, 855, 856, 857, 858, 859, 860, 861.
    - Added the following Open issues: 839.
    - Added the following Ready issues: 842, 844, 848, 850, 852.
    - Added the following Review issues: 851.
    - Changed the following issues from New to NAD: 826.
    - Changed the following issues from Open to NAD: 570.
    - Changed the following issues from New to NAD Editorial: 786, 831.
    - Changed the following issues from Open to NAD Editorial: 756, 767.
    - Changed the following issues from New to Open: 723, 726, 794, 815, 825, 830, 833, 834.
    - Changed the following issues from Ready to Open: 471.
    - Changed the following issues from Review to Open: 539, 711.
    - Changed the following issues from New to Ready: 713, 714, 769, 772, 779, 787, 805, 806, 807, 808, 809, 813, 824, 829.
    - Changed the following issues from Open to Ready: 180, 396, 522, 720, 762.
    - Changed the following issues from Review to Ready: 691, 728, 771, 776.
    - Changed the following issues from New to Review: 692, 698, 752, 804, 823, 828, 832.
    - Changed the following issues from Open to Review: 23, 675, 734, 803.
    - Changed the following issues from Ready to Review: 758.
    - Changed the following issues from Ready to WP: 387, 518, 550, 574, 595, 596, 612, 618, 629, 638, 672, 673, 685, 710, 715, 722, 740, 743, 744, 746, 749, 755, 759, 761, 766, 768, 770, 775, 777, 778, 781, 782, 783, 789, 792, 798.
- R56: 2008-05-16 pre-Sophia Antipolis mailing.
  - Summary:
    - 191 open issues, up by 24.
    - 647 closed issues, up by 1.
    - 838 issues total, up by 25.
  - Details:
    - Added the following New issues: 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838.
    - Changed the following issues from New to NAD: 802.
- R55: 2008-03-14 post-Bellevue mailing.
  - Summary:
    - 167 open issues, down by 39.
    - 646 closed issues, up by 65.
    - 813 issues total, up by 26.
  - Details:
    - Added the following Dup issues: 795.
    - Added the following NAD issues: 790, 791, 796, 797, 799.
    - Added the following New issues: 788, 794, 802, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813.
    - Added the following Open issues: 793, 800, 801, 803.
    - Added the following Ready issues: 789, 792, 798.
    - Changed the following issues from NAD Future to Dup: 116.
    - Changed the following issues from NAD Future to NAD: 188, 323.
    - Changed the following issues from New to NAD: 729, 730, 731, 733, 735, 736, 737, 739, 741, 745, 748, 763, 764, 773, 784.
    - Changed the following issues from Open to NAD: 388, 462, 579, 627, 653, 686, 707.
    - Changed the following issues from NAD Future to NAD Editorial: 140, 390.
    - Changed the following issues from Open to NAD Editorial: 529, 626.
    - Changed the following issues from Review to NAD Editorial: 645, 684.
    - Changed the following issues from NAD Future to Open: 128, 180, 190.
    - Changed the following issues from New to Open: 617, 718, 719, 720, 724, 732, 734, 742, 747, 750, 753, 756, 760, 762, 767, 774.
    - Changed the following issues from Ready to Open: 675, 676, 688.
    - Changed the following issues from New to Pending NAD Editorial: 709, 717, 725, 738, 754, 757.
    - Changed the following issues from Open to Pending NAD Editorial: 424, 557, 625.
    - Changed the following issues from New to Ready: 710, 715, 722, 740, 743, 744, 746, 749, 755, 758, 759, 761, 766, 768, 770, 775, 777, 778, 781, 782, 783.
    - Changed the following issues from Open to Ready: 387, 471, 550, 612, 629, 673.
    - Changed the following issues from Review to Ready: 518, 574, 596, 618, 638, 672, 685.
    - Changed the following issues from New to Review: 711, 728, 771, 776.
    - Changed the following issues from Open to Review: 539.
    - Changed the following issues from Ready to WP: 561, 562, 563, 567, 581, 620, 621, 622, 623, 624, 661, 664, 665, 666, 674, 679, 680, 687, 689, 693, 694, 695, 700, 703, 705, 706.
    - Changed the following issues from Tentatively Ready to WP: 527.
- R54: 2008-02-01 pre-Bellevue mailing.
  - Summary:
    - 206 open issues, up by 23.
    - 581 closed issues, up by 0.
    - 787 issues total, up by 23.
  - Details:
    - Added the following New issues: 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787.
    - Changed the following issues from NAD Future to Dup: 105, 348.
    - Changed the following issues from NAD Future to NAD Editorial: 353.
    - Changed the following issues from New to NAD Editorial: 697.
    - Changed the following issues from NAD Future to Open: 388.
    - Changed the following issues from Open to Tentatively Ready: 527.
- R53: 2007-12-09 mid-term mailing.
  - Summary:
    - 183 open issues, up by 11.
    - 581 closed issues, down by 1.
    - 764 issues total, up by 10.
  - Details:
    - Added the following New issues: 755, 756, 757, 758, 759, 760, 761, 762, 763, 764.
    - Changed the following issues from NAD to Open: 463.
    - Changed the following issues from Pending WP to WP: 607, 608, 654, 655, 677, 682.
- R52: 2007-10-19 post-Kona mailing.
  - Summary:
    - 172 open issues, up by 4.
    - 582 closed issues, up by 27.
    - 754 issues total, up by 31.
  - Details:
    - Added the following New issues: 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754.
    - Changed the following issues from NAD Future to Dup: 77, 350.
    - Changed the following issues from New to NAD: 639, 657, 663.
    - Changed the following issues from Open to NAD: 548.
    - Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
    - Changed the following issues from New to Pending NAD Editorial: 393, 592.
    - Changed the following issues from New to Pending WP: 607, 608, 654, 655, 677, 682.
    - Changed the following issues from New to Ready: 561, 562, 563, 567, 581, 595, 620, 621, 622, 623, 624, 661, 664, 665, 666, 674, 675, 676, 679, 687, 688, 689, 693, 694, 695, 700, 703, 705, 706.
    - Changed the following issues from Open to Ready: 680.
    - Changed the following issues from New to Review: 574, 596, 618, 638, 645, 672, 684, 685, 691.
    - Changed the following issues from New to WP: 552, 634, 650, 651, 652, 678, 681, 699, 712.
    - Changed the following issues from Open to WP: 258, 401, 524.
    - Changed the following issues from Ready to WP: 488, 577, 660.
- R51: 2007-09-09 pre-Kona mailing.
  - Summary:
    - 168 open issues, up by 15.
    - 555 closed issues, up by 0.
    - 723 issues total, up by 15.
  - Details:
    - Added the following New issues: 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723.
- R50: 2007-08-05 post-Toronto mailing.
  - Summary:
    - 153 open issues, down by 5.
    - 555 closed issues, up by 17.
    - 708 issues total, up by 12.
  - Details:
    - Added the following New issues: 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708.
    - Changed the following issues from New to NAD: 583, 584, 662.
    - Changed the following issues from Open to NAD: 528.
    - Changed the following issues from New to NAD Editorial: 637, 647, 658, 690.
    - Changed the following issues from Open to NAD Editorial: 525.
    - Changed the following issues from Pending NAD Editorial to NAD Editorial: 553, 571, 591, 633, 636, 641, 642, 648, 649, 656.
    - Changed the following issues from New to Open: 579, 631, 680.
    - Changed the following issues from Pending WP to Open: 258.
    - Changed the following issues from Ready to Pending WP: 644.
    - Changed the following issues from New to Ready: 577, 660.
    - Changed the following issues from Open to Ready: 488.
    - Changed the following issues from Open to Review: 518.
    - Changed the following issues from Ready to TRDec: 604.
    - Changed the following issues from DR to WP: 453.
    - Changed the following issues from Ready to WP: 531, 551, 566, 628, 640, 643, 646.
- R49: 2007-06-23 pre-Toronto mailing.
  - Summary:
    - 158 open issues, up by 13.
    - 538 closed issues, up by 7.
    - 696 issues total, up by 20.
  - Details:
    - Added the following New issues: 677, 678, 679, 680, 681, 682, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696.
    - Added the following Pending NAD Editorial issues: 683.
    - Changed the following issues from New to NAD Editorial: 587.
    - Changed the following issues from Open to NAD Editorial: 590.
    - Changed the following issues from New to Pending NAD Editorial: 636, 642, 648, 649.
- R48: 2007-05-06 post-Oxford mailing.
  - Summary:
    - 145 open issues, down by 33.
    - 531 closed issues, up by 53.
    - 676 issues total, up by 20.
  - Details:
    - Added the following New issues: 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676.
    - Changed the following issues from Tentatively Ready to Dup: 479, 536.
    - Changed the following issues from Tentatively Ready to NAD: 385, 463, 466, 470, 515, 526, 547, 560, 572.
    - Changed the following issues from NAD to NAD Editorial: 351, 357, 368, 499, 504, 512, 513, 514, 516, 544, 549, 555, 558.
    - Changed the following issues from Tentatively Ready to NAD Editorial: 482, 615.
    - Changed the following issues from NAD_Future to NAD Future: 77, 105, 111, 116, 128, 138, 140, 149, 180, 188, 190, 219, 323, 348, 350, 353, 388, 390.
    - Changed the following issues from Tentatively Ready to Open: 471.
    - Changed the following issues from New to Pending NAD Editorial: 633, 641, 656.
    - Changed the following issues from Tentatively Ready to Pending NAD Editorial: 532, 553, 571, 591, 594.
    - Changed the following issues from Tentatively Ready to Pending WP: 258.
    - Changed the following issues from New to Ready: 566, 628, 640, 643, 644, 646.
    - Changed the following issues from Review to Ready: 531, 551, 604.
    - Changed the following issues from Ready to TRDec: 598, 599, 600, 601, 602, 603, 605.
    - Changed the following issues from Ready to WP: 543, 545.
    - Changed the following issues from Tentatively Ready to WP: 201, 206, 233, 254, 416, 422, 456, 534, 542, 559, 575, 576, 578, 586, 589, 593, 609, 610, 611, 613, 616, 619.
- R47: 2007-03-09 pre-Oxford mailing.
  - Summary:
    - 178 open issues, up by 37.
    - 478 closed issues, up by 0.
    - 656 issues total, up by 37.
  - Details:
    - Added the following New issues: 620, 621, 622, 623, 624, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656.
    - Added the following Open issues: 625, 626.
    - Changed the following issues from New to Open: 570, 580, 582, 590, 612, 614.
    - Changed the following issues from New to Tentatively Ready: 547, 553, 560, 571, 572, 575, 576, 578, 586, 589, 591, 593, 594, 609, 610, 611, 613, 615, 616, 619.
    - Changed the following issues from Open to Tentatively Ready: 201, 206, 233, 254, 258, 385, 416, 422, 456, 463, 466, 470, 471, 479, 482, 515, 526, 532, 536, 542, 559.
    - Changed the following issues from Review to Tentatively Ready: 534.
- R46: 2007-01-12 mid-term mailing.
  - Summary:
    - 141 open issues, up by 11.
    - 478 closed issues, down by 1.
    - 619 issues total, up by 10.
  - Details:
    - Added new issues 610, 611, 612, 613, 614, 615, 616, 617, 618, 619.
- R45: 2006-11-03 post-Portland mailing.
  - Summary:
    - 130 open issues, up by 0.
    - 479 closed issues, up by 17.
    - 609 issues total, up by 17.
  - Details:
    - Moved issues 520, 521, 530, 535, 537, 538, 540, 541 to WP.
    - Moved issues 504, 512, 516, 544, 549, 554, 555, 558 to NAD.
    - Moved issue 569 to Dup.
    - Moved issues 518, 523, 524, 542, 556, 557, 559, 597, 606 to Open.
    - Moved issues 543, 545, 549, 549, 598 - 603, 605 to Ready.
    - Moved issues 531, 551, 604 to Review.
    - Added new issues 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609.
- R44: 2006-09-08 pre-Portland mailing.
  - Summary:
    - 130 open issues, up by 6.
    - 462 closed issues, down by 1.
    - 592 issues total, up by 5.
  - Details:
    - Added new issues 583, 584, 585, 586, 587, 588, 589, 590, 591, 592.
- R43: 2006-06-23 mid-term mailing.
  - Summary:
    - 124 open issues, up by 14.
    - 463 closed issues, down by 1.
    - 587 issues total, up by 13.
  - Details:
    - Added new issues 575, 576, 577, 578, 579, 580, 581, 582.
    - Reopened 255.
    - Moved issues 520, 541, 544, 569 to Tentatively Ready.
- R42: 2006-04-21 post-Berlin mailing.
  - Summary:
    - 110 open issues, down by 16.
    - 464 closed issues, up by 24.
    - 574 issues total, up by 8.
  - Details:
    - Added new issues 567, 568, 569, 570, 571, 572.
    - Moved issues 499, 501, 506, 509, 510, 511, 513, 514, 517 to NAD.
    - Moved issues 502, 503, 515, 516, 522, 525, 526, 527, 528, 529, 532, 536, 539, 548 to Open.
    - Moved issue 504, 512, 521, 530, 531, 535, 537, 538, 540, 549 to Ready.
    - Moved issues 247, 294, 362, 369, 371, 376, 384, 475, 478, 495, 497, 505, 507, 508, 519 to WP.
    - Moved issue 534 to Review.
- R41: 2006-02-24 pre-Berlin mailing.
  - Summary:
    - 126 open issues, up by 31.
    - 440 closed issues, up by 0.
    - 566 issues total, up by 31.
  - Details:
    - Added new issues 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550 ,551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566.
    - Moved 342 from Ready to Open.
    - Reopened 309.
- R40: 2005-12-16 mid-term mailing.
  - Summary:
    - 95 open issues.
    - 440 closed issues.
    - 535 issues total.
  - Details:
    - Added new issues 529, 530, 531, 532, 533, 534, 535.
- R39: 2005-10-14 post-Mont Tremblant mailing. Added new issues 526-528. Moved issues 280, 461, 464, 465, 467, 468, 474, 496 from Ready to WP as per the vote from Mont Tremblant. Moved issues 247, 294, 342, 362, 369, 371, 376, 384, 475, 478, 495, 497 from Review to Ready. Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open. Moved issues 505, 507, 508, 519 from New to Ready. Moved issue 500 from New to NAD. Moved issue 518 from New to Review.
- R38: 2005-07-03 pre-Mont Tremblant mailing. Merged open TR1 issues in 504-522. Added new issues 523-523
- R37: 2005-06 mid-term mailing. Added new issues 498-503.
- R36: 2005-04 post-Lillehammer mailing. All issues in "ready" status except for 454 were moved to "DR" status, and all issues previously in "DR" status were moved to "WP".
- R35: 2005-03 pre-Lillehammer mailing.
- R34: 2005-01 mid-term mailing. Added new issues 488-494.
- R33: 2004-11 post-Redmond mailing. Reflects actions taken in Redmond.
- R32: 2004-09 pre-Redmond mailing: reflects new proposed resolutions and new issues received after the 2004-07 mailing. Added new issues 479-481.
- R31: 2004-07 mid-term mailing: reflects new proposed resolutions and new issues received after the post-Sydney mailing. Added new issues 463-478.
- R30: Post-Sydney mailing: reflects decisions made at the Sydney meeting. Voted all "Ready" issues from R29 into the working paper. Added new issues 460-462.
- R29: Pre-Sydney mailing. Added new issues 441-457.
- R28: Post-Kona mailing: reflects decisions made at the Kona meeting. Added new issues 432-440.
- R27: Pre-Kona mailing. Added new issues 404-431.
- R26: Post-Oxford mailing: reflects decisions made at the Oxford meeting. All issues in Ready status were voted into DR status. All issues in DR status were voted into WP status.
- R25: Pre-Oxford mailing. Added new issues 390-402.
- R24: Post-Santa Cruz mailing: reflects decisions made at the Santa Cruz meeting. All Ready issues from R23 with the exception of 253, which has been given a new proposed resolution, were moved to DR status. Added new issues 383-389. (Issues 387-389 were discussed at the meeting.) Made progress on issues 225, 226, 229: 225 and 229 have been moved to Ready status, and the only remaining concerns with 226 involve wording.
- R23: Pre-Santa Cruz mailing. Added new issues 367-382. Moved issues in the TC to TC status.
- R22: Post-Curaçao mailing. Added new issues 362-366.
- R21: Pre-Curaçao mailing. Added new issues 351-361.
- R20: Post-Redmond mailing; reflects actions taken in Redmond. Added new issues 336-350, of which issues 347-350 were added since Redmond, hence not discussed at the meeting. All Ready issues were moved to DR status, with the exception of issues 284, 241, and 267. Noteworthy issues discussed at Redmond include 120 202, 226, 233, 270, 253, 254, 323.
- R19: Pre-Redmond mailing. Added new issues 323-335.
- R18: Post-Copenhagen mailing; reflects actions taken in Copenhagen. Added new issues 312-317, and discussed new issues 271-314. Changed status of issues 103 118 136 153 165 171 183 184 185 186 214 221 234 237 243 248 251 252 256 260 261 262 263 265 268 to DR. Changed status of issues 49 109 117 182 228 230 232 235 238 241 242 250 259 264 266 267 271 272 273 275 281 284 285 286 288 292 295 297 298 301 303 306 307 308 312 to Ready. Closed issues 111 277 279 287 289 293 302 313 314 as NAD.
- R17: Pre-Copenhagen mailing. Converted issues list to XML. Added proposed resolutions for issues 49, 76, 91, 235, 250, 267. Added new issues 278-311.
- R16: post-Toronto mailing; reflects actions taken in Toronto. Added new issues 265-277. Changed status of issues 3, 8, 9, 19, 26, 31, 61, 63, 86, 108, 112, 114, 115, 122, 127, 129, 134, 137, 142, 144, 146, 147, 159, 164, 170, 181, 199, 208, 209, 210, 211, 212, 217, 220, 222, 223, 224, 227 to "DR". Reopened issue 23. Reopened issue 187. Changed issues 2 and 4 to NAD. Fixed a typo in issue 17. Fixed issue 70: signature should be changed both places it appears. Fixed issue 160: previous version didn't fix the bug in enough places.
- R15: pre-Toronto mailing. Added issues 233-264. Some small HTML formatting changes so that we pass Weblint tests.
- R14: post-Tokyo II mailing; reflects committee actions taken in Tokyo. Added issues 228 to 232. (00-0019R1/N1242)
- R13: pre-Tokyo II updated: Added issues 212 to 227.
- R12: pre-Tokyo II mailing: Added issues 199 to 211. Added "and paragraph 5" to the proposed resolution of issue 29. Add further rationale to issue 178.
- R11: post-Kona mailing: Updated to reflect LWG and full committee actions in Kona (99-0048/N1224). Note changed resolution of issues 4 and 38. Added issues 196 to 198. Closed issues list split into "defects" and "closed" documents. Changed the proposed resolution of issue 4 to NAD, and changed the wording of proposed resolution of issue 38.
- R10: pre-Kona updated. Added proposed resolutions 83, 86, 91, 92, 109. Added issues 190 to 195. (99-0033/D1209, 14 Oct 99)
- R9: pre-Kona mailing. Added issues 140 to 189. Issues list split into separate "active" and "closed" documents. (99-0030/N1206, 25 Aug 99)
- R8: post-Dublin mailing. Updated to reflect LWG and full committee actions in Dublin. (99-0016/N1193, 21 Apr 99)
- R7: pre-Dublin updated: Added issues 130, 131, 132, 133, 134, 135, 136, 137, 138, 139 (31 Mar 99)
- R6: pre-Dublin mailing. Added issues 127, 128, and 129. (99-0007/N1194, 22 Feb 99)
- R5: update issues 103, 112; added issues 114 to 126. Format revisions to prepare for making list public. (30 Dec 98)
- R4: post-Santa Cruz II updated: Issues 110, 111, 112, 113 added, several issues corrected. (22 Oct 98)
- R3: post-Santa Cruz II: Issues 94 to 109 added, many issues updated to reflect LWG consensus (12 Oct 98)
- R2: pre-Santa Cruz II: Issues 73 to 93 added, issue 17 updated. (29 Sep 98)
- R1: Correction to issue 55 resolution, 60 code format, 64 title. (17 Sep 98)

## Issue Status

New - The issue has not yet been reviewed by the LWG. Any Proposed Resolution is purely a suggestion from the issue submitter, and should not be construed as the view of LWG.

Open - The LWG has discussed the issue but is not yet ready to move the issue forward. There are several possible reasons for open status:

- Consensus may have not yet have been reached as to how to deal with the issue.
- Informal consensus may have been reached, but the LWG awaits exact Proposed Resolution wording for review.
- The LWG wishes to consult additional technical experts before proceeding.
- The issue may require further study.

A Proposed Resolution for an open issue is still not be construed as the view of LWG. Comments on the current state of discussions are often given at the end of open issues in an italic font. Such comments are for information only and should not be given undue importance.

Dup - The LWG has reached consensus that the issue is a duplicate of another issue, and will not be further dealt with. A Rationale identifies the duplicated issue's issue number.

NAD - The LWG has reached consensus that the issue is not a defect in the Standard.

NAD Editorial - The LWG has reached consensus that the issue can either be handled editorially, or is handled by a paper (usually linked to in the rationale).

NAD Concepts - The LWG has reached consensus that the issue is NAD for now, but represents a real issue when the library is done with language-supported concepts.

NAD Future - In addition to the regular status, the LWG believes that this issue should be revisited at the next revision of the standard.

Review - Exact wording of a Proposed Resolution is now available for review on an issue for which the LWG previously reached informal consensus.

Ready - The LWG has reached consensus that the issue is a defect in the Standard, the Proposed Resolution is correct, and the issue is ready to forward to the full committee for further action as a Defect Report (DR).

DR - (Defect Report) - The full J16 committee has voted to forward the issue to the Project Editor to be processed as a Potential Defect Report. The Project Editor reviews the issue, and then forwards it to the WG21 Convenor, who returns it to the full committee for final disposition. This issues list accords the status of DR to all these Defect Reports regardless of where they are in that process.

TC1 - (Technical Corrigenda 1) - The full WG21 committee has voted to accept the Defect Report's Proposed Resolution as a Technical Corrigenda. Action on this issue is thus complete and no further action is possible under ISO rules.

CD1 - (Committee Draft 2008) - The full WG21 committee has voted to accept the Defect Report's Proposed Resolution into the Fall 2008 Committee Draft.

TRDec - (Decimal TR defect) - The LWG has voted to accept the Defect Report's Proposed Resolution into the Decimal TR. Action on this issue is thus complete and no further action is expected.

WP - (Working Paper) - The proposed resolution has not been accepted as a Technical Corrigendum, but the full WG21 committee has voted to apply the Defect Report's Proposed Resolution to the working paper.

Tentatively - This is a status qualifier. The issue has been reviewed online, or at an unofficial meeting, but not in an official meeting, and some support has been formed for the qualified status. Tentatively qualified issues may be moved to the unqualified status and forwarded to full committee (if Ready) within the same meeting. Unlike Ready issues, Tentatively Ready issues will be reviewed in subcommittee prior to forwarding to full committee. When a status is qualified with Tentatively, the issue is still considered active.

Pending - This is a status qualifier. When prepended to a status this indicates the issue has been processed by the committee, and a decision has been made to move the issue to the associated unqualified status. However for logistical reasons the indicated outcome of the issue has not yet appeared in the latest working paper.

Issues are always given the status of New when they first appear on the issues list. They may progress to Open or Review while the LWG is actively working on them. When the LWG has reached consensus on the disposition of an issue, the status will then change to Dup, NAD, or Ready as appropriate. Once the full J16 committee votes to forward Ready issues to the Project Editor, they are given the status of Defect Report ( DR). These in turn may become the basis for Technical Corrigenda (TC), or are closed without action other than a Record of Response (RR ). The intent of this LWG process is that only issues which are truly defects in the Standard move to the formal ISO DR status.

## Active Issues

### 296. Missing descriptions and requirements of pair operators

Section: 20.3.4 [pairs] Status: Ready Submitter: Martin Sebor Opened: 2001-01-14 Last modified: 2009-10-26

View other active issues in [pairs].

View all other issues in [pairs].

View all issues with Ready status.

Discussion:

The synopsis of the header `<utility>` in 20.3 [utility] lists the complete set of equality and relational operators for `pair` but the section describing the template and the operators only describes `operator==()` and `operator<()`, and it fails to mention any requirements on the template arguments. The remaining operators are not mentioned at all.

[ 2009-09-27 Alisdair reopens. ]

> The issue is a lack of wording specifying the semantics of `std::pair` relational operators. The rationale is that this is covered by catch-all wording in the relops component, and that as relops directly precedes `pair` in the document this is an easy connection to make.

> Reading the current working paper I make two observations:

> 1. relops no longer immediately precedes `pair` in the order of specification. However, even if it did, there is a lot of `pair` specification itself between the (apparently) unrelated relops and the relational operators for `pair`. (The catch-all still requires `operator==` and `operator<` to be specified explicitly)
> 2. No other library component relies on the catch-all clause. The following all explicitly document all six relational operators, usually in a manner that could have deferred to the relops clause.

> >     tuple
> >     unique_ptr
> >     duration
> >     time_point
> >     basic_string
> >     queue
> >     stack
> >     move_iterator
> >     reverse_iterator
> >     regex submatch
> >     thread::id

> The container components provide their own (equivalent) definition in 23.2.1 [container.requirements.general] Table 90 -- Container requirements and do so do not defer to relops.

> `Shared_ptr` explicitly documents `operator!=` and does not supply the other 3 missing operators (`>`,`>=`,`<=`) so does not meet the reqirements of the relops clause.

> `Weak_ptr` only supports `operator<` so would not be covered by relops.

> At the very least I would request a note pointing to the relops clause we rely on to provide this definition. If this route is taken, I would recommend reducing many of the above listed clauses to a similar note rather than providing redundant specification.

> My preference would be to supply the 4 missing specifications consistent with the rest of the library.

[ 2009-10-11 Daniel opens 1233 which deals with the same issue as it pertains to `unique_ptr`. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready

Proposed resolution:

After p20 20.3.4 [pairs] add:

>     template <class T1, class T2>
>     bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y);

> > Returns: `!(x==y)`

>     template <class T1, class T2>
>     bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y);

> > Returns: `y < x`

>     template <class T1, class T2>
>     bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y);

> > Returns: `!(x < y)`

>     template <class T1, class T2>
>     bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y);

> > Returns: `!(y < x)`

Rationale:

20.3.1 [operators] paragraph 10 already specifies the semantics. That paragraph says that, if declarations of operator!=, operator>, operator<=, and operator>= appear without definitions, they are defined as specified in 20.3.1 [operators]. There should be no user confusion, since that paragraph happens to immediately precede the specification of `pair`.

### 299. Incorrect return types for iterator dereference

Section: 24.2.4 [bidirectional.iterators], 24.2.5 [random.access.iterators] Status: Open Submitter: John Potter Opened: 2001-01-22 Last modified: 2009-10-26

View all other issues in [bidirectional.iterators].

View all issues with Open status.

Discussion:

In section 24.2.4 [bidirectional.iterators], Table 75 gives the return type of *r-- as convertible to T. This is not consistent with Table 74 which gives the return type of *r++ as T&. *r++ = t is valid while *r-- = t is invalid.

In section 24.2.5 [random.access.iterators], Table 76 gives the return type of a[n] as convertible to T. This is not consistent with the semantics of *(a + n) which returns T& by Table 74. *(a + n) = t is valid while a[n] = t is invalid.

Discussion from the Copenhagen meeting: the first part is uncontroversial. The second part, operator[] for Random Access Iterators, requires more thought. There are reasonable arguments on both sides. Return by value from operator[] enables some potentially useful iterators, e.g. a random access "iota iterator" (a.k.a "counting iterator" or "int iterator"). There isn't any obvious way to do this with return-by-reference, since the reference would be to a temporary. On the other hand, `reverse_iterator` takes an arbitrary Random Access Iterator as template argument, and its operator[] returns by reference. If we decided that the return type in Table 76 was correct, we would have to change `reverse_iterator`. This change would probably affect user code.

History: the contradiction between `reverse_iterator` and the Random Access Iterator requirements has been present from an early stage. In both the STL proposal adopted by the committee (N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by Stepanov and Lee), the Random Access Iterator requirements say that operator[]'s return value is "convertible to T". In N0527 reverse_iterator's operator[] returns by value, but in HPL-95-11 (R.1), and in the STL implementation that HP released to the public, reverse_iterator's operator[] returns by reference. In 1995, the standard was amended to reflect the contents of HPL-95-11 (R.1). The original intent for operator[] is unclear.

In the long term it may be desirable to add more fine-grained iterator requirements, so that access method and traversal strategy can be decoupled. (See "Improved Iterator Categories and Requirements", N1297 = 01-0011, by Jeremy Siek.) Any decisions about issue 299 should keep this possibility in mind.

Further discussion: I propose a compromise between John Potter's resolution, which requires `T&` as the return type of `a[n]`, and the current wording, which requires convertible to `T`. The compromise is to keep the convertible to `T` for the return type of the expression `a[n]`, but to also add `a[n] = t` as a valid expression. This compromise "saves" the common case uses of random access iterators, while at the same time allowing iterators such as counting iterator and caching file iterators to remain random access iterators (iterators where the lifetime of the object returned by `operator*()` is tied to the lifetime of the iterator).

Note that the compromise resolution necessitates a change to `reverse_iterator`. It would need to use a proxy to support `a[n] = t`.

Note also there is one kind of mutable random access iterator that will no longer meet the new requirements. Currently, iterators that return an r-value from `operator[]` meet the requirements for a mutable random access iterartor, even though the expression `a[n] = t` will only modify a temporary that goes away. With this proposed resolution, `a[n] = t` will be required to have the same operational semantics as `*(a + n) = t`.

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-09-18 Alisdair adds: ]

> Why can't we write through the reference returned from operator[] on a random access iterator?

> Recommended solution:

> In table Table 104 -- Random access iterator requirements, replace

> > a[n] : convertible to `const T &` `T&` if `X` is mutable, otherwise convertible to `const T&`

[ 2009-10 Santa Cruz: ]

> Leave Open. Alisdair to spearhead a paper on revivification.

Proposed resolution:

In section 24.1.4 [lib.bidirectdional.iterators], change the return type in table 75 from "convertible to `T`" to `T&`.

In section 24.1.5 [lib.random.access.iterators], change the operational semantics for `a[n]` to " the r-value of `a[n]` is equivalent to the r-value of `*(a + n)`". Add a new row in the table for the expression `a[n] = t` with a return type of convertible to `T` and operational semantics of `*(a + n) = t`.

[Lillehammer: Real problem, but should be addressed as part of iterator redesign]

Rationale:

[ San Francisco: ]

> Solved by N2758.

### 397. ostream::sentry dtor throws exceptions

Section: 27.7.2.4 [ostream::sentry] Status: Open Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2009-10-20

View all other issues in [ostream::sentry].

View all issues with Open status.

Discussion:

17.4.4.8, p3 prohibits library dtors from throwing exceptions.

27.6.2.3, p4 says this about the ostream::sentry dtor:

        -4- If ((os.flags() & ios_base::unitbuf) && !uncaught_exception())
            is true, calls os.flush().

27.6.2.6, p7 that describes ostream::flush() says:

        -7- If rdbuf() is not a null pointer, calls rdbuf()->pubsync().
            If that function returns ?-1 calls setstate(badbit) (which
            may throw ios_base::failure (27.4.4.3)).

That seems like a defect, since both pubsync() and setstate() can throw an exception.

[ The contradiction is real. Clause 17 says destructors may never throw exceptions, and clause 27 specifies a destructor that does throw. In principle we might change either one. We're leaning toward changing clause 17: putting in an "unless otherwise specified" clause, and then putting in a footnote saying the sentry destructor is the only one that can throw. PJP suggests specifying that sentry::~sentry() should internally catch any exceptions it might cause. ]

[ See 418 and 622 for related issues. ]

[ 2009-07 Frankfurt ]

> Move to Review. Add "Throws: nothing" to the specification of ostream::sentry::~sentry().

[ 2009-10-13 Daniel adds: ]

> The proposed resolution of 835 is written to match the outcome of this issue.

[ 2009 Santa Cruz: ]

> Move to Open. Our intent is to solve this issue with 835.

Proposed resolution:

Add after 27.7.2.4 [ostream::sentry] p17:

>     ~sentry();

> > -17- If `((os.flags() & ios_base::unitbuf) && !uncaught_exception())` is `true`, calls `os.flush()`.

> > Throws: Nothing.

### 408. Is vector<reverse_iterator<char*> > forbidden?

Section: 24.2 [iterator.requirements] Status: Open Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-11-03

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with Open status.

Discussion:

I've been discussing iterator semantics with Dave Abrahams, and a surprise has popped up. I don't think this has been discussed before.

X [iterator.concepts] says that the only operation that can be performed on "singular" iterator values is to assign a non-singular value to them. (It doesn't say they can be destroyed, and that's probably a defect.) Some implementations have taken this to imply that there is no need to initialize the data member of a reverse_iterator<> in the default constructor. As a result, code like

>       std::vector<std::reverse_iterator<char*> > v(7);
>       v.reserve(1000);

invokes undefined behavior, because it must default-initialize the vector elements, and then copy them to other storage. Of course many other vector operations on these adapters are also left undefined, and which those are is not reliably deducible from the standard.

I don't think that 24.1 was meant to make standard-library iterator types unsafe. Rather, it was meant to restrict what operations may be performed by functions which take general user- and standard iterators as arguments, so that raw pointers would qualify as iterators. However, this is not clear in the text, others have come to the opposite conclusion.

One question is whether the standard iterator adaptors have defined copy semantics. Another is whether they have defined destructor semantics: is

>       { std::vector<std::reverse_iterator<char*> >  v(7); }

undefined too?

Note this is not a question of whether algorithms are allowed to rely on copy semantics for arbitrary iterators, just whether the types we actually supply support those operations. I believe the resolution must be expressed in terms of the semantics of the adapter's argument type. It should make clear that, e.g., the reverse_iterator<T> constructor is actually required to execute T(), and so copying is defined if the result of T() is copyable.

Issue 235, which defines reverse_iterator's default constructor more precisely, has some relevance to this issue. However, it is not the whole story.

The issue was whether

>       reverse_iterator() { }

is allowed, vs.

>       reverse_iterator() : current() { }

The difference is when T is char*, where the first leaves the member uninitialized, and possibly equal to an existing pointer value, or (on some targets) may result in a hardware trap when copied.

8.5 paragraph 5 seems to make clear that the second is required to satisfy DR 235, at least for non-class Iterator argument types.

But that only takes care of reverse_iterator, and doesn't establish a policy for all iterators. (The reverse iterator adapter was just an example.) In particular, does my function

>       template <typename Iterator>
>         void f() { std::vector<Iterator>  v(7); }

evoke undefined behavior for some conforming iterator definitions? I think it does, now, because vector<> will destroy those singular iterator values, and that's explicitly disallowed.

24.1 shouldn't give blanket permission to copy all singular iterators, because then pointers wouldn't qualify as iterators. However, it should allow copying of that subset of singular iterator values that are default-initialized, and it should explicitly allow destroying any iterator value, singular or not, default-initialized or not.

Related issues: 407, 1012

[ We don't want to require all singular iterators to be copyable, because that is not the case for pointers. However, default construction may be a special case. Issue: is it really default construction we want to talk about, or is it something like value initialization? We need to check with core to see whether default constructed pointers are required to be copyable; if not, it would be wrong to impose so strict a requirement for iterators. ]

[ 2009-05-10 Alisdair provided wording. ]

> The comments regarding destroying singular iterators have already been resolved. That just leaves copying (with moving implied).

[ 2009-07 Frankfurt ]

> This is related to LWG 1012.

> Note that there is a bug in the proposed resolution to LWG 1012. The change to [reverse.iter.con] should be modified so that the word "default" in the second sentence of the Effects clause is replaced by "value."

> We believe that the proposed fix to LWG 1012 (now corrected) is sufficient to solve the problem for reverse_iterator. However, Alisdair pointed out that LWG 1012 does not solve the general problem for authors of iterator adaptors.

> There are some problems with the proposed resolution. The phrase "safely copyable" is not a term of art. Also, it mentions a DefaultConstructible? concept.

> Move to Review after Alisdair updates the wording.

[ 2009-07-31 Alisdair revised wording: ]

[ 2009-08-17 Alisdair and Daniel collaborate on slightly revised wording. This issue depends upon 724 ]

[ 2009-10-14 Daniel adds: ]

> There is a clear dependency on 1213, because the term "singular", which is used as part of the resolution, is not properly defined yet.

[ 2009-10 Santa Cruz: ]

> Moved to Open. Alisdair will provide improved wording to make this have "value semantics" and otherwise behave like a valid iterator.

Proposed resolution:

Add a new paragrpah to Iterator concepts 24.2 [iterator.requirements] after para 5 (the one describing singular iterators)

> Just as a regular pointer to an array guarantees that there is a pointer value pointing past the last element of the array, so for any iterator type there is an iterator value that points past the last element of a corresponding container. These values are called past-the-end values. Values of an iterator `i` for which the expression `*i` is defined are called dereferenceable. The library never assumes that past-the-end values are dereferenceable. Iterators can also have singular values that are not associated with any container. [Example: After the declaration of an uninitialized pointer `x` (as with `int* x;`), `x` must always be assumed to have a singular value of a pointer. — end example] Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value and the assignment of a non-singular value to an iterator that holds a singular value. In this case the singular value is overwritten the same way as any other value. Dereferenceable values are always non-singular.

> After value-initialization, any iterator that satisfies the `DefaultConstructible` requirements ([defaultconstructible]) shall not introduce undefined behaviour when used as the source of a copy or move operation, even if it would otherwise be singular. [Note: This guarantee is not offered for default-initialization (8.5 [dcl.init]), although the distinction only matters for types with trivial default constructors such as pointers. — end note]

### 427. stage 2 and rationale of DR 221

Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-10-26

View other active issues in [facet.num.get.virtuals].

View all other issues in [facet.num.get.virtuals].

View all issues with Open status.

Discussion:

The requirements specified in Stage 2 and reiterated in the rationale of DR 221 (and echoed again in DR 303) specify that num_get<charT>:: do_get() compares characters on the stream against the widened elements of "012...abc...ABCX+-"

An implementation is required to allow programs to instantiate the num_get template on any charT that satisfies the requirements on a user-defined character type. These requirements do not include the ability of the character type to be equality comparable (the char_traits template must be used to perform tests for equality). Hence, the num_get template cannot be implemented to support any arbitrary character type. The num_get template must either make the assumption that the character type is equality-comparable (as some popular implementations do), or it may use char_traits<charT> to do the comparisons (some other popular implementations do that). This diversity of approaches makes it difficult to write portable programs that attempt to instantiate the num_get template on user-defined types.

[Kona: the heart of the problem is that we're theoretically supposed to use traits classes for all fundamental character operations like assignment and comparison, but facets don't have traits parameters. This is a fundamental design flaw and it appears all over the place, not just in this one place. It's not clear what the correct solution is, but a thorough review of facets and traits is in order. The LWG considered and rejected the possibility of changing numeric facets to use narrowing instead of widening. This may be a good idea for other reasons (see issue 459), but it doesn't solve the problem raised by this issue. Whether we use widen or narrow the `num_get` facet still has no idea which traits class the user wants to use for the comparison, because only streams, not facets, are passed traits classes. The standard does not require that two different traits classes with the same `char_type` must necessarily have the same behavior.]

Informally, one possibility: require that some of the basic character operations, such as `eq`, `lt`, and `assign`, must behave the same way for all traits classes with the same `char_type`. If we accept that limitation on traits classes, then the facet could reasonably be required to use `char_traits<charT>`.

[ 2009-07 Frankfurt ]

> There was general agreement that the standard only needs to specify the behavior when the character type is char or wchar_t.

> Beman: we don't need to worry about C++1x because there is a non-zero possibility that we would have a replacement facility for iostreams that would solve these problems.

> We need to change the following sentence in [locale.category], paragraph 6 to specify that C is char and wchar_t:

> "A template formal parameter with name C represents the set of all possible specializations on a parameter that satisfies the requirements for a character on which any member of the iostream components can be instantiated."

> We also need to specify in 27 that the basic character operations, such as eq, lt, and assign use std::char_traits.

> Daniel volunteered to provide wording.

[ 2009-09-19 Daniel provided wording. ]

[ 2009-10 Santa Cruz: ]

> Leave as Open. Alisdair and/or Tom will provide wording based on discussions. We want to clearly state that streams and locales work just on `char` and `wchar_t` (except where otherwise specified).

Proposed resolution:

1. Change 22.3.1.1.1 [locale.category]/6:

   > [..] A template formal parameter with name `C` represents the set of all possible specializations on a `char` or `wchar_t` parameter that satisfies the requirements for a character on which any of the iostream components can be instantiated. [..]

2. Add the following sentence to the end of 22.4.2 [category.numeric]/2:

   > [..] These specializations refer to [..], and also for the `ctype<>` facet to perform character classification. Implementations are encouraged but not required to use the `char_traits<charT>` functions for all comparisons and assignments of characters of type `charT` that do not belong to the set of required specializations.

3. Change 22.4.2.1.2 [facet.num.get.virtuals]/3:

   > Stage 2: If `in==end` then stage 2 terminates. Otherwise a `charT` is taken from `in` and local variables are initialized as if by

   > >     char_type ct = *in;
   > >     using tr = char_traits<char_type>;
   > >     const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct);
   > >     char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms
   > >                  pos ? pos - atoms : sizeof(src) - 1];
   > >     if (tr::eq(ct, ct == use_facet<numpunct<charT>(loc).decimal_point()))
   > >         c = '.';
   > >     bool discard =
   > >         tr::eq(ct, ct == use_facet<numpunct<charT>(loc).thousands_sep())
   > >         && use_facet<numpunct<charT> >(loc).grouping().length() != 0;

   > where the values `src` and `atoms` are defined as if by: [..]

   [Remark of the author: I considered to replace the initialization "`char_type ct = *in;`" by the sequence "`char_type ct; tr::assign(ct, *in);`", but decided against it, because it is a copy-initialization context, not an assignment]

4. Add the following sentence to the end of 22.4.5 [category.time]/1:

   > [..] Their members use [..] , to determine formatting details. Implementations are encouraged but not required to use the `char_traits<charT>` functions for all comparisons and assignments of characters of type `charT` that do not belong to the set of required specializations.

5. Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4:

   - The next element of `fmt` is equal to `'%'` For the next element `c` of `fmt char_traits<char_type>::eq(c, use_facet<ctype<char_type>>(f.getloc()).widen('%')) == true`, [..]

6. Add the following sentence to the end of 22.4.6 [category.monetary]/2:

   > Their members use [..] to determine formatting details. Implementations are encouraged but not required to use the `char_traits<charT>` functions for all comparisons and assignments of characters of type `charT` that do not belong to the set of required specializations.

7. Change 22.4.6.1.2 [locale.money.get.virtuals]/4:

   > [..] The value `units` is produced as if by:

   > >     for (int i = 0; i < n; ++i)
   > >       buf2[i] = src[char_traits<charT>::find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
   > >     buf2[n] = 0;
   > >     sscanf(buf2, "%Lf", &units);

8. Change 22.4.6.2.2 [locale.money.put.virtuals]/1:

   > [..] for character buffers `buf1` and `buf2`. If for the first character `c` in `digits` or `buf2` is equal to `ct.widen('-')``char_traits<charT>::eq(c, ct.widen('-')) == true`, [..]

9. Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1:

   > As in the case of the inserters, these extractors depend on the locale's `num_get<>` (22.4.2.1) object to perform parsing the input stream data.(footnote) [..]

   > footnote) If the traits of the input stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

10. Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1:

    > Effects: The classes `num_get<>` and `num_put<>` handle locale-dependent numeric formatting and parsing. These inserter functions use the imbued locale value to perform numeric formatting.(footnote) [..]

    > footnote) If the traits of the output stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

11. Add a footnote after the first sentence of 27.7.4 [ext.manip]/4:

    > Returns: An object of unspecified type such that if in is an object of type `basic_istream<charT, traits>` then the expression `in >> get_money(mon, intl)` behaves as if it called `f(in, mon, intl)`, where the function `f` is defined as:(footnote) [..]

    > footnote) If the traits of the input stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

12. Add a footnote after the first sentence of 27.7.4 [ext.manip]/5:

    > Returns: An object of unspecified type such that if `out` is an object of type `basic_ostream<charT, traits>` then the expression `out << put_money(mon, intl)` behaves as a formatted input function that calls `f(out, mon, intl)`, where the function `f` is defined as:(footnote) [..]

    > footnote) If the traits of the output stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

13. 13) Add a footnote after the first sentence of 27.7.4 [ext.manip]/8:

    > Returns: An object of unspecified type such that if `in` is an object of type b`asic_istream<charT, traits>` then the expression `in >>get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`, where the function `f` is defined as:(footnote) [..]

    > footnote) If the traits of the input stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

14. Add a footnote after the first sentence of 27.7.4 [ext.manip]/10:

    > Returns: An object of unspecified type such that if `out` is an object of type `basic_ostream<charT, traits>` then the expression `out <<put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`, where the function `f` is defined as:(footnote) [..]

    > footnote) If the traits of the output stream has different semantics for `lt()`, `eq()`, and `assign()` than `char_traits<char_type>`, this may give surprising results.

### 430. valarray subset operations

Section: 26.6.2.4 [valarray.sub] Status: Open Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-11-04

View all issues with Open status.

Discussion:

The standard fails to specify the behavior of valarray::operator[](slice) and other valarray subset operations when they are passed an "invalid" slice object, i.e., either a slice that doesn't make sense at all (e.g., slice (0, 1, 0) or one that doesn't specify a valid subset of the valarray object (e.g., slice (2, 1, 1) for a valarray of size 1).

[Kona: the LWG believes that invalid slices should invoke undefined behavior. Valarrays are supposed to be designed for high performance, so we don't want to require specific checking. We need wording to express this decision.]

[ Bellevue: ]

> Please note that the standard also fails to specify the behavior of slice_array and gslice_array in the valid case. Bill Plauger will endeavor to provide revised wording for slice_array and gslice_array.

[ post-Bellevue: Bill provided wording. ]

[ 2009-07 Frankfurt ]

> Move to Ready.

[ 2009-11-04 Pete opens: ]

> The resolution to LWG issue 430 has not been applied --- there have been changes to the underlying text, and the resolution needs to be reworked.

Proposed resolution:

Insert after 26.6.2.4 [valarray.sub], paragraph 1:

> The member operator is overloaded to provide several ways to select sequences of elements from among those controlled by `*this`. The first group of five member operators work in conjunction with various overloads of `operator=` (and other assigning operators) to allow selective replacement (slicing) of the controlled sequence. The selected elements must exist.

> The first member operator selects element off. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     v0[3] = 'A';
> >     // v0 == valarray<char>("abcAefghijklmnop", 16)

> The second member operator selects those elements of the controlled sequence designated by `slicearr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     valarray<char> v1("ABCDE", 5);
> >     v0[slice(2, 5, 3)] = v1;
> >     // v0 == valarray<char>("abAdeBghCjkDmnEp", 16)

> The third member operator selects those elements of the controlled sequence designated by `gslicearr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     valarray<char> v1("ABCDEF", 6);
> >     const size_t lv[] = {2, 3};
> >     const size_t dv[] = {7, 2};
> >     const valarray<size_t> len(lv, 2), str(dv, 2);
> >     v0[gslice(3, len, str)] = v1;
> >     // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)

> The fourth member operator selects those elements of the controlled sequence designated by `boolarr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     valarray<char> v1("ABC", 3);
> >     const bool vb[] = {false, false, true, true, false, true};
> >     v0[valarray<bool>(vb, 6)] = v1;
> >     // v0 == valarray<char>("abABeCghijklmnop", 16)

> The fifth member operator selects those elements of the controlled sequence designated by indarr. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     valarray<char> v1("ABCDE", 5);
> >     const size_t vi[] = {7, 5, 2, 3, 8};
> >     v0[valarray<size_t>(vi, 5)] = v1;
> >     // v0 == valarray<char>("abCDeBgAEjklmnop", 16)

> The second group of five member operators each construct an object that represents the value(s) selected. The selected elements must exist.

> The sixth member operator returns the value of element off. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     // v0[3] returns 'd'

> The seventh member operator returns an object of class `valarray<Ty>` containing those elements of the controlled sequence designated by `slicearr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)

> The eighth member operator selects those elements of the controlled sequence designated by `gslicearr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     const size_t lv[] = {2, 3};
> >     const size_t dv[] = {7, 2};
> >     const valarray<size_t> len(lv, 2), str(dv, 2);
> >     // v0[gslice(3, len, str)] returns
> >     //    valarray<char>("dfhkmo", 6)

> The ninth member operator selects those elements of the controlled sequence designated by `boolarr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     const bool vb[] = {false, false, true, true, false, true};
> >     // v0[valarray<bool>(vb, 6)] returns
> >     //    valarray<char>("cdf", 3)

> The last member operator selects those elements of the controlled sequence designated by `indarr`. For example:

> >     valarray<char> v0("abcdefghijklmnop", 16);
> >     const size_t vi[] = {7, 5, 2, 3, 8};
> >     // v0[valarray<size_t>(vi, 5)] returns
> >     //    valarray<char>("hfcdi", 5)

### 446. Iterator equality between different containers

Section: 24.2 [iterator.requirements], 23.2 [container.requirements] Status: Open Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2009-11-03

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with Open status.

Discussion:

What requirements does the standard place on equality comparisons between iterators that refer to elements of different containers. For example, if v1 and v2 are empty vectors, is v1.end() == v2.end() allowed to yield true? Is it allowed to throw an exception?

The standard appears to be silent on both questions.

[Sydney: The intention is that comparing two iterators from different containers is undefined, but it's not clear if we say that, or even whether it's something we should be saying in clause 23 or in clause 24. Intuitively we might want to say that equality is defined only if one iterator is reachable from another, but figuring out how to say it in any sensible way is a bit tricky: reachability is defined in terms of equality, so we can't also define equality in terms of reachability. ]

[ 2009-07 Frankfurt ]

> Daniel volunteered to work on this.

[ 2009-09-20 Daniel provided wording. ]

[ 2009-10 Santa Cruz: ]

> Leave as Open. Alisdair has volunteered to refine the wording.

Proposed resolution:

Insert a new paragraph between 24.2 [iterator.requirements]/7+8:

> [..] The result of the application of functions in the library to invalid ranges is undefined.

> The result of directly or indirectly evaluating any comparison function or the binary - operator with two iterator values as arguments that were obtained from two different ranges `r1` and `r2` (including their past-the-end values) which are not subranges of one common range is undefined, unless explicitly described otherwise.

### 471. result of what() implementation-defined

Section: 18.8.1 [exception] Status: Ready Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2009-10-26

View all issues with Ready status.

Discussion:

[lib.exception] specifies the following:

        exception (const exception&) throw();
        exception& operator= (const exception&) throw();

        -4- Effects: Copies an exception object.
        -5- Notes: The effects of calling what() after assignment
            are implementation-defined.

First, does the Note only apply to the assignment operator? If so, what are the effects of calling what() on a copy of an object? Is the returned pointer supposed to point to an identical copy of the NTBS returned by what() called on the original object or not?

Second, is this Note intended to extend to all the derived classes in section 19? I.e., does the standard provide any guarantee for the effects of what() called on a copy of any of the derived class described in section 19?

Finally, if the answer to the first question is no, I believe it constitutes a defect since throwing an exception object typically implies invoking the copy ctor on the object. If the answer is yes, then I believe the standard ought to be clarified to spell out exactly what the effects are on the copy (i.e., after the copy ctor was called).

[Redmond: Yes, this is fuzzy. The issue of derived classes is fuzzy too.]

[ Batavia: Howard provided wording. ]

[ Bellevue: ]

> Eric concerned this is unimplementable, due to nothrow guarantees. Suggested implementation would involve reference counting.

> Is the implied reference counting subtle enough to call out a note on implementation? Probably not.

> If reference counting required, could we tighten specification further to require same pointer value? Probably an overspecification, especially if exception classes defer evalutation of final string to calls to what().

> Remember issue moved open and not resolved at Batavia, but cannot remember who objected to canvas a disenting opinion - please speak up if you disagree while reading these minutes!

> Move to Ready as we are accepting words unmodified.

[ Sophia Antipolis: ]

> The issue was pulled from Ready. It needs to make clear that only homogenous copying is intended to be supported, not coping from a derived to a base.

[ Batavia (2009-05): ]

> Howard supplied the following replacement wording for paragraph 7 of the proposed resolution:

> > -7- Postcondition: `what()` shall return the same NTBS as would be obtained by using `static_cast` to cast the rhs to the same types as the lhs and then calling `what()` on that possibly sliced object.

> Pete asks what "the same NTBS" means.

[ 2009-07-30 Niels adds: ]

> Further discussion in the thread starting with c++std-lib-24512.

[ 2009-09-24 Niels provided updated wording: ]

> I think the resolution should at least guarantee that the result of `what()` is independent of whether the compiler does copy-elision. And for any class derived from `std::excepion` that has a constructor that allows specifying a `what_arg`, it should make sure that the text of a user-provided `what_arg` is preserved, when the object is copied. Note that all the implementations I've tested already appear to satisfy the proposed resolution, including MSVC 2008 SP1, Apache stdcxx-4.2.1, GCC 4.1.2, GCC 4.3.2, and CodeGear C++ 6.13.

> The proposed resolution was updated with help from Daniel Krügler; the update aims to clarify that the proposed postcondition only applies to homogeneous copying.

[ 2009-10 Santa Cruz: ]

> Moved to Ready after inserting "publicly accessible" in two places.

Proposed resolution:

Change 18.8.1 [exception] to:

> -1- The class `exception` defines the base class for the types of objects thrown as exceptions by C++ standard library components, and certain expressions, to report errors detected during program execution.

> Each standard library class `T` that derives from class `exception` shall have a publicly accessible copy constructor and a publicly accessible copy assignment operator that do not exit with an exception. These member functions shall preserve the following postcondition: If two objects lhs and rhs both have dynamic type `T`, and lhs is a copy of rhs, then `strcmp(lhs.what(), rhs.what()) == 0`.

> ...

>     exception(const exception& rhs) throw();
>     exception& operator=(const exception& rhs) throw();

> > -4- Effects: Copies an exception object.

> > -5- Remarks: The effects of calling `what()` after assignment are implementation-defined.

> > -5- Postcondition: If `*this` and rhs both have dynamic type `exception` then `strcmp(what(), rhs.what()) == 0`.

### 473. underspecified ctype calls

Section: 22.4.1.1 [locale.ctype] Status: Ready Submitter: Martin Sebor Opened: 2004-07-01 Last modified: 2009-10-21

View all issues with Ready status.

Discussion:

Most ctype member functions come in two forms: one that operates on a single character at a time and another form that operates on a range of characters. Both forms are typically described by a single Effects and/or Returns clause.

The Returns clause of each of the single-character non-virtual forms suggests that the function calls the corresponding single character virtual function, and that the array form calls the corresponding virtual array form. Neither of the two forms of each virtual member function is required to be implemented in terms of the other.

There are three problems:

1. One is that while the standard does suggest that each non-virtual member function calls the corresponding form of the virtual function, it doesn't actually explicitly require it.

Implementations that cache results from some of the virtual member functions for some or all values of their arguments might want to call the array form from the non-array form the first time to fill the cache and avoid any or most subsequent virtual calls. Programs that rely on each form of the virtual function being called from the corresponding non-virtual function will see unexpected behavior when using such implementations.

2. The second problem is that either form of each of the virtual functions can be overridden by a user-defined function in a derived class to return a value that is different from the one produced by the virtual function of the alternate form that has not been overriden.

Thus, it might be possible for, say, ctype::widen(c) to return one value, while for ctype::widen(&c, &c + 1, &wc) to set wc to another value. This is almost certainly not intended. Both forms of every function should be required to return the same result for the same character, otherwise the same program using an implementation that calls one form of the functions will behave differently than when using another implementation that calls the other form of the function "under the hood."

3. The last problem is that the standard text fails to specify whether one form of any of the virtual functions is permitted to be implemented in terms of the other form or not, and if so, whether it is required or permitted to call the overridden virtual function or not.

Thus, a program that overrides one of the virtual functions so that it calls the other form which then calls the base member might end up in an infinite loop if the called form of the base implementation of the function in turn calls the other form.

Lillehammer: Part of this isn't a real problem. We already talk about caching. 22.1.1/6 But part is a real problem. ctype virtuals may call each other, so users don't know which ones to override to avoid avoid infinite loops.

This is a problem for all facet virtuals, not just ctype virtuals, so we probably want a blanket statement in clause 22 for all facets. The LWG is leaning toward a blanket prohibition, that a facet's virtuals may never call each other. We might want to do that in clause 27 too, for that matter. A review is necessary. Bill will provide wording.

[ 2009-07 Frankfurt, Howard provided wording directed by consensus. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add paragraph 3 to 22.4 [locale.categories]:

> -3- Within this clause it is unspecified if one virtual function calls another virtual function.

Rationale:

We are explicitly not addressing bullet item #2, thus giving implementors more latitude. Users will have to override both virtual functions, not just one.

### 485. output iterator insufficiently constrained

Section: 24.2.2 [output.iterators] Status: Ready Submitter: Chris Jefferson Opened: 2004-10-13 Last modified: 2009-10-26

View all other issues in [output.iterators].

View all issues with Ready status.

Discussion:

The note on 24.1.2 Output iterators insufficiently limits what can be performed on output iterators. While it requires that each iterator is progressed through only once and that each iterator is written to only once, it does not require the following things:

Note: Here it is assumed that x is an output iterator of type X which has not yet been assigned to.

a) That each value of the output iterator is written to: The standard allows: ++x; ++x; ++x;

b) That assignments to the output iterator are made in order X a(x); ++a; *a=1; *x=2; is allowed

c) Chains of output iterators cannot be constructed: X a(x); ++a; X b(a); ++b; X c(b); ++c; is allowed, and under the current wording (I believe) x,a,b,c could be written to in any order.

I do not believe this was the intension of the standard?

[Lillehammer: Real issue. There are lots of constraints we intended but didn't specify. Should be solved as part of iterator redesign.]

[ 2009-07 Frankfurt ]

> Bill provided wording according to consensus.

[ 2009-07-21 Alisdair requests change from Review to Open. See thread starting with c++std-lib-24459 for discussion. ]

[ 2009-10 Santa Cruz: ]

> Modified wording. Set to Review.

[ 2009-10 Santa Cruz: ]

> Move to Ready after looking at again in a larger group in Santa Cruz.

Proposed resolution:

Change Table 101 — Output iterator requirements in 24.2.2 [output.iterators]:

> Table 101 — Output iterator requirements
> Expression | Return type | Operational semantics | Assertion/note pre-/post-condition
> --- | --- | --- | ---
> `X(a)` |  |  | `a = t` is equivalent to `X(a) = t`. note: a destructor is assumed.
> `X u(a);` `X u = a;` |  |  |
> `*r = o` | result is not used |  | Post: `r` is not required to be dereferenceable. `r` is incrementable.
> `++r` | `X&` |  | `&r == &++r` Post: `r` is dereferenceable, unless otherwise specified. `r` is not required to be incrementable.
> `r++` | convertible to `const X&` | `{X tmp = r; ++r; return tmp;}` | Post: `r` is dereferenceable, unless otherwise specified. `r` is not required to be incrementable.
> `*r++ = o;` | result is not used |  |

### 539. partial_sum and adjacent_difference should mention requirements

Section: 26.7.3 [partial.sum] Status: Ready Submitter: Marc Schoolderman Opened: 2006-02-06 Last modified: 2009-10-24

View all issues with Ready status.

Discussion:

There are some problems in the definition of partial_sum and adjacent_difference in 26.4 [lib.numeric.ops]

Unlike `accumulate` and `inner_product`, these functions are not parametrized on a "type T", instead, 26.4.3 [lib.partial.sum] simply specifies the effects clause as;

> Assigns to every element referred to by iterator `i` in the range `[result,result + (last - first))` a value correspondingly equal to

> >     ((...(* first + *( first + 1)) + ...) + *( first + ( i - result )))

And similarly for BinaryOperation. Using just this definition, it seems logical to expect that:

>     char i_array[4] = { 100, 100, 100, 100 };
>     int  o_array[4];

>     std::partial_sum(i_array, i_array+4, o_array);

Is equivalent to

>     int o_array[4] = { 100, 100+100, 100+100+100, 100+100+100+100 };

i.e. 100, 200, 300, 400, with addition happening in the `result type`, `int`.

Yet all implementations I have tested produce 100, -56, 44, -112, because they are using an accumulator of the `InputIterator`'s `value_type`, which in this case is `char`, not `int`.

The issue becomes more noticeable when the result of the expression `*i + *(i+1)` or `binary_op(*i, *i-1)` can't be converted to the `value_type`. In a contrived example:

>     enum not_int { x = 1, y = 2 };
>     ...
>     not_int e_array[4] = { x, x, y, y };
>     std::partial_sum(e_array, e_array+4, o_array);

Is it the intent that the operations happen in the `input type`, or in the `result type`?

If the intent is that operations happen in the `result type`, something like this should be added to the "Requires" clause of 26.4.3/4 [lib.partial.sum]:

> The type of `*i + *(i+1)` or `binary_op(*i, *(i+1))` shall meet the requirements of `CopyConstructible` (20.1.3) and `Assignable` (23.1) types.

(As also required for `T` in 26.4.1 [lib.accumulate] and 26.4.2 [lib.inner.product].)

The "auto initializer" feature proposed in N1894 is not required to implement `partial_sum` this way. The 'narrowing' behaviour can still be obtained by using the `std::plus<>` function object.

If the intent is that operations happen in the `input type`, then something like this should be added instead;

> The type of *first shall meet the requirements of `CopyConstructible` (20.1.3) and `Assignable` (23.1) types. The result of `*i + *(i+1)` or `binary_op(*i, *(i+1))` shall be convertible to this type.

The 'widening' behaviour can then be obtained by writing a custom proxy iterator, which is somewhat involved.

In both cases, the semantics should probably be clarified.

26.4.4 [lib.adjacent.difference] is similarly underspecified, although all implementations seem to perform operations in the 'result' type:

>     unsigned char i_array[4] = { 4, 3, 2, 1 };
>     int o_array[4];

>     std::adjacent_difference(i_array, i_array+4, o_array);

o_array is 4, -1, -1, -1 as expected, not 4, 255, 255, 255.

In any case, `adjacent_difference` doesn't mention the requirements on the `value_type`; it can be brought in line with the rest of 26.4 [lib.numeric.ops] by adding the following to 26.4.4/2 [lib.adjacent.difference]:

> The type of `*first` shall meet the requirements of `CopyConstructible` (20.1.3) and `Assignable` (23.1) types."

[ Berlin: Giving output iterator's value_types very controversial. Suggestion of adding signatures to allow user to specify "accumulator". ]

[ Bellevue: ]

> The intent of the algorithms is to perform their calculations using the type of the input iterator. Proposed wording provided.

[ Sophia Antipolis: ]

> We did not agree that the proposed resolution was correct. For example, when the arguments are types `(float*, float*, double*)`, the highest-quality solution would use double as the type of the accumulator. If the intent of the wording is to require that the type of the accumulator must be the `input_iterator`'s `value_type`, the wording should specify it.

[ 2009-05-09 Alisdair adds: ]

> Now that we have the facility, the 'best' accumulator type could probably be deduced as:

> >     std::common_type<InIter::value_type, OutIter::reference>::type

> This type would then have additional requirements of constructability and incrementability/assignability.

> If this extracting an accumulator type from a pair/set of iterators (with additional requirements on that type) is a problem for multiple functions, it might be worth extracting into a SharedAccumulator concept or similar.

> I'll go no further in writing up wording now, until the group gives a clearer indication of preferred direction.

[ 2009-07 Frankfurt ]

> The proposed resolution isn't quite right. For example, "the type of *first" should be changed to "iterator::value_type" or similar. Daniel volunteered to correct the wording.

[ 2009-07-29 Daniel corrected wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

1. Change 26.7.3 [partial.sum]/1 as indicated:

   > Effects: Let `VT` be `InputIterator`'s value type. For a nonempty range, initializes an accumulator `acc` of type `VT` with `*first` and performs `*result = acc`. For every iterator `i` in `[first + 1, last)` in order, `acc` is then modified by `acc = acc + *i` or `acc = binary_op(acc, *i)` and is assigned to `*(result + (i - first))`. Assigns to every element referred to by iterator `i` in the range `[result,result + (last - first))` a value correspondingly equal to

   > >     ((...(*first + *(first + 1)) + ...) + *(first + (i - result)))

   > or

   > >     binary_op(binary_op(...,
   > >        binary_op(*first, *(first + 1)),...), *(first + (i - result)))

2. Change 26.7.3 [partial.sum]/3 as indicated:

   > Complexity: Exactly `max((last - first) - 1, 0)` applications of `binary_op` the binary operation.

3. Change 26.7.3 [partial.sum]/4 as indicated:

   > Requires: `VT` shall be constructible from the type of `*first`, the result of `acc + *i` or `binary_op(acc, *i)` shall be implicitly convertible to `VT`, and the result of the expression `acc` shall be writable to the `result` output iterator. In the ranges `[first,last]` and `[result,result + (last - first)]` [..]

4. Change 26.7.4 [adjacent.difference]/1 as indicated:

   > Effects: Let `VT` be `InputIterator`'s value type. For a nonempty range, initializes an accumulator `acc` of type `VT` with `*first` and performs `*result = acc`. For every iterator `i` in `[first + 1, last)` in order, initializes a value `val` of type `VT` with `*i`, assigns the result of `val - acc` or `binary_op(val, acc)` to `*(result + (i - first))` and modifies `acc = std::move(val)`. Assigns to every element referred to by iterator `i` in the range `[result + 1, result + (last - first))` a value correspondingly equal to

   > >     *(first + (i - result)) - *(first + (i - result) - 1)

   > or

   > >     binary_op(*(first + (i - result)), *(first + (i - result) - 1)).

   > result gets the value of *first.

5. Change 26.7.4 [adjacent.difference]/2 as indicated:

   > Requires: `VT` shall be `MoveAssignable` ([moveassignable]) and shall be constructible from the type of `*first`. The result of the expression `acc` and the result of the expression `val - acc` or `binary_op(val, acc)` shall be writable to the `result` output iterator. In the ranges `[first,last]` [..]

6. Change 26.7.4 [adjacent.difference]/5 as indicated:

   > Complexity: Exactly `max((last - first) - 1, 0)` applications of `binary_op` the binary operation.

### 556. is Compare a BinaryPredicate?

Section: 25.4 [alg.sorting] Status: Review Submitter: Martin Sebor Opened: 2006-02-05 Last modified: 2009-10-25

View all other issues in [alg.sorting].

View all issues with Review status.

Discussion:

In 25, p8 we allow BinaryPredicates to return a type that's convertible to bool but need not actually be bool. That allows predicates to return things like proxies and requires that implementations be careful about what kinds of expressions they use the result of the predicate in (e.g., the expression in if (!pred(a, b)) need not be well-formed since the negation operator may be inaccessible or return a type that's not convertible to bool).

Here's the text for reference:

> ...if an algorithm takes BinaryPredicate binary_pred as its argument and first1 and first2 as its iterator arguments, it should work correctly in the construct if (binary_pred(*first1, first2)){...}.

In 25.3, p2 we require that the Compare function object return true of false, which would seem to preclude such proxies. The relevant text is here:

> Compare is used as a function object which returns true if the first argument is less than the second, and false otherwise...

[ Portland: Jack to define "convertible to bool" such that short circuiting isn't destroyed. ]

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10 Santa Cruz: ]

> Move to Review once wording received. Stefanus to send proposed wording.

[ 2009-10 Santa Cruz: ]

> Move to Review once wording received. Stefanus to send proposed wording.

[ 2009-10-24 Stefanus supplied wording. ]

> Move to Review once wording received. Stefanus to send proposed wording. Current proposed wording proposed here:

> > I think we could fix this by rewording 25.3, p2 to read somthing like:

> > > -2- `Compare` is used as a function object which returns `true` if the first argument a `BinaryPredicate`. The return value of the function call operator applied to an object of type `Compare`, when converted to type `bool`, yields `true` if the first argument of the call is less than the second, and `false` otherwise. `Compare comp` is used throughout for algorithms assuming an ordering relation. It is assumed that `comp` will not apply any non-constant function through the dereferenced iterator.

Proposed resolution:

Change 25.4 [alg.sorting] p2:

> `Compare` is used as a function object. The return value of the function call operator applied to an object of type Compare, when converted to type bool, yields true if the first argument of the call which returns `true` if the first argument is less than the second, and `false` otherwise. `Compare comp` is used throughout for algorithms assuming an ordering relation. It is assumed that `comp` will not apply any non-constant function through the dereferenced iterator.

Rationale:

[ San Francisco: ]

> Solved by (N2774).

### 594. Disadvantages of defining Swappable in terms of CopyConstructible and Assignable

Section: 20.2.1 [utility.arg.requirements] Status: Open Submitter: Niels Dekker Opened: 2006-11-02 Last modified: 2009-11-08

View other active issues in [utility.arg.requirements].

View all other issues in [utility.arg.requirements].

View all issues with Open status.

Discussion:

It seems undesirable to define the Swappable requirement in terms of CopyConstructible and Assignable requirements. And likewise, once the MoveConstructible and MoveAssignable requirements (N1860) have made it into the Working Draft, it seems undesirable to define the Swappable requirement in terms of those requirements. Instead, it appears preferable to have the Swappable requirement defined exclusively in terms of the existence of an appropriate swap function.

Section 20.1.4 [lib.swappable] of the current Working Draft (N2009) says:

> The Swappable requirement is met by satisfying one or more of the following conditions:

> - T is Swappable if T satisfies the CopyConstructible requirements (20.1.3) and the Assignable requirements (23.1);
> - T is Swappable if a namespace scope function named swap exists in the same namespace as the definition of T, such that the expression swap(t,u) is valid and has the semantics described in Table 33.

I can think of three disadvantages of this definition:

1. If a client's type T satisfies the first condition (T is both CopyConstructible and Assignable), the client cannot stop T from satisfying the Swappable requirement without stopping T from satisfying the first condition.

   A client might want to stop T from satisfying the Swappable requirement, because swapping by means of copy construction and assignment might throw an exception, and she might find a throwing swap unacceptable for her type. On the other hand, she might not feel the need to fully implement her own swap function for this type. In this case she would want to be able to simply prevent algorithms that would swap objects of type T from being used, e.g., by declaring a swap function for T, and leaving this function purposely undefined. This would trigger a link error, if an attempt would be made to use such an algorithm for this type. For most standard library implementations, this practice would indeed have the effect of stopping T from satisfying the Swappable requirement.

2. A client's type T that does not satisfy the first condition can not be made Swappable by providing a specialization of std::swap for T.

   While I'm aware about the fact that people have mixed feelings about providing a specialization of std::swap, it is well-defined to do so. It sounds rather counter-intuitive to say that T is not Swappable, if it has a valid and semantically correct specialization of std::swap. Also in practice, providing such a specialization will have the same effect as satisfying the Swappable requirement.

3. For a client's type T that satisfies both conditions of the Swappable requirement, it is not specified which of the two conditions prevails. After reading section 20.1.4 [lib.swappable], one might wonder whether objects of T will be swapped by doing copy construction and assignments, or by calling the swap function of T.

   I'm aware that the intention of the Draft is to prefer calling the swap function of T over doing copy construction and assignments. Still in my opinion, it would be better to make this clear in the wording of the definition of Swappable.

I would like to have the Swappable requirement defined in such a way that the following code fragment will correctly swap two objects of a type T, if and only if T is Swappable:

       using std::swap;
       swap(t, u);  // t and u are of type T.

This is also the way Scott Meyers recommends calling a swap function, in Effective C++, Third Edition, item 25.

Most aspects of this issue have been dealt with in a discussion on comp.std.c++ about the Swappable requirement, from 13 September to 4 October 2006, including valuable input by David Abrahams, Pete Becker, Greg Herlihy, Howard Hinnant and others.

[ San Francisco: ]

> Recommend NAD. Solved by N2774.

[ 2009-07 Frankfurt ]

> Moved to Open. Waiting for non-concepts draft.

[ 2009-11-08 Howard adds: ]

> This issue is very closely related to 742.

Proposed resolution:

Change section 20.1.4 [lib.swappable] as follows:

> The Swappable requirement is met by satisfying one or more of the following conditions: the following condition:

> - T is Swappable if T satisfies the CopyConstructible requirements (20.1.3) and the Assignable requirements (23.1);
> - T is Swappable if a namespace scope function named swap exists in the same namespace as the definition of T, such that the expression swap(t,u) is valid and has the semantics described in Table 33. T is Swappable if an unqualified function call swap(t,u) is valid within the namespace std, and has the semantics described in Table 33.

### 625. mixed up Effects and Returns clauses

Section: 17 [library] Status: Open Submitter: Martin Sebor Opened: 2007-01-20 Last modified: 2009-10-20

View other active issues in [library].

View all other issues in [library].

View all issues with Open status.

Duplicate of: 895

Discussion:

Many member functions of `basic_string` are overloaded, with some of the overloads taking a `string` argument, others `value_type*`, others `size_type`, and others still `iterators`. Often, the requirements on one of the overloads are expressed in the form of Effects, Throws, and in the Working Paper (N2134) also Remark clauses, while those on the rest of the overloads via a reference to this overload and using a Returns clause.

The difference between the two forms of specification is that per 17.5.1.4 [structure.specifications], p3, an Effects clause specifies "actions performed by the functions," i.e., its observable effects, while a Returns clause is "a description of the return value(s) of a function" that does not impose any requirements on the function's observable effects.

Since only Notes are explicitly defined to be informative and all other paragraphs are explicitly defined to be normative, like Effects and Returns, the new Remark clauses also impose normative requirements.

So by this strict reading of the standard there are some member functions of `basic_string` that are required to throw an exception under some conditions or use specific traits members while many other otherwise equivalent overloads, while obliged to return the same values, aren't required to follow the exact same requirements with regards to the observable effects.

Here's an example of this problem that was precipitated by the change from informative Notes to normative Remarks (presumably made to address 424):

In the Working Paper, `find(string, size_type)` contains a Remark clause (which is just a Note in the current standard) requiring it to use `traits::eq()`.

`find(const charT *s, size_type pos)` is specified to return `find(string(s), pos)` by a Returns clause and so it is not required to use `traits::eq()`. However, the Working Paper has replaced the original informative Note about the function using `traits::length()` with a normative requirement in the form of a Remark. Calling `traits::length()` may be suboptimal, for example when the argument is a very long array whose initial substring doesn't appear anywhere in `*this`.

Here's another similar example, one that existed even prior to the introduction of Remarks:

`insert(size_type pos, string, size_type, size_type)` is required to throw `out_of_range` if `pos > size()`.

`insert(size_type pos, string str)` is specified to return `insert(pos, str, 0, npos)` by a Returns clause and so its effects when `pos > size()` are strictly speaking unspecified.

I believe a careful review of the current Effects and Returns clauses is needed in order to identify all such problematic cases. In addition, a review of the Working Paper should be done to make sure that the newly introduced normative Remark clauses do not impose any undesirable normative requirements in place of the original informative Notes.

[ Batavia: Alan and Pete to work. ]

[ Bellevue: Marked as NAD Editorial. ]

[ Post-Sophia Antipolis: Martin indicates there is still work to be done on this issue. Reopened. ]

[ Batavia (2009-05): ]

> Tom proposes we say that, unless specified otherwise, it is always the caller's responsibility to verify that supplied arguments meet the called function's requirements. If further semantics are specified (e.g., that the function throws under certain conditions), then it is up to the implementer to check those conditions. Alan feels strongly that our current use of Requires in this context is confusing, especially now that `requires` is a new keyword.

[ 2009-07 Frankfurt ]

> Move to Tentatively NAD.

[ 2009 Santa Cruz: ]

> Move to Open. Martin will work on proposed wording.

Proposed resolution:

### 631. conflicting requirements for `BinaryPredicate`

Section: 25 [algorithms] Status: Review Submitter: James Kanze Opened: 2007-01-31 Last modified: 2009-10-24

View other active issues in [algorithms].

View all other issues in [algorithms].

View all issues with Review status.

Discussion:

The general requirements for ``BinaryPredicate`` (in 25 [algorithms]/8) contradict the implied specific requirements for some functions. In particular, it says that:

> [...] if an algorithm takes `BinaryPredicate binary_pred` as its argument and `first1` and first2 as its iterator arguments, it should work correctly in the construct `if (binary_pred (*first1 , *first2 )){...}`. `BinaryPredicate` always takes the first iterator type as its first argument, that is, in those cases when `T value` is part of the signature, it should work correctly in the context of `if (binary_pred (*first1 , value)){...}`.

In the description of `upper_bound` (25.4.3.2 [upper.bound]/2), however, the use is described as "`!comp(value, e)`", where `e` is an element of the sequence (a result of dereferencing `*first`).

In the description of `lexicographical_compare`, we have both "`*first1 < *first2`" and "`*first2 < *first1`" (which presumably implies "`comp( *first1, *first2 )`" and "`comp( *first2, *first1 )`".

[ Toronto: Moved to Open. ConceptGCC seems to get `lower_bound` and `upper_bound` to work withoutt these changes. ]

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10 Santa Cruz: ]

> Move to Review. The small problem with the "iterator type" will be fixed. The cited functions (`lower_bound`, `uppwer_bound`, `equal_range`) don't actually use `BinaryPredicate` , and where it is used, it is consistent with [algorithm]/8, so the main complaint of the issue is moot.

Proposed resolution:

Logically, the `BinaryPredicate` is used as an ordering relationship, with the semantics of "less than". Depending on the function, it may be used to determine equality, or any of the inequality relationships; doing this requires being able to use it with either parameter first. I would thus suggest that the requirement be:

> [...] `BinaryPredicate` always takes the first iterator `value_type` as one of its arguments, it is unspecified which. If an algorithm takes `BinaryPredicate binary_pred` as its argument and `first1` and first2 as its iterator arguments, it should work correctly both in the construct `if (binary_pred (*first1 , *first2 )){...}` and `if (binary_pred (*first2, *first1)){...}`. In those cases when `T value` is part of the signature, it should work correctly in the context of `if (binary_pred (*first1 , value)){...}` and of `if (binary_pred (value, *first1)){...}`. [Note: if the two types are not identical, and neither is convertable to the other, this may require that the `BinaryPredicate` be a functional object with two overloaded `operator()()` functions. --end note]

Alternatively, one could specify an order for each function. IMHO, this would be more work for the committee, more work for the implementors, and of no real advantage for the user: some functions, such as `lexicographical_compare` or `equal_range`, will still require both functions, and it seems like a much easier rule to teach that both functions are always required, rather than to have a complicated list of when you only need one, and which one.

Rationale:

[ post San Francisco: ]

> Solved by N2759.

### 671. precision of hexfloat

Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Ready Submitter: John Salmon Opened: 2007-04-20 Last modified: 2009-10-21

View other active issues in [facet.num.put.virtuals].

View all other issues in [facet.num.put.virtuals].

View all issues with Ready status.

Discussion:

I am trying to understand how TR1 supports hex float (%a) output.

As far as I can tell, it does so via the following:

8.15 Additions to header <locale> [tr.c99.locale]

In subclause 22.4.2.2.2 [facet.num.put.virtuals], Table 58 Floating-point conversions, after the line: floatfield == ios_base::scientific %E

add the two lines:

>     floatfield == ios_base::fixed | ios_base::scientific && !uppercase %a
>     floatfield == ios_base::fixed | ios_base::scientific %A 2

[Note: The additional requirements on print and scan functions, later in this clause, ensure that the print functions generate hexadecimal floating-point fields with a %a or %A conversion specifier, and that the scan functions match hexadecimal floating-point fields with a %g conversion specifier. end note]

Following the thread, in 22.4.2.2.2 [facet.num.put.virtuals], we find:

For conversion from a floating-point type, if (flags & fixed) != 0 or if str.precision() > 0, then str.precision() is specified in the conversion specification.

This would seem to imply that when floatfield == fixed|scientific, the precision of the conversion specifier is to be taken from str.precision(). Is this really what's intended? I sincerely hope that I'm either missing something or this is an oversight. Please tell me that the committee did not intend to mandate that hex floats (and doubles) should by default be printed as if by %.6a.

[ Howard: I think the fundamental issue we overlooked was that with %f, %e, %g, the default precision was always 6. With %a the default precision is not 6, it is infinity. So for the first time, we need to distinguish between the default value of precision, and the precision value 6. ]

[ 2009-07 Frankfurt ]

> Leave this open for Robert and Daniel to work on.

> Straw poll: Disposition?

> - Default is %.6a (i.e. NAD): 2
> - Always %a (no precision): 6
> - precision(-1) == %a: 3

> Daniel and Robert have direction to write up wording for the "always %a" solution.

> [ 2009-07-15 Robert provided wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change 22.4.2.2.2 [facet.num.put.virtuals], Stage 1, under p5 (near the end of Stage 1):

> For conversion from a floating-point type, `str.precision()` is specified as precision in the conversion specification if `floatfield != (ios_base::fixed | ios_base::scientific)`, else no precision is specified.

[ Kona (2007): Robert volunteers to propose wording. ]

### 676. Moving the unordered containers

Section: 23.5 [unord] Status: Review Submitter: Howard Hinnant Opened: 2007-05-05 Last modified: 2009-10-29

View all other issues in [unord].

View all issues with Review status.

Discussion:

Move semantics are missing from the `unordered` containers. The proposed resolution below adds move-support consistent with N1858 and the current working draft.

The current proposed resolution simply lists the requirements for each function. These might better be hoisted into the requirements table for unordered associative containers. Futhermore a mild reorganization of the container requirements could well be in order. This defect report is purposefully ignoring these larger issues and just focusing on getting the unordered containers "moved".

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10-17 Removed rvalue-swaps from wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Review. Alisdair will review proposed wording.

[ 2009-10-29 Daniel updates wording. ]

Proposed resolution:

`unordered_map`

Change 23.5.1 [unord.map]:

>     class unordered_map
>     {
>         ...
>         unordered_map(const unordered_map&);
>         unordered_map(unordered_map&&);
>         ~unordered_map();
>         unordered_map& operator=(const unordered_map&);
>         unordered_map& operator=(unordered_map&&);
>         ...
>         // modifiers
>         std::pair<iterator, bool> insert(const value_type& obj);
>         template <class P> pair<iterator, bool> insert(P&& obj);
>         iterator       insert(const_iterator hint, const value_type& obj);
>         template <class P> iterator       insert(const_iterator hint, P&& obj);
>         ...
>         mapped_type& operator[](const key_type& k);
>         mapped_type& operator[](key_type&& k);
>         ...
>     };

Add to 23.5.1.1 [unord.map.cnstr]:

>     template <class InputIterator>
>       unordered_map(InputIterator f, InputIterator l,
>                     size_type n = implementation-defined,
>                     const hasher& hf = hasher(),
>                     const key_equal& eql = key_equal(),
>                     const allocator_type& a = allocator_type());

> > Requires: If the iterator's dereference operator returns an lvalue or a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and `mapped_type` shall be `CopyConstructible`.

Add to 23.5.1.2 [unord.map.elem]:

>     mapped_type& operator[](const key_type& k);

> > ...

> > Requires: `key_type` shall be `CopyConstructible` and `mapped_type` shall be `DefaultConstructible`.

>     mapped_type& operator[](key_type&& k);

> > Effects: If the `unordered_map` does not already contain an element whose key is equivalent to `k` , inserts the value `std::pair<const key_type, mapped_type>(std::move(k), mapped_type())`.

> > Requires: `mapped_type` shall be `DefaultConstructible`.

> > Returns: A reference to `x.second`, where `x` is the (unique) element whose key is equivalent to `k`.

Add new section [unord.map.modifiers]:

>     pair<iterator, bool> insert(const value_type& x);
>     template <class P> pair<iterator, bool> insert(P&& x);
>     iterator       insert(const_iterator hint, const value_type& x);
>     template <class P> iterator       insert(const_iterator hint, P&& x);
>     template <class InputIterator>
>       void insert(InputIterator first, InputIterator last);

> > Requires: Those signatures taking a `const value_type&` parameter requires both the `key_type` and the `mapped_type` to be `CopyConstructible`. If `P` is instantiated as a reference type, then the argument `x` is copied from. Otherwise `x` is considered to be an rvalue as it is converted to `value_type` and inserted into the `unordered_map`. Specifically, in such cases `CopyConstructible` is not required for `key_type` or `mapped_type` unless the conversion from `P` specifically requires it (e.g. if `P` is a `tuple<const key_type, mapped_type>`, then `key_type` must be `CopyConstructible`).

> > The signature taking `InputIterator` parameters requires `CopyConstructible` of both `key_type` and `mapped_type` if the dereferenced `InputIterator` returns an lvalue or `const` rvalue `value_type`.

`unordered_multimap`

Change 23.5.2 [unord.multimap]:

>     class unordered_multimap
>     {
>         ...
>         unordered_multimap(const unordered_multimap&);
>         unordered_multimap(unordered_multimap&&);
>         ~unordered_multimap();
>         unordered_multimap& operator=(const unordered_multimap&);
>         unordered_multimap& operator=(unordered_multimap&&);
>         ...
>         // modifiers
>         iterator insert(const value_type& obj);
>         template <class P> iterator insert(P&& obj);
>         iterator       insert(const_iterator hint, const value_type& obj);
>         template <class P> iterator       insert(const_iterator hint, P&& obj);
>         ...
>     };

Add to 23.5.2.1 [unord.multimap.cnstr]:

>     template <class InputIterator>
>       unordered_multimap(InputIterator f, InputIterator l,
>                     size_type n = implementation-defined,
>                     const hasher& hf = hasher(),
>                     const key_equal& eql = key_equal(),
>                     const allocator_type& a = allocator_type());

> > Requires: If the iterator's dereference operator returns an lvalue or a const rvalue `pair<key_type, mapped_type>`, then both `key_type` and `mapped_type` shall be `CopyConstructible`.

Add new section [unord.multimap.modifiers]:

>     iterator insert(const value_type& x);
>     template <class P> iterator       insert(P&& x);
>     iterator       insert(const_iterator hint, const value_type& x);
>     template <class P> iterator       insert(const_iterator hint, P&& x);
>     template <class InputIterator>
>       void insert(InputIterator first, InputIterator last);

> > Requires: Those signatures taking a `const value_type&` parameter requires both the `key_type` and the `mapped_type` to be `CopyConstructible`. If `P` is instantiated as a reference type, then the argument `x` is copied from. Otherwise `x` is considered to be an rvalue as it is converted to `value_type` and inserted into the `unordered_multimap`. Specifically, in such cases `CopyConstructible` is not required for `key_type` or `mapped_type` unless the conversion from `P` specifically requires it (e.g. if `P` is a `tuple<const key_type, mapped_type>`, then `key_type` must be `CopyConstructible`).

> > The signature taking `InputIterator` parameters requires `CopyConstructible` of both `key_type` and `mapped_type` if the dereferenced `InputIterator` returns an lvalue or `const` rvalue `value_type`.

`unordered_set`

Change 23.5.3 [unord.set]:

>     class unordered_set
>     {
>         ...
>         unordered_set(const unordered_set&);
>         unordered_set(unordered_set&&);
>         ~unordered_set();
>         unordered_set& operator=(const unordered_set&);
>         unordered_set& operator=(unordered_set&&);
>         ...
>         // modifiers
>         std::pair<iterator, bool> insert(const value_type& obj);
>         pair<iterator, bool> insert(value_type&& obj);
>         iterator       insert(const_iterator hint, const value_type& obj);
>         iterator       insert(const_iterator hint, value_type&& obj);
>         ...
>     };

Add to 23.5.3.1 [unord.set.cnstr]:

>     template <class InputIterator>
>       unordered_set(InputIterator f, InputIterator l,
>                     size_type n = implementation-defined,
>                     const hasher& hf = hasher(),
>                     const key_equal& eql = key_equal(),
>                     const allocator_type& a = allocator_type());

> > Requires: If the iterator's dereference operator returns an lvalue or a const rvalue `value_type`, then the `value_type` shall be `CopyConstructible`.

Add new section [unord.set.modifiers]:

>     pair<iterator, bool> insert(const value_type& x);
>     pair<iterator, bool> insert(value_type&& x);
>     iterator       insert(const_iterator hint, const value_type& x);
>     iterator       insert(const_iterator hint, value_type&& x);
>     template <class InputIterator>
>       void insert(InputIterator first, InputIterator last);

> > Requires: Those signatures taking a `const value_type&` parameter requires the `value_type` to be `CopyConstructible`.

> > The signature taking `InputIterator` parameters requires `CopyConstructible` of `value_type` if the dereferenced `InputIterator` returns an lvalue or `const` rvalue `value_type`.

`unordered_multiset`

Change 23.5.4 [unord.multiset]:

>     class unordered_multiset
>     {
>         ...
>         unordered_multiset(const unordered_multiset&);
>         unordered_multiset(unordered_multiset&&);
>         ~unordered_multiset();
>         unordered_multiset& operator=(const unordered_multiset&);
>         unordered_multiset& operator=(unordered_multiset&&);
>         ...
>         // modifiers
>         iterator insert(const value_type& obj);
>         iterator insert(value_type&& obj);
>         iterator       insert(const_iterator hint, const value_type& obj);
>         iterator       insert(const_iterator hint, value_type&& obj);
>         ...
>     };

Add to 23.5.4.1 [unord.multiset.cnstr]:

>     template <class InputIterator>
>       unordered_multiset(InputIterator f, InputIterator l,
>                     size_type n = implementation-defined,
>                     const hasher& hf = hasher(),
>                     const key_equal& eql = key_equal(),
>                     const allocator_type& a = allocator_type());

> > Requires: If the iterator's dereference operator returns an lvalue or a const rvalue `value_type`, then the `value_type` shall be `CopyConstructible`.

Add new section [unord.multiset.modifiers]:

>     iterator insert(const value_type& x);
>     iterator insert(value_type&& x);
>     iterator       insert(const_iterator hint, const value_type& x);
>     iterator       insert(const_iterator hint, value_type&& x);
>     template <class InputIterator>
>       void insert(InputIterator first, InputIterator last);

> > Requires: Those signatures taking a `const value_type&` parameter requires the `value_type` to be `CopyConstructible`.

> > The signature taking `InputIterator` parameters requires `CopyConstructible` of `value_type` if the dereferenced `InputIterator` returns an lvalue or `const` rvalue `value_type`.

[ Voted to WP in Bellevue. ]

[ post Bellevue, Pete notes: ]

> Please remind people who are reviewing issues to check that the text modifications match the current draft. Issue 676, for example, adds two overloads for unordered_map::insert taking a hint. One takes a const_iterator and returns a const_iterator, and the other takes an iterator and returns an iterator. This was correct at the time the issue was written, but was changed in Toronto so there is only one hint overload, taking a const_iterator and returning an iterator.

> This issue is not ready. In addition to the relatively minor signature problem I mentioned earlier, it puts requirements in the wrong places. Instead of duplicating requirements throughout the template specifications, it should put them in the front matter that talks about requirements for unordered containers in general. This presentation problem is editorial, but I'm not willing to do the extensive rewrite that it requires. Please put it back into Open status.

Rationale:

[ San Francisco: ]

> Solved by N2776.

### 704. MoveAssignable requirement for container value type overly strict

Section: 23.2 [container.requirements] Status: Open Submitter: Howard Hinnant Opened: 2007-05-20 Last modified: 2009-10-20

View other active issues in [container.requirements].

View all other issues in [container.requirements].

View all issues with Open status.

Discussion:

The move-related changes inadvertently overwrote the intent of 276. Issue 276 removed the requirement of `CopyAssignable` from most of the member functions of node-based containers. But the move-related changes unnecessarily introduced the `MoveAssignable` requirement for those members which used to require `CopyAssignable`.

We also discussed (c++std-lib-18722) the possibility of dropping `MoveAssignable` from some of the sequence requirements. Additionally the in-place construction work may further reduce requirements. For purposes of an easy reference, here are the minimum sequence requirements as I currently understand them. Those items in requirements table in the working draft which do not appear below have been purposefully omitted for brevity as they do not have any requirements of this nature. Some items which do not have any requirements of this nature are included below just to confirm that they were not omitted by mistake.

Container Requirements
`X u(a)` | `value_type` must be `CopyConstructible`
`X u(rv)` | `array` and containers with a `propagate_never` allocator require `value_type` to be `MoveConstructible`
`a = u` | Sequences require `value_type` to be `CopyConstructible` and `CopyAssignable`. Associative containers require `value_type` to be `CopyConstructible`.
`a = rv` | `array` requires `value_type` to be `MoveAssignable`. Sequences and Associative containers with `propagate_never` and `propagate_on_copy_construction` allocators require `value_type` to be `MoveConstructible`.
`swap(a,u)` | `array` and containers with `propagate_never` and `propagate_on_copy_construction` allocators require `value_type` to be `Swappable`.

Sequence Requirements
`X(n)` | `value_type` must be `DefaultConstructible`
`X(n, t)` | `value_type` must be `CopyConstructible`
`X(i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. If the iterators return an rvalue the `value_type` must be `MoveConstructible`.
`a.insert(p, t)` | The `value_type` must be `CopyConstructible`. The sequences `vector` and `deque` also require the `value_type` to be `CopyAssignable`.
`a.insert(p, rv)` | The `value_type` must be `MoveConstructible`. The sequences `vector` and `deque` also require the `value_type` to be `MoveAssignable`.
`a.insert(p, n, t)` | The `value_type` must be `CopyConstructible`. The sequences `vector` and `deque` also require the `value_type` to be `CopyAssignable`.
`a.insert(p, i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. The sequences `vector` and `deque` also require the `value_type` to be `CopyAssignable` when the iterators return an lvalue. If the iterators return an rvalue the `value_type` must be `MoveConstructible`. The sequences `vector` and `deque` also require the `value_type` to be `MoveAssignable` when the iterators return an rvalue.
`a.erase(p)` | The sequences `vector` and `deque` require the `value_type` to be `MoveAssignable`.
`a.erase(q1, q2)` | The sequences `vector` and `deque` require the `value_type` to be `MoveAssignable`.
`a.clear()` |
`a.assign(i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible` and `CopyAssignable`. If the iterators return an rvalue the `value_type` must be `MoveConstructible` and `MoveAssignable`.
`a.assign(n, t)` | The `value_type` must be `CopyConstructible` and `CopyAssignable`.
`a.resize(n)` | The `value_type` must be `DefaultConstructible`. The sequence `vector` also requires the `value_type` to be `MoveConstructible`.
`a.resize(n, t)` | The `value_type` must be `CopyConstructible`.

Optional Sequence Requirements
`a.front()` |
`a.back()` |
`a.push_front(t)` | The `value_type` must be `CopyConstructible`.
`a.push_front(rv)` | The `value_type` must be `MoveConstructible`.
`a.push_back(t)` | The `value_type` must be `CopyConstructible`.
`a.push_back(rv)` | The `value_type` must be `MoveConstructible`.
`a.pop_front()` |
`a.pop_back()` |
`a[n]` |
`a.at[n]` |

Associative Container Requirements
`X(i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. If the iterators return an rvalue the `value_type` must be `MoveConstructible`.
`a_uniq.insert(t)` | The `value_type` must be `CopyConstructible`.
`a_uniq.insert(rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a_eq.insert(t)` | The `value_type` must be `CopyConstructible`.
`a_eq.insert(rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a.insert(p, t)` | The `value_type` must be `CopyConstructible`.
`a.insert(p, rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a.insert(i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. If the iterators return an rvalue the `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`..

Unordered Associative Container Requirements
`X(i, j, n, hf, eq)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. If the iterators return an rvalue the `value_type` must be `MoveConstructible`.
`a_uniq.insert(t)` | The `value_type` must be `CopyConstructible`.
`a_uniq.insert(rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a_eq.insert(t)` | The `value_type` must be `CopyConstructible`.
`a_eq.insert(rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a.insert(p, t)` | The `value_type` must be `CopyConstructible`.
`a.insert(p, rv)` | The `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`.
`a.insert(i, j)` | If the iterators return an lvalue the `value_type` must be `CopyConstructible`. If the iterators return an rvalue the `key_type` and the `mapped_type` (if it exists) must be `MoveConstructible`..

Miscellaneous Requirements
`map[lvalue-key]` | The `key_type` must be `CopyConstructible`. The `mapped_type` must be `DefaultConstructible` and `MoveConstructible`.
`map[rvalue-key]` | The `key_type` must be `MoveConstructible`. The `mapped_type` must be `DefaultConstructible` and `MoveConstructible`.

[ Kona (2007): Howard and Alan to update requirements table in issue with emplace signatures. ]

[ Bellevue: This should be handled as part of the concepts work. ]

[ 2009-07-20 Reopened by Howard: ]

> This is one of the issues that was "solved by concepts" and is now no longer solved.

> In a nutshell, concepts adopted the "minimum requirements" philosophy outlined in the discussion of this issue, and enforced it. My strong suggestion is that we translate the concepts specification into documentation for the containers.

> What this means for vendors is that they will have to implement container members being careful to only use those characteristics of a type that the concepts specification formally allowed. Note that I am not talking about `enable_if`'ing everything. I am simply suggesting that (for example) we tell the vendor he can't call `T's` copy constructor or move constructor within the `emplace` member function, etc.

> What this means for customers is that they will be able to use types within C++03 containers which are sometimes not CopyConstructible, and sometimes not even MoveConstructible, etc.

[ 2009-10 Santa Cruz: ]

> Leave open. Howard to provide wording.

Proposed resolution:

Rationale:

[ post San Francisco: ]

> Solved by N2776.

### 724. `DefaultConstructible` is not defined

Section: 20.2.1 [utility.arg.requirements] Status: Open Submitter: Pablo Halpern Opened: 2007-09-12 Last modified: 2009-10-23

View other active issues in [utility.arg.requirements].

View all other issues in [utility.arg.requirements].

View all issues with Open status.

Discussion:

The `DefaultConstructible` requirement is referenced in several places in the August 2007 working draft N2369, but is not defined anywhere.

[ Bellevue: ]

> Walking into the default/value-initialization mess...

> Why two lines? Because we need both expressions to be valid.

> AJM not sure what the phrase "default constructed" means. This is unfortunate, as the phrase is already used 24 times in the library!

> Example: const int would not accept first line, but will accept the second.

> This is an issue that must be solved by concepts, but we might need to solve it independantly first.

> It seems that the requirements are the syntax in the proposed first column is valid, but not clear what semantics we need.

> A table where there is no post-condition seems odd, but appears to sum up our position best.

> At a minimum an object is declared and is destuctible.

> Move to open, as no-one happy to produce wording on the fly.

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-08-17 Daniel adds "[defaultconstructible]" to table title. 408 depends upon this issue. ]

[ 2009-08-18 Alisdair adds: ]

> Looking at the proposed table in this issue, it really needs two rows:

> > Table 33: `DefaultConstructible` requirements [defaultconstructible]
> > expression | post-condition
> > --- | ---
> > `T t;` | `t` is default-initialized.
> > `T{}` | Object of type `T` is value-initialized.

> Note I am using the new brace-initialization syntax that is unambiguous in all use cases (no most vexing parse.)

[ 2009-10-03 Daniel adds: ]

> The suggested definition `T{}` describing it as value-initialization is wrong, because it belongs to list-initialization which would - as the current rules are - always prefer a initializer-list constructor over a default-constructor. I don't consider this as an appropriate definition of `DefaultConstructible`. My primary suggestion is to ask core, whether the special case `T{}` (which also easily leads to ambiguity situations for more than one initializer-list in a class) would always prefer a default-constructor - if any - before considering an initializer-list constructor or to provide another syntax form to prefer value-initialization over list-initialization. If that fails I would fall back to suggest to use the expression `T()` instead of `T{}` with all it's disadvantages for the meaning of the expression

> >     T t();

[ 2009-10 Santa Cruz: ]

> Leave Open. Core is looking to make Alisdair's proposed resolution correct.

Proposed resolution:

In section 20.2.1 [utility.arg.requirements], before table 33, add the following table:

Table 33: `DefaultConstructible` requirements [defaultconstructible]

expression | post-condition
`T t;` `T()` | `T` is default constructed.

Rationale:

[ San Francisco: ]

> We believe concepts will solve this problem (N2774).

### 726. Missing `regex_replace()` overloads

Section: 28.11.4 [re.alg.replace] Status: Open Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-10-23

View other active issues in [re.alg.replace].

View all other issues in [re.alg.replace].

View all issues with Open status.

Discussion:

Two overloads of `regex_replace()` are currently provided:

>     template <class OutputIterator, class BidirectionalIterator,
>         class traits, class charT>
>       OutputIterator
>       regex_replace(OutputIterator out,
>                     BidirectionalIterator first, BidirectionalIterator last,
>                     const basic_regex<charT, traits>& e,
>                     const basic_string<charT>& fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

>     template <class traits, class charT>
>       basic_string<charT>
>       regex_replace(const basic_string<charT>& s,
>                     const basic_regex<charT, traits>& e,
>                     const basic_string<charT>& fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

1. Overloads taking `const charT *` are provided for `regex_match()` and `regex_search()`, but not `regex_replace()`. This is inconsistent.

2. The absence of `const charT *` overloads prevents ordinary-looking code from compiling, such as:

   >     const string s("kitten");
   >     const regex r("en");
   >     cout << regex_replace(s, r, "y") << endl;

   The compiler error message will be something like "could not deduce template argument for 'const std::basic_string<_Elem> &' from 'const char[1]'".

   Users expect that anything taking a `basic_string<charT>` can also take a `const charT *`. In their own code, when they write a function taking `std::string` (or `std::wstring`), they can pass a `const char *` (or `const wchar_t *`), thanks to `basic_string`'s implicit constructor. Because the regex algorithms are templated on `charT`, they can't rely on `basic_string`'s implicit constructor (as the compiler error message indicates, template argument deduction fails first).

   If a user figures out what the compiler error message means, workarounds are available - but they are all verbose. Explicit template arguments could be given to `regex_replace()`, allowing `basic_string`'s implicit constructor to be invoked - but `charT` is the last template argument, not the first, so this would be extremely verbose. Therefore, constructing a `basic_string` from each C string is the simplest workaround.

3. There is an efficiency consideration: constructing `basic_string`s can impose performance costs that could be avoided by a library implementation taking C strings and dealing with them directly. (Currently, for replacement sources, C strings can be converted into iterator pairs at the cost of verbosity, but for format strings, there is no way to avoid constructing a `basic_string`.)

[ Sophia Antipolis: ]

> We note that Boost already has these overloads. However, the proposed wording is provided only for 28.11.4 [re.alg.replace]; wording is needed for the synopsis as well. We also note that this has impact on `match_results::format`, which may require further overloads.

[ 2009-07 Frankfurt: ]

> Daniel to tweak for us.

[ 2009-07-25 Daniel tweaks both this issue and 727. ]

> This is solved by the proposed resolution of 727.

[ 2009-10 Santa Cruz: ]

> Leave Open. Though we believe this is solved by the proposed resolution to 727.

Proposed resolution:

Provide additional overloads for `regex_replace()`: one additional overload of the iterator-based form (taking `const charT* fmt`), and three additional overloads of the convenience form (one taking `const charT* str`, another taking `const charT* fmt`, and the third taking both `const charT* str` and `const charT* fmt`). 28.11.4 [re.alg.replace]:

>     template <class OutputIterator, class BidirectionalIterator,
>         class traits, class charT>
>       OutputIterator
>       regex_replace(OutputIterator out,
>                     BidirectionalIterator first, BidirectionalIterator last,
>                     const basic_regex<charT, traits>& e,
>                     const basic_string<charT>& fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

>     template <class OutputIterator, class BidirectionalIterator,
>         class traits, class charT>
>       OutputIterator
>       regex_replace(OutputIterator out,
>                     BidirectionalIterator first, BidirectionalIterator last,
>                     const basic_regex<charT, traits>& e,
>                     const charT* fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

> ...

>     template <class traits, class charT>
>       basic_string<charT>
>       regex_replace(const basic_string<charT>& s,
>                     const basic_regex<charT, traits>& e,
>                     const basic_string<charT>& fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

>     template <class traits, class charT>
>       basic_string<charT>
>       regex_replace(const basic_string<charT>& s,
>                     const basic_regex<charT, traits>& e,
>                     const charT* fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

>     template <class traits, class charT>
>       basic_string<charT>
>       regex_replace(const charT* s,
>                     const basic_regex<charT, traits>& e,
>                     const basic_string<charT>& fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

>     template <class traits, class charT>
>       basic_string<charT>
>       regex_replace(const charT* s,
>                     const basic_regex<charT, traits>& e,
>                     const charT* fmt,
>                     regex_constants::match_flag_type flags =
>                       regex_constants::match_default);

### 727. `regex_replace()` doesn't accept `basic_string`s with custom traits and allocators

Section: 28.11.4 [re.alg.replace] Status: Review Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-10-23

View other active issues in [re.alg.replace].

View all other issues in [re.alg.replace].

View all issues with Review status.

Discussion:

`regex_match()` and `regex_search()` take `const basic_string<charT, ST, SA>&`. `regex_replace()` takes `const basic_string<charT>&`. This prevents `regex_replace()` from accepting `basic_string`s with custom traits and allocators.

Overloads of `regex_replace()` taking `basic_string` should be additionally templated on `class ST, class SA` and take `const basic_string<charT, ST, SA>&`. Consistency with `regex_match()` and `regex_search()` would place `class ST, class SA` as the first template arguments; compatibility with existing code using TR1 and giving explicit template arguments to `regex_replace()` would place `class ST, class SA` as the last template arguments.

[ Batavia (2009-05): ]

> Bill comments, "We need to look at the depth of this change."

> Pete remarks that we are here dealing with a convenience function that saves a user from calling the iterato-based overload.

> Move to Open.

[ 2009-07 Frankfurt: ]

> Howard to ask Stephan Lavavej to provide wording.

[ 2009-07-17 Stephan provided wording. ]

[ 2009-07-25 Daniel tweaks both this issue and 726. ]

> One relevant part of the proposed resolution below suggests to add a new overload of the format member function in the `match_results` class template that accepts two character pointers defining the `begin` and `end` of a format range. A more general approach could have proposed a pair of iterators instead, but the used pair of char pointers reflects existing practice. If the committee strongly favors an iterator-based signature, this could be simply changed. I think that the minimum requirement should be a `BidirectionalIterator`, but current implementations take advantage (at least partially) of the `RandomAccessIterator` sub interface of the char pointers.

> Suggested Resolution:

> [Moved into the proposed resloution]

[ 2009-07-30 Stephan agrees with Daniel's wording. Howard places Daniel's wording in the Proposed Resolution. ]

[ 2009-10 Santa Cruz: ]

> Move to Review. Chair is anxious to move this to Ready in Pittsburgh.

Proposed resolution:

1. Change 28.4 [re.syn] as indicated:

   >     // 28.11.4, function template regex_replace:
   >     template <class OutputIterator, class BidirectionalIterator,
   >               class traits, class charT, class ST, class SA>
   >       OutputIterator
   >       regex_replace(OutputIterator out,
   >                     BidirectionalIterator first, BidirectionalIterator last,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, ST, SA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class OutputIterator, class BidirectionalIterator,
   >               class traits, class charT>
   >       OutputIterator
   >       regex_replace(OutputIterator out,
   >                     BidirectionalIterator first, BidirectionalIterator last,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT, class ST, class SA,
   >               class FST, class FSA>
   >       basic_string<charT, ST, SA>
   >       regex_replace(const basic_string<charT, ST, SA>& s,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, FST, FSA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT, class ST, class SA>
   >       basic_string<charT, ST, SA>
   >       regex_replace(const basic_string<charT, ST, SA>& s,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT, class ST, class SA>
   >       basic_string<charT>
   >       regex_replace(const charT* s,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, ST, SA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT>
   >       basic_string<charT>
   >       regex_replace(const charT* s,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

2. Change 28.10 [re.results]/3, class template `match_results` as indicated:

   >     template <class OutputIter>
   >       OutputIter
   >       format(OutputIter out,
   >              const char_type* fmt_first, const char_type* fmt_last,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   >     template <class OutputIter, class ST, class SA>
   >       OutputIter
   >       format(OutputIter out,
   >              const string_typebasic_string<char_type, ST, SA>& fmt,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   >     template <class ST, class SA>
   >       string_typebasic_string<char_type, ST, SA>
   >       format(const string_typebasic_string<char_type, ST, SA>& fmt,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   >     string_type
   >     format(const char_type* fmt,
   >            regex_constants::match_flag_type flags =
   >              regex_constants::format_default) const;

3. Insert at the very beginning of 28.10.4 [re.results.form] the following:

   >     template <class OutputIter>
   >       OutputIter
   >       format(OutputIter out,
   >              const char_type* fmt_first, const char_type* fmt_last,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   > > 1 Requires: The type `OutputIter` shall satisfy the requirements for an Output Iterator (24.2.2 [output.iterators]).

   > > 2 Effects: Copies the character sequence `[fmt_first,fmt_last)` to `OutputIter out`. Replaces each format specifier or escape sequence in the copied range with either the character(s) it represents or the sequence of characters within `*this` to which it refers. The bitmasks specified in `flags` determines what format specifiers and escape sequences are recognized.

   > > 3 Returns: `out`.

4. Change 28.10.4 [re.results.form], before p. 1 until p. 3 (according to previous numbering) as indicated:

   >     template <class OutputIter, class ST, class SA>
   >       OutputIter
   >       format(OutputIter out,
   >              const string_typebasic_string<char_type, ST, SA>& fmt,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   > > Requires: The type `OutputIter` shall satisfy the requirements for an Output Iterator (24.2.3).

   > > Effects: Copies the character sequence `[fmt.begin(),fmt.end())` to `OutputIter out`. Replaces each format specifier or escape sequence in `fmt` with either the character(s) it represents or the sequence of characters within `*this` to which it refers. The bitmasks specified in `flags` determines what format specifiers and escape sequences are recognized.

   > > Returns: `outformat(out, fmt.data(), fmt.data() + fmt.size(), flags)`.

5. Change 28.10.4 [re.results.form], before p. 4 until p. 4 (according to previous numbering) as indicated:

   >     template <class ST, class SA>
   >       string_typebasic_string<char_type, ST, SA>
   >       format(const string_typebasic_string<char_type, ST, SA>& fmt,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   > > Effects: Returns a copy of the string `fmt`. Replaces each format specifier or escape sequence in `fmt` with either the character(s) it represents or the sequence of characters within `*this` to which it refers. The bitmasks specified in flags determines what format specifiers and escape sequences are recognized. Constructs an empty string `result` of type `basic_string<char_type, ST, SA>`, and calls `format(back_inserter(result), fmt, flags)`.

   > > Returns: `result`

6. At the end of 28.10.4 [re.results.form] insert as indicated:

   >     string_type
   >       format(const char_type* fmt,
   >              regex_constants::match_flag_type flags =
   >                regex_constants::format_default) const;

   > > Effects: Constructs an empty string `result` of type `string_type`, and calls `format(back_inserter(result), fmt, fmt + char_traits<char_type>::length(fmt), flags)`.

   > > Returns: `result`

7. Change 28.11.4 [re.alg.replace] before p. 1 as indicated:

   >     template <class OutputIterator, class BidirectionalIterator,
   >               class traits, class charT, class ST, class SA>
   >       OutputIterator
   >       regex_replace(OutputIterator out,
   >                     BidirectionalIterator first, BidirectionalIterator last,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, ST, SA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class OutputIterator, class BidirectionalIterator,
   >               class traits, class charT>
   >       OutputIterator
   >       regex_replace(OutputIterator out,
   >                     BidirectionalIterator first, BidirectionalIterator last,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   > > Effects: [..]. If any matches are found then, for each such match, if `!(flags & regex_constants::format_no_copy)` calls `std::copy(m.prefix().first, m.prefix().second, out)`, and then calls `m.format(out, fmt, flags)` for the first form of the function and `m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags)` for the second form. [..].

8. Change 28.11.4 [re.alg.replace] before p. 3 as indicated:

   >     template <class traits, class charT, class ST, class SA,
   >               class FST, class FSA>
   >       basic_string<charT, ST, SA>
   >       regex_replace(const basic_string<charT, ST, SA>& s,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, FST, FSA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT, class ST, class SA>
   >       basic_string<charT, ST, SA>
   >       regex_replace(const basic_string<charT, ST, SA>& s,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   > > Effects: Constructs an empty string `result` of type `basic_string<charT, ST, SA>`, calls `regex_replace(back_inserter(result), s.begin(), s.end(), e, fmt, flags)`, and then returns `result`.

9. At the end of 28.11.4 [re.alg.replace] add the following new prototype description:

   >     template <class traits, class charT, class ST, class SA>
   >       basic_string<charT>
   >       regex_replace(const charT* s,
   >                     const basic_regex<charT, traits>& e,
   >                     const basic_string<charT, ST, SA>& fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   >     template <class traits, class charT>
   >       basic_string<charT>
   >       regex_replace(const charT* s,
   >                     const basic_regex<charT, traits>& e,
   >                     const charT* fmt,
   >                     regex_constants::match_flag_type flags =
   >                       regex_constants::match_default);

   > > Effects: Constructs an empty string `result` of type `basic_string<charT>`, calls `regex_replace(back_inserter(result), s, s + char_traits<charT>::length(s), e, fmt, flags)`, and then returns `result`.

### 742. Enabling `swap` for proxy iterators

Section: 20.2.1 [utility.arg.requirements] Status: Open Submitter: Howard Hinnant Opened: 2007-10-10 Last modified: 2009-11-08

View other active issues in [utility.arg.requirements].

View all other issues in [utility.arg.requirements].

View all issues with Open status.

Discussion:

This issue was split from 672. 672 now just deals with changing the requirements of `T` in the `Swappable` requirement from `CopyConstructible` and `CopyAssignable` to `MoveConstructible` and `MoveAssignable`.

This issue seeks to widen the `Swappable` requirement to support proxy iterators. Here is example code:

>     namespace Mine {

>     template <class T>
>     struct proxy {...};

>     template <class T>
>     struct proxied_iterator
>     {
>        typedef T value_type;
>        typedef proxy<T> reference;
>        reference operator*() const;
>        ...
>     };

>     struct A
>     {
>        // heavy type, has an optimized swap, maybe isn't even copyable or movable, just swappable
>        void swap(A&);
>        ...
>     };

>     void swap(A&, A&);
>     void swap(proxy<A>, A&);
>     void swap(A&, proxy<A>);
>     void swap(proxy<A>, proxy<A>);

>     }  // Mine

>     ...

>     Mine::proxied_iterator<Mine::A> i(...)
>     Mine::A a;
>     swap(*i1, a);

The key point to note in the above code is that in the call to `swap`, `*i1` and `a` are different types (currently types can only be `Swappable` with the same type). A secondary point is that to support proxies, one must be able to pass rvalues to `swap`. But note that I am not stating that the general purpose `std::swap` should accept rvalues! Only that overloaded `swap`s, as in the example above, be allowed to take rvalues.

That is, no standard library code needs to change. We simply need to have a more flexible definition of `Swappable`.

[ Bellevue: ]

> While we believe Concepts work will define a swappable concept, we should still resolve this issue if possible to give guidance to the Concepts work.

> Would an ambiguous swap function in two namespaces found by ADL break this wording? Suggest that the phrase "valid expression" means such a pair of types would still not be swappable.

> Motivation is proxy-iterators, but facility is considerably more general. Are we happy going so far?

> We think this wording is probably correct and probably an improvement on what's there in the WP. On the other hand, what's already there in the WP is awfully complicated. Why do we need the two bullet points? They're too implementation-centric. They don't add anything to the semantics of what swap() means, which is there in the post-condition. What's wrong with saying that types are swappable if you can call swap() and it satisfies the semantics of swapping?

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10 Santa Cruz: ]

> Leave as Open. Dave to provide wording.

[ 2009-11-08 Howard adds: ]

> Updated wording to sync with N3000. Also this issue is very closely related to 594.

Proposed resolution:

Change 20.2.1 [utility.arg.requirements]:

> -1- The template definitions in the C++ Standard Library refer to various named requirements whose details are set out in tables 31-38. In these tables, `T` and `V` are is a types to be supplied by a C++ program instantiating a template; `a`, `b`, and `c` are values of type `const T`; `s` and `t` are modifiable lvalues of type `T`; `u` is a value of type (possibly `const`) `T`; and `rv` is a non-`const` rvalue of type `T`; `w` is a value of type `T`; and `v` is a value of type `V`.

> Table 37: `Swappable` requirements [swappable]
> expression | Return type | Post-condition
> --- | --- | ---
> `swap(sw,tv)` | `void` | `t` `w` has the value originally held by `u` `v`, and `u` `v` has the value originally held by `t` `w`
> The `Swappable` requirement is met by satisfying one or more of the following conditions: `T` is `Swappable` if `T` and `V` are the same type and `T` satisfies the `MoveConstructible` requirements (Table 33) and the `MoveAssignable` requirements (Table 35); `T` is `Swappable` with `V` if a namespace scope function named `swap` exists in the same namespace as the definition of `T` or `V`, such that the expression `swap(sw,t v)` is valid and has the semantics described in this table. `T` is `Swappable` if `T` is an array type whose element type is `Swappable`.

Rationale:

[ post San Francisco: ]

> Solved by N2758.

### 774. Member swap undefined for most containers

Section: 23 [containers] Status: Open Submitter: Alisdair Meredith Opened: 2008-01-14 Last modified: 2009-10-31

View other active issues in [containers].

View all other issues in [containers].

View all issues with Open status.

Discussion:

It appears most containers declare but do not define a member-swap function.

This is unfortunate, as all overload the `swap` algorithm to call the member-swap function! (required for `swappable` guarantees [Table 37] and Container Requirements [Table 87])

Note in particular that Table 87 gives semantics of `a.swap(b)` as `swap(a,b)`, yet for all containers we define `swap(a,b)` to call `a.swap(b)` - a circular definition.

A quick survey of clause 23 shows that the following containers provide a definition for member-swap:

>     array
>     queue
>     stack
>     vector

Whereas the following declare it, but do not define the semantics:

>     deque
>     list
>     map
>     multimap
>     multiset
>     priority_queue
>     set
>     unordered_map
>     unordered_multi_map
>     unordered_multi_set
>     unordered_set

Suggested resolution:

> Provide a definition for each of the affected containers...

[ Bellevue: ]

> Move to Open and ask Alisdair to provide wording.

[ 2009-07 Frankfurt: ]

> Daniel to provide wording. N2590 is no longer applicable.

[ 2009-07-28 Daniel provided wording. ]

> 1. It assumes that the proposed resolution for 883 is applied, which breaks the circularity of definition between member `swap` and free `swap`.
> 2. It uses the notation of the pre-concept allocator trait `allocator_propagation_map`, which might be renamed after the next refactoring phase of generalized allocators.
> 3. It requires that compare objects, key equal functions and hash functions in containers are swapped via unqualified free `swap` according to 594.

[ 2009-09-30 Daniel adds: ]

> The outcome of this issue should be considered with the outcome of 1198 both in style and in content (e.g. bullet 9 suggests to define the semantic of `void priority_queue::swap(priority_queue&)` in terms of the member `swap` of the container).

[ 2009-10 Santa Cruz: ]

> Looked at, but took no action on as it overlaps too much with N2982. Waiting for a new draft WP.

[ 2009-10 Santa Cruz: ]

> Leave as open. Pablo to provide wording.

[ 2009-10-26 Pablo updated wording. Here is the wording he replaced: ]

> 1. Add a new Throws clause just after X [allocator.propagation.map]/5:

>    >     static void swap(Alloc& a, Alloc& b);

>    > > Effects: [..]

>    > > Throws: Nothing.

>    [ This exception requirement is added, such that it's combination with the general container requirements of N2723 [container.requirements.general]/9 make it unambiguously clear that the following descriptions of "swaps the allocators" have the following meaning: (a) This swap is done by calling `allocator_propagation_map<allocator_type>::swap` and (b) This allocator swap does never propagate an exception ]

> 2. Change 23.2.4.1 [associative.reqmts.except]/3 as indicated:

>    > For associative containers, no `swap` function throws an exception unless that exception is thrown by the copy constructor or copy assignment operator `swap` of the container's `Pred` objects (if any).

> 3. Change 23.2.5.1 [unord.req.except]/3 as indicated:

>    > For unordered associative containers, no `swap` function throws an exception unless that exception is thrown by the copy constructor or copy assignment operator `swap` of the container's `Hash` or `Pred` objects, respectively (if any).

> 4. Insert a new paragraph just after 23.3 [sequences]/1:

>    > In addition to being available via inclusion of the `<algorithm>` header, the `swap` function templates in 25.3.3 [alg.swap] are also available when the header `<queue>` is included.

>    [ There is a new issue in process that will suggest a minimum header for `swap` and `move`. If this one is provided, this text can be removed and the header dependency should be added to `<queue>` ]

> 5. Add one further clause at the end of 23.3.1.2 [array.special]:

>    [This part is added, because otherwise `array::swap` would otherwise contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5]

>    > Throws: Nothing, unless one of the element-wise `swap` calls throws an exception.

> 6. 1. In 23.3.2 [deque], class template deque synopsis change as indicated:

>       >     void swap(deque<T,Alloc>&);

>    2. At the end of 23.3.2.3 [deque.modifiers] add as indicated:

>       >     void swap(deque& x);

>       > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`.

>       > > Complexity: Constant time.

> 7. 1. In 23.3.3 [forwardlist], class template `forward_list` synposis change as indicated:

>       >     void swap(forward_list<T,Allocator>&);

>    2. At the end of 23.3.3.4 [forwardlist.modifiers] add as indicated:

>       >     void swap(forward_list& x);

>       > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`.

>       > > Complexity: Constant time.

> 8. 1. In 23.3.4 [list], class template `list` synopsis change as indicated:

>       >     void swap(list<T,Allocator>&);

>    2. At the end of 23.3.4.3 [list.modifiers] add as indicated:

>       >     void swap(list& x);

>       > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`.

>       > > Complexity: Constant time.

> 9. At the end of 23.3.5.2.2 [priqueue.members] add a new prototype description:

>    >     void swap(priority_queue& q);

>    > > Requires: `Compare` shall satisfy the `Swappable` requirements ( [swappable]).

>    > > [ This requirement is added to ensure that even a user defined `swap` which is found by ADL for `Compare` satisfies the `Swappable` requirements ]

>    > > Effects: `this->c.swap(q.c); swap(this->comp, q.comp);`

>    > > Throws: What and if `c.swap(q.c)` and `swap(comp, q.comp)` throws.

>    [ This part is added, because otherwise `priority_queue::swap` would otherwise contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5 ]

> 10. 1. In 23.3.6 [vector], class template `vector` synopsis change as indicated:

>        >     void swap(vector<T,Allocator>&);

>     2. Change 23.3.6.2 [vector.capacity]/8 as indicated:

>        >     void swap(vector<T,Allocator>& x);

>        > > Effects: Exchanges the contents and `capacity()` and swaps the allocators of `*this` with that of `x`.

> 11. Insert a new paragraph just before 23.4 [associative]/1:

>     > In addition to being available via inclusion of the `<algorithm>` header, the `swap` function templates in 25.3.3 [alg.swap] are also available when any of the headers `<map>` or `<set>` are included.

> 12. 1. In 23.4.1 [map], class template `map` synopsis change as indicated:

>        >     void swap(map<Key,T,Compare,Allocator>&);

>     2. At the end of 23.4.1.3 [map.modifiers] add as indicated:

>        >     void swap(map& x);

>        > > Requires: Compare shall satisfy the `Swappable` requirements ( [swappable]).

>        > > [ This requirement is added to ensure that even a user defined `swap` which is found by ADL for `Compare` satisfies the `Swappable` requirements ]

>        > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the comparison objects of `*this` and `x`.

>        > > Complexity: Constant time

> 13. 1. In 23.4.2 [multimap], class template `multimap` synopsis change as indicated:

>        >     void swap(multimap<Key,T,Compare,Allocator>&);

>     2. At the end of 23.4.2.2 [multimap.modifiers] add as indicated:

>        >     void swap(multimap& x);

>        > > Requires: Compare shall satisfy the `Swappable` requirements ( [swappable]).

>        > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the comparison objects of `*this` and `x`.

>        > > Complexity: Constant time

> 14. 1. In 23.4.3 [set], class template `set` synopsis change as indicated:

>        >     void swap(set<Key,Compare,Allocator>&);

>     2. After section 23.4.3.1 [set.cons] add a new section `set` modifiers [set.modifiers] and add the following paragraphs:

>        >     void swap(set& x);

>        > > Requires: Compare shall satisfy the `Swappable` requirements ( [swappable]).

>        > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the comparison objects of `*this` and `x`.

>        > > Complexity: Constant time

> 15. 1. In 23.4.4 [multiset], class template `multiset` synosis, change as indicated:

>        >     void swap(multiset<Key,Compare,Allocator>&);

>     2. After section 23.4.4.1 [multiset.cons] add a new section `multiset` modifiers [multiset.modifiers] and add the following paragraphs:

>        >     void swap(multiset& x);

>        > > Requires: Compare shall satisfy the `Swappable` requirements ( [swappable]).

>        > > Effects: Exchanges the contents and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the comparison objects of `*this` and `x`.

>        > > Complexity: Constant time

> 16. Insert a new paragraph just before 23.5 [unord]/1:

>     > In addition to being available via inclusion of the `<algorithm>` header, the `swap` function templates in 25.3.3 [alg.swap] are also available when any of the headers `<unordered_map>` or `<unordered_set>` are included.

> 17. After section 23.5.1.2 [unord.map.elem] add a new section unordered_map modifiers [unord.map.modifiers] and add the following paragraphs:

>     >     void swap(unordered_map& x);

>     > > Requires: `Hash` and `Pred` shall satisfy the `Swappable` requirements ( [swappable]).

>     > > [ This requirement is added to ensure that even a user defined `swap` which is found by ADL for `Hash` and `Pred` satisfies the `Swappable` requirements ]

>     > > Effects: Exchanges the contents and hash policy and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the `Pred` objects and an unqualified `swap` of the `Hash` objects of `*this` and `x`.

>     > > Complexity: Constant time

> 18. After section 23.5.2.1 [unord.multimap.cnstr] add a new section unordered_multimap modifiers [unord.multimap.modifiers] and add the following paragraphs:

>     >     void swap(unordered_multimap& x);

>     > > Requires: `Hash` and `Pred` shall satisfy the `Swappable` requirements ( [swappable]).

>     > > Effects: Exchanges the contents and hash policy and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the `Pred` objects and an unqualified `swap` of the `Hash` objects of `*this` and `x`

>     > > Complexity: Constant time

> 19. After section 23.5.3.1 [unord.set.cnstr] add a new section unordered_set modifiers [unord.set.modifiers] and add the following paragraphs:

>     >     void swap(unordered_set& x);

>     > > Requires: `Hash` and `Pred` shall satisfy the `Swappable` requirements ( [swappable]).

>     > > Effects: Exchanges the contents and hash policy and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the `Pred` objects and an unqualified `swap` of the `Hash` objects of `*this` and `x`

>     > > Complexity: Constant time

> 20. After section 23.5.4.1 [unord.multiset.cnstr] add a new section unordered_multiset modifiers [unord.multiset.modifiers] and add the following paragraphs:

>     >     void swap(unordered_multiset& x);

>     > > Requires: `Hash` and `Pred` shall satisfy the `Swappable` requirements ( [swappable]).

>     > > Effects: Exchanges the contents and hash policy and swaps the allocators of `*this` with that of `x`, followed by an unqualified `swap` of the `Pred` objects and an unqualified `swap` of the `Hash` objects of `*this` and `x`

>     > > Complexity: Constant time

[ 2009-10-30 Pablo and Daniel updated wording. ]

Proposed resolution:

[ This resolution is based on the September 2009 WP, N2960, except that it assumes that N2982 and issues 883 and 1232 have already been applied. Note in particular that Table 91 in N2960 is refered to as Table 90 because N2982 removed the old Table 90. This resolution also addresses issue 431. ]

In 23.2.1 [container.requirements.general], replace the a.swap(b) row in table 90, "container requirements" (was table 91 before the application of N2982 to the WP):

> `a.swap(b)` | `void` |  | `swap(a,b)Exchange the contents of `a` and `b`.` | (Note A)
> `swap(a,b)` | `void` | `` | `a.swap(b)` | (Note A)

Modify the notes immediately following Table 90 in 23.2.1 [container.requirements.general] as follows (The wording below is after the application of N2982 to N2960. The editor might also want to combine Notes A and B into one.):

> Notes: the algorithms swap(), equal() and lexicographical_compare() are defined in Clause 25. Those entries marked "(Note A)" or "(Note B)" should have linear complexity for array and constant complexity for all other standard containers.

In 23.2.1 [container.requirements.general], after paragraph 9, add:

> The expression `a.swap(b)`, for containers `a` and `b` of a standard container type other than `array`, exchanges the values of `a` and `b` without invoking any move, copy, or swap operations on the individual container elements. Any `Compare`, `Pred`, or `Hash` function objects belonging to `a` and `b` shall satisfy the `Swappable` requirements and are exchanged by unqualified calls to non-member `swap`. If `allocator_traits<allocator_type>::propagate_on_container_swap::value == true`, then the allocators of `a` and `b` are also exchanged using an unqualified call to non-member `swap`. Otherwise, the behavior is undefined unless `a.get_allocator() == b.get_allocator()`. Each iterator refering to an element in one container before the swap shall refer to the same element in the other container after the swap. It is unspecified whether an iterator with value `a.end()` before the swap will have value `b.end()` after the swap. In addition to being available via inclusion of the `<utility>` header, the `swap` function template in 25.3.3 [alg.swap] is also available within the definition of every standard container's `swap` function.

[ Note to the editor: Paragraph 2 starts with a sentence fragment, clearly from an editing or source-control error. ]

Modify 23.2.4.1 [associative.reqmts.except] as follows:

> 23.2.4.1 Exception safety guarantees 23.2.4.1 [associative.reqmts.except]

> For associative containers, no `clear()` function throws an exception. `erase(k)` does not throw an exception unless that exception is thrown by the container's `PredCompare` object (if any).

> For associative containers, if an exception is thrown by any operation from within an `insert()` function inserting a single element, the `insert()` function has no effect.

> For associative containers, no `swap` function throws an exception unless that exception is thrown by the copy constructor or copy assignment operator swap of the container's `PredCompare` object (if any).

Modify 23.2.5.1 [unord.req.except], paragraph 3 as follows:

> For unordered associative containers, no `swap` function throws an exception unless that exception is thrown by the copy constructor or copy assignment operator swap of the container's `Hash` or `Pred` object (if any).

Modify section 23.3.1.2 [array.special]:

> array specialized algorithms 23.3.1.2 [array.special]

> `template <class T, size_t N> void swap(array<T,N>& x,array<T,N>& y);`

> > Effects: `swap_ranges(x.begin(), x.end(), y.begin() );x.swap(y);`

Add a new section after 23.3.1.5 [array.fill] (Note to the editor: array::fill make use of a concept requirement that must be removed or changed to text.):

> array::swap [array.swap]

> `void swap(array& y);`

> > Effects: `swap_ranges(this->begin(), this->end(), y.begin() );`

> > Throws: Nothing unless one of the element-wise swap calls throws an exception.

> > [Note: Unlike other containers' `swap` functions, `array::swap` takes linear, not constant, time, may exit via an exception, and does not cause iterators to become associated with the other container. — end note]

Insert a new paragraph just after 23.3.5 [container.adaptors]/1:

> For container adaptors, no `swap` function throws an exception unless that exception is thrown by the swap of the adaptor's `Container` or `Compare` object (if any).

### 780. `std::merge()` specification incorrect/insufficient

Section: 25.4.4 [alg.merge] Status: Review Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2009-10-22

View all issues with Review status.

Discussion:

Though issue 283 has fixed many open issues, it seems that some are still open:

Both 25.3.4 [lib.alg.merge] in 14882:2003 and 25.4.4 [alg.merge] in N2461 have no Requires element and the Effects element contains some requirements, which is probably editorial. Worse is that:

- no assignment requirements are specified (neither implicit nor explicit).
- the effects clause just speaks of "merges", which is badly worded near to a circular definition.
- p. 2 mentions a range `[first, last)`, which is not defined by the function arguments or otherwise.
- p. 2 says "according to the ordering defined by comp" which is both incomplete (because this excludes the first variant with <) and redundant (because the following subordinate clause mentions comp again)

[ Post Summit Alisdair adds: ]

> Suggest:

> > (where `last` is equal to `next(result, distance(first1, last1) + distance(first2, last2))`, such that resulting range will be sorted in non-decreasing order; that is, for every iterator `i` in `[result,last)` other than `result`, the condition `*i < *prev(i)` or, respectively, `comp(*i, *prev(i))` will be `false`.

> Note that this might still not be technically accurate in the case of `InputIterators`, depending on other resolutions working their way through the system (1011).

[ Post Summit Daniel adds: ]

> If we want to use `prev` and `next` here (Note: `merge` is sufficiently satisfied with `InputIterator`) we should instead *add* more to 25 [algorithms]/6, but I can currently not propose any good wording for this.

[ Batavia (2009-05): ]

> Pete points out the existing wording in [algorithms]/4 that permits the use of + in algorithm specifications.

> Alisdair points out that that wording may not apply to input iterators.

> Move to Review.

[ 2009-07 Frankfurt: ]

> Move to Ready.

[ 2009-08-23 Daniel reopens: ]

> The proposed wording must be rephrased, because the part

> > for every iterator `i` in `[result,last)` other than `result`, the condition `*i < *(i - 1)` or, respectively, `comp(*i, *(i - 1))` will be `false`"

> isn't meaningful, because the range `[result,last)` is that of a pure `OutputIterator`, which is not readable in general.

> [Howard: Proposed wording updated by Daniel, status moved from Ready to Review.]

[ 2009-10 Santa Cruz: ]

> Matt has some different words to propose. Those words have been moved into the proposed wording section, and the original proposed wording now appears here:

> > In 25.4.4 [alg.merge] replace p.1+ 2:

> > > Effects: Merges Copies all the elements of the two sorted ranges `[first1,last1)` and `[first2,last2)` into the range `[result,result + (last1 - first1) + (last2 - first2))` , such that resulting range will be sorted in non-decreasing order; that is for every pair of iterators `i` and `j` of either input ranges, where `*i` was copied to the output range before `*j` was copied to the output range, the condition `*j < *i` or, respectively, `comp(*j, *i)` will be `false`.

> > > Requires:The resulting range shall not overlap with either of the original ranges. The list will be sorted in non-decreasing order according to the ordering defined by `comp`; that is, for every iterator `i` in `[first,last)` other than `first`, the condition `*i < *(i - 1)` or `comp(*i, *(i - 1))` will be `false`.

Proposed resolution:

Effects: Merges two sorted ranges `[first1,last1)` and `[first2,last2)` into the range `[result, result + (last1 - first1) + (last2 - first2))`.

Effects: Copies all the elements of the two sorted ranges `[first1,last1)` and `[first2,last2)` into the range `[result, result_last)`, where `result_last` is `result + (last1 - first1) + (last2 - first2)`, such that the resulting range satisfies `is_sorted(result, result_last)` or `is_sorted(result, result_last, comp)`, respectively.

Requires: The resulting range shall not overlap with either of the original ranges. The list will be sorted in non-decreasing order according to the ordering defined by `comp`; that is, for every iterator `i` in `[first,last)` other than `first`, the condition `*i < *(i - 1)` or `comp(*i, *(i - 1))` will be `false`.

### 801. `tuple` and `pair` trivial members

Section: 20.5 [tuple] Status: Open Submitter: Lawrence Crowl Opened: 2008-02-18 Last modified: 2009-10-23

View all other issues in [tuple].

View all issues with Open status.

Discussion:

Classes with trivial special member functions are inherently more efficient than classes without such functions. This efficiency is particularly pronounced on modern ABIs that can pass small classes in registers. Examples include value classes such as complex numbers and floating-point intervals. Perhaps more important, though, are classes that are simple collections, like `pair` and `tuple`. When the parameter types of these classes are trivial, the `pair`s and `tuple`s themselves can be trivial, leading to substantial performance wins.

The current working draft make specification of trivial functions (where possible) much easer through `default`ed and `delete`d functions. As long as the semantics of defaulted and deleted functions match the intended semantics, specification of defaulted and deleted functions will yield more efficient programs.

There are at least two cases where specification of an explicitly defaulted function may be desirable.

First, the `std::pair` template has a non-trivial default constructor, which prevents static initialization of the pair even when the types are statically initializable. Changing the definition to

>     pair() = default;

would enable such initialization. Unfortunately, the change is not semantically neutral in that the current definition effectively forces value initialization whereas the change would not value initialize in some contexts.

** Does the committee confirm that forced value initialization was the intent? If not, does the committee wish to change the behavior of `std::pair` in C++0x?

Second, the same default constructor issue applies to `std::tuple`. Furthermore, the `tuple` copy constructor is current non-trivial, which effectively prevents passing it in registers. To enable passing `tuples` in registers, the copy constructor should be make explicitly `default`ed. The new declarations are:

>     tuple() = default;
>     tuple(const tuple&) = default;

This changes is not implementation neutral. In particular, it prevents implementations based on pointers to the parameter types. It does however, permit implementations using the parameter types as bases.

** How does the committee wish to trade implementation efficiency versus implementation flexibility?

[ Bellevue: ]

> General agreement; the first half of the issue is NAD.

> Before voting on the second half, it was agreed that a "Strongly Favor" vote meant support for trivial tuples (assuming usual requirements met), even at the expense of other desired qualities. A "Weakly Favor" vote meant support only if not at the expense of other desired qualities.

> Concensus: Go forward, but not at expense of other desired qualities.

> It was agreed to Alisdair should fold this work in with his other pair/tuple action items, above, and that issue 801 should be "open", but tabled until Alisdair's proposals are disposed of.

[ 2009-05-27 Daniel adds: ]

> This is partly solved by 1117.

[ 2009-07 Frankfurt: ]

> Wait for dust to settle from fixing exception safety problem with rvalue refs.

[ 2009-07-20 Alisdair adds: ]

> Basically, this issue is what should we do with the default constructor for pairs and tuples of trivial types. The motivation of the issue was to force static initialization rather than dynamic initialization, and was rejected in the case of pair as it would change the meaning of existing programs. The advice was "do the best we can" for tuple without changing existing meaning.

> Frankfurt seems to simply wait and see the resolution on no-throw move constructors, which (I believe) is only tangentially related to this issue, but as good as any to defer until Santa Cruz.

> Looking again now, I think constant (static) initialization for pair can be salvaged by making the default construct constexpr. I have a clarification from Core that this is intended to work, even if the constructor is not trivial/constexpr, so long as no temporaries are implied in the process (even if elided).

[ 2009-10 Santa Cruz: ]

> Leave as open. Alisdair to provide wording.

Proposed resolution:

### 811. `pair` of pointers no longer works with literal 0

Section: 20.3.4 [pairs] Status: Open Submitter: Doug Gregor Opened: 2008-03-14 Last modified: 2009-10-23

View other active issues in [pairs].

View all other issues in [pairs].

View all issues with Open status.

Discussion:

>     #include <utility>

>     int main()
>     {
>        std::pair<char *, char *> p (0,0);
>     }

I just got a bug report about that, because it's valid C++03, but not C++0x. The important realization, for me, is that the emplace proposal---which made `push_back` variadic, causing the `push_back(0)` issue---didn't cause this break in backward compatibility. The break actually happened when we added this pair constructor as part of adding rvalue references into the language, long before variadic templates or emplace came along:

>     template<class U, class V> pair(U&& x, V&& y);

Now, concepts will address this issue by constraining that `pair` constructor to only `U`'s and `V`'s that can properly construct "first" and "second", e.g. (from N2322):

>     template<class U , class V >
>     requires Constructible<T1, U&&> && Constructible<T2, V&&>
>     pair(U&& x , V&& y );

[ San Francisco: ]

> Suggested to resolve using pass-by-value for that case.

> Side question: Should pair interoperate with tuples? Can construct a tuple of a pair, but not a pair from a two-element tuple.

> Related to 885.

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10 Santa Cruz: ]

> Leave as open. Howard to provide wording.

Proposed resolution:

Rationale:

[ San Francisco: ]

> Solved by N2770.

### 815. `std::function` and `reference_closure` do not use perfect forwarding

Section: 20.7.15.2.4 [func.wrap.func.inv] Status: Open Submitter: Alisdair Meredith Opened: 2008-03-16 Last modified: 2009-10-23

View all issues with Open status.

Discussion:

`std::function` and `reference_closure` should use "perfect forwarding" as described in the rvalue core proposal.

[ Sophia Antipolis: ]

> According to Doug Gregor, as far as `std::function` is concerned, perfect forwarding can not be obtained because of type erasure. Not everyone agreed with this diagnosis of forwarding.

[ 2009-05-01 Howard adds: ]

> Sebastian Gesemann brought to my attention that the `CopyConstructible` requirement on `function`'s `ArgTypes...` is an unnecessary restriction.

> >     template<Returnable R, CopyConstructible... ArgTypes>
> >     class function<R(ArgTypes...)>
> >     ...

> On further investigation, this complaint seemed to be the same issue as this one. I believe the reason `CopyConstructible` was put on `ArgTypes` in the first place was because of the nature of the invoke member:

> >     template<class R, class ...ArgTypes>
> >     R
> >     function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
> >     {
> >         if (f_ == 0)
> >             throw bad_function_call();
> >         return (*f_)(arg...);
> >     }

> However now with rvalue-refs, "by value" no longer implies `CopyConstructible` (as Sebastian correctly points out). If rvalue arguments are supplied, `MoveConstructible` is sufficient. Furthermore, the constraint need not be applied in `function` if I understand correctly. Rather the client must apply the proper constraints at the call site. Therefore, at the very least, I recommend that `CopyConstructible` be removed from the template class `function`.

> Furthermore we need to mandate that the invoker is coded as:

> >     template<class R, class ...ArgTypes>
> >     R
> >     function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
> >     {
> >         if (f_ == 0)
> >             throw bad_function_call();
> >         return (*f_)(std::forward<ArgTypes>(arg)...);
> >     }

> Note that `ArgTypes&&` (the "perfect forwarding signature") is not appropriate here as this is not a deduced context for `ArgTypes`. Instead the client's arguments must implicitly convert to the non-deduced `ArgType` type. Catching these arguments by value makes sense to enable decay.

> Next `forward` is used to move the `ArgTypes` as efficiently as possible, and also with minimum requirements (not `CopyConstructible`) to the type-erased functor. For object types, this will be a `move`. For reference type `ArgTypes`, this will be a copy. The end result must be that the following is a valid program:

> >     #include <functional>
> >     #include <memory>
> >     #include <cassert>

> >     std::unique_ptr<int>
> >     f(std::unique_ptr<int> p, int& i)
> >     {
> >         ++i;
> >         return std::move(p);
> >     }

> >     int main()
> >     {
> >         int i = 2;
> >         std::function<std::unique_ptr<int>(std::unique_ptr<int>,
> >                                            int&> g(f);
> >         std::unique_ptr<int> p = g(std::unique_ptr<int>(new int(1)), i);
> >         assert(*p == 1);
> >         assert(i == 3);
> >     }

> [ Tested in pre-concepts rvalue-ref-enabled compiler. ]

> In the example above, the first `ArgType` is `unique_ptr<int>` and the second `ArgType` is `int&`. Both must work!

[ 2009-05-27 Daniel adds: ]

> in the 2009-05-01 comment of above mentioned issue Howard

> 1. Recommends to replace the `CopyConstructible` requirement by a `MoveConstructible` requirement
> 2. Says: "Furthermore, the constraint need not be applied in `function` if I understand correctly. Rather the client must apply the proper constraints at the call site"

> I'm fine with (a), but I think comment (b) is incorrect, at least in the sense I read these sentences. Let's look at Howard's example code:

> >     function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
> >     {
> >        if (f_ == 0)
> >            throw bad_function_call();
> >        return (*f_)(std::forward<ArgTypes>(arg)...);
> >     }

> In the constrained scope of this `operator()` overload the expression "`(*f_)(std::forward<ArgTypes>(arg)...)`" must be valid. How can it do so, if `ArgTypes` aren't at least `MoveConstructible`?

[ 2009-07 Frankfurt: ]

> Leave this open and wait until concepts are removed from the Working Draft so that we know how to write the proposed resolution in terms of diffs to otherwise stable text.

[ 2009-10 Santa Cruz: ]

> Leave as open. Howard to provide wording. Howard welcomes any help.

Proposed resolution:

### 816. Should `bind()`'s returned functor have a nofail copy ctor when `bind()` is nofail?

Section: 20.7.11.1.3 [func.bind.bind] Status: Ready Submitter: Stephan T. Lavavej Opened: 2008-02-08 Last modified: 2009-11-07

View other active issues in [func.bind.bind].

View all other issues in [func.bind.bind].

View all issues with Ready status.

Discussion:

Library Issue 527 notes that `bind(f, t1, ..., tN)` should be nofail when `f, t1, ..., tN` have nofail copy ctors.

However, no guarantees are provided for the copy ctor of the functor returned by `bind()`. (It's guaranteed to have a copy ctor, which can throw implementation-defined exceptions: `bind()` returns a forwarding call wrapper, TR1 3.6.3/2. A forwarding call wrapper is a call wrapper, TR1 3.3/4. Every call wrapper shall be CopyConstructible, TR1 3.3/4. Everything without an exception-specification may throw implementation-defined exceptions unless otherwise specified, C++03 17.4.4.8/3.)

Should the nofail guarantee requested by Library Issue 527 be extended to cover both calling `bind()` and copying the returned functor?

[ Howard adds: ]

> `tuple` construction should probably have a similar guarantee.

[ San Francisco: ]

> Howard to provide wording.

[ Post Summit, Anthony provided wording. ]

[ Batavia (2009-05): ]

> Part of all of this issue appears to be rendered moot by the proposed resolution to issue 817 (q.v.). We recommend the issues be considered simultaneously (or possibly even merged) to ensure there is no overlap. Move to Open, and likewise for issue 817.

[ 2009-07 Frankfurt: ]

> Related to 817 (see below). Leave Open.

[ 2009-10 Santa Cruz: ]

> Move to Ready. Decoupling from issue 817.

Proposed resolution:

Add a new sentence to the end of paragraphs 2 and 4 of 20.7.11.1.3 [func.bind.bind]:

> -2- Returns: A forwarding call wrapper `g` with a weak result type (20.6.2). The effect of `g(u1, u2, ..., uM)` shall be `INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type)`, where cv represents the cv-qualifiers of `g` and the values and types of the bound arguments `v1, v2, ..., vN` are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of `F` or any of the types in `BoundArgs...` throw an exception.

> ...

> -5- Returns: A forwarding call wrapper `g` with a nested type `result_type` defined as a synonym for `R`. The effect of `g(u1, u2, ..., uM)` shall be `INVOKE(f, v1, v2, ..., vN, R)`, where the values and types of the bound arguments `v1, v2, ..., vN` are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of `F` or any of the types in `BoundArgs...` throw an exception.

### 817. `bind` needs to be moved

Section: 20.7.11.1.3 [func.bind.bind] Status: Open Submitter: Howard Hinnant Opened: 2008-03-17 Last modified: 2009-11-08

View other active issues in [func.bind.bind].

View all other issues in [func.bind.bind].

View all issues with Open status.

Discussion:

Addresses US 72, JP 38 and DE 21

The functor returned by `bind()` should have a move constructor that requires only move construction of its contained functor and bound arguments. That way move-only functors can be passed to objects such as `thread`.

This issue is related to issue 816.

US 72:

> `bind` should support move-only functors and bound arguments.

JP 38:

> add the move requirement for bind's return type.

> For example, assume following `th1` and `th2`,

> >     void f(vector<int> v) { }

> >     vector<int> v{ ... };
> >     thread th1([v]{ f(v); });
> >     thread th2(bind(f, v));

> When function object are set to thread, `v` is moved to `th1`'s lambda expression in a Move Constructor of lambda expression because `th1`'s lambda expression has a Move Constructor. But `bind` of `th2`'s return type doesn't have the requirement of Move, so it may not moved but copied.

> Add the requirement of move to get rid of this useless copy.

> And also, add the `MoveConstructible` as well as `CopyConstructible`.

DE 21

> The specification for bind claims twice that "the values and types for the bound arguments v1, v2, ..., vN are determined as specified below". No such specification appears to exist.

[ San Francisco: ]

> Howard to provide wording.

[ Post Summit Alisdair and Howard provided wording. ]

> Several issues are being combined in this resolution. They are all touching the same words so this is an attempt to keep one issue from stepping on another, and a place to see the complete solution in one place.

> 1. `bind` needs to be "moved".
> 2. 20.7.11.1.3 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798.
> 3. Issue 929 argues for a way to pass by && for efficiency but retain the decaying behavior of pass by value for the `thread` constructor. That same solution is applicable here.

[ Batavia (2009-05): ]

> We were going to recommend moving this issue to Tentatively Ready until we noticed potential overlap with issue 816 (q.v.).

> Move to Open, and recommend both issues be considered together (and possibly merged).

[ 2009-07 Frankfurt: ]

> The proposed resolution uses concepts. Leave Open.

[ 2009-10 Santa Cruz: ]

> Leave as Open. Howard to provide deconceptified wording.

[ 2009-11-07 Howard updates wording. ]

Proposed resolution:

Change 20.7 [function.objects] p2:

>     template<class Fn, class... Types BoundArgs>
>       unspecified bind(Fn&&, Types BoundArgs&&...);
>     template<class R, class Fn, class... Types BoundArgs>
>       unspecified bind(Fn&&, Types BoundArgs&&...);

Change 20.7.11.1.3 [func.bind.bind]:

> Within this clause:

> - Let `FD` be a synonym for the type `decay<F>::type`.
> - Let `fd` be an lvalue of type `FD` constructed from `std::forward<F>(f)`.
> - Let `Ti` be a synonym for the ith type in the parameter pack `BoundArgs`.
> - Let `TiD` be a synonym for the type `decay<Ti>::type`.
> - Let `ti` be the ith argument in `bound_args`.
> - Let `tid` be an lvalue of type `TiD` constructed from `std::forward<Ti>(ti)`.

>     template<class F, class... BoundArgs>
>       unspecified bind(F&& f, BoundArgs&&... bound_args);

> > -1- Requires: `is_constructible<FD, F>::value` shall be `true`. `is_constructible<TiD, Ti>::value` shall be `true`. `F` and each `Ti` in `BoundArgs` shall be CopyConstructible. `INVOKE(fd, w1, w2, ..., wN)` (20.7.2 [func.require]) shall be a valid expression for some values w1, w2, ..., wN, where `N == sizeof...(bound_args)`.

> > -2- Returns: A forwarding call wrapper `g` with a weak result type (20.7.2 [func.require]). The effect of `g(u1, u2, ..., uM)` shall be `INVOKE(fd, v1, v2, ..., vN, result_of<FD cv (V1, V2, ..., VN)>::type)`, where cv represents the cv-qualifiers of `g` and the values and types of the bound arguments `v1, v2, ..., vN` are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of `FD` or any of the types `TiD` throw an exception.

> > -3- Throws: Nothing unless the copy construction or of `Ffd` or of one of the values `tid` types in the `BoundArgs...` pack expansion throws an exception.

> > Remarks: The unspecified return type shall be `MoveConstructible`. If all of `FD` and `TiD` are `CopyConstructible` then the unspecified return type shall be `CopyConstructible`. [Note: This implies that all of `FD` and `TiD` shall be `MoveConstructible` — end note]

>     template<class R, class F, class... BoundArgs>
>       unspecified bind(F&& f, BoundArgs&&... bound_args);

> > -4- Requires: `is_constructible<FD, F>::value` shall be `true`. `is_constructible<TiD, Ti>::value` shall be `true`. `F` and each `Ti` in `BoundArgs` shall be CopyConstructible. `INVOKE(fd, w1, w2, ..., wN)` shall be a valid expression for some values w1, w2, ..., wN, where `N == sizeof...(bound_args)`.

> > -5- Returns: A forwarding call wrapper `g` with a nested type `result_type` defined as a synonym for `R`. The effect of `g(u1, u2, ..., uM)` shall be `INVOKE(fd, v1, v2, ..., vN, R)`, where the values and types of the bound arguments `v1, v2, ..., vN` are determined as specified below. The copy constructor and move constructor of the forwarding call wrapper shall throw an exception if and only if the corresponding constructor of `FD` or any of the types `TiD` throw an exception.

> > -6- Throws: Nothing unless the copy construction or of `Ffd` or of one of the values `tid` types in the `BoundArgs...` pack expansion throws an exception.

> > Remarks: The unspecified return type shall be `MoveConstructible`. If all of `FD` and `TiD` are `CopyConstructible` then the unspecified return type shall be `CopyConstructible`. [Note: This implies that all of `FD` and `TiD` shall be `MoveConstructible` — end note]

> -7- The values of the bound arguments `v1, v2, ..., vN` and their corresponding types `V1, V2, ..., VN` depend on the types `TiD` derived from of the corresponding argument `ti` in `bound_args` of type `Ti` in `BoundArgs` in the call to `bind` and the cv-qualifiers cv of the call wrapper `g` as follows:

> - if `ti TiD` is of has type `reference_wrapper<T>` the argument is `tid.get()` and its type `Vi` is `T&`;
> - if the value of `std::is_bind_expression<TiD>::value` is `true` the argument is `tid(u1, u2, ..., uM)` and its type `Vi` is `result_of<TiD cv (U1&, U2&, ..., UM&)>::type`;
> - if the value `j` of `std::is_placeholder<TiD>::value` is not zero the argument is `std::forward<Uj>(uj)` and its type `Vi` is `Uj&&`;
> - otherwise the value is `tid` and its type `Vi` is `TiD cv &`.

### 819. rethrow_if_nested

Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2008-03-25 Last modified: 2009-10-23

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with Open status.

Discussion:

Looking at the wording I submitted for `rethrow_if_nested`, I don't think I got it quite right.

The current wording says:

>     template <class E> void rethrow_if_nested(const E& e);

> > Effects: Calls `e.rethrow_nested()` only if `e` is publicly derived from `nested_exception`.

This is trying to be a bit subtle, by requiring `e` (not `E`) to be publicly derived from `nested_exception` the idea is that a `dynamic_cast` would be required to be sure. Unfortunately, if `e` is dynamically but not statically derived from `nested_exception`, `e.rethrow_nested()` is ill-formed.

[ San Francisco: ]

> Alisdair was volunteered to provide wording.

[ 2009-10 Santa Cruz: ]

> Leave as Open. Alisdair to provide wording.

Proposed resolution:

### 834. Unique_ptr::pointer requirements underspecified

Section: 20.8.14.2 [unique.ptr.single] Status: Open Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2009-10-26

View other active issues in [unique.ptr.single].

View all other issues in [unique.ptr.single].

View all issues with Open status.

Discussion:

Issue 673 (including recent updates by 821) proposes a useful extension point for `unique_ptr` by granting support for an optional `deleter_type::pointer` to act as pointer-like replacement for `element_type*` (In the following: `pointer`).

Unfortunately no requirements are specified for the type `pointer` which has impact on at least two key features of `unique_ptr`:

1. Operational fail-safety.
2. (Well-)Definedness of expressions.

`Unique_ptr` specification makes great efforts to require that essentially *all* operations cannot throw and therefore adds proper wording to the affected operations of the deleter as well. If user-provided `pointer`-emulating types ("smart pointers") will be allowed, either *all* throw-nothing clauses have to be replaced by weaker "An exception is thrown only if `pointer`'s {op} throws an exception"-clauses or it has to be said explicitly that all used operations of `pointer` are required *not* to throw. I understand the main focus of `unique_ptr` to be as near as possible to the advantages of native pointers which cannot fail and thus strongly favor the second choice. Also, the alternative position would make it much harder to write safe and simple template code for `unique_ptr`. Additionally, I assume that a general statement need to be given that all of the expressions of `pointer` used to define semantics are required to be well-formed and well-defined (also as back-end for 762).

[ Sophia Antipolis: ]

> Howard: We maybe need a core concept `PointerLike`, but we don't need the arithmetic (see `shared_ptr` vs. `vector<T>::iterator`.

> Howard will go through and enumerate the individual requirements wrt. `pointer` for each member function.

[ 2009-07 Frankfurt: ]

> Move to Ready.

[ 2009-10-15 Alisdair pulls from Ready: ]

> I hate to pull an issue out of Ready status, but I don't think 834 is fully baked yet.

> For reference the proposed resolution is to add the following words:

> > `unique_ptr<T, D>::pointer`'s operations shall be well-formed, shall have well defined behavior, and shall not throw exceptions.

> This leaves me with a big question : which operations?

> Are all pointer operations required to be nothrow, including operations that have nothing to do with interactions with `unique_ptr`? This was much simpler with concepts where we could point to operations within a certain concept, and so nail down the interactions.

[ 2009-10-15 Daniel adds: ]

> I volunteer to prepare a more fine-grained solution, but I would like to ask for feedback that helps me doing so. If this question is asked early in the meeting I might be able to fix it within the week, but I cannot promise that now.

[ 2009-10 Santa Cruz: ]

> Leave in open. Daniel to provide wording as already suggested.

Proposed resolution:

Add the following sentence just at the end of the newly proposed 20.8.14.2 [unique.ptr.single]/p. 3:

> `unique_ptr<T, D>::pointer`'s operations shall be well-formed, shall have well defined behavior, and shall not throw exceptions.

### 835. tying two streams together (correction to DR 581)

Section: 27.5.4.2 [basic.ios.members] Status: Open Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-10-20

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with Open status.

Discussion:

The fix for issue 581, now integrated into the working paper, overlooks a couple of minor problems.

First, being an unformatted function once again, `flush()` is required to create a sentry object whose constructor must, among other things, flush the tied stream. When two streams are tied together, either directly or through another intermediate stream object, flushing one will also cause a call to `flush()` on the other tied stream(s) and vice versa, ad infinitum. The program below demonstrates the problem.

Second, as Bo Persson notes in his comp.lang.c++.moderated post, for streams with the `unitbuf` flag set such as `std::stderr`, the destructor of the sentry object will again call `flush()`. This seems to create an infinite recursion for `std::cerr << std::flush;`

>     #include <iostream>

>     int main ()
>     {
>        std::cout.tie (&std::cerr);
>        std::cerr.tie (&std::cout);
>        std::cout << "cout\n";
>        std::cerr << "cerr\n";
>     }

[ Batavia (2009-05): ]

> We agree with the proposed resolution. Move to Review.

[ 2009-05-26 Daniel adds: ]

> I think that the most recently suggested change in 27.7.2.4 [ostream::sentry] need some further word-smithing. As written, it would make the behavior undefined, if under conditions when `pubsync()` should be called, but when in this scenario `os.rdbuf()` returns 0.

> This case is explicitly handled in `flush()` and needs to be taken care of. My suggested fix is:

> > If `((os.flags() & ios_base::unitbuf) && !uncaught_exception()` `&& os.rdbuf() != 0`) is true, calls `os.flush()` `os.rdbuf()->pubsync()`.

> Two secondary questions are:

> 1. Should `pubsync()` be invoked in any case or shouldn't a base requirement for this trial be that `os.good() == true` as required in the original `flush()` case?
> 2. Since `uncaught_exception()` is explicitly tested, shouldn't a return value of -1 of `pubsync()` produce `setstate(badbit)` (which may throw `ios_base::failure`)?

[ 2009-07 Frankfurt: ]

> Daniel volunteered to modify the proposed resolution to address his two questions.

> Move back to Open.

[ 2009-07-26 Daniel provided wording. Moved to Review. ]

[ 2009-10-13 Daniel adds: ]

> This proposed wording is written to match the outcome of 397.

[ 2009 Santa Cruz: ]

> Move to Open. Martin to propose updated wording that will also resolve issue 397 consistently.

Proposed resolution:

[ based on N2960 numbering ]

1. Just before 27.5.4.2 [basic.ios.members]/2 insert a new paragraph:

   > Requires: If `(tiestr != 0)` is `true`, `tiestr` must not be reachable by traversing the linked list of tied stream objects starting from `tiestr->tie()`.

2. Change 27.7.2.4 [ostream::sentry]/4 as indicated:

   > If `((os.flags() & ios_base::unitbuf) && !uncaught_exception()&& os.good())` is `true`, calls `os.flush()` `os.rdbuf()->pubsync()`. If that function returns -1 sets `badbit` in `os.rdstate()` without propagating an exception.

### 836. effects of `money_base::space` and `money_base::none` on `money_get`

Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Ready Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-10-21

View all other issues in [locale.money.get.virtuals].

View all issues with Ready status.

Duplicate of: 670

Discussion:

In paragraph 2, 22.4.6.1.2 [locale.money.get.virtuals] specifies the following:

> Where `space` or `none` appears in the format pattern, except at the end, optional white space (as recognized by `ct.is`) is consumed after any required space.

This requirement can be (and has been) interpreted two mutually exclusive ways by different readers. One possible interpretation is that:

> 1. where `money_base::space` appears in the format, at least one space is required, and
> 2. where `money_base::none` appears in the format, space is allowed but not required.

The other is that:

> where either `money_base::space` or `money_base::none` appears in the format, white space is optional.

[ San Francisco: ]

> Martin will revise the proposed resolution.

[ 2009-07 Frankfurt: ]

> There is a noun missing from the proposed resolution. It's not clear that the last sentence would be helpful, even if the word were not missing:

> > In either case, any required MISSINGWORD followed by all optional whitespace (as recognized by ct.is()) is consumed.

> Strike this sentence and move to Review.

> [ Howard: done. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

I propose to change the text to make it clear that the first interpretation is intended, that is, to make following change to 22.4.6.1.2 [locale.money.get.virtuals], p2:

> When `money_base::space` or `money_base::none` appears as the last element in the format pattern, except at the end, optional white space (as recognized by `ct.is`) is consumed after any required space. no white space is consumed. Otherwise, where `money_base::space` appears in any of the initial elements of the format pattern, at least one white space character is required. Where `money_base::none` appears in any of the initial elements of the format pattern, white space is allowed but not required. If `(str.flags() & str.showbase)` is `false`, ...

### 854. `default_delete` converting constructor underspecified

Section: 20.8.14.1.1 [unique.ptr.dltr.dflt] Status: Ready Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-10-21

View all issues with Ready status.

Discussion:

No relationship between `U` and `T` in the converting constructor for `default_delete` template.

Requirements: `U*` is convertible to `T*` and `has_virtual_destructor<T>`; the latter should also become a concept.

Rules out cross-casting.

The requirements for `unique_ptr` conversions should be the same as those on the deleter.

[ Howard adds 2008-11-26: ]

> I believe we need to be careful to not outlaw the following use case, and I believe the current proposed wording (`requires Convertible<U*, T*> && HasVirtualDestructor<T>`) does so:

> >     #include <memory>

> >     int main()
> >     {
> >         std::unique_ptr<int> p1(new int(1));
> >         std::unique_ptr<const int> p2(move(p1));
> >         int i = *p2;
> >     //    *p2 = i;  // should not compile
> >     }

> I've removed "`&& HasVirtualDestructor<T>`" from the `requires` clause in the proposed wording.

[ Post Summit: ]

> Alisdair: This issue has to stay in review pending a paper constraining `unique_ptr`.

> Consensus: We agree with the resolution, but `unique_ptr` needs to be constrained, too.

> Recommend Keep in Review.

[ Batavia (2009-05): ]

> Keep in Review status for the reasons cited.

[ 2009-07 Frankfurt: ]

> The proposed resolution uses concepts. Howard needs to rewrite the proposed resolution.

> Move back to Open.

[ 2009-07-26 Howard provided rewritten proposed wording and moved to Review. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add after 20.8.14.1.1 [unique.ptr.dltr.dflt], p1:

>     template <class U> default_delete(const default_delete<U>& other);

> > -1- Effects: ...

> > Remarks: This constructor shall participate in overload resolution if and only if `U*` is implicitly convertible to `T*`.

### 860. Floating-Point State

Section: 26 [numerics] Status: Ready Submitter: Lawrence Crowl Opened: 2008-06-23 Last modified: 2009-10-23

View all other issues in [numerics].

View all issues with Ready status.

Discussion:

There are a number of functions that affect the floating point state. These function need to be thread-safe, but I'm unsure of the right approach in the standard, as we inherit them from C.

[ San Francisco: ]

> Nick: I think we already say that these functions do not introduce data races; see 17.6.5.6/20

> Pete: there's more to it than not introducing data races; are these states maintained per thread?

> Howard: 21.5/14 says that strtok and strerror are not required to avoid data races, and 20.9/2 says the same about asctime, gmtime, ctime, and gmtime.

> Nick: POSIX has a list of not-safe functions. All other functions are implicitly thread safe.

> Lawrence is to form a group between meetings to attack this issue. Nick and Tom volunteered to work with Lawrence.

> Move to Open.

[ Post Summit: ]

> Hans: Sane oses seem ok. Sensible thing is implementable and makes sense.

> Nick: Default wording seems to cover this? Hole in POSIX, these functions need to be added to list of thread-unsafe functions.

> Lawrence: Not sufficient, not "thread-safe" per our definition, but think of state as a thread-local variable. Need something like "these functions only affect state in the current thread."

> Hans: Suggest the following wording: "The floating point environment is maintained per-thread."

> Walter: Any other examples of state being thread safe that are not already covered elsewhere?

> Have thread unsafe functions paper which needs to be updated. Should just fold in 26.3 [cfenv] functions.

> Recommend Open. Lawrence instead suggests leaving it open until we have suitable wording that may or may not include the thread local commentary.

[ 2009-09-23 Hans provided wording. ]

> If I understand the history correctly, Nick, as the Posix liaison, should probably get a veto on this, since I think it came from Posix (?) via WG14 and should probably really be addressed there (?). But I think we are basically in agreement that there is no other sane way to do this, and hence we don't have to worry too much about stepping on toes. As far as I can tell, this same issue also exists in the latest Posix standard (?).

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

Add at the end of 26.3.1 [cfenv.syn]:

> 2 The header defines all functions, types, and macros the same as C99 7.6.

> A separate floating point environment shall be maintained for each thread. Each function accesses the environment corresponding to its calling thread.

### 861. Incomplete specification of EqualityComparable for std::forward_list

Section: 23.2 [container.requirements] Status: Open Submitter: Daniel Krügler Opened: 2008-06-24 Last modified: 2009-10-24

View other active issues in [container.requirements].

View all other issues in [container.requirements].

View all issues with Open status.

Discussion:

Table 89, Container requirements, defines `operator==` in terms of the container member function `size()` and the algorithm `std::equal`:

> `==` is an equivalence relation. `a.size() == b.size() && equal(a.begin(), a.end(), b.begin()`

The new container `forward_list` does not provide a `size` member function by design but does provide `operator==` and `operator!=` without specifying it's semantic.

Other parts of the (sequence) container requirements do also depend on `size()`, e.g. `empty()` or `clear()`, but this issue explicitly attempts to solve the missing `EqualityComparable` specification, because of the special design choices of `forward_list`.

I propose to apply one of the following resolutions, which are described as:

1. Provide a definition, which is optimal for this special container without previous size test. This choice prevents two `O(N)` calls of `std::distance()` with the corresponding container ranges and instead uses a special `equals` implementation which takes two container ranges instead of 1 1/2.
2. The simple fix where the usual test is adapted such that `size()` is replaced by `distance` with corresponding performance disadvantages.

Both proposal choices are discussed, the preferred choice of the author is to apply (A).

[ San Francisco: ]

> There's an Option C: change the requirements table to use distance().

> LWG found Option C acceptable.

> Martin will draft the wording for Option C.

[ post San Francisco: ]

> Martin provided wording for Option C.

[ 2009-07 Frankfurt ]

> Other operational semantics (see, for example, Tables 82 and 83) are written in terms of a container's size() member. Daniel to update proposed resolution C.

> [ Howard: Commented out options A and B. ]

[ 2009-07-26 Daniel updated proposed resolution C. ]

[ 2009-10 Santa Cruz: ]

> Mark NAD Editorial. Addressed by N2986.

[ 2009-10 Santa Cruz: ]

> Reopened. N2986 was rejected in full committee on procedural grounds.

Proposed resolution:

Option (C):

> [ The changes are relative to N2914 but concept-free. ]

> 1. In 23.2.1 [container.requirements.general] change Table 80 -- Container requirements as indicated:

>    1. Change the text in the Assertion/note column in the row for "`X u`;" as follows:

>       > post: `u.size() == 0empty() == true`

>    2. Change the text in the Assertion/note column in the row for "`X();`" as follows:

>       > `X().size() == 0empty() == true`

>    3. Change the text in the Operational Semantics column in the row for "`a == b`" as follows:

>       > `==` is an equivalence relation. `a.size()distance(a.begin(), a.end()) == b.size()distance(b.begin(), b.end()) && equal(a.begin(), a.end(), b.begin())`

>    4. Change the text in the Operational Semantics column in the row for "`a.size()`" as follows:

>       > `a.end() - a.begin()distance(a.begin(), a.end())`

>    5. Change the text in the Operational Semantics column in the row for "`a.max_size()`" as follows:

>       > `size()distance(begin(), end())` of the largest possible container

>    6. Change the text in the Operational Semantics column in the row for "`a.empty()`" as follows:

>       > `a.size() == 0a.begin() == a.end()`

> 2. In 23.2.1 [container.requirements.general] change Table 82 -- Allocator-aware container requirements as indicated:

>    1. Change the text in the Assertion/note column in the row for "`X() / X u;`" as follows:

>       > Requires: `A` is `DefaultConstructible` post: `u.size() == 0u.empty() == true`, `get_allocator() == A()`

>    2. Change the text in the Assertion/note column in the row for "`X(m) / X u(m);`" as follows:

>       > post: `u.size() == 0u.empty() == true, get_allocator() == m`

> 3. In 23.2.3 [sequence.reqmts] change Table 83 -- Sequence container requirements as indicated:

>    1. Change the text in the Assertion/note column in the row for "`X(n, t) / X a(n, t)`" as follows:

>       > post: `size()distance(begin(), end()) == n [..]`

>    2. Change the text in the Assertion/note column in the row for "`X(i, j) / X a(i, j)`" as follows:

>       > [..] post: `size() ==` distance between `i` and `j` `distance(begin(), end()) == distance(i, j)` [..]

>    3. Change the text in the Assertion/note column in the row for "`a.clear()`" as follows:

>       > `a.erase(a.begin(), a.end())` post: `size() == 0a.empty() == true`

> 4. In 23.2.4 [associative.reqmts] change Table 85 -- Associative container requirements as indicated:

>    [ Not every occurrence of `size()` was replaced, because all current associative containers have a `size`. The following changes ensure consistency regarding the semantics of "`erase`" for all tables and adds some missing objects ]

>    1. Change the text in the Complexity column in the row for "`a.insert(i, j)`" as follows:

>       > `N log(a.size() + N)` (`N` is the distance from `i` to `j`) where `N == distance(i, j)`

>    2. Change the text in the Complexity column in the row for "`a.erase(k)`" as follows:

>       > `log(a.size()) + a.count(k)`

>    3. Change the text in the Complexity column in the row for "`a.erase(q1, q2)`" as follows:

>       > `log(a.size()) + N` where `N` is the distance from `q1` to `q2` `== distance(q1, q2)`.

>    4. Change the text in the Assertion/note column in the row for "`a.clear()`" as follows:

>       > `a.erase(a.begin(),a.end())` post: `size() == 0a.empty() == true`

>    5. Change the text in the Complexity column in the row for "`a.clear()`" as follows:

>       > linear in `a.size()`

>    6. Change the text in the Complexity column in the row for "`a.count(k)`" as follows:

>       > `log(a.size()) + a.count(k)`

> 5. In 23.2.5 [unord.req] change Table 87 -- Unordered associative container requirements as indicated:

>    [ The same rational as for Table 85 applies here ]

>    1. Change the text in the Assertion/note column in the row for "`a.clear()`" as follows:

>       > [..] Post: `a.size() == 0empty() == true`

### 865. More algorithms that throw away information

Section: 25.3.6 [alg.fill], 25.3.7 [alg.generate] Status: Ready Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-10-23

View all issues with Ready status.

Discussion:

In regard to library defect 488 I found some more algorithms which unnecessarily throw away information. These are typically algorithms, which sequentially write into an `OutputIterator`, but do not return the final value of this output iterator. These cases are:

1.     template<class OutputIterator, class Size, class T>
       void fill_n(OutputIterator first, Size n, const T& value);

2.     template<class OutputIterator, class Size, class Generator>
       void generate_n(OutputIterator first, Size n, Generator gen);

In both cases the minimum requirements on the iterator are `OutputIterator`, which means according to the requirements of 24.2.2 [output.iterators]/2 that only single-pass iterations are guaranteed. So, if users of `fill_n` and `generate_n` have *only* an `OutputIterator` available, they have no chance to continue pushing further values into it, which seems to be a severe limitation to me.

[ Post Summit Daniel "conceptualized" the wording. ]

[ Batavia (2009-05): ]

> Alisdair likes the idea, but has concerns about the specific wording about the returns clauses.

> Alan notes this is a feature request.

> Bill notes we have made similar changes to other algorithms.

> Move to Open.

[ 2009-07 Frankfurt ]

> We have a consensus for moving forward on this issue, but Daniel needs to deconceptify it.

[ 2009-07-25 Daniel provided non-concepts wording. ]

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

1. Replace the current declaration of `fill_n` in 25 [algorithms]/2, header `<algorithm>` synopsis and in 25.3.6 [alg.fill] by

   >     template<class OutputIterator, class Size, class T>
   >       voidOutputIterator fill_n(OutputIterator first, Size n, const T& value);

   Just after the effects clause add a new returns clause saying:

   > Returns: For `fill_n` and positive `n`, returns `first + n`. Otherwise returns `first` for `fill_n`.

2. Replace the current declaration of `generate_n` in 25 [algorithms]/2, header `<algorithm>` synopsis and in 25.3.7 [alg.generate] by

   >     template<class OutputIterator, class Size, class Generator>
   >       voidOutputIterator generate_n(OutputIterator first, Size n, Generator gen);

   Just after the effects clause add a new returns clause saying:

   > For `generate_n` and positive `n`, returns `first + n`. Otherwise returns `first` for `generate_n`.

### 868. default construction and value-initialization

Section: 23 [containers] Status: Ready Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2009-10-20

View other active issues in [containers].

View all other issues in [containers].

View all issues with Ready status.

Discussion:

The term "default constructed" is often used in wording that predates the introduction of the concept of value-initialization. In a few such places the concept of value-initialization is more correct than the current wording (for example when the type involved can be a built-in) so a replacement is in order. Two of such places are already covered by issue 867. This issue deliberately addresses the hopefully non-controversial changes in the attempt of being approved more quickly. A few other occurrences (for example in `std::tuple`, `std::reverse_iterator` and `std::move_iterator`) are left to separate issues. For `std::reverse_iterator`, see also issue 408. This issue is related with issue 724.

[ San Francisco: ]

> The list provided in the proposed resolution is not complete. James Dennett will review the library and provide a complete list and will double-check the vocabulary.

> This issue relates to Issue 886 tuple construction

[ 2009-07 Frankfurt ]

> The proposed resolution is incomplete.

> Move to Tentatively NAD Future. Howard will contact Ganesh for wording. If wording is forthcoming, Howard will move it back to Review.

[ 2009-07-18 Ganesh updated the proposed wording. ]

> Howard: Moved back to Review. Note that 20.2.1 [utility.arg.requirements] refers to a section that is not in the current working paper, but does refer to a section that we expect to reappear after the de-concepts merge. This was a point of confusion we did not recognize when we reviewed this issue in Frankfurt.

> Howard: Ganesh also includes a survey of places in the WP surveyed for changes of this nature and purposefully not treated:

> > Places where changes are not being proposed

> > In the following paragraphs, we are not proposing changes because it's not clear whether we actually prefer value-initialization over default-initialization (now partially covered by 1012):

> > - 20.8.14.2.1 [unique.ptr.single.ctor] para 3 e 7

> > - 24.5.1.3.1 [reverse.iter.cons] para 1

> > - 24.5.3.3.1 [move.iter.op.const] para 1

> > In the following paragraphs, the expression "default constructed" need not be changed, because the relevant type does not depend on a template parameter and has a user-provided constructor:

> > - [func.referenceclosure.invoke] para 12, type: reference_closure

> > - 30.3.1.2 [thread.thread.constr] para 30, type: thread

> > - 30.3.1.5 [thread.thread.member] para 52, type: thread_id

> > - 30.3.2 [thread.thread.this], para 1, type: thread_id

[ 2009-08-18 Daniel adds: ]

> I have no objections against the currently suggested changes, but I also cross-checked with the list regarding intentionally excluded changes, and from this I miss the discussion of

> 1. 21.4.1 [string.require]/2:

>    > "[..] The `Allocator` object used shall be a copy of the `Allocator>` object passed to the `basic_string` object's constructor or, if the constructor does not take an `Allocator` argument, a copy of a default-constructed `Allocator` object."

> 2. N2723, X [rand.req.eng], Table 109, expression "`T()`":

>    > Pre-/post-condition: "Creates an engine with the same initial state as all other default-constructed engines of type `X`."

>    as well as in 26.5.5 [rand.predef]/1-9 (N2914), 26.5.7.1 [rand.util.seedseq]/3, 27.7.1.1.1 [istream.cons]/3, 27.7.2.2 [ostream.cons]/9 (N2914), 28.13 [re.grammar]/2, 30.3.1.4 [thread.thread.assign]/1 (N2914),

>    [ Candidates for the "the expression "default constructed" need not be changed" list ]

>    I'm fine, if these would be added to the intentionally exclusion list, but mentioning them makes it easier for other potential reviewers to decide on the relevance or not-relevance of them for this issue.

> 3. I suggest to remove the reference of [func.referenceclosure.invoke] in the "it's not clear" list, because this component does no longer exist.

> 4. I also suggest to add a short comment that all paragraphs in the resolution whether they refer to N2723 or to N2914 numbering, because e.g. "Change 23.3.2.1 [deque.cons] para 5" is an N2723 coordinate, while "Change 23.3.2.2 [deque.capacity] para 1" is an N2914 coordinate. Even better would be to use one default document for the numbering (probably N2914) and mention special cases (e.g. "Change 20.2.1 [utility.arg.requirements] para 2" as referring to N2723 numbering).

[ 2009-08-18 Alisdair adds: ]

> I strongly believe the term "default constructed" should not appear in the library clauses unless we very clearly define a meaning for it, and I am not sure what that would be.

> In those cases where we do not want to replace "default constructed" with "vale initialized" we should be using "default initialized". If we have a term that could mean either, we reduce portability of programs.

> I have not done an exhaustive review to clarify if that is a vendor freedom we have reason to support (e.g. value-init in debug, default-init in release) so I may yet be convinced that LWG has reason to define this new term of art, but generally C++ initialization is confusing enough without supporting further ill-defined terms.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change 20.2.1 [utility.arg.requirements] para 2:

> In general, a default constructor is not required. Certain container class member function signatures specify the default constructor T() as a default argument. T() shall be a well-defined expression (8.5) if one of those signatures is called using the default argument (8.3.6).

Change 23.3.2.1 [deque.cons] para 5:

> Effects: Constructs a deque with n default constructed value-initialized elements.

Change 23.3.2.2 [deque.capacity] para 1:

> Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If size() < sz, appends sz - size() default constructed value-initialized elements to the sequence.

Change 23.3.3.1 [forwardlist.cons] para 5:

> Effects: Constructs a forward_list object with n default constructed value-initialized elements.

Change 23.3.3.4 [forwardlist.modifiers] para 21:

> Effects: [...] For the first signature the inserted elements are default constructed value-initialized, and for the second signature they are copies of c.

Change 23.3.4.1 [list.cons] para 5:

> Effects: Constructs a list with n default constructed value-initialized elements.

Change 23.3.4.2 [list.capacity] para 15:

> Effects: If sz < size(), equivalent to list<T>::iterator it = begin(); advance(it, sz); erase(it, end());. If size() < sz, appends sz - size() default constructed value-initialized elements to the sequence.

Change 23.3.6.1 [vector.cons] para 3:

> Effects: Constructs a vector with n default constructed value-initialized elements.

Change 23.3.6.2 [vector.capacity] para 24:

> Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If size() < sz, appends sz - size() default constructed value-initialized elements to the sequence.

### 870. Do unordered containers not support function pointers for predicate/hasher?

Section: 23.2.5 [unord.req] Status: Open Submitter: Daniel Krügler Opened: 2008-08-17 Last modified: 2009-10-20

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with Open status.

Discussion:

Good ol' associative containers allow both function pointers and function objects as feasible comparators, as described in 23.2.4 [associative.reqmts]/2:

> Each associative container is parameterized on `Key` and an ordering relation `Compare` that induces a strict weak ordering (25.3) on elements of Key. [..]. The object of type `Compare` is called the comparison object of a container. This comparison object may be a pointer to function or an object of a type with an appropriate function call operator.[..]

The corresponding wording for unordered containers is not so clear, but I read it to disallow function pointers for the hasher and I miss a clear statement for the equality predicate, see 23.2.5 [unord.req]/3+4+5:

> Each unordered associative container is parameterized by `Key`, by a function object `Hash` that acts as a hash function for values of type `Key`, and by a binary predicate `Pred` that induces an equivalence relation on values of type `Key`.[..]

> A hash function is a function object that takes a single argument of type `Key` and returns a value of type `std::size_t`.

> Two values `k1` and `k2` of type `Key` are considered equal if the container's equality function object returns `true` when passed those values.[..]

and table 97 says in the column "assertion...post-condition" for the expression X::hasher:

> `Hash` shall be a unary function object type such that the expression `hf(k)` has type `std::size_t`.

Note that 20.7 [function.objects]/1 defines as "Function objects are objects with an `operator()` defined.[..]"

Does this restriction exist by design or is it an oversight? If an oversight, I suggest that to apply the following

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-10 Santa Cruz: ]

> Ask Daniel to provide proposed wording that: makes it explicit that function pointers are function objects at the beginning of 20.7 [function.objects]; fixes the "requirements" for typedefs in 20.7.5 [refwrap] to instead state that the function objects defined in that clause have these typedefs, but not that these typedefs are requirements on function objects; remove the wording that explicitly calls out that associative container comparators may be function pointers.

Proposed resolution:

In 23.2.5 [unord.req]/3, just after the second sentence which is written as

> Additionally, `unordered_map` and `unordered_multimap` associate an arbitrary mapped type `T` with the `Key`.

add one further sentence:

> Both `Hash` and `Pred` may be pointers to function or objects of a type with an appropriate function call operator.

[Note1: Since the detailed requirements for `Pred` and `Hash` are given in p.4 and p.5, it an alternative resolution would be to insert a new paragraph just after p.5, which contains the above proposed sentence]

[Note2: I do not propose a change of above quoted element in table 97, because the mis-usage of the notion of "function object" seems already present in the standard at several places, even if it includes function pointers, see e.g. 25 [algorithms]/7. The important point is that in those places a statement is given that the actually used symbol, like "Predicate" applies for function pointers as well]

Rationale:

[ San Francisco: ]

> This is fixed by N2776.

### 871. Iota's requirements on T are too strong

Section: 26.7.5 [numeric.iota] Status: Ready Submitter: Daniel Krügler Opened: 2008-08-20 Last modified: 2009-10-22

View all issues with Ready status.

Discussion:

According to the recent WP N2691, 26.7.5 [numeric.iota]/1, the requires clause of `std::iota` says:

> `T` shall meet the requirements of `CopyConstructible` and `Assignable` types, and shall be convertible to `ForwardIterator`'s value type.[..]

Neither `CopyConstructible` nor `Assignable` is needed, instead `MoveConstructible` seems to be the correct choice. I guess the current wording resulted as an artifact from comparing it with similar numerical algorithms like `accumulate`.

Note: If this function will be conceptualized, the here proposed `MoveConstructible` requirement can be removed, because this is an implied requirement of function arguments, see N2710/[temp.req.impl]/3, last bullet.

[ post San Francisco: ]

> Issue pulled by author prior to review.

[ 2009-07-30 Daniel reopened: ]

> with the absence of concepts, this issue (closed) is valid again and I suggest to reopen it. I also revised by proposed resolution based on N2723 wording:

[ 2009-10 Santa Cruz: ]

> Change 'convertible' to 'assignable', Move To Ready.

Proposed resolution:

Change the first sentence of 26.7.5 [numeric.iota]/1:

> Requires: `T` shall meet the requirements of `CopyConstructible` and `Assignable` types, and shall be assignable to `ForwardIterator`'s value type. [..]

### 872. `move_iterator::operator[]` has wrong return type

Section: 24.5.3.3.12 [move.iter.op.index] Status: Ready Submitter: Doug Gregor Opened: 2008-08-21 Last modified: 2009-10-23

View all issues with Ready status.

Discussion:

`move_iterator`'s `operator[]` is declared as:

>     reference operator[](difference_type n) const;

This has the same problem that `reverse_iterator`'s `operator[]` used to have: if the underlying iterator's `operator[]` returns a proxy, the implicit conversion to `value_type&&` could end up referencing a temporary that has already been destroyed. This is essentially the same issue that we dealt with for `reverse_iterator` in DR 386.

[ 2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

[ 2009-08-15 Howard adds: ]

> I recommend closing this as a duplicate of 1051 which addresses this issue for both `move_iterator` and `reverse_iterator`.

[ 2009-10 Santa Cruz: ]

> Move to Ready. Note that if 1051 is reopened, it may yield a better resolution, but 1051 is currently marked NAD.

Proposed resolution:

In 24.5.3.1 [move.iterator] and 24.5.3.3.12 [move.iter.op.index], change the declaration of `move_iterator`'s `operator[]` to:

>     reference unspecified operator[](difference_type n) const;

Rationale:

[ San Francisco: ]

> NAD Editorial, see N2777.

### 885. pair assignment

Section: 20.3.4 [pairs] Status: Open Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2009-07-17

View other active issues in [pairs].

View all other issues in [pairs].

View all issues with Open status.

Discussion:

>     20.2.3 pairs
>     Missing assignemnt operator:
>     template<class U , class V>
>       requires CopyAssignable<T1, U> && CopyAssignable<T2, V>
>         pair& operator=(pair<U , V> const & p );

Well, that's interesting. This assignment operator isn't in the current working paper, either. Perhaps we deemed it acceptable to build a temporary of type `pair` from `pair<U, V>`, then move-assign from that temporary?

It sounds more like an issue waiting to be opened, unless you want to plug it now. As written we risk moving from lvalues.

[ San Francisco: ]

> Would be NAD if better ctors fixed it.

> Related to 811.

[ post San Francisco: ]

> Possibly NAD Editorial, solved by N2770.

[ 2009-05-25 Alisdair adds: ]

> Issue 885 was something I reported while reviewing the library concepts documents ahead of San Francisco. The missing operator was added as part of the paper adopted at that meeting (N2770) and I can confirm this operator is present in the current working paper. I recommend NAD.

[ 2009-07 Frankfurt ]

> We agree with the intent, but we need to wait for the dust to settle on concepts.

Proposed resolution:

### 887. issue with condition::wait_...

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-10-26

View other active issues in [thread.condition.condvar].

View all other issues in [thread.condition.condvar].

View all issues with Open status.

Discussion:

The Posix/C++ working group has identified an inconsistency between Posix and the C++ working draft in that Posix requires the clock to be identified at creation, whereas C++ permits identifying the clock at the call to wait. The latter cannot be implemented with the former.

[ San Francisco: ]

> Howard recommends NAD with the following explanation:

> The intent of the current wording is for the `condtion_variable::wait_until` be able to handle user-defined clocks as well as clocks the system knows about. This can be done by providing overloads for the known clocks, and another overload for unknown clocks which synchs to a known clock before waiting. For example:

> >     template <class Duration>
> >     bool
> >     condition_variable::wait_until(unique_lock<mutex>& lock,
> >                                    const chrono::time_point<chrono::system_clock, Duration>& abs_time)
> >     {
> >         using namespace chrono;
> >         nanoseconds d = __round_up<nanoseconds>(abs_time.time_since_epoch());
> >         __do_timed_wait(lock.mutex()->native_handle(), time_point<system_clock, nanoseconds>(d));
> >         return system_clock::now() < abs_time;
> >     }

> >     template <class Clock, class Duration>
> >     bool
> >     condition_variable::wait_until(unique_lock<mutex>& lock,
> >                                    const chrono::time_point<Clock, Duration>& abs_time)
> >     {
> >         using namespace chrono;
> >         system_clock::time_point    s_entry = system_clock::now();
> >         typename Clock::time_point  c_entry = Clock::now();
> >         nanoseconds dn = __round_up<nanoseconds>(abs_time.time_since_epoch() -
> >                                                   c_entry.time_since_epoch());
> >         __do_timed_wait(lock.mutex()->native_handle(), s_entry + dn);
> >         return Clock::now() < abs_time;
> >     }

> In the above example, `system_clock` is the only clock which the underlying condition variable knows how to deal with. One overload just passes that clock through. The second overload (approximately) converts the unknown clock into a `system_clock time_point` prior to passing it down to the native condition variable.

> On Posix systems vendors are free to add implementation defined constructors which take a clock. That clock can be stored in the condition_variable, and converted to (or not as necessary) as shown above.

> If an implementation defined constructor takes a clock (for example), then part of the semantics for that implementation defined ctor might include that a `wait_until` using a clock other than the one constructed with results in an error (exceptional condition) instead of a conversion to the stored clock. Such a design is up to the vendor as once an implementation defined ctor is used, the vendor is free to specifiy the behavior of waits and/or notifies however he pleases (when the cv is constructed in an implementation defined manner).

[ Post Summit: ]

> "POSIX people will review the proposed NAD resolution at their upcoming NY meeting.

> See the minutes at: http://wiki.dinkumware.com/twiki/bin/view/Posix/POSIX-CppBindingWorkingGroupNewYork2009.

[ 2009-07 Frankfurt ]

> Move to NAD.

[ 2009-07-18 Detlef reopens the issue: ]

> On Friday afternoon in Frankfurt is was decided that 887 is NAD. This decision was mainly based on a sample implementation presented by Howard that implemented one clock on top of another. Unfortunately this implementation doesn't work for the probably most important case where a system has a monotonic clock and a real-time clock (or "wall time" clock):

> If the underlying "system_clock" is a monotonic clock, and the program waits on the real-time clock, and the real-time clock is set forward, the wait will unblock too late.

> If the underlying "system_clock" is a real-time clock, and the program waits on the monotonic clock, and the real-time clock is set back, the wait again will unblock too late.

> Sorry that I didn't remember this on Friday, but it was Friday afternoon after a busy week...

> So as the decision was made on a wrong asumption, I propose to re-open the issue.

[ 2009-07-26 Howard adds: ]

> Detlef correctly argues that `condition_variable::wait_until` could return "too late" in the context of clocks being adjusted during the wait. I agree with his logic. But I disagree that this makes this interface unimplementable on POSIX.

> The POSIX spec also does not guarantee that `pthread_cond_timedwait` does not return "too late" when clocks are readjusted during the wait. Indeed, the POSIX specification lacks any requirements at all concerning how soon `pthread_cond_timedwait` returns after a time out. This is evidently a QOI issue by the POSIX standard. Here is a quote of the most relevant normative text concerning `pthread_cond_timedwait` found here.

> > The `pthread_cond_timedwait()` function shall be equivalent to `pthread_cond_wait()`, except that an error is returned if the absolute time specified by `abstime` passes (that is, system time equals or exceeds `abstime`) before the condition `cond` is signaled or broadcasted, or if the absolute time specified by `abstime` has already been passed at the time of the call.

> I.e. the POSIX specification speaks of the error code returned in case of a time out, but not on the timeliness of that return.

> Might this simply be an oversight, or minor defect in the POSIX specification?

> I do not believe so. This same section goes on to say in non-normative text:

> > For cases when the system clock is advanced discontinuously by an operator, it is expected that implementations process any timed wait expiring at an intervening time as if that time had actually occurred.

> Here is non-normative wording encouraging the implementation to ignore an advancing underlying clock and subsequently causing an early (spurious) return. There is no wording at all which addresses Detlef's example of a "late return". With `pthread_cond_timedwait` this would be caused by setting the system clock backwards. It seems reasonable to assume, based on the wording that is already in the POSIX spec, that again, the discontinuously changed clock would be ignored by `pthread_cond_timedwait`.

> A noteworthy difference between `pthread_cond_timedwait` and `condition_variable::wait_until` is that the POSIX spec appears to say that `ETIMEDOUT` should be returned if `pthread_cond_timedwait` returns because of timeout signal, whether or not the system clock was discontinuously advanced during the wait. In contrast `condition_variable::wait_until` always returns:

> >     Clock::now() < abs_time

> That is, the C++ spec requires that the clock be rechecked (detecting discontinuous adjustments during the wait) at the time of return. `condition_variable::wait_until` may indeed return early or late. But regardless it will return a value reflecting timeout status at the time of return (even if clocks have been adjusted). Of course the clock may be adjusted after the return value is computed but before the client has a chance to read the result of the return. Thus there are no iron-clad guarantees here.

> `condition_variable::wait_until` (and `pthread_cond_timedwait`) is little more than a convenience function for making sure `condition_variable::wait` doesn't hang for an unreasonable amount of time (where the client gets to define "unreasonable"). I do not think it is in anyone's interest to try to make it into anything more than that.

> I maintain that this is a useful and flexible specification in the spirit of C++, and is implementable on POSIX. The implementation technique described above is a reasonable approach. There may also be higher quality approaches. This specification, like the POSIX specification, gives a wide latitude for QOI.

> I continue to recommend NAD, but would not object to a clarifying note regarding the behavior of `condition_variable::wait_until`. At the moment, I do not have good wording for such a note, but welcome suggestions.

[ 2009-09-30: See N2969. ]

[ 2009-10 Santa Cruz: ]

> The LWG is in favor of Detlef to supply revision which adopts Option 2 from N2969 but is modified by saying that `system_clock` must be available for `wait_until`.

Proposed resolution:

### 889. thread::id comparisons

Section: 30.3.1.1 [thread.thread.id] Status: Ready Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-10-22

View all other issues in [thread.thread.id].

View all issues with Ready status.

Discussion:

Addresses UK 324

The `thread::id` type supports the full set of comparison operators. This is substantially more than is required for the associative containers that justified them. Please place an issue against the threads library.

[ San Francisco: ]

> Would depend on proposed extension to POSIX, or non-standard extension. What about hash? POSIX discussing op. POSIX not known to be considering support needed for hash, op.

> Group expresses support for putting ids in both unordered and ordered containers.

[ post San Francisco: ]

> Howard: It turns out the current working paper N2723 already has `hash<thread::id>` (20.7 [function.objects], 20.7.16 [unord.hash]). We simply overlooked it in the meeting. It is a good thing we voted in favor of it (again). :-)

> Recommend NAD.

[ Post Summit: ]

> Recommend to close as NAD. For POSIX, see if we need to add a function to convert `pthread_t` to integer.

[ Post Summit, Alisdair adds: ]

> The recommendation for LWG-889/UK-324 is NAD, already specified.

> It is not clear to me that the specification is complete.

> In particular, the synopsis of `<functional>` in 20.7 [function.objects] does not mention `hash< thread::id >` nor `hash< error_code >`, although their existence is implied by 20.7.16 [unord.hash], p1.

> I am fairly uncomfortable putting the declaration for the `thread_id` specialization into `<functional>` as `id` is a nested class inside `std::thread`, so it implies that `<functional>` would require the definition of the `thread` class template in order to forward declared `thread::id` and form this specialization.

> It seems better to me that the dependency goes the other way around (`<thread>` will more typically make use of `<functional>` than vice-versa) and the `hash<thread::id>` specialization be declared in the `<thread>` header.

> I think `hash<error_code>` could go into either `<system_error>` or `<functional>` and have no immediate preference either way. However, it should clearly appear in the synopsis of one of these two.

> Recommend moving 889 back to open, and tying in a reference to UK-324.

[ Batavia (2009-05): ]

> Howard observes that `thread::id` need not be a nested class; it could be a `typedef` for a more visible type.

[ 2009-05-24 Alisdair adds: ]

> I do not believe this is correct. `thread::id` is explicitly documents as a nested class, rather than as an unspecified typedef analogous to an iterator. If the intent is that this is not implemented as a nested class (under the as-if freedoms) then this is a novel form of standardese.

[ 2009-07 Frankfurt ]

> Decided we want to move hash specialization for thread_id to the thread header. Alisdair to provide wording.

[ 2009-07-28 Alisdair provided wording, moved to Review. ]

[ 2009-10 Santa Cruz: ]

> Add a strike for `hash<thread::id>`. Move to Ready

Proposed resolution:

Remove the following prototype from the synopsis in 20.7 [function.objects]:

>     template <> struct hash<std::thread::id>;

Add to 30.3 [thread.threads], p1 Header `<thread>` synopsis:

>     template <class T> struct hash;
>     template <> struct hash<thread::id>;

Add template specialization below class definition in 30.3.1.1 [thread.thread.id]

>     template <>
>     struct hash<thread::id> : public unary_function<thread::id, size_t> {
>        size_t operator()(thread::id val) const;
>     };

Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence:

> [Note: Relational operators allow `thread::id` objects to be used as keys in associative containers. `hash` template specialization allow `thread::id` objects to be used as keys in unordered containers. — end note]

Add new paragraph to end of 30.3.1.1 [thread.thread.id]

>     template <> struct hash<thread::id>;

> > An explicit specializations of the class template hash (20.7.16 [unord.hash]) shall be provided for the values of type `thread::id` suitable for use as keys in unordered associative containers (23.5 [unord]).

### 891. std::thread, std::call_once issue

Section: 30.3.1.2 [thread.thread.constr], 30.4.5.2 [thread.once.callonce] Status: Open Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2009-10-24

View other active issues in [thread.thread.constr].

View all other issues in [thread.thread.constr].

View all issues with Open status.

Discussion:

I notice that the vararg overloads of `std::thread` and `std::call_once` (N2723 30.3.1.2 [thread.thread.constr] and 30.4.5.2 [thread.once.callonce]) are no longer specified in terms of `std::bind`; instead, some of the `std::bind` wording has been inlined into the specification.

There are two problems with this.

First, the specification (and implementation) in terms of `std::bind` allows, for example:

>     std::thread th( f, 1, std::bind( g ) );

which executes `f( 1, g() )` in a thread. This can be useful. The "inlined" formulation changes it to execute `f( 1, bind(g) )` in a thread.

Second, assuming that we don't want the above, the specification has copied the wording

> `INVOKE(func, w1, w2, ..., wN)` (20.6.2) shall be a valid expression for some values `w1, w2, ..., wN`

but this is not needed since we know that our argument list is args; it should simply be

> `INVOKE(func, args...)` (20.6.2) shall be a valid expression

[ Summit: ]

> Move to open.

[ Post Summit Anthony provided proposed wording. ]

[ 2009-07 Frankfurt ]

> Leave Open. Await decision for thread variadic constructor.

[ 2009-10 Santa Cruz: ]

> See proposed wording for 929 for this, for the formulation on how to solve this. 929 modifies the thread constructor to have "pass by value" behavior with pass by reference efficiency through the use of the `decay` trait. This same formula would be useful for `call_once`.

Proposed resolution:

Change paragraph 4 of 30.3.1.2 [thread.thread.constr] to:

>     template <class F> explicit thread(F f);
>     template <class F, class ...Args> thread(F&& f, Args&&... args);

> > -4- Requires: `F` and each `Ti` in `Args` shall be `CopyConstructible` if an lvalue and otherwise `MoveConstructible`. `INVOKE(f, w1, w2, ..., wN args...)` (20.6.2) shall be a valid expression for some values w1, w2, ..., wN, where `N == sizeof...(Args)`.

Change paragraph 1 of 30.4.5.2 [thread.once.callonce] to:

>     template<class Callable, class ...Args>
>       void call_once(once_flag& flag, Callable func, Args&&... args);

> > -1- Requires: The template parameters `Callable>` and each `Ti` in `Args` shall be `CopyConstructible` if an lvalue and otherwise `MoveConstructible`. `INVOKE(func, w1, w2, ..., wN args...)` (20.6.2) shall be a valid expression for some values w1, w2, ..., wN, where `N == sizeof...(Args)`.

### 893. std::mutex issue

Section: 30.4.1.1 [thread.mutex.class] Status: Ready Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2009-10-22

View all other issues in [thread.mutex.class].

View all issues with Ready status.

Duplicate of: 905

Discussion:

30.4.1.1 [thread.mutex.class]/27 (in N2723) says that the behavior is undefined if:

- a thread that owns a `mutex` object calls `lock()` or `try_lock()` on that object

I don't believe that this is right. Calling `lock()` or `try_lock()` on a locked `mutex` is well defined in the general case. `try_lock()` is required to fail and return `false`. `lock()` is required to either throw an exception (and is allowed to do so if it detects deadlock) or to block until the `mutex` is free. These general requirements apply regardless of the current owner of the `mutex`; they should apply even if it's owned by the current thread.

Making double `lock()` undefined behavior probably can be justified (even though I'd still disagree with the justification), but `try_lock()` on a locked `mutex` must fail.

[ Summit: ]

> Move to open. Proposed resolution:

> - In 30.4.1 [thread.mutex.requirements] paragraph 12, change the error condition for `resource_deadlock_would_occur` to: "if the implementation detects that a deadlock would occur"
> - Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2 "a thread that owns a mutex object calls `lock()` or `try_lock()` on that object, or"

[ 2009-07 Frankfurt ]

> Move to Review. Alisdair to provide note.

[ 2009-07-31 Alisdair provided note. ]

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

In 30.4.1 [thread.mutex.requirements] paragraph 12 change:

> - ...
> - `resource_deadlock_would_occur` -- if the current thread already owns the mutex and is able to detect it implementation detects that a deadlock would occur.
> - ...

Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2:

> -3- The behavior of a program is undefined if:

> - ...
> - a thread that owns a `mutex` object calls `lock()` or `try_lock()` on that object, or
> - ...

Add the following note after p3 30.4.1.1 [thread.mutex.class]

> [Note: a program may deadlock if the thread that owns a `mutex` object calls `lock()` or `try_lock()` on that object. If the program can detect the deadlock, a `resource_deadlock_would_occur` error condition may be observed. — end note]

### 896. Library thread safety issue

Section: 20.8.15.2 [util.smartptr.shared] Status: Open Submitter: Hans Boehm Opened: 2008-09-16 Last modified: 2009-10-25

View all other issues in [util.smartptr.shared].

View all issues with Open status.

Discussion:

It is unclear whether `shared_ptr` is thread-safe in the sense that multiple threads may simultaneously copy a `shared_ptr`. However this is a critical piece of information for the client, and it has significant impact on usability for many applications. (Detlef Vollman thinks it is currently clear that it is not thread-safe. Hans Boehm thinks it currently requires thread safety, since the `use_count` is not an explicit field, and constructors and assignment take a const reference to an existing `shared_ptr`.)

Pro thread-safety:

Many multi-threaded usages are impossible. A thread-safe version can be used to destroy an object when the last thread drops it, something that is often required, and for which we have no other easy mechanism.

Against thread-safety:

The thread-safe version is well-known to be far more expensive, even if used by a single thread. Many applications, including all single-threaded ones, do not care.

[ San Francisco: ]

> Beman: this is a complicated issue, and would like to move this to Open and await comment from Peter Dimov; we need very careful and complete rationale for any decision we make; let's go slow

> Detlef: I think that `shared_ptr` should not be thread-safe.

> Hans: When you create a thread with a lambda, it in some cases makes it very difficult for the lambda to reference anything in the heap. It's currently ambiguous as to whether you can use a `shared_ptr` to get at an object.

> Leave in Open. Detlef will submit an alternative proposed resolution that makes `shared_ptr` explicitly unsafe.

> A third option is to support both threadsafe and non-safe share_ptrs, and to let the programmer decide which behavior they want.

> Beman: Peter, do you support the PR?

> Peter:

> > Yes, I support the proposed resolution, and I certainly oppose any attempts to `make shared_ptr` thread-unsafe.

> > I'd mildly prefer if

> > > [Note: This is true in spite of that fact that such functions often modify `use_count()` --end note]

> > is changed to

> > > [Note: This is true in spite of that fact that such functions often cause a change in `use_count()` --end note]

> > (or something along these lines) to emphasise that `use_count()` is not, conceptually, a variable, but a return value.

[ 2009-07 Frankfurt ]

> Vote: Do we want one thread-safe shared pointer or two? If two, one would allow concurrent construction and destruction of shared pointers, and one would not be thread-safe. If one, then it would be thread-safe.

> No concensus on that vote.

> Hans to improve wording in consultation with Pete. Leave Open.

[ 2009-10 Santa Cruz: ]

> Move to Ready. Ask Editor to clear up wording a little when integrating to make it clear that the portion after the first comma only applies for the presence of data races.

[ 2009-10-24 Hans adds: ]

> I think we need to pull 896 back from ready, unfortunately. My wording doesn't say the right thing.

> I suspect we really want to say something along the lines of:

> > For purposes of determining the presence of a data race, member functions access and modify only the `shared_ptr` and `weak_ptr` objects themselves and not objects they refer to. Changes in `use_count()` do not reflect modifications that can introduce data races.

> But I think this needs further discussion by experts to make sure this is right.

> Detlef and I agree continue to disagree on the resolution, but I think we agree that it would be good to try to expedite this so that it can be in CD2, since it's likely to generate NB comments no matter what we do. And lack of clarity of intent is probably the worst option. I think it would be good to look at this between meetings.

Proposed resolution:

Make it explicitly thread-safe, in this weak sense, as I believe was intended:

Insert in 20.8.15.2 [util.smartptr.shared], before p5:

> For purposes of determining the presence of a data race, member functions do not modify `const shared_ptr` and const `weak_ptr` arguments, nor any objects they refer to. [Note: This is true in spite of that fact that such functions often cause a change in `use_count()` --end note]

On looking at the text, I'm not sure we need a similar disclaimer anywhere else, since nothing else has the problem with the modified `use_count()`. I think Howard arrived at a similar conclusion.

### 900. stream move-assignment

Section: 27.9.1.8 [ifstream.assign] Status: Open Submitter: Niels Dekker Opened: 2008-09-20 Last modified: 2009-10-20

View all issues with Open status.

Discussion:

It appears that we have an issue similar to issue 675 regarding the move-assignment of stream types. For example, when assigning to an `std::ifstream`, `ifstream1`, it seems preferable to close the file originally held by `ifstream1`:

>     ifstream1 = std::move(ifstream2);

The current Draft (N2723) specifies that the move-assignment of stream types like `ifstream` has the same effect as a swap:

> Assign and swap 27.9.1.8 [ifstream.assign]

>     basic_ifstream& operator=(basic_ifstream&& rhs);

> > Effects: `swap(rhs)`.

[ Batavia (2009-05): ]

> Howard agrees with the analysis and the direction proposed.

> Move to Open pending specific wording to be supplied by Howard.

[ 2009-07 Frankfurt: ]

> Howard is going to write wording.

[ 2009-07-26 Howard provided wording. ]

[ 2009-09-13 Niels adds: ]

> Note: The proposed change of 27.9.1.3 [filebuf.assign]/1 depends on the resolution of LWG 1204, which allows implementations to assume that `*this` and `rhs` refer to different objects.

[ 2009 Santa Cruz: ]

> Leave as Open. Too closely related to 911 to move on at this time.

Proposed resolution:

Change 27.8.1.2 [stringbuf.assign]/1:

>     basic_stringbuf& operator=(basic_stringbuf&& rhs);

> > -1- Effects: `swap(rhs)`. After the move assignment `*this` reflects the same observable state it would have if it had been move constructed from `rhs` (27.8.1.1 [stringbuf.cons]).

Change 27.8.2.2 [istringstream.assign]/1:

>     basic_istringstream& operator=(basic_istringstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

Change 27.8.3.2 [ostringstream.assign]/1:

>     basic_ostringstream& operator=(basic_ostringstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

Change 27.8.5.1 [stringstream.assign]/1:

>     basic_stringstream& operator=(basic_stringstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

Change 27.9.1.3 [filebuf.assign]/1:

>     basic_filebuf& operator=(basic_filebuf&& rhs);

> > -1- Effects: `swap(rhs)`. Begins by calling `this->close()`. After the move assignment `*this` reflects the same observable state it would have if it had been move constructed from `rhs` (27.9.1.2 [filebuf.cons]).

Change 27.9.1.8 [ifstream.assign]/1:

>     basic_ifstream& operator=(basic_ifstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

Change 27.9.1.12 [ofstream.assign]/1:

>     basic_ofstream& operator=(basic_ofstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

Change 27.9.1.16 [fstream.assign]/1:

>     basic_fstream& operator=(basic_fstream&& rhs);

> > -1- Effects: `swap(rhs)`. Move assigns the base and members of `*this` with the respective base and members of `rhs`.

### 910. Effects of MoveAssignable

Section: 20.2.1 [utility.arg.requirements] Status: Open Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2009-11-03

View other active issues in [utility.arg.requirements].

View all other issues in [utility.arg.requirements].

View all issues with Open status.

Discussion:

Addresses UK 150

The description of the effect of `operator=` in the `MoveAssignable` concept, given in paragraph 7 is:

>     result_type  T::operator=(T&&  rv);  // inherited from HasAssign<T, T&&>

> > Postconditions: the constructed `T` object is equivalent to the value of `rv` before the assignment. [Note: there is no requirement on the value of `rv` after the assignment. --end note]

The sentence contains a typo (what is the "constructed `T` object"?) probably due to a cut&paste from `MoveConstructible`. Moreover, the discussion of LWG issue 675 shows that the postcondition is too generic and might not reflect the user expectations. An implementation of the move assignment that just calls `swap()` would always fulfill the postcondition as stated, but might have surprising side-effects in case the source rvalue refers to an object that is not going to be immediately destroyed. See LWG issue 900 for another example. Due to the sometimes intangible nature of the "user expectation", it seems difficult to have precise normative wording that could cover all cases without introducing unnecessary restrictions. However a non-normative clarification could be a very helpful warning sign that swapping is not always the correct thing to do.

[ 2009-05-09 Alisdair adds: ]

> Issue 910 is exactly the reason BSI advanced the Editorial comment UK-150.

> The post-conditions after assignment are at a minimum that the object referenced by rv must be safely destructible, and the transaction should not leak resources. Ideally it should be possible to simply assign rv a new valid state after the call without invoking undefined behaviour, but any other use of the referenced object would depend upon additional guarantees made by that type.

[ 2009-05-09 Howard adds: ]

> The intent of the rvalue reference work is that the moved from `rv` is a valid object. Not one in a singular state. If, for example, the moved from object is a `vector`, one should be able to do anything on that moved-from `vector` that you can do with any other `vector`. However you would first have to query it to find out what its current state is. E.g. it might have `capacity`, it might not. It might have a non-zero `size`, it might not. But regardless, you can `push_back` on to it if you want.

> That being said, most standard code is now conceptized. That is, the concepts list the only operations that can be done with templated types - whether or not the values have been moved from.

> Here is user-written code which must be allowed to be legal:

> >     #include <vector>
> >     #include <cstdio>

> >     template <class Allocator>
> >     void
> >     inspect(std::vector<double, Allocator>&& v)
> >     {
> >         std::vector<double, Allocator> result(move(v));
> >         std::printf("moved from vector has %u size and %u capacity\n", v.size(), v.capacity());
> >         std::printf("The contents of the vector are:\n");
> >         typedef typename std::vector<double, Allocator>::iterator I;
> >         for (I i = v.begin(), e = v.end(); i != e; ++i)
> >             printf("%f\n", *i);
> >     }

> >     int main()
> >     {
> >         std::vector<double> v1(100, 5.5);
> >         inspect(move(v1));
> >     }

> The above program does not treat the moved-from `vector` as singular. It only treats it as a `vector` with an unknown value.

> I believe the current proposed wording is consistent with my view on this.

[ Batavia (2009-05): ]

> We agree that the proposed resolution is an improvement over the current wording.

[ 2009-07 Frankfurt: ]

> Need to look at again without concepts.

[ 2009-07 Frankfurt: ]

> Walter will consult with Dave and Doug.

[ 2009-10 Santa Cruz: ]

> We believe this is handled by the resolution to issue 1204, but there is to much going on in this area to be sure. Defer for now.

Proposed resolution:

In [concept.copymove], replace the postcondition in paragraph 7 with:

> Postconditions: `*this` is equivalent to the value of `rv` before the assignment. [Note: there is no requirement on the value of `rv` after the assignment, but the effect should be unsurprising to the user even in case `rv` is not immediately destroyed. This may require that resources previously owned by `*this` are released instead of transferred to `rv`. -- end note]

### 911. I/O streams and `move/swap` semantic

Section: 27.7.1 [input.streams], 27.7.2 [output.streams] Status: Open Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2009-10-20

View all issues with Open status.

Discussion:

Class template `basic_istream`, `basic_ostream` and `basic_iostream` implements public move constructors, move assignment operators and `swap` method and free functions. This might induce both the user and the compiler to think that those types are `MoveConstructible`, `MoveAssignable` and `Swappable`. However, those class templates fail to fulfill the user expectations. For example:

>     std::ostream os(std::ofstream("file.txt"));
>     assert(os.rdbuf() == 0); // buffer object is not moved to os, file.txt has been closed

>     std::vector<std::ostream> v;
>     v.push_back(std::ofstream("file.txt"));
>     v.reserve(100); // causes reallocation
>     assert(v[0].rdbuf() == 0); // file.txt has been closed!

>     std::ostream&& os1 = std::ofstream("file1.txt");
>     os1 = std::ofstream("file2.txt");
>     os1 << "hello, world"; // still writes to file1.txt, not to file2.txt!

>     std::ostream&& os1 = std::ofstream("file1.txt");
>     std::ostream&& os2 = std::ofstream("file2.txt");
>     std::swap(os1, os2);
>     os1 << "hello, world"; // writes to file1.txt, not to file2.txt!

This is because the move constructor, the move assignment operator and `swap` are all implemented through calls to `std::basic_ios` member functions `move()` and `swap()` that do not move nor swap the controlled stream buffers. That can't happen because the stream buffers may have different types.

Notice that for `basic_streambuf`, the member function `swap()` is protected. I believe that is correct and all of `basic_istream`, `basic_ostream`, `basic_iostream` should do the same as the move ctor, move assignment operator and swap member function are needed by the derived `fstream`s and `stringstream`s template. The free swap functions for `basic_(i|o|io)stream` templates should be removed for the same reason.

[ Batavia (2009-05): ]

> We note that the rvalue swap functions have already been removed.

> Bill is unsure about making the affected functions protected; he believes they may need to be public.

> We are also unsure about removing the lvalue swap functions as proposed.

> Move to Open.

[ 2009-07 Frankfurt: ]

> It's not clear that the use case is compelling.

> Howard: This needs to be implemented and tested.

[ 2009-07-26 Howard adds: ]

> I started out thinking I would recommend NAD for this one. I've turned around to agree with the proposed resolution (which I've updated to the current draft). I did not fully understand Ganesh's rationale, and attempt to describe my improved understanding below.

> The move constructor, move assignment operator, and swap function are different for `basic_istream`, `basic_ostream` and `basic_iostream` than other classes. A timely conversation with Daniel reminded me of this long forgotten fact. These members are sufficiently different that they would be extremely confusing to use in general, but they are very much needed for derived clients.

> - The move constructor moves everything but the `rdbuf` pointer.
> - The move assignment operator moves everything but the `rdbuf` pointer.
> - The swap function swaps everything but the `rdbuf` pointer.

> The reason for this behavior is that for the std-derived classes (stringstreams, filestreams), the `rdbuf` pointer points back into the class itself (self referencing). It can't be swapped or moved. But this fact isn't born out at the `stream` level. Rather it is born out at the `fstream`/`sstream` level. And the lower levels just need to deal with that fact by not messing around with the `rdbuf` pointer which is stored down at the lower levels.

> In a nutshell, it is very confusing for all of those who are not so intimately related with streams that they've implemented them. And it is even fairly confusing for some of those who have (including myself). I do not think it is safe to swap or move `istreams` or `ostreams` because this will (by necessary design) separate stream state from streambuffer state. Derived classes (such as `fstream` and `stringstream` must be used to keep the stream state and stream buffer consistently packaged as one unit during a move or swap.

> I've implemented this proposal and am living with it day to day.

[ 2009 Santa Cruz: ]

> Leave Open. Pablo expected to propose alternative wording which would rename move construction, move assignment and swap, and may or may not make them protected. This will impact issue 900.

Proposed resolution:

27.7.1.1 [istream]: make the following member functions protected:

>     basic_istream(basic_istream&&  rhs);
>     basic_istream&  operator=(basic_istream&&  rhs);
>     void  swap(basic_istream&  rhs);

Ditto: remove the swap free function signature

>     // swap:
>     template <class charT, class traits>
>       void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);

27.7.1.1.2 [istream.assign]: remove paragraph 4

>     template <class charT, class traits>
>       void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);

> > Effects: `x.swap(y)`.

27.7.1.5 [iostreamclass]: make the following member function protected:

>     basic_iostream(basic_iostream&&  rhs);
>     basic_iostream&  operator=(basic_iostream&&  rhs);
>     void  swap(basic_iostream&  rhs);

Ditto: remove the swap free function signature

>     template <class charT, class traits>
>       void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);

27.7.1.5.3 [iostream.assign]: remove paragraph 3

>     template <class charT, class traits>
>       void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);

> > Effects: `x.swap(y)`.

27.7.2.1 [ostream]: make the following member function protected:

>     basic_ostream(basic_ostream&&  rhs);
>     basic_ostream&  operator=(basic_ostream&&  rhs);
>     void  swap(basic_ostream&  rhs);

Ditto: remove the swap free function signature

>     // swap:
>     template <class charT, class traits>
>       void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);

27.7.2.3 [ostream.assign]: remove paragraph 4

>     template <class charT, class traits>
>       void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);

> > Effects: `x.swap(y)`.

### 915. `minmax` with `initializer_list` should return `pair` of `T`, not `pair` of `const T&`

Section: 25.4.7 [alg.min.max] Status: Open Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-10-23

View all other issues in [alg.min.max].

View all issues with Open status.

Discussion:

It seems that the proposed changes for N2772 were not clear enough in this point:

> 25.4.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return type of the `minmax` overloads with an `initializer_list` is `pair<const T&, const T&>`, which is inconsistent with the decision for the other `min/max` overloads which take a `initializer_list` as argument and return a `T`, not a `const T&`. Doing otherwise for `minmax` would easily lead to unexpected life-time problems by using `minmax` instead of `min` and `max` separately.

[ Batavia (2009-05): ]

> We agree with the proposed resolution. Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-08-18 Daniel adds: ]

> Recommend NAD since the proposed changes have already been performed as part of editorial work of N2914.

[ 2009-10 Santa Cruz: ]

> Can't find initializer_list form of minmax anymore, only variadic version. Seems like we had an editing clash with concepts. Leave Open, at least until editorial issues resolved. Bring this to Editor's attention.

Proposed resolution:

1. In 25 [algorithms]/2, header `<algorithm>` synopsis change as indicated:

   >     template<classLessThanComparable T>
   >     requires CopyConstructible<T>
   >     pair<const T&, const T&>
   >     minmax(initializer_list<T> t);

   >     template<class T, classStrictWeakOrder<auto, T> Compare>
   >     requires CopyConstructible<T>
   >     pair<const T&, const T&>
   >     minmax(initializer_list<T> t, Compare comp);

2. In 25.4.7 [alg.min.max] change as indicated (Begin: Just before p.20):

   >     template<classLessThanComparable T>
   >       requires CopyConstructible<T>
   >       pair<const T&, const T&>
   >       minmax(initializer_list<T> t);

   > > -20- Requires: `T` is `LessThanComparable` and `CopyConstructible`.

   > > -21- Returns: `pair<const T&, const T&>(x, y)` where `x` is the smallest value and `y` the largest value in the `initializer_list`.

   > [..]

   >     template<class T, classStrictWeakOrder<auto, T> Compare>
   >       requires CopyConstructible<T>
   >       pair<const T&, const T&>
   >       minmax(initializer_list<T> t, Compare comp);

   > > -24- Requires: type `T` is `LessThanComparable` and `CopyConstructible`.

   > > -25- Returns: `pair<const T&, const T&>(x, y)` where `x` is the smallest value and `y` largest value in the `initializer_list`.

### 920. Ref-qualification support in the library

Section: 20.7.14 [func.memfn] Status: Ready Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-10-23

View all other issues in [func.memfn].

View all issues with Ready status.

Duplicate of: 1230

Discussion:

Daniel Krügler wrote:

> Shouldn't above list be completed for &- and &&-qualified member functions This would cause to add:

> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) &);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) const &);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) volatile &);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) &&);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) const &&);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
> >     template<Returnable R, class T, CopyConstructible... Args>
> >     unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);

yes, absolutely. Thanks for spotting this. Without this change `mem_fn` cannot be initialized from pointer to ref-qualified member function. I believe semantics of such function pointer is well defined.

[ Post Summit Daniel provided wording. ]

[ Batavia (2009-05): ]

> We need to think about whether we really want to go down the proposed path of combinatorial explosion. Perhaps a Note would suffice.

> We would really like to have an implementation before proceeding.

> Move to Open, and recommend this be deferred until after the next Committee Draft has been issued.

[ 2009-10-10 Daniel updated wording to post-concepts. ]

> 1230 has a similar proposed resolution

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

1. Change 20.7 [function.objects]/2, header `<functional>` synopsis as follows:

   >     // 20.7.14, member function adaptors:
   >     template<class R, class T> unspecified mem_fn(R T::*);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...));
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);

2. Change the prototype list of 20.7.14 [func.memfn] as follows [NB: The following text, most notably p.2 and p.3 which discuss influence of the cv-qualification on the definition of the base class's first template parameter remains unchanged. ]:

   >     template<class R, class T> unspecified mem_fn(R T::* pm);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...));
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &);

   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
   >     template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);

3. Remove 20.7.14 [func.memfn]/5:

   > Remarks: Implementations may implement `mem_fn` as a set of overloaded function templates.

### 921. Rational Arithmetic should use template aliases

Section: 20.4.1 [ratio.ratio] Status: Ready Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-10-21

View all other issues in [ratio.ratio].

View all issues with Ready status.

Discussion:

The compile-time functions that operate on `ratio<N,D>` require the cumbersome and error-prone "evaluation" of a `type` member using a meta-programming style that predates the invention of template aliases. Thus, multiplying three ratios `a`, `b`, and `c` requires the expression:

>     ratio_multiply<a, ratio_multiply<b, c>::type>::type

The simpler expression:

>     ratio_multiply<a, ratio_multiply<b, c>>

Could be used by if template aliases were employed in the definitions.

[ Post Summit: ]

> Jens: not a complete proposed resolution: "would need to make similar change"

> Consensus: We agree with the direction of the issue.

> Recommend Open.

[ 2009-05-11 Daniel adds: ]

> Personally I'm not in favor for the addition of:

> >     typedef ratio type;

> For a reader of the standard it's usage or purpose is unclear. I haven't seen similar examples of attempts to satisfy non-feature complete compilers.

[ 2009-05-11 Pablo adds: ]

> The addition of type to the `ratio` template allows the previous style (i.e., in the prototype implementations) to remain valid and permits the use of transitional library implementations for C++03 compilers. I do not feel strongly about its inclusion, however, and leave it up to the reviewers to decide.

[ Batavia (2009-05): ]

> Bill asks for additional discussion in the issue that spells out more details of the implementation. Howard points us to issue 948 which has at least most of the requested details. Tom is strongly in favor of overflow-checking at compile time. Pete points out that there is no change of functionality implied. We agree with the proposed resolution, but recommend moving the issue to Review to allow time to improve the discussion if needed.

[ 2009-07-21 Alisdair adds: ]

> See 1121 for a potentially incompatible proposal.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

0. In 20.4 [ratio]/3 change as indicated:

   >     // ratio arithmetic
   >     template <class R1, class R2> structusing ratio_add = see below;
   >     template <class R1, class R2> structusing ratio_subtract = see below;
   >     template <class R1, class R2> structusing ratio_multiply = see below;
   >     template <class R1, class R2> structusing ratio_divide = see below;

1. In 20.4.1 [ratio.ratio], change as indicated:

   >     namespace std {
   >       template <intmax_t N, intmax_t D = 1>
   >       class ratio {
   >       public:
   >         typedef ratio type;
   >         static const intmax_t num;
   >         static const intmax_t den;
   >       };
   >     }

2. In 20.4.2 [ratio.arithmetic] change as indicated:

   >     template <class R1, class R2> structusing ratio_add = see below{
   >       typedef see below type;
   >     };

   > > 1 The nested typedef type `ratio_add<R1, R2>` shall be a synonym for `ratio<T1, T2>` where `T1` has the value `R1::num * R2::den + R2::num * R1::den` and `T2` has the value `R1::den * R2::den`.

   >     template <class R1, class R2> structusing ratio_subtract = see below{
   >       typedef see below type;
   >     };

   > > 2 The nested typedef type `ratio_subtract<R1, R2>` shall be a synonym for `ratio<T1, T2>` where `T1` has the value `R1::num * R2::den - R2::num * R1::den` and `T2` has the value `R1::den * R2::den`.

   >     template <class R1, class R2> structusing ratio_multiply = see below{
   >       typedef see below type;
   >     };

   > > 3 The nested typedef type `ratio_multiply<R1, R2>` shall be a synonym for `ratio<T1, T2>` where `T1` has the value `R1::num * R2::num` and `T2` has the value `R1::den * R2::den`.

   >     template <class R1, class R2> structusing ratio_divide = see below{
   >       typedef see below type;
   >     };

   > > 4 The nested typedef type `ratio_divide<R1, R2>` shall be a synonym for `ratio<T1, T2>` where `T1` has the value `R1::num * R2::den` and `T2` has the value `R1::den * R2::num`.

3. In 20.9.3.1 [time.duration.cons]/4 change as indicated:

   > Requires: `treat_as_floating_point<rep>::value` shall be true or `ratio_divide<Period2, period>::type::den` shall be 1.[..]

4. In 20.9.3.7 [time.duration.cast]/2 change as indicated:

   > Returns: Let CF be `ratio_divide<Period, typename ToDuration::period>::type`, and [..]

### 929. Thread constructor

Section: 30.3.1.2 [thread.thread.constr] Status: Review Submitter: Anthony Williams Opened: 2008-10-23 Last modified: 2009-10-25

View other active issues in [thread.thread.constr].

View all other issues in [thread.thread.constr].

View all issues with Review status.

Discussion:

Addresses UK 323

The `thread` constructor for starting a new thread with a function and arguments is overly constrained by the signature requiring rvalue references for `func` and `args` and the `CopyConstructible` requirements for the elements of `args`. The use of an rvalue reference for the function restricts the potential use of a plain function name, since the type of the bound parameter will be deduced to be a function reference and decay to pointer-to-function will not happen. This therefore complicates the implementation in order to handle a simple case. Furthermore, the use of rvalue references for args prevents the array to pointer decay. Since arrays are not `CopyConstructible` or even `MoveConstructible`, this essentially prevents the passing of arrays as parameters. In particular it prevents the passing of string literals. Consequently a simple case such as

>     void f(const char*);
>     std::thread t(f,"hello");

is ill-formed since the type of the string literal is `const char[6]`.

By changing the signature to take all parameters by value we can eliminate the `CopyConstructible` requirement and permit the use of arrays, as the parameter passing semantics will cause the necessary array-to-pointer decay. They will also cause the function name to decay to a pointer to function and allow the implementation to handle functions and function objects identically.

The new signature of the `thread` constructor for a function and arguments is thus:

>     template<typename F,typename... Args>
>     thread(F,Args... args);

Since the parameter pack `Args` can be empty, the single-parameter constructor that takes just a function by value is now redundant.

[ Howard adds: ]

> I agree with everything Anthony says in this issue. However I believe we can optimize in such a way as to get the pass-by-value behavior with the pass-by-rvalue-ref performance. The performance difference is that the latter removes a `move` when passing in an lvalue.

> This circumstance is very analogous to `make_pair` (20.3.4 [pairs]) where we started with passing by const reference, changed to pass by value to get pointer decay, and then changed to pass by rvalue reference, but modified with `decay<T>` to retain the pass-by-value behavior. If we were to apply the same solution here it would look like:

> >     template <class F> explicit thread(F f);
> >     template <class F, class ...Args> thread(F&& f, Args&&... args);

> > > -4- Requires: `F` and each `Ti` in `Args` shall be `CopyConstructible` if an lvalue and otherwise `MoveConstructible`. `INVOKE(f, w1, w2, ..., wN)` (20.7.2 [func.require]) shall be a valid expression for some values `w1, w2, ... , wN,` where `N == sizeof...(Args)`.

> > > -5- Effects: Constructs an object of type `thread` and executes `INVOKE(f, t1, t2, ..., tN)` in a new thread of execution, where `t1, t2, ..., tN` are the values in `args...`. Constructs the following objects in memory which is accessible to a new thread of execution as if:

> > > >     typename decay<F>::type g(std::forward<F>(f));
> > > >     tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);

> > > The new thread of execution executes `INVOKE(g, wi...)` where the `wi...` refers to the elements stored in the `tuple w`. Any return value from `g` is ignored. If `f` terminates with an uncaught exception, `std::terminate()` shall be called. If the evaluation of `INVOKE(g, wi...)` terminates with an uncaught exception, `std::terminate()` shall be called [Note: `std::terminate()` could be called before entering `g`. -- end note]. Any exception thrown before the evaluation of `INVOKE` has started shall be catchable in the calling thread.

> Text referring to when `terminate()` is called was contributed by Ganesh.

[ Batavia (2009-05): ]

> We agree with the proposed resolution, but would like the final sentence to be reworded since "catchable" is not a term of art (and is used nowhere else).

[ 2009-07 Frankfurt: ]

> This is linked to N2901.

> Howard to open a separate issue to remove (1176).

> In Frankfurt there is no consensus for removing the variadic constructor.

[ 2009-10 Santa Cruz: ]

> We want to move forward with this issue. If we later take it out via 1176 then that's ok too. Needs small group to improve wording.

[ 2009-10 Santa Cruz: ]

> Stefanus provided revised wording. Moved to Review Here is the original wording:

> > Modify the class definition of `std::thread` in 30.3.1 [thread.thread.class] to remove the following signature:

> > >     template<class F> explicit thread(F f);
> > >     template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);

> > Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with the single constructor as above. Replace paragraph 4 - 6 with the following:

> > > -4- Requires: `F` and each `Ti` in `Args` shall be `CopyConstructible` if an lvalue and otherwise `MoveConstructible`. `INVOKE(f, w1, w2, ..., wN)` (20.7.2 [func.require]) shall be a valid expression for some values `w1, w2, ... , wN,` where `N == sizeof...(Args)`.

> > > -5- Effects: Constructs an object of type `thread` and executes `INVOKE(f, t1, t2, ..., tN)` in a new thread of execution, where `t1, t2, ..., tN` are the values in `args...`. Constructs the following objects:

> > > >     typename decay<F>::type g(std::forward<F>(f));
> > > >     tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);

> > > and executes `INVOKE(g, wi...)` in a new thread of execution. These objects shall be destroyed when the new thread of execution completes. Any return value from `g` is ignored. If `f` terminates with an uncaught exception, `std::terminate()` shall be called. If the evaluation of `INVOKE(g, wi...)` terminates with an uncaught exception, `std::terminate()` shall be called [Note: `std::terminate()` could be called before entering `g`. -- end note]. Any exception thrown before the evaluation of `INVOKE` has started shall be catchable in the calling thread.

> > > -6- Synchronization: The invocation of the constructor happens before the invocation of `f` `g`.

Proposed resolution:

Modify the class definition of `std::thread` in 30.3.1 [thread.thread.class] to remove the following signature:

>     template<class F> explicit thread(F f);
>     template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);

Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with the single constructor as above. Replace paragraph 4 - 6 with the following:

> -4- Requires: `F` and each `Ti` in `Args` shall be `CopyConstructible` if an lvalue and otherwise `MoveConstructible`. `INVOKE(f, w1, w2, ..., wN)` (20.7.2 [func.require]) shall be a valid expression for some values `w1, w2, ... , wN,` where `N == sizeof...(Args)`.

> -5- Effects: Constructs an object of type `thread` and executes `INVOKE(f, t1, t2, ..., tN)` in a new thread of execution, where `t1, t2, ..., tN` are the values in `args...`. Given a function as follows: Any return value from `f` is ignored. If `f` terminates with an uncaught exception, `std::terminate()` shall be called.

> >     template<typename T> typename decay<T>::type decay_copy(T&& v)
> >         { return std::forward<T>(v); }

> The new thread of execution executes `INVOKE(decay_copy(f), decay_copy(args)...)` with the calls to `decay_copy()` being evaluated in the constructing thread. Any return value from this invocation is ignored. [Note: this implies any exceptions not thrown from the invocation of the copy of `f` will be thrown in the constructing thread, not the new thread. — end note].

> -6- Synchronization: The invocation of the constructor happens before the invocation of copy of `f`.

### 932. `unique_ptr(pointer p)` for pointer deleter types

Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready Submitter: Howard Hinnant Opened: 2008-11-26 Last modified: 2009-10-22

View other active issues in [unique.ptr.single.ctor].

View all other issues in [unique.ptr.single.ctor].

View all issues with Ready status.

Discussion:

Addresses US 79

20.8.14.2.1 [unique.ptr.single.ctor]/5 no longer requires for `D` not to be a pointer type. I believe this restriction was accidently removed when we relaxed the completeness reuqirements on `T`. The restriction needs to be put back in. Otherwise we have a run time failure that could have been caught at compile time:

>     {
>     unique_ptr<int, void(*)(void*)> p1(malloc(sizeof(int)));  // should not compile
>     }  // p1.~unique_ptr() dereferences a null function pointer
>     unique_ptr<int, void(*)(void*)> p2(malloc(sizeof(int)), free);  // ok

[ Post Summit: ]

> Recommend Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.

[ 2009-07 Frankfurt: ]

> We need to consider whether some requirements in the Requires paragraphs of [unique.ptr] should instead be Remarks.

> Leave Open. Howard to provide wording, and possibly demonstrate how this can be implemented using enable_if.

[ 2009-07-27 Howard adds: ]

> The two constructors to which this issue applies are not easily constrained with `enable_if` as they are not templated:

> >     unique_ptr();
> >     explicit unique_ptr(pointer p);

> To "SFINAE" these constructors away would take heroic effort such as specializing the entire `unique_ptr` class template on pointer deleter types. There is insufficient motivation for such heroics. Here is the expected and reasonable implementation for these constructors:

> >     unique_ptr()
> >         : ptr_(pointer())
> >         {
> >             static_assert(!is_pointer<deleter_type>::value,
> >                 "unique_ptr constructed with null function pointer deleter");
> >         }
> >     explicit unique_ptr(pointer p)
> >         : ptr_(p)
> >         {
> >             static_assert(!is_pointer<deleter_type>::value,
> >                 "unique_ptr constructed with null function pointer deleter");
> >         }

> I.e. just use `static_assert` to verify that the constructor is not instantiated with a function pointer for a deleter. The compiler will automatically take care of issuing a diagnostic if the deleter is a reference type (uninitialized reference error).

> In keeping with our discussions in Frankfurt, I'm moving this requirement on the implementation from the Requires paragraph to a Remarks paragraph.

[ 2009-08-17 Daniel adds: ]

> It is insufficient to require a diagnostic. This doesn't imply an ill-formed program as of 1.3.3 [defns.diagnostic] (a typical alternative would be a compiler warning), but exactly that seems to be the intend. I suggest to use the following remark instead:

> > Remarks: The program shall be ill-formed if this constructor is instantiated when `D` is a pointer type or reference type.

> Via the general standard rules of 1.4 [intro.compliance] the "diagnostic required" is implied.

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

Change the description of the default constructor in 20.8.14.2.1 [unique.ptr.single.ctor]:

>     unique_ptr();

> > -1- Requires: `D` shall be default constructible, and that construction shall not throw an exception. `D` shall not be a reference type or pointer type (diagnostic required).

> > ...

> > Remarks: The program shall be ill-formed if this constructor is instantiated when `D` is a pointer type or reference type.

Add after 20.8.14.2.1 [unique.ptr.single.ctor]/8:

>     unique_ptr(pointer p);

> > ...

> > Remarks: The program shall be ill-formed if this constructor is instantiated when `D` is a pointer type or reference type.

### 939. Problem with `std::identity` and reference-to-temporaries

Section: 20.3.3 [forward] Status: Ready Submitter: Alisdair Meredith Opened: 2008-12-11 Last modified: 2009-10-29

View all other issues in [forward].

View all issues with Ready status.

Discussion:

`std::identity` takes an argument of type `T const &` and returns a result of `T const &`.

Unfortunately, this signature will accept a value of type other than `T` that is convertible-to-`T`, and then return a reference to the dead temporary. The constraint in the concepts version simply protects against returning reference-to-`void`.

Solutions:

> i/ Return-by-value, potentially slicing bases and rejecting non-copyable types

> ii/ Provide an additional overload:

> >     template< typename T >
> >     template operator( U & ) = delete;

> This seems closer on intent, but moves beyond the original motivation for the operator, which is compatibility with existing (non-standard) implementations.

> iii/ Remove the `operator()` overload. This restores the original definition of the `identity`, although now effectively a type_trait rather than part of the perfect forwarding protocol.

> iv/ Remove `std::identity` completely; its original reason to exist is replaced with the `IdentityOf` concept.

My own preference is somewhere between (ii) and (iii) - although I stumbled over the issue with a specific application hoping for resolution (i)!

[ Batavia (2009-05): ]

> We dislike options i and iii, and option ii seems like overkill. If we remove it (option iv), implementers can still provide it under a different name.

> Move to Open pending wording (from Alisdair) for option iv.

[ 2009-05-23 Alisdair provided wording for option iv. ]

[ 2009-07-20 Alisdair adds: ]

> I'm not sure why this issue was not discussed at Frankfurt (or I missed the discussion) but the rationale is now fundamentally flawed. With the removal of concepts, `std::identity` again becomes an important library type so we cannot simply remove it.

> At that point, we need to pick one of the other suggested resolutions, but have no guidance at the moment.

[ 2009-07-20 Howard adds: ]

> I believe the rationale for not addressing this issue in Frankfurt was that it did not address a national body comment.

> I also believe that removal of `identity` is still a practical option as my latest reformulation of `forward`, which is due to comments suggested at Summit, no longer uses `identity`. :-)

> >     template <class T, class U,
> >         class = typename enable_if
> >                 <
> >                     !is_lvalue_reference<T>::value ||
> >                      is_lvalue_reference<T>::value &&
> >                      is_lvalue_reference<U>::value
> >                 >::type,
> >         class = typename enable_if
> >                 <
> >                     is_same<typename remove_all<T>::type,
> >                             typename remove_all<U>::type>::value
> >                 >::type>
> >     inline
> >     T&&
> >     forward(U&& t)
> >     {
> >         return static_cast<T&&>(t);

> >     }

> > [ The above code assumes acceptance of 1120 for the definition of `remove_all`. This is just to make the syntax a little more palatable. Without this trait the above is still very implementable. ]

> Paper with rationale is on the way ... really, I promise this time! ;-)

[ 2009-07-30 Daniel adds: See 823 for an alternative resolution. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready. Howard will update proposed wording to reflect current draft.

Proposed resolution:

Strike from 20.3 [utility]:

>     template <class T> struct identity;

Remove from 20.3.3 [forward]:

>     template <class T> struct identity {
>       typedef T type;

>       const T& operator()(const T& x) const;
>     };

>     const T& operator()(const T& x) const;

> > -2- Returns: `x`

### 940. `std::distance`

Section: 24.4.4 [iterator.operations] Status: Ready Submitter: Thomas Opened: 2008-12-14 Last modified: 2009-10-22

View other active issues in [iterator.operations].

View all other issues in [iterator.operations].

View all issues with Ready status.

Discussion:

Addresses UK 270

Regarding the `std::distance` - function, 24.4.4 [iterator.operations] / 4 says:

> Returns the number of increments or decrements needed to get from first to last.

This sentence is completely silent about the sign of the return value. 24.4.4 [iterator.operations] / 1 gives more information about the underlying operations, but again no inferences about the sign can be made. Strictly speaking, that is taking that sentence literally, I think this sentence even implies a positive return value in all cases, as the number of increments or decrements is clearly a ratio scale variable, with a natural zero bound.

Practically speaking, my implementations did what common sense and knowledge based on pointer arithmetic forecasts, namely a positive sign for increments (that is, going from `first` to `last` by `operator++`), and a negative sign for decrements (going from `first` to `last` by `operator--`).

Here are my two questions:

First, is that paragraph supposed to be interpreted in the way what I called 'common sense', that is negative sign for decrements ? I am fairly sure that's the supposed behavior, but a double-check here in this group can't hurt.

Second, is the present wording (2003 standard version - no idea about the draft for the upcoming standard) worth an edit to make it a bit more sensible, to mention the sign of the return value explicitly ?

[ Daniel adds: ]

> My first thought was that resolution 204 would already cover the issue report, but it seems that current normative wording is in contradiction to that resolution:

> Referring to N2798, 24.4.4 [iterator.operations]/ p.4 says:

> > Effects: Returns the number of increments or decrements needed to get from `first` to `last`.

> IMO the part " or decrements" is in contradiction to p. 5 which says

> > Requires: `last` shall be reachable from `first`.

> because "reachable" is defined in X [iterator.concepts]/7 as

> > An iterator `j` is called reachable from an iterator `i` if and only if there is a finite sequence of applications of the expression `++i` that makes `i == j`.[..]

> Here is wording that would be consistent with this definition of "reachable":

> Change 24.4.4 [iterator.operations] p4 as follows:

> > Effects: Returns the number of increments or decrements needed to get from `first` to `last`.

Thomas adds more discussion and an alternative view point here.

[ Summit: ]

> The proposed wording below was verbally agreed to. Howard provided.

[ Batavia (2009-05): ]

> Pete reports that a recent similar change has been made for the `advance()` function.

> We agree with the proposed resolution. Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-07 Frankfurt: ]

> Leave Open pending arrival of a post-Concepts WD.

[ 2009-10-14 Daniel provided de-conceptified wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready, replacing the Effects clause in the proposed wording with "If InputIterator meets the requirements of random access iterator then returns (last - first), otherwise returns the number of increments needed to get from first to list.".

Proposed resolution:

1. Change 24.2.5 [random.access.iterators], Table 105 as indicated [This change is not essential but it simplifies the specification] for the row with expression "`b - a`" and the column Operational semantics:

   >     (a < b) ? distance(a,b)
   >     : -distance(b,a)

2. Change 24.4.4 [iterator.operations]/4+5 as indicated:

   >     template<class InputIterator>
   >       typename iterator_traits<InputIterator>::difference_type
   >         distance(InputIterator first, InputIterator last);

   > > 4 Effects: If `InputIterator` meets the requirements of random access iterator then returns `(last - first)`, otherwise R returns the number of increments or decrements needed to get from `first` to `last`.

   > > 5 Requires: If `InputIterator` meets the requirements of random access iterator then `last` shall be reachable from `first` or `first` shall be reachable from `last`, otherwise `last` shall be reachable from `first`.

### 950. unique_ptr converting ctor shouldn't accept array form

Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready Submitter: Howard Hinnant Opened: 2009-01-07 Last modified: 2009-10-21

View other active issues in [unique.ptr.single.ctor].

View all other issues in [unique.ptr.single.ctor].

View all issues with Ready status.

Discussion:

`unique_ptr`'s of array type should not convert to `unique_ptr`'s which do not have an array type.

>     struct Deleter
>     {
>        void operator()(void*) {}
>     };

>     int main()
>     {
>        unique_ptr<int[], Deleter> s;
>        unique_ptr<int, Deleter> s2(std::move(s));  // should not compile
>     }

[ Post Summit: ]

> Walter: Does the "diagnostic required" apply to both arms of the "and"?

> Tom Plum: suggest to break into several sentences

> Walter: suggest "comma" before the "and" in both places

> Recommend Review.

[ Batavia (2009-05): ]

> The post-Summit comments have been applied to the proposed resolution. We now agree with the proposed resolution. Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.

[ 2009-08-01 Howard updates wording and sets to Review. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change 20.8.14.2.1 [unique.ptr.single.ctor]:

>     template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);

> > -20- Requires: If `D` is not a reference type, construction of the deleter `D` from an rvalue of type `E` shall be well formed and shall not throw an exception. If `D` is a reference type, then `E` shall be the same type as `D` (diagnostic required). `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`. [Note: These requirements imply that `T` and `U` are complete types. — end note]

> > Remarks: If `D` is a reference type, then `E` shall be the same type as `D`, else this constructor shall not participate in overload resolution. `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`, else this constructor shall not participate in overload resolution. `U` shall not be an array type, else this constructor shall not participate in overload resolution. [Note: These requirements imply that `T` and `U` are complete types. — end note]

Change 20.8.14.2.3 [unique.ptr.single.asgn]:

>     template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);

> > -6- Requires: Assignment of the deleter `D` from an rvalue `D` shall not throw an exception. `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`. [Note: These requirements imply that `T` and `U` are complete types. — end note]

> > Remarks: `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`, else this operator shall not participate in overload resolution. `U` shall not be an array type, else this operator shall not participate in overload resolution. [Note: These requirements imply that `T` and `U` are complete types. — end note]

### 951. Various threading bugs #1

Section: 20.9.2.1 [time.traits.is_fp] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-23

View all issues with Open status.

Discussion:

Related to 953.

20.9.2.1 [time.traits.is_fp] says that the type `Rep` "is assumed to be ... a class emulating an integral type." What are the requirements for such a type?

[ 2009-05-10 Howard adds: ]

> `IntegralLike`.

[ Batavia (2009-05): ]

> As with issue 953, we recommend this issue be addressed in the context of providing concepts for the entire `thread` header.

> We look forward to proposed wording.

> Move to Open.

[ 2009-08-01 Howard adds: ]

> I have surveyed all clauses of 20.9.2.2 [time.traits.duration_values], 20.9.2.3 [time.traits.specializations] and 20.9.3 [time.duration]. I can not find any clause which involves the use of a `duration::rep` type where the requirements on the `rep` type are not clearly spelled out. These requirements were carefully crafted to allow any arithmetic type, or any user-defined type emulating an arithmetic type.

> Indeed, `treat_as_floating_point` becomes completely superfluous if `duration::rep` can never be a class type.

> There will be some `Rep` types which will not meet the requirements of every `duration` operation. This is no different than the fact that `vector<T>` can easily be used for types `T` which are not `DefaultConstructible`, even though some members of `vector<T>` require `T` to be `DefaultConstructible`. This is why the requirements on `Rep` are specified for each operation individually.

> In 20.9.2.1 [time.traits.is_fp] p1:

> >     template <class Rep> struct treat_as_floating_point
> >       : is_floating_point<Rep> { };

> > > The `duration` template uses the `treat_as_floating_point` trait to help determine if a `duration` object can be converted to another `duration` with a different tick period. If `treat_as_floating_point<Rep>::value` is `true`, then `Rep` is a floating-point type and implicit conversions are allowed among `duration`s. Otherwise, the implicit convertibility depends on the tick periods of the `duration`s. If `Rep` is a class type which emulates a floating-point type, the author of `Rep` can specialize `treat_as_floating_point` so that `duration` will treat this `Rep` as if it were a floating-point type. Otherwise `Rep` is assumed to be an integral type or a class emulating an integral type.

> The phrases "a class type which emulates a floating-point type" and "a class emulating an integral type" are clarifying phrases which refer to the summation of all the requirements on the `Rep` type specified in detail elsewhere (and should not be repeated here).

> This specification has been implemented, now multiple times, and the experience has been favorable. The current specification clearly specifies the requirements at each point of use (though I'd be happy to fix any place I may have missed, but none has been pointed out).

> I am amenable to improved wording of this paragraph (and any others), but do not have any suggestions for improved wording at this time. I am strongly opposed to changes which would significantly alter the semantics of the specification under 20.9 [time] without firmly grounded and documented rationale, example implementation, testing, and user experience which relates a positive experience.

> I recommend NAD unless someone wants to produce some clarifying wording.

[ 2009-10 Santa Cruz: ]

> Stefanus to provide wording to turn this into a note.

Proposed resolution:

### 953. Various threading bugs #3

Section: 20.9.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-23

View other active issues in [time.clock.req].

View all other issues in [time.clock.req].

View all issues with Open status.

Discussion:

Related to 951.

20.9.1 [time.clock.req] says that a clock's `rep` member is "an arithmetic type or a class emulating an arithmetic type." What are the requirements for such a type?

[ 2009-05-10 Howard adds: ]

> This wording was aimed directly at the `ArithmeticLike` concept.

[ Batavia (2009-05): ]

> We recommend this issue be addressed in the context of providing concepts for the entire `thread` header.

> May resolve for now by specifying arithmetic types, and in future change to `ArithmeticLike`. However, Alisdair believes this is not feasible.

> Bill disagrees.

> We look forward to proposed wording. Move to Open.

[ 2009-08-01 Howard adds: ]

> See commented dated 2009-08-01 in 951.

[ 2009-10 Santa Cruz: ]

> Stefanus to provide wording to turn this into a note.

Proposed resolution:

### 954. Various threading bugs #4

Section: 20.9.1 [time.clock.req] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-21

View other active issues in [time.clock.req].

View all other issues in [time.clock.req].

View all issues with Ready status.

Discussion:

Table 55 -- Clock Requirements (in 20.9.1 [time.clock.req])

1. the requirements for `C1::time_point` require `C1` and `C2` to "refer to the same epoch", but "epoch" is not defined.
2. "Different clocks may share a `time_point` definition if it is valid to compare their `time_point`s by comparing their respective `duration`s." What does "valid" mean here? And, since `C1::rep` is "**THE** representation type of the native `duration` and `time_point`" (emphasis added), there doesn't seem to be much room for some other representation.
3. `C1::is_monotonic` has type "`const bool`". The "`const`" should be removed.
4. `C1::period` has type `ratio`. `ratio` isn't a type, it's a template. What is the required type?

[ 2009-05-10 Howard adds: ]

1. "epoch" is purposefully not defined beyond the common English definition. The C standard also chose not to define epoch, though POSIX did. I believe it is a strength of the C standard that epoch is not defined. When it is known that two `time_point`s refer to the same epoch, then a definition of the epoch is not needed to compare the two `time_point`s, or subtract them.

   A `time_point` and a `Clock` implicitly refer to an (unspecified) epoch. The `time_point` represents an offset (`duration`) from an epoch.

2. The sentence:

   > Different clocks may share a `time_point` definition if it is valid to compare their `time_point`s by comparing their respective `duration`s.

   is redundant and could be removed. I believe the sentence which follows the above:

   > `C1` and `C2` shall refer to the same epoch.

   is sufficient. If two clocks share the same epoch, then by definition, comparing their `time_point`s is valid.

3. `is_monotonic` is meant to never change (be `const`). It is also desired that this value be usable in compile-time computation and branching.

4. This should probably instead be worded:

   > An instantiation of `ratio`.

[ Batavia (2009-05): ]

> Re (a): It is not clear to us whether "epoch" is a term of art.

> Re (b), (c), and (d): We agree with Howard's comments, and would consider adding to (c) a `static constexpr` requirement.

> Move to Open pending proposed wording.

[ 2009-05-25 Daniel adds: ]

> In regards to (d) I suggest to say "a specialization of ratio" instead of "An instantiation of ratio". This seems to be the better matching standard core language term for this kind of entity.

[ 2009-05-25 Ganesh adds: ]

> Regarding (a), I found this paper on the ISO website using the term "epoch" consistently with the current wording:

> http://standards.iso.org/ittf/PubliclyAvailableStandards/C030811e_FILES/MAIN_C030811e/text/ISOIEC_18026E_TEMPORAL_CS.HTM

> which is part of ISO/IEC 18026 "Information technology -- Spatial Reference Model (SRM)".

[ 2009-08-01 Howard: Moved to Reivew as the wording requested in Batavia has been provided. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

1. Change 20.9.1 [time.clock.req] p1:

   > -1- A clock is a bundle consisting of a native `duration`, a native `time_point`, and a function `now()` to get the current `time_point`. The origin of the clock's `time_point` is referred to as the clock's epoch as defined in section 6.3 of ISO/IEC 18026. A clock shall meet the requirements in Table 45.

2. Remove the sentence from the `time_point` row of the table "Clock Requirements":

   Clock requirements
   `C1::time_point` | `chrono::time_point<C1>` or `chrono::time_point<C2, C1::duration>` | The native `time_point` type of the clock. Different clocks may share a `time_point` definition if it is valid to compare their `time_point`s by comparing their respective `duration`s. `C1` and `C2` shall refer to the same epoch.

4. Change the row starting with `C1::period` of the table "Clock Requirements":

   Clock requirements
   `C1::period` | a specialization of `ratio` | The tick period of the clock in seconds.

### 956. Various threading bugs #6

Section: 20.9.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-24

View other active issues in [time.clock.req].

View all other issues in [time.clock.req].

View all issues with Open status.

Discussion:

20.9.1 [time.clock.req] uses the word "native" in several places, but doesn't define it. What is a "native `duration`"?

[ 2009-05-10 Howard adds: ]

> The standard uses "native" in several places without defining it (e.g. 2.14.3 [lex.ccon]). It is meant to mean "that which is defined by the facility", or something along those lines. In this case it refers to the nested `time_point` and `duration` types of the clock. Better wording is welcome.

[ Batavia (2009-05): ]

> Move to Open pending proposed wording from Pete.

[ 2009-10-23 Pete provides wording: ]

Proposed resolution:

Remove every occurrence of "native" in 20.9.1 [time.clock.req].

Add the following sentence at the end of 20.9.1 [time.clock.req]/1:

> A clock is a bundle consisting of a native `duration`, a native `time_point`, and a function `now()` to get the current `time_point`. A clock shall meet the requirements in Table 55. The `duration` and `time_point` types have the natural size and resolution suggested by the architecture of the execution environment.

### 957. Various threading bugs #7

Section: 20.9.5.1 [time.clock.system] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-21

View all other issues in [time.clock.system].

View all issues with Ready status.

Discussion:

20.9.5.1 [time.clock.system]: `to_time_t` is overspecified. It requires truncation, but should allow rounding. For example, suppose a system has a clock that gives times in milliseconds, but `time()` rounds those times to the nearest second. Then `system_clock` can't use any resolution finer than one second, because if it did, truncating times between half a second and a full second would produce the wrong `time_t` value.

[ Post Summit Anthony Williams provided proposed wording. ]

[ Batavia (2009-05): ]

> Move to Review pending input from Howard. and other stakeholders.

[ 2009-05-23 Howard adds: ]

> I am in favor of the wording provided by Anthony.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

In 20.9.5.1 [time.clock.system] replace paragraphs 3 and 4 with:

>     time_t to_time_t(const time_point& t);

> > -3- Returns: A `time_t` object that represents the same point in time as `t` when both values are truncated restricted to the coarser of the precisions of `time_t` and `time_point`. It is implementation defined whether values are rounded or truncated to the required precision.

>     time_point from_time_t(time_t t);

> > -4- Returns: A `time_point` object that represents the same point in time as `t` when both values are truncated restricted to the coarser of the precisions of `time_t` and `time_point`. It is implementation defined whether values are rounded or truncated to the required precision.

### 959. Various threading bugs #9

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

View other active issues in [thread.condition.condvar].

View all other issues in [thread.condition.condvar].

View all issues with Open status.

Discussion:

30.5.1 [thread.condition.condvar]: `condition_variable::wait_for` is required to compute the absolute time by adding the duration value to `chrono::monotonic_clock::now()`, but `monotonic_clock` is not required to exist.

[ Summit: ]

> Move to open. Associate with LWG 859 and any other monotonic-clock related issues.

[ 2009-08-01 Howard adds: ]

> I believe that 859 (currently Ready) addresses this issue, and that this issue should be marked NAD, solved by 859 (assuming it moves to WP).

[ 2009-10 Santa Cruz: ]

> Leave open, but expect to be fixed by N2969 revision that Detlef is writing.

Proposed resolution:

### 960. Various threading bugs #10

Section: 30.4.1 [thread.mutex.requirements] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Ready status.

Discussion:

30.4.1 [thread.mutex.requirements]: paragraph 4 is entitled "Error conditions", but according to 17.5.1.4 [structure.specifications], "Error conditions:" specifies "the error conditions for error codes reported by the function." It's not clear what this should mean when there is no function in sight.

[ Summit: ]

> Move to open.

[ Beman provided proposed wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready. Fix the proposed wording with "functions of type Mutex" -> "functions of Mutex type"

Proposed resolution:

Change 30.4.1 [thread.mutex.requirements] Mutex requirements, paragraph 4 as indicated:

> -4- Error conditions: The error conditions for error codes, if any, reported by member functions of Mutex type shall be:

> - `not_enough_memory` -- if there is not enough memory to construct the mutex object.
> - `resource_unavailable_try_again` -- if any native handle type manipulated is not available.
> - `operation_not_permitted` -- if the thread does not have the necessary permission to change the state of the mutex object.
> - `device_or_resource_busy` -- if any native handle type manipulated is already locked.
> - `invalid_argument` -- if any native handle type manipulated as part of mutex construction is incorrect.

### 962. Various threading bugs #12

Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22

View other active issues in [thread.lock.unique.locking].

View all other issues in [thread.lock.unique.locking].

View all issues with Ready status.

Discussion:

30.4.3.2.2 [thread.lock.unique.locking]: `unique_lock::lock` is required to throw an object of type `std::system_error` "when the postcondition cannot be achieved." The postcondition is `owns == true`, and this is trivial to achieve. Presumably, the requirement is intended to mean something more than that.

[ Summit: ]

> Move to open.

[ Beman has volunteered to provide proposed wording. ]

[ 2009-07-21 Beman added wording to address 30.2.2 [thread.req.exception] in response to the Frankfurt notes in 859. ]

[ 2009-09-25 Beman: minor update to wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change Exceptions 30.2.2 [thread.req.exception] as indicated:

> Some functions described in this Clause are specified to throw exceptions of type `system_error` (19.5.5). Such exceptions shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API results in an error that prevents the library function from satisfying its postconditions or from returning a meaningful value meeting its specifications. Failure to allocate storage shall be reported as described in 17.6.4.11 [res.on.exception.handling].

Change thread assignment 30.3.1.5 [thread.thread.member], join(), paragraph 8 as indicated:

> Throws: `std::system_error` when the postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change thread assignment 30.3.1.5 [thread.thread.member], detach(), paragraph 13 as indicated:

> Throws: `std::system_error` when the effects or postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 11, as indicated:

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 3, as indicated:

> Throws: `std::system_error` when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 8, as indicated:

> Throws: `std::system_error` when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 13, as indicated:

> Throws: `std::system_error` when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 18, as indicated:

> Throws: `std::system_error` when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], paragraph 22, as indicated:

> Throws: `std::system_error` when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change Function call_once 30.4.5.2 [thread.once.callonce], paragraph 4, as indicated

> Throws: `std::system_error` when the effects cannot be achieved an exception is required (30.2.2 [thread.req.exception]), or any exception thrown by `func`.

Change Class condition_variable 30.5.1 [thread.condition.condvar], paragraph 12, as indicated:

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change Class condition_variable 30.5.1 [thread.condition.condvar], paragraph 19, as indicated:

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], paragraph 10, as indicated:

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], paragraph 16, as indicated:

> Throws: `std::system_error` when the returned value, effects, or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as indicated:

>     template <class Rep, class Period>
>     bool wait_for(unique_lock<mutex>& lock,
>                   const chrono::duration<Rep, Period>& rel_time);

>     ...

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required ([thread.req.exception]).

Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as indicated:

>     template <class Rep, class Period, class Predicate>
>       bool wait_for(unique_lock<mutex>& lock,
>                     const chrono::duration<Rep, Period>& rel_time,
>                     Predicate pred);

>     ...

> Throws: `std::system_error` when the effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change 30.5.2 [thread.condition.condvarany] as indicated:

>     template <class Lock, class Rep, class Period>
>       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);

>     ...

> Throws: `std::system_error` when the returned value, effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been applied to the working paper, change 30.5.2 [thread.condition.condvarany] as indicated:

>     template <class Lock, class Rep, class Period, class Predicate>
>       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);

>     ...

> Throws: `std::system_error` when the returned value, effects or postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

### 963. Various threading bugs #13

Section: 30.3.1.5 [thread.thread.member] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

View other active issues in [thread.thread.member].

View all other issues in [thread.thread.member].

View all issues with Ready status.

Discussion:

30.3.1.5 [thread.thread.member]: `thread::detach` is required to throw an exception if the thread is "not a detachable thread". "Detachable" is never defined.

[ Howard adds: ]

> Due to a mistake on my part, 3 proposed resolutions appeared at approximately the same time. They are all three noted below in the discussion.

[ Summit, proposed resolution: ]

> In 30.3.1.5 [thread.thread.member] change:

> >     void detach();

> > > ...

> > > -14- Error conditions:

> > > - `no_such_process` -- if the thread is not a valid thread.
> > > - `invalid_argument` -- if the thread is not a detachable joinable thread.

[ Post Summit, Jonathan Wakely adds: ]

> A `thread` is detachable if it is joinable. As we've defined joinable, we can just use that.

> This corresponds to the pthreads specification, where pthread_detach fails if the thread is not joinable:

> > EINVAL: The implementation has detected that the value specified by thread does not refer to a joinable thread.

> Jonathan recommends this proposed wording:

> > In 30.3.1.5 [thread.thread.member] change:

> > >     void detach();

> > > > ...

> > > > -14- Error conditions:

> > > > - ...
> > > > - `invalid_argument` -- not a detachable joinable thread.

[ Post Summit, Anthony Williams adds: ]

> This is covered by the precondition that `joinable()` be `true`.

> Anthony recommends this proposed wording:

> > In 30.3.1.5 [thread.thread.member] change:

> > >     void detach();

> > > > ...

> > > > -14- Error conditions:

> > > > - ...
> > > > - `invalid_argument` -- not a detachable thread.

[ 2009-10 Santa Cruz: ]

> Mark as Ready with proposed resolution from Summit.

Proposed resolution:

In 30.3.1.5 [thread.thread.member] change:

>     void detach();

> > ...

> > -14- Error conditions:

> > - `no_such_process` -- if the thread is not a valid thread.
> > - `invalid_argument` -- if the thread is not a detachable joinable thread.

### 964. Various threading bugs #14

Section: 30.5.2 [thread.condition.condvarany] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

View other active issues in [thread.condition.condvarany].

View all other issues in [thread.condition.condvarany].

View all issues with Open status.

Discussion:

The requirements for the constructor for `condition_variable` has several error conditions, but the requirements for the constructor for `condition_variable_any` has none. Is this difference intentional?

[ Summit: ]

> Move to open, pass to Howard. If this is intentional, a note may be helpful. If the error conditions are to be copied from `condition_variable`, this depends on LWG 965.

[ Post Summit Howard adds: ]

> The original intention (N2447) was to let the OS return whatever errors it was going to return, and for those to be translated into exceptions, for both `condition_variable` and `condition_variable_any`. I have not received any complaints about specific error conditions from vendors on non-POSIX platforms, but such complaints would not surprise me if they surfaced.

[ 2009-10 Santa Cruz: ]

> Leave open. Benjamin to provide wording.

Proposed resolution:

### 966. Various threading bugs #16

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

View other active issues in [thread.condition.condvar].

View all other issues in [thread.condition.condvar].

View all issues with Open status.

Discussion:

30.5.1 [thread.condition.condvar]: `condition_variable::wait` and `condition_variable::wait_until` both have a postcondition that `lock` is locked by the calling thread, and a throws clause that requires throwing an exception if this postcondition cannot be achieved. How can the implementation detect that this `lock` can never be obtained?

[ Summit: ]

> Move to open. Requires wording. Agreed this is an issue, and the specification should not require detecting deadlocks.

[ 2009-08-01 Howard provides wording. ]

> The proposed wording is inspired by the POSIX spec which says:

> > [EINVAL]
> >   The value specified by cond or mutex is invalid.
> > [EPERM]
> >   The mutex was not owned by the current thread at the time of the call.

> I do not believe [EINVAL] is possible without memory corruption (which we don't specify). [EPERM] is possible if this thread doesn't own the mutex, which is listed as a precondition. "May" is used instead of "Shall" because not all OS's are POSIX.

[ 2009-10 Santa Cruz: ]

> Leave open, Detlef to provide improved wording.

[ 2009-10-23 Detlef Provided wording. ]

> Detlef's wording put in Proposed resolution. Original wording here:

> > Change 30.5.1 [thread.condition.condvar] p12, p19 and 30.5.2 [thread.condition.condvarany] p10, p16:

> > > Throws: May throw `std::system_error` if a precondition is not met. when the effects or postcondition cannot be achieved.

[ 2009-10 Santa Cruz: ]

> Leave open, Detlef to provide improved wording.

Proposed resolution:

Replace 30.5.1 [thread.condition.condvar] p12, p19 and 30.5.2 [thread.condition.condvarany] p10, p16:

> Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> Error conditions:

> - equivalent error condition from `lock.lock()` or `lock.unlock()`.

> Throws: It's implementation-defined whether a `std::system_error` with implementation-defined error condition is thrown if the precondition is not met.

### 967. Various threading bugs #17

Section: 30.3.1.2 [thread.thread.constr] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22

View other active issues in [thread.thread.constr].

View all other issues in [thread.thread.constr].

View all issues with Ready status.

Discussion:

the error handling for the constructor for `condition_variable` distinguishes lack of memory from lack of other resources, but the error handling for the thread constructor does not. Is this difference intentional?

[ Beman has volunteered to provide proposed wording. ]

[ 2009-09-25 Beman provided proposed wording. ]

> The proposed resolution assumes 962 has been accepted and its proposed resolution applied to the working paper.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 4, as indicated:

> Error conditions:

> > - `not_enough_memory` — if there is not enough memory to construct the mutex object.
> > - `resource_unavailable_try_again` — if any native handle type manipulated is not available.
> > - `operation_not_permitted` — if the thread does not have the necessary permission to change the state of the mutex object.
> > - `device_or_resource_busy` — if any native handle type manipulated is already locked.
> > - `invalid_argument` — if any native handle type manipulated as part of mutex construction is incorrect.

Change Class condition_variable 30.5.1 [thread.condition.condvar], default constructor, as indicated:

> `condition_variable();`

> > Effects: Constructs an object of type `condition_variable`.

> > Throws: `std::system_error` when an exception is required (30.2.2 [thread.req.exception]).

> > Error conditions:

> > > - `not_enough_memory` — if a memory limitation prevents initialization.
> > > - `resource_unavailable_try_again` — if some non-memory resource limitation prevents initialization.
> > > - `device_or_resource_busy` — if attempting to initialize a previously-initialized but as of yet undestroyed `condition_variable`.

### 968. Various threading bugs #18

Section: 30.4.1 [thread.mutex.requirements] Status: Ready Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Ready status.

Discussion:

30.4.1 [thread.mutex.requirements]: several functions are required to throw exceptions "if the thread does not have the necessary permission ...". "The necessary permission" is not defined.

[ Summit: ]

> Move to open.

[ Beman has volunteered to provide proposed wording. ]

[ 2009-10 Santa Cruz: ]

> Moved to Ready with minor word-smithing in the example.

Proposed resolution:

Change Exceptions 30.2.2 [thread.req.exception] as indicated:

> Some functions described in this Clause are specified to throw exceptions of type `system_error` (19.5.5). Such exceptions shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API results in an error that prevents the library function from meeting its specifications. [Note: See 17.6.4.11 [res.on.exception.handling] for exceptions thrown to report storage allocation failures. —end note]

> [Example:

> > Consider a function in this clause that is specified to throw exceptions of type `system_error` and specifies Error conditions that include `operation_not_permitted` for a thread that does not have the privilege to perform the operation. Assume that, during the execution of this function, an `errno` of `EPERM` is reported by a POSIX API call used by the implementation. Since POSIX specifies an `errno` of `EPERM` when "the caller does not have the privilege to perform the operation", the implementation maps `EPERM` to an `error_condition` of `operation_not_permitted` (19.5 [syserr]) and an exception of type `system_error` is thrown.

> —end example]

> Editorial note: For the sake of exposition, the existing text above is shown with the changes proposed in issues 962 and 967. The proposed additional example is independent of whether or not the 962 and 967 proposed resolutions are accepted.

Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 4, as indicated:

> — `operation_not_permitted` — if the thread does not have the necessary permission to change the state of the mutex object privilege to perform the operation.

Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 12, as indicated:

> — `operation_not_permitted` — if the thread does not have the necessary permission to change the state of the mutex privilege to perform the operation.

### 974. `duration<double>` should not implicitly convert to `duration<int>`

Section: 20.9.3.1 [time.duration.cons] Status: Ready Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-10-26

View all issues with Ready status.

Discussion:

The following code should not compile because it involves implicit truncation errors (against the design philosophy of the `duration` library).

>     duration<double> d(3.5);
>     duration<int> i = d;  // implicit truncation, should not compile

This intent was codified in the example implementation which drove this proposal but I failed to accurately translate the code into the specification in this regard.

[ Batavia (2009-05): ]

> We agree with the proposed resolution.

> Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be improved for enable_if type constraining, possibly following Robert's formula.

[ 2009-08-01 Howard adds: ]

> Addressed by 1177.

[ 2009-10 Santa Cruz: ]

> Not completely addressed by 1177. Move to Ready.

Proposed resolution:

Change 20.9.3.1 [time.duration.cons], p4:

>     template <class Rep2, class Period2>
>       duration(const duration<Rep2, Period2>& d);

> > -4- Requires: `treat_as_floating_point<rep>::value` shall be `true` or both `ratio_divide<Period2, period>::type::den` shall be 1 and `treat_as_floating_point<Rep2>::value` shall be `false`. Diagnostic required. [Note: This requirement prevents implicit truncation error when converting between integral-based `duration` types. Such a construction could easily lead to confusion about the value of the `duration`. -- end note]

### 978. Hashing smart pointers

Section: 20.7.16 [unord.hash] Status: Ready Submitter: Alisdair Meredith Opened: 2009-02-02 Last modified: 2009-10-27

View other active issues in [unord.hash].

View all other issues in [unord.hash].

View all issues with Ready status.

Discussion:

Addresses UK 208

I don't see an open issue on supporting `std::hash` for smart pointers (`unique_ptr` and `shared_ptr` at least).

It seems reasonable to at least expect support for the smart pointers, especially as they support comparison for use in ordered associative containers.

[ Batavia (2009-05): ]

> Howard points out that the client can always supply a custom hash function.

> Alisdair replies that the smart pointer classes are highly likely to be frequently used as hash keys.

> Bill would prefer to be conservative.

> Alisdair mentions that this issue may also be viewed as a subissue or duplicate of issue 1025.

> Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.

[ 2009-05-31 Peter adds: ]

> > Howard points out that the client can always supply a custom hash function.

> Not entirely true. The client cannot supply the function that hashes the address of the control block (the equivalent of the old `operator<`, now proudly carrying the awkward name of '`owner_before`'). Only the implementation can do that, not necessarily via specializing `hash<>`, of course.

> This hash function makes sense in certain situations for `shared_ptr` (when one needs to switch from `set/map` using ownership ordering to `unordered_set/map`) and is the only hash function that makes sense for `weak_ptr`.

[ 2009-07-28 Alisdair provides wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add the following declarations to the synopsis of `<memory>` in 20.8 [memory]

>     // 20.8.10.X hash support
>     template <class T> struct hash;
>     template <class T, class D> struct hash<unique_ptr<T,D>>;
>     template <class T> struct hash<shared_ptr<T>>;

Add a new subclause 20.8.10.X hash support

> 20.8.10.X hash support [util.smartptr.hash]

>     template <class T, class D> struct hash<unique_ptr<T,D>>;

> > A partial specialization of the class template `hash` (20.7.16 [unord.hash]) shall be provided for instances of the `unique_ptr` template suitable for use as a key in unordered associative containers (23.5 [unord]) if and only if there is a `hash` specialization available for the type `D::pointer`. For an object `p` of type `unqiue_ptr<T,D>` the `hash` shall evaluate to the same value as `hash<typename D::pointer>{}(p.get())`.

>     template <class T> struct hash<shared_ptr<T>>;

> > A partial specialization of the class template `hash` (20.7.16 [unord.hash]) shall be provided for instances of the `shared_ptr` template suitable for use as a key in unordered associative containers (23.5 [unord]). For an object `p` of type `shared_ptr<T>` the `hash` shall evaluate to the same value as `hash<T*>{}(p.get())`.

### 983. `unique_ptr` reference deleters should not be moved from

Section: 20.8.14.2 [unique.ptr.single] Status: Ready Submitter: Howard Hinnant Opened: 2009-02-10 Last modified: 2009-10-21

View other active issues in [unique.ptr.single].

View all other issues in [unique.ptr.single].

View all issues with Ready status.

Discussion:

Dave brought to my attention that when a `unique_ptr` has a non-const reference type deleter, move constructing from it, even when the `unique_ptr` containing the reference is an rvalue, could have surprising results:

>     D d(some-state);
>     unique_ptr<A, D&> p(new A, d);
>     unique_ptr<A, D> p2 = std::move(p);
>     // has d's state changed here?

I agree with him. It is the `unique_ptr` that is the rvalue, not the deleter. When the deleter is a reference type, the `unique_ptr` should respect the "lvalueness" of the deleter.

Thanks Dave.

[ Batavia (2009-05): ]

> Seems correct, but complicated enough that we recommend moving to Review.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change 20.8.14.2.1 [unique.ptr.single.ctor], p20-21

>     template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);

> > -20- Requires: If `D E` is not a reference type, construction of the deleter `D` from an rvalue of type `E` shall be well formed and shall not throw an exception. Otherwise `E` is a reference type and construction of the deleter `D` from an lvalue of type `E` shall be well formed and shall not throw an exception. If `D` is a reference type, then `E` shall be the same type as `D` (diagnostic required). `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`. [`Note:` These requirements imply that `T` and `U` are complete types. -- end note]

> > -21- Effects: Constructs a `unique_ptr` which owns the pointer which `u` owns (if any). If the deleter `E` is not a reference type, it this deleter is move constructed from `u`'s deleter, otherwise the reference this deleter is copy constructed from `u`.'s deleter. After the construction, `u` no longer owns a pointer. [Note: The deleter constructor can be implemented with `std::forward<DE>`. -- end note]

Change 20.8.14.2.3 [unique.ptr.single.asgn], p1-3

>     unique_ptr& operator=(unique_ptr&& u);

> > -1- Requires: If the deleter `D` is not a reference type, A assignment of the deleter `D` from an rvalue `D` shall not throw an exception. Otherwise the deleter `D` is a reference type, and assignment of the deleter `D` from an lvalue `D` shall not throw an exception.

> > -2- Effects: reset(u.release()) followed by an move assignment from `u`'s deleter to this deleter `std::forward<D>(u.get_deleter())`.

> > -3- Postconditions: This `unique_ptr` now owns the pointer which `u` owned, and `u` no longer owns it. [Note: If `D` is a reference type, then the referenced lvalue deleters are move assigned. -- end note]

Change 20.8.14.2.3 [unique.ptr.single.asgn], p6-7

>     template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);

> > Requires: If the deleter `E` is not a reference type, A assignment of the deleter `D` from an rvalue `DE` shall not throw an exception. Otherwise the deleter `E` is a reference type, and assignment of the deleter `D` from an lvalue `E` shall not throw an exception. `unique_ptr<U, E>::pointer` shall be implicitly convertible to `pointer`. [Note: These requirements imply that `T` and `U>` are complete types. -- end note]

> > Effects: `reset(u.release())` followed by an move assignment from `u`'s deleter to this deleter `std::forward<E>(u.get_deleter())`. If either `D` or `E` is a reference type, then the referenced lvalue deleter participates in the move assignment.

### 985. Allowing throwing move

Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Rani Sharoni Opened: 2009-02-12 Last modified: 2009-10-20

View other active issues in [container.requirements.general].

View all other issues in [container.requirements.general].

View all issues with Open status.

Discussion:

Introduction

This proposal is meant to resolve potential regression of the N2800 draft, see next section, and to relax the requirements for containers of types with throwing move constructors.

The basic problem is that some containers operations, like `push_back`, have a strong exception safety guarantee (i.e. no side effects upon exception) that are not achievable when throwing move constructors are used since there is no way to guarantee revert after partial move. For such operations the implementation can at most provide the basic guarantee (i.e. valid but unpredictable) as it does with multi copying operations (e.g. range insert).

For example, `vector<T>::push_back()` (where `T` has a move constructor) might resize the `vector` and move the objects to the new underlying buffer. If move constructor throws it might not be possible to recover the throwing object or to move the old objects back to the original buffer.

The current draft is explicit by disallowing throwing move for some operations (e.g. `vector<>::reserve`) and not clear about other operations mentioned in 23.2.1 [container.requirements.general]/10 (e.g. single element `insert`): it guarantees strong exception safety without explicitly disallowing a throwing move constructor.

Regression

This section only refers to cases in which the contained object is by itself a standard container.

Move constructors of standard containers are allowed to throw and therefore existing operations are broken, compared with C++03, due to move optimization. (In fact existing implementations like Dinkumware are actually throwing).

For example, `vector< list<int> >::reserve` yields undefined behavior since `list<int>`'s move constructor is allowed to throw. On the other hand, the same operation has strong exception safety guarantee in C++03.

There are few options to solve this regression:

1. Disallow throwing move and throwing default constructor
2. Disallow throwing move but disallowing usage after move
3. Special casing
4. Disallow throwing move and making it optional

Option 1 is suggested by proposal N2815 but it might not be applicable for existing implementations for which containers default constructors are throwing.

Option 2 limits the usage significantly and it's error prone by allowing zombie objects that are nothing but destructible (e.g. no `clear()` is allowed after move). It also potentially complicates the implementation by introducing special state.

Option 3 is possible, for example, using default construction and `swap` instead of move for standard containers case. The implementation is also free to provide special hidden operation for non throwing move without forcing the user the cope with the limitation of option-2 when using the public move.

Option 4 impact the efficiency in all use cases due to rare throwing move.

The proposed wording will imply option 1 or 3 though option 2 is also achievable using more wording. I personally oppose to option 2 that has impact on usability.

Relaxation for user types

Disallowing throwing move constructors in general seems very restrictive since, for example, common implementation of move will be default construction + `swap` so move will throw if the default constructor will throw. This is currently the case with the Dinkumware implementation of node based containers (e.g. `std::list`) though this section doesn't refer to standard types.

For throwing move constructors it seem that the implementation should have no problems to provide the basic guarantee instead of the strong one. It's better to allow throwing move constructors with basic guarantee than to disallow it silently (compile and run), via undefined behavior.

There might still be cases in which the relaxation will break existing generic code that assumes the strong guarantee but it's broken either way given a throwing move constructor since this is not a preserving optimization.

[ Batavia (2009-05): ]

> Bjarne comments (referring to his draft paper): "I believe that my suggestion simply solves that. Thus, we don't need a throwing move."

> Move to Open and recommend it be deferred until after the next Committee Draft is issued.

[ 2009-10 Santa Cruz: ]

> Should wait to get direction from Dave/Rani (N2983).

Proposed resolution:

23.2.1 [container.requirements.general] paragraph 10 add footnote:

> -10- Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and 23.2.6.4) all container types defined in this Clause meet the following additional requirements:

> - ...

> [Note: for compatibility with C++ 2003, when "no effect" is required, standard containers should not use the value_type's throwing move constructor when the contained object is by itself a standard container. -- end note]

23.2.5.1 [unord.req.except] change paragraph 2 to say:

> -2- For unordered associative containers, if an exception is thrown by any operation other than the container's hash function from within an `insert()` function inserting a single element, the `insert()` function has no effect unless the exception is thrown by the contained object move constructor.

> -4- For unordered associative containers, if an exception is thrown from within a `rehash()` function other than by the container's hash function or comparison function, the `rehash()` function has no effect unless the exception is thrown by the contained object move constructor.

23.3.2.3 [deque.modifiers] change paragraph 2 to say:

> -2- Remarks: If an exception is thrown other than by the copy constructor, move constructor or assignment operator of `T` there are no effects. If an exception is thrown by `push_back()` or `emplace_back()` function, that function has no effects unless the exception is thrown by the move constructor of `T`.

23.3.2.3 [deque.modifiers] change paragraph 6 to say:

> -6- Throws: Nothing unless an exception is thrown by the copy constructor, move constructor or assignment operator of `T`.

23.3.6.2 [vector.capacity] remove paragraph 2

> -2- Requires: If `value_type` has a move constructor, that constructor shall not throw any exceptions.

23.3.6.2 [vector.capacity] paragraph 3 change to say:

> -3- Effects: A directive that informs a `vector` of a planned change in size, so that it can manage the storage allocation accordingly. After `reserve()`, `capacity()` is greater or equal to the argument of `reserve` if reallocation happens; and equal to the previous value of `capacity()` otherwise. Reallocation happens at this point if and only if the current capacity is less than the argument of `reserve()`. If an exception is thrown, there are no effects unless the exception is thrown by the contained object move constructor.

23.3.6.2 [vector.capacity] paragraph 12 change to say:

> -12- Requires: If `value_type` has a move constructor, that constructor shall not throw any exceptions. If an exception is thrown, there are no effects unless the exception is thrown by the contained object move constructor.

23.3.6.4 [vector.modifiers] change paragraph 1 to say:

> -1- Requires: If `value_type` has a move constructor, that constructor shall not throw any exceptions. Remarks: If an exception is thrown by `push_back()` or `emplace_back()` function, that function has no effect unless the exception is thrown by the move constructor of `T`.

23.3.6.4 [vector.modifiers] change paragraph 2 to say:

> -2- Remarks: Causes reallocation if the new size is greater than the old capacity. If no reallocation happens, all the iterators and references before the insertion point remain valid. If an exception is thrown other than by the copy constructor, move constructor or assignment operator of `T` or by any `InputIterator` operation there are no effects.

23.3.6.4 [vector.modifiers] change paragraph 6 to say:

> -6- Throws: Nothing unless an exception is thrown by the copy constructor, move constructor or assignment operator of `T`.

### 987. `reference_wrapper` and function types

Section: 20.7.5 [refwrap] Status: Tentatively Ready Submitter: Howard Hinnant Opened: 2009-02-18 Last modified: 2009-10-26

View all other issues in [refwrap].

View all issues with Tentatively Ready status.

Discussion:

The synopsis in 20.7.5 [refwrap] says:

>     template <ObjectType T> class reference_wrapper
>     ...

And then paragraph 3 says:

> The template instantiation `reference_wrapper<T>` shall be derived from `std::unary_function<T1, R>` only if the type `T` is any of the following:

> - a function type or a pointer to function type taking one argument of type `T1` and returning `R`

But function types are not `ObjectType`s.

Paragraph 4 contains the same contradiction.

[ Post Summit: ]

> Jens: restricted reference to ObjectType

> Recommend Review.

[ Post Summit, Peter adds: ]

> In https://svn.boost.org/trac/boost/ticket/1846 however Eric Niebler makes the very reasonable point that `reference_wrapper<F>`, where `F` is a function type, represents a reference to a function, a legitimate entity. So `boost::ref` was changed to allow it.

> https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp

> Therefore, I believe an alternative proposed resolution for issue 987 could simply allow `reference_wrapper` to be used with function types.

[ Post Summit, Howard adds: ]

> I agree with Peter (and Eric). I got this one wrong on my first try. Here is code that demonstrates how easy (and useful) it is to instantiate `reference_wrapper` with a function type:

> >     #include <functional>

> >     template <class F>
> >     void test(F f);

> >     void f() {}

> >     int main()
> >     {
> >         test(std::ref(f));
> >     }

> Output (link time error shows type of `reference_wrapper` instantiated with function type):

> >     Undefined symbols:
> >       "void test<std::reference_wrapper<void ()()> >(std::reference_wrapper<void ()()>)",...

> I've taken the liberty of changing the proposed wording to allow function types and set to Open. I'll also freely admit that I'm not positive `ReferentType` is the correct concept.

[ Batavia (2009-05): ]

> Howard observed that `FunctionType`, a concept not (yet?) in the Working Paper, is likely the correct constraint to be applied. However, the proposed resolution provides an adequate approximation.

> Move to Review.

[ 2009-05-23 Alisdair adds: ]

> By constraining to `PointeeType` we rule out the ability for `T` to be a reference, and call in reference-collapsing. I'm not sure if this is correct and intended, but would like to be sure the case was considered.

> Is dis-allowing reference types and the implied reference collapsing the intended result?

[ 2009-07 Frankfurt ]

> Moved from Review to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-10-14 Daniel provided de-conceptified wording. ]

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready.

Proposed resolution:

Change 20.7.5 [refwrap]/1 as indicated:

> `reference_wrapper<T>` is a `CopyConstructible` and `CopyAssignable` wrapper around a reference to an object or function of type `T`.

Rationale:

a) The occurrence of `T&` in the function signature auto-implies `std::ReferentType`, this is due to [temp.req.impl]/4 bullet 4

b) The occurrence of the constrained template `reference_wrapper<T>` in the remaining signatures lets kick in [temp.req.impl]/4 bullet 1 and adds *all* requirements of this template. But we need to add at least *one* requirement (and it was an arbitrary, but natural decision to require `std::PointeeType` here) to *activate* this. If we hadn't done this, we were in unconstrained mode!

### 996. Move operation not well specified

Section: 17 [library] Status: Open Submitter: David Abrahams Opened: 2009-03-06 Last modified: 2009-05-23

View other active issues in [library].

View all other issues in [library].

View all issues with Open status.

Discussion:

There are lots of places in the standard where we talk about "the move constructor" but where we mean "the move operation," i.e. `T( move( x ) )`.

We also don't account for whether that operation modifies `x` or not, and we need to.

[ Batavia (2009-05): ]

> Move to Open, pending proposed wording from Dave for further review.

Proposed resolution:

### 999. Taking the address of a function

Section: 20.8.13 [specialized.algorithms] Status: Tentatively Ready Submitter: Peter Dimov Opened: 2009-03-09 Last modified: 2009-10-26

View all other issues in [specialized.algorithms].

View all issues with Tentatively Ready status.

Discussion:

The same fix (reference 987) may be applied to `addressof`, which is also constrained to `ObjectType`. (That was why `boost::ref` didn't work with functions - it tried to apply `boost::addressof` and the `reinterpret_cast<char&>` implementation of `addressof` failed.)

[ Batavia (2009-05): ]

> We agree.

> Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-10-10 Daniel updates wording to concept-free. ]

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready.

Proposed resolution:

[ The resolution assumes that `addressof` is reintroduced as described in n2946 ]

In 20.8.13 [specialized.algorithms] change as described:

>     template <class T> T* addressof(T& r);

> > Returns: The actual address of the object or function referenced by `r`, even in the presence of an overloaded `operator&`.

Rationale:

a) The occurrence of `T&` in the function signature auto-implies `std::ReferentType`, this is due to [temp.req.impl]/4 bullet 4

### 1008. `nested_exception` wording unclear

Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-10-22

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with Open status.

Discussion:

Addresses JP 31

It is difficult to understand in which case `nested_exception` is applied.

[ Summit: ]

> Alisdair will add an example in an update to N2619.

[ 2009-10 Santa Cruz: ]

> It doesn't appear that N2619 really addresses this. Alisdair to propose wording.

Proposed resolution:

### 1011. `next/prev` wrong iterator type

Section: 24.4.4 [iterator.operations] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-10-22

View other active issues in [iterator.operations].

View all other issues in [iterator.operations].

View all issues with Ready status.

Discussion:

Addresses UK 271

`next/prev` return an incremented iterator without changing the value of the original iterator. However, even this may invalidate an `InputIterator`. A `ForwardIterator` is required to guarantee the 'multipass' property.

[ Batavia (2009-05): ]

> We agree with the proposed resolution. Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-10-14 Daniel provided de-conceptified wording. ]

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

1. Change header `<iterator>` synopsis 24.3 [iterator.synopsis] as indicated:

   >     // 24.4.4, iterator operations:
   >     ...
   >     template <class InputForwardIterator>
   >       InputForwardIterator
   >       next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);

2. Change 24.4.4 [iterator.operations] before p.6 as indicated:

   >     template <class InputForwardIterator>
   >       InputForwardIterator
   >       next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);

### 1030. Response to JP 44

Section: 20.8.15.5 [util.smartptr.shared.atomic] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-10-23

View all issues with Ready status.

Discussion:

Addresses JP 44

The 1st parameter `p` and 2nd parameter `v` is now `shared_ptr<T>*`.

It should be `shared_ptr<T>&`, or if these are `shared_ptr<T>*` then add the "`p` shall not be a null pointer" at the requires.

[ Summit: ]

> Agree. All of the functions need a requirement that `p` (or `v`) is a pointer to a valid object.

[ 2009-07 post-Frankfurt: ]

> Lawrence explained that these signatures match the regular atomics. The regular atomics must not use references because these signatures are shared with C. The decision to pass shared_ptrs by pointer rather than by reference was deliberate and was motivated by the principle of least surprise.

> Lawrence to write wording that requires that the pointers not be null.

[ 2009-09-20 Lawrence provided wording: ]

> The parameter types for atomic shared pointer access were deliberately chosen to be pointers to match the corresponding parameters of the atomics chapter. Those in turn were deliberately chosen to match C functions, which do not have reference parameters.

> We adopt the second suggestion, to require that such pointers not be null.

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

In section "`shared_ptr` atomic access" 20.8.15.5 [util.smartptr.shared.atomic], add to each function the following clause.

> Requires: `p` shall not be null.

### 1033. `thread::join()` effects?

Section: 30.3.1.5 [thread.thread.member] Status: Open Submitter: Alberto Ganesh Barbati Opened: 2009-03-12 Last modified: 2009-05-23

View other active issues in [thread.thread.member].

View all other issues in [thread.thread.member].

View all issues with Open status.

Discussion:

While looking at `thread::join()` I think I spotted a couple of possible defects in the specifications. I could not find a previous issue or NB comment about that, but I might have missed it.

The postconditions clause for `thread::join()` is:

> Postconditions: If `join()` throws an exception, the value returned by `get_id()` is unchanged. Otherwise, `get_id() == id()`.

and the throws clause is:

> Throws: `std::system_error` when the postconditions cannot be achieved.

Now... how could the postconditions not be achieved? It's just a matter of resetting the value of `get_id()` or leave it unchanged! I bet we can always do that. Moreover, it's a chicken-and-egg problem: in order to decide whether to throw or not I depend on the postconditions, but the postconditions are different in the two cases.

I believe the throws clause should be:

> Throws: `std::system_error` when the effects or postconditions cannot be achieved.

as it is in `detach()`, or, even better, as the postcondition is trivially satisfiable and to remove the circular dependency:

> Throws: `std::system_error` if the effects cannot be achieved.

Problem is that... ehm... `join()` has no "Effects" clause. Is that intentional?

[ See the thread starting at c++std-lib-23204 for more discussion. ]

[ Batavia (2009-05): ]

> Pete believes there may be some more general language (in frontmatter) that can address this and related issues such as 962.

> Move to Open.

Proposed resolution:

### 1034. Response to UK 222

Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-10-20

View other active issues in [container.requirements.general].

View all other issues in [container.requirements.general].

View all issues with Open status.

Discussion:

Addresses UK 222

It is not clear what purpose the Requirement tables serve in the Containers clause. Are they the definition of a library Container? Or simply a conventient shorthand to factor common semantics into a single place, simplifying the description of each subsequent container? This becomes an issue for 'containers' like `array`, which does not meet the default-construct-to-empty requirement, or `forward_list` which does not support the size operation. Are these components no longer containers? Does that mean the remaining requirements don't apply? Or are these contradictions that need fixing, despite being a clear design decision?

Recommend:

Clarify all the tables in 23.2 [container.requirements] are there as a convenience for documentation, rather than a strict set of requirements. Containers should be allowed to relax specific requirements if they call attention to them in their documentation. The introductory text for `array` should be expanded to mention a default constructed `array` is not empty, and `forward_list` introduction should mention it does not provide the required `size` operation as it cannot be implemented efficiently.

[ Summit: ]

> Agree in principle.

[ 2009-07 post-Frankfurt: ]

> We agree in principle, but we have a timetable. This group feels that the issue should be closed as NAD unless a proposed resolution is submitted prior to the March 2010 meeting.

[ 2009-10 Santa Cruz: ]

> Looked at this and still intend to close as NAD in March 2010 unless there is proposed wording that we like.

Proposed resolution:

### 1052. Response to UK 281

Section: 24.5.1.3.5 [reverse.iter.opref] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-10-22

View all issues with Ready status.

Discussion:

Addresses UK 281

The current specification for return value for `reverse_iterator::operator->` will always be a true pointer type, but `reverse_iterator` supports proxy iterators where the pointer type may be some kind of 'smart pointer'.

[ Summit: ]

> `move_iterator` avoids this problem by returning a value of the wrapped Iterator type. study group formed to come up with a suggested resolution.

> `move_iterator` solution shown in proposed wording.

[ 2009-07 post-Frankfurt: ]

> Howard to deconceptize. Move to Review after that happens.

[ 2009-08-01 Howard deconceptized: ]

[ 2009-10 Santa Cruz: ]

> We can't think of any reason we can't just define reverse iterator's pointer types to be the same as the underlying iterator's pointer type, and get it by calling the right arrow directly.

> Here is the proposed wording that was replaced:

> >     template <class Iterator>
> >     class reverse_iterator {
> >       ...
> >       typedef typename iterator_traits<Iterator>::pointer pointer;

> Change 24.5.1.3.5 [reverse.iter.opref]:

> >     pointer operator->() const;

> > > Returns:

> > > >     &(operator*());
> > > >     this->tmp = current;
> > > >     --this->tmp;
> > > >     return this->tmp;

Proposed resolution:

Change 24.5.1.3.5 [reverse.iter.opref]:

>     pointer operator->() const;

> > Returns:

> > >     &(operator*());
> > >     deref_tmp = current;
> > >     --deref_tmp;
> > >     return deref_tmp::operator->();

### 1056. Must all Engines and Distributions be Streamable?

Section: 26.5 [rand] Status: Tentatively NAD Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-11-03

View all other issues in [rand].

View all issues with Tentatively NAD status.

Discussion:

Both the concepts `RandomNumberEngine` and `RandomNumberDistribution` have requirements to be `InputStreamable` and `OutputStreamable`.

I have no problems leaving the WP in an inconsistent state on the best-faith assumption these concepts will be provided later, however disagree with the proposers that these constraints are not separable, orthogonal to the basic concepts of generating random number distributions.

These constraints should be dropped, and applied to specific algorithms as needed.

If a more refined concept (certainly deemed useful by the proposers) is proposed there is no objection, but the basic concept should not require persistence via streaming.

[ Batavia (2009-05): ]

> Move to Open.

[ 2009-05-31 Alisdair adds: ]

> Working on constraining the stream iterators, I have a few more observations to make on the concepts proposed while constraining the random number facility.

> While I still believe the concerns are orthogonal, I don't believe the existing constraints go far enough either! The goal we want to achieve is not that a `RandomNumberEngine` / `RandomNumberDistribution` supports the stream operators, but that it is `Serializable`. I.e. there is a relationship between the insert and extract operations that guarantees to restore the state of the original object. This implies a coupling of the concepts together in a broader concept (`Serializable`) with at least one axiom to assert the semantics.

> One problem is that `istream` and `ostream` may be fundamentally different types, although we can hook a relation if we are prepared to drop down to the `char` type and `char_traits` template parameters. Doing so ties us to a form of serialization that demands implementation via the std iostreams framework, which seems overly prescriptive. I believe the goal is generally to support serialization without regard to how it is expressed - although this is getting even more inventive in terms of concepts we do not have today.

[ 2009-11-03 Alisdair adds: ]

> I can't find the record in the wiki minutes, but it was agreed at both Frankfurt and Santa Cruz that this issue is NAD.

> The agreement in SC was that I would provide you with the rationale (see below) to include when moving to NAD.

[ 2009-11-03 Howard adds: ]

> Moved to Tentatively NAD after 5 positive votes on c++std-lib.

Proposed resolution:

Rationale:

The issue suggests a more refined concept should be used if we want to require streaming, to separate concerns from the basic `RandomNumberEngine` behaviour. In Frankfurt it was observed that `RandomNumberEngine` is that more refined concept, and the basic concept used in the framework is `UniformRandomNumberGenerator`, which it refines.

We concur, and expect this to have no repurcussions re-writing this clause now concepts are removed.

### 1068. class random_device should be movable

Section: 26.5.6 [rand.device] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2009-10-26

View all other issues in [rand.device].

View all issues with Open status.

Discussion:

class `random_device` should be movable.

[ Batavia (2009-05): ]

> Move to Open, and recommend this issue be deferred until after the next Committee Draft is issued.

[ 2009-10 post-Santa Cruz: ]

> Leave open. Walter to provide drafting as part of his planned paper.

Proposed resolution:

### 1069. class seed_seq should support efficient move operations

Section: 26.5.7.1 [rand.util.seedseq] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-18 Last modified: 2009-10-26

View all other issues in [rand.util.seedseq].

View all issues with Open status.

Discussion:

class `seed_seq` should support efficient move operations.

[ Batavia (2009-05): ]

> Move to Open, and recommend this issue be deferred until after the next Committee Draft is issued.

[ 2009-10 post-Santa Cruz: ]

> Leave open. Walter to provide drafting as part of his planned paper.

Proposed resolution:

### 1071. is_bind_expression should derive from integral_constant<bool>

Section: 20.7.11.1.1 [func.bind.isbind] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-10-26

View all issues with Tentatively Ready status.

Discussion:

Class template is_bind_expression 20.7.11.1.1 [func.bind.isbind]:

>     namespace std {
>       template<class T> struct is_bind_expression {
>         static const bool value = see below;
>       };
>     }

`is_bind_expression` should derive from `std::integral_constant<bool>` like other similar trait types.

[ Daniel adds: ]

> We need the same thing for the trait `is_placeholder` as well.

[ 2009-03-22 Daniel provided wording. ]

[ Batavia (2009-05): ]

> We recommend this be deferred until after the next Committee Draft is issued.

> Move to Open.

[ 2009-05-31 Peter adds: ]

> I am opposed to the proposed resolution and to the premise of the issue in general. The traits's default definitions should NOT derive from `integral_constant`, because this is harmful, as it misleads people into thinking that `is_bind_expression<E>` always derives from `integral_constant`, whereas it may not.

> `is_bind_expression` and `is_placeholder` allow user specializations, and in fact, this is their primary purpose. Such user specializations may not derive from `integral_constant`, and the places where `is_bind_expression` and `is_placeholder` are used intentionally do not require such derivation.

> The long-term approach here is to switch to `BindExpression<E>` and `Placeholder<P>` explicit concepts, of course, but until that happens, I say leave them alone.

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready. We are comfortable with requiring user specializations to derive from `integral_constant`.

Proposed resolution:

1. In 20.7.11.1.1 [func.bind.isbind] change as indicated:

   >     namespace std {
   >      template<class T> struct is_bind_expression : integral_constant<bool, see below> { };{
   >        static const bool value = see below;
   >      };
   >     }

2. In 20.7.11.1.1 [func.bind.isbind]/2 change as indicated:

   >     static const bool value;

   > > -2- `true` if `T` is a type returned from `bind`, `false` otherwise. If `T` is a type returned from `bind`, `is_bind_expression<T>` shall be publicly derived from `integral_constant<bool, true>`, otherwise it shall be publicly derived from `integral_constant<bool, false>`.

3. In 20.7.11.1.2 [func.bind.isplace] change as indicated:

   >     namespace std {
   >      template<class T> struct is_placeholder : integral_constant<int, see below> { };{
   >        static const int value = see below;
   >      };
   >     }

4. In 20.7.11.1.2 [func.bind.isplace]/2 change as indicated:

   >     static const int value;

   > > -2- value is `J` if `T` is the type of `std::placeholders::_J`, 0 otherwise. If `T` is the type of `std::placeholders::_J`, `is_placeholder<T>` shall be publicly derived from `integral_constant<int, J>` otherwise it shall be publicly derived from `integral_constant<int, 0>`.

### 1076. unary/binary_negate need constraining and move support

Section: 20.7.10 [negators] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-20 Last modified: 2009-10-26

View all issues with Open status.

Discussion:

The class templates `unary/binary_negate` need constraining and move support.

Ideally these classes would be deprecated, allowing `unary/binary_function` to also be deprecated. However, until a generic negate adaptor is introduced that can negate any `Callable` type, they must be supported so should be constrained. Likewise, they should be movable, and support adopting a move-only predicate type.

In order to preserve ABI compatibility, new rvalue overloads are supplied in preference to changing the existing pass-by-const-ref to pass-by-value.

Do not consider the issue of forwarding mutable lvalues at this point, although remain open to another issue on the topic.

[ 2009-05-01 Daniel adds: ]

> IMO the currently proposed resolution needs some updates because it is ill-formed at several places:

> 1. In concept AdaptableUnaryFunction change

>    >     typename X::result_type;
>    >     typename X::argument_type;

>    to

>    >     Returnable result_type = typename X::result_type;
>    >     typename argument_type = typename X::argument_type;

>    [The replacement "Returnable result_type" instead of "typename result_type" is non-editorial, but maybe you prefer that as well]

> 2. In concept AdaptableBinaryFunction change

>    >     typename X::result_type;
>    >     typename X::first_argument_type;
>    >     typename X::second_argument_type;

>    to

>    >     Returnable result_type = typename X::result_type;
>    >     typename first_argument_type = typename X::first_argument_type;
>    >     typename second_argument_type = typename X::second_argument_type;

>    [The replacement "Returnable result_type" instead of "typename result_type" is non-editorial, but maybe you prefer that as well.]

> 3. In class unary/binary_function

>    1. I suggest to change "ReturnType" to "Returnable" in both cases.
>    2. I think you want to replace the remaining occurrences of "Predicate" by "P" (in both classes in copy/move from a predicate)

> 4. I think you need to change the proposed signatures of not1 and not2, because they would still remain unconstrained: To make them constrained at least a single requirement needs to be added to enable requirement implication. This could be done via a dummy ("requires True<true>") or just explicit as follows:

>    1. >     template <AdaptableUnaryFunction P>
>       >     requires Predicate< P, P::argument_type>
>       >     unary_negate<P> not1(const P&& pred);
>       >     template <AdaptableUnaryFunction P>
>       >     requires Predicate< P, P::argument_type >
>       >     unary_negate<P> not1(P&& pred);

>       > > -3- Returns: unary_negate<P>(pred).

>       [Don't we want a move call for the second overload as in

>       >     unary_negate<P>(std::move(pred))

>       in the Returns clause ?]

>    2.     template <AdaptableBinaryFunction P>
>           requires Predicate< P, P::first_argument_type, P::second_argument_type >
>           binary_negate<P> not2(const P& pred);
>           template <AdaptableBinaryFunction P>
>           requires Predicate< P, P::first_argument_type, P::second_argument_type >
>           binary_negate<P> not2(P&& pred);

>       -5- Returns: binary_negate<P>(pred).

>       [Don't we want a move call for the second overload as in

>       >     binary_negate<P>(std::move(pred))

>       in the Returns clause ?]

[ Batavia (2009-05): ]

> There is concern that complicating the solution to preserve the ABI seems unnecessary, since we're not in general preserving the ABI.

> We would prefer a separate paper consolidating all Clause 20 issues that are for the purpose of providing constrained versions of the existing facilities.

> Move to Open.

[ 2009-10 post-Santa Cruz: ]

> Leave open pending the potential move constructor paper. Note that we consider the "constraining" part NAD Concepts.

Proposed resolution:

Add new concepts where appropriate::

>     auto concept AdaptableUnaryFunction< typename X > {
>       typename X::result_type;
>       typename X::argument_type;
>     }

>     auto concept AdaptableBinaryFunction< typename X > {
>       typename X::result_type;
>       typename X::first_argument_type;
>       typename X::second_argument_type;
>     }

Revise as follows:

Base 20.7.3 [base] (Only change is constrained Result)

> -1- The following classes are provided to simplify the typedefs of the argument and result types:

>     namespace std {
>       template <class Arg, class ReturnType Result>
>       struct unary_function {
>          typedef Arg    argument_type;
>          typedef Result result_type;
>       };

>       template <class Arg1, class Arg2, class ReturnType Result>
>       struct binary_function {
>          typedef Arg1   first_argument_type;
>          typedef Arg2   second_argument_type;
>          typedef Result result_type;
>       };
>     }

Negators 20.7.10 [negators]:

> -1- Negators `not1` and `not2` take a unary and a binary predicate, respectively, and return their complements (5.3.1).

>     template <class AdaptableUnaryFunction Predicate>
>       requires Predicate< P, P::argument_type >
>       class unary_negate
>         : public unary_function<typename Predicate::argument_type,bool> {
>       public:
>         unary_negate(const unary_negate & ) = default;
>         unary_negate(unary_negate && );

>         requires CopyConstructible< P >
>            explicit unary_negate(const Predicate& pred);
>         requires MoveConstructible< P >
>            explicit unary_negate(Predicate && pred);

>         bool operator()(const typename Predicate::argument_type& x) const;
>       };

> > -2 `operator()` returns `!pred(x)`.

>     template <class Predicate>
>       unary_negate<Predicate> not1(const Predicate&amp; pred);
>     template <class Predicate>
>       unary_negate<Predicate> not1(Predicate&& pred);

> > -3- Returns: `unary_negate<Predicate>(pred)`.

>     template <class AdaptableBinaryFunction Predicate >
>       requires Predicate< P, P::first_argument_type, P::second_argument_type >
>       class binary_negate
>         : public binary_function<typename Predicate::first_argument_type,
>                                   typename Predicate::second_argument_type, bool> {
>       public:
>         biary_negate(const binary_negate & ) = default;
>         binary_negate(binary_negate && );

>         requires CopyConstructible< P >
>            explicit binary_negate(const Predicate& pred);
>         requires MoveConstructible< P >
>            explicit binary_negate(const Predicate& pred);

>         bool operator()(const typename Predicate::first_argument_type& x,
>                         const typename Predicate::second_argument_type& y) const;
>       };

> > -4- `operator()` returns `!pred(x,y)`.

>     template <class Predicate>
>       binary_negate<Predicate> not2(const Predicate& pred);
>     template <class Predicate>
>       binary_negate<Predicate> not2(Predicate&& pred);

> > -5- Returns: `binary_negate<Predicate>(pred)`.

### 1079. UK-265: `RandomAccessIterator`'s `operator-` has nonsensical effects clause

Section: 24.2.5 [random.access.iterators] Status: Ready Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2009-10-23

View all other issues in [random.access.iterators].

View all issues with Ready status.

Discussion:

Addresses UK 265

UK-265:

This effects clause is nonesense. It looks more like an axiom stating equivalence, and certainly an effects clause cannot change the state of two arguments passed by const reference

[ 2009-09-18 Alisdair adds: ]

> For random access iterators, the definitions of `(b-a)` and `(a<b)` are circular:

> From table Table 104 -- Random access iterator requirements:

> >     b - a :==>  (a < b) ? distance(a,b) : -distance(b,a)

> >     a < b :==>  b - a > 0

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

Modify 24.2.5 [random.access.iterators]p7-9 as follows:

>     difference_type operator-(const X& a, const X& b);

> 7. Precondition: there exists a value `n` of `difference_type` such that `a == b + n`.
> 8. Effects: `b == a + (b - a)`
> 9. Returns: `(a < b) ? distance(a,b) : -distance(b,a)``n`

### 1089. Response to JP 76

Section: 30 [thread] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-10-23

View all other issues in [thread].

View all issues with Open status.

Discussion:

Addresses JP 76

A description for "Throws: Nothing." are not unified.

At the part without throw, "Throws: Nothing." should be described.

Add "Throws: Nothing." to the following.

- 30.3.1.6 [thread.thread.static] p1
- 30.4.3.1 [thread.lock.guard] p4
- 30.4.3.2.1 [thread.lock.unique.cons] p6
- 30.5.1 [thread.condition.condvar] p7 and p8
- 30.5.2 [thread.condition.condvarany] p6, p7, p19, p21 and p25

[ Summit: ]

> Pass on to editor.

[ Post Summit: Editor declares this non-editorial. ]

[ 2009-08-01 Howard provided wording: ]

> The definition of "Throws: Nothing." that I added is probably going to be controversial, but I beg you to consider it seriously.

> > In C++ there are three "flow control" options for a function:

> > 1. It can return, either with a value, or with `void`.
> > 2. It can call a function which never returns, such as `std::exit` or `std::terminate`.
> > 3. It can throw an exception.
> > The above list can be abbreviated with:
> > 1. Returns.
> > 2. Ends program.
> > 3. Throws exception.

> > In general a function can have the behavior of any of these 3, or any combination of any of these three, depending upon run time data.

> > 1. R
> > 2. E
> > 3. T
> > 4. RE
> > 5. RT
> > 6. ET
> > 7. RET

> > A function with no throw spec, and no documentation, is in general a RET function. It may return, it may end the program, or it may throw. When we specify a function with an empty throw spec:

> > >     void f() throw();

> > We are saying that `f()` is an RE function: It may return or end the program, but it will not throw.

> > I posit that there are very few places in the library half of the standard where we intend for functions to be able to end the program (call `terminate`). And none of those places where we do say `terminate` could be called, do we currently say "Throws: Nothing.".

> > I believe that if we define "Throws: Nothing." to mean R, we will both clarify many, many places in the standard, and give us a good rationale for choosing between "Throws: Nothing." (R) and `throw()` (RE) in the future. Indeed, this may give us motivation to change several `throw()`s to "Throws: Nothing.".

> I did not add the following changes as JP 76 requested as I believe we want to allow these functions to throw:

> > Add a paragraph under 30.4.3.1 [thread.lock.guard] p4:

> > >     explicit lock_guard(mutex_type& m);

> > > Throws: Nothing.

> > Add a paragraph under 30.4.3.2.1 [thread.lock.unique.cons] p6:

> > >     explicit unique_lock(mutex_type& m);

> > > Throws: Nothing.

> > Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:

> > >     template <class Lock, class Rep, class Period>
> > >       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);

> > > Throws: Nothing.

> > >     template <class Lock, class Duration, class Predicate>
> > >       bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& rel_time, Predicate pred);

> > > Throws: Nothing.

> > >     template <class Lock, class Rep, class Period, class Predicate>
> > >       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);

> > > Throws: Nothing.

[ 2009-10 Santa Cruz: ]

> Defer pending further developments with exception restriction annotations.

Proposed resolution:

Add a paragraph after 17.5.1.4 [structure.specifications] p4:

> -3- Descriptions of function semantics contain the following elements (as appropriate):158

> - ...
> - Throws: any exceptions thrown by the function, and the conditions that would cause the exception
> - ...

> -4- For non-reserved replacement and handler functions, ...

> A "Throws: Nothing." element indicates that the function shall return ordinarily, and not exit via an exception. This element also indicates that the function shall return. [Note: This differs from an empty throw specification which may cause a function to call `unexpected` and subsequently `terminate`. — end note]

Add a paragraph under 30.3.1.6 [thread.thread.static] p1:

>     unsigned hardware_concurrency();

> -1- Returns: ...

> Throws: Nothing.

Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8:

> [Informational, not to be incluced in the WP: The POSIX spec allows only:

> [EINVAL]
>   The value `cond` does not refer to an initialized condition variable. — end informational]

>     void notify_one();

> -7- Effects: ...

> Throws: Nothing.

>     void notify_all();

> -8- Effects: ...

> Throws: Nothing.

Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:

>     void notify_one();

> -6- Effects: ...

> Throws: Nothing.

>     void notify_all();

> -7- Effects: ...

> Throws: Nothing.

### 1090. Missing description of `packaged_task` member `swap`, missing non-member `swap`

Section: 30.6.10 [futures.task] Status: Tentatively Ready Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2009-10-26

View all issues with Tentatively Ready status.

Discussion:

Class template `packaged_task` in 30.6.10 [futures.task] shows a member `swap` declaration, but misses to document it's effects (No prototype provided). Further on this class misses to provide a non-member swap.

[ Batavia (2009-05): ]

> Alisdair notes that paragraph 2 of the proposed resolution has already been applied in the current Working Draft.

> We note a pending `future`-related paper by Detlef; we would like to wait for this paper before proceeding.

> Move to Open.

[ 2009-05-24 Daniel removed part 2 of the proposed resolution. ]

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready, removing bullet 3 from the proposed resolution but keeping the other two bullets.

Proposed resolution:

1. In 30.6.10 [futures.task], immediately after the definition of class template packaged_task add:

   >     template<class R, class... Argtypes>
   >     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&);

4. At the end of 30.6.10 [futures.task] (after p. 20), add add the following prototype description:

   >     template<class R, class... Argtypes>
   >     void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y);

   > > Effects: `x.swap(y)`

   > > Throws: Nothing.

### 1093. Multiple definitions for random_shuffle algorithm

Section: 25.3.12 [alg.random.shuffle] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2009-10-26

View all other issues in [alg.random.shuffle].

View all issues with Open status.

Discussion:

There are a couple of issues with the declaration of the `random_shuffle` algorithm accepting a random number engine.

1. The Iterators must be shuffle iterators, yet this requirement is missing.
2. The `RandomNumberEngine` concept is now provided by the random number library (n2836) and the placeholder should be removed.

[ 2009-05-02 Daniel adds: ]

> this issue completes adding necessary requirement to the third new `random_shuffle` overload. The current suggestion is:

> >     template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
> >     requires ShuffleIterator<Iter>
> >     void random_shuffle(Iter first, Iter last, Rand&& g);

> IMO this is still insufficient and I suggest to add the requirement

> >     Convertible<Rand::result_type, Iter::difference_type>

> to the list (as the two other overloads already have).

> Rationale:

> > Its true that this third overload is somewhat different from the remaining two. Nevertheless we know from `UniformRandomNumberGenerator`, that it's `result_type` is an integral type and that it satisfies `UnsignedIntegralLike<result_type>`.

> > To realize it's designated task, the algorithm has to invoke the `Callable` aspect of `g` and needs to perform some algebra involving it's `min()/max()` limits to compute another index value that at this point is converted into `Iter::difference_type`. This is so, because 24.2.5 [random.access.iterators] uses this type as argument of it's algebraic operators. Alternatively consider the equivalent iterator algorithms in 24.4.4 [iterator.operations] with the same result.

> > This argument leads us to the conclusion that we also need `Convertible<Rand::result_type, Iter::difference_type>` here.

[ Batavia (2009-05): ]

> Alisdair notes that point (ii) has already been addressed.

> We agree with the proposed resolution to point (i) with Daniel's added requirement.

> Move to Review.

[ 2009-06-05 Daniel updated proposed wording as recommended in Batavia. ]

[ 2009-07-28 Alisdair adds: ]

> Revert to Open, with a note there is consensus on direction but the wording needs updating to reflect removal of concepts.

[ 2009-10 post-Santa Cruz: ]

> Leave Open, Walter to work on it.

Proposed resolution:

Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]:

>     concept UniformRandomNumberGenerator<typename Rand> { }
>     template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
>       requires ShuffleIterator<Iter> &&
>       Convertible<Rand::result_type, Iter::difference_type>
>       void random_shuffle(Iter first, Iter last, Rand&& g);

### 1094. Response to JP 65 and JP 66

Section: 27.5.4.3 [iostate.flags] Status: Ready Submitter: P.J. Plauger Opened: 2009-03-24 Last modified: 2009-10-20

View all other issues in [iostate.flags].

View all issues with Ready status.

Discussion:

Addresses JP 65 and JP 66

Switch from "unspecified-bool-type" to "explicit operator bool() const".

Replace `operator unspecified-bool-type() const;`" with `explicit operator bool() const;`

[ Batavia (2009-05): ]

> We agree with the proposed resolution. Move to Review.

[ 2009 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

Change the synopis in 27.5.4 [ios]:

>     explicit operator unspecified-bool-type bool() const;

Change 27.5.4.3 [iostate.flags]:

>     explicit operator unspecified-bool-type bool() const;

> > -1- Returns: `!fail()` If `fail()` then a value that will evaluate false in a boolean context; otherwise a value that will evaluate true in a boolean context. The value type returned shall not be convertible to int.

> > [Note: This conversion can be used in contexts where a bool is expected (e.g., an `if` condition); however, implicit conversions (e.g., to `int`) that can occur with `bool` are not allowed, eliminating some sources of user error. One possible implementation choice for this type is pointer-to-member. -- end note]

### 1095. Shared objects and the library wording unclear

Section: 17.6.3.10 [res.on.objects] Status: Ready Submitter: Beman Dawes Opened: 2009-03-27 Last modified: 2009-10-21

View all issues with Ready status.

Discussion:

N2775, Small library thread-safety revisions, among other changes, removed a note from 17.6.3.10 [res.on.objects] that read:

> [Note: This prohibition against concurrent non-const access means that modifying an object of a standard library type shared between threads without using a locking mechanism may result in a data race. --end note.]

That resulted in wording which is technically correct but can only be understood by reading the lengthy and complex 17.6.4.8 [res.on.data.races] Data race avoidance. This has the effect of making 17.6.3.10 [res.on.objects] unclear, and has already resulted in a query to the LWG reflector. See c++std-lib-23194.

[ Batavia (2009-05): ]

> The proposed wording seems to need a bit of tweaking ("really bad idea" isn't quite up to standardese). We would like feedback as to whether the original Note's removal was intentional.

> Change the phrase "is a really bad idea" to "risks undefined behavior" and move to Review status.

[ 2009-10 Santa Cruz: ]

> Note: Change to read: "Modifying...", Delete 'thus', move to Ready

Proposed resolution:

Change 17.6.3.10 [res.on.objects] as indicated:

> The behavior of a program is undefined if calls to standard library functions from different threads may introduce a data race. The conditions under which this may occur are specified in 17.6.4.7.

> [Note: Modifying an object of a standard library type shared between threads risks undefined behavior unless objects of the type are explicitly specified as being sharable without data races or the user supplies a locking mechanism. --end note]

### 1097. #define __STDCPP_THREADS

Section: 18.2 [support.types] Status: Ready Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-10-21

View all other issues in [support.types].

View all issues with Ready status.

Discussion:

Addresses DE 18

Freestanding implementations do not (necessarily) have support for multiple threads (see 1.10 [intro.multithread]). Applications and libraries may want to optimize for the absence of threads. I therefore propose a preprocessor macro to indicate whether multiple threads can occur.

There is ample prior implementation experience for this feature with various spellings of the macro name. For example, gcc implicitly defines `_REENTRANT` if multi-threading support is selected on the compiler command-line.

While this is submitted as a library issue, it may be more appropriate to add the macro in 16.8 cpp.predefined in the core language.

See also N2693.

[ Batavia (2009-05): ]

> We agree with the issue, and believe it is properly a library issue.

> We prefer that the macro be conditionally defined as part of the `<thread>` header.

> Move to Review.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Insert a new subsection before 18.2 [support.types], entitled "Feature Macros" (support.macros):

> The standard library defines the following macros; no explicit prior inclusion of any header file is necessary.

> > `__STDCPP_THREADS`
> >   The macro `__STDCPP_THREADS` shall be defined if and only if a program can have more than one thread of execution (1.10 [intro.multithread]). If the macro is defined, it shall have the same value as the predefined macro `__cplusplus` (16.8 [cpp.predefined]).

### 1098. definition of get_pointer_safety()

Section: 20.8.15.6 [util.dynamic.safety] Status: Ready Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-10-23

View all other issues in [util.dynamic.safety].

View all issues with Ready status.

Discussion:

Addresses DE 18

In 20.8.15.6 [util.dynamic.safety], `get_pointer_safety()` purports to define behavior for non-safely derived pointers (3.7.4.3 [basic.stc.dynamic.safety]). However, the cited core-language section in paragraph 4 specifies undefined behavior for the use of such pointer values. This seems an unfortunate near-contradiction. I suggest to specify the term relaxed pointer safety in the core language section and refer to it from the library description. This issue deals with the library part, the corresponding core issue (c++std-core-13940) deals with the core modifications.

See also N2693.

[ Batavia (2009-05): ]

> We recommend if this issue is to be moved, the issue be moved concurrently with the cited Core issue.

> We agree with the intent of the proposed resolution. We would like input from garbage collection specialists.

> Move to Open.

[ 2009-10 Santa Cruz: ]

> The core issue is 853 and is in Ready status.

Proposed resolution:

In 20.8.15.6 [util.dynamic.safety] p16, replace the description of `get_pointer_safety()` with:

> `pointer_safety get_pointer_safety();`

> > Returns: an enumeration value indicating the implementation's treatment of pointers that are not safely derived (3.7.4.3). Returns `pointer_safety::relaxed` if pointers that are not safely derived will be treated the same as pointers that are safely derived for the duration of the program. Returns `pointer_safety::preferred` if pointers that are not safely derived will be treated the same as pointers that are safely derived for the duration of the program but allows the implementation to hint that it could be desirable to avoid dereferencing pointers that are not safely derived as described. [Example: `pointer_safety::preferred` might be returned to detect if a leak detector is running to avoid spurious leak reports. -- end note] Returns `pointer_safety::strict` if pointers that are not safely derived might be treated differently than pointers that are safely derived.

> > Returns: Returns `pointer_safety::strict` if the implementation has strict pointer safety (3.7.4.3 [basic.stc.dynamic.safety]). It is implementation-defined whether `get_pointer_safety` returns `pointer_safety::relaxed` or `pointer_safety::preferred` if the implementation has relaxed pointer safety (3.7.4.3 [basic.stc.dynamic.safety]).Footnote

> > Throws: nothing

> > Footnote) `pointer_safety::preferred` might be returned to indicate to the program that a leak detector is running so that the program can avoid spurious leak reports.

### 1099. Various issues

Section: 17 [library] Status: Tentatively NAD Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2009-10-26

View other active issues in [library].

View all other issues in [library].

View all issues with Tentatively NAD status.

Discussion:

Notes

> [2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1, MoveConstructible V2 (where V1,V2 are defined on 539). Also make_tuple on 550

> > CD-1 reads:

> > >     template <MoveConstructible T1, MoveConstructible T2>
> > >     pair<V1, V2> make_pair(T1&&, T2&&);

> > Actually I'm guessing we need something like `MoveConstructible<V1,T1>`, i.e. "`V1` can be constructed from an rvalue of type `T1`."

> > Ditto for `make_tuple`

> [2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to talk about "copiable from generalized rvalue ref argument" for cases where we're going to forward and copy.

> > This issue may well be quite large. Language in para 4 about "if an lvalue" is wrong because types aren't expressions.

> > > Maybe we should define the term "move" so we can just say in the effects, "`f` is moved into the newly-created thread" or something, and agree (and ideally document) that saying "`f` is moved" implies

> > > >     F x(move(f))

> > > is required to work. That would cover both ctors at once.

> > p1199, call_once has all the same issues.

> [2009-03-21 Sat] p869 InputIterator pointer type should not be required to be convertible to const value_type*, rather it needs to have a operator-> of its own that can be used for the value type.

> > This one is serious and unrelated to the move issue.

> [2009-03-21 Sat] p818 stack has the same problem with default ctor.

> [2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so

> >        requires MoveConstructible<Cont>
> >          explicit priority_queue(const Compare& x = Compare(), Cont&& = Cont());

> > Don't require MoveConstructible when default constructing Cont. Also missing semantics for move ctor.

> [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as opposed to MoveConstructible?

> [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't be MoveConstructible). No documented semantics for move c'tor. Or *any* of its 7 ctors!

> [2009-03-21 Sat] std::array should have constructors for C++0x, consequently must consider move construction.

> [ 2009-05-01 Daniel adds: ]

> > This could be done as part of 1035, which already handles deviation of `std::array` from container tables.

> [2009-03-21 Sat] p622 all messed up.

> > para 8 "implementation-defined" is the wrong term; should be "see below" or something.

> > para 12 "will be selected" doesn't make any sense because we're not talking about actual arg types.

> > paras 9-13 need to be totally rewritten for concepts.

> [2009-03-21 Sat] Null pointer comparisons (p587) have all become unconstrained. Need to fix that

> [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration. We think CopyConstructible is the right reqt.

> make_pair needs Constructible<V1, T1&&> requirements!

> make_tuple needs something similar

> tuple bug in synopsis:

> >        template <class... UTypes>
> >        requires Constructible<Types, const UTypes&>...
> >        template <class... UTypes>
> >        requires Constructible<Types, RvalueOf<UTypes>::type>...

> > Note: removal of MoveConstructible requirements in std::function makes these routines unconstrained!

> [ 2009-05-02 Daniel adds: ]

> > This part of the issue is already covered by 1077.

> these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ]

> >      unique_ptr(pointer p, implementation-defined d);
> >      unique_ptr(pointer p, implementation-defined d);

> multimap range constructor should not have MoveConstructible<value_type> requirement.

> > same with insert(..., P&&); multiset has the same issue, as do unordered_multiset and unordered_multimap. Review these!

[ Batavia (2009-05): ]

> Move to Open, pending proposed wording from Dave for further review.

[ 2009-10 post-Santa Cruz: ]

> Tentatively NAD. We are not sure what has been addressed and what hasn't. Recommend closing unless someone sorts this out into something more readable.

Proposed resolution:

### 1100. `auto_ptr` to `unique_ptr` conversion

Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-10-21

View other active issues in [unique.ptr.single.ctor].

View all other issues in [unique.ptr.single.ctor].

View all issues with Ready status.

Discussion:

Message c++std-lib-23182 led to a discussion in which several people expressed interest in being able to convert an `auto_ptr` to a `unique_ptr` without the need to call `release`. Below is wording to accomplish this.

[ Batavia (2009-05): ]

> Pete believes it not a good idea to separate parts of a class's definition. Therefore, if we do this, it should be part of `unique-ptr`'s specification.

> Alisdair believes the lvalue overload may be not necessary.

> Marc believes it is more than just sugar, as it does ease the transition to `unique-ptr`.

> We agree with the resolution as presented. Move to Tentatively Ready.

[ 2009-07 Frankfurt ]

> Moved from Tentatively Ready to Open only because the wording needs to be tweaked for concepts removal.

[ 2009-08-01 Howard deconceptifies wording: ]

> I also moved the change from D.10 [depr.auto.ptr] to 20.8.14.2 [unique.ptr.single] per the Editor's request in Batavia (as long as I was making changes anyway). Set back to Review.

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add to 20.8.14.2 [unique.ptr.single]:

>     template <class T, class D>
>     class unique_ptr
>     {
>     public:
>         template <class U>
>           unique_ptr(auto_ptr<U>& u);
>         template <class U>
>           unique_ptr(auto_ptr<U>&& u);
>     };

Add to 20.8.14.2.1 [unique.ptr.single.ctor]:

>     template <class U>
>       unique_ptr(auto_ptr<U>& u);
>     template <class U>
>       unique_ptr(auto_ptr<U>&& u);

> > Effects: Constructs a `unique_ptr` with `u.release()`.

> > Postconditions: `get() ==` the value `u.get()` had before the construciton, modulo any required offset adjustments resulting from the cast from `U*` to `T*`. `u.get() == nullptr`.

> > Throws: nothing.

> > Remarks: `U*` shall be implicitly convertible to `T*` and `D` shall be the same type as `default_delete<T>`, else these constructors shall not participate in overload resolution.

### 1104. `basic_ios::move` should accept lvalues

Section: 27.5.4.2 [basic.ios.members] Status: Ready Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-10-20

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with Ready status.

Discussion:

With the rvalue reference changes in N2844 `basic_ios::move` no longer has the most convenient signature:

>     void move(basic_ios&& rhs);

This signature should be changed to accept lvalues. It does not need to be overloaded to accept rvalues. This is a special case that only derived clients will see. The generic `move` still needs to accept rvalues.

[ Batavia (2009-05): ]

> Tom prefers, on general principles, to provide both overloads. Alisdair agrees.

> Howard points out that there is no backward compatibility issue as this is new to C++0X.

> We agree that both overloads should be provided, and Howard will provide the additional wording. Move to Open.

[ 2009-05-23 Howard adds: ]

> Added overload, moved to Review.

[ 2009 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add a signature to the existing prototype in the synopsis of 27.5.4 [ios] and in 27.5.4.2 [basic.ios.members]:

>     void move(basic_ios& rhs);
>     void move(basic_ios&& rhs);

### 1106. Multiple exceptions from connected `shared_future::get()`?

Section: 30.6.7 [future.shared_future] Status: Open Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2009-05-23

View all other issues in [future.shared_future].

View all issues with Open status.

Discussion:

It is not clear, if multiple threads are waiting in a `shared_future::get()` call, if each will rethrow the stored exception.

Paragraph 9 reads:

> Throws: the stored exception, if an exception was stored and not retrieved before.

The "not retrieved before" suggests that only one exception is thrown, but one exception for each call to `get()` is needed, and multiple calls to `get()` even on the same `shared_future` object seem to be allowed.

I suggest removing "and not retrieved before" from the Throws paragraph. I recommend adding a note that explains that multiple calls on `get()` are allowed, and each call would result in an exception if an exception was stored.

[ Batavia (2009-05): ]

> We note there is a pending paper by Detlef on such `future`-related issues; we would like to wait for his paper before proceeding.

> Alisdair suggests we may want language to clarify that this `get()` function can be called from several threads with no need for explicit locking.

> Move to Open.

Proposed resolution:

Change 30.6.7 [future.shared_future]:

>     const R& shared_future::get() const;
>     R& shared_future<R&>::get() const;
>     void shared_future<void>::get() const;

> > ...

> > -9- Throws: the stored exception, if an exception was stored and not retrieved before. [Note: Multiple calls on `get()` are allowed, and each call would result in an exception if an exception was stored. — end note]

### 1108. thread.req.exception overly constrains implementations

Section: 30.2.2 [thread.req.exception] Status: Tentatively Ready Submitter: Christopher Kohlhoff Opened: 2009-04-25 Last modified: 2009-10-26

View all issues with Tentatively Ready status.

Discussion:

The current formulation of 30.2.2 [thread.req.exception]/2 reads:

> The error_category of the `error_code` reported by such an exception's `code()` member function is as specified in the error condition Clause.

This constraint on the code's associated `error_categor` means an implementation must perform a mapping from the system-generated error to a `generic_category()` error code. The problems with this include:

- The mapping is always performed, even if the resultant value is never used.

- The original error produced by the operating system is lost.

The latter was one of Peter Dimov's main objections (in a private email discussion) to the original `error_code`-only design, and led to the creation of `error_condition` in the first place. Specifically, `error_code` and `error_condition` are intended to perform the following roles:

- `error_code` holds the original error produced by the operating system.
- `error_condition` and the generic category provide a set of well known error constants that error codes may be tested against.

Any mapping determining correspondence of the returned error code to the conditions listed in the error condition clause falls under the "latitude" granted to implementors in 19.5.1.5 [syserr.errcat.objects]. (Although obviously their latitude is restricted a little by the need to match the right error condition when returning an error code from a library function.)

It is important that this `error_code/error_condition` usage is done correctly for the thread library since it is likely to set the pattern for future TR libraries that interact with the operating system.

[ Batavia (2009-05): ]

> Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready.

Proposed resolution:

Change 30.2.2 [thread.req.exception]/2:

> -2- The `error_category` (19.5.1.1) of the `error_code` reported by such an exception's `code()` member function is as specified in the error condition Clause. The `error_code` reported by such an exception's `code()` member function shall compare equal to one of the conditions specified in the function's error condition Clause. [Example: When the thread constructor fails:

> >     ec.category() == implementation-defined // probably system_category
> >     ec == errc::resource_unavailable_try_again // holds true

> — end example]

### 1110. Is `for_each` overconstrained?

Section: 25.2.4 [alg.foreach] Status: Open Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2009-10-27

View all other issues in [alg.foreach].

View all issues with Open status.

Discussion:

Quoting working paper for reference (25.2.4 [alg.foreach]):

>     template<InputIterator Iter, Callable<auto, Iter::reference> Function>
>       requires CopyConstructible<Function>
>       Function for_each(Iter first, Iter last, Function f);

> > 1 Effects: Applies f to the result of dereferencing every iterator in the range [first,last), starting from first and proceeding to last - 1.

> > 2 Returns: f.

> > 3 Complexity: Applies f exactly last - first times.

P2 implies the passed object `f` should be invoked at each stage, rather than some copy of `f`. This is important if the return value is to usefully accumulate changes. So the requirements are an object of type `Function` can be passed-by-value, invoked multiple times, and then return by value. In this case, `MoveConstructible` is sufficient. This would open support for move-only functors, which might become important in concurrent code as you can assume there are no other references (copies) of a move-only type and so freely use them concurrently without additional locks.

[ See further discussion starting with c++std-lib-23686. ]

[ Batavia (2009-05): ]

> Pete suggests we may want to look at this in a broader context involving other algorithms. We should also consider the implications of parallelism.

> Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.

[ 2009-10-14 Daniel de-conceptified the proposed resolution. ]

> The note in 25.1 [algorithms.general]/9 already says the right thing:

> > Unless otherwise specified, algorithms that take function objects as arguments are permitted to copy those function objects freely.

> So we only need to ensure that the wording for `for_each` is sufficiently clear, which is the intend of the following rewording.

[ 2009-10-15 Daniel proposes: ]

> - Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):

>   > Requires: `Function` shall be `MoveConstructible` ( [moveconstructible]), `CopyConstructible` is not required.

> - Change 25.2.4 [alg.foreach]/2 as indicated:

>   > Returns: std::move(f).

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready, using Daniel's wording without the portion saying "CopyConstructible is not required".

[ 2009-10-27 Daniel adds: ]

> I see that during the Santa Cruz meeting the originally proposed addition

> > , `CopyConstructible` is not required.

> was removed. I don't think that this removal was a good idea. The combination of 25.1 [algorithms.general]/9

> > [Note: Unless otherwise specified, algorithms that take function objects as arguments are permitted to copy those function objects freely.[..]

> with the fact that `CopyConstructible` is a refinement `MoveConstructible` makes it necessary that such an explicit statement is given. Even the existence of the usage of `std::move` in the Returns clause doesn't help much, because this would still be well-formed for a `CopyConstructible` without move constructor. Let me add that the originally proposed addition reflects current practice in the standard, e.g. 25.3.9 [alg.unique]/5 usages a similar terminology.

> For similar wording need in case for auto_ptr see 973.

> [ Howard: Moved from Tentatively Ready to Open. ]

Proposed resolution:

- Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):

  > Requires: `Function` shall be `MoveConstructible` ( [moveconstructible]).

- Change 25.2.4 [alg.foreach]/2 as indicated:

  > Returns: std::move(f).

### 1112. bitsets and new style for loop

Section: 20.3.7 [template.bitset] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-05-06 Last modified: 2009-10-26

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with Tentatively NAD Future status.

Discussion:

`Std::bitset` is a homogeneous container-like sequence of bits, yet it does not model the Range concept so cannot be used with the new for-loop syntax. It is the only such type in the library that does NOT support the new for loop.

The obvious reason is that bitset does not support iterators.

At least two reasonable solutions are available:

1. Add an iterator interface to `bitset`, bringing its interface close to that of `std::array`
2. Provide an unspecified concept_map for `Range<bitset>`.

The latter will still need some kind of iterator-like adapter for `bitset`, but gives implementers greater freedom on the details. E.g. begin/end return some type that simply invokes `operator[]` on the object it wraps, and increments its index on `operator++`. A vendor can settle for `InputIterator` support, rather than wrapping up a full `RandomAccessIterator`.

I have a mild preference for option (ii) as I think it is less work to specify at this stage of the process, although (i) is probably more useful in the long run.

Hmm, my wording looks a little woolly, as it does not say what the element type of the range is. Do I get a range of `bool`, `bitset<N>::reference`, or something else entirely?

I guess most users will assume the behaviour of reference, but expect to work with `bool`. `Bool` is OK for read-only traversal, but you really need to take a reference to a `bitset::reference` if you want to write back.

[ Batavia (2009-05): ]

> Move to Open. We further recommend this be deferred until after the next Committee Draft.

[ 2009-05-25 Alisdair adds: ]

> I just stumbled over the `Range concept_map` for `valarray` and this should probably set the precedent on how to write the wording.

> [ Howard: I've replaced the proposed wording with Alisdair's suggestion. ]

[ 2009-07-24 Daniel modifies the proposed wording for non-concepts. ]

[ 2009-10 post-Santa Cruz: ]

> Mark as Tentatively NAD Future due to the loss of concepts.

Proposed resolution:

1. Modify the section 20.3.7 [template.bitset] `<bitset>` synopsis by adding the following at the end of the synopsis:

   >     // XX.X.X bitset range access [bitset.range]
   >     template<size_t N> unspecified-1 begin(bitset<N>&);
   >     template<size_t N> unspecified-2 begin(const bitset<N>&);
   >     template<size_t N> unspecified-1 end(bitset<N>&);
   >     template<size_t N> unspecified-2 end(const bitset<N>&);

2. Add a new section "bitset range access" [bitset.range] after the current section 20.3.7.3 [bitset.operators] with the following series of paragraphs:

   > 1. In the `begin` and `end` function templates that follow, unspecified-1 is a type that meets the requirements of a mutable random access iterator (24.2.5 [random.access.iterators]) whose `value_type` is `bool` and whose reference type is `bitset<N>::reference`. unspecified-2 is a type that meets the requirements of a constant random access iterator (24.2.5 [random.access.iterators]) whose `value_type` is `bool` and whose reference type is `bool`.

   >     template<size_t N> unspecified-1 begin(bitset<N>&);
   >     template<size_t N> unspecified-2 begin(const bitset<N>&);

   > > 2. Returns: an iterator referencing the first bit in the bitset.

   >     template<size_t N> unspecified-1 end(bitset<N>&);
   >     template<size_t N> unspecified-2 end(const bitset<N>&);

   > > 3. Returns: an iterator referencing one past the last bit in the bitset.

### 1113. `bitset::to_string` could be simplified

Section: 20.3.7 [template.bitset] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-05-09 Last modified: 2009-10-26

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with Tentatively Ready status.

Discussion:

In 853 our resolution is changing the signature by adding two defaulting arguments to 3 calls. In principle, this means that ABI breakage is not an issue, while API is preserved.

With that observation, it would be very nice to use the new ability to supply default template parameters to function templates to collapse all 3 signatures into 1. In that spirit, this issue offers an alternative resolution than that of 853.

[ Batavia (2009-05): ]

> Move to Open, and look at the issue again after 853 has been accepted. We further recommend this be deferred until after the next Committee Draft.

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready.

Proposed resolution:

1. In 20.3.7 [template.bitset]/1 (class bitset) ammend:

   >     template <class charT = char,
   >                 class traits = char_traits<charT>,
   >                 class Allocator = allocator<charT>>
   >       basic_string<charT, traits, Allocator>
   >       to_string(charT zero = charT('0'), charT one = charT('1')) const;
   >     template <class charT, class traits>
   >       basic_string<charT, traits, allocator<charT> > to_string() const;
   >     template <class charT>
   >       basic_string<charT, char_traits<charT>, allocator<charT> > to_string() const;
   >     basic_string<char, char_traits<char>, allocator<char> > to_string() const;

2. In 20.3.7.2 [bitset.members] prior to p35 ammend:

   >     template <class charT = char,
   >                 class traits = char_traits<charT>,
   >                 class Allocator = allocator<charT>>
   >       basic_string<charT, traits, Allocator>
   >       to_string(charT zero = charT('0'), charT one = charT('1')) const;

3. Strike 20.3.7.2 [bitset.members] paragraphs 37 -> 39 (including signature above 37)

### 1114. Type traits underspecified

Section: 20.6 [meta] Status: Tentatively Ready Submitter: Daniel Krügler Opened: 2009-05-12 Last modified: 2009-10-26

View all other issues in [meta].

View all issues with Tentatively Ready status.

Discussion:

Related to 975 and 1023.

The current wording in 20.6.1 [meta.rqmts] is still unclear concerning it's requirements on the type traits classes regarding ambiguities. Specifically it's unclear

- if a predicate trait (20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from both `true_type`/`false_type`.
- if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could ambiguously derive from the same specified result type.
- if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from other `integral_constant` types making the contained names ambiguous
- if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could have other base classes that contain members hiding the name of the result type members or make the contained member names ambiguous.

[ Batavia (2009-05): ]

> Alisdair would prefer to factor some of the repeated text, but modulo a corner case or two, he believes the proposed wording is otherwise substantially correct.

> Move to Open.

[ 2009-10 post-Santa Cruz: ]

> Move to Tentatively Ready.

Proposed resolution:

[ The usage of the notion of a BaseCharacteristic below might be useful in other places - e.g. to define the base class relation in 20.7.5 [refwrap], 20.7.14 [func.memfn], or 20.7.15.2 [func.wrap.func]. In this case it's definition should probably be moved to Clause 17 ]

1. Change 20.6.1 [meta.rqmts]/1 as indicated:

   > [..] It shall be `DefaultConstructible`, `CopyConstructible`, and publicly and unambiguously derived, directly or indirectly, from its BaseCharacteristic, which is a specialization of the template `integral_constant` (20.6.3), with the arguments to the template `integral_constant` determined by the requirements for the particular property being described. The member names of the BaseCharacteristic shall be unhidden and unambiguously available in the UnaryTypeTrait.

2. Change 20.6.1 [meta.rqmts]/2 as indicated:

   > [..] It shall be `DefaultConstructible`, `CopyConstructible`, and publicly and unambiguously derived, directly or indirectly, from an instance its BaseCharacteristic, which is a specialization of the template `integral_constant` (20.6.3), with the arguments to the template `integral_constant` determined by the requirements for the particular relationship being described. The member names of the BaseCharacteristic shall be unhidden and unambiguously available in the BinaryTypeTrait.

3. Change 20.6.4 [meta.unary]/2 as indicated:

   > Each of these templates shall be a UnaryTypeTrait (20.6.1), publicly derived directly or indirectly from `true_type` if the corresponding condition is true, otherwise from `false_type` where its BaseCharacteristic shall be `true_type` if the corresponding condition is true, otherwise `false_type`.

4. Change 20.6.5 [meta.rel]/2 as indicated:

   > Each of these templates shall be a BinaryTypeTrait (20.6.1), publicly derived directly or indirectly from `true_type` if the corresponding condition is true, otherwise from `false_type` where its BaseCharacteristic shall be `true_type` if the corresponding condition is true, otherwise `false_type`.

### 1115. `va_copy` missing from Standard macros table

Section: C.2 [diff.library] Status: Tentatively NAD Editorial Submitter: Miles Zhao Opened: 2009-05-23 Last modified: 2009-10-26

View all other issues in [diff.library].

View all issues with Tentatively NAD Editorial status.

Discussion:

In "Table 122 -- Standard macros" of C.2 [diff.library], which lists the 56 macros inherited from C library, `va_copy` seems to be missing. But in "Table 21 -- Header `<cstdarg>` synopsis" (18.10 [support.runtime]), there is.

[ 2009-10 post-Santa Cruz: ]

> Mark as Tentatively NAD Editorial, if Pete disagrees, Howard will move to Tentatively Ready

Proposed resolution:

Add `va_copy` to Table 122 -- Standard macros in C.2 [diff.library].

### 1118. tuple query APIs do not support cv-qualification

Section: 20.5.2.5 [tuple.helper] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-10-26

View other active issues in [tuple.helper].

View all other issues in [tuple.helper].

View all issues with Open status.

Discussion:

The APIs `tuple_size` and `tuple_element` do not support cv-qualified `tuple`s, `pair`s or `array`s.

The most generic solution would be to supply partial specializations once for each cv-type in the `tuple` header. However, requiring this header for cv-qualified `pair`s/`array`s seems unhelpful. The BSI editorial suggestion (UK-198/US-69, N2533) to merge `tuple` into `<utility>` would help with `pair`, but not `array`. That might be resolved by making a dependency between the `<array>` header and `<utility>`, or simply recognising the dependency be fulfilled in a Remark.

[ 2009-05-24 Daniel adds: ]

> All `tuple_size` templates with a base class need to derive publicly, e.g.

> >     template <IdentityOf T> class tuple_size< const T > :
> >        public tuple_size<T> {};

> The same applies to the tuple_element class hierarchies.

> What is actually meant with the comment

> > this solution relies on 'metafunction forwarding' to inherit the nested typename type

> ?

> I ask, because all base classes are currently unconstrained and their instantiation is invalid in the constrained context of the `tuple_element` partial template specializations.

[ 2009-05-24 Alisdair adds: ]

> I think a better solution might be to ask Pete editorially to change all declarations of tupling APIs to use the struct specifier instead of class.

> "metafunction forwarding" refers to the MPL metafunction protocol, where a metafunction result is declared as a nested typedef with the name "type", allowing metafunctions to be chained by means of inheritance. It is a neater syntax than repeatedly declaring a typedef, and inheritance syntax is slightly nicer when it comes to additional typename keywords.

> The constrained template with an unconstrained base is a good observation though.

[ 2009-10 post-Santa Cruz: ]

> Move to Open, Alisdair to provide wording. Once wording is provided, Howard will move to Review.

Proposed resolution:

Add to 20.5.1 [tuple.general] p2 (Header `<tuple>` synopsis)

>     // 20.5.2.3, tuple helper classes:
>     template <IdentityOf T> class tuple_size; // undefined
>     template <IdentityOf T> class tuple_size< const T > : tuple_size<T> {};
>     template <IdentityOf T> class tuple_size< volatile T > : tuple_size<T> {};
>     template <IdentityOf T> class tuple_size< const volatile T > : tuple_size<T> {};

>     template <VariableType... Types> class tuple_size<tuple<Types...> >;

>     template <size_t I, IdentityOf T> class tuple_element; // undefined
>     template <size_t I, IdentityOf T> class tuple_element<I, const T>;
>     template <size_t I, IdentityOf T> class tuple_element<I, volatile T>;
>     template <size_t I, IdentityOf T> class tuple_element<I, const volatile T>;

>     template <size_t I, VariableType... Types>
>       requires True<(I < sizeof...(Types))> class tuple_element<I, tuple<Types...> >;

Add to 20.5.2.5 [tuple.helper]

[ (note that this solution relies on 'metafunction forwarding' to inherit the nested typename type) ]

>     template <class... Types>
>     class tuple_size<tuple<Types...> >
>       : public integral_constant<size_t, sizeof...(Types)> { };

>     template <size_t I, class... Types>
>     requires True<(I < sizeof...(Types))>
>     class tuple_element<I, tuple<Types...> > {
>     public:
>       typedef TI type;
>     };

>     template <size_t I, IdentityOf T>
>       class tuple_element<I, const T> : add_const<tuple_element<I,T>> {};

>     template <size_t I, IdentityOf T>
>       class tuple_element<I, volatile T> : add_volatile<tuple_element<I,T>> {};

>     template <size_t I, IdentityOf T>
>       class tuple_element<I, const volatile T> : add_cv<tuple_element<I,T>> {};

### 1119. tuple query APIs do not support references

Section: 20.5.2.5 [tuple.helper] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-10-26

View other active issues in [tuple.helper].

View all other issues in [tuple.helper].

View all issues with Open status.

Discussion:

The `tuple` query APIs `tuple_size` and `tuple_element` do not support references-to-tuples. This can be annoying when a template deduced a parameter type to be a reference, which must be explicitly stripped with `remove_reference` before calling these APIs.

I am not proposing a resolution at this point, as there is a combinatorial explosion with lvalue/rvalue references and cv-qualification (see previous issue) that suggests some higher refactoring is in order. This might be something to kick back over to Core/Evolution.

Note that we have the same problem in numeric_limits.

[ 2009-10 post-Santa Cruz: ]

> Move to Open. Alisdair to provide wording.

Proposed resolution:

### 1121. Support for multiple arguments

Section: 20.4.2 [ratio.arithmetic] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-05-25 Last modified: 2009-11-02

View all other issues in [ratio.arithmetic].

View all issues with Tentatively NAD Future status.

Discussion:

Both add and multiply could sensibly be called with more than two arguments. The variadic template facility makes such declarations simple, and is likely to be frequently wrapped by end users if we do not supply the variant ourselves.

We deliberately ignore divide at this point as it is not transitive. Likewise, subtract places special meaning on the first argument so I do not suggest extending that immediately. Both could be supported with analogous wording to that for add/multiply below.

Note that the proposed resolution is potentially incompatible with that proposed for 921, although the addition of the typedef to ratio would be equally useful.

[ 2009-10-30 Alisdair adds: ]

> The consensus of the group when we reviewed this in Santa Cruz was that 921 would proceed to Ready as planned, and the multi-paramater add/multiply templates should be renamed as `ratio_sum` and `ratio_product` to avoid the problem mixing template aliases with partial specializations.

> It was also suggested to close this issue as NAD Future as it does not correspond directly to any NB comment. NBs are free to submit a specific comment (and re-open) in CD2 though.

> Walter Brown also had concerns on better directing the order of evaluation to avoid overflows if we do proceed for 0x rather than TR1, so wording may not be complete yet.

> [ Alisdair updates wording. ]

[ 2009-10-30 Howard: ]

> Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.

Proposed resolution:

Add the following type traits to p3 20.4 [ratio]

>     // ratio arithmetic
>     template <class R1, class R2> struct ratio_add;
>     template <class R1, class R2> struct ratio_subtract;
>     template <class R1, class R2> struct ratio_multiply;
>     template <class R1, class R2> struct ratio_divide;
>     template <class R1, class ... RList> struct ratio_sum;
>     template <class R1, class ... RList> struct ratio_product;

after 20.4.2 [ratio.arithmetic] p1: add

>     template <class R1, class ... RList> struct ratio_sum; // declared, never defined

>     template <class R1> struct ratio_sum<R1> : R1 {};

> > Requires: `R1` is a specialization of class template `ratio`

>     template <class R1, class R2, class ... RList>
>      struct ratio_sum<R1, R2, RList...>
>        : ratio_add< R1, ratio_sum<R2, RList...>> {
>     };

> > Requires: `R1` and each element in parmater pack `RList` is a specialization of class template `ratio`

after 20.4.2 [ratio.arithmetic] p3: add

>     template <class R1, class ... RList> struct ratio_product; // declared, never defined

>     template <class R1> struct ratio_product<R1> : R1 {};

> > Requires: `R1` is a specialization of class template `ratio`

>     template <class R1, class R2, class ... RList>
>      struct ratio_sum<R1, R2, RList...>
>        : ratio_add< R1, ratio_product<R2, RList...>> {
>     };

> > Requires: `R1` and each element in parmater pack `RList` is a specialization of class template `ratio`

### 1123. no requirement that standard streams be flushed

Section: 27.5.2.1.6 [ios::Init] Status: Ready Submitter: James Kanze Opened: 2009-05-14 Last modified: 2009-10-20

View all other issues in [ios::Init].

View all issues with Ready status.

Discussion:

As currently formulated, the standard doesn't require that there is ever a flush of `cout`, etc. (This implies, for example, that the classical hello, world program may have no output.) In the current draft (N2798), there is a requirement that the objects be constructed before `main`, and before the dynamic initialization of any non-local objects defined after the inclusion of `<iostream>` in the same translation unit. The only requirement that I can find concerning flushing, however, is in 27.5.2.1.6 [ios::Init], where the destructor of the last `std::ios_base::Init` object flushes. But there is, as far as I can see, no guarantee that such an object ever exists.

Also, the wording in [iostreams.objects] says that:

> The objects are constructed and the associations are established at some time prior to or during the first time an object of class `ios_base::Init` is constructed, and in any case before the body of main begins execution.

In 27.5.2.1.6 [ios::Init], however, as an effect of the constructor, it says that

> If `init_cnt` is zero, the function stores the value one in `init_cnt`, then constructs and initializes the objects `cin`, `cout`, `cerr`, `clog` `wcin`, `wcout`, `wcerr`, and `wclog`"

which seems to forbid earlier construction.

(Note that with these changes, the exposition only "`static int init_cnt`" in `ios_base::Init` can be dropped.)

Of course, a determined programmer can still inhibit the flush with things like:

>     new std::ios_base::Init ;       //  never deleted

or (in a function):

>     std::ios_base::Init ensureConstruction ;
>     //  ...
>     exit( EXIT_SUCCESS ) ;

Perhaps some words somewhere to the effect that all `std::ios_base::Init` objects should have static lifetime would be in order.

[ 2009 Santa Cruz: ]

> Moved to Ready. Some editorial changes are expected (in addition to the proposed wording) to remove `init_cnt` from `Init`.

Proposed resolution:

Change 27.4 [iostream.objects]/2:

> -2- The objects are constructed and the associations are established at some time prior to or during the first time an object of class `ios_base::Init` is constructed, and in any case before the body of main begins execution.292 The objects are not destroyed during program execution.293 If a translation unit includes `<iostream>` or explicitly constructs an `ios_base::Init` object, these stream objects shall be constructed before dynamic initialization of non-local objects defined later in that translation unit. The results of including `<iostream>` in a translation unit shall be as if `<iostream>` defined an instance of `ios_base::Init` with static lifetime. Similarly, the entire program shall behave as if there were at least one instance of `ios_base::Init` with static lifetime.

Change 27.5.2.1.6 [ios::Init]/3:

>     Init();

> > -3- Effects: Constructs an object of class `Init`. If `init_cnt` is zero, the function stores the value one in `init_cnt`, then constructs and initializes the objects `cin`, `cout`, `cerr`, `clog` (27.4.1), `wcin`, `wcout`, `wcerr`, and `wclog` (27.4.2). In any case, the function then adds one to the value stored in `init_cnt`. Constructs and initializes the objects `cin`, `cout`, `cerr`, `clog`, `wcin`, `wcout`, `wcerr` and `wclog` if they have not already been constructed and initialized.

Change 27.5.2.1.6 [ios::Init]/4:

>     ~Init();

> > -4- Effects: Destroys an object of class `Init`. The function subtracts one from the value stored in `init_cnt` and, if the resulting stored value is one, If there are no other instances of the class still in existance, calls `cout.flush()`, `cerr.flush()`, `clog.flush()`, `wcout.flush()`, `wcerr.flush()`, `wclog.flush()`.

### 1125. ostream_iterator does not work with movable types

Section: 24.6.2.2 [ostream.iterator.ops] Status: New Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2009-05-30

View all issues with New status.

Discussion:

`ostream_iterator` has not been updated to support moveable types, in a similar manner to the insert iterators. Note that this is not a problem for `ostreambuf_iterator`, as the types it is restricted to dealing with do not support extra-efficient moving.

Proposed resolution:

Add second `operator=` overload to class `template ostream_iterator` in 24.6.2 [ostream.iterator], para 2:

>     ostream_iterator<T,charT,traits>& operator=(const T& value);
>     ostream_iterator<T,charT,traits>& operator=(T&& value);

Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]:

>     ostream_iterator& operator=(T&& value);

> > -2- Effects:

> > >     *out_stream << std::move(value);
> > >     if(delim != 0)
> > >       *out_stream << delim;
> > >     return (*this);

### 1126. `istreambuff_iterator::equal` needs a const & parameter

Section: 24.6.3.5 [istreambuf.iterator::equal] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2009-11-02

View all other issues in [istreambuf.iterator::equal].

View all issues with Tentatively Ready status.

Discussion:

The `equal` member function of `istreambuf_iterator` is declared `const`, but takes its argument by non-const reference.

This is not compatible with the `operator==` free function overload, which is defined in terms of calling `equal` yet takes both arguments by reference to const.

[ The proposed wording is consistent with 110 with status TC1. ]

[ 2009-11-02 Howard adds: ]

> Set to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Ammend in both:
24.6.3 [istreambuf.iterator]
24.6.3.5 [istreambuf.iterator::equal]

>     bool equal(const istreambuf_iterator& b) const;

### 1130. `copy_exception` name misleading

Section: 18.8.5 [propagation] Status: Review Submitter: Peter Dimov Opened: 2009-05-13 Last modified: 2009-10-20

View other active issues in [propagation].

View all other issues in [propagation].

View all issues with Review status.

Discussion:

The naming of `std::copy_exception` misleads almost everyone (experts included!) to think that it is the function that copies an `exception_ptr`:

>     exception_ptr p1 = current_exception();
>     exception_ptr p2 = copy_exception( p1 );

But this is not at all what it does. The above actually creates an `exception_ptr p2` that contains a copy of `p1`, not of the exception to which `p1` refers!

This is, of course, all my fault; in my defence, I used `copy_exception` because I was unable to think of a better name.

But I believe that, based on what we've seen so far, any other name would be better.

Therefore, I propose `copy_exception` to be renamed to `create_exception`:

>     template<class E> exception_ptr create_exception(E e);

with the following explanatory paragraph after it:

> Creates an `exception_ptr` that refers to a copy of `e`.

[ 2009-05-13 Daniel adds: ]

> What about

> >     make_exception_ptr

> in similarity to `make_pair` and `make_tuple`, `make_error_code` and `make_error_condition`, or `make_shared`? Or, if a stronger symmetry to `current_exception` is preferred:

> >     make_exception

> We have not a single `create_*` function in the library, it was always `make_*` used.

[ 2009-05-13 Peter adds: ]

> `make_exception_ptr` works for me.

[ 2009-06-02 Thomas J. Gritzan adds: ]

> To avoid surprises and unwanted recursion, how about making a call to `std::make_exception_ptr` with an `exception_ptr` illegal?

> It might work like this:

> >     template<class E>
> >     exception_ptr make_exception_ptr(E e);
> >     template<>
> >     exception_ptr make_exception_ptr<exception_ptr>(exception_ptr e) = delete;

[ 2009 Santa Cruz: ]

> Move to Review for the time being. The subgroup thinks this is a good idea, but doesn't want to break compatibility unnecessarily if someone is already shipping this. Let's talk to Benjamin and PJP tomorrow to make sure neither objects.

Proposed resolution:

Change 18.8.5 [propagation]:

>     template<class E> exception_ptr copy_exceptionmake_exception_ptr(E e);

> > -11- Effects: Creates an `exception_ptr` that refers to a copy of `e`, as if

> > >     try {
> > >       throw e;
> > >     } catch(...) {
> > >       return current_exception();
> > >     }

> > ...

### 1131. C++0x does not need `alignment_of`

Section: 20.6.4.3 [meta.unary.prop] Status: New Submitter: Niels Dekker Opened: 2009-06-01 Last modified: 2009-06-02

View other active issues in [meta.unary.prop].

View all other issues in [meta.unary.prop].

View all issues with New status.

Discussion:

The `alignment_of` template is no longer necessary, now that the core language will provide `alignof`. Scott Meyers raised this issue at comp.std.c++, C++0x: alignof vs. alignment_of, May 21, 2009. In a reply, Daniel Krügler pointed out that `alignof` was added to the working paper after `alignment_of`. So it appears that `alignment_of` is only part of the current Working Draft (N2857) because it is in TR1.

Having both `alignof` and `alignment_of` would cause unwanted confusion. In general, I think TR1 functionality should not be brought into C++0x if it is entirely redundant with other C++0x language or library features.

Proposed resolution:

Remove from Header <type_traits> synopsis 20.6.2 [meta.type.synop]:

>     template <class T> struct alignment_of;

Remove the first row of Table 34 ("Type property queries"), from Type properties 20.6.4.3 [meta.unary.prop]:

> Table 34 -- Type property queries
> `template <class T> struct alignment_of;` | `alignof(T)`. Precondition: `T` shall be a complete type, a reference type, or an array of unknown bound, but shall not be a function type or (possibly cv-qualified) `void`.

Change text in Table 41 ("Other transformations"), from Other transformations 20.6.7 [meta.trans.other], as follows:

> Table 41 -- Other transformations
> ... | Align shall be equal to `alignment_of<T>::value alignof(T)` for some type `T` or to default-alignment. | ...

### 1133. Does N2844 break current specification of list::splice?

Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: New Submitter: Alisdair Meredith Opened: 2009-05-09 Last modified: 2009-10-27

View all other issues in [forwardlist.ops].

View all issues with New status.

Discussion:

IIUC, N2844 means that lvalues will no longer bind to rvalue references. Therefore, the current specification of `list::splice` (list operations 23.3.4.4 [list.ops]) will be a breaking change of behaviour for existing programs. That is because we changed the signature to swallow via an rvalue reference rather than the lvalue reference used in 03.

Retaining this form would be safer, requiring an explicit move when splicing from lvalues. However, this will break existing programs. We have the same problem with `forward_list`, although without the risk of breaking programs so here it might be viewed as a positive feature.

The problem signatures:

>     void splice_after(const_iterator position, forward_list<T,Alloc>&& x);
>     void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
>                       const_iterator i);
>     void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
>                       const_iterator first, const_iterator last);

>     void splice(const_iterator position, list<T,Alloc>&& x);
>     void splice(const_iterator position, list<T,Alloc>&& x,
>                 const_iterator i);
>     void splice(const_iterator position, list<T,Alloc>&& x,
>                 const_iterator first, const_iterator last);

Possible resolutions:

Option A. Add an additional (non-const) lvalue-reference overload in each case

Option B. Change rvalue reference back to (non-const) lvalue-reference overload in each case

Option C. Add an additional (non-const) lvalue-reference overload in just the `std::list` cases

I think (B) would be very unfortunate, I really like the `forward_list` behaviour in (C) but feel (A) is needed for consistency.

My actual preference would be NAD, ship with this as a breaking change as it is a more explicit interface. I don't think that will fly though!

See the thread starting with c++std-lib-23725 for more discussion.

[ 2009-10-27 Christopher Jefferson provides proposed wording for Option C. ]

Proposed resolution:

In 23.3.4 [list]

Add lvalue overloads before rvalue ones:

>     void splice(const_iterator position, list<T,Allocator>& x);
>     void splice(const_iterator position, list<T,Allocator>&& x);
>     void splice(const_iterator position, list<T,Allocator>& x, const_iterator i);
>     void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);
>     void splice(const_iterator position, list<T,Allocator>& x,
>                 const_iterator first, const_iterator last);
>     void splice(const_iterator position, list<T,Allocator>&& x,
>                 const_iterator first, const_iterator last);

In 23.3.4.4 [list.ops], similarly add lvalue overload before each rvalue one:

(After paragraph 2)

>     void splice(const_iterator position, list<T,Allocator>& x);
>     void splice(const_iterator position, list<T,Allocator>&& x);

(After paragraph 6)

>     void splice(const_iterator position, list<T,Allocator>& x, const_iterator i);
>     void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);

(After paragraph 10)

>     void splice(const_iterator position, list<T,Allocator>& x,
>                 const_iterator first, const_iterator last);
>     void splice(const_iterator position, list<T,Allocator>&& x,
>                 const_iterator first, const_iterator last);

### 1134. Redundant specification of stdint.h, fenv.h, tgmath.h, and maybe complex.h

Section: 18.4.2 [stdinth], 26.3.2 [fenv], 26.8 [c.math], 26.4.11 [cmplxh] Status: Ready Submitter: Robert Klarer Opened: 2009-05-26 Last modified: 2009-10-20

View all issues with Ready status.

Discussion:

This is probably editorial.

The following items should be removed from the draft, because they're redundant with Annex D, and they arguably make some *.h headers non-deprecated:

18.4.2 [stdinth] (regarding `<stdint.h>`)

26.3.2 [fenv] (regarding `<fenv.h>`

Line 3 of 26.8 [c.math] (regarding `<tgmath.h>`)

26.4.11 [cmplxh] (regarding `<complex.h>`, though the note in this subclause is not redundant)

[ 2009-06-10 Ganesh adds: ]

> While searching for `stdint` in the CD, I found that `<stdint.h>` is also mentioned in 3.9.1 [basic.fundamental] /5. It guess it should refer to `<cstdint>` instead.

[ 2009 Santa Cruz: ]

> Real issue. Maybe just editorial, maybe not. Move to Ready.

Proposed resolution:

Remove the section 18.4.2 [stdinth].

Remove the section 26.3.2 [fenv].

Remove 26.8 [c.math], p3:

> -3- The header `<tgmath.h>` effectively includes the headers `<complex.h>` and `<math.h>`.

Remove the section 26.4.11 [cmplxh].

### 1135. `exception_ptr` should support contextual conversion to `bool`

Section: 18.8.5 [propagation] Status: Ready Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-10-20

View other active issues in [propagation].

View all other issues in [propagation].

View all issues with Ready status.

Discussion:

As of N2857 18.8.5 [propagation]/5, the implementation-defined type `exception_ptr` does provide the following ways to check whether it is a null value:

>     void f(std::exception_ptr p) {
>       p == nullptr;
>       p == 0;
>       p == exception_ptr();
>     }

This is rather cumbersome way of checking for the null value and I suggest to require support for evaluation in a boolean context like so:

>     void g(std::exception_ptr p) {
>       if (p) {}
>       !p;
>     }

[ 2009 Santa Cruz: ]

> Move to Ready. Note to editor: considering putting in a cross-reference to 4 [conv], paragraph 3, which defines the phrase "contextually converted to `bool`".

Proposed resolution:

In section 18.8.5 [propagation] insert a new paragraph between p.5 and p.6:

> An object `e` of type `exception_ptr` can be contextually converted to `bool`. The effect shall be as if `e != exception_ptr()` had been evaluated in place of `e`. There shall be no implicit conversion to arithmetic type, to enumeration type or to pointer type.

### 1136. Incomplete specification of `nested_exception::rethrow_nested()`

Section: 18.8.6 [except.nested] Status: Ready Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-10-20

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with Ready status.

Discussion:

It was recently mentioned in a newsgroup article http://groups.google.de/group/comp.std.c++/msg/f82022aff68edf3d that the specification of the member function `rethrow_nested()` of the class `nested_exception` is incomplete, specifically it remains unclear what happens, if member `nested_ptr()` returns a null value. In 18.8.6 [except.nested] we find only the following paragraph related to that:

>     void rethrow_nested() const; // [[noreturn]]

> > -4- Throws: the stored exception captured by this `nested_exception` object.

This is a problem, because it is possible to create an object of `nested_exception` with exactly such a state, e.g.

>     #include <exception>
>     #include <iostream>

>     int main() try {
>       std::nested_exception e; // OK, calls current_exception() and stores it's null value
>       e.rethrow_nested(); // ?
>       std::cout << "A" << std::endl;
>     }
>     catch(...) {
>       std::cout << "B" << std::endl;
>     }

I suggest to follow the proposal of the reporter, namely to invoke `terminate()` if `nested_ptr()` return a null value of `exception_ptr` instead of relying on the fallback position of undefined behavior. This would be consistent to the behavior of a `throw;` statement when no exception is being handled.

[ 2009 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Change around 18.8.6 [except.nested]/4 as indicated:

> -4- Throws: the stored exception captured by this `nested_exception` object, if `nested_ptr() != nullptr`

> - Remarks: If `nested_ptr() == nullptr`, `terminate()` shall be called.

### 1137. Return type of `conj` and `proj`

Section: 26.4.9 [cmplx.over] Status: New Submitter: Marc Steinbach Opened: 2009-06-11 Last modified: 2009-06-27

View all other issues in [cmplx.over].

View all issues with New status.

Discussion:

In clause 1, the Working Draft (N2857) specifies overloads of the functions

>     arg, conj, imag, norm, proj, real

for non-complex arithmetic types (`float`, `double`, `long double`, and integers). The only requirement (clause 2) specifies effective type promotion of arguments.

I strongly suggest to add the following requirement on the return types:

> All the specified overloads must return real (i.e., non-complex) values, specifically, the nested `value_type` of effectively promoted arguments.

(This has no effect on `arg`, `imag`, `norm`, `real`: they are real-valued anyway.)

Rationale:

Mathematically, `conj()` and `proj()`, like the transcendental functions, are complex-valued in general but map the (extended) real line to itself. In fact, both functions act as identity on the reals. A typical user will expect `conj()` and `proj()` to preserve this essential mathematical property in the same way as `exp()`, `sin()`, etc. A typical use of `conj()`, e.g., is the generic scalar product of n-vectors:

>     template<typename T>
>     inline T
>     scalar_product(size_t n, T const* x, T const* y) {
>       T result = 0;
>       for (size_t i = 0; i < n; ++i)
>         result += x[i] * std::conj(y[i]);
>       return result;
>     }

This will work equally well for real and complex floating-point types `T` if `conj()` returns `T`. It will not work with real types if `conj()` returns complex values.

Instead, the implementation of `scalar_product` becomes either less efficient and less useful (if a complex result is always returned), or unnecessarily complicated (if overloaded versions with proper return types are defined). In the second case, the real-argument overload of `conj()` cannot be used. In fact, it must be avoided.

Overloaded `conj()` and `proj()` are principally needed in generic programming. All such use cases will benefit from the proposed return type requirement, in a similar way as the `scalar_product` example. The requirement will not harm use cases where a complex return value is expected, because of implicit conversion to complex. Without the proposed return type guarantee, I find overloaded versions of `conj()` and `proj()` not only useless but actually troublesome.

Proposed resolution:

Insert a new paragraph after 26.4.9 [cmplx.over]/2:

> All of the specified overloads shall have a return type which is the nested `value_type` of the effectively promoted arguments.

### 1138. unusual return value for operator+

Section: 21.4.8.1 [string::op+] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-06-12 Last modified: 2009-11-05

View all issues with Tentatively Ready status.

Discussion:

Many of the `basic_string operator+` overloads return an rvalue-reference. Is that really intended?

I'm considering it might be a mild performance tweak to avoid making un-necessary copies of a cheaply movable type, but it opens risk to dangling references in code like:

>     auto && s = string{"x"} + string{y};

and I'm not sure about:

>     auto s = string{"x"} + string{y};

[ 2009-10-11 Howard updated Returns: clause for each of these. ]

[ 2009-11-05 Howard adds: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Strike the `&&` from the return type in the following function signatures:

> 21.3 [string.classes] p2 Header Synopsis

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   const basic_string<charT,traits,Allocator>& rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(const basic_string<charT,traits,Allocator>& lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(const charT* lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   const charT* rhs);

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);

> 21.4.8.1 [string::op+]

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   const basic_string<charT,traits,Allocator>& rhs);

> > > Returns: `std::move(lhs.append(rhs))`

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(const basic_string<charT,traits,Allocator>& lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> > > Returns: `std::move(rhs.insert(0, lhs))`

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> > > Returns: `std::move(lhs.append(rhs))` [Note: Or equivalently `std::move(rhs.insert(0, lhs))` — end note]

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(const charT* lhs,
> >                   basic_string<charT,traits,Allocator>&& rhs);

> > > Returns: `std::move(rhs.insert(0, lhs))`.

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);

> > > Returns: `std::move(rhs.insert(0, 1, lhs))`.

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs,
> >                   const charT* rhs);

> > > Returns: `std::move(lhs.append(rhs))`.

> >     template<class charT, class traits, class Allocator>
> >       basic_string<charT,traits,Allocator>&&
> >         operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);

> > > Returns: `std::move(lhs.append(1, rhs))`.

### 1144. "thread safe" is undefined

Section: 18.5 [support.start.term] Status: Ready Submitter: LWG Opened: 2009-06-16 Last modified: 2009-10-20

View all other issues in [support.start.term].

View all issues with Ready status.

Discussion:

Addresses UK 187

The term "thread safe" is not defined nor used in this context anywhere else in the standard.

Suggested action:

Clarify the meaning of "thread safe".

[ 2009 Santa Cruz: ]

> The "thread safe" language has already been change in the WP. It was changed to "happen before", but the current WP text is still a little incomplete: "happen before" is binary, but the current WP text only mentions one thing.

> Move to Ready.

Proposed resolution:

For the following functions in 18.5 [support.start.term].

>     extern "C" int at_quick_exit(void (*f)(void));
>     extern "C++" int at_quick_exit(void (*f)(void));

Edit paragraph 10 as follows. The intent is to provide the other half of the happens before relation; to note indeterminate ordering; and to clean up some formatting.

> Effects: The `at_quick_exit()` functions register the function pointed to by `f` to be called without arguments when `quick_exit` is called. It is unspecified whether a call to `at_quick_exit()` that does not happen-before happen before (1.10) all calls to `quick_exit` will succeed. [Note: the `at_quick_exit()` functions shall not introduce a data race (17.6.4.7). exitnote —end note] [Note: The order of registration may be indeterminate if `at_quick_exit` was called from more than one thread. —end note] [Note: The `at_quick_exit` registrations are distinct from the `atexit` registrations, and applications may need to call both registration functions with the same argument. —end note]

For the following function.

>     void quick_exit [[noreturn]] (int status)

Edit paragraph 13 as follows. The intent is to note that thread-local variables may be different.

> Effects: Functions registered by calls to `at_quick_exit` are called in the reverse order of their registration, except that a function shall be called after any previously registered functions that had already been called at the time it was registered. Objects shall not be destroyed as a result of calling `quick_exit`. If control leaves a registered function called by `quick_exit` because the function does not provide a handler for a thrown exception, `terminate()` shall be called. [Note: Functions registered by one thread may be called by any thread, and hence should not rely on the identity of thread-storage-duration objects. —end note] After calling registered functions, `quick_exit` shall call `_Exit(status)`. [Note: The standard file buffers are not flushed. See: ISO C 7.20.4.4. —end note]

### 1151. Behavior of the library in the presence of threads is incompletely specified

Section: 17 [library] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-20

View other active issues in [library].

View all other issues in [library].

View all issues with Open status.

Discussion:

Addresses US 63

Description

The behavior of the library in the presence of threads is incompletely specified.

For example, if thread 1 assigns to `X`, then writes data to file `f`, which is read by thread 2, and then accesses variable `X`, is thread 2 guaranteed to be able to see the value assigned to `X` by thread 1? In other words, does the write of the data "happen before" the read?

Another example: does simultaneous access using `operator at()` to different characters in the same non-const string really introduce a data race?

Suggestion

Notes

17 SG: should go to threads group; misclassified in document

Concurrency SG: Create an issue. Hans will look into it.

[ 2009 Santa Cruz: ]

> Move to "Open". Hans and the rest of the concurrency working group will study this. We can't make progress without a thorough review and a paper.

Proposed resolution:

### 1152. expressions parsed differently than intended

Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Tentatively Ready Submitter: Seungbeom Kim Opened: 2009-06-27 Last modified: 2009-10-28

View other active issues in [facet.num.put.virtuals].

View all other issues in [facet.num.put.virtuals].

View all issues with Tentatively Ready status.

Discussion:

In Table 73 -- Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals], in N2914, we have the following entries:

Table 73 — Floating-point conversions
State | `stdio` equivalent
--- | ---
`floatfield == ios_base::fixed | ios_base::scientific && !uppercase` | `%a`
`floatfield == ios_base::fixed | ios_base::scientific` | `%A`

These expressions are supposed to mean:

>     floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase
>     floatfield == (ios_base::fixed | ios_base::scientific)

but technically parsed as:

>     ((floatfield == ios_base::fixed) | ios_base::scientific) && (!uppercase)
>     ((floatfield == ios_base::fixed) | ios_base::scientific)

and should be corrected with additional parentheses, as shown above.

[ 2009-10-28 Howard: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Change Table 83 — Floating-point conversions in 22.4.2.2.2 [facet.num.put.virtuals]:

Table 83 — Floating-point conversions
State | `stdio` equivalent
--- | ---
`floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase` | `%a`
`floatfield == (ios_base::fixed | ios_base::scientific)` | `%A`

### 1153. Standard library needs review for constructors to be explicit to avoid treatment as initializer-list constructor

Section: 17 [library], 30 [thread], D [depr] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-20

View other active issues in [library].

View all other issues in [library].

View all issues with Open status.

Discussion:

Addresses DE 2

Description

Marking a constructor with `explicit` has semantics even for a constructor with zero or several parameters: Such a constructor cannot be used with list-initialization in a copy-initialization context, see 13.3.1.7 [over.match.list]. The standard library apparently has not been reviewed for marking non-single-parameter constructors as `explicit`.

Suggestion

Consider marking zero-parameter and multi-parameter constructors `explicit` in classes that have at least one constructor marked `explicit` and that do not have an initializer-list constructor.

Notes

Robert Klarer to address this one.

[ 2009 Santa Cruz: ]

> Move to "Open". Robert Klarer has promised to provide wording.

Proposed resolution:

### 1154. `complex` should accept integral types

Section: 26.4 [complex.numbers] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-26

View all other issues in [complex.numbers].

View all issues with New status.

Discussion:

Addresses FR 35

Description

Instantiations of the class template `complex<>` have to be allowed for integral types, to reflect existing practice and ISO standards (LIA-III).

Suggestion

[ 2009-10-26 Proposed wording in N3002. ]

Proposed resolution:

Adopt N3002.

### 1156. Constraints on bitmask and enumeration types to be tightened

Section: 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-27

View all issues with Open status.

Discussion:

Addresses UK 165

Description

Constraints on bitmask and enumeration types were supposed to be tightened up as part of the motivation for the `constexpr` feature - see paper N2235 for details

Suggestion

Adopt wording in line with the motivation described in N2235

Notes

Robert Klarer to review

[ 2009 Santa Cruz: ]

> Move to Open. Ping Robert Klarer to provide wording, using N2235 as guidance.

Proposed resolution:

### 1157. Local types can now instantiate templates

Section: 17.6.3.2.1 [namespace.std] Status: Ready Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-21

View all issues with Ready status.

Discussion:

Addresses UK 175

Description

Local types can now be used to instantiate templates, but don't have external linkage.

Suggestion

Remove the reference to external linkage.

Notes

We accept the proposed solution. Martin will draft an issue.

[ 2009-07-28 Alisdair provided wording. ]

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

17.6.3.2.1 [namespace.std]

Strike "of external linkage" in p1 and p2:

> -1- The behavior of a C++ program is undefined if it adds declarations or definitions to namespace `std` or to a namespace within namespace `std` unless otherwise specified. A program may add a concept map for any standard library concept or a template specialization for any standard library template to namespace `std` only if the declaration depends on a user-defined type of external linkage and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.179

> -2- The behavior of a C++ program is undefined if it declares

> - an explicit specialization of any member function of a standard library class template, or
> - an explicit specialization of any member function template of a standard library class or class template, or
> - an explicit or partial specialization of any member class template of a standard library class or class template.

> A program may explicitly instantiate a template defined in the standard library only if the declaration depends on the name of a user-defined type of external linkage and the instantiation meets the standard library requirements for the original template.

### 1158. Encouragement to use monotonic clock

Section: 30.2.4 [thread.req.timing] Status: Tentatively Ready Submitter: LWG Opened: 2009-06-28 Last modified: 2009-10-31

View all issues with Tentatively Ready status.

Discussion:

Addresses UK 322, US 96

Description

Not all systems can provide a monotonic clock. How are they expected to treat a _for function?

Suggestion

Add at least a note explaining the intent for systems that do not support a monotonic clock.

Notes

Create an issue, together with UK 96. Note that the specification as is already allows a non-monotonic clock due to the word “should” rather than “shall”. If this wording is kept, a footnote should be added to make the meaning clear.

[ 2009-06-29 Beman provided a proposed resolution. ]

[ 2009-10-31 Howard adds: ]

> Set to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Change Timing specifications 30.2.4 [thread.req.timing] as indicated:

The member functions whose names end in `_for` take an argument that specifies a relative time. Implementations should are encouraged but not required to use a monotonic clock to measure time for these functions.

### 1159. Unclear spec for `resource_deadlock_would_occur`

Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-04

View other active issues in [thread.lock.unique.locking].

View all other issues in [thread.lock.unique.locking].

View all issues with New status.

Discussion:

Addresses UK 327, UK 328

UK 327 Description

Not clear what the specification for error condition `resource_deadlock_would_occur` means. It is perfectly possible for this thread to own the mutex without setting owns to true on this specific lock object. It is also possible for lock operations to succeed even if the thread does own the mutex, if the mutex is recursive. Likewise, if the mutex is not recursive and the mutex has been locked externally, it is not always possible to know that this error condition should be raised, depending on the host operating system facilities. It is possible that 'i.e.' was supposed to be 'e.g.' and that suggests that recursive locks are not allowed. That makes sense, as the exposition-only member owns is boolean and not a integer to count recursive locks.

UK 327 Suggestion

Add a precondition `!owns`. Change the 'i.e.' in the error condition to be 'e.g.' to allow for this condition to propogate deadlock detection by the host OS.

UK 327 Notes

Create an issue. Assigned to Lawrence Crowl. Note: not sure what try_lock means for recursive locks when you are the owner. POSIX has language on this, which should ideally be followed. Proposed fix is not quite right, for example, try_lock should have different wording from lock.

UK 328 Description

There is a missing precondition that `owns` is true, or an `if(owns)` test is missing from the effect clause

UK 328 Suggestion

Add a precondition that `owns == true`. Add an error condition to detect a violation, rather than yield undefined behaviour.

UK 328 Notes

Handle in same issue as UK 327. Also uncertain that the proposed resolution is the correct one.

Proposed resolution:

### 1169. `num_get` not fully compatible with `strto*`

Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: New Submitter: Cosmin Truta Opened: 2009-07-04 Last modified: 2009-07-07

View other active issues in [facet.num.get.virtuals].

View all other issues in [facet.num.get.virtuals].

View all issues with New status.

Discussion:

As specified in the latest draft, N2914, `num_get` is still not fully compatible with the following C functions: `strtoul`, `strtoull`, `strtof` and `strtod`.

In C, when conversion of a string to an unsigned integer type falls outside the representable range, `strtoul` and `strtoull` return `ULONG_MAX` and `ULLONG_MAX`, respectively, regardless whether the input field represents a positive or a negative value. On the other hand, the result of `num_get` conversion of negative values to unsigned integer types is zero. This raises a compatibility issue.

Moreover, in C, when conversion of a string to a floating-point type falls outside the representable range, `strtof`, `strtod` and `strtold` return `±HUGE_VALF`, `±HUGE_VAL` and `±HUGE_VALL`, respectively. On the other hand, the result of `num_get` conversion of such out-of-range floating-point values results in the most positive/negative representable value. Although many C library implementations do implement `HUGE_VAL` (etc.) as the highest representable (which is, usually, the infinity), this isn't required by the C standard. The C library specification makes no statement regarding the value of `HUGE_VAL` and friends, which potentially raises the same compatibility issue as in the above case of unsigned integers. In addition, neither C nor C++ define symbolic constants for the maximum representable floating-point values (they only do so only for the maximum representable finite floating-point values), which raises a usability issue (it would be hard for the programmer to check the result of `num_get` against overflow).

As such, we propose to adjust the specification of `num_get` to closely follow the behavior of all of its underlying C functions.

Proposed resolution:

Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:

> Stage 3: The sequence of `char`s accumulated in stage 2 (the field) is converted to a numeric value by the rules of one of the functions declared in the header `<cstdlib>`:

> - For a signed integer value, the function `strtoll`.
> - For an unsigned integer value, the function `strtoull`.
> - For a `float` value, the function `strtof`.
> - For a `double` value, the function `strtod`.
> - For a floating-point `long double` value, the function `strtold`.

> The numeric value to be stored can be one of:

> - zero, if the conversion function fails to convert the entire field. `ios_base::failbit` is assigned to `err`.
> - the most positive (or negative) representable value, if the field to be converted to a signed integer type represents a value too large positive (or negative) to be represented in `val`. `ios_base::failbit` is assigned to `err`.
> - the most negative representable value or zero for an unsigned integer type, if the field represents a value too large negative to be represented in `val`. `ios_base::failbit` is assigned to `err`.
> - the most positive representable value, if the field to be converted to an unsigned integer type represents a value that cannot be represented in `val`.
> - the converted value, otherwise.

> The resultant numeric value is stored in `val`. If the conversion function fails to convert the entire field, or if the field represents a value outside the range of representable values, `ios_base::failbit` is assigned to `err`.

### 1170. String char-like types no longer PODs

Section: 21.1 [strings.general] Status: New Submitter: Beman Dawes Opened: 2009-06-22 Last modified: 2009-11-04

View all issues with New status.

Discussion:

Addresses UK 218

Prior to the introduction of constant expressions into the library, `basic_string` elements had to be POD types, and thus had to be both trivially copyable and standard-layout. This ensured that they could be memcpy'ed and would be compatible with other libraries and languages, particularly the C language and its library.

N2349, Constant Expressions in the Standard Library Revision 2, changed the requirement in 21/1 from "POD type" to "literal type". That change had the effect of removing the trivially copyable and standard-layout requirements from `basic_string` elements.

This means that `basic_string` elements no longer are guaranteed to be memcpy'able, and are no longer guaranteed to be standard-layout types:

> 3.9/p2 and 3.9/p3 both make it clear that a "trivially copyable type" is required for memcpy to be guaranteed to work.

> Literal types (3.9p12) may have a non-trivial copy assignment operator, and that violates the trivially copyable requirements given in 9/p 6, bullet item 2.

> Literal types (3.9p12) have no standard-layout requirement, either.

This situation probably arose because the wording for "Constant Expressions in the Standard Library" was in process at the same time the C++ POD deconstruction wording was in process.

Since trivially copyable types meet the C++0x requirements for literal types, and thus work with constant expressions, it seems an easy fix to revert the `basic_string` element wording to its original state.

[ 2009-07-28 Alisdair adds: ]

> When looking for any resolution for this issue, consider the definition of "character container type" in 17.3.4 [defns.character.container]. This does require the character type to be a POD, and this term is used in a number of places through clause 21 and 28. This suggests the PODness constraint remains, but is much more subtle than before. Meanwhile, I suspect the change from POD type to literal type was intentional with the assumption that trivially copyable types with non-trivial-but-constexpr constructors should serve as well. I don't believe the current wording offers the right guarantees for either of the above designs.

[ 2009-11-04 Howard modifies proposed wording to disallow array types as char-like types. ]

Proposed resolution:

Change General 21.1 [strings.general] as indicated:

> This Clause describes components for manipulating sequences of any literal non-array POD (3.9) type. In this Clause such types are called char-like types, and objects of char-like types are called char-like objects or simply characters.

### 1171. duration types should be literal

Section: 20.9.3 [time.duration] Status: Open Submitter: Alisdair Meredith Opened: 2009-07-06 Last modified: 2009-10-31

View other active issues in [time.duration].

View all other issues in [time.duration].

View all issues with Open status.

Discussion:

The `duration` types in 20.9.3 [time.duration] are exactly the sort of type that should be "literal types" in the new standard. Likewise, arithmetic operations on `duration`s should be declared `constexpr`.

[ 2009-09-21 Daniel adds: ]

> An alternative (and possibly preferable solution for potentially heap-allocating big_int representation types) would be to ask the core language to allow references to `const` literal types as feasible arguments for `constexpr` functions.

[ 2009-10-30 Alisdair adds: ]

> I suggest this issue moves from New to Open.

> Half of this issue was dealt with in paper n2994 on constexpr constructors.

> The other half (duration arithmetic) is on hold pending Core support for `const &` in `constexpr` functions.

Proposed resolution:

Add `constexpr` to declaration of following functions and constructors:

p1 20.9 [time]

> Header `<chrono>` synopsis

> [Draughting note - observe switch to pass-by-value to support constexpr]

>     // duration arithmetic
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
>        constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
>        constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period, class Rep2>
>        duration<typename common_type<Rep1, Rep2>::type, Period>
>        constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
>     template <class Rep1, class Period, class Rep2>
>        duration<typename common_type<Rep1, Rep2>::type, Period>
>        constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
>     template <class Rep1, class Period, class Rep2>
>        duration<typename common_type<Rep1, Rep2>::type, Period>
>        constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        typename common_type<Rep1, Rep2>::type
>        constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

>     // duration comparisons
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>        constexpr bool operator>=(const  duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

>     // duration_cast
>     template <class ToDuration, class Rep, class Period>
>        constexpr ToDuration duration_cast(const duration<Rep, Period>& d);

> 20.9.3 [time.duration]

>     template <class Rep, class Period = ratio<1>>
>     class duration {
>       ....
>     public:
>       // 20.9.3.1, construct/copy/destroy:
>      constexpr duration() = default;

>      template <class Rep2>
>        constexpr explicit duration(const Rep2& r);
>      template <class Rep2, class Period2>
>        constexpr duration(const duration<Rep2, Period2>& d);

>       constexpr duration(const duration&) = default;

>       // 20.9.3.2, observer:
>       constexpr rep count() const;

>       // 20.9.3.3, arithmetic:
>       constexpr duration operator+() const;
>       constexpr duration operator-() const;
>       ...

>     };

[ Note - this edit already seems assumed by definition of the duration static members `zero/min/max`. They cannot meaningfully be `constexpr` without this change. ]

### 1173. "Equivalence" wishy-washiness

Section: 17 [library] Status: Open Submitter: David Abrahams Opened: 2009-07-14 Last modified: 2009-10-20

View other active issues in [library].

View all other issues in [library].

View all issues with Open status.

Discussion:

Issue: The `CopyConstructible` requirements are wishy-washy. It requires that the copy is "equivalent" to the original, but "equivalent" is never defined.

I believe this to be an example of a more general lack of rigor around copy and assignment, although I haven't done the research to dig up all the instances.

It's a problem because if you don't know what `CopyConstructible` means, you also don't know what it means to copy a pair of `CopyConstructible` types. It doesn't prevent us from writing code, but it is a hole in our ability to understand the meaning of copy.

Furthermore, I'm pretty sure that vector's copy constructor doesn't require the elements to be `EqualityComparable`, so that table is actually referring to some ill-defined notion of equivalence when it uses ==.

[ 2009 Santa Cruz: ]

> Move to "Open". Dave is right that this is a big issue. Paper D2987 ("Defining Move Special Member Functions", Bjarne Stroustrup and Lawrence Crowl) touches on this but does not solve it. This issue is discussed in Elements of Programming.

Proposed resolution:

### 1175. `unordered` complexity

Section: 23.2.5 [unord.req] Status: New Submitter: Pablo Halpern Opened: 2009-07-17 Last modified: 2009-07-19

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with New status.

Discussion:

When I look at the `unordered_*` constructors, I think the complexity is poorly described and does not follow the style of the rest of the standard.

The complexity for the default constructor is specified as constant. Actually, it is proportional to `n`, but there are no invocations of `value_type` constructors or other `value_type` operations.

For the iterator-based constructor the complexity should be:

> Complexity: exactly `n` calls to construct `value_type` from `InputIterator::value_type` (where `n = distance(f,l)`). The number of calls to `key_equal::operator()` is proportional to `n` in the average case and `n*n` in the worst case.

Proposed resolution:

### 1176. Make `thread` constructor non-variadic

Section: 30.3.1.2 [thread.thread.constr] Status: New Submitter: Howard Hinnant Opened: 2009-07-18 Last modified: 2009-07-18

View other active issues in [thread.thread.constr].

View all other issues in [thread.thread.constr].

View all issues with New status.

Discussion:

The variadic `thread` constructor is causing controversy, e.g. N2901. This issue has been created as a placeholder for this course of action.

>     template <class F, class ...Args> thread(F&& f, Args&&... args);

See 929 for wording which specifies an rvalue-ref signature but with "decay behavior", but using variadics.

Proposed resolution:

### 1177. Improve "diagnostic required" wording

Section: 20.9.3 [time.duration] Status: Ready Submitter: Howard Hinnant Opened: 2009-07-18 Last modified: 2009-10-26

View other active issues in [time.duration].

View all other issues in [time.duration].

View all issues with Ready status.

Discussion:

"diagnostic required" has been used (by me) for code words meaning "use `enable_if` to constrain templated functions. This needs to be improved by referring to the function signature as not participating in the overload set, and moving this wording to a Remarks paragraph.

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

[ This proposed resolution addresses 947 and 974. ]

1. Change 20.9.3.1 [time.duration.cons]:

   >     template <class Rep2>
   >       explicit duration(const Rep2& r);

   > > Requires: Remarks: `Rep2` shall be implicitly convertible to `rep` and

   > > - `treat_as_floating_point<rep>::value` shall be `true` or
   > > - `treat_as_floating_point<Rep2>::value` shall be `false`.

   > > Diagnostic required If these constraints are not met, this constructor shall not participate in overload resolution. [Example:

   > > >     duration<int, milli> d(3); // OK
   > > >     duration<int, milli> d(3.5); // error

   > > — end example]

   > > Effects: Constructs an object of type `duration`.

   > > Postcondition: `count() == static_cast<rep>(r)`.

   >     template <class Rep2, class Period2>
   >       duration(const duration<Rep2, Period2>& d);

   > > Requires: Remarks: `treat_as_floating_point<rep>::value` shall be `true` or `ratio_divide<Period2, period>::type::den` shall be 1. Diagnostic required, else this constructor shall not participate in overload resolution. [Note: This requirement prevents implicit truncation error when converting between integral-based duration types. Such a construction could easily lead to confusion about the value of the duration. — end note] [Example:

   > > >     duration<int, milli> ms(3);
   > > >     duration<int, micro> us = ms; // OK
   > > >     duration<int, milli> ms2 = us; // error

   > > — end example]

   > > Effects: Constructs an object of type `duration`, constructing `rep_` from `duration_cast<duration>(d).count()`.

2. Change the following paragraphs in 20.9.3.5 [time.duration.nonmember]:

   >     template <class Rep1, class Period, class Rep2>
   >       duration<typename common_type<Rep1, Rep2>::type, Period>
   >       operator*(const duration<Rep1, Period>& d, const Rep2& s);

   > > Requires Remarks: `Rep2` shall be implicitly convertible to `CR(Rep1, Rep2)`, else this signature shall not participate in overload resolution. Diagnostic required.

   >     template <class Rep1, class Period, class Rep2>
   >       duration<typename common_type<Rep1, Rep2>::type, Period>
   >       operator*(const Rep1& s, const duration<Rep2, Period>& d);

   > > Requires Remarks: `Rep1` shall be implicitly convertible to `CR(Rep1, Rep2)`, else this signature shall not participate in overload resolution. Diagnostic required.

   >     template <class Rep1, class Period, class Rep2>
   >       duration<typename common_type<Rep1, Rep2>::type, Period>
   >       operator/(const duration<Rep1, Period>& d, const Rep2& s);

   > > Requires Remarks: `Rep2` shall be implicitly convertible to `CR(Rep1, Rep2)` and `Rep2` shall not be an instantiation of `duration`, else this signature shall not participate in overload resolution. Diagnostic required.

   >     template <class Rep1, class Period, class Rep2>
   >       duration<typename common_type<Rep1, Rep2>::type, Period>
   >       operator%(const duration<Rep1, Period>& d, const Rep2& s);

   > > Requires Remarks: `Rep2` shall be implicitly convertible to `CR(Rep1, Rep2)` and `Rep2` shall not be an instantiation of `duration`, else this signature shall not participate in overload resolution. Diagnostic required.

3. Change the following paragraphs in 20.9.3.7 [time.duration.cast]:

   >     template <class ToDuration, class Rep, class Period>
   >       ToDuration duration_cast(const duration<Rep, Period>& d);

   > > Requires Remarks: `ToDuration` shall be an instantiation of `duration`, else this signature shall not participate in overload resolution. Diagnostic required.

4. Change the following paragraphs in 20.9.4.7 [time.point.cast]:

   >     template <class ToDuration, class Clock, class Duration>
   >       time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

   > > Requires Remarks: `ToDuration` shall be an instantiation of `duration`, else this signature shall not participate in overload resolution. Diagnostic required.

### 1180. Missing string_type member typedef in class `sub_match`

Section: 28.9.1 [re.submatch.members] Status: New Submitter: Daniel Krügler Opened: 2009-07-25 Last modified: 2009-07-26

View all issues with New status.

Discussion:

The definition of class template `sub_match` is strongly dependent on the type `basic_string<value_type>`, both in interface and effects, but does not provide a corresponding typedef `string_type`, as e.g. class `match_results` does, which looks like an oversight to me that should be fixed.

Proposed resolution:

1. In the class template `sub_match` synopsis 28.9 [re.submatch]/1 change as indicated:

   >     template <class BidirectionalIterator>
   >     class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> {
   >     public:
   >       typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
   >       typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
   >       typedef BidirectionalIterator iterator;
   >       typedef basic_string<value_type> string_type;

   >       bool matched;

   >       difference_type length() const;
   >       operator basic_string<value_type>string_type() const;
   >       basic_string<value_type>string_type str() const;
   >       int compare(const sub_match& s) const;
   >       int compare(const basic_string<value_type>string_type& s) const;
   >       int compare(const value_type* s) const;
   >     };

2. In 28.9.1 [re.submatch.members]/2 change as indicated:

   >     operator basic_string<value_type>string_type() const;

   > > Returns: `matched ? basic_string<value_type> string_type(first, second) : basic_string<value_type> string_type()`.

3. In 28.9.1 [re.submatch.members]/3 change as indicated:

   >     basic_string<value_type>string_type str() const;

   > > Returns: `matched ? basic_string<value_type> string_type(first, second) : basic_string<value_type> string_type()`.

### 1181. Invalid `sub_match` comparison operators

Section: 28.9.2 [re.submatch.op] Status: New Submitter: Daniel Krügler Opened: 2009-07-25 Last modified: 2009-07-28

View all other issues in [re.submatch.op].

View all issues with New status.

Discussion:

Several heterogeneous comparison operators of class template `sub_match` are specified by return clauses that are not valid in general. E.g. 28.9.2 [re.submatch.op]/7:

>     template <class BiIter, class ST, class SA>
>     bool operator==(
>       const basic_string<
>         typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
>       const sub_match<BiIter>& rhs);

> > Returns: `lhs == rhs.str()`.

The returns clause would be ill-formed for all cases where `ST != std::char_traits<iterator_traits<BiIter>::value_type>` or `SA != std::allocator<iterator_traits<BiIter>::value_type>`.

The generic character of the comparison was intended, so there are basically two approaches to fix the problem: The first one would define the semantics of the comparison using the traits class `ST` (The semantic of `basic_string::compare` is defined in terms of the compare function of the corresponding traits class), the second one would define the semantics of the comparison using the traits class

>     std::char_traits<iterator_traits<BiIter>::value_type>

which is essentially identical to

>     std::char_traits<sub_match<BiIter>::value_type>

I suggest to follow the second approach, because this emphasizes the central role of the `sub_match` object as part of the comparison and would also make sure that a `sub_match` comparison using some `basic_string<char_t, ..>` always is equivalent to a corresponding comparison with a string literal because of the existence of further overloads (beginning from 28.9.2 [re.submatch.op]/19). If users really want to take advantage of their own `traits::compare`, they can simply write a corresponding compare function that does so.

Proposed resolution:

1. In 28.9.2 [re.submatch.op] change as indicated:

   1. If 1180 is accepted:

      >     template <class BiIter, class ST, class SA>
      >       bool operator==(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 7 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) == rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator!=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 8 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) != rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 9 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) < rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 10 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) > rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 11 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >= rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 12 Returns: `lhstypename sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <= rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator==(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 13 Returns: `lhs.str() == rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator!=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 14 Returns: `lhs.str() != rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 15 Returns: `lhs.str() < rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 16 Returns: `lhs.str() > rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 17 Returns: `lhs.str() >= rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 18 Returns: `lhs.str() <= rhstypename sub_match<BiIter>::string_type(rhs.begin(), rhs.end())`.

   2. If 1180 is not accepted:

      >     template <class BiIter, class ST, class SA>
      >       bool operator==(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 7 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) == rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator!=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 8 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) != rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 9 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) < rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 10 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) > rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 11 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >= rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<=(
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
      >         const sub_match<BiIter>& rhs);

      > > 12 Returns: `lhsbasic_string<typename sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <= rhs.str()`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator==(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 13 Returns: `lhs.str() == rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator!=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 14 Returns: `lhs.str() != rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 15 Returns: `lhs.str() < rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 16 Returns: `lhs.str() > rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator>=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 17 Returns: `lhs.str() >= rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

      >     template <class BiIter, class ST, class SA>
      >       bool operator<=(const sub_match<BiIter>& lhs,
      >         const basic_string<
      >           typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

      > > 18 Returns: `lhs.str() <= rhsbasic_string<typename sub_match<BiIter>::value_type>(rhs.begin(), rhs.end())`.

### 1182. Unfortunate hash dependencies

Section: 20.7.16 [unord.hash] Status: New Submitter: Alisdair Meredith Opened: 2009-07-28 Last modified: 2009-09-21

View other active issues in [unord.hash].

View all other issues in [unord.hash].

View all issues with New status.

Discussion:

The implied library dependencies created by spelling out all the `hash` template specializations in the `<functional>` synopsis are unfortunate. The potential coupling is greatly reduced if the `hash` specialization is declared in the appropriate header for each library type, as it is much simpler to forward declare the primary template and provide a single specialization than it is to implement a `hash` function for a `string` or `vector` without providing a definition for the whole `string/vector` template in order to access the necessary bits.

Note that the proposed resolution purely involves moving the declarations of a few specializations, it specifically does not make any changes to 20.7.16 [unord.hash].

[ 2009-09-15 Daniel adds: ]

I suggest to add to the current existing proposed resolution the following items.

- Add to the very first strike-list of the currently suggested resolution the following lines:

  >     template <> struct hash<std::error_code>;
  >     template <> struct hash<std::thread::id>;

- Add the following declarations to 19.5 [syserr], header `<system_error>` synopsis after // 19.5.4:

  >     // 19.5.x hash support
  >     template <class T> struct hash;
  >     template <> struct hash<error_code>;

- Add a new clause 19.5.X (probably after 19.5.4):

  > 19.5.X Hash support [syserr.hash]

  >     template <> struct hash<error_code>;

  > > An explicit specialization of the class template hash (20.7.16 [unord.hash]) shall be provided for the type `error_code` suitable for using this type as key in unordered associative containers (23.5 [unord]).

- Add the following declarations to 30.3.1.1 [thread.thread.id] just after the declaration of the comparison operators:

  >     template <class T> struct hash;
  >     template <> struct hash<thread::id>;

- Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]:

  >     template <> struct hash<thread::id>;

  > > An explicit specialization of the class template hash (20.7.16 [unord.hash]) shall be provided for the type `thread::id` suitable for using this type as key in unordered associative containers (23.5 [unord]).

- Issue 889 independently suggests moving the specialization `std::hash<std::thread::id>` to header `<thread>`.

Proposed resolution:

Strike the following specializations declared in the `<functional>` synopsis p2 20.7 [function.objects]

>     template <> struct hash<std::string>;
>     template <> struct hash<std::u16string>;
>     template <> struct hash<std::u32string>;
>     template <> struct hash<std::wstring>;

>     template <class Allocator> struct hash<std::vector<bool, Allocator> >;
>     template <std::size_t N> struct hash<std::bitset<N> >;

Add the following declarations to the synopsis of `<string>` in 21.3 [string.classes]

>     // 21.4.x hash support
>     template <class T> struct hash;
>     template <> struct hash<string>;
>     template <> struct hash<u16string>;
>     template <> struct hash<u32string>;
>     template <> struct hash<wstring>;

Add a new clause 21.4.X

> 21.4.X Hash support [basic.string.hash]

>     template <> struct hash<string>;
>     template <> struct hash<u16string>;
>     template <> struct hash<u32string>;
>     template <> struct hash<wstring>;

> > Explicit specializations of the class template hash (20.7.16 [unord.hash]) shall be provided for the types `string`, `u16string`, `u32string` and `wstring` suitable for using these types as keys in unordered associative containers (23.5 [unord]).

Add the following declarations to the synopsis of `<vector>` in 23.3 [sequences]

>     // 21.4.x hash support
>     template <class T> struct hash;
>     template <class Allocator> struct hash<vector<bool, Allocator>>;

Add a new paragraph to the end of 23.3.7 [vector.bool]

>     template <class Allocator> struct hash<vector<bool, Allocator>>;

> > A partial specialization of the class template hash (20.7.16 [unord.hash]) shall be provided for vectors of boolean values suitable for use as a key in unordered associative containers (23.5 [unord]).

Add the following declarations to the synopsis of `<bitset>` in 20.3.7 [template.bitset]

>     // 20.3.6.X hash support
>     template <class T> struct hash;
>     template <size_t N> struct hash<bitset<N> >;

Add a new subclause 20.3.6.X [bitset.hash]

> 20.3.6.X bitset hash support [bitset.hash]

>     template <size_t N> struct hash<bitset<N> >;

> > A partial specialization of the class template hash (20.7.16 [unord.hash]) shall be provided for bitsets suitable for use as a key in unordered associative containers (23.5 [unord]).

### 1183. `basic_ios::set_rdbuf` may break class invariants

Section: 27.5.4.2 [basic.ios.members] Status: Open Submitter: Daniel Krügler Opened: 2009-07-28 Last modified: 2009-10-22

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with Open status.

Discussion:

The protected member function `set_rdbuf` had been added during the process of adding move and swap semantics to IO classes. A relevant property of this function is described by it's effects in 27.5.4.2 [basic.ios.members]/19:

> Effects: Associates the `basic_streambuf` object pointed to by sb with this stream without calling `clear()`.

This means that implementors of or those who derive from existing IO classes could cause an internal state where the stream buffer could be 0, but the IO class has the state `good()`. This would break several currently existing implementations which rely on the fact that setting a stream buffer via the currently only ways, i.e. either by calling

>     void init(basic_streambuf<charT,traits>* sb);

or by calling

>     basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);

to set `rdstate()` to `badbit`, if the buffer is 0. This has the effect that many internal functions can simply check `rdstate()` instead of `rdbuf()` for being 0.

I therefore suggest that a requirement is added for callers of `set_rdbuf` to set a non-0 value.

[ 2009-10 Santa Cruz: ]

> Moved to Open. Martin volunteers to provide new wording, where `set_rdbuf()` sets the `badbit` but does not cause an exception to be thrown like a call to `clear()` would.

[ 2009-10-20 Martin provides wording: ]

Proposed resolution:

Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated:

>     void set_rdbuf(basic_streambuf<charT, traits>* sb);

> > Effects: Associates the `basic_streambuf` object pointed to by `sb` with this stream without calling `clear()`. Postconditions: `rdbuf() == sb`.

> > Effects: As if:

> > >     iostate state = rdstate();
> > >     try { rdbuf(sb); }
> > >     catch(ios_base::failure) {
> > >        if (0 == (state & ios_base::badbit))
> > >            unsetf(badbit);
> > >     }

> > Throws: Nothing.

Rationale:

We need to be able to call `set_rdbuf()` on stream objects for which (`rdbuf() == 0`) holds without causing `ios_base::failure` to be thrown. We also don't want `badbit` to be set as a result of setting `rdbuf()` to 0 if it wasn't set before the call. This changed Effects clause maintains the current behavior (as of N2914) without requiring that `sb` be non-null.

### 1185. iterator categories and output iterators

Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2009-07-31

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with New status.

Discussion:

(wording relative to N2723 pending new working paper)

According to p3 24.2 [iterator.requirements], Forward iterators, Bidirectional iterators and Random Access iterators all satisfy the requirements for an Output iterator:

> XXX iterators satisfy all the requirements of the input and output iterators and can be used whenever either kind is specified ...

Meanwhile, p4 goes on to contradict this:

> Besides its category, a forward, bidirectional, or random access iterator can also be mutable or constant...

> ... Constant iterators do not satisfy the requirements for output iterators

The latter seems to be the overriding concern, as the iterator tag hierarchy does not define `forward_iterator_tag` as multiply derived from both `input_iterator_tag` and `output_iterator_tag`.

The work on concepts for iterators showed us that output iterator really is fundamentally a second dimension to the iterator categories, rather than part of the linear input -> forward -> bidirectional -> random-access sequence. It would be good to clear up these words to reflect that, and separately list output iterator requirements in the requires clauses for the appropriate algorithms and operations.

Proposed resolution:

### 1186. Forward list could model a stack

Section: 23.3.5.3 [stack] Status: Tentatively NAD Concepts Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2009-11-02

Discussion:

The library template `forward_list` could easily model the idea of a `stack`, where the operations work on the front of the list rather than the back. However, the standard library `stack` adaptor cannot support this.

It would be relatively easy to write a partial specialization for `stack` to support `forward_list`, but that opens the question of which header to place it in. A much better solution would be to add a `concept_map` for the `StackLikeContainer` concept to the `<forward_list>` header and then everything just works, including a user's own further uses in a stack-like context.

Therefore while I am submitting the issue now so that it is on record, I strongly recommend we resolve as "NAD Concepts" as any non-concepts based solution will be inferior to the final goal, and the feature is not so compelling it must be supported ahead of the concepts-based library.

[ 2009-11-02 Howard adds: ]

> Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib.

Proposed resolution:

### 1187. std::decay

Section: 20.6.7 [meta.trans.other] Status: New Submitter: Jason Merrill Opened: 2009-08-07 Last modified: 2009-08-22

View all other issues in [meta.trans.other].

View all issues with New status.

Discussion:

I notice that `std::decay` is specified to strip the cv-quals from anything but an array or pointer. This seems incorrect for values of class type, since class rvalues can have cv-qualified type (3.10 [basic.lval]/9).

[ 2009-08-09 Howard adds: ]

> See the thread starting with c++std-lib-24568 for further discussion. And here is a convenience link to the original proposal. Also see the closely related issue 705.

Proposed resolution:

Add a note to `decay` in 20.6.7 [meta.trans.other]:

> [Note: This behavior is similar to the lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) conversions applied when an lvalue expression is used as an rvalue, but also strips cv-qualifiers from class types in order to more closely model by-value argument passing. — end note]

### 1188. Unordered containers should have a minimum load factor as well as a maximum

Section: 23.2.5 [unord.req], 23.5 [unord] Status: New Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2009-08-11

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with New status.

Discussion:

Unordered associative containers have a notion of a maximum load factor: when the number of elements grows large enough, the containers automatically perform a rehash so that the number of elements per bucket stays below a user-specified bound. This ensures that the hash table's performance characteristics don't change dramatically as the size increases.

For similar reasons, Google has found it useful to specify a minimum load factor: when the number of elements shrinks by a large enough, the containers automatically perform a rehash so that the number of elements per bucket stays above a user-specified bound. This is useful for two reasons. First, it prevents wasting a lot of memory when an unordered associative container grows temporarily. Second, it prevents amortized iteration time from being arbitrarily large; consider the case of a hash table with a billion buckets and only one element. (This was discussed even before TR1 was published; it was TR issue 6.13, which the LWG closed as NAD on the grounds that it was a known design feature. However, the LWG did not consider the approach of a minimum load factor.)

The only interesting question is when shrinking is allowed. In principle the cleanest solution would be shrinking on erase, just as we grow on insert. However, that would be a usability problem; it would break a number of common idioms involving erase. Instead, Google's hash tables only shrink on insert and rehash.

The proposed resolution allows, but does not require, shrinking in rehash, mostly because a postcondition for rehash that involves the minimum load factor would be fairly complicated. (It would probably have to involve a number of special cases and it would probably have to mention yet another parameter, a minimum bucket count.)

The current behavior is equivalent to a minimum load factor of 0. If we specify that 0 is the default, this change will have no impact on backward compatibility.

Proposed resolution:

Add two new rows, and change rehash's postcondition in the unordered associative container requirements table in 23.2.5 [unord.req]:

> Table 87 — Unordered associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `a.min_load_factor()` | `float` | Returns a non-negative number that the container attempts to keep the load factor greater than or equal to. The container automatically decreases the number of buckets as necessary to keep the load factor above this number. | constant
> `a.min_load_factor(z)` | `void` | Pre: `z` shall be non-negative. Changes the container's minimum load factor, using `z` as a hint. [Footnote: the minimum load factor should be significantly smaller than the maximum. If `z` is too large, the implementation may reduce it to a more sensible value.] | constant
> `a.rehash(n)` | `void` | Post: `a.bucket_count() >= n`, and `a.size() <= a.bucket_count() * a.max_load_factor()`. [Footnote: It is intentional that the postcondition does not mention the minimum load factor. This member function is primarily intended for cases where the user knows that the container's size will increase soon, in which case the container's load factor will temporarily fall below `a.min_load_factor()`.] `a.bucket_cout > a.size() / a.max_load_factor()` and `a.bucket_count() >= n`. | Average case linear in `a.size()`, worst case quadratic.

Add a footnote to 23.2.5 [unord.req] p12:

> The insert members shall not affect the validity of references to container elements, but may invalidate all iterators to the container. The erase members shall invalidate only iterators and references to the erased elements.

> > [A consequence of these requirements is that while insert may change the number of buckets, erase may not. The number of buckets may be reduced on calls to insert or rehash.]

Change paragraph 13:

> The insert members shall not affect the validity of iterators if `(N+n) < z * B` `zmin * B <= (N+n) <= zmax * B`, where `N` is the number of elements in the container prior to the insert operation, `n` is the number of elements inserted, `B` is the container's bucket count, `zmin` is the container's minimum load factor, and `zmax` is the container's maximum load factor.

Add to the `unordered_map` class synopsis in section 23.5.1 [unord.map], the `unordered_multimap` class synopsis in 23.5.2 [unord.multimap], the `unordered_set` class synopsis in 23.5.3 [unord.set], and the `unordered_multiset` class synopsis in 23.5.4 [unord.multiset]:

>     float min_load_factor() const;
>     void min_load_factor(float z);

In 23.5.1.1 [unord.map.cnstr], 23.5.2.1 [unord.multimap.cnstr], 23.5.3.1 [unord.set.cnstr], and 23.5.4.1 [unord.multiset.cnstr], change:

> ... `max_load_factor()` returns 1.0 and `min_load_factor()` returns 0.

### 1189. Awkward interface for changing the number of buckets in an unordered associative container

Section: 23.2.5 [unord.req], 23.5 [unord] Status: Tentatively Ready Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2009-10-28

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with Tentatively Ready status.

Discussion:

Consider a typical use case: I create an `unordered_map` and then start adding elements to it one at a time. I know that it will eventually need to store a few million elements, so, for performance reasons, I would like to reserve enough capacity that none of the calls to `insert` will trigger a rehash.

Unfortunately, the existing interface makes this awkward. The user naturally sees the problem in terms of the number of elements, but the interface presents it as buckets. If `m` is the map and `n` is the expected number of elements, this operation is written `m.rehash(n / m.max_load_factor())` — not very novice friendly.

[ 2009-09-30 Daniel adds: ]

> I recommend to replace "`resize`" by a different name like "`reserve`", because that would better match the intended use-case. Rational: Any existing resize function has the on-success post-condition that the provided size is equal to `size()`, which is not satisfied for the proposal. Reserve seems to fit the purpose of the actual renaming suggestion.

[ 2009-10-28 Ganesh summarizes alternative resolutions and expresses a strong preference for the second (and opposition to the first): ]

> 1. In the unordered associative container requirements (23.2.5 [unord.req]), remove the row for rehash and replace it with:

>    > Table 87 — Unordered associative container requirements (in addition to container)
>    > Expression | Return type | Assertion/note pre-/post-condition | Complexity
>    > --- | --- | --- | ---
>    > `a.rehashreserve(n)` | `void` | Post: `a.bucket_count > max(a.size(), n) / a.max_load_factor()` and `a.bucket_count() >= n`. | Average case linear in `a.size()`, worst case quadratic.

>    Make the corresponding change in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].

> 2. In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:

>    > Table 87 — Unordered associative container requirements (in addition to container)
>    > Expression | Return type | Assertion/note pre-/post-condition | Complexity
>    > --- | --- | --- | ---
>    > `a.rehash(n)` | `void` | Post: `a.bucket_count > a.size() / a.max_load_factor()` and `a.bucket_count() >= n`. | Average case linear in `a.size()`, worst case quadratic.
>    > `a.reserve(n)` | `void` | Same as `a.rehash(ceil(n / a.max_load_factor()))` | Average case linear in `a.size()`, worst case quadratic.

>    In 23.5.1 [unord.map]/3 in the definition of class template `unordered_map`, in 23.5.2 [unord.multimap]/3 in the definition of class template `unordered_multimap`, in 23.5.3 [unord.set]/3 in the definition of class template `unordered_set` and in 23.5.4 [unord.multiset]/3 in the definition of class template `unordered_multiset`, add the following line after member function `rehash()`:

>    >     void reserve(size_type n);

[ 2009-10-28 Howard: ]

> Moved to Tentatively Ready after 5 votes in favor of Ganesh's option 2 above. The original proposed wording now appears here:

> > Informally: instead of providing `rehash(n)` provide `resize(n)`, with the semantics "make the container a good size for `n` elements".

> > In the unordered associative container requirements (23.2.5 [unord.req]), remove the row for rehash and replace it with:

> > > Table 87 — Unordered associative container requirements (in addition to container)
> > > Expression | Return type | Assertion/note pre-/post-condition | Complexity
> > > --- | --- | --- | ---
> > > `a.rehashresize(n)` | `void` | Post: `a.bucket_count > max(a.size(), n) / a.max_load_factor()` and `a.bucket_count() >= n`. | Average case linear in `a.size()`, worst case quadratic.

> > Make the corresponding change in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].

Proposed resolution:

In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:

> Table 87 — Unordered associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `a.rehash(n)` | `void` | Post: `a.bucket_count > a.size() / a.max_load_factor()` and `a.bucket_count() >= n`. | Average case linear in `a.size()`, worst case quadratic.
> `a.reserve(n)` | `void` | Same as `a.rehash(ceil(n / a.max_load_factor()))` | Average case linear in `a.size()`, worst case quadratic.

In 23.5.1 [unord.map]/3 in the definition of class template `unordered_map`, in 23.5.2 [unord.multimap]/3 in the definition of class template `unordered_multimap`, in 23.5.3 [unord.set]/3 in the definition of class template `unordered_set` and in 23.5.4 [unord.multiset]/3 in the definition of class template `unordered_multiset`, add the following line after member function `rehash()`:

>     void reserve(size_type n);

### 1190. Setting the maximum load factor should return the previous value

Section: 23.2.5 [unord.req], 23.5 [unord] Status: New Submitter: Matt Austern Opened: 2009-08-10 Last modified: 2009-08-11

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with New status.

Discussion:

The unordered associative container requirements table specifies that `a.set_max_load_factor(z)` has return type `void`. However, there is a useful piece of information to return: the previous value. Users who don't need it can always ignore it.

Proposed resolution:

In the unordered associative container requirements table, change:

> Table 87 — Unordered associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `a.max_load_factor(z)` | `void float` | Pre: `z` shall be positive. Changes the container's maximum load load factor, using `z` as a hint. Returns: the previous value of `a.max_load_factor()`. | constant

Change the return type of `set_max_load_factor` in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4 [unord.multiset].

If issue 1188 is also accepted, make the same changes for `min_load_factor`.

### 1191. `tuple get` API should respect rvalues

Section: 20.5.2.6 [tuple.elem] Status: Open Submitter: Alisdair Meredith Opened: 2009-08-18 Last modified: 2009-10-31

View all issues with Open status.

Discussion:

The `tuple get` API should respect rvalues. This would allow for moving a single element out of a `tuple`-like type.

[ 2009-10-30 Alisdair adds: ]

> The issue of rvalue overloads of get for tuple-like types was briefly discussed in Santa Cruz.

> The feedback was this would be welcome, but we need full wording for the other types (`pair` and `array`) before advancing.

> I suggest the issue moves to Open from New as it has been considered, feedback given, and it has not (yet) been rejected as NAD.

Proposed resolution:

Add the following signature to p2 20.5.1 [tuple.general]

>     template <size_t I, class ... Types>
>     typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...> &&);

And again to 20.5.2.6 [tuple.elem].

>     template <size_t I, class ... Types>
>     typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&& t);

> > Effects: Equivalent to `return std::forward<typename tuple_element<I, tuple<Types...> >::type&&>(get<I>(t));`

> > [Note: If a `T` in `Types` is some reference type `X&`, the return type is `X&`, not `X&&`. However, if the element type is non-reference type `T`, the return type is `T&&`. — end note]

Add the following signature to p1 20.3 [utility]

>     template <size_t I, class T1, class T2>
>     typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&&);

And to p5 20.3.5 [pair.astuple]

>     template <size_t I, class T1, class T2>
>     typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&& p);

> > Returns: If `I == 0` returns `std::forward<T1&&>(p.first)`; if `I == 1` returns `std::forward<T2&&>(p.second)`; otherwise the program is ill-formed.

> > Throws: Nothing.

Add the following signature to 23.3 [sequences] `<array>` synopsis

>     template <size_t I, class T, size_t N>
>     T&& get(array<T,N> &&);

And after p8 23.3.1.7 [array.tuple]

>     template <size_t I, class T, size_t N>
>     T&& get(array<T,N> && a);

> > Effects: Equivalent to `return std::move(get<I>(a));`

### 1192. `basic_string` missing definitions for `cbegin` / `cend` / `crbegin` / `crend`

Section: 21.4.3 [string.iterators] Status: Tentatively Ready Submitter: Jonathan Wakely Opened: 2009-08-14 Last modified: 2009-10-29

View all issues with Tentatively Ready status.

Discussion:

Unlike the containers in clause 23, `basic_string` has definitions for `begin()` and `end()`, but these have not been updated to include `cbegin`, `cend`, `crbegin` and `crend`.

[ 2009-10-28 Howard: ]

> Moved to Tentatively NAD after 5 positive votes on c++std-lib. Added rationale.

[ 2009-10-28 Alisdair disagrees: ]

> I'm going to have to speak up as the dissenting voice.

> I agree the issue could be handled editorially, and that would be my preference if Pete feels this is appropriate. Failing that, I really think this issue should be accepted and moved to ready. The other begin/end functions all have a semantic definition for this template, and it is confusing if a small few are missing.

> I agree that an alternative would be to strike all the definitions for `begin/end/rbegin/rend` and defer completely to the requirements tables in clause 23. I think that might be confusing without a forward reference though, as those tables are defined in a *later* clause than the basic_string template itself. If someone wants to pursue this I would support it, but recommend it as a separate issue.

> So my preference is strongly to move Ready over NAD, and a stronger preference for NAD Editorial if Pete is happy to make these changes.

[ 2009-10-29 Howard: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib. Removed rationale to mark it NAD. :-)

Proposed resolution:

Add to 21.4.3 [string.iterators]

>     iterator       begin();
>     const_iterator begin() const;
>     const_iterator cbegin() const;

> ...

>     iterator       end();
>     const_iterator end() const;
>     const_iterator cend() const;

> ...

>     reverse_iterator       rbegin();
>     const_reverse_iterator rbegin() const;
>     const_reverse_iterator crbegin() const;

> ...

>     reverse_iterator       rend();
>     const_reverse_iterator rend() const;
>     const_reverse_iterator crend() const;

### 1193. `default_delete` cannot be instantiated with incomplete types

Section: 20.8.14.1 [unique.ptr.dltr] Status: New Submitter: Daniel Krügler Opened: 2009-08-18 Last modified: 2009-08-22

View all issues with New status.

Discussion:

According to the general rules of 17.6.3.8 [res.on.functions]/2 b 5 the effects are undefined, if an incomplete type is used to instantiate a library template. But neither in 20.8.14.1 [unique.ptr.dltr] nor in any other place of the standard such explicit allowance is given. Since this template is intended to be instantiated with incomplete types, this must be fixed.

Proposed resolution:

Add two new paragraphs directly to 20.8.14.1 [unique.ptr.dltr] (before 20.8.14.1.1 [unique.ptr.dltr.dflt]) with the following content:

> The class template `default_delete` serves as the default deleter (destruction policy) for the class template `unique_ptr`.

> The template parameter `T` of `default_delete` may be an incomplete type.

### 1194. Unintended `queue` constructor

Section: 23.3.5 [container.adaptors] Status: Ready Submitter: Howard Hinnant Opened: 2009-08-20 Last modified: 2009-10-20

View other active issues in [container.adaptors].

View all other issues in [container.adaptors].

View all issues with Ready status.

Discussion:

23.3.5.1.1 [queue.defn] has the following `queue` constructor:

>     template <class Alloc> explicit queue(const Alloc&);

This will be implemented like so:

>     template <class Alloc> explicit queue(const Alloc& a) : c(a) {}

The issue is that `Alloc` can be anything that a container will construct from, for example an `int`. Is this intended to compile?

>     queue<int> q(5);

Before the addition of this constructor, `queue<int>(5)` would not compile. I ask, not because this crashes, but because it is new and appears to be unintended. We do not want to be in a position of accidently introducing this "feature" in C++0X and later attempting to remove it.

I've picked on `queue`. `priority_queue` and `stack` have the same issue. Is it useful to create a `priority_queue` of 5 identical elements?

[ Daniel, Howard and Pablo collaborated on the proposed wording. ]

[ 2009-10 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

[ This resolution includes a semi-editorial clean up, giving definitions to members which in some cases weren't defined since C++98. This resolution also offers editorially different wording for 976, and it also provides wording for 1196. ]

Change container.adaptors, p1:

> The container adaptors each take a `Container` template parameter, and each constructor takes a `Container` reference argument. This container is copied into the `Container` member of each adaptor. If the container takes an allocator, then a compatible allocator may be passed in to the adaptor's constructor. Otherwise, normal copy or move construction is used for the container argument. [Note: it is not necessary for an implementation to distinguish between the one-argument constructor that takes a `Container` and the one- argument constructor that takes an allocator_type. Both forms use their argument to construct an instance of the container. — end note]

Change queue.defn, p1:

>     template <class T, class Container = deque<T> >
>     class queue {
>     public:
>       typedef typename Container::value_type      value_type;
>       typedef typename Container::reference       reference;
>       typedef typename Container::const_reference const_reference;
>       typedef typename Container::size_type       size_type;
>       typedef Container                           container_type;
>     protected:
>       Container c;

>     public:
>       explicit queue(const Container&);
>       explicit queue(Container&& = Container());
>       queue(queue&& q); : c(std::move(q.c)) {}
>       template <class Alloc> explicit queue(const Alloc&);
>       template <class Alloc> queue(const Container&, const Alloc&);
>       template <class Alloc> queue(Container&&, const Alloc&);
>       template <class Alloc> queue(queue&&, const Alloc&);
>       queue& operator=(queue&& q); { c = std::move(q.c); return *this; }

>       bool empty() const          { return c.empty(); }
>       ...
>     };

Add a new section after 23.3.5.1.1 [queue.defn], [queue.cons]:

> `queue` constructors [queue.cons]

>     explicit queue(const Container& cont);

> > Effects: Initializes `c` with `cont`.

>     explicit queue(Container&& cont = Container());

> > Effects: Initializes `c` with `std::move(cont)`.

>     queue(queue&& q)

> > Effects: Initializes `c` with `std::move(q.c)`.

> For each of the following constructors, if `uses_allocator<container_type, Alloc>::value` is `false`, then the constructor shall not participate in overload resolution.

>     template <class Alloc>
>       explicit queue(const Alloc& a);

> > Effects: Initializes `c` with `a`.

>     template <class Alloc>
>       queue(const container_type& cont, const Alloc& a);

> > Effects: Initializes `c` with `cont` as the first argument and `a` as the second argument.

>     template <class Alloc>
>       queue(container_type&& cont, const Alloc& a);

> > Effects: Initializes `c` with `std::move(cont)` as the first argument and `a` as the second argument.

>     template <class Alloc>
>       queue(queue&& q, const Alloc& a);

> > Effects: Initializes `c` with `std::move(q.c)` as the first argument and `a` as the second argument.

>     queue& operator=(queue&& q);

> > Effects: Assigns `c` with `std::move(q.c)`.

> > Returns: `*this`.

Add to 23.3.5.2.1 [priqueue.cons]:

>     priority_queue(priority_queue&& q);

> > Effects: Initializes `c` with `std::move(q.c)` and initializes `comp` with `std::move(q.comp)`.

> For each of the following constructors, if `uses_allocator<container_type, Alloc>::value` is `false`, then the constructor shall not participate in overload resolution.

>     template <class Alloc>
>       explicit priority_queue(const Alloc& a);

> > Effects: Initializes `c` with `a` and value-initializes `comp`.

>     template <class Alloc>
>       priority_queue(const Compare& compare, const Alloc& a);

> > Effects: Initializes `c` with `a` and initializes `comp` with `compare`.

>     template <class Alloc>
>       priority_queue(const Compare& compare, const Container& cont, const Alloc& a);

> > Effects: Initializes `c` with `cont` as the first argument and `a` as the second argument, and initializes `comp` with `compare`.

>     template <class Alloc>
>       priority_queue(const Compare& compare, Container&& cont, const Alloc& a);

> > Effects: Initializes `c` with `std::move(cont)` as the first argument and `a` as the second argument, and initializes `comp` with `compare`.

>     template <class Alloc>
>       priority_queue(priority_queue&& q, const Alloc& a);

> > Effects: Initializes `c` with `std::move(q.c)` as the first argument and `a` as the second argument, and initializes `comp` with `std::move(q.comp)`.

>     priority_queue& operator=(priority_queue&& q);

> > Effects: Assigns `c` with `std::move(q.c)` and assigns `comp` with `std::move(q.comp)`.

> > Returns: `*this`.

Change 23.3.5.3.1 [stack.defn]:

>     template <class T, class Container = deque<T> >
>     class stack {
>     public:
>       typedef typename Container::value_type      value_type;
>       typedef typename Container::reference       reference;
>       typedef typename Container::const_reference const_reference;
>       typedef typename Container::size_type       size_type;
>       typedef Container                           container_type;
>     protected:
>       Container c;

>     public:
>       explicit stack(const Container&);
>       explicit stack(Container&& = Container());
>       stack(stack&& s);
>       template <class Alloc> explicit stack(const Alloc&);
>       template <class Alloc> stack(const Container&, const Alloc&);
>       template <class Alloc> stack(Container&&, const Alloc&);
>       template <class Alloc> stack(stack&&, const Alloc&);
>       stack& operator=(stack&& s);

>       bool empty() const          { return c.empty(); }
>       ...
>     };

Add a new section after 23.3.5.3.1 [stack.defn], [stack.cons]:

> `stack` constructors [stack.cons]

>     stack(stack&& s);

> > Effects: Initializes `c` with `std::move(s.c)`.

> For each of the following constructors, if `uses_allocator<container_type, Alloc>::value` is `false`, then the constructor shall not participate in overload resolution.

>     template <class Alloc>
>       explicit stack(const Alloc& a);

> > Effects: Initializes `c` with `a`.

>     template <class Alloc>
>       stack(const container_type& cont, const Alloc& a);

> > Effects: Initializes `c` with `cont` as the first argument and `a` as the second argument.

>     template <class Alloc>
>       stack(container_type&& cont, const Alloc& a);

> > Effects: Initializes `c` with `std::move(cont)` as the first argument and `a` as the second argument.

>     template <class Alloc>
>       stack(stack&& s, const Alloc& a);

> > Effects: Initializes `c` with `std::move(s.c)` as the first argument and `a` as the second argument.

>     stack& operator=(stack&& s);

> > Effects: Assigns `c` with `std::move(s.c)`.

> > Returns: `*this`.

### 1197. Can unordered containers have `bucket_count() == 0`?

Section: 23.2.5 [unord.req] Status: New Submitter: Howard Hinnant Opened: 2009-08-24 Last modified: 2009-09-03

View other active issues in [unord.req].

View all other issues in [unord.req].

View all issues with New status.

Discussion:

Table 97 "Unordered associative container requirements" in 23.2.5 [unord.req] says:

> Table 97 — Unordered associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `b.bucket(k)` | `size_type` | Returns the index of the bucket in which elements with keys equivalent to `k` would be found, if any such element existed. Post: the return value shall be in the range `[0, b.bucket_count())`. | Constant

What should `b.bucket(k)` return if `b.bucket_count() == 0`?

I believe allowing `b.bucket_count() == 0` is important. It is a very reasonable post-condition of the default constructor, or of a moved-from container.

I can think of several reasonable results from `b.bucket(k)` when `b.bucket_count() == 0`:

1. Return 0.
2. Return `numeric_limits<size_type>::max()`.
3. Throw a `domain_error`.
4. Precondition: `b.bucket_count() != 0`.

[ 2009-08-26 Daniel adds: ]

> A forth choice would be to add the pre-condition "`b.bucket_count() != 0`" and thus imply undefined behavior if this is violated.

> [ Howard: I like this option too, added to the list. ]

> Further on here my own favorite solution (rationale see below):

> Suggested resolution:

> [Rationale: I suggest to follow choice (1). The main reason is that all associative container functions which take a key argument, are basically free of pre-conditions and non-disrupting, therefore excluding choices (3) and (4). Option (2) seems a bit unexpected to me. It would be more natural, if several similar functions would exist which would also justify the existence of a symbolic constant like npos for this situation. The value 0 is both simple and consistent, it has exactly the same role as a past-the-end iterator value. A typical use-case is:

> >     size_type pos = m.bucket(key);
> >     if (pos != m.bucket_count()) {
> >      ...
> >     } else {
> >      ...
> >     }

> — end Rationale]

> - Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column "Assertion/..."):

> > Table 97 — Unordered associative container requirements (in addition to container)
> > Expression | Return type | Assertion/note pre-/post-condition | Complexity
> > --- | --- | --- | ---
> > `b.bucket(k)` | `size_type` | Returns the index of the bucket in which elements with keys equivalent to `k` would be found, if any such element existed. Post: if b.bucket_count() != 0, the return value shall be in the range `[0, b.bucket_count())`, otherwise 0. | Constant

Proposed resolution:

### 1198. Container adaptor swap: member or non-member?

Section: 23.3.5 [container.adaptors] Status: New Submitter: Pablo Halpern Opened: 2009-08-26 Last modified: 2009-09-30

View other active issues in [container.adaptors].

View all other issues in [container.adaptors].

View all issues with New status.

Discussion:

Under 23.3.5 [container.adaptors] of N2914 the member function of `swap` of `queue` and `stack` call:

>     swap(c, q.c);

But under 23.3.5 [container.adaptors] of N2723 these members are specified to call:

>     c.swap(q.c);

Neither draft specifies the semantics of member `swap` for `priority_queue` though it is declared.

Although the distinction between member `swap` and non-member `swap` is not important when these adaptors are adapting standard containers, it may be important for user-defined containers.

We (Pablo and Howard) feel that it is more likely for a user-defined container to support a namespace scope `swap` than a member `swap`, and therefore these adaptors should use the container's namespace scope `swap`.

[ 2009-09-30 Daniel adds: ]

> The outcome of this issue should be considered with the outcome of 774 both in style and in content (e.g. 774 bullet 9 suggests to define the semantic of `void priority_queue::swap(priority_queue&)` in terms of the member `swap` of the container).

Proposed resolution:

[ Changes written with respect to N2723. ]

Change 23.3.5.1.1 [queue.defn]:

>     template <class T, class Container = deque<T> >
>     class queue {
>        ...
>        void swap(queue&& q) { using std::swap;
>                               c.swap(c, q.c); }
>        ...
>     };

Change 23.3.5.2 [priority.queue]:

>     template <class T, class Container = vector<T>,
>               class Compare = less<typename Container::value_type> >
>     class priority_queue {
>         ...
>         void swap(priority_queue&& q); { using std::swap;
>                                          swap(c, q.c);
>                                          swap(comp, q.comp); }
>         ...
>     };

Change 23.3.5.3.1 [stack.defn]:

>     template <class T, class Container = deque<T> >
>     class stack {
>        ...
>        void swap(stack&& s) { using std::swap;
>                               c.swap(c, s.c); }
>        ...
>     };

### 1199. Missing extended copy constructor in container adaptors

Section: 23.3.5 [container.adaptors] Status: New Submitter: Pablo Halpern Opened: 2009-08-26 Last modified: 2009-08-31

View other active issues in [container.adaptors].

View all other issues in [container.adaptors].

View all issues with New status.

Discussion:

`queue` has a constructor:

>     template <class Alloc>
>       queue(queue&&, const Alloc&);

but it is missing a corresponding constructor:

>     template <class Alloc>
>       queue(const queue&, const Alloc&);

The same is true of `priority_queue`, and `stack`. This "extended copy constructor" is needed for consistency and to ensure that the user of a container adaptor can always specify the allocator for his adaptor.

Proposed resolution:

[ This resolution has been harmonized with the proposed resolution to issue 1194 ]

Change 23.3.5.1.1 [queue.defn], p1:

>     template <class T, class Container = deque<T> >
>     class queue {
>     public:
>       typedef typename Container::value_type      value_type;
>       typedef typename Container::reference       reference;
>       typedef typename Container::const_reference const_reference;
>       typedef typename Container::size_type       size_type;
>       typedef Container                           container_type;
>     protected:
>       Container c;

>     public:
>       explicit queue(const Container&);
>       explicit queue(Container&& = Container());
>       queue(queue&& q);

>       template <class Alloc> explicit queue(const Alloc&);
>       template <class Alloc> queue(const Container&, const Alloc&);
>       template <class Alloc> queue(Container&&, const Alloc&);
>       template <class Alloc> queue(const queue&, const Alloc&);
>       template <class Alloc> queue(queue&&, const Alloc&);
>       queue& operator=(queue&& q);

>       bool empty() const          { return c.empty(); }
>       ...
>     };

To the new section [queue.cons], introduced in 1194, add:

>     template <class Alloc>
>       queue(const queue& q, const Alloc& a);

> > Effects: Initializes `c` with `q.c` as the first argument and `a` as the second argument.

Change 23.3.5.2 [priority.queue] as follows (I've an included an editorial change to move the poorly-placed move-assignment operator):

>     template <class T, class Container = vector<T>,
>               class Compare = less<typename Container::value_type> >
>     class priority_queue {
>     public:
>       typedef typename Container::value_type      value_type;
>       typedef typename Container::reference       reference;
>       typedef typename Container::const_reference const_reference;
>       typedef typename Container::size_type       size_type;
>       typedef          Container                  container_type;
>     protected:
>       Container c;
>       Compare comp;

>     public:
>       priority_queue(const Compare& x, const Container&);
>       explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
>       template <class InputIterator>
>         priority_queue(InputIterator first, InputIterator last,
>                        const Compare& x, const Container&);
>       template <class InputIterator>
>         priority_queue(InputIterator first, InputIterator last,
>                        const Compare& x = Compare(), Container&& = Container());
>       priority_queue(priority_queue&&);
>       priority_queue& operator=(priority_queue&&);
>       template <class Alloc> explicit priority_queue(const Alloc&);
>       template <class Alloc> priority_queue(const Compare&, const Alloc&);
>       template <class Alloc> priority_queue(const Compare&,
>                                             const Container&, const Alloc&);
>       template <class Alloc> priority_queue(const Compare&,
>                                             Container&&, const Alloc&);
>       template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
>       template <class Alloc> priority_queue(priority_queue&&, const Alloc&);

>       priority_queue& operator=(priority_queue&&);
>       ...
>     };

Add to 23.3.5.2.1 [priqueue.cons]:

>     template <class Alloc>
>       explicit priority_queue(const priority_queue& q, const Alloc& a);

> > Effects: Initializes `c` with `q.c` as the first argument and `a` as the second argument, and initializes `comp` with `q.comp`.

Change 23.3.5.3.1 [stack.defn]:

>     template <class T, class Container = deque<T> >
>     class stack {
>     public:
>       typedef typename Container::value_type      value_type;
>       typedef typename Container::reference       reference;
>       typedef typename Container::const_reference const_reference;
>       typedef typename Container::size_type       size_type;
>       typedef Container                           container_type;
>     protected:
>       Container c;

>     public:
>       explicit stack(const Container&);
>       explicit stack(Container&& = Container());
>       stack(stack&& s);

>       template <class Alloc> explicit stack(const Alloc&);
>       template <class Alloc> stack(const Container&, const Alloc&);
>       template <class Alloc> stack(Container&&, const Alloc&);
>       template <class Alloc> stack(const stack&, const Alloc&);
>       template <class Alloc> stack(stack&&, const Alloc&);
>       stack& operator=(stack&& s);

>       bool empty() const          { return c.empty(); }
>       ...
>     };

To the new section [stack.cons], introduced in 1194, add:

>     template <class Alloc>
>       stack(const stack& s, const Alloc& a);

> > Effects: Initializes `c` with `s.c` as the first argument and `a` as the second argument.

### 1200. "surprising" `char_traits<T>::int_type` requirements

Section: 21.2.2 [char.traits.typedefs] Status: New Submitter: Sean Hunt Opened: 2009-09-03 Last modified: 2009-10-28

View all other issues in [char.traits.typedefs].

View all issues with New status.

Discussion:

The footnote for `int_type` in 21.2.2 [char.traits.typedefs] says that

> If `eof()` can be held in `char_type` then some iostreams implementations may give surprising results.

This implies that `int_type` should be a superset of `char_type`. However, the requirements for `char16_t` and `char32_t` define `int_type` to be equal to `int_least16_t` and `int_least32_t` respectively. `int_least16_t` is likely to be the same size as `char_16_t`, which may lead to surprising behavior, even if `eof()` is not a valid UTF-16 code unit. The standard should not prescribe surprising behavior, especially without saying what it is (it's apparently not undefined, just surprising). The same applies for 32-bit types.

I personally recommend that behavior be undefined if `eof()` is a member of `char_type`, and another type be chosen for `int_type` (my personal favorite has always been a `struct {bool eof; char_type c;}`). Alternatively, the exact results of such a situation should be defined, at least so far that I/O could be conducted on these types as long as the code units remain valid. Note that the argument that no one streams `char16_t` or `char32_t` is not really valid as it would be perfectly reasonable to use a `basic_stringstream` in conjunction with UTF character types.

[ 2009-10-28 Ganesh provides two possible resolutions and expresses a preference for the second: ]

> 1. Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:

>    > The member `eof()` shall return an implementation-defined constant that cannot appear as a valid UTF-16 code unit `UINT_LEAST16_MAX` [Note: this value is guaranteed to be a permanently reserved UCS-2 code position if `UINT_LEAST16_MAX == 0xFFFF` and it's not a UCS-2 code position otherwise — end note].

>    Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:

>    > The member `eof()` shall return an implementation-defined constant that cannot appear as a Unicode code point `UINT_LEAST32_MAX` [Note: this value is guaranteed to be a permanently reserved UCS-4 code position if `UINT_LEAST32_MAX == 0xFFFFFFFF` and it's not a UCS-4 code position otherwise — end note].

> 2. In 21.2.3.2 [char.traits.specializations.char16_t], in the definition of `char_traits<char16_t>` replace the definition of nested typedef `int_type` with:

>    >     namespace std {
>    >       template<> struct char_traits<char16_t> {
>    >         typedef char16_t         char_type;
>    >         typedef uint_least16_t uint_fast16_t int_type;
>    >          ...

>    Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:

>    > The member `eof()` shall return an implementation-defined constant that cannot appear as a valid UTF-16 code unit `UINT_FAST16_MAX` [Note: this value is guaranteed to be a permanently reserved UCS-2 code position if `UINT_FAST16_MAX == 0xFFFF` and it's not a UCS-2 code position otherwise — end note].

>    In 21.2.3.3 [char.traits.specializations.char32_t], in the definition of `char_traits<char32_t>` replace the definition of nested typedef `int_type` with:

>    >     namespace std {
>    >       template<> struct char_traits<char32_t> {
>    >         typedef char32_t         char_type;
>    >         typedef uint_least32_t uint_fast32_t int_type;
>    >          ...

>    Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:

>    > The member `eof()` shall return an implementation-defined constant that cannot appear as a Unicode code point `UINT_FAST32_MAX` [Note: this value is guaranteed to be a permanently reserved UCS-4 code position if `UINT_FAST32_MAX == 0xFFFFFFFF` and it's not a UCS-4 code position otherwise — end note].

Proposed resolution:

### 1201. Do we always want to unwrap `ref`-wrappers in `make_tuple`

Section: 20.5.2.4 [tuple.creation], 20.3.4 [pairs] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-09-05 Last modified: 2009-10-26

View all issues with Tentatively NAD Future status.

Discussion:

Spotting a recent thread on the boost lists regarding collapsing optional representations in `optional<optional<T>>` instances, I wonder if we have some of the same issues with `make_tuple`, and now `make_pair`?

Essentially, if my generic code in my own library is handed a `reference_wrapper` by a user, and my library in turn delegates some logic to `make_pair` or `make_tuple`, then I am going to end up with a `pair`/`tuple` holding a real reference rather than the intended reference wrapper.

There are two things as a library author I can do at this point:

1. document my library also has the same reference-wrapper behaviour as `std::make_tuple`
2. roll my own `make_tuple` that does not unwrap rereferences, a lost opportunity to re-use the standard library.

(There may be some metaprogramming approaches my library can use to wrap the `make_tuple` call, but all will be significantly more complex than simply implementing a simplified `make_tuple`.)

Now I don't propose we lose this library facility, I think unwrapping references will be the common behaviour. However, we might want to consider adding another overload that does nothing special with `ref`-wrappers. Note that we already have a second overload of `make_tuple` in the library, called `tie`.

[ 2009-09-30 Daniel adds: ]

> I suggest to change the currently proposed paragraph for `make_simple_pair`

> >     template<typename... Types>
> >       pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);

> > > Type requirements: `sizeof...(Types) == 2`. Remarks: The program shall be ill-formed, if `sizeof...(Types) != 2`.

> > > ...

> or alternatively (but with a slightly different semantic):

> > > Remarks: If `sizeof...(Types) != 2`, this function shall not participate in overload resolution.

> to follow a currently introduced style and because the library does not have yet a specific "Type requirements" element. If such thing would be considered as useful this should be done as a separate issue. Given the increasing complexity of either of these wordings it might be preferable to use the normal two-argument-declaration style again in either of the following ways:

> 1.     template<class T1, class T2>
>        pair<typename decay<T1>::type, typename decay<T2>::type>
>        make_simple_pair(T1&& t1, T2&& t2);

> 2.     template<class T1, class T2>
>        pair<V1, V2> make_simple_pair(T1&& t1, T2&& t2);

>    > Let `V1` be `typename decay<T1>::type` and `V2` be `typename decay<T2>::type`.

[ 2009-10 post-Santa Cruz: ]

> Mark as Tentatively NAD Future.

Proposed resolution:

Add the following function to 20.3.4 [pairs] and signature in appropriate synopses:

>     template<typename... Types>
>       pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);

> > Type requirements: `sizeof...(Types) == 2`.

> > Returns: `pair<typename decay<Types>::type...>(std::forward<Types>(t)...)`.

[ Draughting note: I chose a variadic representation similar to `make_tuple` rather than naming both types as it is easier to read through the clutter of metaprogramming this way. Given there are exactly two elements, the committee may prefer to draught with two explicit template type parameters instead ]

Add the following function to 20.5.2.4 [tuple.creation] and signature in appropriate synopses:

>     template<typename... Types>
>       tuple<typename decay<Types>::type...> make_simple_tuple(Types&&... t);

> > Returns: `tuple<typename decay<Types>::type...>(std::forward<Types>(t)...)`.

### 1202. `integral_constant` needs a spring clean

Section: 20.6.3 [meta.help] Status: New Submitter: Alisdair Meredith Opened: 2009-09-05 Last modified: 2009-09-06

View all other issues in [meta.help].

View all issues with New status.

Discussion:

The specification of `integral_constant` has been inherited essentially unchanged from TR1:

>     template <class T, T v>
>     struct integral_constant {
>       static const T value = v;
>       typedef T value_type;
>       typedef integral_constant<T,v> type;
>     };

In light of 0x language changes there are several things we might consider changing, notably the form of specification for value.

The current form requires a static data member have storage allocated for it, where we could now implement without this using the new enum syntax:

>     template <class T, T v>
>     struct integral_constant {
>       enum : T { value = v };
>       typedef T value_type;
>       typedef integral_constant type;
>     };

The effective difference between these two implementation is:

1. No requirement to allocate storage for data member (which we hope but do not guarantee compilers strip today)
2. You can no longer take the address of the constant as `&integral_constant<T,v>::value;`

Also note the editorial change to drop the explicit qualification of `integral_constant` in the `typedef type`. This makes it quite clear we mean the current instantiation, and cannot be mistaken for a recursive metaprogram.

Even if we don't mandate this implementation, it would be nice to give vendors freedom under QoI to choose their preferred representation.

The other side of this issue is if we choose to retain the static constant form. In that case we should go further and insist on `constexpr`, much like we did throughout `numeric_limits`:

>     template <class T, T v>
>     struct integral_constant {
>       static constexpr T value = v;
>       typedef T value_type;
>       typedef integral_constant type;
>     };

[Footnote] It turns out `constexpr` is part of the Tentatively Ready resolution for 1019. I don't want to interfere with that issue, but would like a new issue to consider if the fixed-base enum implementation should be allowed.

[ 2009-09-05 Daniel adds: ]

> I think that the suggested resolution is incomplete and may have some possible unwanted side-effects. To understand why, note that `integral_constant` is completely specified by code in 20.6.3 [meta.help]. While this is usually considered as a good thing, let me give a possible user-defined specialization that would break given the suggested changes:

> >     enum NodeColor { Red, Black };

> >     std::integral_constant<NodeColor, Red> red;

> The reason why that breaks is due to the fact that current core language rules does only allow integral types as enum-bases, see 7.2 [dcl.enum]/2.

> So, I think that we cannot leave the implementation the freedom to decide which way they would like to provide the implementation, because that is easily user-visible (I don't speak of addresses, but of instantiation errors), therefore if applied, this should be either specified or wording must be added that gives a note about this freedom of implementation.

> Another possible disadvantage seems to me that user-expectations are easy to disappoint if they see a failure of the test

> >     assert(typeid(std::integral_constant<int, 0>::value) == typeid(int));

> or of

> >     static_assert(std::is_same<decltype(std::integral_constant<int, 0>::value), const int>::value, "Bad library");

Proposed resolution:

### 1204. Global permission to move

Section: 17.6.3.9 [res.on.arguments] Status: Ready Submitter: Howard Hinnant Opened: 2009-09-12 Last modified: 2009-10-20

View all issues with Ready status.

Discussion:

When a library function binds an rvalue reference parameter to an argument, the library must be able to assume that the bound argument is a temporary, and not a moved-from lvalue. The reason for this is that the library function must be able to modify that argument without concern that such modifications will corrupt the logic of the calling code. For example:

>     template <class T, class A>
>     void
>     vector<T, A>::push_back(value_type&& v)
>     {
>         // This function should move from v, potentially modifying
>         //   the object v is bound to.
>     }

If `v` is truly bound to a temporary, then `push_back` has the only reference to this temporary in the entire program. Thus any modifications will be invisible to the rest of the program.

If the client supplies `std::move(x)` to `push_back`, the onus is on the client to ensure that the value of `x` is no longer important to the logic of his program after this statement. I.e. the client is making a statement that `push_back` may treat `x` as a temporary.

> The above statement is the very foundation upon which move semantics is based.

The standard is currently lacking a global statement to this effect. I propose the following addition to 17.6.3.9 [res.on.arguments]:

> Each of the following statements applies to all arguments to functions defined in the C++ standard library, unless explicitly stated otherwise.

> - If an argument to a function has an invalid value (such as a value outside the domain of the function, or a pointer invalid for its intended use), the behavior is undefined.
> - If a function argument is described as being an array, the pointer actually passed to the function shall have a value such that all address computations and accesses to objects (that would be valid if the pointer did point to the first element of such an array) are in fact valid.
> - If a function argument binds to an rvalue reference parameter, the C++ standard library may assume that this parameter is a unique reference to this argument. If the parameter is a generic parameter of the form `T&&`, and an lvalue of type `A` is bound, then the binding is considered to be to an lvalue reference (14.9.2.1 [temp.deduct.call]) and thus not covered by this clause. [Note: If a program casts an lvalue to an rvalue while passing that lvalue to a library function (e.g. `move(x)`), then the program is effectively asking the library to treat that lvalue as a temporary. The library is at liberty to optimize away aliasing checks which might be needed if the argument were an lvalue. — end note]

Such a global statement will eliminate the need for piecemeal statements such as 23.2.1 [container.requirements.general]/13:

> An object bound to an rvalue reference parameter of a member function of a container shall not be an element of that container; no diagnostic required.

Additionally this clarifies that move assignment operators need not perform the traditional `if (this != &rhs)` test commonly found (and needed) in copy assignment operators.

[ 2009-09-13 Niels adds: ]

> Note: This resolution supports the change of 27.9.1.3 [filebuf.assign]/1, proposed by LWG 900.

[ 2009 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add a bullet to 17.6.3.9 [res.on.arguments]:

> Each of the following statements applies to all arguments to functions defined in the C++ standard library, unless explicitly stated otherwise.

> - If an argument to a function has an invalid value (such as a value outside the domain of the function, or a pointer invalid for its intended use), the behavior is undefined.
> - If a function argument is described as being an array, the pointer actually passed to the function shall have a value such that all address computations and accesses to objects (that would be valid if the pointer did point to the first element of such an array) are in fact valid.
> - If a function argument binds to an rvalue reference parameter, the C++ standard library may assume that this parameter is a unique reference to this argument. If the parameter is a generic parameter of the form `T&&`, and an lvalue of type `A` is bound, then the binding is considered to be to an lvalue reference (14.9.2.1 [temp.deduct.call]) and thus not covered by this clause. [Note: If a program casts an lvalue to an rvalue while passing that lvalue to a library function (e.g. `move(x)`), then the program is effectively asking the library to treat that lvalue as a temporary. The library is at liberty to optimize away aliasing checks which might be needed if the argument were an lvalue. — end note]

Delete 23.2.1 [container.requirements.general]/13:

> An object bound to an rvalue reference parameter of a member function of a container shall not be an element of that container; no diagnostic required.

### 1205. Some algorithms could more clearly document their handling of empty ranges

Section: 25 [algorithms] Status: New Submitter: Alisdair Meredith Opened: 2009-09-13 Last modified: 2009-09-13

View other active issues in [algorithms].

View all other issues in [algorithms].

View all issues with New status.

Discussion:

There are a number of algorithms whose result might depend on the handling of an empty range. In some cases the result is not clear, while in others it would help readers to clearly mention the result rather than require some subtle intuition of the supplied wording.

25.2.1 [alg.all_of]

> Returns: `true` if `pred(*i)` is `true` for every iterator `i` in the range `[first,last)`, ...

What does this mean if the range is empty?

I believe that we intend this to be `true` and suggest a non-normative note to clarify:

Add to p1 25.2.1 [alg.all_of]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

25.2.3 [alg.none_of]

> Returns: `true` if `pred(*i)` is `false` for every iterator `i` in the range `[first,last)`, ...

What does this mean if the range empty?

I believe that we intend this to be `true` and suggest a non-normative note to clarify:

Add to p1 25.2.3 [alg.none_of]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

25.2.2 [alg.any_of]

The specification for an empty range is actually fairly clear in this case, but a note wouldn't hurt and would be consistent with proposals for `all_of`/`none_of` algorithms.

Add to p1 25.2.2 [alg.any_of]:

> [Note: Returns `false` if `[first,last)` is empty. — end note]

25.2.6 [alg.find.end]

what does this mean if `[first2,last2)` is empty?

I believe the wording suggests the algorithm should return `last1` in this case, but am not 100% sure. Is this in fact the correct result anyway? Surely an empty range should always match and the naive expected result would be `first1`?

My proposed wording is a note to clarify the current semantic:

Add to p2 25.2.6 [alg.find.end]:

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

I would prefer a normative wording treating empty ranges specially, but do not believe we can change semantics at this point in the process, unless existing implementations actually yield this result:

Alternative wording: (NOT a note)

Add to p2 25.2.6 [alg.find.end]:

> Returns `first1` if `[first2,last2)` is empty.

25.2.7 [alg.find.first.of]

The phrasing seems precise when `[first2, last2)` is empty, but a small note to confirm the reader's understanding might still help.

Add to p2 25.2.7 [alg.find.first.of]

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

25.2.12 [alg.search]

What is the expected result if `[first2, last2)` is empty?

I believe the wording suggests the algorithm should return `last1` in this case, but am not 100% sure. Is this in fact the correct result anyway? Surely an empty range should always match and the naive expected result would be `first1`?

My proposed wording is a note to clarify the current semantic:

Add to p2 25.2.12 [alg.search]:

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

Again, I would prefer a normative wording treating empty ranges specially, but do not believe we can change semantics at this point in the process, unless existing implementations actually yield this result:

Alternative wording: (NOT a note)

Add to p2 25.2.12 [alg.search]:

> Returns `first1` if `[first2,last2)` is empty.

25.3.13 [alg.partitions]

Is an empty range partitioned or not?

Proposed wording:

Add to p1 25.3.13 [alg.partitions]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

25.4.5.1 [includes]

> Returns: `true` if every element in the range `[first2,last2)` is contained in the range `[first1,last1)`. ...

I really don't know what this means if `[first2,last2)` is empty. I could loosely guess that this implies empty ranges always match, and my proposed wording is to clarify exactly that:

Add to p1 25.4.5.1 [includes]:

> [Note: Returns `true` if `[first2,last2)` is empty. — end note]

25.4.6.2 [pop.heap]

The effects clause is invalid if the range `[first,last)` is empty, unlike all the other heap alogorithms. The should be called out in the requirements.

Proposed wording:

Revise p2 25.4.6.2 [pop.heap]

> Requires: The range `[first,last)` shall be a valid non-empty heap.

[Editorial] Reverse order of 25.4.6.2 [pop.heap] p1 and p2.

25.4.7 [alg.min.max]

`minmax_element` does not clearly specify behaviour for an empty range in the same way that `min_element` and `max_element` do.

Add to p31 25.4.7 [alg.min.max]:

> Returns `make_pair(first, first)` if `first == last`.

25.4.8 [alg.lex.comparison]

The wording here seems quite clear, especially with the sample algorithm implementation. A note is recommended purely for consistency with the rest of these issue resolutions:

Add to p1 25.4.8 [alg.lex.comparison]:

> [Note: An empty sequence is lexicographically less than any other non-empty sequence, but not to another empty sequence. — end note]

Proposed resolution:

Add to p1 25.2.1 [alg.all_of]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

Add to p1 25.2.2 [alg.any_of]:

> [Note: Returns `false` if `[first,last)` is empty. — end note]

Add to p1 25.2.3 [alg.none_of]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

Add to p2 25.2.6 [alg.find.end]:

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

Add to p2 25.2.7 [alg.find.first.of]

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

Add to p2 25.2.12 [alg.search]:

> [Note: Returns `last1` if `[first2,last2)` is empty. — end note]

Add to p1 25.3.13 [alg.partitions]:

> [Note: Returns `true` if `[first,last)` is empty. — end note]

Add to p1 25.4.5.1 [includes]:

> [Note: Returns `true` if `[first2,last2)` is empty. — end note]

Revise p2 25.4.6.2 [pop.heap]

> Requires: The range `[first,last)` shall be a valid non-empty heap.

[Editorial]

> Reverse order of 25.4.6.2 [pop.heap] p1 and p2.

Add to p31 25.4.7 [alg.min.max]:

> Returns `make_pair(first, first)` if `first == last`.

Add to p1 25.4.8 [alg.lex.comparison]:

> [Note: An empty sequence is lexicographically less than any other non-empty sequence, but not less than another empty sequence. — end note]

### 1206. Incorrect requires for `move_backward` and `copy_backward`

Section: 25.3.2 [alg.move] Status: New Submitter: Howard Hinnant Opened: 2009-09-13 Last modified: 2009-09-13

View all issues with New status.

Discussion:

25.3.2 [alg.move], p6 says:

>     template<class BidirectionalIterator1, class BidirectionalIterator2>
>       BidirectionalIterator2
>         move_backward(BidirectionalIterator1 first,
>                       BidirectionalIterator1 last,
>                       BidirectionalIterator2 result);

> > ...

> > Requires: `result` shall not be in the range `[first,last)`.

This is essentially an "off-by-one" error.

When `result == last`, which is allowed by this specification, then the range `[first, last)` is being move assigned into the range `[first, last)`. The `move` (forward) algorithm doesn't allow self move assignment, and neither should `move_backward`. So `last` should be included in the range which `result` can not be in.

Conversely, when `result == first`, which is not allowed by this specification, then the range `[first, last)` is being move assigned into the range `[first - (last-first), first)`. I.e. into a non-overlapping range. Therefore `first` should not be included in the range which `result` can not be in.

The same argument applies to `copy_backward` though copy assigning elements to themselves (`result == last`) should be harmless (though is disallowed by `copy`).

Proposed resolution:

Change 25.3.2 [alg.move], p6:

>     template<class BidirectionalIterator1, class BidirectionalIterator2>
>       BidirectionalIterator2
>         move_backward(BidirectionalIterator1 first,
>                       BidirectionalIterator1 last,
>                       BidirectionalIterator2 result);

> > ...

> > Requires: `result` shall not be in the range `[(first,last])`.

Change 25.3.1 [alg.copy], p13:

>     template<class BidirectionalIterator1, class BidirectionalIterator2>
>       BidirectionalIterator2
>         copy_backward(BidirectionalIterator1 first,
>                       BidirectionalIterator1 last,
>                       BidirectionalIterator2 result);

> > ...

> > Requires: `result` shall not be in the range `[(first,last])`.

### 1207. Underspecified std::list operations?

Section: 23.3.4.4 [list.ops] Status: New Submitter: Loïc Joly Opened: 2009-09-13 Last modified: 2009-09-19

View other active issues in [list.ops].

View all other issues in [list.ops].

View all issues with New status.

Discussion:

It looks to me like some operations of `std::list` (`sort`, `reverse`, `remove`, `unique` & `merge`) do not specify the validity of iterators, pointers & references to elements of the list after those operations. Is it implied by some other text in the standard?

I believe `sort` & `reverse` do not invalidating anything, `remove` & `unique` only invalidates what refers to erased elements, `merge` does not invalidate anything (with the same precision as `splice` for elements who changed of container). Are those assumptions correct ?

Proposed resolution:

### 1208. valarray initializer_list constructor has incorrect effects

Section: 26.6.2.1 [valarray.cons] Status: Tentatively Ready Submitter: Howard Hinnant Opened: 2009-09-23 Last modified: 2009-10-29

View all other issues in [valarray.cons].

View all issues with Tentatively Ready status.

Discussion:

26.6.2.1 [valarray.cons] says:

>     valarray(initializer_list<T> il);

> > Effects: Same as `valarray(il.begin(), il.end())`.

But there is no `valarray` constructor taking two `const T*`.

[ 2009-10-29 Howard: ]

> Moved to Tentatively Ready after 6 positive votes on c++std-lib.

Proposed resolution:

Change 26.6.2.1 [valarray.cons]:

>     valarray(initializer_list<T> il);

> > Effects: Same as `valarray(il.begin(), il.endsize())`.

### 1209. match_results should be moveable

Section: 28.10.1 [re.results.const] Status: New Submitter: Stephan T. Lavavej Opened: 2009-09-15 Last modified: 2009-09-21

View all issues with New status.

Discussion:

In Working Draft N2914, `match_results` lacks a move constructor and move assignment operator. Because it owns dynamically allocated memory, it should be moveable.

As far as I can tell, this isn't tracked by an active issue yet; Library Issue 723 doesn't talk about `match_results`.

[ 2009-09-21 Daniel provided wording. ]

Proposed resolution:

1. Add the following member declarations to 28.10 [re.results]/3:

   >     // 28.10.1, construct/copy/destroy:
   >     explicit match_results(const Allocator& a = Allocator());
   >     match_results(const match_results& m);
   >     match_results(match_results&& m);
   >     match_results& operator=(const match_results& m);
   >     match_results& operator=(match_results&& m);
   >     ~match_results();

2. Add the following new prototype descriptions to 28.10.1 [re.results.const] using the table numbering of N2723:

   >     match_results(const match_results& m);

   > > 4 Effects: Constructs an object of class `match_results`, as a copy of `m`.

   >     match_results(match_results&& m);

   > > 5 Effects: Move-constructs an object of class `match_results` from `m` satisfying the same postconditions as Table 132. Additionally the stored `Allocator` value is move constructed from `m.get_allocator()`. After the initialization of `*this` sets `m` to an unspecified but valid state.

   > > 6 Throws: Nothing if the allocator's move constructor throws nothing.

   >     match_results& operator=(const match_results& m);

   > > 7 Effects: Assigns `m` to `*this`. The postconditions of this function are indicated in Table 132.

   >     match_results& operator=(match_results&& m);

   > > 8 Effects: Move-assigns `m` to `*this`. The postconditions of this function are indicated in Table 132. After the assignment, `m` is in a valid but unspecified state.

   > > 9 Throws: Nothing.

### 1210. iterator reachability should not require a container

Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-09-19

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with New status.

Discussion:

p6 Iterator requirements 24.2 [iterator.requirements]

> An iterator `j` is called reachable from an iterator `i` if and only if there is a finite sequence of applications of the expression `++i` that makes `i == j`. If `j` is reachable from `i`, they refer to the same container.

A good example would be stream iterators, which do not refer to a container. Typically, the end iterator from a range of stream iterators will compare equal for many such ranges. I suggest striking the second sentence.

An alternative wording might be:

> If `j` is reachable from `i`, and both `i` and `j` are dereferencable iterators, then they refer to the same range.

Proposed resolution:

Change 24.2 [iterator.requirements], p6:

> An iterator `j` is called reachable from an iterator `i` if and only if there is a finite sequence of applications of the expression `++i` that makes `i == j`. If `j` is reachable from `i`, they refer to the same container.

### 1211. move iterators should be restricted as input iterators

Section: 24.5.3.1 [move.iterator] Status: Open Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-10-26

View all other issues in [move.iterator].

View all issues with Open status.

Discussion:

I contend that while we can support both bidirectional and random access traversal, the category of a move iterator should never be better than `input_iterator_tag`.

The contentious point is that you cannot truly have a multipass property when values are moved from a range. This is contentious if you view a moved-from object as still holding a valid value within the range.

The second reason comes from the Forward Iterator requirements table:

> Forward iterators 24.2.3 [forward.iterators]

> Table 102 -- Forward iterator requirements

> > For expression `*a` the return type is: "`T&` if `X` is mutable, otherwise `const T&`"

There is a similar constraint on `a->m`.

There is no support for rvalue references, nor do I believe their should be. Again, opinions may vary but either this table or the definition of `move_iterator` need updating.

Note: this requirement probably need updating anyway if we wish to support proxy iterators but I am waiting to see a new working paper before filing that issue.

[ 2009-10 post-Santa Cruz: ]

> Move to Open. Howard to put his rationale mentioned above into the issue as a note.

[ 2009-10-26 Howard adds: ]

> `vector::insert(pos, iter, iter)` is significantly more effcient when `iter` is a random access iterator, as compared to when it is an input iterator.

> When `iter` is an input iterator, the best algorithm is to append the inserted range to the end of the `vector` using `push_back`. This may involve several reallocations before the input range is exhausted. After the append, then one can use `std::rotate` to place the inserted range into the correct position in the vector.

> But when `iter` is a random access iterator, the best algorithm is to first compute the size of the range to be inserted (`last - first`), do a buffer reallocation if necessary, scoot existing elements in the `vector` down to make the "hole", and then insert the new elements directly to their correct place.

> > The insert-with-random-access-iterators algorithm is considerably more efficient than the insert-with-input-iterators algorithm

> Now consider:

> >     vector<A> v;
> >     //  ... build up a large vector of A ...
> >     vector<A> temp;
> >     //  ... build up a large temporary vector of A to later be inserted ...
> >     typedef move_iterator<vector<A>::iterator> MI;
> >     //  Now insert the temporary elements:
> >     v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));

> A major motivation for using `move_iterator` in the above example is the expectation that `A` is cheap to move but expensive to copy. I.e. the customer is looking for high performance. If we allow `vector::insert` to subtract two `MI`'s to get the distance between them, the customer enjoys substantially better performance, compared to if we say that `vector::insert` can not subtract two `MI`'s.

> I can find no rationale for not giving this performance boost to our customers. Therefore I am strongly against restricting `move_iterator` to the `input_iterator_tag` category.

> I believe that the requirement that forward iterators have a dereference that returns an lvalue reference to cause unacceptable pessimization. For example `vector<bool>::iterator` also does not return a `bool&` on dereference. Yet I am not aware of a single vendor that is willing to ship `vector<bool>::iterator` as an input iterator. Everyone classifies it as a random access iterator. Not only does this not cause any problems, it prevents significant performance problems.

Proposed resolution:

Class template move_iterator 24.5.3.1 [move.iterator]

>     namespace std {
>     template <class Iterator>
>     class move_iterator {
>     public:
>      ...
>      typedef typename iterator_traits<Iterator>::iterator_category input_iterator_tag iterator_category;

### 1212. result of post-increment/decrement operator

Section: 24.2 [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-09-18 Last modified: 2009-09-19

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with New status.

Discussion:

Forward iterator and bidirectional iterator place different requirements on the result of post-increment/decrement operator. The same form should be used in each case.

Merging row from:

>     Table 102 -- Forward iterator requirements
>     Table 103 -- Bidirectional iterator requirements

>         r++ : convertible to const X&
>         r-- : convertible to const X&

>         *r++ : T& if X is mutable, otherwise const T&
>         *r-- : convertible to T

Proposed resolution:

### 1213. Meaning of valid and singular iterator underspecified

Section: 24.2 [iterator.requirements] Status: New Submitter: Daniel Krügler Opened: 2009-09-19 Last modified: 2009-09-19

View other active issues in [iterator.requirements].

View all other issues in [iterator.requirements].

View all issues with New status.

Discussion:

The terms valid iterator and singular aren't properly defined. The fuzziness of those terms became even worse after the resolution of 208 (including further updates by 278). In 24.2 [iterator.requirements] as of N2723 the standard says now:

> 5 - These values are called past-the-end values. Values of an iterator `i` for which the expression `*i` is defined are called dereferenceable. The library never assumes that past-the-end values are dereferenceable. Iterators can also have singular values that are not associated with any container. [...] Results of most expressions are undefined for singular values; the only exceptions are destroying an iterator that holds a singular value and the assignment of a non-singular value to an iterator that holds a singular value. [...] Dereferenceable values are always non-singular.

> 10 - An invalid iterator is an iterator that may be singular.

First, issue 208 intentionally removed the earlier constraint that past-the-end values are always non-singular. The reason for this was to support null pointers as past-the-end iterators of e.g. empty sequences. But there seem to exist different views on what a singular (iterator) value is. E.g. according to the SGI definition a null pointer is not a singular value:

> Dereferenceable iterators are always nonsingular, but the converse is not true. For example, a null pointer is nonsingular (there are well defined operations involving null pointers) even thought it is not dereferenceable.

and proceeds:

> An iterator is valid if it is dereferenceable or past-the-end.

Even if the standard prefers a different meaning of singular here, the change was incomplete, because by restricting feasible expressions of singular iterators to destruction and assignment isn't sufficient for a past-the-end iterator: Of-course it must still be equality-comparable and in general be a readable value.

Second, the standard doesn't clearly say whether a past-the-end value is a valid iterator or not. E.g. 20.8.13 [specialized.algorithms]/1 says:

> In all of the following algorithms, the formal template parameter `ForwardIterator` is required to satisfy the requirements of a forward iterator (24.1.3) [..], and is required to have the property that no exceptions are thrown from [..], or dereference of valid iterators.

The standard should make better clear what "singular pointer" and "valid iterator" means. The fact that the meaning of a valid value has a core language meaning doesn't imply that for an iterator concept the term "valid iterator" has the same meaning.

Let me add a final example: In X [allocator.concepts.members] of N2914 we find:

>     pointer X::allocate(size_type n);

> > 11 Returns: a pointer to the allocated memory. [Note: if `n == 0`, the return value is unspecified. —end note]

> [..]

>     void X::deallocate(pointer p, size_type n);

> > Preconditions: `p` shall be a non-singular pointer value obtained from a call to `allocate()` on this allocator or one that compares equal to it.

If singular pointer value would include null pointers this make the preconditions unclear if the pointer value is a result of `allocate(0)`: Since the return value is unspecified, it could be a null pointer. Does that mean that programmers need to check the pointer value for a null value before calling deallocate?

Proposed resolution:

### 1214. Insufficient/inconsistent key immutability requirements for associative containers

Section: 23.2.4 [associative.reqmts] Status: New Submitter: Daniel Krügler Opened: 2009-09-20 Last modified: 2009-09-20

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with New status.

Discussion:

Scott Meyers' mentions on a recent posting on c.s.c++ some arguments that point to an incomplete resolution of 103 and to an inconsistency of requirements on keys in ordered and unordered associative containers:

> 1) 103 introduced the term immutable without defining it in a unique manner in 23.2.4 [associative.reqmts]/5:

> > [..] Keys in an associative container are immutable.

> According to conventional dictionaries immutable is an unconditional way of saying that something cannot be changed. So without any further explicit allowance a user always runs into undefined behavior if (s)he attempts to modify such a key. IMO this was not the intend of the committee to resolve 103 in that way because the comments suggest an interpretation that should give any user the freedom to modify the key in an explicit way provided it would not affect the sort order in that container.

> 2) Another observation was that surprisingly no similar 'safety guards' exists against unintentional key changes for the unordered associative containers, specifically there is no such requirement as in 23.2.4 [associative.reqmts]/6 that "both `iterator` and `const_iterator` are constant iterators". But the need for such protection against unintentional changes as well as the constraints in which manner any explicit changes may be performed are both missing and necessary, because such changes could potentially change the equivalence of keys that is measured by the `hasher` and `key_equal`.

> I suggest to fix the unconditional wording involved with "immutable keys" by at least adding a hint for the reader that users may perform such changes in an explicit manner and to perform similar wording changes as 103 did for the ordered associative containers also for the unordered containers.

Proposed resolution:

### 1215. `list::merge` with unequal allocators

Section: 23.3.4.4 [list.ops] Status: New Submitter: Pablo Halpern Opened: 2009-09-24 Last modified: 2009-09-24

View other active issues in [list.ops].

View all other issues in [list.ops].

View all issues with New status.

Discussion:

In Bellevue (I think), we passed N2525, which, among other things, specifies that the behavior of `list::splice` is undefined if the allocators of the two lists being spliced do not compare equal. The same rationale should apply to `list::merge`. The intent of `list::merge` (AFAIK) is to move nodes from one sorted `list` into another sorted `list` without copying the elements. This is possible only if the allocators compare equal.

Proposed resolution:

Relative to the August 2009 WP, N2857, change 23.3.4.4 [list.ops], paragraphs 22-25 as follows:

>     void merge(list&& x);
>     template <class Compare> void merge(list&& x, Compare comp);

> > Requires: both the list and the argument list shall be sorted according to operator< or comp.

> > Effects: If `(&x == this)` does nothing; otherwise, merges the two sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result is a range in which the elements will be sorted in non-decreasing order according to the ordering defined by `comp`; that is, for every iterator `i`, in the range other than the `first`, the condition `comp(*i, *(i - 1))` will be `false`.

> > Remarks: Stable. If `(&x != this)` the range `[x.begin(), x.end())` is empty after the merge. No elements are copied by this operation. The behavior is undefined if `this->get_allocator() != x.get_allocator()`.

> > Complexity: At most `size() + x.size() - 1` applications of `comp` if `(&x != this)`; otherwise, no applications of `comp` are performed. If an exception is thrown other than by a comparison there are no effects.

### 1216. LWG 1066 Incomplete?

Section: 18.8.6 [except.nested] Status: Ready Submitter: Pete Becker Opened: 2009-09-25 Last modified: 2009-10-20

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with Ready status.

Discussion:

LWG 1066 adds `[[noreturn]]` to a bunch of things. It doesn't add it to `rethrow_nested()`, which seems like an obvious candidate. I've made the changes indicated in the issue, and haven't changed `rethrow_nested()`.

[ 2009 Santa Cruz: ]

> Move to Ready.

Proposed resolution:

Add `[[noreturn]]` to `rethrow_nested()` in 18.8.6 [except.nested].

### 1218. mutex destructor synchronization

Section: 30.4.1 [thread.mutex.requirements] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with New status.

Discussion:

If an object `*o` contains a mutex `mu` and a correctly-maintained reference count `c`, is the following code safe?

>     o->mu.lock();
>     bool del = (--(o->c) == 0);
>     o->mu.unlock();
>     if (del) { delete o; }

If the implementation of `mutex::unlock()` can touch the mutex's memory after the moment it becomes free, this wouldn't be safe, and "Construction and destruction of an object of a Mutex type need not be thread-safe" 30.4.1 [thread.mutex.requirements] may imply that it's not safe. Still, it's useful to allow mutexes to guard reference counts, and if it's not allowed, users are likely to write bugs.

Proposed resolution:

### 1219. unique_lock::lock and resource_deadlock_would_occur

Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.lock.unique.locking].

View all other issues in [thread.lock.unique.locking].

View all issues with New status.

Discussion:

`unique_lock::lock` and friends raise "`resource_deadlock_would_occur` -- if the current thread already owns the mutex (i.e., on entry, `owns` is `true`)." 1) The current thread owning a mutex is not the same as any particular `unique_lock::owns` being `true`. 2) There's no need to raise this exception for a `recursive_mutex` if `owns` is `false`. 3) If `owns` is true, we need to raise some exception or the unique_lock will lose track of whether to unlock itself on destruction, but "deadlock" isn't it. For (3), s/bool owns/int ownership_level/ would fix it.

Proposed resolution:

### 1220. What does condition_variable wait on?

Section: 30.5 [thread.condition] Status: Tentatively Ready Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-11-06

View other active issues in [thread.condition].

View all other issues in [thread.condition].

View all issues with Tentatively Ready status.

Discussion:

"Class `condition_variable` provides a condition variable that can only wait on an object of type `unique_lock`" should say "...object of type `unique_lock<mutex>`"

[ 2009-11-06 Howard adds: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Change 30.5 [thread.condition], p1:

> Condition variables provide synchronization primitives used to block a thread until notified by some other thread that some condition is met or until a system time is reached. Class `condition_variable` provides a condition variable that can only wait on an object of type `unique_lock<mutex>`, allowing maximum efficiency on some platforms. Class `condition_variable_any` provides a general condition variable that can wait on objects of user-supplied lock types.

### 1221. condition_variable wording

Section: 30.5.1 [thread.condition.condvar] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.condition.condvar].

View all other issues in [thread.condition.condvar].

View all issues with New status.

Discussion:

30.5.1 [thread.condition.condvar] says:

>     ~condition_variable();

> > Precondition: There shall be no thread blocked on `*this`. [Note: That is, all threads shall have been notified; they may subsequently block on the lock specified in the wait. Beware that destroying a `condition_variable` object while the corresponding predicate is `false` is likely to lead to undefined behavior. — end note]

The text hasn't introduced the notion of a "corresponding predicate" yet.

Proposed resolution:

### 1222. condition_variable incorrect effects for exception safety

Section: 30.5 [thread.condition] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.condition].

View all other issues in [thread.condition].

View all issues with New status.

Discussion:

30.5.1 [thread.condition.condvar] says:

>     void wait(unique_lock<mutex>& lock);

> > ...

> > Effects:

> > - ...
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

Should that be `lock.lock()`?

Proposed resolution:

Change 30.5.1 [thread.condition.condvar] p10:

>     void wait(unique_lock<mutex>& lock);

> > ...

> > Effects:

> > - ...
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

And make a similar change in p16, and in 30.5.2 [thread.condition.condvarany], p8 and p13.

### 1223. condition_variable_any lock matching?

Section: 30.5.2 [thread.condition.condvarany] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.condition.condvarany].

View all other issues in [thread.condition.condvarany].

View all issues with New status.

Discussion:

For `condition_variable_any`, must all lock arguments to concurrent wait calls "match" in some way, similar to the requirement in 30.5.1 [thread.condition.condvar] that `lock.mutex()` returns the same value for each of the lock arguments supplied by all concurrently waiting threads (via `wait` or `timed_wait`)?

Proposed resolution:

### 1224. condition_variable_any support for recursive mutexes?

Section: 30.5.2 [thread.condition.condvarany] Status: New Submitter: Jeffrey Yasskin Opened: 2009-09-30 Last modified: 2009-09-30

View other active issues in [thread.condition.condvarany].

View all other issues in [thread.condition.condvarany].

View all issues with New status.

Discussion:

For `condition_variable_any`, are recursive mutexes allowed? (I think "no")

Proposed resolution:

### 1225. C++0x result_of issue

Section: 20.7.4 [func.ret] Status: New Submitter: Sebastian Gesemann Opened: 2009-10-05 Last modified: 2009-10-17

View all other issues in [func.ret].

View all issues with New status.

Discussion:

I think the text about `std::result_of` could be a little more precise. Quoting from N2960...

> 20.7.4 [func.ret] Function object return types

>     template<class> class result_of;

>     template<class Fn, class... ArgTypes>
>     class result_of<Fn(ArgTypes...)> {
>     public:
>       typedef see below type;
>     };

> Given an rvalue `fn` of type `Fn` and values `t1, t2, ..., tN` of types `T1, T2, ... TN` in `ArgTypes` respectivly, the `type` member is the result type of the expression `fn(t1,t2,...,tN)`. the values `ti` are lvalues when the corresponding type `Ti` is an lvalue-reference type, and rvalues otherwise.

This text doesn't seem to consider lvalue reference types for `Fn`. Also, it's not clear whether this class template can be used for "SFINAE" like `std::enable_if`. Example:

>     template<typename Fn, typename... Args>
>     typename std::result_of<Fn(Args...)>::type
>     apply(Fn && fn, Args && ...args)
>     {
>       // Fn may be an lvalue reference, too
>       return std::forward<Fn>(fn)(std::forward<Args>(args)...);
>     }

Either `std::result_of<...>` can be instantiated and simply may not have a typedef "`type`" (-->SFINAE) or instantiating the class template for some type combinations will be a "hard" compile-time error.

Proposed resolution:

[ These changes will require compiler support ]

Change 20.7.4 [func.ret]:

>     template<class> class result_of; // undefined

>     template<class Fn, class... ArgTypes>
>     class result_of<Fn(ArgTypes...)> {
>     public:
>       typedef see below type;
>     };

> Given an rvalue `fn` of type `Fn` and values `t1, t2, ..., tN` of types `T1, T2, ... TN` in `ArgTypes` respectivly, the `type` member is the result type of the expression `fn(t1,t2,...,tN)`. the values `ti` are lvalues when the corresponding type `Ti` is an lvalue-reference type, and rvalues otherwise.

> The class template `result_of` shall meet the requirements of a TransformationTrait: Given the types `Fn`, `T1`, `T2`, ..., `TN` every template specialization `result_of<Fn(T1,T2,...,TN)>` shall define the member typedef type equivalent to `decltype(RE)` if and only if the expression `RE`

> >     value<Fn>() ( value<T1>(), value<T2>(), ... value<TN>()  )

> would be well-formed. Otherwise, there shall be no member typedef `type` defined.

[ The `value<>` helper function is a utility Daniel Krügler proposed in N2958. ]

### 1226. Incomplete changes of #890

Section: 30.6.2 [futures.errors] Status: Tentatively Ready Submitter: Daniel Krügler Opened: 2009-10-05 Last modified: 2009-10-27

View all issues with Tentatively Ready status.

Discussion:

Defect issue 890 overlooked to adapt the `future_category` from 30.6.1 [futures.overview] and 30.6.2 [futures.errors]:

>     extern const error_category* const future_category;

which should be similarly transformed into function form.

[ 2009-10-27 Howard: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

1. Change in 30.6.1 [futures.overview], header `<future>` synopsis:

   >     extern const error_category&* const future_category();

2. Change in 30.6.2 [futures.errors]:

   >     extern const error_category&* const future_category();

   > > 1- `future_category` shall point to a statically initialized object of a type derived from class `error_category`.

   > > 1- Returns: A reference to an object of a type derived from class `error_category`.

   >     constexpr error_code make_error_code(future_errc e);

   > > 3 Returns: `error_code(static_cast<int>(e), *future_category())`.

   >     constexpr error_code make_error_condition(future_errc e);

   > > 4 Returns: `error_condition(static_cast<int>(e), *future_category())`.

### 1227. `<bitset>` synopsis overspecified

Section: 20.3.7 [template.bitset] Status: Ready Submitter: Bo Persson Opened: 2009-10-05 Last modified: 2009-10-26

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with Ready status.

Discussion:

The resolutions to some library defect reports, like 1178 requires that `#includes` in each synopsis should be taken literally. This means that the `<bitset>` header now must include `<stdexcept>`, even though none of the exceptions are mentioned in the `<bitset>` header.

Many other classes are required to throw exceptions like `invalid_argument` and `out_of_range`, without explicitly including `<stdexcept>` in their synopsis. It is totally possible for implementations to throw the needed exceptions from utility functions, whose implementations are not visible in the headers.

I propose that `<stdexcept>` is removed from the `<bitset>` header.

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

Change 20.3.7 [template.bitset]:

>     #include <cstddef>        // for size_t
>     #include <string>
>     #include <stdexcept>      // for invalid_argument,
>                               // out_of_range, overflow_error
>     #include <iosfwd>         // for istream, ostream
>     namespace std {
>     ...

### 1228. User-specialized nothrow type traits

Section: 20.6.4.3 [meta.unary.prop] Status: Open Submitter: Alisdair Meredith Opened: 2009-10-07 Last modified: 2009-10-26

View other active issues in [meta.unary.prop].

View all other issues in [meta.unary.prop].

View all issues with Open status.

Discussion:

According to p1 20.6.2 [meta.type.synop]:

> The behavior of a program that adds specializations for any of the class templates defined in this subclause is undefined unless otherwise specified.

I believe we should 'otherwise specify' for the nothrow traits, are these are exactly the use cases where the end user actually has more information than the compiler.

[ 2009-10 Santa Cruz: ]

> Moved to Open. Definitely need to give the users the ability to ensure that the traits give the right answers. Unsure we want to give them the ability to say this in more than one way. Believes the noexcept proposal already gives this.

Proposed resolution:

Add the following comment:

> user specialization permitted to derive from `std::true_type` when the operation is known not to throw.

to the following traits in 20.6.4.3 [meta.unary.prop] Table 43 Type property predicates.

[ This may require a new Comments column ]

>     has_nothrow_default_constructor
>     has_nothrow_copy_constructor
>     has_nothrow_assign

### 1231. `weak_ptr` comparisons incompletely resolved

Section: 20.8.15.3.5 [util.smartptr.weak.obs] Status: Tentatively Ready Submitter: Daniel Krügler Opened: 2009-10-10 Last modified: 2009-11-06

View all issues with Tentatively Ready status.

Discussion:

The n2637 paper suggested several updates of the ordering semantics of `shared_ptr` and `weak_ptr`, among those the explicit comparison operators of `weak_ptr` were removed/deleted, instead a corresponding functor `owner_less` was added. The problem is that n2637 did not clearly enough specify, how the previous wording parts describing the comparison semantics of `weak_ptr` should be removed.

[ 2009-11-06 Howard adds: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

1. Change 20.8.15.3 [util.smartptr.weak]/2 as described, the intention is to fix the now no longer valid requirement that `weak_ptr` is `LessComparable` [Note the deleted comma]:

   > Specializations of `weak_ptr` shall be `CopyConstructible`, and `CopyAssignable`, and `LessThanComparable`, allowing their use in standard containers.

2. In 20.8.15.3.5 [util.smartptr.weak.obs] remove the paragraphs 9-11 including prototype:

   > template<class T, class U> bool operator<(const weak_ptr<T>& a, const weak_ptr<U>& b);

   > Returns: an unspecified value such that

   > - `operator<` is a strict weak ordering as described in 25.4;
   > - under the equivalence relation defined by `operator<`, `!(a < b) && !(b < a)`, two `weak_ptr` instances are equivalent if and only if they share ownership or are both empty.

   > Throws: nothing.

   > [Note: Allows `weak_ptr` objects to be used as keys in associative containers. — end note]

### 1233. Missing `unique_ptr` signatures in synopsis

Section: 20.8 [memory] Status: Tentatively NAD Editorial Submitter: Daniel Krügler Opened: 2009-10-11 Last modified: 2009-11-04

View all other issues in [memory].

View all issues with Tentatively NAD Editorial status.

Discussion:

Related to 296. Some `unique_ptr` signatures are missing from the synopsis in 20.8 [memory].

[ 2009-11-04 Howard adds: ]

> Moved to Tentatively NAD Editorial. The editor has adopted the fix.

Proposed resolution:

Add in 20.8 [memory], Header `<memory>` synopsis missing declarations as shown below:

>     // 20.8.11 Class unique_ptr:
>     template <class X> class default_delete;
>     template<class T> struct default_delete<T[]>;
>     template <class X, class D = default_delete<T>> class unique_ptr;
>     template<class T, class D> class unique_ptr<T[], D>;

>     template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);

>     template<class T1, class D1, class T2, class D2>
>     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
>     template<class T1, class D1, class T2, class D2>
>     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
>     template<class T1, class D1, class T2, class D2>
>     bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
>     template<class T1, class D1, class T2, class D2>
>     bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
>     template<class T1, class D1, class T2, class D2>
>     bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
>     template<class T1, class D1, class T2, class D2>
>     bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

### 1234. "Do the right thing" and NULL

Section: 23.2.3 [sequence.reqmts] Status: New Submitter: Matt Austern Opened: 2009-10-09 Last modified: 2009-10-13

View other active issues in [sequence.reqmts].

View all other issues in [sequence.reqmts].

View all issues with New status.

Discussion:

On g++ 4.2.4 (x86_64-linux-gnu), the following file gives a compile error:

>     #include <vector>
>     void foo() { std::vector<int*> v(500l, NULL); }

Is this supposed to work?

The issue: if `NULL` happens to be defined as `0l`, this is an invocation of the constructor with two arguments of the same integral type. 23.2.3 [sequence.reqmts]/11 says that this will behave as if the the overloaded constructor

>     X(size_type, const value_type& = value_type(),
>       const allocator_type& = allocator_type())

were called instead, with the arguments `static_cast<size_type>(first)`, `last` and `alloc`, respectively. However, it does not say whether this actually means invoking that constructor with the exact textual form of the arguments as supplied by the user, or whether the standard permits an implementation to invoke that constructor with variables of the same type and value as what the user passed in. In most cases this is a distinction without a difference. In this particular case it does make a difference, since one of those things is a null pointer constant and the other is not.

Note that an implementation based on forwarding functions will use the latter interpretation.

Proposed resolution:

### 1237. Constrained error_code/error_condition members

Section: 19.5 [syserr] Status: Ready Submitter: Daniel Krügler Opened: 2009-10-14 Last modified: 2009-10-26

View all other issues in [syserr].

View all issues with Ready status.

Discussion:

I'm just reflecting on the now SFINAE-constrained constructors and assignment operators of `error_code` and `error_condition`:

These are the only library components that are pro-actively announcing that they are using `std::enable_if` as constraining tool, which has IMO several disadvantages:

1. With the availability of template default arguments and decltype, using `enable_if` in C++0x standard library, seems unnecessary restricting implementation freedom. E.g. there should be not need for a useless specification of a dummy default function argument, which only confuses the reader. A more reasonable implementation could e.g. be

   >     template <class ErrorCodeEnum
   >      class = typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type>
   >     error_code(ErrorCodeEnum e);

   As currently specified, the function signatures are so unreadable, that errors quite easily happen, see e.g. 1229.

2. We have a lot of constrained functions in other places, that now have a standard phrase that is easily understandable:

   > Remarks: This constructor/function shall participate in overload resolution if and only if X.

   where X describes the condition. Why should these components deviate?

3. If `enable_if` would not be explicitly specified, the standard library is much better prepared for the future. It would also be possible, that libraries with partial support for not-yet-standard-concepts could provide a much better diagnostic as is possible with `enable_if`. This again would allow for experimental concept implementations in the wild, which as a result would make concept standardization a much more natural thing, similar to the way as templates were standardized in C++.

   In summary: I consider it as a library defect that `error_code` and `error_condition` explicitly require a dependency to `enable_if` and do limit implementation freedom and I volunteer to prepare a corresponding resolution.

[ 2009-10-18 Beman adds: ]

> I support this proposed resolution, and thank Daniel for writing it up.

[ 2009-10 Santa Cruz: ]

> Moved to Ready.

Proposed resolution:

[ Should this resolution be accepted, I recommend to resolve 1229 as NAD ]

1. In 19.5.2.1 [syserr.errcode.overview]/1, class `error_code`, change as indicated:

   >     // 19.5.2.2 constructors:
   >     error_code();
   >     error_code(int val, const error_category& cat);
   >     template <class ErrorCodeEnum>
   >       error_code(ErrorCodeEnum e,
   >         typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0);

   >     // 19.5.2.3 modifiers:
   >     void assign(int val, const error_category& cat);
   >     template <class ErrorCodeEnum>
   >       typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code&
   >         operator=(ErrorCodeEnum e);
   >     void clear();

2. Change 19.5.2.2 [syserr.errcode.constructors] around the prototype before p. 7:

   >     template <class ErrorCodeEnum>
   >     error_code(ErrorCodeEnum e,
   >       typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0);

   > > Remarks: This constructor shall not participate in overload resolution, unless `is_error_code_enum<ErrorCodeEnum>::value == true`.

3. Change 19.5.2.3 [syserr.errcode.modifiers] around the prototype before p. 3:

   >     template <class ErrorCodeEnum>
   >       typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code&
   >         operator=(ErrorCodeEnum e);

   > > Remarks: This operator shall not participate in overload resolution, unless `is_error_code_enum<ErrorCodeEnum>::value == true`.

4. In 19.5.3.1 [syserr.errcondition.overview]/1, class `error_condition`, change as indicated:

   >     // 19.5.3.2 constructors:
   >     error_condition();
   >     error_condition(int val, const error_category& cat);
   >     template <class ErrorConditionEnum>
   >       error_condition(ErrorConditionEnum e,
   >         typename enable_if<is_error_condition_enum<ErrorConditionEnum>::type* = 0);

   >     // 19.5.3.3 modifiers:
   >     void assign(int val, const error_category& cat);
   >     template<typenameclass ErrorConditionEnum>
   >       typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::typeerror_condition &
   >         operator=( ErrorConditionEnum e );
   >     void clear();

5. Change 19.5.3.2 [syserr.errcondition.constructors] around the prototype before p. 7:

   >     template <class ErrorConditionEnum>
   >       error_condition(ErrorConditionEnum e,
   >         typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type* = 0);

   > > Remarks: This constructor shall not participate in overload resolution, unless `is_error_condition_enum<ErrorConditionEnum>::value == true`.

6. Change 19.5.3.3 [syserr.errcondition.modifiers] around the prototype before p. 3:

   >     template <class ErrorConditionEnum>
   >       typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::typeerror_condition&
   >         operator=(ErrorConditionEnum e);

   > > Remarks: This operator shall not participate in overload resolution, unless `is_error_condition_enum<ErrorConditionEnum>::value == true`.

   > > Postcondition: `*this == make_error_condition(e)`.

   > > Returns: `*this`

### 1238. defining algorithms taking iterator for range

Section: 25 [algorithms] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-10-15 Last modified: 2009-11-03

View other active issues in [algorithms].

View all other issues in [algorithms].

View all issues with Tentatively NAD Future status.

Discussion:

The library has many algorithms that take a source range represented by a pair of iterators, and the start of some second sequence given by a single iterator. Internally, these algorithms will produce undefined behaviour if the second 'range' is not as large as the input range, but none of the algorithms spell this out in Requires clauses, and there is no catch-all wording to cover this in clause 17 or the front matter of 25.

There was an attempt to provide such wording in paper n2944 but this seems incidental to the focus of the paper, and getting the wording of this issue right seems substantially more difficult than the simple approach taken in that paper. Such wording will be removed from an updated paper, and hopefully tracked via the LWG issues list instead.

It seems there are several classes of problems here and finding wording to solve all in one paragraph could be too much. I suspect we need several overlapping requirements that should cover the desired range of behaviours.

Motivating examples:

A good initial example is the `swap_ranges` algorithm. Here there is a clear requirement that `first2` refers to the start of a valid range at least as long as the range `[first1, last1)`. n2944 tries to solve this by positing a hypothetical `last2` iterator that is implied by the signature, and requires `distance(first2,last2) < distance(first1,last1)`. This mostly works, although I am uncomfortable assuming that `last2` is clearly defined and well known without any description of how to obtain it (and I have no idea how to write that).

A second motivating example might be the `copy` algorithm. Specifically, let us image a call like:

>     copy(istream_iterator<int>(is),istream_iterator(),ostream_iterator<int>(os));

In this case, our input iterators are literally simple `InputIterators`, and the destination is a simple `OutputIterator`. In neither case am I happy referring to `std::distance`, in fact it is not possible for the `ostream_iterator` at all as it does not meet the requirements. However, any wording we provide must cover both cases. Perhaps we might deduce `last2 == ostream_iterator<int>{}`, but that might not always be valid for user-defined iterator types. I can well imagine an 'infinite range' that writes to `/dev/null` and has no meaningful `last2`.

The motivating example in n2944 is `std::equal`, and that seems to fall somewhere between the two.

Outlying examples might be `partition_copy` that takes two output iterators, and the `_n` algorithms where a range is specified by a specific number of iterations, rather than traditional iterator pair. We should also not accidentally apply inappropriate constraints to `std::rotate` which takes a third iterator that is not intended to be a separate range at all.

I suspect we want some wording similar to:

> For algorithms that operate on ranges where the end iterator of the second range is not specified, the second range shall contain at least as many elements as the first.

I don't think this quite captures the intent yet though. I am not sure if 'range' is the right term here rather than sequence. More awkwardly, I am not convinced we can describe an Output sequence such as produce by an `ostream_iterator` as "containing elements", at least not as a precondition to the call before they have been written.

Another idea was to describe require that the trailing iterator support at least distance(input range) applications of `operator++` and may be written through the same number of times if a mutable/output iterator.

We might also consider handling the case of an output range vs. an input range in separate paragraphs, if that simplifies how we describe some of these constraints.

[ 2009-11-03 Howard adds: ]

> Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.

Proposed resolution:

### 1239. Defect report

Section: 20.6.4.3 [meta.unary.prop] Status: Tentatively NAD Editorial Submitter: David Abrahams Opened: 2009-10-16 Last modified: 2009-10-26

View other active issues in [meta.unary.prop].

View all other issues in [meta.unary.prop].

View all issues with Tentatively NAD Editorial status.

Discussion:

Table 43 defines a number of traits that yield true for arrays of class types with the trait's property, but not arrays of other types with that property. For example, `has_trivial_default_constructor`:

> `T` is a trivial type (3.9) or a class type with a trivial default constructor (12.1) or an array of such a class type.

[ 2009-10 post-Santa Cruz: ]

> An array of a trivial type is a trivial type.

> Mark as Tentatively NAD Editorial. The wording is OK as is, since an array of a trivial type is a trivial type, but the wording as proposed might be clearer.

Proposed resolution:

Change all the traits in question following this pattern:

> `T` is a trivial type (3.9) or a class type with a trivial default constructor (12.1), or an array of such a class type.

i.e., add a comma and delete a "class."

### 1240. Deleted comparison functions of std::function not needed

Section: 20.7.15.2 [func.wrap.func] Status: New Submitter: Daniel Krügler Opened: 2009-10-18 Last modified: 2009-10-19

View all other issues in [func.wrap.func].

View all issues with New status.

Discussion:

The class template `std::function` contains the following member declarations:

>     // deleted overloads close possible hole in the type system
>     template<class R2, class... ArgTypes2>
>       bool operator==(const function<R2(ArgTypes2...)>&) = delete;
>     template<class R2, class... ArgTypes2>
>       bool operator!=(const function<R2(ArgTypes2...)>&) = delete;

The leading comment here is part of the history of `std::function`, which was introduced with N1402. During that time no explicit conversion functions existed, and the "safe-bool" idiom (based on pointers-to-member) was a popular technique. The only disadvantage of this idiom was that given two objects `f1` and `f2` of type `std::function` the expression

>     f1 == f2;

was well-formed, just because the built-in `operator==` for pointer to member was considered after a single user-defined conversion. To fix this, an overload set of undefined comparison functions was added, such that overload resolution would prefer those ending up in a linkage error. The new language facility of deleted functions provided a much better diagnostic mechanism to fix this issue.

The central point of this issue is, that with the replacement of the safe-bool idiom by explicit conversion to bool the original "hole in the type system" does no longer exist and therefore the comment is wrong and the superfluous function definitions should be removed as well. An explicit conversion function is considered in direct-initialization situations only, which indirectly contain the so-called "contextual conversion to bool" (4 [conv]/3). These conversions are not considered for `==` or `!=` as defined by the core language.

Proposed resolution:

In 20.7.15.2 [func.wrap.func]/1, class function change as indicated:

>     // 20.7.15.2.3, function capacity:
>     explicit operator bool() const;

>     // deleted overloads close possible hole in the type system
>     template<class R2, class... ArgTypes2>
>       bool operator==(const function<R2(ArgTypes2...)>&) = delete;
>     template<class R2, class... ArgTypes2>
>       bool operator!=(const function<R2(ArgTypes2...)>&) = delete;

### 1241. unique_copy needs to require EquivalenceRelation

Section: 25.3.9 [alg.unique] Status: Tentatively Ready Submitter: Daniel Krügler Opened: 2009-10-17 Last modified: 2009-10-31

View all other issues in [alg.unique].

View all issues with Tentatively Ready status.

Discussion:

A lot of fixes were silently applied during concept-time and we should not lose them again. The Requires clause of 25.3.9 [alg.unique]/5 doesn't mention that `==` and the predicate need to satisfy an `EquivalenceRelation`, as it is correctly said for `unique`. This was intentionally fixed during conceptification, were we had:

>     template<InputIterator InIter, class OutIter>
>       requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
>             && EqualityComparable<InIter::value_type>
>             && HasAssign<InIter::value_type, InIter::reference>
>             && Constructible<InIter::value_type, InIter::reference>
>       OutIter unique_copy(InIter first, InIter last, OutIter result);

>     template<InputIterator InIter, class OutIter,
>              EquivalenceRelation<auto, InIter::value_type> Pred>
>       requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
>             && HasAssign<InIter::value_type, InIter::reference>
>             && Constructible<InIter::value_type, InIter::reference>
>             && CopyConstructible<Pred>
>       OutIter unique_copy(InIter first, InIter last, OutIter result, Pred pred);

Note that EqualityComparable implied an equivalence relation.

[ N.B. `adjacent_find` was also specified to require `EquivalenceRelation`, but that was considered as a defect in concepts, see 1000 ]

[ 2009-10-31 Howard adds: ]

> Moved to Tentatively Ready after 5 positive votes on c++std-lib.

Proposed resolution:

Change 25.3.9 [alg.unique]/5 as indicated:

>     template<class InputIterator, class OutputIterator>
>       OutputIterator
>         unique_copy(InputIterator first, InputIterator last, OutputIterator result);

>     template<class InputIterator, class OutputIterator, class BinaryPredicate>
>       OutputIterator
>         unique_copy(InputIterator first, InputIterator last,
>                     OutputIterator result, BinaryPredicate pred);

> > Requires: The comparison function shall be an equivalence relation. The ranges `[first,last)` and `[result,result+(last-first))` shall not overlap. The expression `*result = *first` shall be valid. If neither `InputIterator` nor `OutputIterator` meets the requirements of forward iterator then the value type of `InputIterator` shall be `CopyConstructible` (34) and `CopyAssignable` (table 36). Otherwise `CopyConstructible` is not required.

### 1244. wait_*() in *future for synchronous functions

Section: 30.6 [futures] Status: New Submitter: Detlef Vollmann Opened: 2009-10-22 Last modified: 2009-10-23

View all other issues in [futures].

View all issues with New status.

Discussion:

With the addition of `async()`, a `future` might be associated with a function that is not running in a different thread but is stored to by run synchronously on the `get()` call. It's not clear what the `wait()` functions should do in this case.

Suggested resolution:

Throw an exception.

Proposed resolution:

### 1245. `std::hash<string>` & co

Section: 20.7.16 [unord.hash] Status: New Submitter: Paolo Carlini Opened: 2009-10-22 Last modified: 2009-10-25

View other active issues in [unord.hash].

View all other issues in [unord.hash].

View all issues with New status.

Discussion:

In 20.7.16 [unord.hash], `operator()` is specified as taking the argument by value. Moreover, it is said that `operator()` shall not throw exceptions.

However, for the specializations for class types, like `string`, `wstring`, etc, the former requirement seems suboptimal from the performance point of view (a specific PR has been filed about this in the GCC Bugzilla) and, together with the latter requirement, hard if not impossible to fulfill. It looks like pass by const reference should be allowed in such cases.

Proposed resolution:

Add to 20.7.16 [unord.hash]/2:

>     namespace std {
>       template <class T>
>       struct hash : public std::unary_function<T, std::size_t> {
>         std::size_t operator()(T val) const;
>       };
>     }

> The return value of `operator()` is unspecified, except that equal arguments shall yield the same result. `operator()` shall not throw exceptions. It is also unspecified whether `operator()` of `std::hash` specializations for class types takes its argument by value or const reference.

### 1246. `vector::resize()` missing efficiency guarantee

Section: 23.3.6.2 [vector.capacity] Status: New Submitter: David Abrahams Opened: 2009-10-24 Last modified: 2009-10-25

View all other issues in [vector.capacity].

View all issues with New status.

Discussion:

If `v` is a `vector`, I think repeated calls to `v.resize( v.size() + 1 )` should be amortized O(1), but it's not clear that's true from the text of the standard:

>     void resize(size_type sz);

> > Effects: If `sz < size()`, equivalent to `erase(begin() + sz, end());`. If `size() < sz`, appends `sz - size()` default constructed elements to the sequence.

Seems to me if we used `push_back` instead of appends, we might be giving the guarantee I'd like. Thoughts?

Proposed resolution:

In 23.3.6.2 [vector.capacity]/10, change

>     void resize(size_type sz);

> > Effects: If `sz < size()`, equivalent to `erase(begin() + sz, end());`. If `size() < sz`, appends `sz - size()` default constructed elements to the sequence equivalent to `sz - size()` consecutive evaluations of `push_back(T())`.

### 1247. `auto_ptr` is overspecified

Section: D.10.1 [auto.ptr] Status: Review Submitter: Alisdair Meredith Opened: 2009-10-24 Last modified: 2009-11-06

View all other issues in [auto.ptr].

View all issues with Review status.

Discussion:

This issue is extracted as the ongoing point-of-interest from earlier issue 463.

`auto_ptr` is overspecified as the `auto_ptr_ref` implementation detail is formally specified, and the technique is observable so workarounds for compiler defects can cause a working implementation of the primary `auto_ptr` template become non-conforming.

`auto_ptr_ref` is a documentation aid to describe a possible mechanism to implement the class. It should be marked exposition only, as per similar classes, e.g., `istreambuf_iterator::proxy`

[ 2009-10-25 Daniel adds: ]

> I wonder, whether the revised wording shouldn't be as straight as for `istream_buf` by adding one further sentence:

> > An implementation is permitted to provide equivalent functionality without providing a class with this name.

[ 2009-11-06 Alisdair adds Daniel's suggestion to the proposed wording. ]

[ 2009-11-06 Howard moves issue to Review. ]

Proposed resolution:

Add the term "exposition only" in the following two places:

Ammend D.10.1 [auto.ptr]p2:

> The exposition only class T template `auto_ptr_ref` holds a reference to an `auto_ptr`. It is used by the `auto_ptr` conversions to allow `auto_ptr` objects to be passed to and returned from functions. An implementation is permitted to provide equivalent functionality without providing a class with this name.

> >     namespace std {
> >      template <class Y> struct auto_ptr_ref { }; // exposition only

### 1249. basic_ios default ctor

Section: 27.5.4.1 [basic.ios.cons] Status: New Submitter: Martin Sebor Opened: 2009-10-25 Last modified: 2009-10-26

View all other issues in [basic.ios.cons].

View all issues with New status.

Discussion:

The basic_ios default ctor is required to leave the objects members uninitialized (see below). The paragraph says the object must be initialized by calling basic_ios::init() before it's destroyed by I can't find a requirement that it be initialized before calling any of the class other member functions. Am I not looking in the right place or that an issue?

[ 2009-10-25 Daniel adds: ]

> I agree, that your wording makes that clearer, but suggest to write

> > ... calling `basic_ios::init()` before ...

> Doing so, I recommend to adapt that of `ios_base();` as well, where we have:

> > Effects: Each `ios_base` member has an indeterminate value after construction. These members shall be initialized by calling `basic_ios::init`. If an `ios_base` object is destroyed before these initializations have taken place, the behavior is undefined.

Proposed resolution:

Change 27.5.2.7 [ios.base.cons] p1:

>     ios_base();

> > Effects: Each `ios_base` member has an indeterminate value after construction. These The object's members shall be initialized by calling `basic_ios::init` before the object's first use or before it is destroyed, whichever comes first; otherwise the behavior is undefined.. If an `ios_base` object is destroyed before these initializations have taken place, the behavior is undefined.

Change 27.5.4.1 [basic.ios.cons] p2:

>     basic_ios();

> > Effects: Constructs an object of class `basic_ios` (27.5.2.7) leaving its member objects uninitialized. The object shall be initialized by calling its `basic_ios::init` before its first use or before it is destroyed, whichever comes first; otherwise the behavior is undefined. member function. If it is destroyed before it has been initialized the behavior is undefined.

### 1250. `<bitset>` still overspecified

Section: 20.3.7 [template.bitset] Status: New Submitter: Martin Sebor Opened: 2009-10-29 Last modified: 2009-10-29

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with New status.

Discussion:

Issue 1227 — `<bitset>` synopsis overspecified makes the observation that `std::bitset`, and in fact the whole library, may be implemented without needing to `#include <stdexcept>` in any library header. The proposed resolution removes the `#include <stdexcept>` directive from the header.

I'd like to add that the `<bitset>` header (as well as the rest of the library) has also been implemented without #including the `<cstddef>` header in any library header. In the case of `std::bitset`, the template is fully usable (i.e., it may be instantiated and all its member functions may be used) without ever mentioning `size_t`. In addition, just like no library header except for `<bitset>` `#includes <stdexcept>` in its synopsis, no header but `<bitset>` `#includes <cstddef>` either.

Thus I suggest that the `#include <cstddef>` directive be similarly removed from the synopsis of `<bitset>`.

Proposed resolution:

Change 20.3.7 [template.bitset]:

>     #include <cstddef>        // for size_t
>     #include <string>
>     #include <iosfwd>         // for istream, ostream
>     namespace std {
>     ...

### 1251. move constructing `basic_stringbuf`

Section: 27.8.1.1 [stringbuf.cons] Status: New Submitter: Martin Sebor Opened: 2009-10-29 Last modified: 2009-10-29

View all other issues in [stringbuf.cons].

View all issues with New status.

Discussion:

I just came across issue 1204 -- Global permission to move, which seems to address the concern raised by the example in c++std-lib-25030.

IIUC, the example violates the permission to assume that arguments bound to rvalue references are unnamed temporaries granted to implementations by the resolution of issue 1204 - Global permission to move.

I.e., the `ostringstream(ostringstream &&rhs)` ctor can leave the `rhs` pointers pointing to the newly constructed object's buffer just as long as the dtor doesn't change or invalidate the buffer. The caller may not make any assumptions about rhs after the move beyond it being safe to destroy or reassign.

So unless I misunderstood something, I still think the `basic_stringbuf` move ctor is overspecified. Specifically, I think the third sentence in the Effects clause and the last 6 bullets in the Postconditions clause can, and IMO should, be stricken.

Proposed resolution:

Strike from 27.8.1.1 [stringbuf.cons]:

>     basic_stringbuf(basic_stringbuf&& rhs);

> > Effects: Move constructs from the rvalue `rhs`. It is implementation-defined whether the sequence pointers in `*this` (`eback()`, `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) obtain the values which `rhs` had. Whether they do or not, `*this` and `rhs` reference separate buffers (if any at all) after the construction. The openmode, locale and any other state of `rhs` is also copied.

> > Postconditions: Let `rhs_p` refer to the state of `rhs` just prior to this construction and let `rhs_a` referto the state of `rhs` just after this construction.

> > - `str() == rhs_p.str()`
> > - `gptr() - eback() == rhs_p.gptr() - rhs_p.eback()`
> > - `egptr() - eback() == rhs_p.egptr() - rhs_p.eback()`
> > - `pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()`
> > - `epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()`
> > - if `(eback()) eback() != rhs_a.eback()`
> > - if `(gptr()) gptr() != rhs_a.gptr()`
> > - if `(egptr()) egptr() != rhs_a.egptr()`
> > - if `(pbase()) pbase() != rhs_a.pbase()`
> > - if `(pptr()) pptr() != rhs_a.pptr()`
> > - if `(epptr()) epptr() != rhs_a.epptr()`

### 1252. `wbuffer_convert::state_type` inconsistency

Section: 22.3.3.2.3 [conversions.buffer] Status: New Submitter: Bo Persson Opened: 2009-10-21 Last modified: 2009-10-31

View all issues with New status.

Discussion:

The synopisis for `wbuffer_convert` 22.3.3.2.3 [conversions.buffer]/2 contains

>     typedef typename Tr::state_type   state_type;

making `state_type` a synonym for (possibly) some `char_traits<x>::state_type`.

However, in paragraph 9 of the same section, we have

>     typedef typename Codecvt::state_type state_type;

> > The type shall be a synonym for `Codecvt::state_type`.

From what I can see, it might be hard to implement `wbuffer_convert` if the types were not both `std::mbstate_t`, but I cannot find a requirement that they must be the same type.

Proposed resolution:

### 1253. invalidation of iterators and `emplace` vs. `insert` inconsistence in assoc. containers

Section: 23.2.4 [associative.reqmts] Status: New Submitter: Boris Dušek Opened: 2009-10-24 Last modified: 2009-10-31

View other active issues in [associative.reqmts].

View all other issues in [associative.reqmts].

View all issues with New status.

Discussion:

In the latest published draft N2960, section 23.2.4 [associative.reqmts], paragraph 8, it is specifies that that `insert` does not invalidate any iterators. As per 23.2.1 [container.requirements.general], paragraph 12, this holds true not only for `insert`, but `emplace` as well. This gives the `insert` member a special treatment w.r.t. `emplace` member in 23.2.4 [associative.reqmts], par. 8, since both modify the container. For the sake of consistency, in 23.2.4 [associative.reqmts], par. 8: either reference to `insert` should be removed (i.e. count on 23.2.1 [container.requirements.general], par. 12), or reference to `emplace` be added (i.e. mention all members of assoc. containers that modify it).

Proposed resolution:

### 1254. Misleading sentence in `vector<bool>::flip`

Section: 23.3.7 [vector.bool] Status: New Submitter: Christopher Jefferson Opened: 2009-11-01 Last modified: 2009-11-01

View all other issues in [vector.bool].

View all issues with New status.

Discussion:

The effects of `vector<bool>::flip` has the line:

> It is unspecified whether the function has any effect on allocated but unused bits.

While this is technically true, it is misleading, as any member function in any standard container may change unused but allocated memory. Users can never observe such changes as it would also be undefined behaviour to read such memory.

Proposed resolution:

Strike second sentence from the definition of `vector<bool>::flip()`, 23.3.7 [vector.bool], paragraph 5.

> Effects: Replaces each element in the container with its complement. It is unspecified whether the function has any effect on allocated but unused bits.

### 1255. `declval` should be added to the library

Section: 20.3 [utility] Status: New Submitter: Daniel Krügler Opened: 2009-11-03 Last modified: 2009-11-04

View all issues with New status.

Discussion:

During the Santa Cruz meeting it was decided to split off the provision of the library utility `value()` proposed in N2979 from the concrete request of the UK 300 comment. The provision of a new library component that allows the production of values in unevaluated expressions is considered as important to realize constrained templates in C++0x where concepts are not available.

The following proposed resolution is an improvement over that suggested in N2958, because the proposed component can now be defined without loss of general usefulness and any use by user-code will make the program ill-formed. A possible prototype implementation that satisfies the core language requirements can be written as:

>     template<class T>
>       struct declval_protector {
>         static const bool stop = false;
>         static typename std::add_rvalue_reference<T>::type delegate(); // undefined
>       };

>     template<class T>
>     typename std::add_rvalue_reference<T>::type declval() {
>       static_assert(declval_protector<T>::stop, "declval() must not be used!");
>       return declval_protector<T>::delegate();
>     }

Further-on the earlier suggested name `value()` has been changed to `declval()` after discussions with committee members.

Finally the suggestion shown below demonstrates that it can simplify existing standard wording by directly using it in the library specification, and that it also improves an overlooked corner case for `common_type` by adding support for `cv void`.

Proposed resolution:

[ The following edit assumes that the earlier component identity has been removed as part of applying the solution of 939, N2951, and N2984. Note that the proposal does not depend on this application, but it just simplifies the editorial representation ]

1. Change 20.3 [utility], header `<utility>` synopsis as indicated:

   >     // 20.3.2, forward/move:
   >     template <class T, class U> T&& forward(U&& u);;
   >     template <class T> typename remove_reference<T>::type&& move(T&&);

   >     // 20.3.3, declval:
   >     template <class T> typename add_rvalue_reference<T>::type declval(); // for unused context

2. Immediately after the current section 20.3.3 [forward] insert a new section:

   20.3.3 Function template declval [declval]

   The library provides the function template `declval` to simplify the definition of expressions in unevaluated and unused contexts (3.2 [basic.def.odr], 5 [expr]). The template parameter `T` of `declval` may be an incomplete type.

       template <class T> typename add_rvalue_reference<T>::type declval(); // for unused context

   > Remarks: If this function is used according to 3.2 [basic.def.odr], the program shall be ill-formed.

   > [Example:

   > >     template<class To, class From>
   > >     decltype(static_cast<To>(declval<From>())) convert(From&&);

   > declares a function template `convert`, which does only participate in overloading, if the type `From` can be explicitly casted to type `To` — end example]

3. This bullet just makes clear that after applying N2984, the changes in 20.6.4.3 [meta.unary.prop], before table Type property queries should not use `declval`, because the well-formedness requirement of the specification of `is_constructible` would become more complicated, because we would need to make sure that the expression CE is checked in an unevaluated context.

4. Also 20.6.5 [meta.rel]/4 is not modified similar to the previous bullet, because with the stricter requirements of not using `declval()` the well-formedness condition would be harder to specify. The following changes are only editorial ones (e.g. the removal of the duplicate declaration of `create()`):

   > Given the following function prototype:

   > >     template <class T>
   > >       typename add_rvalue_reference<T>::type create();

   > the predicate condition for a template specialization `is_convertible<From, To>` shall be satisfied if and only if the return expression in the following code would be well-formed, including any immplicit conversions to the return type of the function:

   > >     template <class T>
   > >     typename add_rvalue_reference<T>::type create();
   > >     To test() {
   > >       return create<From>();
   > >     }

5. Change the entry in column "Comments" for `common_type` in Table 51 — Other transformations (20.6.7 [meta.trans.other]):

   [ NB: This wording change extends the type domain of `common_type` for `cv void => cv void` transformations and thus makes `common_type` usable for all binary type combinations that are supported by `is_convertible` ]

   > The member typedef `type` shall be defined as set out below. All types in the parameter pack `T` shall be complete or (possibly cv-qualified) `void`. A program may specialize this trait if at least one template parameter in the specialization is a user-defined type. [Note: Such specializations are needed when only explicit conversions are desired among the template arguments. — end note]

6. Change 20.6.7 [meta.trans.other]/3 as indicated:

   [ NB: This wording change is more than an editorial simplification of the definition of `common_type`: It also extends its usefulness for `cv void` types as outlined above ]

   > The nested typedef `common_type::type` shall be defined as follows:

   > > [..]

   > >     template <class T, class U>
   > >     struct common_type<T, U> {
   > >     private:
   > >       static T&& __t();
   > >       static U&& __u();
   > >     public:
   > >       typedef decltype(true ? __tdeclval<T>() : __udeclval<U>()) type;
   > >     };

### 1256. `weak_ptr` comparison functions should be removed

Section: 20.8.15.3 [util.smartptr.weak] Status: New Submitter: Daniel Krügler Opened: 2009-11-04 Last modified: 2009-11-04

View all issues with New status.

Discussion:

Additional to the necessary cleanup of the description of the the `weak_ptr` component from 20.8.15.3 [util.smartptr.weak] described in 1231 it turns out that the currently deleted comparison functions of `weak_ptr` are not needed at all: There is no safe-bool conversion from `weak_ptr`, and it won't silently chose a conversion to `shared_ptr`.

Proposed resolution:

Change 20.8.15.3 [util.smartptr.weak]/1 as indicated:

>     namespace std {
>     template<class T> class weak_ptr {
>     public:
>     ...
>       // comparisons
>       template<class Y> bool operator<(weak_ptr<Y> const&) const = delete;
>       template<class Y> bool operator<=(weak_ptr<Y> const&) const = delete;
>       template<class Y> bool operator>(weak_ptr<Y> const&) const = delete;
>       template<class Y> bool operator>=(weak_ptr<Y> const&) const = delete;
>     };
>     ...

### 1257. Header <ios> still contains a `concept_map`

Section: 27.5 [iostreams.base] Status: New Submitter: Beman Dawes Opened: 2009-11-04 Last modified: 2009-11-04

View all other issues in [iostreams.base].

View all issues with New status.

Discussion:

The current WP still contains a `concept_map`.

Proposed resolution:

Change Iostreams base classes 27.5 [iostreams.base], Header <ios> synopsis, as indicated:

>     concept_map ErrorCodeEnum<io_errc> { };
>     template <> struct is_error_code_enum<io_errc> : true_type { }
>     error_code make_error_code(io_errc e);
>     error_condition make_error_condition(io_errc e);
>     const error_category& iostream_category();

### 1258. std::function Effects clause impossible to satisfy

Section: 20.7.15.2.2 [func.wrap.func.mod] Status: New Submitter: Daniel Krügler Opened: 2009-11-05 Last modified: 2009-11-05

View all issues with New status.

Discussion:

As of 20.7.15.2.2 [func.wrap.func.mod]/2+ we have the following prototype description:

>     template<class F, Allocator Alloc>
>       requires Callable<F, ArgTypes...>
>         && Convertible<Callable<F, ArgTypes...>::result_type, R>
>       void assign(F, const Alloc&);

> > Effects: `function(f, a).swap(*this)`

Two things: First the concept debris needs to be removed, second and much more importantly, the effects clause is now impossible to satisfy, because there is no constructor that would match the parameter sequence (`FunctionObject`, `Allocator`) [plus the fact that no `f` and no `a` is part of the signature]. The most probable candidate is

>     template<class F, class A> function(allocator_arg_t, const A&, F);

and the effects clause needs to be adapted to use this signature.

Proposed resolution:

Change in 20.7.15.2.2 [func.wrap.func.mod] the complete prototype description as indicated

[ Question to the editor: Shouldn't there a paragraph number in front of the Effects clause? ]

>     template<class F, Allocator Alloc>
>       requires Callable<F, ArgTypes...>
>         && Convertible<Callable<F, ArgTypes...>::result_type, R>
>       void assign(F, const Alloc&);
>     template<class F, class A> void assign(F f, const A& a);

> > 3 Effects: `function(f, aallocator_arg, a, f).swap(*this)`

### 1259. Should initializer-list constructors move elements?

Section: 23.2.3 [sequence.reqmts] Status: New Submitter: Sean Hunt Opened: 2009-11-05 Last modified: 2009-11-06

View other active issues in [sequence.reqmts].

View all other issues in [sequence.reqmts].

View all issues with New status.

Discussion:

According to 23.2.3 [sequence.reqmts], `X(il)` is equivalent to `X(il.begin(), il.end())`. Should it instead be equivalent to `X(move_iterator(il.begin()), move_iterator(il.end()))` so that needless copies are not made? This doesn't seem ideal either - it may make more sense to provide two overloads for the constructor, one for move and one for copy.

Proposed resolution:

### 1260. `is_constructible<int*,void*>` reports true

Section: 20.6.4.3 [meta.unary.prop] Status: New Submitter: Peter Dimov Opened: 2009-11-07 Last modified: 2009-11-08

View other active issues in [meta.unary.prop].

View all other issues in [meta.unary.prop].

View all issues with New status.

Discussion:

The specification of `is_constructible<T,Args...>` in N3000 uses

>     static_cast<T>(create<Args>()...)

for the one-argument case, but `static_cast` also permits unwanted conversions such as `void*` to `T*` and `Base*` to `Derived*`.

Proposed resolution:

Change 20.6.4.3 [meta.unary.prop], p6:

> the predicate condition for a template specialization `is_constructible<T, Args>` shall be satisfied, if and only if the following expression CE variable definition would be well-formed:

> - if `sizeof...(Args) == 0 1`, the expression:

>   >     static_cast<T>(create<Args>()...)
>   >     T t;

> - otherwise the expression:

>   >     T t(create<Args>()...);