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

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

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.

## Revision History

- 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

### 96. Vector<bool> is not a container

Section: 23.3.6 [vector] Status: Open Submitter: AFNOR Opened: 1998-10-07 Last modified: 2009-07-29

View other active issues in [vector].

View all other issues in [vector].

View all issues with Open status.

Discussion:

`vector<bool>` is not a container as its reference and pointer types are not references and pointers.

Also it forces everyone to have a space optimization instead of a speed one.

See also: 99-0008 == N1185 Vector<bool> is Nonconforming, Forces Optimization Choice.

[In Santa Cruz the LWG felt that this was Not A Defect.]

[In Dublin many present felt that failure to meet Container requirements was a defect. There was disagreement as to whether or not the optimization requirements constituted a defect.]

[The LWG looked at the following resolutions in some detail:
* Not A Defect.
* Add a note explaining that vector<bool> does not meet Container requirements.
* Remove vector<bool>.
* Add a new category of container requirements which vector<bool> would meet.
* Rename vector<bool>.
No alternative had strong, wide-spread, support and every alternative had at least one "over my dead body" response.
There was also mention of a transition scheme something like (1) add vector_bool and deprecate vector<bool> in the next standard. (2) Remove vector<bool> in the following standard.]

[Modifying container requirements to permit returning proxies (thus allowing container requirements conforming vector<bool>) was also discussed.]

[It was also noted that there is a partial but ugly workaround in that vector<bool> may be further specialized with a customer allocator.]

[Kona: Herb Sutter presented his paper J16/99-0035==WG21/N1211, vector<bool>: More Problems, Better Solutions. Much discussion of a two step approach: a) deprecate, b) provide replacement under a new name. LWG straw vote on that: 1-favor, 11-could live with, 2-over my dead body. This resolution was mentioned in the LWG report to the full committee, where several additional committee members indicated over-my-dead-body positions.]

Discussed at Lillehammer. General agreement that we should deprecate vector<bool> and introduce this functionality under a different name, e.g. bit_vector. This might make it possible to remove the vector<bool> specialization in the standard that comes after C++0x. There was also a suggestion that in C++0x we could additional say that it's implementation defined whether vector<bool> refers to the specialization or to the primary template, but there wasn't general agreement that this was a good idea.

We need a paper for the new bit_vector class.

[ Batavia: ]

> The LWG feels we need something closer to SGI's `bitvector` to ease migration from `vector<bool>`. Although some of the funcitonality from N2050 could well be used in such a template. The concern is easing the API migration for those users who want to continue using a bit-packed container. Alan and Beman to work.

[ Post Summit Alisdair adds: ]

> `vector<bool>` is now a conforming container under the revised terms of C++0x, which supports containers of proxies.

> Recommend NAD.

> Two issues remain:

> i/ premature optimization in the specification. There is still some sentiment that deprecation is the correct way to go, although it is still not clear what it would mean to deprecate a single specialization of a template.

> Recommend: Create a new issue for the discussion, leave as Open.

> ii/ Request for a new bitvector class to guarantee the optimization, perhaps with a better tuned interface.

> This is a clear extension request that may be handled via a future TR.

[ Batavia (2009-05): ]

> We note that most of this issue has become moot over time, and agree with Alisdair's recommendations. Move to NAD Future for reconsideration of part (ii).

[ 2009-07-29 Alisdair reopens: ]

> This infamous issue was closed as NAD Future when concepts introduced support for proxy iterators, so the only remaining requirement was to provide a better type to support bitsets of dynamic length. I fear we must re-open this issue until the post-concept form of iterators is available, and hopefully will support the necessary proxy functionality to allow us to close this issue as NAD.

> I recommend we spawn a separate issue (1184) requesting a dynamic length bitset and pre-emptively file it as NAD Future. It is difficult to resolve #96 when it effectively contains two separate sub-issues.

Proposed resolution:

We now have: N2050 and N2160.

### 149. Insert should return iterator to first element inserted

Section: 23.2.3 [sequence.reqmts] Status: Ready Submitter: Andrew Koenig Opened: 1999-06-28 Last modified: 2009-07-15

View all other issues in [sequence.reqmts].

View all issues with Ready status.

Discussion:

Suppose that c and c1 are sequential containers and i is an iterator that refers to an element of c. Then I can insert a copy of c1's elements into c ahead of element i by executing

>     c.insert(i, c1.begin(), c1.end());

If c is a vector, it is fairly easy for me to find out where the newly inserted elements are, even though i is now invalid:

>     size_t i_loc = i - c.begin();
>     c.insert(i, c1.begin(), c1.end());

and now the first inserted element is at c.begin()+i_loc and one past the last is at c.begin()+i_loc+c1.size().
But what if c is a list? I can still find the location of one past the last inserted element, because i is still valid. To find the location of the first inserted element, though, I must execute something like

>     for (size_t n = c1.size(); n; --n)
>        --i;

because i is now no longer a random-access iterator.
Alternatively, I might write something like

>     bool first = i == c.begin();
>     list<T>::iterator j = i;
>     if (!first) --j;
>     c.insert(i, c1.begin(), c1.end());
>     if (first)
>        j = c.begin();
>     else
>        ++j;

which, although wretched, requires less overhead.
But I think the right solution is to change the definition of insert so that instead of returning void, it returns an iterator that refers to the first element inserted, if any, and otherwise is a copy of its first argument.

[ Summit: ]

> Reopened by Alisdair.

[ Post Summit Alisdair adds: ]

> In addition to the original rationale for C++03, this change also gives a consistent interface for all container insert operations i.e. they all return an iterator to the (first) inserted item.

> Proposed wording provided.

[ 2009-07 Frankfurt ]

> Q: why isn't this change also proposed for associative containers?

> A: The returned iterator wouldn't necessarily point to a contiguous range.

> Moved to Ready.

Proposed resolution:

Table 83 change return type from `void` to `iterator` for the following rows:

> Table 83 -- Sequence container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition
> --- | --- | ---
> `a.insert(p,n,t)` | `void iterator` | Inserts `n` copies of `t` before `p`.
> `a.insert(p,i,j)` | `void iterator` | Each iterator in the range `[i,j)` shall be dereferenced exactly once. pre: `i` and `j` are not iterators into `a`. Inserts copies of elements in `[i, j)` before `p`
> `a.insert(p,il)` | `void iterator` | `a.insert(p, il.begin(), il.end())`.

Add after p6 23.2.3 [sequence.reqmts]:

> -6- ...

> The iterator returned from `a.insert(p,n,t)` points to the copy of the first element inserted into `a`, or `p` if `n == 0`.

> The iterator returned from `a.insert(p,i,j)` points to the copy of the first element inserted into `a`, or `p` if `i == j`.

> The iterator returned from `a.insert(p,il)` points to the copy of the first element inserted into `a`, or `p` if `il` is empty.

p2 23.3.2 [deque] Update class definition, change return type from `void` to `iterator`:

>     void iterator insert(const_iterator position, size_type n, const T& x);
>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);
>       void iterator insert(const_iterator position, initializer_list<T>);

23.3.2.3 [deque.modifiers] change return type from `void` to `iterator` on following declarations:

>       void iterator insert(const_iterator position, size_type n, const T& x);
>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);

Add the following (missing) declaration

>     iterator insert(const_iterator position, initializer_list<T>);

23.3.3 [forwardlist] Update class definition, change return type from `void` to `iterator`:

>     void iterator insert_after(const_iterator position, initializer_list<T> il);
>     void iterator insert_after(const_iterator position, size_type n, const T& x);
>     template <class InputIterator>
>       void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);

p8 23.3.3.4 [forwardlist.modifiers] change return type from `void` to `iterator`:

>     void iterator insert_after(const_iterator position, size_type n, const T& x);

Add paragraph:

> Returns: position.

p10 23.3.3.4 [forwardlist.modifiers] change return type from `void` to `iterator`:

>     template <class InputIterator>
>       void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);

Add paragraph:

> Returns: position.

p12 23.3.3.4 [forwardlist.modifiers] change return type from `void` to `iterator` on following declarations:

>     void iterator insert_after(const_iterator position, initializer_list<T> il);

change return type from `void` to `iterator` on following declarations:

p2 23.3.4 [list] Update class definition, change return type from `void` to `iterator`:

>     void iterator insert(const_iterator position, size_type n, const T& x);

>     template <class InputIterator>
>     void iterator insert(const_iterator position, InputIterator first, InputIterator last);

>     void iterator insert(const_iterator position, initializer_list<T>);

23.3.4.3 [list.modifiers] change return type from `void` to `iterator` on following declarations:

>     void iterator insert(const_iterator position, size_type n, const T& x);

>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);

Add the following (missing) declaration

>     iterator insert(const_iterator position, initializer_list<T>);

p2 23.3.6 [vector]

Update class definition, change return type from `void` to `iterator`:

>     void iterator insert(const_iterator position, T&& x);

>     void iterator insert(const_iterator position, size_type n, const T& x);

>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);

>     void iterator insert(const_iterator position, initializer_list<T>);

23.3.6.4 [vector.modifiers] change return type from `void` to `iterator` on following declarations:

>     void iterator insert(const_iterator position, size_type n, const T& x);

>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);

Add the following (missing) declaration

>     iterator insert(const_iterator position, initializer_list<T>);

p1 23.3.7 [vector.bool] Update class definition, change return type from `void` to `iterator`:

>     void iterator insert (const_iterator position, size_type n, const bool& x);

>     template <class InputIterator>
>       void iterator insert(const_iterator position, InputIterator first, InputIterator last);

>       void iterator insert(const_iterator position, initializer_list<bool> il);

p5 21.4 [basic.string] Update class definition, change return type from `void` to `iterator`:

>     void iterator insert(const_iterator p, size_type n, charT c);

>     template<class InputIterator>
>       void iterator insert(const_iterator p, InputIterator first, InputIterator last);

>     void iterator insert(const_iterator p, initializer_list<charT>);

p13 21.4.6.4 [string::insert] change return type from `void` to `iterator`:

>     void iterator insert(const_iterator p, size_type n, charT c);

Add paragraph:

> Returns: an iterator which refers to the copy of the first inserted character, or `p` if `n == 0`.

p15 21.4.6.4 [string::insert] change return type from `void` to `iterator`:

>     template<class InputIterator>
>       void iterator insert(const_iterator p, InputIterator first, InputIterator last);

Add paragraph:

> Returns: an iterator which refers to the copy of the first inserted character, or `p` if `first == last`.

p17 21.4.6.4 [string::insert] change return type from `void` to `iterator`:

>     void iterator insert(const_iterator p, initializer_list<charT> il);

Add paragraph:

> Returns: an iterator which refers to the copy of the first inserted character, or `p` if `il` is empty.

Rationale:

[ The following was the C++98/03 rationale and does not necessarily apply to the proposed resolution in the C++0X time frame: ]

> The LWG believes this was an intentional design decision and so is not a defect. It may be worth revisiting for the next standard.

### 299. Incorrect return types for iterator dereference

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

View all other issues in [bidirectional.iterators].

View all issues with Open status.

Discussion:

In section 24.2.5 [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.6 [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. ]

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: Review Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2009-07-14

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

View all issues with Review 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().

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.concepts] Status: Review Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-07-31

View other active issues in [iterator.concepts].

View all other issues in [iterator.concepts].

View all issues with Review 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.

24.2 [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: ]

Proposed resolution:

Add a new paragrpah to Iterator concepts 24.2 [iterator.concepts] 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` concept shall not introduce undefined behaviour when used 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]

### 419. istream extractors not setting failbit if eofbit is already set

Section: 27.7.1.1.3 [istream::sentry] Status: Ready Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-07-14

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

View all issues with Ready status.

Discussion:

27.7.1.1.3 [istream::sentry], p2 says that istream::sentry ctor prepares for input if is.good() is true. p4 then goes on to say that the ctor sets the sentry::ok_ member to true if the stream state is good after any preparation. 27.7.1.2.1 [istream.formatted.reqmts], p1 then says that a formatted input function endeavors to obtain the requested input if the sentry's operator bool() returns true. Given these requirements, no formatted extractor should ever set failbit if the initial stream rdstate() == eofbit. That is contrary to the behavior of all implementations I tested. The program below prints out eof = 1, fail = 0 eof = 1, fail = 1 on all of them.

    #include <sstream>
    #include <cstdio>

    int main()
    {
        std::istringstream strm ("1");

        int i = 0;

        strm >> i;

        std::printf ("eof = %d, fail = %d\n",
                     !!strm.eof (), !!strm.fail ());

        strm >> i;

        std::printf ("eof = %d, fail = %d\n",
                     !!strm.eof (), !!strm.fail ());
    }

Comments from Jerry Schwarz (c++std-lib-11373):
Jerry Schwarz wrote:
I don't know where (if anywhere) it says it in the standard, but the formatted extractors are supposed to set failbit if they don't extract any characters. If they didn't then simple loops like
while (cin >> x);
would loop forever.
Further comments from Martin Sebor:
The question is which part of the extraction should prevent this from happening by setting failbit when eofbit is already set. It could either be the sentry object or the extractor. It seems that most implementations have chosen to set failbit in the sentry [...] so that's the text that will need to be corrected.

Pre Berlin: This issue is related to 342. If the sentry sets `failbit` when it finds `eofbit` already set, then you can never seek away from the end of stream.

Kona: Possibly NAD. If eofbit is set then good() will return false. We then set ok to false. We believe that the sentry's constructor should always set failbit when ok is false, and we also think the standard already says that. Possibly it could be clearer.

[ 2009-07 Frankfurt ]

> Moved to Ready.

Proposed resolution:

Change 27.7.1.1.3 [istream::sentry], p2 to:

>     explicit sentry(basic_istream<charT,traits>& is , bool noskipws = false);

> -2- Effects: If `is.good()` is `true` `false`, calls `is.setstate(failbit)`. Otherwise prepares for formatted or unformatted input. ...

### 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-07-14

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.

Proposed resolution:

### 430. valarray subset operations

Section: 26.6.2.4 [valarray.sub] Status: Ready Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-07-14

View all issues with Ready 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.

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)

### 431. Swapping containers with unequal allocators

Section: X [allocator.requirements], 25 [algorithms] Status: Open Submitter: Matt Austern Opened: 2003-09-20 Last modified: 2009-07-17

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with Open status.

Discussion:

Clause X [allocator.requirements] paragraph 4 says that implementations are permitted to supply containers that are unable to cope with allocator instances and that container implementations may assume that all instances of an allocator type compare equal. We gave implementers this latitude as a temporary hack, and eventually we want to get rid of it. What happens when we're dealing with allocators that don't compare equal?

In particular: suppose that `v1` and `v2` are both objects of type `vector<int, my_alloc>` and that `v1.get_allocator() != v2.get_allocator()`. What happens if we write `v1.swap(v2)`? Informally, three possibilities:

1. This operation is illegal. Perhaps we could say that an implementation is required to check and to throw an exception, or perhaps we could say it's undefined behavior.

2. The operation performs a slow swap (i.e. using three invocations of `operator=`, leaving each allocator with its original container. This would be an O(N) operation.

3. The operation swaps both the vectors' contents and their allocators. This would be an O(1) operation. That is:

>         my_alloc a1(...);
>         my_alloc a2(...);
>         assert(a1 != a2);

>         vector<int, my_alloc> v1(a1);
>         vector<int, my_alloc> v2(a2);
>         assert(a1 == v1.get_allocator());
>         assert(a2 == v2.get_allocator());

>         v1.swap(v2);
>         assert(a1 == v2.get_allocator());
>         assert(a2 == v1.get_allocator());

[Kona: This is part of a general problem. We need a paper saying how to deal with unequal allocators in general.]

[pre-Sydney: Howard argues for option 3 in N1599. ]

[ 2007-01-12, Howard: This issue will now tend to come up more often with move constructors and move assignment operators. For containers, these members transfer resources (i.e. the allocated memory) just like swap. ]

[ Batavia: There is agreement to overload the container `swap` on the allocator's Swappable requirement using concepts. If the allocator supports Swappable, then container's swap will swap allocators, else it will perform a "slow swap" using copy construction and copy assignment. ]

[ 2009-04-28 Pablo adds: ]

> Fixed in N2525. I argued for marking this Tentatively-Ready right after Bellevue, but there was a concern that N2525 would break in the presence of the RVO. (That breakage had nothing to do with swap, but never-the-less). I addressed that breakage in in N2840 (Summit) by means of a non-normative reference:

> > [Note: in situations where the copy constructor for a container is elided, this function is not called. The behavior in these cases is as if `select_on_container_copy_construction` returned `x` — end note]

Proposed resolution:

### 446. Iterator equality between different containers

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

View other active issues in [iterator.concepts].

View all other issues in [iterator.concepts].

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.

Proposed resolution:

### 458. 24.1.5 contains unintended limitation for operator-

Section: 24.2.6 [random.access.iterators] Status: Open Submitter: Daniel Frey Opened: 2004-02-27 Last modified: 2009-07-17

View other active issues in [random.access.iterators].

View all other issues in [random.access.iterators].

View all issues with Open status.

Discussion:

In 24.1.5 [lib.random.access.iterators], table 76 the operational semantics for the expression "r -= n" are defined as "return r += -n". This means, that the expression -n must be valid, which is not the case for unsigned types.

[ Sydney: Possibly not a real problem, since difference type is required to be a signed integer type. However, the wording in the standard may be less clear than we would like. ]

[ Post Summit Alisdair adds: ]

> This issue refers to a requirements table we have removed.

> The issue might now relate to 24.2.6 [random.access.iterators] p5. However, the rationale in the issue already recognises that the `difference_type` must be signed, so this really looks NAD.

[ Batavia (2009-05): ]

> We agree with Alisdair's observations.

> Move to NAD.

[ 2009-07 Frankfurt: ]

> Need to look at again without concepts.

> There was a question about this phrase in the discussion: "the expression -n must be valid, which is not the case for unsigned types." If n is an object ofthe iterator difference_type (eg ptrdiff_t), then it is never unsigned.

Proposed resolution:

To remove this limitation, I suggest to change the operational semantics for this column to:

>         { Distance m = n;
>           if (m >= 0)
>             while (m--) --r;
>           else
>             while (m++) ++r;
>           return r; }

### 463. auto_ptr usability issues

Section: D.9.1 [auto.ptr] Status: Open Submitter: Rani Sharoni Opened: 2003-12-07 Last modified: 2009-07-14

View all other issues in [auto.ptr].

View all issues with Open status.

Discussion:

TC1 CWG DR #84 effectively made the template<class Y> operator auto_ptr<Y>() member of auto_ptr (20.4.5.3/4) obsolete.

The sole purpose of this obsolete conversion member is to enable copy initialization base from r-value derived (or any convertible types like cv-types) case:

    #include <memory>
    using std::auto_ptr;

    struct B {};
    struct D : B {};

    auto_ptr<D> source();
    int sink(auto_ptr<B>);
    int x1 = sink( source() ); // #1 EDG - no suitable copy constructor

The excellent analysis of conversion operations that was given in the final auto_ptr proposal (http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf) explicitly specifies this case analysis (case 4). DR #84 makes the analysis wrong and actually comes to forbid the loophole that was exploited by the auto_ptr designers.

I didn't encounter any compliant compiler (e.g. EDG, GCC, BCC and VC) that ever allowed this case. This is probably because it requires 3 user defined conversions and in fact current compilers conform to DR #84.

I was surprised to discover that the obsolete conversion member actually has negative impact of the copy initialization base from l-value derived case:

    auto_ptr<D> dp;
    int x2 = sink(dp); // #2 EDG - more than one user-defined conversion applies

I'm sure that the original intention was allowing this initialization using the template<class Y> auto_ptr(auto_ptr<Y>& a) constructor (20.4.5.1/4) but since in this copy initialization it's merely user defined conversion (UDC) and the obsolete conversion member is UDC with the same rank (for the early overloading stage) there is an ambiguity between them.

Removing the obsolete member will have impact on code that explicitly invokes it:

    int y = sink(source().operator auto_ptr<B>());

IMHO no one ever wrote such awkward code and the reasonable workaround for #1 is:

    int y = sink( auto_ptr<B>(source()) );

I was even more surprised to find out that after removing the obsolete conversion member the initialization was still ill-formed: int x3 = sink(dp); // #3 EDG - no suitable copy constructor

This copy initialization semantically requires copy constructor which means that both template conversion constructor and the auto_ptr_ref conversion member (20.4.5.3/3) are required which is what was explicitly forbidden in DR #84. This is a bit amusing case in which removing ambiguity results with no candidates.

I also found exception safety issue with auto_ptr related to auto_ptr_ref:

    int f(auto_ptr<B>, std::string);
    auto_ptr<B> source2();

    // string constructor throws while auto_ptr_ref
    // "holds" the pointer
    int x4 = f(source2(), "xyz"); // #4

The theoretic execution sequence that will cause a leak:

1. call auto_ptr<B>::operator auto_ptr_ref<B>()
2. call string::string(char const*) and throw

According to 20.4.5.3/3 and 20.4.5/2 the auto_ptr_ref conversion member returns auto_ptr_ref<Y> that holds *this and this is another defect since the type of *this is auto_ptr<X> where X might be different from Y. Several library vendors (e.g. SGI) implement auto_ptr_ref<Y> with Y* as member which is much more reasonable. Other vendor implemented auto_ptr_ref as defectively required and it results with awkward and catastrophic code: int oops = sink(auto_ptr<B>(source())); // warning recursive on all control paths

Dave Abrahams noticed that there is no specification saying that auto_ptr_ref copy constructor can't throw.

My proposal comes to solve all the above issues and significantly simplify auto_ptr implementation. One of the fundamental requirements from auto_ptr is that it can be constructed in an intuitive manner (i.e. like ordinary pointers) but with strict ownership semantics which yield that source auto_ptr in initialization must be non-const. My idea is to add additional constructor template with sole propose to generate ill-formed, diagnostic required, instance for const auto_ptr arguments during instantiation of declaration. This special constructor will not be instantiated for other types which is achievable using 14.8.2/2 (SFINAE). Having this constructor in hand makes the constructor template<class Y> auto_ptr(auto_ptr<Y> const&) legitimate since the actual argument can't be const yet non const r-value are acceptable.

This implementation technique makes the "private auxiliary class" auto_ptr_ref obsolete and I found out that modern C++ compilers (e.g. EDG, GCC and VC) consume the new implementation as expected and allow all intuitive initialization and assignment cases while rejecting illegal cases that involve const auto_ptr arguments.

The proposed auto_ptr interface:

    namespace std {
        template<class X> class auto_ptr {
        public:
            typedef X element_type;

            // 20.4.5.1 construct/copy/destroy:
            explicit auto_ptr(X* p=0) throw();
            auto_ptr(auto_ptr&) throw();
            template<class Y> auto_ptr(auto_ptr<Y> const&) throw();
            auto_ptr& operator=(auto_ptr&) throw();
            template<class Y> auto_ptr& operator=(auto_ptr<Y>) throw();
            ~auto_ptr() throw();

            // 20.4.5.2 members:
            X& operator*() const throw();
            X* operator->() const throw();
            X* get() const throw();
            X* release() throw();
            void reset(X* p=0) throw();

        private:
            template<class U>
            auto_ptr(U& rhs, typename
    unspecified_error_on_const_auto_ptr<U>::type = 0);
        };
    }

One compliant technique to implement the unspecified_error_on_const_auto_ptr helper class is using additional private auto_ptr member class template like the following:

    template<typename T> struct unspecified_error_on_const_auto_ptr;

    template<typename T>
    struct unspecified_error_on_const_auto_ptr<auto_ptr<T> const>
    { typedef typename auto_ptr<T>::const_auto_ptr_is_not_allowed type; };

There are other techniques to implement this helper class that might work better for different compliers (i.e. better diagnostics) and therefore I suggest defining its semantic behavior without mandating any specific implementation. IMO, and I didn't found any compiler that thinks otherwise, 14.7.1/5 doesn't theoretically defeat the suggested technique but I suggest verifying this with core language experts.

Further changes in standard text:

Remove section 20.4.5.3

Change 20.4.5/2 to read something like: Initializing auto_ptr<X> from const auto_ptr<Y> will result with unspecified ill-formed declaration that will require unspecified diagnostic.

Change 20.4.5.1/4,5,6 to read:

    template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();

4 Requires: Y* can be implicitly converted to X*.

5 Effects: Calls const_cast<auto_ptr<Y>&>(a).release().

6 Postconditions: *this holds the pointer returned from a.release().

Change 20.4.5.1/10

    template<class Y> auto_ptr& operator=(auto_ptr<Y> a) throw();

10 Requires: Y* can be implicitly converted to X*. The expression delete get() is well formed.

LWG TC DR #127 is obsolete.

Notice that the copy constructor and copy assignment operator should remain as before and accept non-const auto_ptr& since they have effect on the form of the implicitly declared copy constructor and copy assignment operator of class that contains auto_ptr as member per 12.8/5,10:

    struct X {
        // implicit X(X&)
        // implicit X& operator=(X&)
        auto_ptr<D> aptr_;
    };

In most cases this indicates about sloppy programming but preserves the current auto_ptr behavior.

Dave Abrahams encouraged me to suggest fallback implementation in case that my suggestion that involves removing of auto_ptr_ref will not be accepted. In this case removing the obsolete conversion member to auto_ptr<Y> and 20.4.5.3/4,5 is still required in order to eliminate ambiguity in legal cases. The two constructors that I suggested will co exist with the current members but will make auto_ptr_ref obsolete in initialization contexts. auto_ptr_ref will be effective in assignment contexts as suggested in DR #127 and I can't see any serious exception safety issues in those cases (although it's possible to synthesize such). auto_ptr_ref<X> semantics will have to be revised to say that it strictly holds pointer of type X and not reference to an auto_ptr for the favor of cases in which auto_ptr_ref<Y> is constructed from auto_ptr<X> in which X is different from Y (i.e. assignment from r-value derived to base).

[Redmond: punt for the moment. We haven't decided yet whether we want to fix auto_ptr for C++-0x, or remove it and replace it with move_ptr and unique_ptr.]

[ Oxford 2007: Recommend NAD. We're just going to deprecate it. It still works for simple use cases and people know how to deal with it. Going forward `unique_ptr` is the recommended tool. ]

[ 2007-11-09: Reopened at the request of David Abrahams, Alisdair Meredith and Gabriel Dos Reis. ]

[ 2009-07 Frankfurt ]

> This is a complicated issue, so we agreed to defer discussion until later in the week so that interested parties can read up on it.

Proposed resolution:

Change the synopsis in D.9.1 [auto.ptr]:

>     namespace std {
>       template <class Y> struct auto_ptr_ref {};

>       // exposition only
>       template <class T> struct constant_object;

>       // exposition only
>       template <class T>
>       struct cannot_transfer_ownership_from
>         : constant_object<T> {};

>       template <class X> class auto_ptr {
>       public:
>         typedef X element_type;

>         // D.9.1.1 construct/copy/destroy:
>         explicit auto_ptr(X* p =0) throw();
>         auto_ptr(auto_ptr&) throw();
>         template<class Y> auto_ptr(auto_ptr<Y> const&) throw();
>         auto_ptr& operator=(auto_ptr&) throw();
>         template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
>         auto_ptr& operator=(auto_ptr_ref<X> r) throw();
>         ~auto_ptr() throw();

>         // D.9.1.2 members:
>         X& operator*() const throw();
>         X* operator->() const throw();
>         X* get() const throw();
>         X* release() throw();
>         void reset(X* p =0) throw();

>         // D.9.1.3 conversions:
>         auto_ptr(auto_ptr_ref<X>) throw();
>         template<class Y> operator auto_ptr_ref<Y>() throw();
>         template<class Y> operator auto_ptr<Y>() throw();

>         // exposition only
>         template<class U>
>         auto_ptr(U& rhs, typename cannot_transfer_ownership_from<U>::error = 0);
>       };

>       template <> class auto_ptr<void>
>       {
>       public:
>         typedef void element_type;
>       };

>     }

Remove D.9.1.3 [auto.ptr.conv].

Change D.9.1 [auto.ptr], p3:

> The `auto_ptr` provides a semantics of strict ownership. An `auto_ptr` owns the object it holds a pointer to. Copying an `auto_ptr` copies the pointer and transfers ownership to the destination. If more than one `auto_ptr` owns the same object at the same time the behavior of the program is undefined. Templates `constant_object` and `cannot_transfer_ownership_from`, and the final constructor of `auto_ptr` are for exposition only. For any types `X` and `Y`, initializing `auto_ptr<X>` from `const auto_ptr<Y>` is ill-formed, diagnostic required. [Note: The uses of `auto_ptr` include providing temporary exception-safety for dynamically allocated memory, passing ownership of dynamically allocated memory to a function, and returning dynamically allocated memory from a function. `auto_ptr` does not meet the `CopyConstructible` and `Assignable` requirements for Standard Library container elements and thus instantiating a Standard Library container with an `auto_ptr` results in undefined behavior. -- end note]

Change D.9.1.1 [auto.ptr.cons], p5:

>     template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();

> > Requires: `Y*` can be implicitly converted to `X*`.

> > Effects: Calls `const_cast<auto_ptr<Y>&>(``a``)``.release()`.

> > Postconditions: `*this` holds the pointer returned from `a.release()`.

Change D.9.1.1 [auto.ptr.cons], p10:

>     template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();

> > Requires: `Y*` can be implicitly converted to `X*`. The expression `delete get()` is well formed.

> > Effects: Calls `reset(a.release())`.

> > Returns: `*this`.

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

Section: 18.8.1 [exception] Status: Open Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2009-07-30

View all issues with Open 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.

Proposed resolution:

Change 18.8.1 [exception] to:

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

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

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

> > -5- Throws: Nothing. This also applies to all standard library-defined classes that derive from `exception`.

> > -7- Postcondition: `strcmp(what(), e.what()) == 0`. This also applies to all standard library-defined classes that derive from `exception`.

### 473. underspecified ctype calls

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

View all issues with Review 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. ]

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.

### 484. Convertible to T

Section: 24.2.2 [input.iterators] Status: Open Submitter: Chris Jefferson Opened: 2004-09-16 Last modified: 2009-07-28

View all other issues in [input.iterators].

View all issues with Open status.

Discussion:

From comp.std.c++:

I note that given an input iterator a for type T, then *a only has to be "convertable to T", not actually of type T.

Firstly, I can't seem to find an exact definition of "convertable to T". While I assume it is the obvious definition (an implicit conversion), I can't find an exact definition. Is there one?

Slightly more worryingly, there doesn't seem to be any restriction on the this type, other than it is "convertable to T". Consider two input iterators a and b. I would personally assume that most people would expect *a==*b would perform T(*a)==T(*b), however it doesn't seem that the standard requires that, and that whatever type *a is (call it U) could have == defined on it with totally different symantics and still be a valid inputer iterator.

Is this a correct reading? When using input iterators should I write T(*a) all over the place to be sure that the object i'm using is the class I expect?

This is especially a nuisance for operations that are defined to be "convertible to bool". (This is probably allowed so that implementations could return say an int and avoid an unnessary conversion. However all implementations I have seen simply return a bool anyway. Typical implemtations of STL algorithms just write things like `while(a!=b && *a!=0)`. But strictly speaking, there are lots of types that are convertible to T but that also overload the appropriate operators so this doesn't behave as expected.

If we want to make code like this legal (which most people seem to expect), then we'll need to tighten up what we mean by "convertible to T".

[Lillehammer: The first part is NAD, since "convertible" is well-defined in core. The second part is basically about pathological overloads. It's a minor problem but a real one. So leave open for now, hope we solve it as part of iterator redesign.]

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

Proposed resolution:

Rationale:

[ San Francisco: ]

> Solved by N2758.

### 485. output iterator insufficiently constrained

Section: 24.2.3 [output.iterators] Status: Open Submitter: Chris Jefferson Opened: 2004-10-13 Last modified: 2009-07-21

View all other issues in [output.iterators].

View all issues with Open 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 Alsidair requests change from Review to Open. See thread starting with c++std-lib-24459 for discussion. ]

Proposed resolution:

Change Table 101 — Output iterator requirements in 24.2.3 [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 |  |
> `++r` | `X&` |  | `&r == &++r`
> `r++` | convertible to `const X&` | `{X tmp = r; ++r; return tmp;}` |
> `*r++ = o *r = o, ++r *r = o, r++` | result is not used usable |  | Note: only these forms permitted

### 498. Requirements for partition() and stable_partition() too strong

Section: 25.4.13 [alg.partitions] Status: Ready Submitter: Sean Parent, Joe Gottman Opened: 2005-05-04 Last modified: 2009-07-15

View all issues with Ready status.

Discussion:

Problem: The iterator requirements for partition() and stable_partition() [25.2.12] are listed as BidirectionalIterator, however, there are efficient algorithms for these functions that only require ForwardIterator that have been known since before the standard existed. The SGI implementation includes these (see http://www.sgi.com/tech/stl/partition.html and http://www.sgi.com/tech/stl/stable_partition.html).

[ 2009-04-30 Alisdair adds: ]

> Now we have concepts this is easier to express!

> Proposed resolution:

> Add the following signature to:

> Header `<algorithm>` synopsis 25.2 [algorithms.syn]
> p3 Partitions 25.4.13 [alg.partitions]

> >      template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
> >        requires ShuffleIterator<Iter>
> >              && CopyConstructible<Pred>
> >        Iter partition(Iter first, Iter last, Pred pred);

> Update p3 Partitions 25.4.13 [alg.partitions]:

> > Complexity: At most `(last - first)/2` swaps. Exactly `last - first` applications of the predicate are done. If `Iter` satisfies `BidirectionalIterator`, at most `(last - first)/2` swaps. Exactly `last - first` applications of the predicate are done.

> > If `Iter` merely satisfied `ForwardIterator` at most `(last - first)` swaps are done. Exactly `(last - first)` applications of the predicate are done.

> [Editorial note: I looked for existing precedent in how we might call out distinct overloads overloads from a set of constrained templates, but there is not much existing practice to lean on. advance/distance were the only algorithms I could find, and that wording is no clearer.]

[ 2009-07 Frankfurt ]

> Hinnant: if you want to partition your std::forward_list, you'll need partition() to accept ForwardIterators.

> No objection to Ready.

> Move to Ready.

Proposed resolution:

Change 25.2.12 from

>     template<class BidirectionalIterator, class Predicate>
>     BidirectionalIterator partition(BidirectionalIterato r first,
>                                     BidirectionalIterator last,
>                                     Predicate pred);

to

>     template<class ForwardIterator, class Predicate>
>     ForwardIterator partition(ForwardIterator first,
>                               ForwardIterator last,
>                               Predicate pred);

Change the complexity from

> At most (last - first)/2 swaps are done. Exactly (last - first) applications of the predicate are done.

to

> If ForwardIterator is a bidirectional_iterator, at most (last - first)/2 swaps are done; otherwise at most (last - first) swaps are done. Exactly (last - first) applications of the predicate are done.

Rationale:

Partition is a "foundation" algorithm useful in many contexts (like sorting as just one example) - my motivation for extending it to include forward iterators is foward_list - without this extension you can't partition an foward_list (without writing your own partition). Holes like this in the standard library weaken the argument for generic programming (ideally I'd be able to provide a library that would refine std::partition() to other concepts without fear of conflicting with other libraries doing the same - but that is a digression). I consider the fact that partition isn't defined to work for ForwardIterator a minor embarrassment.

[Mont Tremblant: Moved to Open, request motivation and use cases by next meeting. Sean provided further rationale by post-meeting mailing.]

### 532. Tuple comparison

Section: 20.5.2.5 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] Status: Open Submitter: David Abrahams Opened: 2005-11-29 Last modified: 2009-07-28

View all other issues in [tuple.rel].

View all issues with Open status.

Duplicate of: 348

Discussion:

Where possible, tuple comparison operators <,<=,=>, and > ought to be defined in terms of std::less rather than operator<, in order to support comparison of tuples of pointers.

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

Proposed resolution:

change 6.1.3.5/5 from:

> Returns: The result of a lexicographical comparison between t and u. The result is defined as: (bool)(get<0>(t) < get<0>(u)) || (!(bool)(get<0>(u) < get<0>(t)) && ttail < utail), where rtail for some tuple r is a tuple containing all but the first element of r. For any two zero-length tuples e and f, e < f returns false.

to:

> Returns: The result of a lexicographical comparison between t and u. For any two zero-length tuples e and f, e < f returns false. Otherwise, the result is defined as: cmp( get<0>(t), get<0>(u)) || (!cmp(get<0>(u), get<0>(t)) && ttail < utail), where rtail for some tuple r is a tuple containing all but the first element of r, and cmp(x,y) is an unspecified function template defined as follows.

> Where T is the type of x and U is the type of y:

> if T and U are pointer types and T is convertible to U, returns less<U>()(x,y)

> otherwise, if T and U are pointer types, returns less<T>()(x,y)

> otherwise, returns (bool)(x < y)

[ Berlin: This issue is much bigger than just tuple (pair, containers, algorithms). Dietmar will survey and work up proposed wording. ]

Rationale:

Recommend NAD. This will be fixed with the next revision of concepts.

[ San Francisco: ]

> Solved by N2770.

### 539. partial_sum and adjacent_difference should mention requirements

Section: 26.7.3 [partial.sum] Status: Open Submitter: Marc Schoolderman Opened: 2006-02-06 Last modified: 2009-07-30

View all issues with Open 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. ]

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.5 [alg.sorting] Status: Open Submitter: Martin Sebor Opened: 2006-02-05 Last modified: 2009-07-28

View all other issues in [alg.sorting].

View all issues with Open 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...

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

Proposed resolution:

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.

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

Rationale:

[ San Francisco: ]

> Solved by (N2774).

### 564. stringbuf seekpos underspecified

Section: 27.8.1.4 [stringbuf.virtuals] Status: Ready Submitter: Martin Sebor Opened: 2006-02-23 Last modified: 2009-07-15

View all other issues in [stringbuf.virtuals].

View all issues with Ready status.

Discussion:

The effects of the `seekpos()` member function of `basic_stringbuf` simply say that the function positions the input and/or output sequences but fail to spell out exactly how. This is in contrast to the detail in which `seekoff()` is described.

[ 2009-07 Frankfurt ]

> Move to Ready.

Proposed resolution:

Change 27.7.1.3, p13 to read:

> -13- Effects: Equivalent to `seekoff(off_type(sp), ios_base::beg, which)`. Alters the stream position within the controlled sequences, if possible, to correspond to the stream position stored in `sp` (as described below).

> - If `(which & ios_base::in) != 0`, positions the input sequence.
> - If `(which & ios_base::out) != 0`, positions the output sequence.
> - If `sp` is an invalid stream position, or if the function positions neither sequence, the positioning operation fails. If `sp` has not been obtained by a previous successful call to one of the positioning functions (`seekoff`, `seekpos`, `tellg`, `tellp`) the effect is undefined.

[ Kona (2007): A `pos_type` is a position in a stream by definition, so there is no ambiguity as to what it means. Proposed Disposition: NAD ]

[ Post-Kona Martin adds: I'm afraid I disagree with the Kona '07 rationale for marking it NAD. The only text that describes precisely what it means to position the input or output sequence is in `seekoff()`. The `seekpos()` Effects clause is inadequate in comparison and the proposed resolution plugs the hole by specifying `seekpos()` in terms of `seekoff()`. ]

### 565. xsputn inefficient

Section: 27.6.2.4.5 [streambuf.virt.put] Status: Ready Submitter: Martin Sebor Opened: 2006-02-23 Last modified: 2009-07-15

View all issues with Ready status.

Discussion:

`streambuf::xsputn()` is specified to have the effect of "writing up to `n` characters to the output sequence as if by repeated calls to `sputc(c)`."

Since `sputc()` is required to call `overflow()` when `(pptr() == epptr())` is true, strictly speaking `xsputn()` should do the same. However, doing so would be suboptimal in some interesting cases, such as in unbuffered mode or when the buffer is `basic_stringbuf`.

Assuming calling `overflow()` is not really intended to be required and the wording is simply meant to describe the general effect of appending to the end of the sequence it would be worthwhile to mention in `xsputn()` that the function is not actually required to cause a call to `overflow()`.

[ 2009-07 Frankfurt ]

> Move to Ready.

Proposed resolution:

Add the following sentence to the `xsputn()` Effects clause in 27.5.2.4.5, p1 (N1804):

> -1- Effects: Writes up to `n` characters to the output sequence as if by repeated calls to `sputc(c)`. The characters written are obtained from successive elements of the array whose first element is designated by `s`. Writing stops when either `n` characters have been written or a call to `sputc(c)` would return `traits::eof()`. It is uspecified whether the function calls `overflow()` when `(pptr() == epptr())` becomes true or whether it achieves the same effects by other means.

In addition, I suggest to add a footnote to this function with the same text as Footnote 292 to make it extra clear that derived classes are permitted to override `xsputn()` for efficiency.

[ Kona (2007): We want to permit a `streambuf` that streams output directly to a device without making calls to `sputc` or `overflow`. We believe that has always been the intention of the committee. We believe that the proposed wording doesn't accomplish that. Proposed Disposition: Open ]

### 580. unused allocator members

Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Martin Sebor Opened: 2006-06-14 Last modified: 2009-07-15

View other active issues in [container.requirements.general].

View all other issues in [container.requirements.general].

View all issues with Open status.

Duplicate of: 479

Discussion:

C++ Standard Library templates that take an allocator as an argument are required to call the `allocate()` and `deallocate()` members of the allocator object to obtain storage. However, they do not appear to be required to call any other allocator members such as `construct()`, `destroy()`, `address()`, and `max_size()`. This makes these allocator members less than useful in portable programs.

It's unclear to me whether the absence of the requirement to use these allocator members is an unintentional omission or a deliberate choice. However, since the functions exist in the standard allocator and since they are required to be provided by any user-defined allocator I believe the standard ought to be clarified to explictly specify whether programs should or should not be able to rely on standard containers calling the functions.

I propose that all containers be required to make use of these functions.

[ Batavia: We support this resolution. Martin to provide wording. ]

[ pre-Oxford: Martin provided wording. ]

[ 2009-04-28 Pablo adds: ]

> N2554 (scoped allocators), N2768 (allocator concepts), and N2810 (allocator defects), address all of these points EXCEPT `max_size()`. So, I would add a note to that affect and re-class the defect as belonging to section 23.2.1 [container.requirements.general].

[ 2009-07 Frankfurt ]

> The comment in the description of this issue that this "would be" rendered editorial by the adoption of N2257 is confusing. It appears that N2257 was never adopted.

Proposed resolution:

Specifically, I propose to change 23.2 [container.requirements], p9 as follows:

> -9- Copy constructors for all container types defined in this clause that are parametrized on `Allocator` copy an the allocator argument from their respective first parameters. All other constructors for these container types take an const `Allocator&` argument (20.1.6), an allocator whose `value_type` is the same as the container's `value_type`. A copy of this argument is shall be used for any memory allocation and deallocation performed, by these constructors and by all member functions, during the lifetime of each container object. Allocation shall be performed "as if" by calling the `allocate()` member function on a copy of the allocator object of the appropriate type New Footnote), and deallocation "as if" by calling `deallocate()` on a copy of the same allocator object of the corresponding type. A copy of this argument shall also be used to construct and destroy objects whose lifetime is managed by the container, including but not limited to those of the container's `value_type`, and to obtain their address. All objects residing in storage allocated by a container's allocator shall be constructed "as if" by calling the `construct()` member function on a copy of the allocator object of the appropriate type. The same objects shall be destroyed "as if" by calling `destroy()` on a copy of the same allocator object of the same type. The address of such objects shall be obtained "as if" by calling the `address()` member function on a copy of the allocator object of the appropriate type. Finally, a copy of this argument shall be used by its container object to determine the maximum number of objects of the container's `value_type` the container may store at the same time. The container member function `max_size()` obtains this number from the value returned by a call to `get_allocator().max_size()`. In all container types defined in this clause that are parametrized on `Allocator`, the member `get_allocator()` returns a copy of the `Allocator` object used to construct the container.258)

> New Footnote: This type may be different from `Allocator`: it may be derived from `Allocator` via `Allocator::rebind<U>::other` for the appropriate type `U`.

The proposed wording seems cumbersome but I couldn't think of a better way to describe the requirement that containers use their `Allocator` to manage only objects (regardless of their type) that persist over their lifetimes and not, for example, temporaries created on the stack. That is, containers shouldn't be required to call `Allocator::construct(Allocator::allocate(1), elem)` just to construct a temporary copy of an element, or `Allocator::destroy(Allocator::address(temp), 1)` to destroy temporaries.

[ Howard: This same paragraph will need some work to accommodate 431. ]

[ post Oxford: This would be rendered NAD Editorial by acceptance of N2257. ]

### 588. requirements on zero sized tr1::arrays and other details

Section: 23.3.1 [array] Status: Tentatively NAD Submitter: Gennaro Prota Opened: 2006-07-18 Last modified: 2009-07-15

View other active issues in [array].

View all other issues in [array].

View all issues with Tentatively NAD status.

Discussion:

The wording used for section 23.2.1 [lib.array] seems to be subtly ambiguous about zero sized arrays (N==0). Specifically:

* "An instance of array<T, N> stores N elements of type T, so that [...]"

Does this imply that a zero sized array object stores 0 elements, i.e. that it cannot store any element of type T? The next point clarifies the rationale behind this question, basically how to implement begin() and end():

* 23.2.1.5 [lib.array.zero], p2: "In the case that N == 0, begin() == end() == unique value."

What does "unique" mean in this context? Let's consider the following possible implementations, all relying on a partial specialization:

>     a)
>         template< typename T >
>         class array< T, 0 > {

>             ....

>             iterator begin()
>             { return iterator( reinterpret_cast< T * >( this ) ); }
>             ....

>         };

This has been used in boost, probably intending that the return value had to be unique to the specific array object and that array couldn't store any T. Note that, besides relying on a reinterpret_cast, has (more than potential) alignment problems.

>     b)
>         template< typename T >
>         class array< T, 0 > {

>             T t;

>             iterator begin()
>             { return iterator( &t ); }
>             ....

>         };

This provides a value which is unique to the object and to the type of the array, but requires storing a T. Also, it would allow the user to mistakenly provide an initializer list with one element.

A slight variant could be returning *the* null pointer of type T

>         return static_cast<T*>(0);

In this case the value would be unique to the type array<T, 0> but not to the objects (all objects of type array<T, 0> with the same value for T would yield the same pointer value).

Furthermore this is inconsistent with what the standard requires from allocation functions (see library issue 9).

c) same as above but with t being a static data member; again, the value would be unique to the type, not to the object.

d) to avoid storing a T *directly* while disallowing the possibility to use a one-element initializer list a non-aggregate nested class could be defined

>         struct holder { holder() {} T t; } h;

and then begin be defined as

>      iterator begin() { return &h.t; }

But then, it's arguable whether the array stores a T or not. Indirectly it does.

-----------------------------------------------------

Now, on different issues:

* what's the effect of calling assign(T&) on a zero-sized array? There seems to be only mention of front() and back(), in 23.2.1 [lib.array] p4 (I would also suggest to move that bullet to section 23.2.1.5 [lib.array.zero], for locality of reference)

* (minor) the opening paragraph of 23.2.1 [lib.array] wording is a bit inconsistent with that of other sequences: that's not a problem in itself, but compare it for instance with "A vector is a kind of sequence that supports random access iterators"; though the intent is obvious one might argue that the wording used for arrays doesn't tell what an array is, and relies on the reader to infer that it is what the <array> header defines.

* it would be desiderable to have a static const data member of type std::size_t, with value N, for usage as integral constant expression

* section 23.1 [lib.container.requirements] seem not to consider fixed-size containers at all, as it says: "[containers] control allocation and deallocation of these objects [the contained objects] through constructors, destructors, *insert and erase* operations"

* max_size() isn't specified: the result is obvious but, technically, it relies on table 80: "size() of the largest possible container" which, again, doesn't seem to consider fixed size containers

[ 2009-05-29 Daniel adds: ]

> 1. star bullet 1 ("what's the effect of calling `assign(T&)` on a zero-sized array?[..]");

>    > `assign` has been renamed to `fill` and the semantic of `fill` is now defined in terms of the free algorithm `fill_n`, which is well-defined for this situation.

> 2. star bullet 3 ("it would be desiderable to have a static const data member..."):

>    > It seems that `tuple_size<array<T, N> >::value` as of 23.3.1.7 [array.tuple] does provide this functionality now.

[ 2009-07 Frankfurt ]

> Alisdair to address by the next meeting, or declare NAD.

> Moved to Tentatively NAD.

Proposed resolution:

[ Kona (2007): requirements on zero sized `tr1::array`s and other details Issue 617: `std::array` is a sequence that doesn't satisfy the sequence requirements? Alisdair will prepare a paper. Proposed Disposition: Open ]

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

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

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.

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.

### 617. std::array is a sequence that doesn't satisfy the sequence requirements?

Section: 23.3.1 [array] Status: Tentatively NAD Submitter: Bo Persson Opened: 2006-12-30 Last modified: 2009-07-16

View other active issues in [array].

View all other issues in [array].

View all issues with Tentatively NAD status.

Discussion:

The `<array>` header is given under 23.3 [sequences]. 23.3.1 [array]/paragraph 3 says:

> "Unless otherwise specified, all array operations are as described in 23.2 [container.requirements]".

However, array isn't mentioned at all in section 23.2 [container.requirements]. In particular, Table 82 "Sequence requirements" lists several operations (insert, erase, clear) that std::array does not have in 23.3.1 [array].

Also, Table 83 "Optional sequence operations" lists several operations that std::array does have, but array isn't mentioned.

[ 2009-07 Frankfurt ]

> The real issue seems to be different than what is described here. Non-normative text says that std::array is a sequence container, but there is disagreement about what that really means. There are two possible interpretations:

> 1. a sequence container is one that satisfies all sequence container requirements
> 2. a sequence container is one that satisfies some of the sequence container requirements. Any operation that the container supports is specified by one or more sequence container requirements, unless that operation is specifically singled out and defined alongside the description of the container itself.

> Move to Tentatively NAD.

[ 2009-07-15 Loïc Joly adds: ]

> The section 23.2.3 [sequence.reqmts]/1 states that array is a sequence. 23.2.3 [sequence.reqmts]/3 introduces table 83, named Sequence container requirements. This seems to me to be defining the requirements for all sequences. However, array does not follow all of this requirements (this can be read in the array specific section, for the standard is currently inconsistent).

> Proposed resolution 1 (minimal change):

> > Say that array is a container, that in addition follows only some of the sequence requirements, as described in the array section:

> > > The library provides five three basic kinds of sequence containers: `array`, `vector`, `forward_list`, `list`, and `deque`. In addition, `array` and `forward_list` follows some of the requirements of sequences, as described in their respective sections.

> Proposed resolution 2 (most descriptive description, no full wording provided):

> > Introduce the notion of a Fixed Size Sequence, with it requirement table that would be a subset of the current Sequence container. array would be the only Fixed Size Sequence (but dynarray is in the queue for TR2). Sequence requirements would now be requirements in addition to Fixed Size Sequence requirements (it is currently in addition to container).

[ 2009-07 Frankfurt: ]

> Move to NAD Editorial

Proposed resolution:

### 625. mixed up Effects and Returns clauses

Section: 17 [library] Status: Tentatively NAD Submitter: Martin Sebor Opened: 2007-01-20 Last modified: 2009-07-15

View other active issues in [library].

View all other issues in [library].

View all issues with Tentatively NAD 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.

Proposed resolution:

### 630. arrays of valarray

Section: 26.6.2.1 [valarray.cons] Status: Ready Submitter: Martin Sebor Opened: 2007-01-28 Last modified: 2009-07-15

View all other issues in [valarray.cons].

View all issues with Ready status.

Discussion:

Section 26.2 [numeric.requirements], p1 suggests that a `valarray` specialization on a type `T` that satisfies the requirements enumerated in the paragraph is itself a valid type on which `valarray` may be instantiated (Footnote 269 makes this clear). I.e., `valarray<valarray<T> >` is valid as long as `T` is valid. However, since implementations of `valarray` are permitted to initialize storage allocated by the class by invoking the default ctor of `T` followed by the copy assignment operator, such implementations of `valarray` wouldn't work with (perhaps user-defined) specializations of `valarray` whose assignment operator had undefined behavior when the size of its argument didn't match the size of `*this`. By "wouldn't work" I mean that it would be impossible to resize such an array of arrays by calling the `resize()` member function on it if the function used the copy assignment operator after constructing all elements using the default ctor (e.g., by invoking `new value_type[N]`) to obtain default-initialized storage) as it's permitted to do.

Stated more generally, the problem is that `valarray<valarray<T> >::resize(size_t)` isn't required or guaranteed to have well-defined semantics for every type `T` that satisfies all requirements in 26.2 [numeric.requirements].

I believe this problem was introduced by the adoption of the resolution outlined in N0857, Assignment of valarrays, from 1996. The copy assignment operator of the original numerical array classes proposed in N0280, as well as the one proposed in N0308 (both from 1993), had well-defined semantics for arrays of unequal size (the latter explicitly only when `*this` was empty; assignment of non empty arrays of unequal size was a runtime error).

The justification for the change given in N0857 was the "loss of performance [deemed] only significant for very simple operations on small arrays or for architectures with very few registers."

Since tiny arrays on a limited subset of hardware architectures are likely to be an exceedingly rare case (despite the continued popularity of x86) I propose to revert the resolution and make the behavior of all `valarray` assignment operators well-defined even for non-conformal arrays (i.e., arrays of unequal size). I have implemented this change and measured no significant degradation in performance in the common case (non-empty arrays of equal size). I have measured a 50% (and in some cases even greater) speedup in the case of assignments to empty arrays versus calling `resize()` first followed by an invocation of the copy assignment operator.

[ Bellevue: ]

> If no proposed wording by June meeting, this issue should be closed NAD.

[ 2009-07 Frankfurt ]

> Move resolution 1 to Ready.

> Howard: second resolution has been commented out (made invisible). Can be brought back on demand.

Proposed resolution:

Change 26.6.2.2 [valarray.assign], p1 as follows:

> `valarray<T>& operator=(const valarray<T>& x);`

> -1- Each element of the `*this` array is assigned the value of the corresponding element of the argument array. The resulting behavior is undefined if When the length of the argument array is not equal to the length of the *this array. resizes `*this` to make the two arrays the same length, as if by calling `resize(x.size())`, before performing the assignment.

And add a new paragraph just below paragraph 1 with the following text:

> -2- Postcondition: `size() == x.size()`.

Also add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:

> -?- When the length, `N` of the array referred to by the argument is not equal to the length of `*this`, the operator resizes `*this` to make the two arrays the same length, as if by calling `resize(N)`, before performing the assignment.

[ pre-Sophia Antipolis, Martin adds the following compromise wording, but prefers the original proposed resolution: ]

[ Kona (2007): Gaby to propose wording for an alternative resolution in which you can assign to a `valarray` of size 0, but not to any other `valarray` whose size is unequal to the right hand side of the assignment. ]

### 631. conflicting requirements for `BinaryPredicate`

Section: 25 [algorithms] Status: Open Submitter: James Kanze Opened: 2007-01-31 Last modified: 2009-07-28

View other active issues in [algorithms].

View all other issues in [algorithms].

View all issues with Open 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.5.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. ]

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.

### 635. domain of `allocator::address`

Section: X [allocator.requirements] Status: Open Submitter: Howard Hinnant Opened: 2007-02-08 Last modified: 2009-07-28

View other active issues in [allocator.requirements].

View all other issues in [allocator.requirements].

View all issues with Open status.

Discussion:

The table of allocator requirements in X [allocator.requirements] describes `allocator::address` as:

>     a.address(r)
>     a.address(s)

where `r` and `s` are described as:

> a value of type `X::reference` obtained by the expression `*p`.

and `p` is

> a value of type `X::pointer`, obtained by calling `a1.allocate`, where `a1 == a`

This all implies that to get the address of some value of type `T` that value must have been allocated by this allocator or a copy of it.

However sometimes container code needs to compare the address of an external value of type `T` with an internal value. For example `list::remove(const T& t)` may want to compare the address of the external value `t` with that of a value stored within the list. Similarly `vector` or `deque insert` may want to make similar comparisons (to check for self-referencing calls).

Mandating that `allocator::address` can only be called for values which the allocator allocated seems overly restrictive.

[ post San Francisco: ]

> Pablo recommends NAD Editorial, solved by N2768.

[ 2009-04-28 Pablo adds: ]

> Tentatively-ready NAD Editorial as fixed by N2768.

[ 2009-07 Frankfurt ]

> Fixed by N2768.

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

Proposed resolution:

Change X [allocator.requirements]:

> `r` : a value of type `X::reference` obtained by the expression *p.

> `s` : a value of type `X::const_reference` obtained by the expression `*q` or by conversion from a value `r`.

[ post Oxford: This would be rendered NAD Editorial by acceptance of N2257. ]

[ Kona (2007): This issue is section 8 of N2387. There was some discussion of it but no resolution to this issue was recorded. Moved to Open. ]

### 659. istreambuf_iterator should have an operator->()

Section: 24.6.3 [istreambuf.iterator] Status: Ready Submitter: Niels Dekker Opened: 2007-03-25 Last modified: 2009-07-15

View all other issues in [istreambuf.iterator].

View all issues with Ready status.

Discussion:

Greg Herlihy has clearly demonstrated that a user defined input iterator should have an operator->(), even if its value type is a built-in type (comp.std.c++, "Re: Should any iterator have an operator->() in C++0x?", March 2007). And as Howard Hinnant remarked in the same thread that the input iterator `istreambuf_iterator` doesn't have one, this must be a defect!

Based on Greg's example, the following code demonstrates the issue:

     #include <iostream>
     #include <fstream>
     #include <streambuf>

     typedef char C;
     int main ()
     {
       std::ifstream s("filename", std::ios::in);
       std::istreambuf_iterator<char> i(s);

       (*i).~C();  // This is well-formed...
       i->~C();  // ... so this should be supported!
     }

Of course, operator-> is also needed when the value_type of istreambuf_iterator is a class.

The operator-> could be implemented in various ways. For instance, by storing the current value inside the iterator, and returning its address. Or by returning a proxy, like operator_arrow_proxy, from http://www.boost.org/boost/iterator/iterator_facade.hpp

I hope that the resolution of this issue will contribute to getting a clear and consistent definition of iterator concepts.

[ Kona (2007): The proposed resolution is inconsistent because the return type of `istreambuf_iterator::operator->()` is specified to be `pointer`, but the proposed text also states that "`operator->` may return a proxy." ]

[ Niels Dekker (mailed to Howard Hinnant): ]

> The proposed resolution does not seem inconsistent to me. `istreambuf_iterator::operator->()` should have `istreambuf_iterator::pointer` as return type, and this return type may in fact be a proxy.

> AFAIK, the resolution of 445 ("`iterator_traits::reference` unspecified for some iterator categories") implies that for any iterator class `Iter`, the return type of `operator->()` is `Iter::pointer`, by definition. I don't think `Iter::pointer` needs to be a raw pointer.

> Still I wouldn't mind if the text "`operator->` may return a proxy" would be removed from the resolution. I think it's up to the library implementation, how to implement `istreambuf_iterator::operator->()`. As longs as it behaves as expected: `i->m` should have the same effect as `(*i).m`. Even for an explicit destructor call, `i->~C()`. The main issue is just: `istreambuf_iterator` should have an `operator->()`!

[ 2009-04-30 Alisdair adds: ]

> Note that operator-> is now a requirement in the `InputIterator` concept, so this issue cannot be ignored or existing valid programs will break when compiled with an 0x library.

[ 2009-05-29 Alisdair adds: ]

> I agree with the observation that in principle the type 'pointer' may be a proxy, and the words highlighting this are redundant.

> However, in the current draught `pointer` is required to be exactly '`charT *`' by the derivation from `std::iterator`. At a minimum, the 4th parameter of this base class template should become unspecified. That permits the introduction of a proxy as a nested class in some further undocumented (not even exposition-only) base.

> It also permits the `istream_iterator` approach where the cached value is stored in the iterator itself, and the iterator serves as its own proxy for post-increment `operator++` - removing the need for the existing exposition-only nested class `proxy`.

> Note that the current `proxy` class also has exactly the right properties to serve as the pointer `proxy` too. This is likely to be a common case where an `InputIterator` does not hold internal state but delegates to another class.

> Proposed Resolution:

> In addition to the current proposal:

> 24.6.3 [istreambuf.iterator]

> >     template<class charT, class traits = char_traits<charT> >
> >     class istreambuf_iterator
> >       : public iterator<input_iterator_tag, charT,
> >                         typename traits::off_type, charT* unspecified, charT> {

[ 2009-07 Frankfurt ]

> Move the additional part into the proposed resolution, and wrap the descriptive text in a Note.

> [Howard: done.]

> Move to Ready.

Proposed resolution:

Add to the synopsis in 24.6.3 [istreambuf.iterator]:

>     charT operator*() const;
>     pointer operator->() const;
>     istreambuf_iterator<charT,traits>& operator++();

24.6.3 [istreambuf.iterator]

>     template<class charT, class traits = char_traits<charT> >
>     class istreambuf_iterator
>       : public iterator<input_iterator_tag, charT,
>                         typename traits::off_type, charT* unspecified, charT> {

Change 24.6.3 [istreambuf.iterator], p1:

> The class template `istreambuf_iterator` reads successive characters from the `streambuf` for which it was constructed. `operator*` provides access to the current input character, if any. [Note: `operator->` may return a proxy. — end note] Each time `operator++` is evaluated, the iterator advances to the next input character. If the end of stream is reached (`streambuf_type::sgetc()` returns `traits::eof()`), the iterator becomes equal to the end of stream iterator value. The default constructor `istreambuf_iterator()` and the constructor `istreambuf_iterator(0)` both construct an end of stream iterator object suitable for use as an end-of-range.

### 668. `money_get`'s empty minus sign

Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Review Submitter: Thomas Plum Opened: 2007-04-16 Last modified: 2009-07-20

View other active issues in [locale.money.get.virtuals].

View all other issues in [locale.money.get.virtuals].

View all issues with Review status.

Discussion:

22.4.6.1.2 [locale.money.get.virtuals], para 3 says:

> If `pos` or `neg` is empty, the sign component is optional, and if no sign is detected, the result is given the sign that corresponds to the source of the empty string.

The following objection has been raised:

> A `negative_sign` of "" means "there is no way to write a negative sign" not "any null sequence is a negative sign, so it's always there when you look for it".

[Plum ref _222612Y32]

[ Kona (2007): Bill to provide proposed wording and interpretation of existing wording. ]

Related to 669.

[ 2009-05-17 Howard adds: ]

> I disagree that a `negative_sign` of "" means "there is no way to write a negative sign". The meaning requires the sentences of 22.4.6.1.2 [locale.money.get.virtuals] p3 following that quoted above to be taken into account:

> > -3- ... If `pos` or `neg` is empty, the sign component is optional, and if no sign is detected, the result is given the sign that corresponds to the source of the empty string. Otherwise, the character in the indicated position must match the first character of `pos` or `neg`, and the result is given the corresponding sign. If the first character of `pos` is equal to the first character of `neg`, or if both strings are empty, the result is given a positive sign.

> So a `negative_sign` of "" means "there is no way to write a negative sign" only when `positive_sign` is also "". However when `negative_sign` is "" and `postive_sign.size() > 0`, then one writes a negative value by not writing the `postive_sign` in the position indicated by `money_base::sign`. For example:

> >     pattern = {symbol, sign, value, none}
> >     positive_sign = "+"
> >     negative_sign = ""
> >     $123   // a negative value, using optional sign
> >     $+123  // a positive value
> >     $-123  // a parse error

> And:

> >     pattern = {symbol, sign, value, none}
> >     positive_sign = ""
> >     negative_sign = ""
> >     $123   // a positive value, no sign possible
> >     $+123  // a parse error
> >     $-123  // a parse error

> And (regarding 669):

> >     pattern = {symbol, sign, value, none}
> >     positive_sign = "-"
> >     negative_sign = "-"
> >     $123   // a parse error, sign is mandatory
> >     $+123  // a parse error
> >     $-123  // a positive value

> The text seems both unambiguous and clear to me. I recommend NAD for both this issue and 669. However I would have no objection to adding examples such as those above.

[ Batavia (2009-05): ]

> This discussion applies equally to issue 669 (q.v.). Howard has added examples above, and recommends either NAD or a resolution that adds his (or similar) examples to the Working Paper.

> Alan would like to rewrite paragraph 3.

> We recommend moving to NAD. Anyone who feels strongly about adding the examples is invited to submit corresponding wording. We further recommend issue 669 be handled identically.

[ 2009-07-14 Alan reopens with improved wording. ]

[ 2009-07 Frankfurt ]

> No consensus for closing as NAD. Leave in Review.

Proposed resolution:

Change 22.4.6.1.2 [locale.money.get.virtuals] p3:

> -3- If the first character (if any) in the string pos returned by `mp.positive_sign()` or the string `neg` returned by `mp.negative_sign()` is recognized in the position indicated by sign in the format pattern, it is consumed and any remaining characters in the string are required after all the other format components. [Example: If `showbase` is off�, then for a `neg` value of "()" and a currency symbol of "L", in "(100 L)" the "L" is consumed; but if `neg` is "-", the "L" in "-100 L" is not consumed. -- end example] If `pos` or `neg` is empty, the sign component is optional, and if no sign is detected, the result is given the sign that corresponds to the source of the empty string. Otherwise, the character in the indicated position must match the first character of `pos` or `neg`, and the result is given the corresponding sign. If the first character of `pos` is equal to the first character of `neg`, or if both strings are empty, the result is given a positive sign. The sign pattern strings `pos` and `neg` are returned by `mp.positive_sign()` and `mp.negative_sign()` respectively. A sign pattern is matched if its first character is recognized in `s` in the position indicated by `sign` in the format pattern, or if the pattern is empty and there is no sign recognized in `s`. A match is required to occur. If both patterns are matched, the result is given a positive sign, otherwise the result is given the sign corresponding to the matched pattern. If the pattern contains more than one character, the characters after the first must be matched in `s` after all other format components. If any sign characters are matched, `s` is consumed up to and including those characters. [Example: If `showbase` is off, then for a `neg` value of "`()`" and a currency symbol of "`L`", in "`(100 L)`" the entire string is consumed; but for a `neg` value of "`-`", in "`-100 L`", the string is consumed through the second "`0`" (the space and "`L`" are not consumed). — end example]

### 671. precision of hexfloat

Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Review Submitter: John Salmon Opened: 2007-04-20 Last modified: 2009-07-26

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

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

View all issues with Review 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. ]

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: Open Submitter: Howard Hinnant Opened: 2007-05-05 Last modified: 2009-07-28

View all other issues in [unord].

View all issues with Open 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. ]

Proposed resolution:

Add to 23.5 [unord]:

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

>     ...

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
>                 unordered_set<Value, Hash, Pred, Alloc>& y);

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
>                 unordered_set<Value, Hash, Pred, Alloc>&& y);

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Value, Hash, Pred, Alloc>&& x,
>                 unordered_set<Value, Hash, Pred, Alloc>& y);

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Value, Hash, Pred, Alloc>& y);

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Value, Hash, Pred, Alloc>&& y);

>     template <class Value, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Value, Hash, Pred, Alloc>&& x,
>                 unordered_multiset<Value, Hash, Pred, Alloc>& y);

`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(iterator hint, const value_type& obj);
>         template <class P> iterator       insert(iterator hint, P&& obj);
>         const_iterator insert(const_iterator hint, const value_type& obj);
>         template <class P> const_iterator insert(const_iterator hint, P&& obj);
>         ...
>         void swap(unordered_map&&);
>         ...
>         mapped_type& operator[](const key_type& k);
>         mapped_type& operator[](key_type&& k);
>         ...
>     };

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);

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(iterator hint, const value_type& x);
>     template <class P> iterator       insert(iterator hint, P&& x);
>     const_iterator insert(const_iterator hint, const value_type& x);
>     template <class P> const_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`.

> > `P` shall be convertible to `value_type`. 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 of `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`.

Add to 23.5.1.3 [unord.map.swap]:

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>&& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_map<Key, T, Hash, Pred, Alloc>& y);

`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(iterator hint, const value_type& obj);
>         template <class P> iterator       insert(iterator hint, P&& obj);
>         const_iterator insert(const_iterator hint, const value_type& obj);
>         template <class P> const_iterator insert(const_iterator hint, P&& obj);
>         ...
>         void swap(unordered_multimap&&);
>         ...
>     };

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

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(iterator hint, const value_type& x);
>     template <class P> iterator       insert(iterator hint, P&& x);
>     const_iterator insert(const_iterator hint, const value_type& x);
>     template <class P> const_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`.

> > `P` shall be convertible to `value_type`. 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 of `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`.

Add to 23.5.2.2 [unord.multimap.swap]:

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

`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(iterator hint, const value_type& obj);
>         iterator       insert(iterator hint, value_type&& obj);
>         const_iterator insert(const_iterator hint, const value_type& obj);
>         const_iterator insert(const_iterator hint, value_type&& obj);
>         ...
>         void swap(unordered_set&&);
>         ...
>     };

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>& y);

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(iterator hint, const value_type& x);
>     iterator       insert(iterator hint, value_type&& x);
>     const_iterator insert(const_iterator hint, const value_type& x);
>     const_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`.

Add to 23.5.3.2 [unord.set.swap]:

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>&& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_set<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_set<Key, T, Hash, Pred, Alloc>& y);

`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(iterator hint, const value_type& obj);
>         iterator       insert(iterator hint, value_type&& obj);
>         const_iterator insert(const_iterator hint, const value_type& obj);
>         const_iterator insert(const_iterator hint, value_type&& obj);
>         ...
>         void swap(unordered_multiset&&);
>         ...
>     };

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>&& y);

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>& y);

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(iterator hint, const value_type& x);
>     iterator       insert(iterator hint, value_type&& x);
>     const_iterator insert(const_iterator hint, const value_type& x);
>     const_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`.

Add to 23.5.4.2 [unord.multiset.swap]:

>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>&& y);
>     template <class Key, class T, class Hash, class Pred, class Alloc>
>       void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>&& x,
>                 unordered_multiset<Key, T, Hash, Pred, Alloc>& y);

[ 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.

### 696. `istream::operator>>(int&)` broken

Section: 27.7.1.2.2 [istream.formatted.arithmetic] Status: Ready Submitter: Martin Sebor Opened: 2007-06-23 Last modified: 2009-07-15

View all other issues in [istream.formatted.arithmetic].

View all issues with Ready status.

Discussion:

From message c++std-lib-17897:

The code shown in 27.7.1.2.2 [istream.formatted.arithmetic] as the "as if" implementation of the two arithmetic extractors that don't have a corresponding `num_get` interface (i.e., the `short` and `int` overloads) is subtly buggy in how it deals with `EOF`, overflow, and other similar conditions (in addition to containing a few typos).

One problem is that if `num_get::get()` reaches the EOF after reading in an otherwise valid value that exceeds the limits of the narrower type (but not `LONG_MIN` or `LONG_MAX`), it will set `err` to `eofbit`. Because of the if condition testing for `(err == 0)`, the extractor won't set `failbit` (and presumably, return a bogus value to the caller).

Another problem with the code is that it never actually sets the argument to the extracted value. It can't happen after the call to `setstate()` since the function may throw, so we need to show when and how it's done (we can't just punt as say: "it happens afterwards"). However, it turns out that showing how it's done isn't quite so easy since the argument is normally left unchanged by the facet on error except when the error is due to a misplaced thousands separator, which causes `failbit` to be set but doesn't prevent the facet from storing the value.

[ Batavia (2009-05): ]

> We believe this part of the Standard has been recently adjusted and that this issue was addressed during that rewrite.

> Move to NAD.

[ 2009-05-28 Howard adds: ]

> I've moved this issue from Tentatively NAD to Open.

> The current wording of N2857 in 22.4.2.1.2 [facet.num.get.virtuals] p3, stage 3 appears to indicate that in parsing arithmetic types, the value is always set, but sometimes in addition to setting `failbit`.

> - If there is a range error, the value is set to min or max, else
> - if there is a conversion error, the value is set to 0, else
> - if there is a grouping error, the value is set to whatever it would be if grouping were ignored, else
> - the value is set to its error-free result.

> However there is a contradictory sentence in 22.4.2.1.2 [facet.num.get.virtuals] p1.

> 27.7.1.2.2 [istream.formatted.arithmetic] should mimic the behavior of 22.4.2.1.2 [facet.num.get.virtuals] (whatever we decide that behavior is) for `int` and `short`, and currently does not. I believe that the correct code fragment should look like:

> >     typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
> >     iostate err = ios_base::goodbit;
> >     long lval;
> >     use_facet<numget>(loc).get(*this, 0, *this, err, lval);
> >     if (lval < numeric_limits<int>::min())
> >     {
> >       err |= ios_base::failbit;
> >       val = numeric_limits<int>::min();
> >     }
> >     else if (lval > numeric_limits<int>::max())
> >     {
> >       err |= ios_base::failbit;
> >       val = numeric_limits<int>::max();
> >     }
> >     else
> >       val = static_cast<int>(lval);
> >     setstate(err);

[ 2009-07 Frankfurt ]

> Move to Ready.

Proposed resolution:

Change 22.4.2.1.2 [facet.num.get.virtuals], p1:

> -1- Effects: Reads characters from `in`, interpreting them according to `str.flags()`, `use_facet<ctype<charT> >(loc)`, and `use_facet< numpunct<charT> >(loc)`, where `loc` is `str.getloc()`. If an error occurs, `val` is unchanged; otherwise it is set to the resulting value.

Change 27.7.1.2.2 [istream.formatted.arithmetic], p2 and p3:

>     operator>>(short& val);

> > -2- The conversion occurs as if performed by the following code fragment (using the same notation as for the preceding code fragment):

> > >     typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
> > >     iostate err = iostate_base::goodbit;
> > >     long lval;
> > >     use_facet<numget>(loc).get(*this, 0, *this, err, lval);
> > >     if (err != 0)
> > >       ;
> > >     else if (lval < numeric_limits<short>::min()
> > >       || numeric_limits<short>::max() < lval)
> > >          err = ios_base::failbit;
> > >     if (lval < numeric_limits<short>::min())
> > >     {
> > >       err |= ios_base::failbit;
> > >       val = numeric_limits<short>::min();
> > >     }
> > >     else if (lval > numeric_limits<short>::max())
> > >     {
> > >       err |= ios_base::failbit;
> > >       val = numeric_limits<short>::max();
> > >     }
> > >     else
> > >       val = static_cast<short>(lval);
> > >     setstate(err);

>     operator>>(int& val);

> > -3- The conversion occurs as if performed by the following code fragment (using the same notation as for the preceding code fragment):

> > >     typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
> > >     iostate err = iostate_base::goodbit;
> > >     long lval;
> > >     use_facet<numget>(loc).get(*this, 0, *this, err, lval);
> > >     if (err != 0)
> > >       ;
> > >     else if (lval < numeric_limits<int>::min()
> > >       || numeric_limits<int>::max() < lval)
> > >          err = ios_base::failbit;
> > >     if (lval < numeric_limits<int>::min())
> > >     {
> > >       err |= ios_base::failbit;
> > >       val = numeric_limits<int>::min();
> > >     }
> > >     else if (lval > numeric_limits<int>::max())
> > >     {
> > >       err |= ios_base::failbit;
> > >       val = numeric_limits<int>::max();
> > >     }
> > >     else
> > >       val = static_cast<int>(lval);
> > >     setstate(err);

### 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-07-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.

Proposed resolution:

Rationale:

[ post San Francisco: ]

> Solved by N2776.

### 711. Contradiction in empty `shared_ptr`

Section: 20.8.10.2.5 [util.smartptr.shared.obs] Status: Ready Submitter: Peter Dimov Opened: 2007-08-24 Last modified: 2009-07-17

View all other issues in [util.smartptr.shared.obs].

View all issues with Ready status.

Discussion:

A discussion on comp.std.c++ has identified a contradiction in the `shared_ptr` specification. The note:

> [ Note: this constructor allows creation of an empty shared_ptr instance with a non-NULL stored pointer. -end note ]

after the aliasing constructor

>     template<class Y> shared_ptr(shared_ptr<Y> const& r, T *p);

reflects the intent of N2351 to, well, allow the creation of an empty `shared_ptr` with a non-NULL stored pointer.

This is contradicted by the second sentence in the Returns clause of 20.8.10.2.5 [util.smartptr.shared.obs]:

>     T* get() const;

> > Returns: the stored pointer. Returns a null pointer if `*this` is empty.

[ Bellevue: ]

> Adopt option 1 and move to review, not ready.

> There was a lot of confusion about what an empty `shared_ptr` is (the term isn't defined anywhere), and whether we have a good mental model for how one behaves. We think it might be possible to deduce what the definition should be, but the words just aren't there. We need to open an issue on the use of this undefined term. (The resolution of that issue might affect the resolution of issue 711.)

> The LWG is getting more uncomfortable with the aliasing proposal (N2351) now that we realize some of its implications, and we need to keep an eye on it, but there isn't support for removing this feature at this time.

[ Sophia Antipolis: ]

> We heard from Peter Dimov, who explained his reason for preferring solution 1.

> Because it doesn't seem to add anything. It simply makes the behavior for p = 0 undefined. For programmers who don't create empty pointers with p = 0, there is no difference. Those who do insist on creating them presumably have a good reason, and it costs nothing for us to define the behavior in this case.

> The aliasing constructor is sharp enough as it is, so "protecting" users doesn't make much sense in this particular case.

> > Do you have a use case for r being empty and r being non-null?

> I have received a few requests for it from "performance-conscious" people (you should be familiar with this mindset) who don't like the overhead of allocating and maintaining a control block when a null deleter is used to approximate a raw pointer. It is obviously an "at your own risk", low-level feature; essentially a raw pointer behind a shared_ptr facade.

> We could not agree upon a resolution to the issue; some of us thought that Peter's description above is supporting an undesirable behavior.

[ 2009-07 Frankfurt: ]

> We favor option 1, move to Ready.

> [ Howard: Option 2 commented out for clarity, and can be brought back. ]

Proposed resolution:

In keeping the N2351 spirit and obviously my preference, change 20.8.10.2.5 [util.smartptr.shared.obs]:

>     T* get() const;

> > Returns: the stored pointer. Returns a null pointer if `*this` is empty.

### 716. Production in [re.grammar] not actually modified

Section: 28.13 [re.grammar] Status: Ready Submitter: Stephan T. Lavavej Opened: 2007-08-31 Last modified: 2009-07-16

View all issues with Ready status.

Discussion:

TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.13 [re.grammar]/3 say:

> The following productions within the ECMAScript grammar are modified as follows:

> >     CharacterClass ::
> >     [ [lookahead ∉ {^}] ClassRanges ]
> >     [ ^ ClassRanges ]

This definition for `CharacterClass` appears to be exactly identical to that in ECMA-262.

Was an actual modification intended here and accidentally omitted, or was this production accidentally included?

[ Batavia (2009-05): ]

> We agree that what is specified is identical to what ECMA-262 specifies. Pete would like to take a bit of time to assess whether we had intended, but failed, to make a change. It would also be useful to hear from John Maddock on the issue.

> Move to Open.

[ 2009-07 Frankfurt: ]

> Move to Ready.

Proposed resolution:

Remove this mention of the CharacterClass production.

>     CharacterClass ::
>     [ [lookahead ∉ {^}] ClassRanges ]
>     [ ^ ClassRanges ]

### 719. `std::is_literal` type traits should be provided

Section: 20.6 [meta] Status: Open Submitter: Daniel Krügler Opened: 2007-08-25 Last modified: 2009-07-16

View other active issues in [meta].

View all other issues in [meta].

View all issues with Open status.

Duplicate of: 750

Discussion:

Since the inclusion of `constexpr` in the standard draft N2369 we have a new type category "literal", which is defined in 3.9 [basic.types]/p.11:

> -11- A type is a literal type if it is:

> - a scalar type; or

> - a class type (clause 9) with

>   - a trivial copy constructor,
>   - a trivial destructor,
>   - at least one constexpr constructor other than the copy constructor,
>   - no virtual base classes, and
>   - all non-static data members and base classes of literal types; or
> - an array of literal type.

I strongly suggest that the standard provides a type traits for literal types in 20.6.4.3 [meta.unary.prop] for several reasons:

1. To keep the traits in sync with existing types.
2. I see many reasons for programmers to use this trait in template code to provide optimized template definitions for these types, see below.
3. A user-provided definition of this trait is practically impossible to write portably.

The special problem of reason (c) is that I don't see currently a way to portably test the condition for literal class types:

> - at least one constexpr constructor other than the copy constructor,

[ Alisdair is considering preparing a paper listing a number of missing type traits, and feels that it might be useful to handle them all together rather than piecemeal. This would affect issue 719 and 750. These two issues should move to OPEN pending AM paper on type traits. ]

[ 2009-07 Frankfurt: ]

> Beman, Daniel, and Alisdair will work on a paper proposing new type traits.

Proposed resolution:

In 20.6.2 [meta.type.synop] in the group "type properties", just below the line

>     template <class T> struct is_pod;

add a new one:

>     template <class T> struct is_literal;

In 20.6.4.3 [meta.unary.prop], table Type Property Predicates, just below the line for the `is_pod` property add a new line:

Template | Condition | Preconditions
--- | --- | ---
`template <class T> struct is_literal;` | `T` is a literal type (3.9) | `T` shall be a complete type, an array of unknown bound, or (possibly cv-qualified) `void`.

### 723. `basic_regex` should be moveable

Section: 28.8 [re.regex] Status: Ready Submitter: Daniel Krügler Opened: 2007-08-29 Last modified: 2009-07-16

View all other issues in [re.regex].

View all issues with Ready status.

Discussion:

Addresses UK 316

According to the current state of the standard draft, the class template `basic_regex`, as described in 28.8 [re.regex]/3, is neither `MoveConstructible` nor `MoveAssignable`. IMO it should be, because typical regex state machines tend to have a rather large data quantum and I have seen several use cases, where a factory function returns regex values, which would take advantage of moveabilities.

[ Sophia Antipolis: ]

> Needs wording for the semantics, the idea is agreed upon.

[ Post Summit Daniel updated wording to reflect new "swap rules". ]

[ 2009-07 Frankfurt: ]

> Move to Ready.

Proposed resolution:

In the class definition of `basic_regex`, just below 28.8 [re.regex]/3, perform the following changes:

1. Just after `basic_regex(const basic_regex&);` insert:

   >     basic_regex(basic_regex&&);

2. Just after `basic_regex& operator=(const basic_regex&);` insert:

   >     basic_regex& operator=(basic_regex&&);

3. Just after `basic_regex& assign(const basic_regex& that);` insert:

   >     basic_regex& assign(basic_regex&& that);

4. In 28.8.2 [re.regex.construct], just after p.11 add the following new member definition:

   >     basic_regex(basic_regex&& e);

   > > Effects: Move-constructs a `basic_regex` instance from `e`.

   > > Postconditions: `flags()` and `mark_count()` return `e.flags()` and `e.mark_count()`, respectively, that `e` had before construction, leaving `e` in a valid state with an unspecified value.

   > > Throws: nothing.

5. Also in 28.8.2 [re.regex.construct], just after p.18 add the following new member definition:

   >     basic_regex& operator=(basic_regex&& e);

   > > Effects: Returns the result of `assign(std::move(e))`.

6. In 28.8.3 [re.regex.assign], just after p. 2 add the following new member definition:

   >     basic_regex& assign(basic_regex&& rhs);

   > > Effects: Move-assigns a `basic_regex` instance from `rhs` and returns `*this`.

   > > Postconditions: `flags()` and `mark_count()` return `rhs.flags()` and `rhs.mark_count()`, respectively, that `rhs` had before assignment, leaving `rhs` in a valid state with an unspecified value.

   > > Throws: nothing.

### 724. `DefaultConstructible` is not defined

Section: X [utility.arg.requirements] Status: Open Submitter: Pablo Halpern Opened: 2007-09-12 Last modified: 2009-07-28

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. ]

Proposed resolution:

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

Table 33: `DefaultConstructible` requirements

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-07-25

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.

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: Open Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-07-31

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

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

View all issues with Open 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. ]

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.3 [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: X [utility.arg.requirements] Status: Open Submitter: Howard Hinnant Opened: 2007-10-10 Last modified: 2009-07-28

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. ]

Proposed resolution:

Change X [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 `CopyConstructible` `MoveConstructible` requirements (Table 34 33) and the `CopyAssignable` `MoveAssignable` requirements (Table 36 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(tw,u v)` is valid and has the semantics described in this table.

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-07-30

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.

Proposed resolution:

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.4.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.4.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.4.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

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

Section: 25.5.4 [alg.merge] Status: Ready Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2009-07-16

View all issues with Ready 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.5.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.

Proposed resolution:

In 25.5.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))` `[result, last)` (where `last` is equal to `result + (last1 - first1) + (last2 - first2))`, 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 < *(i - 1)` or, respectively, `comp(*i, *(i - 1))` 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.

[N.B.: I attempted to reuse the wording style of `inplace_merge`, therefore proposing to insert ", respectively," between both predicate tests. This is no strictly necessary as other parts of `<algorithm>` show, just a matter of consistency]

### 788. ambiguity in [istream.iterator]

Section: 24.6.1 [istream.iterator] Status: Ready Submitter: Martin Sebor Opened: 2008-02-06 Last modified: 2009-07-16

View other active issues in [istream.iterator].

View all other issues in [istream.iterator].

View all issues with Ready status.

Discussion:

Addresses UK 287

> It is not clear what the initial state of an `istream_iterator` should be. Is _value_ initialized by reading the stream, or default/value initialized? If it is initialized by reading the stream, what happens if the initialization is deferred until first dereference, when ideally the iterator value should have been that of an end-of-stream iterator which is not safely dereferencable?

> Recommendation: Specify _value_ is initialized by reading the stream, or the iterator takes on the end-of-stream value if the stream is empty.

The description of how an istream_iterator object becomes an end-of-stream iterator is a) ambiguous and b) out of date WRT issue 468:

> `istream_iterator` reads (using `operator>>`) successive elements from the input stream for which it was constructed. After it is constructed, and every time `++` is used, the iterator reads and stores a value of `T`. If the end of stream is reached (`operator void*()` on the stream returns `false`), the iterator becomes equal to the end-of-stream iterator value. The constructor with no arguments `istream_iterator()` always constructs an end of stream input iterator object, which is the only legitimate iterator to be used for the end condition. The result of `operator*` on an end of stream is not defined. For any other iterator value a `const T&` is returned. The result of `operator->` on an end of stream is not defined. For any other iterator value a `const T*` is returned. It is impossible to store things into istream iterators. The main peculiarity of the istream iterators is the fact that `++` operators are not equality preserving, that is, `i == j` does not guarantee at all that `++i == ++j`. Every time `++` is used a new value is read.

`istream::operator void*()` returns null if `istream::fail()` is `true`, otherwise non-null. `istream::fail()` returns `true` if `failbit` or `badbit` is set in `rdstate()`. Reaching the end of stream doesn't necessarily imply that `failbit` or `badbit` is set (e.g., after extracting an `int` from `stringstream("123")` the stream object will have reached the end of stream but `fail()` is `false` and `operator void*()` will return a non-null value).

Also I would prefer to be explicit about calling `fail()` here (there is no `operator void*()` anymore.)

[ Summit: ]

> Moved from Ready to Open for the purposes of using this issue to address NB UK 287. Martin to handle.

[ 2009-07 Frankfurt: ]

> This improves the wording.

> Move to Ready.

Proposed resolution:

Change 24.6.1 [istream.iterator]/1:

> `istream_iterator` reads (using `operator>>`) successive elements from the input stream for which it was constructed. After it is constructed, and every time `++` is used, the iterator reads and stores a value of `T`. If the end of stream is reached the iterator fails to read and store a value of `T` (`operator void*() fail()` on the stream returns `false true`), the iterator becomes equal to the end-of-stream iterator value. The constructor with no arguments `istream_iterator()` always constructs an end of stream input iterator object, which is the only legitimate iterator to be used for the end condition. The result of `operator*` on an end of stream is not defined. For any other iterator value a `const T&` is returned. The result of `operator->` on an end of stream is not defined. For any other iterator value a `const T*` is returned. It is impossible to store things into istream iterators. The main peculiarity of the istream iterators is the fact that `++` operators are not equality preserving, that is, `i == j` does not guarantee at all that `++i == ++j`. Every time `++` is used a new value is read.

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

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

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

Proposed resolution:

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

Section: 20.3.3 [pairs] Status: Open Submitter: Doug Gregor Opened: 2008-03-14 Last modified: 2009-07-28

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. ]

Proposed resolution:

Rationale:

[ San Francisco: ]

> Solved by N2770.

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

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

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.

Proposed resolution:

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

Section: 20.7.12.1.3 [func.bind.bind] Status: Open Submitter: Stephan T. Lavavej Opened: 2008-02-08 Last modified: 2009-07-16

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

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

View all issues with Open 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.

Proposed resolution:

Add a new sentence to the end of paragraphs 2 and 4 of 20.7.12.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.

> ...

> -4- 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.12.1.3 [func.bind.bind] Status: Open Submitter: Howard Hinnant Opened: 2008-03-17 Last modified: 2009-07-16

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.12.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.

Proposed resolution:

Change 20.7 [function.objects] p2:

>     template<CopyConstructible MoveConstructible Fn, CopyConstructible MoveConstructible... Types>
>       unspecified bind(Fn&&, Types&&...);
>     template<Returnable R, CopyConstructible MoveConstructible Fn, CopyConstructible MoveConstructible... Types>
>       unspecified bind(Fn&&, Types&&...);

Change 20.7.12.1.3 [func.bind.bind]:

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

> > Requires: unspecified return type shall be `MoveConstructible`.

> > -1- Requires: `INVOKE(f, w1, w2, ..., wN)` (20.6.2) 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.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.

> > Throws: Nothing unless the constructor of `F` or of one of the types in the `BoundArgs...` pack expansion throws an exception.

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

> > Requires: unspecified return type shall be `MoveConstructible`.

> > -3- Requires: `INVOKE(f, w1, w2, ..., wN)` shall be a valid expression for some values w1, w2, ..., wN, where `N == sizeof...(bound_args)`.

> > -4- 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.

> > Throws: Nothing unless the constructor of `F` or of one of the types in the `BoundArgs...` pack expansion throws an exception.

> Let the values of bound arguments `v1, v2, ..., vN` and their corresponding types `V1, V2, ..., VN` depend on the type of the corresponding argument `ti` in `bound_args` in the call to `bind` and the cv-qualifiers cv of the call wrapper `g` as follows. Let `Ti` be an alias for the ith element of the pack expansion `decay<BoundArgs>::type...`, and let `ti` be an alias for the ith element in the function parameter pack expansion `bound_args...`:

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

### 819. rethrow_if_nested

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

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.

Proposed resolution:

### 822. Object with explicit copy constructor no longer `CopyConstructible`

Section: X [utility.arg.requirements] Status: Ready Submitter: James Kanze Opened: 2008-04-01 Last modified: 2009-07-26

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

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

View all issues with Ready status.

Discussion:

I just noticed that the following program is legal in C++03, but is forbidden in the current draft:

>     #include <vector>
>     #include <iostream>

>     class Toto
>     {
>     public:
>         Toto() {}
>         explicit Toto( Toto const& ) {}
>     } ;

>     int
>     main()
>     {
>         std::vector< Toto > v( 10 ) ;
>         return 0 ;
>     }

Is this change intentional? (And if so, what is the justification? I wouldn't call such code good, but I don't see any reason to break it unless we get something else in return.)

[ San Francisco: ]

> The subgroup that looked at this felt this was a good change, but it may already be handled by incoming concepts (we're not sure).

[ Post Summit: ]

> Alisdair: Proposed resolution kinda funky as these tables no longer exist. Move from direct init to copy init. Clarify with Doug, recommends NAD.

> Walter: Suggest NAD via introduction of concepts.

> Recommend close as NAD.

[ 2009-07 Frankfurt: ]

> Need to look at again without concepts.

[ 2009-07 Frankfurt: ]

> Move to Ready with original proposed resolution.

> [Howard: Original proposed resolution restored.]

Proposed resolution:

In X [utility.arg.requirements] change Table 33: `MoveConstructible` requirements [moveconstructible]:

> expression | post-condition
> --- | ---
> `T t(rv) = rv` | `t` is equivalent to the value of `rv` before the construction
> ...

In X [utility.arg.requirements] change Table 34: `CopyConstructible` requirements [copyconstructible]:

> expression | post-condition
> --- | ---
> `T t(u) = u` | the value of `u` is unchanged and is equivalent to `t`
> ...

### 823. `identity<void>` seems broken

Section: 20.3.2 [forward] Status: Open Submitter: Walter Brown Opened: 2008-04-09 Last modified: 2009-07-30

View other active issues in [forward].

View all other issues in [forward].

View all issues with Open status.

Discussion:

N2588 seems to have added an `operator()` member function to the `identity<>` helper in 20.3.2 [forward]. I believe this change makes it no longer possible to instantiate `identity<void>`, as it would require forming a reference-to-`void` type as this `operator()`'s parameter type.

Suggested resolution: Specialize `identity<void>` so as not to require the member function's presence.

[ Sophia Antipolis: ]

> Jens: suggests to add a requires clause to avoid specializing on `void`.

> Alisdair: also consider cv-qualified `void`.

> Alberto provided proposed wording.

[ 2009-07-30 Daniel reopens: ]

> This issue became closed, because the `ReferentType` requirement fixed the problem - this is no longer the case. In retrospective it seems to be that the root of current issues around `std::identity` (823, 700, 939) is that it was standardized as something very different (an unconditional type mapper) than traditional usage indicated (a function object that should derive from `std::unary_function)`, as the SGI definition does. This issue could be solved, if `std::identity` is removed (one proposal of 939), but until this has been decided, this issue should remain open. An alternative for removing it, would be, to do the following:

> 1. Let `identity` stay as a real function object, which would now properly derive from `unary_function`:

>    >     template <class T> struct identity : unary_function<T, T> {
>    >       const T& operator()(const T&) const;
>    >     };

> 2. Invent (if needed) a generic type wrapper (corresponding to concept `IdentityOf`), e.g. `identity_of`, and move it's prototype description back to 20.3.2 [forward]:

>    >     template <class T> struct identity_of {
>    >       typedef T type;
>    >     };

>    and adapt the `std::forward` signature to use `identity_of` instead of `identity`.

Proposed resolution:

Change definition of `identity` in 20.3.2 [forward], paragraph 2, to:

>     template <class T>  struct identity {
>         typedef T type;

>         requires ReferentType<T>
>           const T& operator()(const T& x) const;
>       };

...

>       requires ReferentType<T>
>         const T& operator()(const T& x) const;

Rationale:

The point here is to able to write `T&` given `T` and `ReferentType` is precisely the concept that guarantees so, according to N2677 (Foundational concepts). Because of this, it seems preferable than an explicit check for `cv void` using `SameType/remove_cv` as it was suggested in Sophia. In particular, Daniel remarked that there may be types other than `cv void` which aren't referent types (`int[]`, perhaps?).

### 827. `constexpr shared_ptr::shared_ptr()?`

Section: 20.8.10.2.1 [util.smartptr.shared.const] Status: Open Submitter: Peter Dimov Opened: 2008-04-11 Last modified: 2009-07-21

View other active issues in [util.smartptr.shared.const].

View all other issues in [util.smartptr.shared.const].

View all issues with Open status.

Discussion:

Would anyone object to making the default constructor of `shared_ptr` (and `weak_ptr` and `enable_shared_from_this) constexpr`? This would enable static initialization for `shared_ptr` variables, eliminating another unfair advantage of raw pointers.

[ San Francisco: ]

> It's not clear to us that you can initialize a pointer with the literal 0 in a constant expression. We need to ask CWG to make sure this works. Bjarne has been appointed to do this.

> Core got back to us and assured as that `nullptr` would do the job nicely here.

[ 2009-05-01 Alisdair adds: ]

> I don't believe that constexpr will buy anything in this case. `shared_ptr/weak_ptr/enable_shared_from_this` cannot be literal types as they have a non-trivial copy constructor. As they do not produce literal types, then the constexpr default constructor will not guarantee constant initialization, and so not buy the hoped for optimization.

> I recommend referring this back to Core to see if we can get static initialization for types with constexpr constructors, even if they are not literal types. Otherwise this should be closed as NAD.

[ 2009-05-26 Daniel adds: ]

> If Alisdair's 2009-05-01 comment is correct, wouldn't that also make `constexpr mutex()` useless, because this class has a non-trivial destructor? (828)

[ 2009-07-21 Alisdair adds: ]

> The feedback from core is that this and similar uses of constexpr constructors to force static initialization should be supported. If there are any problems with this in the working draught, we should file core issues.

> Recommend we declare the default constructor constexpr as the issue suggests (proposed wording added).

Proposed resolution:

Change 20.8.10.2 [util.smartptr.shared] and 20.8.10.2.1 [util.smartptr.shared.const]:

>     consexpr shared_ptr();

Change 20.8.10.3 [util.smartptr.weak] and 20.8.10.3.1 [util.smartptr.weak.const]:

>     consexpr weak_ptr();

Change 20.8.10.5 [util.smartptr.enab] (2 places):

>     consexpr enable_shared_from_this();

### 828. Static initialization for `std::mutex`?

Section: 30.4.1.1 [thread.mutex.class] Status: Review Submitter: Peter Dimov Opened: 2008-04-18 Last modified: 2009-05-30

View other active issues in [thread.mutex.class].

View all other issues in [thread.mutex.class].

View all issues with Review status.

Discussion:

[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.]

Currently `std::mutex` doesn't support static initialization. This is a regression with respect to `pthread_mutex_t`, which does. I believe that we should strive to eliminate such regressions in expressive power where possible, both to ease migration and to not provide incentives to (or force) people to forego the C++ primitives in favor of pthreads.

[ Sophia Antipolis: ]

> We believe this is implementable on POSIX, because the initializer-list feature and the constexpr feature make this work. Double-check core language about static initialization for this case. Ask core for a core issue about order of destruction of statically-initialized objects wrt. dynamically-initialized objects (should come afterwards). Check non-POSIX systems for implementability.

> If ubiquitous implementability cannot be assured, plan B is to introduce another constructor, make this constexpr, which is conditionally-supported. To avoid ambiguities, this new constructor needs to have an additional parameter.

[ Post Summit: ]

> Jens: constant initialization seems to be ok core-language wise

> Consensus: Defer to threading experts, in particular a Microsoft platform expert.

> Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams, Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker, Peter Dimov to alert them of this issue.

> Lawrence: What about header file shared with C? The initialization syntax is different in C and C++.

> Recommend Keep in Review

[ Batavia (2009-05): ]

> Keep in Review status pending feedback from members of the Concurrency subgroup.

[ See related comments from Alisdiar and Daniel in 827. ]

Proposed resolution:

Change 30.4.1.1 [thread.mutex.class]:

>     class mutex {
>     public:
>       constexpr mutex();
>       ...

### 834. Unique_ptr::pointer requirements underspecified

Section: 20.8.9.2 [unique.ptr.single] Status: Ready Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2009-07-16

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

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

View all issues with Ready 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.

Proposed resolution:

Add the following sentence just at the end of the newly proposed 20.8.9.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: Review Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-27

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with Review 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. ]

Proposed resolution:

[ based on N2914 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: Review Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-16

View other active issues in [locale.money.get.virtuals].

View all other issues in [locale.money.get.virtuals].

View all issues with Review 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.

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`, ...

### 838. can an end-of-stream iterator become a non-end-of-stream one?

Section: 24.6.1 [istream.iterator] Status: Ready Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-16

View other active issues in [istream.iterator].

View all other issues in [istream.iterator].

View all issues with Ready status.

Discussion:

From message c++std-lib-20003...

The description of `istream_iterator` in 24.6.1 [istream.iterator], p1 specifies that objects of the class become the end-of-stream (EOS) iterators under the following condition (see also issue 788 another problem with this paragraph):

> If the end of stream is reached (`operator void*()` on the stream returns `false`), the iterator becomes equal to the end-of-stream iterator value.

One possible implementation approach that has been used in practice is for the iterator to set its `in_stream` pointer to 0 when it reaches the end of the stream, just like the default ctor does on initialization. The problem with this approach is that the Effects clause for `operator++()` says the iterator unconditionally extracts the next value from the stream by evaluating `*in_stream >> value`, without checking for `(in_stream == 0)`.

Conformance to the requirement outlined in the Effects clause can easily be verified in programs by setting `eofbit` or `failbit` in `exceptions()` of the associated stream and attempting to iterate past the end of the stream: each past-the-end access should trigger an exception. This suggests that some other, more elaborate technique might be intended.

Another approach, one that allows `operator++()` to attempt to extract the value even for EOS iterators (just as long as `in_stream` is non-0) is for the iterator to maintain a flag indicating whether it has reached the end of the stream. This technique would satisfy the presumed requirement implied by the Effects clause mentioned above, but it isn't supported by the exposition-only members of the class (no such flag is shown). This approach is also found in existing practice.

The inconsistency between existing implementations raises the question of whether the intent of the specification is that a non-EOS iterator that has reached the EOS become a non-EOS one again after the stream's `eofbit` flag has been cleared? That is, are the assertions in the program below expected to pass?

>        sstream strm ("1 ");
>        istream_iterator eos;
>        istream_iterator it (strm);
>        int i;
>        i = *it++
>        assert (it == eos);
>        strm.clear ();
>        strm << "2 3 ";
>        assert (it != eos);
>        i = *++it;
>        assert (3 == i);

Or is it intended that once an iterator becomes EOS it stays EOS until the end of its lifetime?

[ San Francisco: ]

> We like the direction of the proposed resolution. We're not sure about the wording, and we need more time to reflect on it,

> Move to Open. Detlef to rewrite the proposed resolution in such a way that no reference is made to exposition only members of `istream_iterator`.

[ 2009-07 Frankfurt: ]

> Move to Ready.

Proposed resolution:

The discussion of this issue on the reflector suggests that the intent of the standard is for an `istreambuf_iterator` that has reached the EOS to remain in the EOS state until the end of its lifetime. Implementations that permit EOS iterators to return to a non-EOS state may only do so as an extension, and only as a result of calling `istream_iterator` member functions on EOS iterators whose behavior is in this case undefined.

To this end we propose to change 24.6.1 [istream.iterator], p1, as follows:

> The result of operator-> on an end-of-stream is not defined. For any other iterator value a `const T*` is returned. Invoking `operator++()` on an end-of-stream iterator is undefined. It is impossible to store things into istream iterators...

Add pre/postconditions to the member function descriptions of `istream_iterator` like so:

>     istream_iterator();

> Effects: Constructs the end-of-stream iterator.
> Postcondition: `in_stream == 0`.

>     istream_iterator(istream_type &s);

> Effects: Initializes `in_stream` with &s. value may be initialized during construction or the first time it is referenced.
> Postcondition: `in_stream == &s`.

>     istream_iterator(const istream_iterator &x);

> Effects: Constructs a copy of `x`.
> Postcondition: `in_stream == x.in_stream`.

>     istream_iterator& operator++();

> Requires: `in_stream != 0`.
> Effects: `*in_stream >> value`.

>     istream_iterator& operator++(int);

> Requires: `in_stream != 0`.
> Effects:

> >     istream_iterator tmp (*this);
> >     *in_stream >> value;
> >     return tmp;

### 847. string exception safety guarantees

Section: 21.4.1 [string.require] Status: Ready Submitter: Hervé Brönnimann Opened: 2008-06-05 Last modified: 2009-07-16

View all other issues in [string.require].

View all issues with Ready status.

Discussion:

In March, on comp.lang.c++.moderated, I asked what were the string exception safety guarantees are, because I cannot see *any* in the working paper, and any implementation I know offers the strong exception safety guarantee (string unchanged if a member throws exception). The closest the current draft comes to offering any guarantees is 21.4 [basic.string], para 3:

> The class template `basic_string` conforms to the requirements for a Sequence Container (23.1.1), for a Reversible Container (23.1), and for an Allocator-aware container (91). The iterators supported by `basic_string` are random access iterators (24.1.5).

However, the chapter 23 only says, on the topic of exceptions: 23.2 [container.requirements], para 10:

> Unless otherwise specified (see 23.2.2.3 and 23.2.6.4) all container types defined in this clause meet the following additional requirements:

> - if an exception is thrown by...

I take it as saying that this paragraph has *no* implication on `std::basic_string`, as `basic_string` isn't defined in Clause 23 and this paragraph does not define a *requirement* of Sequence nor Reversible Container, just of the models defined in Clause 23. In addition, LWG Issue 718 proposes to remove 23.2 [container.requirements], para 3.

Finally, the fact that no operation on Traits should throw exceptions has no bearing, except to suggest (since the only other throws should be allocation, `out_of_range`, or `length_error`) that the strong exception guarantee can be achieved.

The reaction in that group by Niels Dekker, Martin Sebor, and Bo Persson, was all that this would be worth an LWG issue.

A related issue is that `erase()` does not throw. This should be stated somewhere (and again, I don't think that the 23.2 [container.requirements], para 1 applies here).

[ San Francisco: ]

> Implementors will study this to confirm that it is actually possible.

[ Daniel adds 2009-02-14: ]

> The proposed resolution of paper N2815 interacts with this issue (the paper does not refer to this issue).

[ 2009-07 Frankfurt: ]

> Move to Ready.

Proposed resolution:

Add a blanket statement in 21.4.1 [string.require]:

> - if any member function or operator of `basic_string<charT, traits, Allocator>` throws, that function or operator has no effect.

> - no `erase()` or `pop_back()` function throws.

As far as I can tell, this is achieved by any implementation. If I made a mistake and it is not possible to offer this guarantee, then either state all the functions for which this is possible (certainly at least `operator+=`, `append`, `assign`, and `insert`), or add paragraphs to Effects clauses wherever appropriate.

### 851. simplified array construction

Section: 23.3.1 [array] Status: Open Submitter: Benjamin Kosnik Opened: 2008-06-05 Last modified: 2009-07-25

View other active issues in [array].

View all other issues in [array].

View all issues with Open status.

Discussion:

This is an issue that came up on the libstdc++ list, where a discrepancy between "C" arrays and C++0x's `std::array` was pointed out.

In "C," this array usage is possible:

>     int ar[] = {1, 4, 6};

But for C++,

>     std::array<int> a = { 1, 4, 6 }; // error

Instead, the second parameter of the `array` template must be explicit, like so:

>     std::array<int, 3> a = { 1, 4, 6 };

Doug Gregor proposes the following solution, that assumes generalized initializer lists.

>     template<typename T, typename... Args>
>     inline array<T, sizeof...(Args)>
>     make_array(Args&&... args)
>     { return { std::forward<Args>(args)... };  }

Then, the way to build an `array` from a list of unknown size is:

>     auto a = make_array<T>(1, 4, 6);

[ San Francisco: ]

> Benjamin: Move to Ready?

> Bjarne: I'm not convinced this is useful enough to add, so I'd like us to have time to reflect on it.

> Alisdair: the constraints are wrong, they should be

> >     template<ValueType T, ValueType... Args>
> >     requires Convertible<Args, T>...
> >     array<T, sizeof...(Args)> make_array(Args&&... args);

> Alidair: this would be useful if we had a constexpr version.

> Bjarne: this is probably useful for arrays with a small number of elements, but it's not clearly useful otherwise.

> Consensus is to move to Open.

[ 2009-06-07 Daniel adds: ]

> I suggest a fix and a simplification of the current proposal: Recent prototyping by Howard showed, that a fix is required because narrowing conversion 8.5.4 [dcl.init.list]/6 b.3 would severely limit the possible distribution of argument types, e.g. the expression `make_array<double>(1, 2.0)` is ill-formed, because the narrowing happens inside the function body where no constant expressions exist anymore. Furthermore given e.g.

> >     int f();
> >     double g();

> we probably want to support

> >     make_array<double>(f(), g());

> as well. To make this feasible, the currently suggested expansion

> >     { std::forward<Args>(args)... }

> needs to be replaced by

> >     { static_cast<T>(std::forward<Args>(args))... }

> which is safe, because we already ensure convertibility via the element-wise `Convertible<Args, T>` requirement. Some other fixes are necessary: The `ValueType` requirement for the function parameters is invalid, because all lvalue arguments will deduce to an lvalue-reference, thereby no longer satisfying this requirement.

> The suggested simplification is to provide a default-computed effective type for the result array based on common_type and decay, in unconstrained form:

> >     template<typename... Args>
> >     array<typename decay<typename common_type<Args...>::type>::type,
> >     sizeof...(Args)>
> >     make_array(Args&&... args);

> The approach used below is similar to that of `make_pair` and `make_tuple` using a symbol `C` to represent the decayed common type [Note: Special handling of `reference_wrapper` types is intentionally not provided, because our target has so satisfy `ValueType`, thus under the revised proposal only an all-`reference_wrapper`-arguments would be well-formed and an array of `reference_wrapper` will be constructed]. I do currently not suggest to add new concepts reflecting `decay` and `common_type`, but an implementor will need something like this to succeed. Note that we use a similar fuzziness for `make_pair` and `make_tuple` currently. This fuzziness is not related to the currently missing `Constructible<Vi, Ti&&>` requirement for those functions. The following proposal fixes that miss for `make_array`. If the corresponding `C` type deduction is explicitly wanted for standardization, here the implementation

> >     auto concept DC<typename... T> {
> >       typename type = typename decay<typename common_type<T...>::type>::type;
> >     }

> where `C` is identical to `DC<Args...>::type` in the proposed resolution below.

> I intentionally added no further type relation between type and the concept template parameters, but instead added this requirement below to make the specification as transparent as possible. As written this concept is satisfied, if the corresponding associated type exists.

> Suggested Resolution:

> 1. Add to the array synopsis in 23.3 [sequences]:

>    >     template<ReferentType... Args>
>    >     requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
>    >     array<C, sizeof...(Args)>
>    >     make_array(Args&&... args);

> 2. Append after 23.3.1.7 [array.tuple] Tuple interface to class template array the following new section:

>    > 23.4.1.7 Array creation functions [array.creation]

>    >     template<ReferentType... Args>
>    >     requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
>    >     array<C, sizeof...(Args)>
>    >     make_array(Args&&... args);

>    > > Let `C` be `decay<common_type<Args...>::type>::type`.

>    > > Returns: an `array<C, sizeof...(Args)>` initialized with `{ static_cast<C>(std::forward<Args>(args))... }`.

[ 2009-07 Frankfurt: ]

> The proposed resolution uses concepts.

> Daniel to rewrite the proposed resolution.

> Leave Open.

[ 2009-07-25 Daniel provides rewritten proposed resolution. ]

Proposed resolution:

1. Add to the array synopsis in 23.3 [sequences]:

   >     template<class... Args>
   >       array<CT, sizeof...(Args)>
   >       make_array(Args&&... args);

2. Append after 23.3.1.7 [array.tuple] "Tuple interface to class template array" the following new section:

   > XX.X.X.X Array creation functions [array.creation]

   >     template<class... Args>
   >     array<CT, sizeof...(Args)>
   >     make_array(Args&&... args)

   > > Let CT be `decay<common_type<Args...>::type>::type`.

   > > Returns: An `array<CT, sizeof...(Args)>` initialized with `{ static_cast<CT>(std::forward<Args>(args))... }`.

   > > [Example:

   > > >     int i = 0; int& ri = i;
   > > >     make_array(42u, i, 2.78, ri);

   > > returns an array of type

   > > >     array<double, 4>

   > > —end example]

### 854. `default_delete` converting constructor underspecified

Section: 20.8.9.1.1 [unique.ptr.dltr.dflt] Status: Review Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-07-26

View all issues with Review 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. ]

Proposed resolution:

Add after 20.8.9.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*`.

### 857. `condition_variable::time_wait` return `bool` error prone

Section: 30.5.1 [thread.condition.condvar] Status: Ready Submitter: Beman Dawes Opened: 2008-06-13 Last modified: 2009-07-16

View other active issues in [thread.condition.condvar].

View all other issues in [thread.condition.condvar].

View all issues with Ready status.

Discussion:

The meaning of the `bool` returned by `condition_variable::timed_wait` is so obscure that even the class' designer can't deduce it correctly. Several people have independently stumbled on this issue.

It might be simpler to change the return type to a scoped enum:

>     enum class timeout { not_reached, reached };

That's the same cost as returning a `bool`, but not subject to mistakes. Your example below would be:

>     if (cv.wait_until(lk, time_limit) == timeout::reached )
>       throw time_out();

[ Beman to supply exact wording. ]

[ San Francisco: ]

> There is concern that the enumeration names are just as confusing, if not more so, as the bool. You might have awoken because of a signal or a spurious wakeup, for example.

> Group feels that this is a defect that needs fixing.

> Group prefers returning an enum over a void return.

> Howard to provide wording.

[ 2009-06-14 Beman provided wording. ]

[ 2009-07 Frankfurt: ]

> Move to Ready.

Proposed resolution:

Change Condition variables 30.5 [thread.condition], Header condition_variable synopsis, as indicated:

>     namespace std {
>       class condition_variable;
>       class condition_variable_any;

>       enum class cv_status { no_timeout, timeout };
>     }

Change Class condition_variable 30.5.1 [thread.condition.condvar] as indicated:

>     class condition_variable {
>     public:
>       ...
>       template <class Clock, class Duration>
>         bool cv_status wait_until(unique_lock<mutex>& lock,
>                         const chrono::time_point<Clock, Duration>& abs_time);
>       template <class Clock, class Duration, class Predicate>
>         bool wait_until(unique_lock<mutex>& lock,
>                         const chrono::time_point<Clock, Duration>& abs_time,
>                         Predicate pred);

>       template <class Rep, class Period>
>         bool cv_status wait_for(unique_lock<mutex>& lock,
>                       const chrono::duration<Rep, Period>& rel_time);
>       template <class Rep, class Period, class Predicate>
>         bool wait_for(unique_lock<mutex>& lock,
>                       const chrono::duration<Rep, Period>& rel_time,
>                       Predicate pred);
>       ...
>     };

>     ...

>     template <class Clock, class Duration>
>       bool cv_status wait_until(unique_lock<mutex>& lock,
>                       const chrono::time_point<Clock, Duration>& abs_time);

> > -15- Precondition: `lock` is locked by the calling thread, and either

> > - no other thread is waiting on this `condition_variable` object or
> > - `lock.mutex()` returns the same value for each of the `lock` arguments supplied by all concurrently waiting threads (via `wait`, `wait_for` or `wait_until`.).

> > -16- Effects:

> > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > - When unblocked, calls `lock.lock()` (possibly blocking on the lock) and returns.
> > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the current time exceeding `abs_time` if `Clock::now() >= abs_time`, or spuriously.
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

> > -17- Postcondition: `lock` is locked by the calling thread.

> > -18- Returns: `Clock::now() < abs_time` `cv_status::timeout` if the function unblocked because `abs_time` was reached, otherwise `cv_status::no_timeout`.

> > -19- Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> > -20- Error conditions:

> > - `operation_not_permitted` — if the thread does not own the lock.
> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

>     template <class Rep, class Period>
>       bool cv_status wait_for(unique_lock<mutex>& lock,
>                     const chrono::duration<Rep, Period>& rel_time);

> > -21- Effects Returns:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time)

> > -22- Returns: `false` if the call is returning because the time duration specified by `rel_time` has elapsed, otherwise `true`.

> > [ This part of the wording may conflict with 859 in detail, but does not do so in spirit. If both issues are accepted, there is a logical merge. ]

>     template <class Clock, class Duration, class Predicate>
>       bool wait_until(unique_lock<mutex>& lock,
>                       const chrono::time_point<Clock, Duration>& abs_time,
>                       Predicate pred);

> > -23- Effects:

> > >     while (!pred())
> > >       if (!wait_until(lock, abs_time) == cv_status::timeout)
> > >         return pred();
> > >     return true;

> > -24- Returns: `pred()`.

> > -25- [Note: The returned value indicates whether the predicate evaluates to `true` regardless of whether the timeout was triggered. — end note].

Change Class condition_variable_any 30.5.2 [thread.condition.condvarany] as indicated:

>     class condition_variable_any {
>     public:
>       ...
>       template <class Lock, class Clock, class Duration>
>         bool cv_status wait_until(Lock& lock,
>                         const chrono::time_point<Clock, Duration>& abs_time);
>       template <class Lock, class Clock, class Duration, class Predicate>
>         bool wait_until(Lock& lock,
>                         const chrono::time_point<Clock, Duration>& abs_time,
>                         Predicate pred);

>       template <class Lock, class Rep, class Period>
>         bool cv_status wait_for(Lock& lock,
>                       const chrono::duration<Rep, Period>& rel_time);
>       template <class Lock, class Rep, class Period, class Predicate>
>         bool wait_for(Lock& lock,
>                       const chrono::duration<Rep, Period>& rel_time,
>                       Predicate pred);
>       ...
>     };

>     ...

>     template <class Lock, class Clock, class Duration>
>       bool cv_status wait_until(Lock& lock,
>                       const chrono::time_point<Clock, Duration>& abs_time);

> > -13- Effects:

> > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > - When unblocked, calls `lock.lock()` (possibly blocking on the lock) and returns.
> > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the current time exceeding `abs_time` if `Clock::now() >= abs_time`, or spuriously.
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

> > -14- Postcondition: `lock` is locked by the calling thread.

> > -15- Returns: `Clock::now() < abs_time` `cv_status::timeout` if the function unblocked because `abs_time` was reached, otherwise `cv_status::no_timeout`.

> > -16- Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> > -17- Error conditions:

> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

>     template <class Lock, class Rep, class Period>
>       bool cv_status wait_for(Lock& lock,
>                     const chrono::duration<Rep, Period>& rel_time);

> > -18- Effects Returns:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time)

> > -19- Returns: `false` if the call is returning because the time duration specified by `rel_time` has elapsed, otherwise `true`.

> > [ This part of the wording may conflict with 859 in detail, but does not do so in spirit. If both issues are accepted, there is a logical merge. ]

>     template <class Lock, class Clock, class Duration, class Predicate>
>       bool wait_until(Lock& lock,
>                       const chrono::time_point<Clock, Duration>& rel_time abs_time,
>                       Predicate pred);

> > -20- Effects:

> > >     while (!pred())
> > >       if (!wait_until(lock, abs_time) == cv_status::timeout)
> > >         return pred();
> > >     return true;

> > -21- Returns: `pred()`.

> > -22- [Note: The returned value indicates whether the predicate evaluates to `true` regardless of whether the timeout was triggered. — end note].

### 859. Monotonic Clock is Conditionally Supported?

Section: 30.5 [thread.condition] Status: Ready Submitter: Pete Becker Opened: 2008-06-23 Last modified: 2009-07-21

View all issues with Ready status.

Discussion:

Related to 958, 959.

N2661 says that there is a class named `monotonic_clock`. It also says that this name may be a synonym for `system_clock`, and that it's conditionally supported. So the actual requirement is that it can be monotonic or not, and you can tell by looking at `is_monotonic`, or it might not exist at all (since it's conditionally supported). Okay, maybe too much flexibility, but so be it.

A problem comes up in the threading specification, where several variants of `wait_for` explicitly use `monotonic_clock::now()`. What is the meaning of an effects clause that says

>     wait_until(lock, chrono::monotonic_clock::now() + rel_time)

when `monotonic_clock` is not required to exist?

[ San Francisco: ]

> Nick: maybe instead of saying that chrono::monotonic_clock is conditionally supported, we could say that it's always there, but not necessarily supported..

> Beman: I'd prefer a typedef that identifies the best clock to use for wait_for locks.

> Tom: combine the two concepts; create a duration clock type, but keep the is_monotonic test.

> Howard: if we create a duration_clock type, is it a typedef or an entirely true type?

> There was broad preference for a typedef.

> Move to Open. Howard to provide wording to add a typedef for duration_clock and to replace all uses of monotonic_clock in function calls and signatures with duration_clock.

[ Howard notes post-San Francisco: ]

> After further thought I do not believe that creating a `duration_clock typedef` is the best way to proceed. An implementation may not need to use a `time_point` to implement the `wait_for` functions.

> For example, on POSIX systems `sleep_for` can be implemented in terms of `nanosleep` which takes only a duration in terms of nanoseconds. The current working paper does not describe `sleep_for` in terms of `sleep_until`. And paragraph 2 of 30.2.4 [thread.req.timing] has the words strongly encouraging implementations to use monotonic clocks for `sleep_for`:

> > 2 The member functions whose names end in `_for` take an argument that specifies a relative time. Implementations should use a monotonic clock to measure time for these functions.

> I believe the approach taken in describing the effects of `sleep_for` and `try_lock_for` is also appropriate for `wait_for`. I.e. these are not described in terms of their `_until` variants.

[ 2009-07 Frankfurt: ]

> Beman will send some suggested wording changes to Howard.

> Move to Ready.

[ 2009-07-21 Beman added the requested wording changes to 962. ]

Proposed resolution:

Change 30.5.1 [thread.condition.condvar], p21-22:

>     template <class Rep, class Period>
>       bool wait_for(unique_lock<mutex>& lock,
>                     const chrono::duration<Rep, Period>& rel_time);

> > Precondition: `lock` is locked by the calling thread, and either

> > - no other thread is waiting on this `condition_variable` object or
> > - `lock.mutex()` returns the same value for each of the `lock` arguments supplied by all concurrently waiting threads (via `wait`, `wait_for` or `wait_until`).

> > 21 Effects:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time)

> > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > - When unblocked, calls `lock.lock()` (possibly blocking on the lock) and returns.
> > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the elapsed time `rel_time` passing (30.2.4 [thread.req.timing]), or spuriously.
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

> > Postcondition: `lock` is locked by the calling thread.

> > 22 Returns: `false` if the call is returning because the time duration specified by `rel_time` has elapsed, otherwise `true`.

> > [ This part of the wording may conflict with 857 in detail, but does not do so in spirit. If both issues are accepted, there is a logical merge. ]

> > Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> > Error conditions:

> > - `operation_not_permitted` -- if the thread does not own the lock.
> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

Change 30.5.1 [thread.condition.condvar], p26-p29:

>     template <class Rep, class Period, class Predicate>
>       bool wait_for(unique_lock<mutex>& lock,
>                     const chrono::duration<Rep, Period>& rel_time,
>                     Predicate pred);

> > Precondition: `lock` is locked by the calling thread, and either

> > - no other thread is waiting on this `condition_variable` object or
> > - `lock.mutex()` returns the same value for each of the `lock` arguments supplied by all concurrently waiting threads (via `wait`, `wait_for` or `wait_until`).

> > 26 Effects:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))

> > > - Executes a loop: Within the loop the function first evaluates `pred()` and exits the loop if the result of `pred()` is `true`.
> > > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > > - When unblocked, calls `lock.lock()` (possibly blocking on the lock).
> > > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the elapsed time `rel_time` passing (30.1.4 [thread.req.timing]), or spuriously.
> > > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.
> > > - The loop terminates when `pred()` returns `true` or when the time duration specified by `rel_time` has elapsed.

> > 27 [Note: There is no blocking if `pred()` is initially `true`, even if the timeout has already expired. -- end note]

> > Postcondition: `lock` is locked by the calling thread.

> > 28 Returns: `pred()`

> > 29 [Note: The returned value indicates whether the predicate evaluates to `true` regardless of whether the timeout was triggered. -- end note]

> > Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> > Error conditions:

> > - `operation_not_permitted` -- if the thread does not own the lock.
> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

Change 30.5.2 [thread.condition.condvarany], p18-19:

>     template <class Lock, class Rep, class Period>
>       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);

> > 18 Effects:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time)

> > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > - When unblocked, calls `lock.lock()` (possibly blocking on the lock) and returns.
> > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the elapsed time `rel_time` passing (30.2.4 [thread.req.timing]), or spuriously.
> > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.

> > Postcondition: `lock` is locked by the calling thread.

> > 19 Returns: `false` if the call is returning because the time duration specified by `rel_time` has elapsed, otherwise `true`.

> > Throws: `std::system_error` when the returned value, effects, or postcondition cannot be achieved.

> > Error conditions:

> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

Change 30.5.2 [thread.condition.condvarany], p23-p26:

>     template <class Lock, class Rep, class Period, class Predicate>
>       bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);

> > Precondition: `lock` is locked by the calling thread, and either

> > - no other thread is waiting on this `condition_variable` object or
> > - `lock.mutex()` returns the same value for each of the `lock` arguments supplied by all concurrently waiting threads (via `wait`, `wait_for` or `wait_until`).

> > 23 Effects:

> > >     wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))

> > > - Executes a loop: Within the loop the function first evaluates `pred()` and exits the loop if the result of `pred()` is `true`.
> > > - Atomically calls `lock.unlock()` and blocks on `*this`.
> > > - When unblocked, calls `lock.lock()` (possibly blocking on the lock).
> > > - The function will unblock when signaled by a call to `notify_one()`, a call to `notify_all()`, by the elapsed time `rel_time` passing (30.1.4 [thread.req.timing]), or spuriously.
> > > - If the function exits via an exception, `lock.unlock()` shall be called prior to exiting the function scope.
> > > - The loop terminates when `pred()` returns `true` or when the time duration specified by `rel_time` has elapsed.

> > 24 [Note: There is no blocking if `pred()` is initially `true`, even if the timeout has already expired. -- end note]

> > Postcondition: `lock` is locked by the calling thread.

> > 25 Returns: `pred()`

> > 26 [Note: The returned value indicates whether the predicate evaluates to `true` regardless of whether the timeout was triggered. -- end note]

> > Throws: `std::system_error` when the effects or postcondition cannot be achieved.

> > Error conditions:

> > - `operation_not_permitted` -- if the thread does not own the lock.
> > - equivalent error condition from `lock.lock()` or `lock.unlock()`.

### 860. Floating-Point State

Section: 26 [numerics] Status: Open Submitter: Lawrence Crowl Opened: 2008-06-23 Last modified: 2009-03-09

View all other issues in [numerics].

View all issues with Open 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.

Proposed resolution:

### 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-07-26

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. ]

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.4.6 [alg.fill], 25.4.7 [alg.generate] Status: Open Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-07-25

View all issues with Open 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.3 [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. ]

Proposed resolution:

1. Replace the current declaration of `fill_n` in 25 [algorithms]/2, header `<algorithm>` synopsis and in 25.4.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.4.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: Review Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2009-07-19

View other active issues in [containers].

View all other issues in [containers].

View all issues with Review 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 X [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.9.2.1 [unique.ptr.single.ctor] para 3 e 7

> > - 24.5.1.2.1 [reverse.iter.cons] para 1

> > - 24.5.2.2.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

Proposed resolution:

Change X [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-07-28

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. ]

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: Review Submitter: Daniel Krügler Opened: 2008-08-20 Last modified: 2009-07-30

View all issues with Review 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:

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 convertible to `ForwardIterator`'s value type. [..]

### 872. `move_iterator::operator[]` has wrong return type

Section: 24.5.2.2.12 [move.iter.op.index] Status: Open Submitter: Doug Gregor Opened: 2008-08-21 Last modified: 2009-07-28

View all issues with Open 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. ]

Proposed resolution:

In 24.5.2.1 [move.iterator] and 24.5.2.2.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.

### 876. `basic_string` access operations should give stronger guarantees

Section: 21.4 [basic.string] Status: Ready Submitter: Daniel Krügler Opened: 2008-08-22 Last modified: 2009-07-17

View all other issues in [basic.string].

View all issues with Ready status.

Discussion:

During the Sophia Antipolis meeting it was decided to split-off some parts of the n2647 ("Concurrency modifications for `basic_string`") proposal into a separate issue, because these weren't actually concurrency-related. The here proposed changes refer to the recent update document n2668 and attempt to take advantage of the stricter structural requirements.

Indeed there exists some leeway for more guarantees that would be very useful for programmers, especially if interaction with transactionary or exception-unaware C API code is important. This would also allow compilers to take advantage of more performance optimizations, because more functions can have throw() specifications. This proposal uses the form of "Throws: Nothing" clauses to reach the same effect, because there already exists a different issue in progress to clean-up the current existing "schizophrenia" of the standard in this regard.

Due to earlier support for copy-on-write, we find the following unnecessary limitations for C++0x:

1. Missing no-throw guarantees: `data()` and `c_str()` simply return a pointer to their guts, which is a non-failure operation. This should be spelled out. It is also noteworthy to mention that the same guarantees should also be given by the size query functions, because the combination of pointer to content and the length is typically needed during interaction with low-level API.
2. Missing complexity guarantees: `data()` and `c_str()` simply return a pointer to their guts, which is guaranteed O(1). This should be spelled out.
3. Missing reading access to the terminating character: Only the const overload of `operator[]` allows reading access to the terminator char. For more intuitive usage of strings, reading access to this position should be extended to the non-const case. In contrast to C++03 this reading access should now be homogeneously an lvalue access.

The proposed resolution is split into a main part (A) and a secondary part (B) (earlier called "Adjunct Adjunct Proposal"). (B) extends (A) by also making access to index position size() of the at() overloads a no-throw operation. This was separated, because this part is theoretically observable in specifically designed test programs.

[ San Francisco: ]

> We oppose part 1 of the issue but hope to address `size()` in issue 877.

> We do not support part B. 4 of the issue because of the breaking API change.

> We support part A. 2 of the issue.

> On support part A. 3 of the issue:

> > Pete's broader comment: now that we know that basic_string will be a block of contiguous memory, we should just rewrite its specification with that in mind. The expression of the specification will be simpler and probably more correct as a result.

[ 2009-07 Frankfurt ]

> Move proposed resolution A to Ready.

> [ Howard: Commented out part B. ]

Proposed resolution:

1. 1. In 21.4.4 [string.capacity], just after p. 1 add a new paragraph:

      > Throws: Nothing.

   2. In 21.4.5 [string.access] replace p. 1 by the following 4 paragraghs:

      > Requires: `pos ≤ size()`.

      > Returns: If `pos < size()`, returns `*(begin() + pos)`. Otherwise, returns a reference to a `charT()` that shall not be modified.

      > Throws: Nothing.

      > Complexity: Constant time.

   3. In 21.4.7.1 [string.accessors] replace the now common returns clause of `c_str()` and `data()` by the following three paragraphs:

      > Returns: A pointer `p` such that `p+i == &operator[](i)` for each `i` in `[0, size()]`.

      > Throws: Nothing.

      > Complexity: Constant time.

### 879. Atomic load const qualification

Section: 29 [atomics] Status: Open Submitter: Alexander Chemeris Opened: 2008-08-24 Last modified: 2009-07-17

View other active issues in [atomics].

View all other issues in [atomics].

View all issues with Open status.

Discussion:

The `atomic_address` type and `atomic<T*>` specialization provide atomic updates to pointers. However, the current specification requires that the types pointer be to non-const objects. This restriction is unnecessary and unintended.

[ Summit: ]

> Move to review. Lawrence will first check with Peter whether the current examples are sufficient, or whether they need to be expanded to include all cases.

[ 2009-07 Frankfurt ]

> Lawrence will handle all issues relating to atomics in a single paper.

> LWG will defer discussion on atomics until that paper appears.

> Move to Open.

Proposed resolution:

Add const qualification to the pointer values of the `atomic_address` and `atomic<T*>` specializations. E.g.

>     typedef struct atomic_address {
>        void store(const void*, memory_order = memory_order_seq_cst) volatile;
>        void* exchange( const void*, memory_order = memory_order_seq_cst) volatile;
>        bool compare_exchange( const void*&, const void*,
>                               memory_order, memory_order) volatile;
>        bool compare_exchange( const void*&, const void*,
>                               memory_order = memory_order_seq_cst ) volatile;
>        void* operator=(const void*) volatile;
>     } atomic_address;

>     void atomic_store(volatile atomic_address*, const void*);
>     void atomic_store_explicit(volatile atomic_address*, const void*,
>                               memory_order);
>     void* atomic_exchange(volatile atomic_address*, const void*);
>     void* atomic_exchange_explicit(volatile atomic_address*, const void*,
>                                   memory_order);
>     bool atomic_compare_exchange(volatile atomic_address*,
>                                 const void**, const void*);
>     bool atomic_compare_exchange_explicit(volatile atomic_address*,
>                                          const void**, const void*,
>                                          memory_order, memory_order);

### 880. Missing atomic exchange parameter

Section: 29 [atomics] Status: Open Submitter: Lawrence Crowl Opened: 2008-08-24 Last modified: 2009-07-17

View other active issues in [atomics].

View all other issues in [atomics].

View all issues with Open status.

Duplicate of: 942

Discussion:

The `atomic_exchange` and `atomic_exchange_explicit` functions seem to be inconsistently missing parameters.

[ Post Summit: ]

> Lawrence: Need to write up a list for Pete with details.

> Detlef: Should not be New, we already talked about in Concurrency group.

> Recommend Open.

[ 2009-07 Frankfurt ]

> Lawrence will handle all issues relating to atomics in a single paper.

> LWG will defer discussion on atomics until that paper appears.

> Move to Open.

Proposed resolution:

Add the appropriate parameters. For example,

>     bool atomic_exchange(volatile atomic_bool*, bool);
>     bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);

### 881. shared_ptr conversion issue

Section: 20.8.10.2.1 [util.smartptr.shared.const] Status: Ready Submitter: Peter Dimov Opened: 2008-08-30 Last modified: 2009-07-17

View other active issues in [util.smartptr.shared.const].

View all other issues in [util.smartptr.shared.const].

View all issues with Ready status.

Discussion:

We've changed `shared_ptr<Y>` to not convert to `shared_ptr<T>` when `Y*` doesn't convert to `T*` by resolving issue 687. This only fixed the converting copy constructor though. N2351 later added move support, and the converting move constructor is not constrained.

[ San Francisco: ]

> We might be able to move this to NAD, Editorial once shared_ptr is conceptualized, but we want to revisit this issue to make sure.

[ 2009-07 Frankfurt ]

> Moved to Ready.

> This issue now represents the favored format for specifying constrained templates.

Proposed resolution:

We need to change the Requires clause of the move constructor:

>     shared_ptr(shared_ptr&& r);
>     template<class Y> shared_ptr(shared_ptr<Y>&& r);

> > Requires Remarks: For the second constructor `Y*` shall be convertible to `T*`. The second constructor shall not participate in overload resolution unless `Y*` is convertible to `T*`.

in order to actually make the example in 687 compile (it now resolves to the move constructor).

### 883. swap circular definition

Section: 23 [containers] Status: Ready Submitter: Alisdair Meredith Opened: 2008-09-10 Last modified: 2009-07-17

View other active issues in [containers].

View all other issues in [containers].

View all issues with Ready status.

Discussion:

Note in particular that Table 90 "Container Requirements" 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.

[ San Francisco: ]

> Robert to propose a resolution along the lines of "Postcondition: "a = b, b = a" This will be a little tricky for the hash containers, since they don't have `operator==`.

[ Post Summit Anthony Williams provided proposed wording. ]

[ 2009-07 Frankfurt ]

> Moved to Ready with minor edits (which have been made).

Proposed resolution:

In table 80 in section 23.2.1 [container.requirements.general], replace the postcondition of `a.swap(b)` with the following:

> Table 80 -- Container requirements
> Expression | Return type | Operational semantics | Assertion/note pre-/post-conidtion | Complexity
> --- | --- | --- | --- | ---
> ... | ... | ... | ... | ...
> `a.swap(b);` | `void` |  | `swap(a,b)` Exchange the contents of `a` and `b`. | (Note A)

Remove the reference to swap from the paragraph following the table.

> Notes: the algorithms `swap()`, `equal()` and `lexicographical_compare()` are defined in Clause 25. ...

### 885. pair assignment

Section: 20.3.3 [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:

### 886. tuple construction

Section: 20.5.2.1 [tuple.cnstr] Status: Ready Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2009-07-17

View other active issues in [tuple.cnstr].

View all other issues in [tuple.cnstr].

View all issues with Ready status.

Discussion:

20.5.2.1 [tuple.cnstr]:

> Effects: Default initializes each element.

Could be clarified to state each "non-trivial" element. Otherwise we have a conflict with Core deinfition of default initialization - trivial types do not get initialized (rather than initialization having no effect)

I'm going to punt on this one, because it's not an issue that's related to concepts. I suggest bringing it to Howard's attention on the reflector.

[ San Francisco: ]

> Text in draft doesn't mean anything, changing to "non-trivial" makes it meaningful.

> We prefer "value initializes". Present implementations use value-initialization. Users who don't want value initialization have alternatives.

> Request resolution text from Alisdair.

> This issue relates to Issue 868 default construction and value-initialization.

[ 2009-05-04 Alisdair provided wording and adds: ]

> Note: This IS a change of semantic from TR1, although one the room agreed with during the discussion. To preserve TR1 semantics, this would have been worded:

> >     requires DefaultConstructible<Types>... tuple();

> > > -2- Effects: Default-initializes each non-trivial element.

[ 2009-07 Frankfurt ]

> Move to Ready.

Proposed resolution:

Change p2 in Construction 20.5.2.1 [tuple.cnstr]:

>     requires DefaultConstructible<Types>... tuple();

> > -2- Effects: Default Value-initializes each element.

### 887. issue with condition::wait_...

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-07-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;
> >         typename Clock::time_point  c_entry = Clock::now();
> >         system_clock::time_point    s_entry = system_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.

Proposed resolution:

### 889. thread::id comparisons

Section: 30.3.1.1 [thread.thread.id] Status: Review Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-07-28

View all other issues in [thread.thread.id].

View all issues with Review 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.17 [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.17 [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. ]

Proposed resolution:

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.17 [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-07-17

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.

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: Review Submitter: Peter Dimov Opened: 2008-09-15 Last modified: 2009-07-31

View other active issues in [thread.mutex.class].

View all other issues in [thread.mutex.class].

View all issues with Review 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. ]

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.10.2 [util.smartptr.shared] Status: Open Submitter: Hans Boehm Opened: 2008-09-16 Last modified: 2009-07-17

View other active issues in [util.smartptr.shared].

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.

Proposed resolution:

Make it explicitly thread-safe, in this weak sense, as I believe was intended:

Insert in 20.8.10.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.

### 897. Forward_list issues... Part 2

Section: 23.3.3.4 [forwardlist.modifiers] Status: Review Submitter: Howard Hinnant Opened: 2008-09-22 Last modified: 2009-07-18

View all issues with Review status.

Discussion:

This issue was split off from 892 at the request of the LWG.

[ San Francisco: ]

> This issue is more complicated than it looks.

> paragraph 47: replace each `(first, last) with (first, last]`

> add a statement after paragraph 48 that complexity is O(1)

> remove the complexity statement from the first overload of splice_after

> We may have the same problems with other modifiers, like erase_after. Should it require that all iterators in the range (position, last] be dereferenceable?

There are actually 3 issues here:

1. What value should `erase_after` return? With `list`, code often looks like:

   >     for (auto i = l.begin(); i != l.end();)
   >     {
   >         // inspect *i and decide if you want to erase it
   >         // ...
   >         if (I want to erase *i)
   >             i = l.erase(i);
   >         else
   >             ++i;
   >     }

   I.e. the iterator returned from `erase` is useful for setting up the logic for operating on the next element. For `forward_list` this might look something like:

   >     auto i = fl.before_begin();
   >     auto ip1 = i;
   >     for (++ip1; ip1 != fl.end(); ++ip1)
   >     {
   >         // inspect *(i+1) and decide if you want to erase it
   >         // ...
   >         if (I want to erase *(i+1))
   >             i = fl.erase_after(i);
   >         else
   >             ++i;
   >         ip1 = i;
   >     }

   In the above example code, it is convenient if `erase_after` returns the element prior to the erased element (range) instead of the element after the erase element (range).

   Existing practice:

   - SGI slist returns an iterator referencing the element after the erased range.
   - CodeWarrior slist returns an iterator referencing the element before the erased range.

   There is not a strong technical argument for either solution over the other.

2. With all other containers, operations always work on the range `[first, last)` and/or prior to the given `position`.

   With `forward_list`, operations sometimes work on the range `(first, last]` and/or after the given `position`.

   This is simply due to the fact that in order to operate on `*first` (with `forward_list`) one needs access to `*(first-1)`. And that's not practical with `forward_list`. So the operating range needs to start with `(first`, not `[first` (as the current working paper says).

   Additionally, if one is interested in splicing the range `(first, last)`, then (with `forward_list`), one needs practical (constant time) access to `*(last-1)` so that one can set the next field in this node to the proper value. As this is not possible with `forward_list`, one must specify the last element of interest instead of one past the last element of interest. The syntax for doing this is to pass `(first, last]` instead of `(first, last)`.

   With `erase_after` we have a choice of either erasing the range `(first, last]` or `(first, last)`. Choosing the latter enables:

   >     x.erase_after(pos, x.end());

   With the former, the above statement is inconvenient or expensive due to the lack of constant time access to `x.end()-1`. However we could introduce:

   >     iterator erase_to_end(const_iterator position);

   to compensate.

   The advantage of the former (`(first, last]`) for `erase_after` is a consistency with `splice_after` which uses `(first, last]` as the specified range. But this either requires the addition of `erase_to_end` or giving up such functionality.

3. As stated in the discussion of 892, and reienforced by point 2 above, a `splice_after` should work on the source range `(first, last]` if the operation is to be Ο(1). When splicing an entire list `x` the algorithm needs `(x.before_begin(), x.end()-1]`. Unfortunately `x.end()-1` is not available in constant time unless we specify that it must be. In order to make `x.end()-1` available in constant time, the implementation would have to dedicate a pointer to it. I believe the design of N2543 intended a nominal overhead of `foward_list` of 1 pointer. Thus splicing one entire `forward_list` into another can not be Ο(1).

[ Batavia (2009-05): ]

> We agree with the proposed resolution.

> Move to Review.

[ 2009-07 Frankfurt ]

> We may need a new issue to correct splice_after, because it may no longer be correct to accept an rvalues as an argument. Merge may be affected, too. This might be issue 1133. (Howard: confirmed)

> Move this to Ready, but the Requires clause of the second form of splice_after should say "(first, last)," not "(first, last]" (there are three occurrences). There was considerable discussion on this. (Howard: fixed)

> Alan suggested removing the "foward_last<T. Alloc>&& x" parameter from the second form of splice_after, because it is redundant. PJP wanted to keep it, because it allows him to check for bad ranges (i.e. "Granny knots").

> We prefer to keep `x`.

> Beman. Whenever we deviate from the customary half-open range in the specification, we should add a non-normative comment to the standard explaining the deviation. This clarifies the intention and spares the committee much confusion in the future.

> Alan to write a non-normative comment to explain the use of fully-closed ranges.

> Move to Ready, with the changes described above. (Howard: awaiting note from Alan)

Proposed resolution:

Wording below assumes issue 878 is accepted, but this issue is independent of that issue.

Change 23.3.3.4 [forwardlist.modifiers]:

>     iterator erase_after(const_iterator position);

> > Requires: The iterator following `position` is dereferenceable.

> > Effects: Erases the element pointed to by the iterator following `position`.

> > Returns: An iterator pointing to the element following the one that was erased, or `end()` if no such element exists An iterator equal to `position`.

>     iterator erase_after(const_iterator position, const_iterator last);

> > Requires: All iterators in the range `[(position,last)` are dereferenceable.

> > Effects: Erases the elements in the range `[(position,last)`.

> > Returns: An iterator equal to `position` `last`

Change 23.3.3.5 [forwardlist.ops]:

>     void splice_after(const_iterator position, forward_list<T,Allocator>&& x);

> > Requires: `position` is `before_begin()` or a dereferenceable iterator in the range `[begin(), end))`. `&x != this`.

> > Effects: Inserts the contents of `x` after `position`, and `x` becomes empty. Pointers and references to the moved elements of `x` now refer to those same elements but as members of `*this`. Iterators referring to the moved elements will continue to refer to their elements, but they now behave as iterators into `*this`, not into `x`.

> > Throws: Nothing.

> > Complexity: Ο(1) Ο(`distance(x.begin(), x.end())`)

> ...

>     void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
>                       const_iterator first, const_iterator last);

> > Requires: `position` is `before_begin()` or a dereferenceable iterator in the range `[begin(), end))`. `(first,last)` is a valid range in `x`, and all iterators in the range `(first,last)` are dereferenceable. `position` is not an iterator in the range `(first,last)`.

> > Effects: Inserts elements in the range `(first,last)` after `position` and removes the elements from `x`. Pointers and references to the moved elements of `x` now refer to those same elements but as members of `*this`. Iterators referring to the moved elements will continue to refer to their elements, but they now behave as iterators into `*this`, not into `x`.

> > Complexity: Ο(1).

### 900. stream move-assignment

Section: 27.9.1.8 [ifstream.assign] Status: Open Submitter: Niels Dekker Opened: 2008-09-20 Last modified: 2009-07-26

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. ]

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`.

### 908. Deleted assignment operators for atomic types must be volatile

Section: 29.5 [atomics.types] Status: Open Submitter: Anthony Williams Opened: 2008-09-26 Last modified: 2009-03-22

View all other issues in [atomics.types].

View all issues with Open status.

Discussion:

Addresses US 90

The deleted copy-assignment operators for the atomic types are not marked as volatile in N2723, whereas the assignment operators from the associated non-atomic types are. e.g.

>     atomic_bool& operator=(atomic_bool const&) = delete;
>     atomic_bool& operator=(bool) volatile;

This leads to ambiguity when assigning a non-atomic value to a non-volatile instance of an atomic type:

>     atomic_bool b;
>     b=false;

Both assignment operators require a standard conversions: the copy-assignment operator can use the implicit `atomic_bool(bool)` conversion constructor to convert `false` to an instance of `atomic_bool`, or `b` can undergo a qualification conversion in order to use the assignment from a plain `bool`.

This is only a problem once issue 845 is applied.

[ Summit: ]

> Move to open. Assign to Lawrence. Related to US 90 comment.

Proposed resolution:

Add volatile qualification to the deleted copy-assignment operator of all the atomic types:

>     atomic_bool& operator=(atomic_bool const&) volatile = delete;
>     atomic_itype& operator=(atomic_itype const&) volatile = delete;

etc.

This will mean that the deleted copy-assignment operator will require two conversions in the above example, and thus be a worse match than the assignment from plain `bool`.

### 910. Effects of MoveAssignable

Section: 20.2.9 [concept.copymove] Status: Open Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2009-07-18

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.

Proposed resolution:

In 20.2.9 [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-07-27

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.

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.5.7 [alg.min.max] Status: Open Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-07-14

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.5.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.

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.5.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`.

### 916. Redundant move-assignment operator of `pair` should be removed

Section: 20.3.3 [pairs] Status: Open Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-07-18

View other active issues in [pairs].

View all other issues in [pairs].

View all issues with Open status.

Discussion:

see also 917.

The current WP provides the following assignment operators for `pair` in 20.3.3 [pairs]/1:

1.     template<class U , class V>
       requires HasAssign<T1, const U&> && HasAssign<T2, const V&>
       pair& operator=(const pair<U , V>& p);

2.     requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );

3.     template<class U , class V>
       requires HasAssign<T1, RvalueOf<U>::type> && HasAssign<T2, RvalueOf<V>::type>
       pair& operator=(pair<U , V>&& p);

It seems that the functionality of (2) is completely covered by (3), therefore (2) should be removed.

[ Batavia (2009-05): ]

> Bill believes the extra assignment operators are necessary for resolving ambiguities, but that does not mean it needs to be part of the specification.

> Move to Open. We recommend this be looked at in the context of the ongoing work related to the pair templates.

[ 2009-07 Frankfurt: ]

> Leave this open pending the removal of concepts from the WD.

Proposed resolution:

1. In 20.3.3 [pairs] p. 1, class `pair` and just before p. 13 remove the declaration:

   >     requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );

2. Remove p.13+p.14

### 917. Redundant move-assignment operator of `tuple` should be removed

Section: 20.5.2.1 [tuple.cnstr] Status: Open Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-07-18

View other active issues in [tuple.cnstr].

View all other issues in [tuple.cnstr].

View all issues with Open status.

Discussion:

see also 916.

N2770 (and thus now the WP) removed the non-template move-assignment operator from tuple's class definition, but the latter individual member description does still provide this operator. Is this (a) an oversight and can it (b) be solved as part of an editorial process?

[ Post Summit Daniel provided wording. ]

[ Batavia (2009-05): ]

> We believe that the proposed resolution's part 1 is editorial.

> Regarding part 2, we either remove the specification as proposed, or else add back the declaration to which the specification refers. Alisdair and Bill prefer the latter. It is not immediately obvious whether the function is intended to be present.

> We recommend that the Project Editor restore the missing declaration and that we keep part 2 of the issue alive.

> Move to Open.

[ 2009-07 Frankfurt: ]

> Leave this open pending the removal of concepts from the WD.

Proposed resolution:

1. In 20.5.2 [tuple.tuple], class `tuple` just before member `swap` please change as indicated:

   [ This fixes an editorial loss between N2798 to N2800 ]

   >     template <class... UTypes>
   >     requires HasAssign<Types, const UTypes&>...
   >     tuple& operator=(const pair<UTypes...>&);

   >     template <class... UTypes>
   >     requires HasAssign<Types, RvalueOf<UTypes>::type>...
   >     tuple& operator=(pair<UTypes...>&&);

2. In 20.5.2.1 [tuple.cnstr], starting just before p. 11 please remove as indicated:

   >     requires MoveAssignable<Types>... tuple& operator=(tuple&& u);

   > > -11- Effects: Move-assigns each element of `u` to the corresponding element of `*this`.

   > > -12- Returns: `*this`.

### 919. (forward_)list specialized remove algorithms are over constrained

Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: Open Submitter: Daniel Krügler Opened: 2008-10-06 Last modified: 2009-07-21

View other active issues in [forwardlist.ops].

View all other issues in [forwardlist.ops].

View all issues with Open status.

Discussion:

The signatures of `forwardlist::remove` and `list::remove` defined in 23.3.3.5 [forwardlist.ops] before 11 + 23.3.4.4 [list.ops] before 15:

>     requires EqualityComparable<T> void remove(const T& value);

are asymmetric to their predicate variants (which only require `Predicate`, not `EquivalenceRelation`) and with the free algorithm remove (which only require `HasEqualTo`). Also, nothing in the pre-concept WP N2723 implies that `EqualityComparable` should be the intended requirement.

[ Batavia (2009-05): ]

> We agree with the proposed resolution, but would like additional input from concepts experts.

> Move to Review.

[ 2009-07-21 Alisdair adds: ]

> Current rationale and wording for this issue is built around concepts. I suggest the issue reverts to Open status. I believe there is enough of an issue to review after concepts are removed from the WP to re-examine the issue in Santa Cruz, rather than resolve as NAD Concepts.

Proposed resolution:

1. Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15

   >     requires EqualityComparable<T> HasEqualTo<T, T> void remove(const T& value);

### 920. Ref-qualification support in the library

Section: 20.7.15 [func.memfn] Status: Open Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-05-23

View all issues with Open status.

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.

Proposed resolution:

1. In 20.7 [function.objects]/2, header `<functional>` synopsis, just after the section "// 20.6.15, member function adaptors::" add the following declarations to the existing list:

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

2. In 20.7.15 [func.memfn] add the following declarations to the existing list:

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

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.

### 921. Rational Arithmetic should use template aliases

Section: 20.4.1 [ratio.ratio] Status: Review Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-07-21

View other active issues in [ratio.ratio].

View all other issues in [ratio.ratio].

View all issues with Review 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.

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 [..]

### 923. atomics with floating-point

Section: 29 [atomics] Status: Open Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-05-01

View other active issues in [atomics].

View all other issues in [atomics].

View all issues with Open status.

Discussion:

Right now, C++0x doesn't have `atomic<float>`. We're thinking of adding the words to support it for TR2 (note: that would be slightly post-C++0x). If we need it, we could probably add the words.

Proposed resolutions: Using `atomic<FP>::compare_exchange` (weak or strong) should be either:

1. ill-formed, or
2. well-defined.

I propose Option 1 for C++0x for expediency. If someone wants to argue for Option 2, they need to say what exactly they want `compare_exchange` to mean in this case (IIRC, C++0x doesn't even assume IEEE 754).

[ Summit: ]

> Move to open. Blocked until concepts for atomics are addressed.

[ Post Summit Anthony adds: ]

> Recommend NAD. C++0x does have `std::atomic<float>`, and both `compare_exchange_weak` and `compare_exchange_strong` are well-defined in this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to:

> > [Note: The effect of the compare-and-exchange operations is

> > >     if (!memcmp(object,expected,sizeof(*object)))
> > >         *object = desired;
> > >     else
> > >         *expected = *object;

> > This may result in failed comparisons for values that compare equal if the underlying type has padding bits or alternate representations of the same value. -- end note]

Proposed resolution:

Change the note in 29.6 [atomics.types.operations] paragraph 20 to:

> [Note: The effect of the compare-and-exchange operations is

> >     if (*object == *expected !memcmp(object,expected,sizeof(*object)))
> >         *object = desired;
> >     else
> >         *expected = *object;

> This may result in failed comparisons for values that compare equal if the underlying type has padding bits or alternate representations of the same value. -- end note]

### 924. structs with internal padding

Section: 29 [atomics] Status: Open Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-03-22

View other active issues in [atomics].

View all other issues in [atomics].

View all issues with Open status.

Discussion:

Right now, the `compare_exchange_weak` loop should rapidly converge on the padding contents. But `compare_exchange_strong` will require a bit more compiler work to ignore padding for comparison purposes.

Note that this isn't a problem for structs with no padding, and we do already have one portable way to ensure that there is no padding that covers the key use cases: Have elements be the same type. I suspect that the greatest need is for a structure of two pointers, which has no padding problem. I suspect the second need is a structure of a pointer and some form of an integer. If that integer is `intptr_t`, there will be no padding.

Related but separable issue: For unused bitfields, or other unused fields for that matter, we should probably say it's the programmer's responsibility to set them to zero or otherwise ensure they'll be ignored by `memcmp`.

Proposed resolutions: Using `atomic<struct-with-padding>::compare_exchange_strong` should be either:

1. ill-formed, or
2. well-defined.

I propose Option 1 for C++0x for expediency, though I'm not sure how to say it. I would be happy with Option 2, which I believe would mean that `compare_exchange_strong` would be implemented to avoid comparing padding bytes, or something equivalent such as always zeroing out padding when loading/storing/comparing. (Either implementation might require compiler support.)

[ Summit: ]

> Move to open. Blocked until concepts for atomics are addressed.

[ Post Summit Anthony adds: ]

> The resoultion of LWG 923 should resolve this issue as well.

Proposed resolution:

### 926. Sequentially consistent fences, relaxed operations and modification order

Section: 29.3 [atomics.order] Status: Open Submitter: Anthony Williams Opened: 2008-10-19 Last modified: 2009-03-22

View all other issues in [atomics.order].

View all issues with Open status.

Discussion:

Addresses UK 313

There was an interesting issue raised over on comp.programming.threads today regarding the following example

>     // Thread 1:
>     x.store(1, memory_order_relaxed);           // SX
>     atomic_thread_fence(memory_order_seq_cst);  // F1
>     y.store(1, memory_order_relaxed);           // SY1
>     atomic_thread_fence(memory_order_seq_cst);  // F2
>     r1 = y.load(memory_order_relaxed);          // RY

>     // Thread 2:
>     y.store(0, memory_order_relaxed);          // SY2
>     atomic_thread_fence(memory_order_seq_cst); // F3
>     r2 = x.load(memory_order_relaxed);         // RX

is the outcome `r1 == 0` and `r2 == 0` possible?

I think the intent is that this is not possible, but I am not sure the wording guarantees that. Here is my analysis:

Since all the fences are SC, there must be a total order between them. `F1` must be before `F2` in that order since they are in the same thread. Therefore `F3` is either before `F1`, between `F1` and `F2` or after `F2`.

If `F3` is after `F2`, then we can apply 29.3 [atomics.order]p5 from N2798:

> For atomic operations `A` and `B` on an atomic object `M`, where `A` modifies `M` and `B` takes its value, if there are `memory_order_seq_cst` fences `X` and `Y` such that `A` is sequenced before `X`, `Y` is sequenced before `B`, and `X` precedes `Y` in `S`, then `B` observes either the effects of `A` or a later modification of `M` in its modification order.

In this case, `A` is `SX`, `B` is `RX`, the fence `X` is `F2` and the fence `Y` is `F3`, so `RX` must see 1.

If `F3` is before `F2`, this doesn't apply, but `F3` can therefore be before or after `F1`.

If `F3` is after `F1`, the same logic applies, but this time the fence `X` is `F1`. Therefore again, `RX` must see 1.

Finally we have the case that `F3` is before `F1` in the SC ordering. There are now no guarantees about `RX`, and `RX` can see `r2==0`.

We can apply 29.3 [atomics.order]p5 again. This time, `A` is `SY2`, `B` is `RY`, `X` is `F3` and `Y` is `F1`. Thus `RY` must observe the effects of `SY2` or a later modification of `y` in its modification order.

Since `SY1` is sequenced before `RY`, `RY` must observe the effects of `SY1` or a later modification of `y` in its modification order.

In order to ensure that `RY` sees `(r1==1)`, we must see that `SY1` is later in the modification order of `y` than `SY2`.

We're now skating on thin ice. Conceptually, `SY2` happens-before `F3`, `F3` is SC-ordered before `F1`, `F1` happens-before `SY1`, so `SY1` is later in the modification order `M` of `y`, and `RY` must see the result of `SY1` (`r1==1`). However, I don't think the words are clear on that.

[ Post Summit Hans adds: ]

> In my (Hans') view, our definition of fences will always be weaker than what particular hardware will guarantee. `Memory_order_seq_cst` fences inherently don't guarantee sequential consistency anyway, for good reasons (e.g. because they can't enforce a total order on stores). Hence I don't think the issue demonstrates a gross failure to achieve what we intended to achieve. The example in question is a bit esoteric. Hence, in my view, living with the status quo certainly wouldn't be a disaster either.

> In any case, we should probably add text along the lines of the following between p5 and p6 in 29.3 [atomics.order]:

> > [Note: `Memory_order_seq_cst` only ensures sequential consistency for a data-race-free program that uses exclusively `memory_order_seq_cst` operations. Any use of weaker ordering will invalidate this guarantee unless extreme care is used. In particular, `memory_order_seq_cst` fences only ensure a total order for the fences themselves. They cannot, in general, be used to restore sequential consistency for atomic operations with weaker ordering specifications.]

> Also see thread beginning at c++std-lib-23271.

[ Herve's correction: ]

> Minor point, and sorry for the knee jerk reaction: I admit to having no knowledge of Memory_order_seq_cst, but my former boss (John Lakos) has ingrained an automatic introspection on the use of "only". I think you meant:

> > [Note: `Memory_order_seq_cst` ensures sequential consistency only for . . . . In particular, `memory_order_seq_cst` fences ensure a total order only for . . .

> Unless, of course, `Memory_order_seq_cst` really do nothing but ensure sequential consistency for a data-race-free program that uses exclusively `memory_order_seq_cst` operations.

Proposed resolution:

Add a new paragraph after 29.3 [atomics.order]p5 that says

> For atomic operations `A` and `B` on an atomic object `M`, where `A` and `B` modify `M`, if there are `memory_order_seq_cst` fences `X` and `Y` such that `A` is sequenced before `X`, `Y` is sequenced before `B`, and `X` precedes `Y` in `S`, then `B` occurs later than `A` in the modifiction order of `M`.

### 929. Thread constructor

Section: 30.3.1.2 [thread.thread.constr] Status: Open Submitter: Anthony Williams Opened: 2008-10-23 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 Open 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.3 [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.

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...`. 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`.

### 930. Access to std::array data as built-in array type

Section: 23.3.1 [array] Status: Review Submitter: Niels Dekker Opened: 2008-11-17 Last modified: 2009-07-31

View other active issues in [array].

View all other issues in [array].

View all issues with Review status.

Discussion:

The Working Draft (N2798) allows access to the elements of `std::array` by its `data()` member function:

> ##### 23.2.1.4 array::data [array.data]

>      T *data();
>      const T *data() const;

> 1. Returns: elems.

Unfortunately, the result of `std::array::data()` cannot be bound to a reference to a built-in array of the type of `array::elems`. And `std::array` provides no other way to get a reference to `array::elems`. This hampers the use of `std::array`, for example when trying to pass its data to a C style API function:

     // Some C style API function.
     void set_path( char (*)[MAX_PATH] );

     std::array<char,MAX_PATH> path;
     set_path( path.data() );  // error
     set_path( &(path.data()) );  // error

Another example, trying to pass the array data to an instance of another C++ class:

     // Represents a 3-D point in space.
     class three_d_point {
     public:
       explicit three_d_point(const double (&)[3]);
     };

     const std::array<double,3> coordinates = { 0, 1, 2 };
     three_d_point point1( coordinates.data() );  // error.
     three_d_point point2( *(coordinates.data()) );  // error.

A user might be tempted to use `std::array::elems` instead, but doing so isn't recommended, because `std::array::elems` is "for exposition only". Note that Boost.Array users might already use `boost::array::elems`, as its documentation doesn't explicitly state that `boost::array::elems` is for exposition only: http://www.boost.org/doc/libs/1_36_0/doc/html/boost/array.html

I can think of three options to solve this issue:

1. Remove the words "exposition only" from the definition of `std::array::elems`, as well as the note saying that "elems is shown for exposition only."
2. Change the signature of `std::array::data()`, so that it would return a reference to the built-in array, instead of a pointer to its first element.
3. Add extra member functions, returning a reference to the built-in array.

Lawrence Crowl wrote me that it might be better to leave `std::array::elems` "for exposition only", to allow alternate representations to allocate the array data dynamically. This might be of interest to the embedded community, having to deal with very limited stack sizes.

The second option, changing the return type of `std::array::data()`, would break backward compatible to current Boost and TR1 implementations, as well as to the other contiguous container (`vector` and `string`) in a very subtle way. For example, the following call to `std::swap` currently swap two locally declared pointers `(data1, data2)`, for any container type `T` that has a `data()` member function. When `std::array::data()` is changed to return a reference, the `std::swap` call may swap the container elements instead.

     template <typename T>
     void func(T& container1, T& container2)
     {
       // Are data1 and data2 pointers or references?
       auto data1 = container1.data();
       auto data2 = container2.data();

       // Will this swap two local pointers, or all container elements?
       std::swap(data1, data2);
     }

The following concept is currently satisfied by all contiguous containers, but it no longer is for `std::array`, when `array::data()` is changed to return a reference (tested on ConceptGCC Alpha 7):

     auto concept ContiguousContainerConcept<typename T>
     {
       typename value_type = typename T::value_type;
       const value_type * T::data() const;
     }

Still it's worth considering having `std::array::data()` return a reference, because it might be the most intuitive option, from a user's point of view. Nicolai Josuttis (who wrote `boost::array`) mailed me that he very much prefers this option.

Note that for this option, the definition of `data()` would also need to be revised for zero-sized arrays, as its return type cannot be a reference to a zero-sized built-in array. Regarding zero-sized array, `data()` could throw an exception. Or there could be a partial specialization of `std::array` where `data()` returns `T*` or gets removed.

Personally I prefer the third option, adding a new member function to `std::array`, overloaded for const and non-const access, returning a reference to the built-in array, to avoid those compatible issues. I'd propose naming the function `std::array::c_array()`, which sounds intuitive to me. Note that `boost::array` already has a `c_array()` member, returning a pointer, but Nicolai told me that this one is only there for historical reasons. (Otherwise a name like `std::array::native_array()` or `std::array::builtin_array()` would also be fine with me.) According to my proposed resolution, a zero-sized `std::array` does not need to have `c_array()`, while it is still required to have `data()` functions.

[ Post Summit: ]

> Alisdair: Don't like p4 suggesting implementation-defined behaviour.

> Walter: What about an explicit conversion operator, instead of adding the new member function?

> Alisdair: Noodling about:

> >     template<size_t N, ValueType T>
> >     struct array
> >     {
> >       T elems[N];

> >     // fantasy code starts here

> >     // crazy decltype version for grins only
> >     //requires True<(N>0)>
> >     //explict operator decltype(elems) & () { return elems; }

> >     // conversion to lvalue ref
> >     requires True<(N>0)>
> >     explict operator T(&)[N] () & { return elems; }

> >     // conversion to const lvalue ref
> >     requires True<(N>0)>
> >     explict operator const T(&)[N] () const & { return elems; }

> >     // conversion to rvalue ref using ref qualifiers
> >     requires True<(N>0)>
> >     explict operator T(&&)[N] () && { return elems; }

> >     // fantasy code ends here

> >     explicit operator bool() { return true; }
> >     };

> This seems legal but odd. Jason Merrill says currently a CWG issue 613 on the non-static data member that fixes the error that current G++ gives for the non-explicit, non-conceptualized version of this. Verdict from human compiler: seems legal.

> Some grumbling about zero-sized arrays being allowed and supported.

> Walter: Would this address the issue? Are we inclined to go this route?

> Alan: What would usage look like?

> >     // 3-d point in space
> >     struct three_d_point
> >     {
> >       explicit three_d_point(const double (&)[3]);
> >     };

> >     void sink(double*);

> >     const std::array<double, 3> coordinates = { 0, 1, 2 };
> >     three_d_point point1( coordinates.data() ); //error
> >     three_d_point point2( *(coordinates.data()) ); // error
> >     three_d_point point3( coordinates ); // yay!

> >     sink(cooridinates); // error, no conversion

> Recommended Open with new wording. Take the required clause and add the explicit conversion operators, not have a `typedef`. At issue still is use `decltype` or use `T[N]`. In favour of using `T[N]`, even though use of `decltype` is specially clever.

[ Post Summit, further discussion in the thread starting with c++std-lib-23215. ]

[ 2009-07 post-Frankfurt (Saturday afternoon group): ]

> The idea to resolve the issue by adding explicit conversion operators was abandoned, because it would be inconvenient to use, especially when passing the array to a template function, as mentioned by Daniel. So we reconsidered the original proposed resolution, which appeared acceptable, except for its proposed changes to 23.3.1.6 [array.zero], which allowed `c_array_type` and `c_array()` to be absent for a zero-sized array. Alisdair argued that such wording would disallow certain generic use cases. New wording for 23.3.1.6 [array.zero] was agreed upon (Howard: and is reflected in the proposed resolution).

> Move to Review

[ 2009-07-31 Alisdair adds: ]

> I will be unhappy voting the proposed resolution for 930 past review until we have implementation experience with reference qualifiers. Specifically, I want to understand the impact of the missing overload for `const &&` (if any.)

> If we think the issue is important enough it might be worthwhile stripping the ref qualifiers for easy progress next meeting, and opening yet another issue to put them back with experience.

> Recommend deferring any decision on splitting the issue until we get LWG feedback next meeting - I may be the lone dissenting voice if others are prepared to proceed without it.

Proposed resolution:

Add to the template definition of array, 23.3.1 [array]/3:

>     typedef T c_array_type[N];
>     c_array_type & c_array() &;
>     c_array_type && c_array() &&;
>     const c_array_type & c_array() const &;

Add the following subsection to 23.3.1 [array], after 23.3.1.4 [array.data]:

> ##### 23.2.1.5 array::c_array [array.c_array]

>     c_array_type & c_array() &;
>     c_array_type && c_array() &&;
>     const c_array_type & c_array() const &;

> > Returns: `elems`.

Change Zero sized arrays 23.3.1.6 [array.zero]:

> -2- ...

> The type `c_array_type` is unspecified for a zero-sized array.

> -3- The effect of calling `c_array()`, `front()`, or `back()` for a zero-sized array is implementation defined.

### 932. `unique_ptr(pointer p)` for pointer deleter types

Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Open Submitter: Howard Hinnant Opened: 2008-11-26 Last modified: 2009-07-27

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

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

View all issues with Open status.

Discussion:

Addresses US 79

20.8.9.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.

Proposed resolution:

Change the description of the default constructor in 20.8.9.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: A diagnostic shall be emitted if this constructor is instantiated when `D` is a pointer type or reference type.

Add after 20.8.9.2.1 [unique.ptr.single.ctor]/8:

>     unique_ptr(pointer p);

> > ...

> > Remarks: A diagnostic shall be emitted if this constructor is instantiated when `D` is a pointer type or reference type.

### 933. Unique_ptr defect

Section: 20.8.9.2.5 [unique.ptr.single.modifiers] Status: Open Submitter: Alisdair Meredith Opened: 2008-11-27 Last modified: 2009-05-23

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

View all issues with Open status.

Discussion:

If we are supporting stateful deleters, we need an overload for `reset` that takes a deleter as well.

>     void reset( pointer p, deleter_type d);

We probably need two overloads to support move-only deleters, and this sounds uncomfortably like the two constructors I have been ignoring for now...

[ Batavia (2009-05): ]

> Howard comments that we have the functionality via move-assigment.

> Move to Open.

Proposed resolution:

### 934. `duration` is missing `operator%`

Section: 20.9.3 [time.duration] Status: Ready Submitter: Terry Golubiewski Opened: 2008-11-30 Last modified: 2009-07-27

View other active issues in [time.duration].

View all other issues in [time.duration].

View all issues with Ready status.

Discussion:

Addresses US 81

`duration` is missing `operator%`. This operator is convenient for computing where in a time frame a given `duration` lies. A motivating example is converting a `duration` into a "broken-down" time duration such as hours::minutes::seconds:

>     class ClockTime
>     {
>         typedef std::chrono::hours hours;
>         typedef std::chrono::minutes minutes;
>         typedef std::chrono::seconds seconds;
>     public:
>         hours hours_;
>         minutes minutes_;
>         seconds seconds_;

>         template <class Rep, class Period>
>           explicit ClockTime(const std::chrono::duration<Rep, Period>& d)
>             : hours_  (std::chrono::duration_cast<hours>  (d)),
>               minutes_(std::chrono::duration_cast<minutes>(d % hours(1))),
>               seconds_(std::chrono::duration_cast<seconds>(d % minutes(1)))
>               {}
>     };

[ Summit: ]

> Agree except that there is a typo in the proposed resolution. The member operators should be operator%=.

[ 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-07 Frankfurt: ]

> Howard to open a separate issue (1177) to handle the removal of member functions from overload sets, provide wording, and possibly demonstrate how this can be implemented using enable_if (see 947).

> Move to Ready.

Proposed resolution:

Add to the synopsis in 20.9 [time]:

>     template <class Rep1, class Period, class Rep2>
>       duration<typename common_type<Rep1, Rep2>::type, Period>
>       operator%(const duration<Rep1, Period>& d, const Rep2& s);
>     template <class Rep1, class Period1, class Rep2, class Period2>
>       typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
>       operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

Add to the synopsis of `duration` in 20.9.3 [time.duration]:

>     template <class Rep, class Period = ratio<1>>
>     class duration {
>     public:
>       ...
>       duration& operator%=(const rep& rhs);
>       duration& operator%=(const duration& d);
>       ...
>     };

Add to 20.9.3.3 [time.duration.arithmetic]:

>     duration& operator%=(const rep& rhs);

> > Effects: `rep_ %= rhs`.

> > Returns: `*this`.

>     duration& operator%=(const duration& d);

> > Effects: `rep_ %= d.count()`.

> > Returns: `*this`.

Add to 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: `Rep2` shall be implicitly convertible to `CR(Rep1, Rep2)` and `Rep2` shall not be an instantiation of `duration`. Diagnostic required.

> > Returns: `duration<CR, Period>(d) %= s`.

>     template <class Rep1, class Period1, class Rep2, class Period2>
>       typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
>       operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

> > Returns: `common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type(lhs) %= rhs`.

### 935. clock error handling needs to be specified

Section: 20.9.5 [time.clock] Status: Open Submitter: Beman Dawes Opened: 2008-11-24 Last modified: 2009-05-23

View all issues with Open status.

Discussion:

Each of the three clocks specified in Clocks 20.9.5 [time.clock] provides the member function:

>     static time_point now();

The semantics specified by Clock requirements 20.9.1 [time.clock.req] make no mention of error handling. Thus the function may throw `bad_alloc` or an implementation-defined exception (17.6.4.10 [res.on.exception.handling] paragraph 4).

Some implementations of these functions on POSIX, Windows, and presumably on other operating systems, may fail in ways only detectable at runtime. Some failures on Windows are due to supporting chipset errata and can even occur after successful calls to a clock's `now()` function.

These functions are used in cases where exceptions are not appropriate or where the specifics of the exception or cause of error need to be available to the user. See N2828, Library Support for hybrid error handling (Rev 1), for more specific discussion of use cases. Thus some change in the interface of now is required.

The proposed resolution has been implemented in the Boost version of the chrono library. No problems were encountered.

[ Batavia (2009-05): ]

> We recommend this issue be deferred until the next Committee Draft has been issued and the prerequisite paper has been accepted.

> Move to Open.

Proposed resolution:

Accept the proposed wording of N2828, Library Support for hybrid error handling (Rev 1).

Change Clock requirements 20.9.1 [time.clock.req] as indicated:

> -2- In Table 55 `C1` and `C2` denote clock types. `t1` and `t2` are values returned by `C1::now()` where the call returning `t1` happens before (1.10) the call returning `t2` and both of these calls happen before `C1::time_point::max()`. `ec` denotes an object of type `error_code` (19.5.2.2 [syserr.errcode.overview]).

> Table 55 -- Clock requirements
> Expression | Return type | Operational semantics
> --- | --- | ---
> ... | ... | ...
> `C1::now()` | `C1::time_point` | Returns a `time_point` object representing the current point in time.
> `C1::now(ec)` | `C1::time_point` | Returns a `time_point` object representing the current point in time.

Change Class system_clock 20.9.5.1 [time.clock.system] as indicated:

>     static time_point now(error_code& ec=throws());

Change Class monotonic_clock 20.9.5.2 [time.clock.monotonic] as indicated:

>     static time_point now(error_code& ec=throws());

Change Class high_resolution_clock 20.9.5.3 [time.clock.hires] as indicated:

>     static time_point now(error_code& ec=throws());

### 936. Mutex type overspecified

Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2008-12-05 Last modified: 2009-03-22

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Open status.

Discussion:

30.4.1 [thread.mutex.requirements] describes the requirements for a type to be a "Mutex type". A Mutex type can be used as the template argument for the `Lock` type that's passed to `condition_variable_any::wait` (although `Lock` seems like the wrong name here, since `Lock` is given a different formal meaning in 30.4.3 [thread.lock]) and, although the WD doesn't quite say so, as the template argument for `lock_guard` and `unique_lock`.

The requirements for a Mutex type include:

- `m.lock()` shall be well-formed and have [described] semantics, including a return type of `void`.
- `m.try_lock()` shall be well-formed and have [described] semantics, including a return type of `bool`.
- `m.unlock()` shall be well-formed and have [described] semantics, including a return type of `void`.

Also, a Mutex type "shall not be copyable nor movable".

The latter requirement seems completely irrelevant, and the three requirements on return types are tighter than they need to be. For example, there's no reason that `lock_guard` can't be instantiated with a type that's copyable. The rule is, in fact, that `lock_guard`, etc. won't try to copy objects of that type. That's a constraint on locks, not on mutexes. Similarly, the requirements for `void` return types are unnecessary; the rule is, in fact, that `lock_guard`, etc. won't use any returned value. And with the return type of `bool`, the requirement should be that the return type is convertible to `bool`.

[ Summit: ]

> Move to open. Related to conceptualization and should probably be tackled as part of that.

> - The intention is not only to place a constraint on what types such as `lock_guard` may do with mutex types, but on what any code, including user code, may do with mutex types. Thus the constraints as they are apply to the mutex types themselves, not the current users of mutex types in the standard.
> - This is a low priority issue; the wording as it is may be overly restrictive but this may not be a real issue.

[ Post Summit Anthony adds: ]

> Section 30.4.1 [thread.mutex.requirements] conflates the requirements on a generic Mutex type (including user-supplied mutexes) with the requirements placed on the standard-supplied mutex types in an attempt to group everything together and save space.

> When applying concepts to chapter 30, I suggest that the concepts `Lockable` and `TimedLockable` embody the requirements for *use* of a mutex type as required by `unique_lock/lock_guard/condition_variable_any`. These should be relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of `std::mutex`, `std::timed_mutex`, `std::recursive_mutex` and `std::recursive_timed_mutex`, and should be rephrased as such.

Proposed resolution:

### 939. Problem with `std::identity` and reference-to-temporaries

Section: 20.7.6 [identity.operation] Status: Open Submitter: Alisdair Meredith Opened: 2008-12-11 Last modified: 2009-07-30

View all issues with Open 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. ]

Proposed resolution:

Strike 20.2.1 [concept.transform] p3:

> -4- Note: concept form of the identity type metafunction (20.7.6).

Strike from 20.7 [function.objects] p2:

>     // 20.7.6, identity operation:
>     template <IdentityOf T> struct identity;

Remove 20.7.6 [identity.operation] (whole subclause):

>     template <IdentityOf T> struct identity {
>       typedef T type;

>       requires ReferentType<T>
>          const T& operator()(const T& x) const;
>     };

>     requires ReferentType<T>
>       const T& operator()(const T& x) const;

> > -1- Returns: `x`

### 940. `std::distance`

Section: 24.4 [iterator.operations] Status: Open Submitter: Thomas Opened: 2008-12-14 Last modified: 2009-07-18

View other active issues in [iterator.operations].

View all other issues in [iterator.operations].

View all issues with Open status.

Discussion:

Addresses UK 270

Regarding the `std::distance` - function, 24.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 [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 [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 24.2 [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 [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.

Proposed resolution:

Change 24.4 [iterator.operations]:

>     template <InputIterator Iter>
>       Iter::difference_type
>       distance(Iter first, Iter last);
>     template <RandomAccessIterator Iter>
>       Iter::difference_type distance(Iter first, Iter last);

> > -4- Effects: Returns the number of increments or decrements needed to get from `first` to `last`.

> > -5- Requires: `last` shall be reachable from `first`.

>     template <RandomAccessIterator Iter>
>       Iter::difference_type distance(Iter first, Iter last);

> > -6- Effects: Returns the number of increments or decrements needed to get from `first` to `last`.

> > -7- Requires: `last` shall be reachable from `first` or `first` shall be reachable from `last`.

### 944. `atomic<bool>` derive from `atomic_bool`?

Section: 29.5.3 [atomics.types.generic] Status: Open Submitter: Holger Grund Opened: 2008-12-19 Last modified: 2009-03-22

View all other issues in [atomics.types.generic].

View all issues with Open status.

Discussion:

I think it's fairly obvious that `atomic<bool>` is supposed to be derived from `atomic_bool` (and otherwise follow the `atomic<integral>` interface), though I think the current wording doesn't support this. I raised this point along with `atomic<floating-point>` privately with Herb and I seem to recall it came up in the resulting discussion on this list. However, I don't see anything on the current libs issue list mentioning this problem.

29.5.3 [atomics.types.generic]/3 reads

> There are full specializations over the integral types on the atomic class template. For each integral type integral in the second column of table 121 or table 122, the specialization `atomic<integral>` shall be publicly derived from the corresponding atomic integral type in the first column of the table. These specializations shall have trivial default constructors and trivial destructors.

Table 121 does not include (`atomic_bool`, `bool`), so that this should probably be mentioned explicitly in the quoted paragraph.

[ Summit: ]

> Move to open. Lawrence will draft a proposed resolution. Also, ask Howard to fix the title.

[ Post Summit Anthony provided proposed wording. ]

Proposed resolution:

Replace paragraph 3 in 29.5.3 [atomics.types.generic] with

> -3- There are full specializations over the integral types on the `atomic` class template. For each integral type `integral` in the second column of table 121 or table 122, the specialization `atomic<integral>` shall be publicly derived from the corresponding atomic integral type in the first column of the table. In addition, the specialization `atomic<bool>` shall be publicly derived from `atomic_bool`. These specializations shall have trivial default constructors and trivial destructors.

### 947. duration arithmetic: contradictory requirements

Section: 20.9.3.5 [time.duration.nonmember] Status: Open Submitter: Pete Becker Opened: 2008-12-20 Last modified: 2009-07-27

View all other issues in [time.duration.nonmember].

View all issues with Open status.

Discussion:

In 20.9.3.5 [time.duration.nonmember], paragraph 8 says that calling `dur / rep` when `rep` is an instantiation of `duration` requires a diagnostic. That's followed by an `operator/` that takes two durations. So `dur1 / dur2` is legal under the second version, but requires a diagnostic under the first.

[ Howard adds: ]

> Please see the thread starting with c++std-lib-22980 for more information.

[ Batavia (2009-05): ]

> Move to Open, pending proposed wording (and preferably an implementation).

[ 2009-07-27 Howard adds: ]

> I've addressed this issue under the proposed wording for 1177 which cleans up several places under 20.9.3 [time.duration] which used the phrase "diagnostic required".

> For clarity's sake, here is an example implementation of the constrained `operator/`:

> >     template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
> >     struct __duration_divide_result
> >     {
> >     };

> >     template <class _Duration, class _Rep2,
> >         bool = is_convertible<_Rep2,
> >                               typename common_type<typename _Duration::rep, _Rep2>::type>::value>
> >     struct __duration_divide_imp
> >     {
> >     };

> >     template <class _Rep1, class _Period, class _Rep2>
> >     struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
> >     {
> >         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
> >     };

> >     template <class _Rep1, class _Period, class _Rep2>
> >     struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
> >         : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
> >     {
> >     };

> >     template <class _Rep1, class _Period, class _Rep2>
> >     inline
> >     typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
> >     operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
> >     {
> >         typedef typename common_type<_Rep1, _Rep2>::type _Cr;
> >         duration<_Cr, _Period> __r = __d;
> >         __r /= static_cast<_Cr>(__s);
> >         return __r;
> >     }

> `__duration_divide_result` is basically a custom-built `enable_if` that will contain `type` only if `Rep2` is not a `duration` and if `Rep2` is implicitly convertible to `common_type<typename Duration::rep, Rep2>::type`. `__is_duration` is simply a private trait that answers `false`, but is specialized for `duration` to answer `true`.

> The constrained `operator%` works identically.

Proposed resolution:

### 950. unique_ptr converting ctor shouldn't accept array form

Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Review Submitter: Howard Hinnant Opened: 2009-01-07 Last modified: 2009-08-01

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

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

View all issues with Review 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. ]

Proposed resolution:

Change 20.8.9.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.9.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-08-01

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 to 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.

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-08-01

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.

Proposed resolution:

### 954. Various threading bugs #4

Section: 20.9.1 [time.clock.req] Status: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

View other active issues in [time.clock.req].

View all other issues in [time.clock.req].

View all issues with Review 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. ]

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.

### 955. Various threading bugs #5

Section: 20.9.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-06-07

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] requires that a clock type have a member typedef named `time_point` that names an instantiation of the template `time_point`, and a member named `duration` that names an instantiation of the template `duration`. This mixing of levels is confusing. The typedef names should be different from the template names.

[ Post Summit, Anthony provided proposed wording. ]

[ 2009-05-04 Howard adds: ]

> The reason that the typedef names were given the same name as the class templates was so that clients would not have to stop and think about whether they were using the clock's native `time_point` / `duration` or the class template directly. In this case, one person's confusion is another person's encapsulation. The detail that sometimes one is referring to the clock's native types, and sometimes one is referring to an independent type is purposefully "hidden" because it is supposed to be an unimportant detail. It can be confusing to have to remember when to type `duration` and when to type `duration_type`, and there is no need to require the client to remember something like that.

> For example, here is code that I once wrote in testing out the usability of this facility:

> >     template <class Clock, class Duration>
> >     void do_until(const std::chrono::time_point<Clock, Duration>& t)
> >     {
> >         typename Clock::time_point now = Clock::now();
> >         if (t > now)
> >         {
> >             typedef typename std::common_type
> >             <
> >                 Duration,
> >                 typename std::chrono::system_clock::duration
> >             >::type CD;
> >             typedef std::chrono::duration<double, std::nano> ID;

> >             CD d = t - now;
> >             ID us = duration_cast<ID>(d);
> >             if (us < d)
> >                 ++us;
> >             ...
> >         }
> >     }

> I see no rationale to require the client to append `_type` to some of those declarations. It seems overly burdensome on the author of `do_until`:

> >     template <class Clock, class Duration>
> >     void do_until(const std::chrono::time_point<Clock, Duration>& t)
> >     {
> >         typename Clock::time_point_type now = Clock::now();
> >         if (t > now)
> >         {
> >             typedef typename std::common_type
> >             <
> >                 Duration,
> >                 typename std::chrono::system_clock::duration_type
> >             >::type CD;
> >             typedef std::chrono::duration<double, std::nano> ID;

> >             CD d = t - now;
> >             ID us = duration_cast<ID>(d);
> >             if (us < d)
> >                 ++us;
> >             ...
> >         }
> >     }

> Additionally I'm fairly certain that this suggestion hasn't been implemented. If it had, it would have been discovered that it is incomplete. `time_point` also has a nested type (purposefully) named `duration`.

> > That is, the current proposed wording would put the WP into an inconsistent state.

> In contrast, the current WP has been implemented and I've received very favorable feedback from people using this interface in real-world code.

[ Batavia (2009-05): ]

> Bill agrees that distinct names should be used for distinct kinds of entities.

> Walter would prefer not to suffix type names, especially for such well-understood terms as "duration".

> Howard reminds us that the proposed resolution is incomplete, per his comment in the issue.

> Move to Open.

[ 2009-06-07 Howard adds: ]

> Not meaning to be argumentative, but we have a decade of positive experience with the precedent of using the same name for the nested type as an external class representing an identical concept.

> >     template<class Category, class T, class Distance = ptrdiff_t,
> >              class Pointer = T*, class Reference = T&>
> >     struct iterator
> >     {
> >         ...
> >     };

> >     template <BidirectionalIterator Iter>
> >     class reverse_iterator
> >     {
> >         ...
> >     };

> >     template <ValueType T, Allocator Alloc = allocator<T> >
> >         requires NothrowDestructible<T>
> >     class list
> >     {
> >     public:
> >         typedef implementation-defined     iterator;
> >         ...
> >         typedef reverse_iterator<iterator> reverse_iterator;
> >         ...
> >     };

> I am aware of zero complaints regarding the use of `iterator` and `reverse_iterator` as nested types of the containers despite these names also having related meaning at namespace std scope.

> Would we really be doing programmers a favor by renaming these nested types?

> >     template <ValueType T, Allocator Alloc = allocator<T> >
> >         requires NothrowDestructible<T>
> >     class list
> >     {
> >     public:
> >         typedef implementation-defined     iterator_type;
> >         ...
> >         typedef reverse_iterator<iterator> reverse_iterator_type;
> >         ...
> >     };

> I submit that such design contributes to needless verbosity which ends up reducing readability.

Proposed resolution:

Change 20.9 [time]:

>     ...
>     template <class Clock, class Duration = typename Clock::duration_type> class time_point;
>     ...

Change 20.9.1 [time.clock.req]:

> Table 45 -- Clock requirements
> Expression | Return type | Operational semantics
> --- | --- | ---
> ... | ... | ...
> `C1::duration_type` | `chrono::duration<C1::rep, C1::period>` | The native `duration` type of the clock.
> `C1::time_point_type` | `chrono::time_point<C1>` or `chrono::time_point<C2, C1::duration_type<` | The native `time_point` type of the clock. Different clocks may share a `time_point_type` definition if it is valid to compare their `time_point_type`s by comparing their respective `duration_type`s. `C1` and `C2` shall refer to the same epoch.
> ... | ... | ...
> `C1::now()` | `C1::time_point_type` | Returns a `time_point_type` object representing the current point in time.

Change 20.9.5.1 [time.clock.system]:

> -1- Objects of class `system_clock` represent wall clock time from the system-wide realtime clock.

> >     class system_clock {
> >     public:
> >       typedef see below rep;
> >       typedef ratio<unspecified, unspecified> period;
> >       typedef chrono::duration<rep, period> duration_type;
> >       typedef chrono::time_point<system_clock> time_point_type;
> >       static const bool is_monotonic = unspecified ;

> >       static time_point_type now();

> >       // Map to C API
> >       static time_t to_time_t (const time_point_type& t);
> >       static time_point_type from_time_t(time_t t);
> >     };

> -2- `system_clock::duration_type::min() < system_clock::duration_type::zero()` shall be `true`.

>     time_t to_time_t(const time_point_type& t);

> > -3- Returns: A `time_t` object that represents the same point in time as `t` when both values are truncated to the coarser of the precisions of `time_t` and `time_point_type`.

>     time_point_type from_time_t(time_t t);

> > -4- Returns: A `time_point_type` object that represents the same point in time as `t` when both values are truncated to the coarser of the precisions of `time_t` and `time_point_type`.

Change 20.9.5.2 [time.clock.monotonic]:

>     class monotonic_clock {
>     public:
>       typedef unspecified                                rep;
>       typedef ratio<unspecified , unspecified>           period;
>       typedef chrono::duration<rep, period>              duration_type;
>       typedef chrono::time_point<unspecified , duration_type> time_point_type;
>       static const bool is_monotonic =                   true;

>       static time_point_type now();
>     };

Change 20.9.5.3 [time.clock.hires]:

>     class high_resolution_clock {
>     public:
>       typedef unspecified                                rep;
>       typedef ratio<unspecified , unspecified>           period;
>       typedef chrono::duration<rep, period>              duration_type;
>       typedef chrono::time_point<unspecified , duration_type> time_point_type;
>       static const bool is_monotonic =                   true;

>       static time_point_type now();
>     };

### 956. Various threading bugs #6

Section: 20.9.1 [time.clock.req] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-05-23

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.

Proposed resolution:

### 957. Various threading bugs #7

Section: 20.9.5.1 [time.clock.system] Status: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-05-23

View all other issues in [time.clock.system].

View all issues with Review 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.

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.

### 958. Various threading bugs #8

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

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]: the specification for `wait_for` with no predicate has an effects clause that says it calls `wait_until`, and a returns clause that sets out in words how to determine the return value. Is this description of the return value subtly different from the description of the value returned by `wait_until`? Or should the effects clause and the returns clause be merged?

[ 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).

Proposed resolution:

### 959. Various threading bugs #9

Section: 30.5.1 [thread.condition.condvar] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

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

Proposed resolution:

### 960. Various threading bugs #10

Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-27

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Open 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. ]

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 type Mutex 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.

### 961. Various threading bugs #11

Section: 30.4.1 [thread.mutex.requirements] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Open status.

Discussion:

30.4.1 [thread.mutex.requirements] describes required member functions of mutex types, and requires that they throw exceptions under certain circumstances. This is overspecified. User-defined types can abort on such errors without affecting the operation of templates supplied by standard-library.

[ Summit: ]

> Move to open. Related to conceptualization and should probably be tackled as part of that.

Proposed resolution:

### 962. Various threading bugs #12

Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-07-21

View other active issues in [thread.lock.unique.locking].

View all other issues in [thread.lock.unique.locking].

View all issues with Review 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. ]

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. Nevertheless, failure to allocate storage shall be reported as described in [res.on.exception.handling].

Change thread assignment 30.3.1.4 [thread.thread.assign], 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.4 [thread.thread.assign], 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: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

View other active issues in [thread.thread.member].

View all other issues in [thread.thread.member].

View all issues with Open 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.

Proposed resolution:

### 964. Various threading bugs #14

Section: 30.5.2 [thread.condition.condvarany] Status: Open Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

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.

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-08-01

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.

Proposed resolution:

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.

### 967. Various threading bugs #17

Section: 30.3.1.2 [thread.thread.constr] Status: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-06-27

View other active issues in [thread.thread.constr].

View all other issues in [thread.thread.constr].

View all issues with Review 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. ]

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.10 [res.on.exception.handling] for exceptions thrown to report storage allocation failures. --end note]

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` &msash; if a memory limitation prevents initialization.
> > > - `resource_unavailable_try_again` &msash; if some non-memory resource limitation prevents initialization.
> > > - `device_or_resource_busy` &msash; 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: Review Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-06-27

View other active issues in [thread.mutex.requirements].

View all other issues in [thread.mutex.requirements].

View all issues with Review 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. ]

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.10 [res.on.exception.handling] for exceptions thrown to report storage allocation failures. —end note]

> [Example:

> > 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. 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.

### 971. Spurious diagnostic conversion function

Section: 19.5.2.6 [syserr.errcode.nonmembers] Status: Tentatively NAD Submitter: Beman Dawes Opened: 2009-01-19 Last modified: 2009-07-22

View all issues with Tentatively NAD status.

Discussion:

Anthony Williams raised the question in c++std-lib-22987 "why is there `std::make_error_code(std::errc)`? What purpose does this serve?"

The function `make_error_code(errc e)` is not required, since `make_error_condition(errc e)` is the function that is needed for `errc` conversions. `make_error_code(errc e)` appears to be a holdover from my initial confusion over the distinction between POSIX and operating systems that conform to the POSIX spec.

[ Post Summit: ]

> Recommend Review.

[ Batavia (2009-05): ]

> The designer of the facility (Christopher Kohlhoff) strongly disagrees that there is an issue here, and especially disagrees with the proposed resolution. Bill would prefer to be conservative and not apply this proposed resolution. Move to Open, and recommend strong consideration for NAD status.

[ 2009-05-21 Beman adds: ]

> My mistake. Christopher and Bill are correct and the issue should be NAD. The function is needed by users.

[ 2009-07-21 Christopher Kohlhoff adds rationale for `make_error_code`: ]

> Users (and indeed library implementers) may need to use the `errc` codes in portable code. For example:

> >     void do_foo(error_code& ec)
> >     {
> >     #if defined(_WIN32)
> >       // Windows implementation ...
> >     #elif defined(linux)
> >       // Linux implementation ...
> >     #else
> >       // do_foo not supported on this platform
> >       ec = make_error_code(errc::not_supported);
> >     #endif
> >     }

Proposed resolution:

Change System error support 19.5 [syserr], Header `<system_error>` synopsis, as indicated:

>     error_code make_error_code(errc e);
>     error_condition make_error_condition(errc e);

Delete from Class error_code non-member functions 19.5.2.6 [syserr.errcode.nonmembers]:

>     error_code make_error_code(errc e);

> > Returns: `error_code(static_cast<int>(e), generic_category)`.

### 974. `duration<double>` should not implicitly convert to `duration<int>`

Section: 20.9.3.1 [time.duration.cons] Status: Open Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-08-01

View all issues with Open 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.

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]

### 976. Class template std::stack should be movable

Section: 23.3.5.3.1 [stack.defn] Status: Open Submitter: Daniel Krügler Opened: 2009-02-01 Last modified: 2009-07-14

View all issues with Open status.

Discussion:

The synopsis given in 23.3.5.3.1 [stack.defn] does not show up

>     requires MoveConstructible<Cont> stack(stack&&);
>     requires MoveAssignable<Cont> stack& operator=(stack&&);

although the other container adaptors do provide corresponding members.

[ 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.

Proposed resolution:

In the class stack synopsis of 23.3.5.3.1 [stack.defn] insert:

>     template <ObjectType T, StackLikeContainer Cont = deque<T> >
>       requires SameType<Cont::value_type, T>
>             && NothrowDestructible<Cont>
>     class stack {
>     public:
>        ...
>        requires CopyConstructible<Cont> explicit stack(const Cont&);
>        requires MoveConstructible<Cont> explicit stack(Cont&& = Cont());
>        requires MoveConstructible<Cont> stack(stack&&);
>        requires MoveAssignable<Cont> stack& operator=(stack&&);
>        template <class Alloc>
>          requires Constructible<Cont, const Alloc&>
>          explicit stack(const Alloc&);
>        ...
>     };

[Remark: This change should be done in sync with the resolution of paper N2819]

### 977. insert iterators inefficient for expensive to move types

Section: 24.7 [insert.iterators] Status: Open Submitter: Howard Hinnant Opened: 2009-02-02 Last modified: 2009-05-23

View other active issues in [insert.iterators].

View all other issues in [insert.iterators].

View all issues with Open status.

Discussion:

The new concepts for the insert iterators mandate an extra copy when inserting an lvalue:

>     requires CopyConstructible<Cont::value_type>
>       back_insert_iterator<Cont>&
>       operator=(const Cont::value_type& value);

> > -1- Effects: `push_back(*container, Cont::value_type(value));`

The reason is to convert `value` into an rvalue because the current `BackInsertionContainer` concept only handles `push_back`-ing rvalues:

>     concept BackInsertionContainer<typename C> : Container<C> {
>       void push_back(C&, value_type&&);
>     }

Without the conversion of `value` to an rvalue, the assignment operator fails to concept check.

A solution is to modify the `BackInsertionContainer` concept so that the client can pass in the parameter type for `push_back` similar to what is already done for the `OutputIterator` concept:

>     concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
>       : Container<C> {
>          void push_back(C&, Value);
>     }

This allows the assignment operator to be adjusted appropriately:

>     requires BackInsertionContainer<Cont, Cont::value_type const&> &&
>              CopyConstructible<Cont::value_type>
>       back_insert_iterator<Cont>&
>       operator=(const Cont::value_type& value);

> > -1- Effects: `push_back(*container, value);`

[ We may want to propagate this fix to other concepts such as `StackLikeContainer`. ]

[ Solution and wording collaborated on by Doug and Howard. ]

[ Batavia (2009-05): ]

> Howard notes that "these operations behaved efficiently until concepts were added."

> Alisdair is uncertain that the proposed resolution is syntactically correct.

> Move to Open, and recommend the issue be deferred until after the next Committee Draft is issued.

Proposed resolution:

Change 23.2.6.1 [container.concepts.free]:

>     concept FrontInsertionContainer<typename C, typename Value = C::value_type&&>
>         : Container<C> {
>       void push_front(C&, value_type&& Value);

>       axiom FrontInsertion(C c, value_type Value x) {
>         x == (push_front(c, x), front(c));
>       }
>     }

> ...

>     concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
>         : Container<C> {
>       void push_back(C&, value_type&& Value);
>     }

> ...

>     concept InsertionContainer<typename C, typename Value = C::value_type&&>
>         : Container<C> {
>       iterator insert(C&, const_iterator, value_type&& Value);

>       axiom Insertion(C c, const_iterator position, value_type Value v) {
>         v == *insert(c, position, v);
>       }
>     }

Change 23.2.6.2 [container.concepts.member]:

>     auto concept MemberFrontInsertionContainer<typename C, typename Value = C::value_type&&>
>         : MemberContainer<C> {
>       void C::push_front(value_type&& Value);

>       axiom MemberFrontInsertion(C c, value_type Value x) {
>         x == (c.push_front(x), c.front());
>       }
>     }

> ...

>     auto concept MemberBackInsertionContainer<typename C, typename Value = C::value_type&&>
>         : MemberContainer<C> {
>       void C::push_back(value_type&& Value);
>     }

> ...

>     auto concept MemberInsertionContainer<typename C, typename Value = C::value_type&&>
>         : MemberContainer<C> {
>       iterator C::insert(const_iterator, value_type&& Value);

>       axiom MemberInsertion(C c, const_iterator position, value_type Value v) {
>         v == *c.insert(position, v);
>       }
>     }

Change 23.2.6.3 [container.concepts.maps]:

>     template <MemberFrontInsertionContainer C, typename Value = C::value_type&&>
>     concept_map FrontInsertionContainer<C, Value> {
>       typedef Container<C>::value_type value_type;

>       void push_front(C& c, value_type&& Value v) { c.push_front(static_cast<value_type&& Value>(v)); }
>     }

> ...

>     template <MemberBackInsertionContainer C, typename Value = C::value_type&&>
>     concept_map BackInsertionContainer<C, Value> {
>       typedef Container<C>::value_type value_type;

>       void push_back(C& c, value_type&& Value v) { c.push_back(static_cast<value_type&& Value>(v)); }
>     }

> ...

>     template <MemberInsertionContainer C, typename Value = C::value_type&&>
>     concept_map InsertionContainer<C, Value> {
>       typedef Container<C>::value_type value_type;
>       Container<C>::iterator insert(C& c, Container<C>::const_iterator i, value_type&& Value v)
>       { return c.insert(i, static_cast<value_type&& Value>(v)); }
>     }

Change 24.7.1 [back.insert.iterator]:

>     template <BackInsertionContainer Cont>
>     class back_insert_iterator {
>       ...
>       requires BackInsertionContainer<Cont, const Cont::value_type&>
>                CopyConstructible<Cont::value_type>
>         back_insert_iterator<Cont>&
>           operator=(const Cont::value_type& value);
>       ...

Change 24.7.2.2 [back.insert.iter.op=]:

>     requires BackInsertionContainer<Cont, const Cont::value_type&>
>              CopyConstructible<Cont::value_type>
>       back_insert_iterator<Cont>&
>         operator=(const Cont::value_type& value);

> > -1- Effects: `push_back(*container, Cont::value_type(value));`

Change 24.7.3 [front.insert.iterator]:

>     template <FrontInsertionContainer Cont>
>     class front_insert_iterator {
>       ...
>       requires FrontInsertionContainer<Cont, const Cont::value_type&>
>                CopyConstructible<Cont::value_type>
>         front_insert_iterator<Cont>&
>           operator=(const Cont::value_type& value);
>       ...

Change 24.7.4.2 [front.insert.iter.op=]:

>     requires FrontInsertionContainer<Cont, const Cont::value_type&>
>              CopyConstructible<Cont::value_type>
>       front_insert_iterator<Cont>&
>         operator=(const Cont::value_type& value);

> > -1- Effects: `push_front(*container, Cont::value_type(value));`

Change 24.7.5 [insert.iterator]:

>     template <InsertionContainer Cont>
>     class insert_iterator {
>       ...
>       requires InsertionContainer<Cont, const Cont::value_type&>
>                CopyConstructible<Cont::value_type>
>         insert_iterator<Cont>&
>           operator=(const Cont::value_type& value);
>       ...

Change 24.7.6.2 [insert.iter.op=]:

>     requires InsertionContainer<Cont, const Cont::value_type&>
>              CopyConstructible<Cont::value_type>
>       insert_iterator<Cont>&
>         operator=(const Cont::value_type& value);

> > -1- Effects:

> > >     iter = insert(*container, iter, Cont::value_type(value));
> > >     ++iter;

### 978. Hashing smart pointers

Section: 20.7.17 [unord.hash] Status: Open Submitter: Alisdair Meredith Opened: 2009-02-02 Last modified: 2009-07-28

View other active issues in [unord.hash].

View all other issues in [unord.hash].

View all issues with Open status.

Discussion:

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. ]

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.17 [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.17 [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.9.2 [unique.ptr.single] Status: Review Submitter: Howard Hinnant Opened: 2009-02-10 Last modified: 2009-05-23

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

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

View all issues with Review 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.

Proposed resolution:

Change 20.8.9.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.9.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.9.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-05-23

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.

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: Open Submitter: Howard Hinnant Opened: 2009-02-18 Last modified: 2009-07-14

View all other issues in [refwrap].

View all issues with Open 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.

Proposed resolution:

Change the synopsis in 20.7 [function.objects]:

>     // 20.6.5, reference_wrapper:
>     template <ObjectType ReferentType T>
>       requires PointeeType<T>
>       class reference_wrapper;

>     template <ObjectType PointeeType T>
>       reference_wrapper<T> ref(T&);

>     template <ObjectType PointeeType T>
>       reference_wrapper<const T> cref(const T&);

>     template <ObjectType PointeeType T>
>       reference_wrapper<T> ref(reference_wrapper<T>);
>     template <ObjectType PointeeType T>
>       reference_wrapper<const T> cref(reference_wrapper<T>);

Change the synopsis in 20.7.5 [refwrap]:

>     template <ObjectType ReferentType T>
>       requires PointeeType<T>
>       class reference_wrapper
>        ...

Change the prototypes in 20.7.5.5 [refwrap.helpers]:

>     template <ObjectType PointeeType T>
>       reference_wrapper<T> ref(T&);
>     ...
>     template <ObjectType PointeeType T>
>       reference_wrapper<const T> cref(const T&);
>     ...
>     template <ObjectType PointeeType T>
>       reference_wrapper<T> ref(reference_wrapper<T>);
>     ...
>     template <ObjectType PointeeType T>
>       reference_wrapper<const T> cref(reference_wrapper<T>);

Rationale:

a) The occurrence of `T&` in the function signature auto-implies `std::ReferentType`, this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4

b) The occurrence of the constrained template `reference_wrapper<T>` in the remaining signatures lets kick in 14.11.1.2 [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.8.1 [object.addressof] Status: Open Submitter: Peter Dimov Opened: 2009-03-09 Last modified: 2009-07-14

View all other issues in [object.addressof].

View all issues with Open 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.

Proposed resolution:

Change the synopsis in 20.8 [memory]:

>     template <ObjectType PointeeType T>
>       T* addressof(T& r);

Change 20.8.8.1 [object.addressof]:

>     template <ObjectType PointeeType T>
>       T* addressof(T& r);

Rationale:

a) The occurrence of `T&` in the function signature auto-implies `std::ReferentType`, this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4

### 1004. Response to UK 179

Section: 17.6.3.8 [res.on.functions] Status: Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-18

View all other issues in [res.on.functions].

View all issues with Ready status.

Discussion:

Addresses UK 179

According to the 4th bullet there is a problem if "if any replacement function or handler function or destructor operation throws an exception". There should be no problem throwing exceptions so long as they are caught within the function.

[ Batavia (2009-05): ]

> The phrasing "throws an exception" is commonly used elsewhere to mean "throws or propagates an exception." Move to Open pending a possible more general resolution.

[ 2009-07 Frankfurt: ]

> Replace "propagates" in the proposed resolution with the phrase "exits via" and move to Ready.

Proposed resolution:

Change the 4th bullet of 17.6.3.8 [res.on.functions], p2:

> - if any replacement function or handler function or destructor operation throws exits via an exception, unless specifically allowed in the applicable Required behavior: paragraph.

### 1008. `nested_exception` wording unclear

Section: 18.8.6 [except.nested] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-04

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.

Proposed resolution:

### 1009. `InputIterator` post-increment dangerous

Section: 24.2.1 [iterator.iterators] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-28

View all issues with Open status.

Discussion:

Addresses UK 251

The post-increment operator is dangerous for a general InputIterator. The multi-pass guarantees that make it meaningful are defined as part of the ForwardIterator refinement. Any change will affect only constrained templates that have not yet been written, so should not break existing user iterators which remain free to add these operations. This change will also affect the generalised OutputIterator, although there is no percieved need for the post-increment operator in this case either.

[ 2009-07-28 Alisdair adds: ]

> We still think the issue is relevant, but needs totally rewording in non-concept language. We would like to see the issue retained as Open, rather than deferred as NAD Concepts. Review status is no longer appropriate.

Proposed resolution:

Change 24.2.1 [iterator.iterators]:

>     concept Iterator<typename X> : Semiregular<X> {
>       MoveConstructible reference = typename X::reference;
>       MoveConstructible postincrement_result;

>       requires HasDereference<postincrement_result>;

>       reference operator*(X&&);
>       X& operator++(X&);
>       postincrement_result operator++(X&, int);
>     }

> ...

>     postincrement_result operator++(X& r, int);

> > -3- Effects: equivalent to `{ X tmp = r; ++r; return tmp; }`.

Change 24.2.2 [input.iterators]:

>     concept InputIterator<typename X> : Iterator<X>, EqualityComparable<X> {
>       ObjectType value_type = typename X::value_type;
>       MoveConstructible pointer = typename X::pointer;

>       SignedIntegralLike difference_type = typename X::difference_type;

>       requires IntegralType<difference_type>
>             && Convertible<reference, const value_type &>;
>             && Convertible<pointer, const value_type*>;

>       requires Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;

>       pointer operator->(const X&);
>     }

Change 24.2.3 [output.iterators]:

>     auto concept OutputIterator<typename X, typename Value> {
>       requires Iterator<X>;

>       typename reference = Iterator<X>::reference;
>       typename postincrement_result = Iterator<X>::postincrement_result;
>       requires SameType<reference, Iterator<X>::reference>
>             && SameType<postincrement_result, Iterator<X>::postincrement_result>
>             && Convertible<postincrement_result, const X&>
>             && HasAssign<reference, Value>
>             && HasAssign<HasDereference<postincrement_result>::result_type, Value>;
>     }

Change 24.2.4 [forward.iterators]:

[ See 1084 which is attempting to change this same area in a compatible way. ]

>     concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> {
>       requires Convertible<postincrement_result, const X&>;

>       MoveConstructible postincrement_result;
>       requires HasDereference<postincrement_result>
>             && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;

>       postincrement_result operator++(X&, int);

>       axiom MultiPass(X a, X b) {
>         if (a == b) *a == *b;
>         if (a == b) ++a == ++b;
>       }
>     }

> > -4- ...

>     postincrement_result operator++(X& r, int);

> > -5- Effects: equivalent to `{ X tmp = r; ++r; return tmp; }`.

### 1011. `next/prev` wrong iterator type

Section: 24.4 [iterator.operations] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-14

View other active issues in [iterator.operations].

View all other issues in [iterator.operations].

View all issues with Open 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.

Proposed resolution:

Change [iterator.synopsis]:

>     template <InputIterator ForwardIterator Iter>
>       Iter next(Iter x,
>         Iter::difference_type n = 1);

Change 24.4 [iterator.operations], p6:

>     template <InputIterator ForwardIterator Iter>
>       Iter next(Iter x,
>         Iter::difference_type n = 1);

### 1012. `reverse_iterator` default ctor should value initialize

Section: 24.5.1.2.1 [reverse.iter.cons] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-18

View all issues with Tentatively Ready status.

Discussion:

Addresses UK 277

The default constructor default-initializes current, rather than value-initializes. This means that when Iterator corresponds to a trivial type, the current member is left un-initialized, even when the user explictly requests value intialization! At this point, it is not safe to perform any operations on the reverse_iterator other than assign it a new value or destroy it. Note that this does correspond to the basic definition of a singular iterator.

[ Summit: ]

> Agree with option i.

Related issue: 408

[ Batavia (2009-05): ]

> We believe this should be revisited in conjunction with issue 408, which nearly duplicates this issue. Move to Open.

[ 2009-07 post-Frankfurt: ]

> Change "constructed" to "initialized" in two places in the proposed resolution.

> Move to Tentatively Ready.

Proposed resolution:

Change [reverse.iter.con]:

>     reverse_iterator();

> > -1- Effects: Default Value initializes `current`. Iterator operations applied to the resulting iterator have defined behavior if and only if the corresponding operations are defined on a default constructed value initialized iterator of type `Iterator`.

Change 24.5.2.2.1 [move.iter.op.const]:

>     move_iterator();

> > -1- Effects: Constructs a `move_iterator`, default value initializing `current`. Iterator operations applied to the resulting iterator have defined behavior if and only if the corresponding operations are defined on a value initialized iterator of type `Iterator`.

### 1019. Response to UK 205

Section: 20.6.3 [meta.help] Status: Tentatively Ready Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-18

View all other issues in [meta.help].

View all issues with Tentatively Ready status.

Discussion:

Addresses UK 205

`integral_constant` objects should be usable in integral-constant-expressions. The addition to the language of literal types and the enhanced rules for constant expressions make this possible.

[ Batavia (2009-05): ]

> We agree that the `static` data member ought be declared `constexpr`, but do not see a need for the proposed `operator value_type()`. (A use case would be helpful.) Move to Open.

[ 2009-05-23 Alisdair adds: ]

> The motivating case in my mind is that we can then use `true_type` and `false_type` as integral Boolean expressions, for example inside a `static_assert` declaration. In that sense it is purely a matter of style.

> Note that Boost has applied the non-explicit conversion operator for many years as it has valuable properties for extension into other metaprogramming libraries, such as MPL. If additional rationale is desired I will poll the Boost lists for why this extension was originally applied. I would argue that explicit conversion is more appropriate for 0x though.

[ 2009-07-04 Howard adds: ]

> Here's a use case which demonstrates the syntactic niceness which Alisdair describes:

> >     #define requires(...) class = typename std::enable_if<(__VA_ARGS__)>::type

> >     template <class T, class U,
> >         requires(!is_lvalue_reference<T>() ||
> >                   is_lvalue_reference<T>() && is_lvalue_reference<U>()),
> >         requires(is_same<typename base_type<T>::type,
> >                          typename base_type<U>::type>)>
> >     inline
> >     T&&
> >     forward(U&& t)
> >     {
> >         return static_cast<T&&>(t);
> >     }

[ 2009-07 post-Frankfurt: ]

> Move to Tentatively Ready.

Proposed resolution:

Add to the `integral_constant` struct definition in 20.6.3 [meta.help]:

>     template <class T, T v>
>     struct integral_constant {
>       static constexpr T value = v;
>       typedef T value_type;
>       typedef integral_constant<T,v> type;
>       constexpr operator value_type() { return value; }
>     };

### 1020. Response to UK 204

Section: 20.6.7 [meta.trans.other] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-03-12

View other active issues in [meta.trans.other].

View all other issues in [meta.trans.other].

View all issues with Open status.

Discussion:

Addresses UK 204

It is not possible to create a variant union based on a parameter pack expansion, e.g. to implement a classic discriminated union template.

Original proposed resolutuion:

Restore `aligned_union` template that was removed by LWG issue 856.

[ Summit: ]

> Agree. The need for `aligned_union` is compelling enough to reinstate.

[ Post Summit, Alisdair adds: ]

> paper N2843 proposes an extension to the `[[align]]` attribute that further diminishes the need for this template. Recommend NAD.

Proposed resolution:

### 1030. Response to JP 44

Section: 20.8.10.6 [util.smartptr.shared.atomic] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-18

View all issues with Open 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.

Proposed resolution:

### 1031. Response to US 78

Section: 20.8.10.2 [util.smartptr.shared] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-03-11 Last modified: 2009-07-26

View other active issues in [util.smartptr.shared].

View all other issues in [util.smartptr.shared].

View all issues with Tentatively NAD Future status.

Discussion:

Addresses US 78

There is presently no way to convert directly from a `shared_ptr` to a `unique_ptr`. Add an interface that performs the conversion.

[ Summit: ]

> We look forward to a paper on this topic. We recommend no action until a paper is available. We believe that the shared pointer must use the default deleter for the conversion to succeed.

[ Peter Dimov adds: ]

> This is basically a request for `shared_ptr<>::release` in disguise, with all the associated problems. Not a good idea.

[ 2009-07 post-Frankfurt: ]

> The rationale for the omission of a release() member function from shared_ptr is given in: http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm

> The implementation of such a member is non-trivial (and maybe impossible), because it would need to account for the deleter.

[ 2009-07-26 Howard sets to Tentatively NAD Future. ]

> I took an online poll and got 3 votes for NAD and 3 for NAD Future. Personally I prefer NAD Future as this does refer to an extension that could conceivably be considered beyond C++0X.

> However such an extension would need to solve a couple of problems:

> 1. What is the interface for such a conversion when the `shared_ptr` does not have unique ownership? Throw an exception? Create a null `unique_ptr`? Undefined behavior?

> 2. How does one handle custom deleters given to the `shared_ptr` constructor?

>    I do not believe it is possible to implement a general answer to this question. The `shared_ptr` deleter is a run time (or construction time) characteristic. The `unique_ptr` deleter is a compile time characteristic. In general one can not know to what type of `unqiue_ptr` you are converting to.

>    One answer is for the user of the conversion to specify the deleter type and perhaps throw an exception if the specification turns out to be incorrect.

>    Another answer is for the conversion to only be valid when the underlying deleter is `default_delete`. We would probalby need to specify that this is indeed the underlying deleter of a `shared_ptr` when a custom deleter is not given in the constructor.

> At any rate, there are non-trivial design issues which would need to be implemented and tested in the field for usability prior to standardization.

Proposed resolution:

### 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-07-18

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.

Proposed resolution:

### 1035. Response to UK 226

Section: 23.2.1 [container.requirements.general] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-08-01

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 226

`<array>` must be added to this list. In particular it doesn't satisfy: - no `swap()` function invalidates any references, pointers, or iterators referring to the elements of the containers being swapped. and probably doesn't satisfy: - no `swap()` function throws an exception.

If `<array>` remains a container, this will have to also reference `array`, which will then have to say which of these points it satisfies.

[ Summit: ]

> Agree. The proposed resolution is incomplete. Further work required.

[ 2009-05-01 Daniel adds: ]

> Issue 1099 also suggests adding move constructor to this.

[ 2009-07 post-Frankfurt: ]

> Howard is to draft a note that explains what happens to references.

[ 2009-08-01 Howard provided wording. ]

Proposed resolution:

Add a paragraph to 23.3.1.2 [array.special]:

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

> > Effects:

> > >     swap_ranges(x.begin(), x.end(), y.begin());

> > [Note: Outstanding iterators, references and pointers may be invalidated. — end note]

### 1041. Response to UK 239

Section: 23.2.4 [associative.reqmts] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-07-18

View all other issues in [associative.reqmts].

View all issues with Open status.

Discussion:

Addresses UK 239

It is not possible to take a move-only key out of an unordered container, such as (`multi`)`set` or (`multi`)`map`, or the new unordered containers.

Add below `a.erase(q)`, `a.extract(q)`, with the following notation:

`a.extract(q)>`, Return type `pair<key, iterator>` Extracts the element pointed to by `q` and erases it from the `set`. Returns a `pair` containing the value pointed to by `q` and an `iterator` pointing to the element immediately following `q` prior to the element being erased. If no such element exists,returns `a.end()`.

[ Summit: ]

> We look forward to a paper on this topic. We recommend no action until a paper is available. The paper would need to address exception safety.

[ Post Summit Alisdair adds: ]

> Would `value_type` be a better return type than `key_type`?

[ 2009-07 post-Frankfurt: ]

> Leave Open. Alisdair to contact Chris Jefferson about this.

Proposed resolution:

In 23.2.4 [associative.reqmts] Table 85, add:

> Table 85 -- Associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `a.erase(q)` | ... | ... | ...
> `a.extract(q)` | `pair<key_type, iterator>` | Extracts the element pointed to by `q` and erases it from the `set`. Returns a `pair` containing the value pointed to by `q` and an `iterator` pointing to the element immediately following `q` prior to the element being erased. If no such element exists, returns `a.end()`. | amortized constant

In 23.2.5 [unord.req] Table 87, add:

> Table 87 -- Unordered associative container requirements (in addition to container)
> Expression | Return type | Assertion/note pre-/post-condition | Complexity
> --- | --- | --- | ---
> `a.erase(q)` | ... | ... | ...
> `a.extract(q)` | `pair<key_type, iterator>` | Extracts the element pointed to by `q` and erases it from the `set`. Returns a `pair` containing the value pointed to by `q` and an `iterator` pointing to the element immediately following `q` prior to the element being erased. If no such element exists, returns `a.end()`. | amortized constant

### 1042. Response to UK 244

Section: 23.3 [sequences] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-07-18

View all other issues in [sequences].

View all issues with Open status.

Discussion:

Addresses UK 244

The validity of the expression `&a[n] == &a[0] + n` is contingent on `operator&` doing the "right thing" (as captured by the `CopyConstructible` requirements in table 30 in C++2003). However this constraint has been lost in the Concepts of C++0x. This applies to `vector` and `array` (it actually applies to `string` also, but that's a different chapter, so I'll file a separate comment there and cross-reference).

Suggested solution:

Define a `ContiguousStrorage` and apply it to `vector`, `array` and `string`.

[ Summit: ]

> Agree with the issue but not the details of the proposed solution. Walter to provide wording for the new concept.

[ Post Summit Alisdair adds: ]

> Another LWG subgroup wondered if this concept should extend to `complex<T>`, and so not be built on the container concept at all?

[ 2009-07 post-Frankfurt: ]

> Leave Open, pending a post-Concepts Working Draft.

Proposed resolution:

Add to `<container_concepts>` synopsis in 23.2.6 [container.concepts]

>     concept< typename C > ContiguousStorageContainer see below;

Add a new section to the end of 23.2.6 [container.concepts]

> 23.1.6.x ContiguousStorageContainer concept [container.concepts.contiguous]

>     concept ContiguousStorageContainer< typename C >
>       : Container<C>
>     {
>       value_type* data(C&);

>       axiom Contiguity(C& c, size_type i) {
>         if( i < size(c) ) {
>              addressof( * (data(c) + i) )
>           == addressof( * advance(data(c), i) );
>         }
>       }
>     }

> The `ContiguousStorageContainer` concept describes a container whose elements are allocated in a single region of memory, and are stored sequentially without intervening padding other than to meet alignment requirements. For example, the elements may be stored in a single array of suitable length.

>     value_type * data( C& );

> > Returns: a pointer to the first element in the region of storage. Result is unspecified for an empty container.

Change 23.3.1 [array] p1:

> -1- The header `<array>` defines a class template for storing fixed-size sequences of objects. An `array` supports random access iterators. An instance of `array<T, N>` stores `N` elements of type `T`, so that `size() == N` is an invariant. The elements of an `array` are stored contiguously, meaning that if `a` is an `array<T, N>` then it obeys the identity `&a[n] == &a[0] + n` for all `0 <= n < N` satisfies the concept `ContiguousStorageContainer< array<T, N>>`.

Add to the synopsis in 23.3.1 [array]:

>         ...
>         T * data();
>         const T * data() const;
>       };

>       template< typename T, size_t N >
>         concept_map ContiguousStorageContainer< array<T, N>> {};
>     }

Change 23.3.6 [vector] p1:

> A `vector` is a sequence container that supports random access iterators. In addition, it supports (amortized) constant time insert and erase operations at the end; insert and erase in the middle take linear time. Storage management is handled automatically, though hints can be given to improve efficiency. The elements of a vector are stored contiguously, meaning that if `v` is a `vector<T, Alloc>` (where `T` is some type other than `bool`), then it obeys the identity `&v[n] == &v[0] + n` for all `0 <= n < v.size()` satisfies the concept `ContiguousStorageContainer< vector< T, Alloc>>`.

Add at the end of the synopsis in 23.3.6 [vector] p2:

>     template< typename T, typename A >
>       requires !SameType< T, bool >
>       concept_map ContiguousStorageContainer< vector<T, A>> {};

### 1043. Response to US 91

Section: 29.6 [atomics.types.operations] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-07-18

View other active issues in [atomics.types.operations].

View all other issues in [atomics.types.operations].

View all issues with Review status.

Discussion:

Addresses US 91

It is unclear whether or not a failed `compare_exchange` is a RMW operation (as used in 1.10 [intro.multithread]).

Suggested solution:

Make failing `compare_exchange` operations not be RMW.

[ Anthony Williams adds: ]

> In 29.6 [atomics.types.operations] p18 it says that "These operations are atomic read-modify-write operations" (final sentence). This is overly restrictive on the implementations of `compare_exchange_weak` and `compare_exchange_strong` on platforms without a native CAS instruction.

[ Summit: ]

> Group agrees with the resolution as proposed by Anthony Williams in the attached note.

[ Batavia (2009-05): ]

> We recommend the proposed resolution be reviewed by members of the Concurrency Subgroup.

[ 2009-07 post-Frankfurt: ]

> This is likely to be addressed by Lawrence's upcoming paper. He will adopt the proposed resolution.

Proposed resolution:

Change 29.6 [atomics.types.operations] p18:

> -18- Effects: Atomically, compares the value pointed to by `object` or by `this` for equality with that in `expected`, and if true, replaces the value pointed to by `object` or by `this` with desired, and if false, updates the value in `expected` with the value pointed to by `object` or by `this`. Further, if the comparison is true, memory is affected according to the value of `success`, and if the comparison is false, memory is affected according to the value of `failure`. When only one `memory_order` argument is supplied, the value of `success` is `order`, and the value of `failure` is `order` except that a value of `memory_order_acq_rel` shall be replaced by the value `memory_order_acquire` and a value of `memory_order_release` shall be replaced by the value `memory_order_relaxed`. If the comparison is `true`, T these operations are atomic read-modify-write operations (1.10). If the comparison is `false`, these operations are atomic load operations.

### 1046. Response to UK 329

Section: 30.6 [futures] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13

View all issues with Open status.

Discussion:

Addresses UK 329

`future`, `promise` and `packaged_task` provide a framework for creating future values, but a simple function to tie all three components together is missing. Note that we only need a *simple* facility for C++0x. Advanced thread pools are to be left for TR2.

Simple Proposal:

Provide a simple function along the lines of:

>     template< typename F, typename ... Args >
>       requires Callable< F, Args... >
>         future< Callable::result_type > async( F&& f, Args && ... );

Semantics are similar to creating a `thread` object with a `packaged_task` invoking `f` with `forward<Args>(args...)` but details are left unspecified to allow different scheduling and thread spawning implementations.

It is unspecified whether a task submitted to async is run on its own thread or a thread previously used for another async task. If a call to `async` succeeds, it shall be safe to wait for it from any thread.

The state of `thread_local` variables shall be preserved during `async` calls.

No two incomplete async tasks shall see the same value of `this_thread::get_id()`.

[Note: this effectively forces new tasks to be run on a new thread, or a fixed-size pool with no queue. If the library is unable to spawn a new thread or there are no free worker threads then the `async` call should fail. --end note]

[ Summit: ]

> The concurrency subgroup has revisited this issue and decided that it could be considered a defect according to the Kona compromise. A task group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a paper for Frankfort proposing a simple asynchronous launch facility returning a `future`. It was agreed that the callable must be run on a separate thread from the caller, but not necessarily a brand-new thread. The proposal might or might not allow for an implementation that uses fixed-size or unlimited thread pools.

> Bjarne in c++std-lib-23121: I think that what we agreed was that to avoid deadlock `async()` would almost certainly be specified to launch in a different thread from the thread that executed `async()`, but I don't think it was a specific design constraint.

Proposed resolution:

### 1047. Response to UK 334

Section: 30.6.5 [futures.unique_future] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-05-23

View other active issues in [futures.unique_future].

View all other issues in [futures.unique_future].

View all issues with Review status.

Discussion:

Addresses UK 334

Behaviour of `get()` is undefined if calling `get()` while not `is_ready()`. The intent is that `get()` is a blocking call, and will wait for the future to become ready.

[ Summit: ]

> Agree, move to Review.

[ 2009-04-03 Thomas J. Gritzan adds: ]

> This issue also applies to `shared_future::get()`.

> Suggested wording:

> Add a paragraph to [futures.shared_future]:

> >     void shared_future<void>::get() const;

> > > Effects: If `is_ready()` would return `false`, block on the asynchronous result associated with `*this`.

[ Batavia (2009-05): ]

> It is not clear to us that this is an issue, because the proposed resolution's Effects clause seems to duplicate information already present in the Synchronization clause. Keep in Review status.

Proposed resolution:

Add a paragraph to 30.6.5 [futures.unique_future]:

>     R&& unique_future::get();
>     R& unique_future<R&>::get();
>     void unique_future<void>::get();

> > Note:...

> > Effects: If `is_ready()` would return `false`, block on the asynchronous result associated with `*this`.

> > Synchronization: if `*this` is associated with a `promise` object, the completion of `set_value()` or `set_exception()` to that `promise` happens before (1.10) `get()` returns.

### 1048. Response to UK 335

Section: 30.6.5 [futures.unique_future] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13

View other active issues in [futures.unique_future].

View all other issues in [futures.unique_future].

View all issues with Open status.

Discussion:

Addresses UK 335

`std::unique_future` is `MoveConstructible`, so you can transfer the association with an asynchronous result from one instance to another. However, there is no way to determine whether or not an instance has been moved from, and therefore whether or not it is safe to wait for it.

>     std::promise<int> p;
>     std::unique_future<int> uf(p.get_future());
>     std::unique_future<int> uf2(std::move(uf));
>     uf.wait(); // oops, uf has no result to wait for.

Suggest we add a `waitable()` function to `unique_future` (and `shared_future`) akin to `std::thread::joinable()`, which returns `true` if there is an associated result to wait for (whether or not it is ready).

Then we can say:

>     if(uf.waitable()) uf.wait();

[ Summit: ]

> Create an issue. Requires input from Howard. Probably NAD.

[ Post Summit, Howard thows in his two cents: ]

> Here is a copy/paste of my last prototype of `unique_future` which was several years ago. At that time I was calling `unique_future` `future`:

> >     template <class R>
> >     class future
> >     {
> >     public:
> >         typedef R result_type;
> >     private:
> >         future(const future&);// = delete;
> >         future& operator=(const future&);// = delete;

> >         template <class R1, class F1> friend class prommise;
> >     public:
> >         future();
> >         ~future();

> >         future(future&& f);
> >         future& operator=(future&& f);

> >         void swap(future&& f);

> >         bool joinable() const;
> >         bool is_normal() const;
> >         bool is_exceptional() const;
> >         bool is_ready() const;

> >         R get();

> >         void join();
> >         template <class ElapsedTime>
> >             bool timed_join(const ElapsedTime&);
> >     };

> `shared_future` had a similar interface. I intentionally reused the `thread` interface where possible to lessen the learning curve std::lib clients will be faced with.

Proposed resolution:

### 1049. Response to UK 339

Section: 30.6.4 [futures.promise] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-05-23

View other active issues in [futures.promise].

View all other issues in [futures.promise].

View all issues with Review status.

Discussion:

Addresses UK 339

Move assignment is goiing in the wrong direction, assigning from `*this` to the passed rvalue, and then returning a reference to an unusable `*this`.

[ Summit: ]

> Agree, move to Review.

[ Batavia (2009-05): ]

> We recommend deferring this issue until after Detlef's paper (on futures) has been issued.

Proposed resolution:

Strike 30.6.4 [futures.promise] p6 and change p7:

>     promise& operator=(promise&& rhs);

> > -6- Effects: move assigns its associated state to `rhs`.

> > -7- Postcondition: `*this` has no associated state. associated state of `*this` is the same as the associated state of `rhs` before the call. `rhs` has no associated state.

### 1050. Response to UK 340

Section: 30.6.4 [futures.promise] Status: Review Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-05-23

View other active issues in [futures.promise].

View all other issues in [futures.promise].

View all issues with Review status.

Discussion:

Addresses UK 340

There is an implied postcondition for `get_future()` that the state of the `promise` is transferred into the `future` leaving the `promise` with no associated state. It should be spelled out.

[ Summit: ]

> Agree, move to Review.

[ 2009-04-03 Thomas J. Gritzan adds: ]

> `promise::get_future()` must not invalidate the state of the promise object.

> A promise is used like this:

> >     promise<int> p;
> >     unique_future<int> f = p.get_future();
> >     // post 'p' to a thread that calculates a value
> >     // use 'f' to retrieve the value.

> So `get_future()` must return an object that shares the same associated state with `*this`.

> But still, this function should throw an `future_already_retrieved` error when it is called twice.

> `packaged_task::get_future()` throws `std::bad_function_call` if its `future` was already retrieved. It should throw `future_error(future_already_retrieved)`, too.

> Suggested resolution:

> Replace p12/p13 30.6.4 [futures.promise]:

> > -12- Throws: `future_error` if `*this` has no associated state the `future` has already been retrieved.

> > -13- Error conditions: `future_already_retrieved` if `*this` has no associated state the `future` associated with the associated state has already been retrieved.

> > Postcondition: The returned object and `*this` share the associated state.

> Replace p14 30.6.7 [futures.task]:

> > -14- Throws: `std::bad_function_call future_error` if the future associated with the task has already been retrieved.

> > Error conditions: `future_already_retrieved` if the `future` associated with the task has already been retrieved.

> > Postcondition: The returned object and `*this` share the associated task.

[ Batavia (2009-05): ]

> Keep in Review status pending Detlef's forthcoming paper on futures.

Proposed resolution:

Add after p13 30.6.4 [futures.promise]:

>     unique_future<R> get_future();

> > -13- ...

> > Postcondition: `*this` has no associated state.

### 1051. Response to UK 279

Section: 24.5.1.2.12 [reverse.iter.opindex], 24.5.2.2.12 [move.iter.op.index] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-07-27

View all issues with Open status.

Discussion:

Addresses UK 279

The reason the return type became unspecified is LWG issue 386. This reasoning no longer applies as there are at least two ways to get the right return type with the new language facilities added since the previous standard.

Proposal: Specify the return type using either decltype or the Iter concept_map.

[ Summit: ]

> Under discussion. This is a general question about all iterator adapters.

[ Howard adds post Summit: ]

> I am requesting test cases to demonstrate a position.

[ 2009-07-24 Daniel adds: ]

> I recommend NAD. Without concepts we can no longer restrict this member in a trivial way. Using `decltype` the declaration would be along the lines of

> >     static const Iter& __base(); // not defined
> >     auto operator[](difference_type n) const -> decltype(__base()[-n-1]);

> but once `reverse_iterator` is instantiated for some given type `Iter` which cannot form a well-formed expression `__base()[-n-1]` this would cause an ill-formed function declaration, diagnostic required, and no silent SFINAE elimination.

Proposed resolution:

### 1052. Response to UK 281

Section: 24.5.1.2.5 [reverse.iter.opref] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-08-01

View all issues with Open 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: ]

Proposed resolution:

Change synopsis in 24.5.1.1 [reverse.iterator]:

>     template <class Iterator>
>     class reverse_iterator {
>       ...
>       typedef typename iterator_traits<Iterator>::pointer pointer;

Change 24.5.1.2.5 [reverse.iter.opref]:

>     pointer operator->() const;

> > Returns:

> > >     &(operator*());
> > >     this->tmp = current;
> > >     --this->tmp;
> > >     return this->tmp;

### 1053. Response to UK 295

Section: 25 [algorithms] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-03-13

View other active issues in [algorithms].

View all other issues in [algorithms].

View all issues with Open status.

Discussion:

Addresses UK 295

There is a level of redundancy in the library specification for many algorithms that can be eliminated with the combination of concepts and default parameters for function templates. Eliminating redundancy simplified specification and reduces the risk of introducing accidental inconsistencies.

Proposed resolution: Adopt N2743.

[ Summit: ]

> NAD, this change would break code that takes the address of an algorithm.

[ Post Summit Alisdair adds: ]

> Request 'Open'. The issues in the paper go beyond just reducing the number of signatures, but cover unifying the idea of the ordering operation used by algorithms, containers and other library components. At least, it takes a first pass at the problem.

> For me (personally) that was the more important part of the paper, and not clearly addressed by the Summit resolution.

Proposed resolution:

### 1054. `forward` broken

Section: 20.3.2 [forward] Status: Open Submitter: Howard Hinnant Opened: 2009-03-13 Last modified: 2009-08-02

View other active issues in [forward].

View all other issues in [forward].

View all issues with Open status.

Discussion:

This is a placeholder issue to track the fact that we (well I) put the standard into an inconsistent state by requesting that we accept N2844 except for the proposed changes to [forward].

There will exist in the post meeting mailing N2835 which in its current state reflects the state of affairs prior to the Summit meeting. I hope to update it in time for the post Summit mailing, but as I write this issue I have not done so yet.

[ Batavia (2009-05): ]

> Move to Open, awaiting the promised paper.

[ 2009-08-02 Howard adds: ]

> My current preferred solution is:

> >     template <class T>
> >     struct __base_type
> >     {
> >        typedef typename remove_cv<typename remove_reference<T>::type>::type type;
> >     };

> >     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 __base_type<T>::type,
> >                     typename __base_type<U>::type>::value>::type>
> >     inline
> >     T&&
> >     forward(U&& t)
> >     {
> >        return static_cast<T&&>(t);
> >     }

> This has been tested by Bill, Jason and myself.

> It allows the following lvalue/rvalue casts:

> 1. Cast an lvalue `t` to an lvalue `T` (identity).
> 2. Cast an lvalue `t` to an rvalue `T`.
> 3. Cast an rvalue `t` to an rvalue `T` (identity).

> It disallows:

> 1. Cast an rvalue `t` to an lvalue `T`.
> 2. Cast one type `t` to another type `T` (such as `int` to `double`).

> "a." is disallowed as it can easily lead to dangling references. "b." is disallowed as this function is meant to only change the lvalue/rvalue characteristic of an expression.

> Jason has expressed concern that "b." is not dangerous and is useful in contexts where you want to "forward" a derived type as a base type. I find this use case neither dangerous, nor compelling. I.e. I could live with or without the "b." constraint. Without it, forward would look like:

> >     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>
> >     inline
> >     T&&
> >     forward(U&& t)
> >     {
> >        return static_cast<T&&>(t);
> >     }

> Or possibly:

> >     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_base_of<typename __base_type<U>::type,
> >                        typename __base_type<T>::type>::value>::type>
> >     inline
> >     T&&
> >     forward(U&& t)
> >     {
> >        return static_cast<T&&>(t);
> >     }

> The "promised paper" is not in the post-Frankfurt mailing only because I'm waiting for the non-concepts draft. But I'm hoping that by adding this information here I can keep people up to date.

Proposed resolution:

### 1055. Response to UK 98

Section: 20.6.7 [meta.trans.other] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-05-23

View other active issues in [meta.trans.other].

View all other issues in [meta.trans.other].

View all issues with Open status.

Discussion:

Addresses UK 98

It would be useful to be able to determine the underlying type of an arbitrary enumeration type. This would allow safe casting to an integral type (especially needed for scoped enums, which do not promote), and would allow use of `numeric_limits`. In general it makes generic programming with enumerations easier.

[ Batavia (2009-05): ]

> Pete observes (and Tom concurs) that the proposed resolution seems to require compiler support for its implementation, as it seems necessary to look at the range of values of the enumerated type. To a first approximation, a library solution could give an answer based on the size of the type. If the user has specialized `numeric_limits` for the enumerated type, then the library might be able to do better, but there is no such requirement. Keep status as Open and solicit input from CWG.

[ 2009-05-23 Alisdair adds: ]

> Just to confirm that the BSI originator of this comment assumed it did indeed imply a compiler intrinsic. Rather than request a Core extension, it seemed in keeping with that the type traits interface provides a library API to unspecified compiler features - where we require several other traits (e.g. `has_trivial_*`) to get the 'right' answer now, unlike in TR1.

Proposed resolution:

Add a new row to the table in 20.6.7 [meta.trans.other]:

> Table 41 -- Other transformations
> Template | Condition | Comments
> --- | --- | ---
> `template< class T > struct enum_base;` | `T` shall be an enumeration type (7.2 [dcl.enum]) | The member typedef `type` shall name the underlying type of the enum `T`.

### 1056. Must all Engines and Distributions be Streamable?

Section: 26.5 [rand] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-12 Last modified: 2009-05-31

View all other issues in [rand].

View all issues with Open 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.

Proposed resolution:

### 1062. Missing insert_iterator for stacks/queues

Section: 24.7 [insert.iterators] Status: Tentatively NAD Future Submitter: Alisdair Meredith Opened: 2009-03-13 Last modified: 2009-07-29

View other active issues in [insert.iterators].

View all other issues in [insert.iterators].

View all issues with Tentatively NAD Future status.

Discussion:

It is odd that we have an iterator to insert into a `vector`, but not an iterator to insert into a `vector` that is adapted as a `stack`. The standard container adapters all have a common interface to `push` and `pop` so it should be simple to create an iterator adapter to complete the library support.

We should provide an `AdaptedContainer` concept supporting `push` and `pop` operations. Create a new insert iterator and factory function that inserts values into the container by calling `push`.

[ Batavia (2009-05): ]

> Walter recommends NAD Future.

> Move to Open, and recommend deferring the issue until after the next Committee Draft is issued.

[ 2009-07-29 Howard moves to Tentatively NAD Future. ]

> A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future.

Proposed resolution:

### 1064. Response to UK 152

Section: 17.3.15 [defns.obj.state] Status: Open Submitter: Howard Hinnant Opened: 2009-03-15 Last modified: 2009-03-15

View all issues with Open status.

Discussion:

Addresses UK 152

Object state is using a definition of object (instance of a class) from outside the standard, rather than the 'region of storage' definiton in 1.8 [intro.object]p1

[ Summit: ]

> We think we're removing this; See X [func.referenceclosure.cons].

Proposed resolution:

### 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-05-23

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.

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-05-23

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.

Proposed resolution:

### 1071. is_bind_expression should derive from integral_constant<bool>

Section: 20.7.12.1.1 [func.bind.isbind] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-19 Last modified: 2009-05-31

View all issues with Open status.

Discussion:

Class template is_bind_expression 20.7.12.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.

Proposed resolution:

1. In 20.7.12.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.12.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.12.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.12.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>`.

### 1075. Response to US 65, US 74.1

Section: 20 [utilities], 23 [containers] Status: Open Submitter: Alan Talbot Opened: 2009-03-20 Last modified: 2009-06-10

View all other issues in [utilities].

View all issues with Open status.

Discussion:

Addresses US 65 and US 74.1

US 65:

> Scoped allocators and allocator propagation traits add a small amount of utility at the cost of a great deal of machinery. The machinery is user visible, and it extends to library components that don't have any obvious connection to allocators, including basic concepts and simple components like `pair` and `tuple`.

> Suggested resolution:

> Sketch of proposed resolution: Eliminate scoped allocators, replace allocator propagation traits with a simple uniform rule (e.g. always propagate on copy and move), remove all mention of allocators from components that don't explicitly allocate memory (e.g. pair), and adjust container interfaces to reflect this simplification.

> Components that I propose eliminating include HasAllocatorType, is_scoped_allocator, allocator_propagation_map, scoped_allocator_adaptor, and ConstructibleAsElement.

US 74.1:

> Scoped allocators represent a poor trade-off for standardization, since (1) scoped-allocator--aware containers can be implemented outside the C++ standard library but used with its algorithms, (2) scoped allocators only benefit a tiny proportion of the C++ community (since few C++ programmers even use today's allocators), and (3) all C++ users, especially the vast majority of the C++ community that won't ever use scoped allocators are forced to cope with the interface complexity introduced by scoped allocators.

> In essence, the larger community will suffer to support a very small subset of the community who can already implement their own data structures outside of the standard library. Therefore, scoped allocators should be removed from the working paper.

> Some evidence of the complexity introduced by scoped allocators:

> > 20.3.3 [pairs], 20.5 [tuple]: Large increase in the number of pair and tuple constructors.

> > 23 [containers]: Confusing "AllocatableElement" requirements throughout.

> Suggested resolution:

> Remove support for scoped allocators from the working paper. This includes at least the following changes:

> > Remove 20.8.3 [allocator.element.concepts]

> > Remove 20.8.5 [allocator.adaptor]

> > Remove [construct.element]

> > In Clause 23 [containers]: replace requirements naming the `AllocatableElement` concept with requirements naming `CopyConstructible`, `MoveConstructible`, `DefaultConstructible`, or `Constructible`, as appropriate.

[ Post Summit Alan moved from NAD to Open. ]

[ 2009-05-15 Ganesh adds: ]

> The requirement `AllocatableElement` should not be replaced with `Constructible` on the `emplace_xxx()` functions as suggested. In the one-parameter case the `Constructible` requirement is not satisfied when the constructor is explicit (as per 14.10.2.1 [concept.map.fct], twelfth bullet) but we do want to allow explicit constructors in emplace, as the following example shows:

> >     vector<shared_ptr<int>> v;
> >     v.emplace_back(new int); // should be allowed

> If the issue is accepted and scoped allocators are removed, I suggest to add a new pair of concepts to 20.2.7 [concept.construct], namely:

> >     auto concept HasExplicitConstructor<typename T, typename... Args> {
> >      explicit T::T(Args...);
> >     }

> >     auto concept ExplicitConstructible<typename T, typename... Args>
> >      : HasExplicitConstructor<T, Args...>, NothrowDestructible<T>
> >     { }

> We should then use `ExplicitConstructible` as the requirement for all `emplace_xxx()` member functions.

> For coherence and consistency with the similar concepts `Convertible/ExplicitlyConvertible`, we might also consider changing `Constructible` to:

> >     auto concept Constructible<typename T, typename... Args>
> >      : HasConstructor<T, Args...>, ExplicitConstructible<T, Args...>
> >     { }

> Moreover, all emplace-related concepts in 23.2.6 [container.concepts] should also use `ExplicitConstructible` instead of `Constructible` in the definitions of their axioms. In fact the concepts in 23.2.6 [container.concepts] should be corrected even if the issue is not accepted.

> On the other hand, if the issue is not accepted, the scoped allocator adaptors should be fixed because the following code:

> >     template <typename T> using scoped_allocator = scoped_allocator_adaptor<allocator<T>>;

> >     vector<shared_ptr<int>, scoped_allocator<shared_ptr<int>>> v;
> >     v.emplace_back(new int); // ops! doesn't compile

> doesn't compile, as the member function `construct()` of the scoped allocator requires non-explicit constructors through concept `ConstructibleWithAllocator`. Fixing that is not difficult but probably more work than it's worth and is therefore, IMHO, one more reason in support of the complete removal of scoped allocators.

[ 2009-06-09 Alan adds: ]

> I reopened this issue because I did not think that these National Body comments were adequately addressed by marking them NAD. My understanding is that something can be marked NAD if it is clearly a misunderstanding or trivial, but a substantive issue that has any technical merit requires a disposition that addresses the concerns.

> The notes in the NB comment list (US 65 & US 74.1) say that:

> 1. this issue has not introduced any new arguments not previously discussed,
> 2. the vote (4-9-3) was not a consensus for removing scoped allocators,
> 3. the issue is resolved by N2840.

> My opinion is:

> 1. there are new arguments in both comments regarding concepts (which were not present in the library when the scoped allocator proposal was voted in),
> 2. the vote was clearly not a consensus for removal, but just saying there was a vote does not provide a rationale,
> 3. I do not believe that N2840 addresses these comments (although it does many other things and was voted in with strong approval).

> My motivation to open the issue was to ensure that the NB comments were adequately addressed in a way that would not risk a "no" vote on our FCD. If there are responses to the technical concerns raised, then perhaps they should be recorded. If the members of the NB who authored the comments are satisfied with N2840 and the other disposition remarks in the comment list, then I am sure they will say so. In either case, this issue can be closed very quickly in Frankfurt, and hopefully will have helped make us more confident of approval with little effort. If in fact there is controversy, my thought is that it is better to know now rather than later so there is more time to deal with it.

Proposed resolution:

### 1076. unary/binary_negate need constraining and move support

Section: 20.7.11 [negators] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-20 Last modified: 2009-05-23

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.

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.11 [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.6 [random.access.iterators] Status: Open Submitter: Doug Gregor Opened: 2009-03-20 Last modified: 2009-03-22

View other active issues in [random.access.iterators].

View all other issues in [random.access.iterators].

View all issues with Open 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

Proposed resolution:

Modify 24.2.6 [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`

### 1088. Response to UK 342

Section: 30.6.4 [futures.promise] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-03-22

View other active issues in [futures.promise].

View all other issues in [futures.promise].

View all issues with Open status.

Discussion:

Addresses UK 342

`std::promise` is missing a non-member overload of `swap`. This is inconsistent with other types that provide a `swap` member function.

Add a non-member overload `void swap(promise&& x,promise&& y){ x.swap(y); }`

[ Summit: ]

> Create an issue. Move to review, attention: Howard. Detlef will also look into it.

[ Post Summit Daniel provided wording. ]

Proposed resolution:

1. In 30.6.4 [futures.promise], before p.1, immediately after class template promise add:

   >     template <class R>
   >     void swap(promise<R>& x, promise<R>& y);

2. Change 30.6.4 [futures.promise]/10 as indicated (to fix a circular definition):

   > -10- Effects: swap(*this, other)Swaps the associated state of `*this` and `other`

   > Throws: Nothing.

3. After the last paragraph in 30.6.4 [futures.promise] add the following prototype description:

   >     template <class R>
   >     void swap(promise<R>& x, promise<R>& y);

   > > Effects: `x.swap(y)`

   > > Throws: Nothing.

### 1089. Response to JP 76

Section: 30 [thread] Status: Open Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-08-02

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.

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 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.7 [futures.task] Status: Open Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2009-05-24

View all issues with Open status.

Discussion:

Class template `packaged_task` in 30.6.7 [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. ]

Proposed resolution:

1. In 30.6.7 [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...)>&);

3. In 30.6.7 [futures.task], immediately after `operator=` prototype description (After p. 8) add:

   >     void swap(packaged_task& other);

   > > Effects: Swaps the associated state of `*this` and `other`.

   > > Throws: Nothing.

4. At the end of 30.6.7 [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.

### 1091. Multimap description confusing

Section: 23.4.2.2 [multimap.modifiers] Status: Review Submitter: LWG Opened: 2009-03-22 Last modified: 2009-07-04

View all issues with Review status.

Discussion:

Addresses UK 246

The content of this sub-clause is purely trying to describe in words the effect of the requires clauses on these operations, now that we have Concepts. As such, the description is more confusing than the signature itself. The semantic for these functions is adequately covered in the requirements tables in 23.2.4 [associative.reqmts].

[ Beman adds: ]

> Pete is clearly right that this one is technical rather than editorial.

[ Batavia (2009-05): ]

> We agree with the proposed resolution.

> Move to Review.

Proposed resolution:

Strike 23.4.2.2 [multimap.modifiers] entirely (but do NOT strike these signatures from the class template definition!).

### 1093. Multiple definitions for random_shuffle algorithm

Section: 25.4.12 [alg.random.shuffle] Status: Open Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2009-07-28

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.6 [random.access.iterators] uses this type as argument of it's algebraic operators. Alternatively consider the equivalent iterator algorithms in 24.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.

Proposed resolution:

Change in 25.2 [algorithms.syn] and 25.4.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: Review Submitter: P.J. Plauger Opened: 2009-03-24 Last modified: 2009-05-23

View all other issues in [iostate.flags].

View all issues with Review 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.

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: Review Submitter: Beman Dawes Opened: 2009-03-27 Last modified: 2009-05-23

View all issues with Review 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.7 [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.

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: Thus 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: Review Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-05-23

View all other issues in [support.types].

View all issues with Review 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.

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.10.7 [util.dynamic.safety] Status: Open Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-05-23

View all other issues in [util.dynamic.safety].

View all issues with Open status.

Discussion:

Addresses DE 18

In 20.8.10.7 [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.

Proposed resolution:

In 20.8.10.7 [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: Open Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2009-05-23

View other active issues in [library].

View all other issues in [library].

View all issues with Open 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

> [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.

> > 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.

> [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.

Proposed resolution:

### 1100. `auto_ptr` to `unique_ptr` conversion

Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Review Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-08-01

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

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

View all issues with Review 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.9 [depr.auto.ptr] to 20.8.9.2 [unique.ptr.single] per the Editor's request in Batavia (as long as I was making changes anyway). Set back to Review.

Proposed resolution:

Add to 20.8.9.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.9.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.

### 1102. `std::vector`'s reallocation policy still unclear

Section: 23.3.6.2 [vector.capacity] Status: Review Submitter: Daniel Krügler Opened: 2009-04-20 Last modified: 2009-05-23

View all other issues in [vector.capacity].

View all issues with Review status.

Discussion:

I have the impression that even the wording of current draft N2857 does insufficiently express the intent of `vector`'s reallocation strategy. This has produced not too old library implementations which release memory in the `clear()` function and even modern articles about C++ programming cultivate the belief that `clear` is allowed to do exactly this. A typical example is something like this:

>     const int buf_size = ...;
>     std::vector<T> buf(buf_size);
>     for (int i = 0; i < some_condition; ++i) {
>       buf.resize(buf_size);
>       write_or_read_data(buf.data());
>       buf.clear(); // Ensure that the next round get's 'zeroed' elements
>     }

where still the myth is ubiquitous that `buf` might be allowed to reallocate it's memory *inside* the `for` loop.

IMO the problem is due to the fact, that

1. the actual memory-reallocation stability of `std::vector` is explained in 23.3.6.2 [vector.capacity]/3 and /6 which are describing just the effects of the `reserve` function, but in many examples (like above) there is no explicit call to `reserve` involved. Further-more 23.3.6.2 [vector.capacity]/6 does only mention insertions and never mentions the consequences of erasing elements.

2. the effects clause of `std::vector`'s `erase` overloads in 23.3.6.4 [vector.modifiers]/4 is silent about capacity changes. This easily causes a misunderstanding, because the counter parting insert functions described in 23.3.6.4 [vector.modifiers]/2 explicitly say, that

   > 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.

   It requires a complex argumentation chain about four different places in the standard to provide the - possibly weak - proof that calling `clear()` also does never change the capacity of the `std::vector` container. Since `std::vector` is the de-facto replacement of C99's dynamic arrays this type is near to a built-in type and it's specification should be clear enough that usual programmers can trust their own reading.

[ Batavia (2009-05): ]

> Bill believes paragraph 1 of the proposed resolution is unnecessary because it is already implied (even if tortuously) by the current wording.

> Move to Review.

Proposed resolution:

[ This is a minimum version. I also suggest that the wording explaining the allocation strategy of `std::vector` in 23.3.6.2 [vector.capacity]/3 and /6 is moved into a separate sub paragraph of 23.3.6.2 [vector.capacity] before any of the prototype's are discussed, but I cannot provide reasonable wording changes now ]

1. Change 23.3.6.2 [vector.capacity]/6 as follows:

   > It is guaranteed that no reallocation takes place during insertions or erasures that happen after a call to `reserve()` until the time when an insertion would make the size of the vector greater than the value of `capacity()`.

2. Change 23.3.6.4 [vector.modifiers]/4 as follows:

   > Effects: The capacity shall remain unchanged and no reallocation shall happen. Invalidates iterators and references at or after the point of the erase.

### 1104. `basic_ios::move` should accept lvalues

Section: 27.5.4.2 [basic.ios.members] Status: Review Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-05-23

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with Review 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.

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.6 [future.shared_future] Status: Open Submitter: Thomas J. Gritzan Opened: 2009-04-03 Last modified: 2009-05-23

View other active issues in [future.shared_future].

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.6 [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: Open Submitter: Christopher Kohlhoff Opened: 2009-04-25 Last modified: 2009-05-23

View all issues with Open 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.

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.3.4 [alg.foreach] Status: Open Submitter: Alisdair Meredith Opened: 2009-04-29 Last modified: 2009-05-23

View all other issues in [alg.foreach].

View all issues with Open status.

Discussion:

Quoting working paper for reference (25.3.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.

Proposed resolution:

Change 25.2 [algorithms.syn] and 25.3.4 [alg.foreach]:

>     template<InputIterator Iter, Callable<auto, Iter::reference> Function>
>       requires CopyConstructible MoveConstructible<Function>
>       Function for_each(Iter first, Iter last, Function f);

### 1112. bitsets and new style for loop

Section: 20.3.6 [template.bitset] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-06 Last modified: 2009-07-25

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with Open 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. ]

Proposed resolution:

1. Modify the section 20.3.6 [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.6.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.6 [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.6 [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.6 [template.bitset] Status: Open Submitter: Alisdair Meredith Opened: 2009-05-09 Last modified: 2009-05-23

View other active issues in [template.bitset].

View all other issues in [template.bitset].

View all issues with Open 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.

Proposed resolution:

1. In 20.3.6 [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.6.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.6.2 [bitset.members] paragraphs 37 -> 39 (including signature above 37)

### 1114. Type traits underspecified

Section: 20.6 [meta] Status: Open Submitter: Daniel Krügler Opened: 2009-05-12 Last modified: 2009-05-23

View other active issues in [meta].

View all other issues in [meta].

View all issues with Open 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.

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.15 [func.memfn], or 20.7.16.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: New Submitter: Miles Zhao Opened: 2009-05-23 Last modified: 2009-05-23

View other active issues in [diff.library].

View all other issues in [diff.library].

View all issues with New 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.

Proposed resolution:

Add `va_copy` to Table 122 -- Standard macros in C.2 [diff.library].

### 1116. Literal constructors for tuple

Section: 20.5.2 [tuple.tuple] Status: New Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-05-24

View all other issues in [tuple.tuple].

View all issues with New status.

Discussion:

It is not currently possible to construct `tuple` literal values, even if the elements are all literal types. This is because parameters are passed to constructor by reference.

An alternative would be to pass all constructor arguments by value, where it is known that *all* elements are literal types. This can be determined with concepts, although note that the negative constraint really requires factoring out a separate concept, as there is no way to provide an 'any of these fails' constraint inline.

Note that we will have similar issues with `pair` (and `tuple` constructors from `pair`) although I am steering clear of that class while other constructor-related issues settle.

Proposed resolution:

Ammend the tuple class template declaration in 20.5.2 [tuple.tuple] as follows

> Add the following concept:

> >     auto concept AllLiteral< typename ... Types > {
> >       requires LiteralType<Types>...;
> >     }

> ammend the constructor

> >     template <class... UTypes>
> >       requires AllLiteral<Types...>
> >             && Constructible<Types, UTypes>...
> >       explicit tuple(UTypes...);

> >     template <class... UTypes>
> >       requires !AllLiteral<Types...>
> >             && Constructible<Types, UTypes&&>...
> >       explicit tuple(UTypes&&...);

> ammend the constructor

> >     template <class... UTypes>
> >       requires AllLiteral<Types...>
> >             && Constructible<Types, UTypes>...
> >       tuple(tuple<UTypes...>);

> >     template <class... UTypes>
> >       requires !AllLiteral<Types...>
> >             && Constructible<Types, const UTypes&>...
> >       tuple(const tuple<UTypes...>&);

Update the same signatures in 20.5.2.1 [tuple.cnstr], paras 3 and 5.

### 1117. tuple copy constructor

Section: 20.5.2.1 [tuple.cnstr] Status: New Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-05-30

View other active issues in [tuple.cnstr].

View all other issues in [tuple.cnstr].

View all issues with New status.

Discussion:

The copy constructor for the `tuple` template is constrained. This seems an unusual strategy, as the copy constructor will be implicitly deleted if the constraints are not met. This is exactly the same effect as requesting an `=default;` constructor. The advantage of the latter is that it retains triviality, and provides support for `tuple`s as literal types if issue 1116 is also accepted.

Actually, it might be worth checking with core if a constrained copy constructor is treated as a constructor template, and as such does not suppress the implicit generation of the copy constructor which would hide the template in this case.

[ 2009-05-27 Daniel adds: ]

> This would solve one half of the suggested changes in 801.

Proposed resolution:

Change 20.5.2 [tuple.tuple] and 20.5.2.1 [tuple.cnstr] p4:

>     requires CopyConstructible<Types>... tuple(const tuple&) = default;

### 1118. tuple query APIs do not support cv-qualification

Section: 20.5.2.3 [tuple.helper] Status: New Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-05-25

View other active issues in [tuple.helper].

View all other issues in [tuple.helper].

View all issues with New 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.

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.3 [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.3 [tuple.helper] Status: New Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-05-24

View other active issues in [tuple.helper].

View all other issues in [tuple.helper].

View all issues with New 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.

Proposed resolution:

### 1120. New type trait - remove_all

Section: 20.6 [meta] Status: New Submitter: Alisdair Meredith Opened: 2009-05-23 Last modified: 2009-05-24

View other active issues in [meta].

View all other issues in [meta].

View all issues with New status.

Discussion:

Sometimes it is necessary to remove all qualifiers from a type before passing on to a further API. A good example would be calling the `tuple` query APIs `tuple_size` or `tuple_element` with a deduced type inside a function template. If the deduced type is cv-qualified or a reference then the call will fail. The solution is to chain calls to `remove_cv<remove_reference<T>::type>::type`, and note that the order matters.

Suggest it would be helpful to add a new type trait, `remove_all`, that removes all top-level qualifiers from a type i.e. cv-qualification and any references. Define the term in such a way that if additional qualifiers are added to the language, then `remove_all` is defined as stripping those as well.

Proposed resolution:

### 1121. Support for multiple arguments

Section: 20.4.2 [ratio.arithmetic] Status: New Submitter: Alisdair Meredith Opened: 2009-05-25 Last modified: 2009-05-25

View all other issues in [ratio.arithmetic].

View all issues with New 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.

Proposed resolution:

[ note that this wording relies on 'metafunction forwarding' as described by Boost MPL ]

20.4 [ratio] p3 synopsis: change

>     // ratio arithmetic
>     template <class R1, class R2, class ... RList> struct ratio_add;
>     template <class R1, class R2> struct ratio_subtract;
>     template <class R1, class R2, class ... RList> struct ratio_multiply;
>     template <class R1, class R2> struct ratio_divide;

20.4.2 [ratio.arithmetic] p1: change

>     template <class R1, class R2, class ... RList> struct ratio_add
>       : ratio_add< R1, ratio_add<R2, RList...>> {
>     };

>     template <class R1, class R2> struct ratio_add<R1, R2> {
>       typedef see below type;
>     };

20.4.2 [ratio.arithmetic] p3: change

>     template <class R1, class R2, class ... RList> struct ratio_multiply
>       : ratio_multiply< R1, ratio_ multiply <R2, RList...>> {
>     };

>     template <class R1, class R2> struct ratio_ multiply<R1, R2> {
>       typedef see below type;
>     };

### 1122. Ratio values should be constexpr

Section: 20.4.1 [ratio.ratio] Status: New Submitter: Alisdair Meredith Opened: 2009-05-25 Last modified: 2009-05-25

View other active issues in [ratio.ratio].

View all other issues in [ratio.ratio].

View all issues with New status.

Discussion:

The values `num` and `den` in the `ratio` template should be declared `constexpr`.

Proposed resolution:

20.4.1 [ratio.ratio]

>     namespace std {
>       template <intmax_t N, intmax_t D = 1>
>       class ratio {
>       public:
>         static constexpr intmax_t num;
>         static constexpr intmax_t den;
>       };
>     }

### 1123. no requirement that standard streams be flushed

Section: 27.5.2.1.6 [ios::Init] Status: New Submitter: James Kanze Opened: 2009-05-14 Last modified: 2009-05-30

View all other issues in [ios::Init].

View all issues with New 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.

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: New Submitter: Alisdair Meredith Opened: 2009-05-28 Last modified: 2009-05-30

View all other issues in [istreambuf.iterator::equal].

View all issues with New 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. ]

Proposed resolution:

Ammend in both:
24.6.3 [istreambuf.iterator]
24.6.3.5 [istreambuf.iterator::equal]

>     bool equal(const istreambuf_iterator& b) const;

### 1129. `istream(buf)_iterator` should support literal sentinel value

Section: 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] Status: New Submitter: Alisdair Meredith Opened: 2009-05-30 Last modified: 2009-06-09

View all issues with New status.

Discussion:

`istream_iterator` and `istreambuf_iterator` should support literal sentinel values. The default constructor is frequently used to terminate ranges, and could easily be a literal value for `istreambuf_iterator`, and `istream_iterator` when iterating value types. A little more work using a suitably sized/aligned char-array for storage (or an updated component like `boost::optional` proposed for TR2) would allow `istream_iterator` to support `constexpr` default constructor in all cases, although we might leave this tweak as a QoI issue. Note that requiring `constexpr` be supported also allows us to place no-throw guarantees on this constructor too.

[ 2009-06-02 Daniel adds: ]

> I agree with the usefulness of the issue suggestion, but we need to ensure that `istream_iterator` can satisfy be literal if needed. Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares a copy constructor and a destructor and explains their semantic in 24.6.1.1 [istream.iterator.cons]/3+4.

> The prototype semantic specification is ok (although it seems somewhat redundant to me, because the semantic doesn't say anything interesting in both cases), but for support of trivial class types we also need a trivial copy constructor and destructor as of 9 [class]/6. The current non-informative specification of these two special members suggests to remove their explicit declaration in the class and add explicit wording that says that if `T` is trivial a default constructed iterator is also literal, alternatively it would be possible to mark both as defaulted and add explicit (memberwise) wording that guarantees that they are trivial.

> Btw.: I'm quite sure that the `istreambuf_iterator` additions to ensure triviality are not sufficient as suggested, because the library does not yet give general guarantees that a defaulted special member declaration makes this member also trivial. Note that e.g. the atomic types do give a general statement!

> Finally there is a wording issue: There does not exist something like a "literal constructor". The core language uses the term "constexpr constructor" for this.

> Suggestion:

> 1. Change 24.6.1 [istream.iterator]/3 as indicated:

>    >     constexpr istream_iterator();
>    >     istream_iterator(istream_type& s);
>    >     istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
>    >     ~istream_iterator() = default;

> 2. Change 24.6.1.1 [istream.iterator.cons]/1 as indicated:

>    >     constexpr istream_iterator();

>    > > -1- Effects: Constructs the end-of-stream iterator. If `T` is a literal type, then this constructor shall be a constexpr constructor.

> 3. Change 24.6.1.1 [istream.iterator.cons]/3 as indicated:

>    >     istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;

>    > > -3- Effects: Constructs a copy of `x`. If `T` is a literal type, then this constructor shall be a trivial copy constructor.

> 4. Change 24.6.1.1 [istream.iterator.cons]/4 as indicated:

>    >     ~istream_iterator() = default;

>    > > -4- Effects: The iterator is destroyed. If `T` is a literal type, then this destructor shall be a trivial destructor.

> 5. Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated:

>    >     constexpr istreambuf_iterator() throw();
>    >     istreambuf_iterator(const istreambuf_iterator&)  throw() = default;
>    >     ~istreambuf_iterator()  throw() = default;

> 6. Change 24.6.3 [istreambuf.iterator]/1 as indicated:

>    > [..] The default constructor `istreambuf_iterator()` and the constructor `istreambuf_iterator(0)` both construct an end of stream iterator object suitable for use as an end-of-range. All specializations of `istreambuf_iterator` shall have a trivial copy constructor, a constexpr default constructor and a trivial destructor.

Proposed resolution:

24.6.1 [istream.iterator] para 3

>     constexpr istream_iterator();

24.6.1.1 [istream.iterator.cons]

>     constexpr istream_iterator();

> > -1- Effects: Constructs the end-of-stream iterator. If `T` is a literal type, then this constructor shall be a literal constructor.

24.6.3 [istreambuf.iterator]

>     constexpr istreambuf_iterator() throw();

### 1130. `copy_exception` name misleading

Section: 18.8.5 [propagation] Status: New Submitter: Peter Dimov Opened: 2009-05-13 Last modified: 2009-06-02

View other active issues in [propagation].

View all other issues in [propagation].

View all issues with New 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;

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. | ...

### 1132. JP-30: nested exceptions

Section: 18.8.6 [except.nested] Status: New Submitter: Seiji Hayashida Opened: 2009-06-01 Last modified: 2009-06-02

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with New status.

Discussion:

Addresses JP 30

C++0x `nested_exception` cannot handle a structured exception well. The following codes show two types of tree structured exception handling.

The first one is based on `nested_exception` in C++0x, while the second one is based on my library `trickerr.h` (in Japanese). http://tricklib.com/cxx/dagger/trickerr.h

Assume that Function `A()` calls two sub functions `A_a()` and `A_b()`, both might throw tree structured exceptions, and `A_b()` must be called even if `A_a()` throws an exception.

List A (code of tree structured exception handling based on nested_exception in C++0x)

>     void A()
>     {
>         try
>         {
>             std::vector<exception_ptr> exception_list;
>             try
>             {
>                 // A_a() does a similar processing as A().
>                 A_a();
>             }
>             catch(...)
>             {
>                 exception_list.push_back(current_exception());
>             }

>             // ***The processing A() has to do even when A_a() fails. ***
>             try
>             {
>                 // A_b() does a similar processing as A().
>                 A_b();
>             }
>             catch(...)
>             {
>                 exception_list.push_back(current_exception());
>             }
>             if (!exception_list.empty())
>             {
>                 throw exception_list;
>             }
>         }
>         catch(...)
>         {
>             throw_with_nested(A_exception("someone error"));
>         }
>     }
>     void print_tree_exception(exception_ptr e, const std::string & indent ="")
>     {
>         const char * indent_unit = " ";
>         const char * mark = "- ";
>         try
>         {
>             rethow_exception(e);
>         }
>         catch(const std::vector<exception_ptr> e)
>         {
>             for(std::vector<exception_ptr>::const_iterator i = e.begin(); i!=e.end(); ++i)
>             {
>                 print_tree_exception(i, indent);
>             }
>         }
>         catch(const std::nested_exception  e)
>         {
>             print_tree_exception(evil_i(e), indent +indent_unit);
>         }
>         catch(const std::exception e)
>         {
>             std::cout << indent << mark << e.what() << std::endl;
>         }
>         catch(...)
>         {
>             std::cout << indent << mark << "unknown exception" << std::endl;
>         }
>     }
>     int main(int, char * [])
>     {
>         try
>         {
>             A();
>         }
>         catch()
>         {
>             print_tree_exception(current_exception());
>         }
>         return EXIT_SUCCESS;
>     }

List B ( code of tree structured exception handling based on `trickerr.h`. ) "trickerr.h" (in Japanese), refer to: http://tricklib.com/cxx/dagger/trickerr.h.

>     void A()
>     {
>         tricklib::error_listener_type error_listener;
>         // A_a() is like A(). A_a() can throw tree structured exception.
>         A_a();

>         // *** It must do process so that A_a() throws exception in A(). ***
>         // A_b() is like A(). A_b() can throw tree structured exception.
>         A_b();

>         if (error_listener.has_error()) // You can write this "if block" in destructor
>                                         //  of class derived from error_listener_type.
>         {
>             throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
>         }
>     }
>     void print_tree_error(const tricklib::error_type &a_error, const std::string & indent = "")
>     {
>         const char * indent_unit = " ";
>         const char * mark = "- ";

>         tricklib::error_type error = a_error;
>         while(error)
>         {
>             std::cout << indent << mark << error->message << std::endl;
>             if (error->children)
>             {
>                 print_tree_error(error->children, indent +indent_unit);
>             }
>             error = error->next;
>         }
>     }
>     int main(int, char * [])
>     {
>         tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.

>         try
>         {
>             A();
>         }
>         catch(error_type error)
>         {
>             print_tree_error(error);
>         }
>         catch(...)
>         {
>             std::cout << "- unknown exception" << std::endl;
>         }
>         return EXIT_SUCCESS;
>     }

Prospect

We will focus on the method A() since the other methods, also main(), occur only once respectively.

- In the List A above (of the nested exception handling), it is hard to find out an active reason to use the nested exception handling at this scene. Rather, we can take a simpler description by throwing the entire exception_list directly to the top level.
- The code in the same example gives us a kind of redundant impression, which might have come from the fact that the try-throw-catch framework does not assume a tree structured exception handling.

According to the above observation, we cannot help concluding that it is not so easy to use the nested_exception handling as a tree structured exception handling mechanism in a practical sense.

This text is based on the web page below (in Japanese). http://d.hatena.ne.jp/wraith13/20081231/1230715424

Proposed resolution:

### 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-06-09

View other active issues in [forwardlist.ops].

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.

Proposed resolution:

### 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: New Submitter: Robert Klarer Opened: 2009-05-26 Last modified: 2009-06-14

View all issues with New 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.

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: New Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-06-09

View other active issues in [propagation].

View all other issues in [propagation].

View all issues with New 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;
>     }

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: New Submitter: Daniel Krügler Opened: 2007-06-06 Last modified: 2009-06-09

View other active issues in [except.nested].

View all other issues in [except.nested].

View all issues with New 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.

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. unusal return value for operator+

Section: 21.4.8.1 [string::op+] Status: New Submitter: Alisdair Meredith Opened: 2009-06-12 Last modified: 2009-06-15

View all issues with New 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};

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

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

### 1144. "thread safe" is undefined

Section: 18.5 [support.start.term] Status: New Submitter: LWG Opened: 2009-06-16 Last modified: 2009-07-04

View all other issues in [support.start.term].

View all issues with New 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".

Proposed resolution:

### 1145. inappropriate headers for atomics

Section: 29 [atomics] Status: New Submitter: LWG Opened: 2009-06-16 Last modified: 2009-07-04

View other active issues in [atomics].

View all other issues in [atomics].

View all issues with New status.

Discussion:

Addresses UK 312

The contents of the `<stdatomic.h>` header are not listed anywhere, and `<cstdatomic>` is listed as a C99 header in chapter 17. If we intend to use these for compatibility with a future C standard, we should not use them now.

Proposed resolution:

Remove `<cstdatomic>` from the C99 headers in table 14. Add a new header `<atomic>` to the headers in table 13. Update chapter 29 to remove reference to `<stdatomic.h>` and replace the use of `<cstdatomic>` with `<atomic>`.

[ If and when WG14 adds atomic operations to C we can add corresponding headers to table 14 with a TR. ]

### 1146. "lockfree" does not say enough

Section: 29.4 [atomics.lockfree] Status: New Submitter: Jeffrey Yasskin Opened: 2009-06-16 Last modified: 2009-07-04

View all issues with New status.

Discussion:

Addresses US 88

The "lockfree" facilities do not tell the programmer enough.

There are 2 problems here. First, at least on x86, it's less important to me whether some integral types are lock free than what is the largest type I can pass to atomic and have it be lock-free. For example, if `long long`s are not lock-free, `ATOMIC_INTEGRAL_LOCK_FREE` is probably 1, but I'd still be interested in knowing whether longs are always lock-free. Or if long longs at any address are lock-free, I'd expect `ATOMIC_INTEGRAL_LOCK_FREE` to be 2, but I may actually care whether I have access to the `cmpxchg16b` instruction. None of the support here helps with that question. (There are really 2 related questions here: what alignment requirements are there for lock-free access; and what processor is the program actually running on, as opposed to what it was compiled for?)

Second, having `atomic_is_lock_free` only apply to individual objects is pretty useless (except, as Lawrence Crowl points out, for throwing an exception when an object is unexpectedly not lock-free). I'm likely to want to use its result to decide what algorithm to use, and that algorithm is probably going to allocate new memory containing atomic objects and then try to act on them. If I can't predict the lock-freedom of the new object by checking the lock-freedom of an existing object, I may discover after starting the algorithm that I can't continue.

[ 2009-06-16 Jeffrey Yasskin adds: ]

> To solve the first problem, I think 2 macros would help: `MAX_POSSIBLE_LOCK_FREE_SIZE` and `MAX_GUARANTEED_LOCK_FREE_SIZE`, which expand to the maximum value of `sizeof(T)` for which atomic may (or will, respectively) use lock-free operations. Lawrence points out that this "relies heavily on implementations using word-size compare-swap on sub-word-size types, which in turn requires address modulation." He expects that to be the end state anyway, so it doesn't bother him much.

> To solve the second, I think one could specify that equally aligned objects of the same type will return the same value from `atomic_is_lock_free()`. I don't know how to specify "equal alignment". Lawrence suggests an additional function, `atomic_is_always_lock_free()`.

Proposed resolution:

### 1147. non-volatile atomic functions

Section: 29.6 [atomics.types.operations] Status: New Submitter: Jeffrey Yasskin Opened: 2009-06-16 Last modified: 2009-07-04

View other active issues in [atomics.types.operations].

View all other issues in [atomics.types.operations].

View all issues with New status.

Discussion:

Addresses US 90

The C++0X draft declares all of the functions dealing with atomics (section 29.6 [atomics.types.operations]) to take volatile arguments. Yet it also says (29.4-3),

> [ Note: Many operations are volatile-qualified. The "volatile as device register" semantics have not changed in the standard. This qualification means that volatility is preserved when applying these operations to volatile objects. It does not mean that operations on non-volatile objects become volatile. Thus, volatile qualified operations on non-volatile objects may be merged under some conditions. —end note ]

I was thinking about how to implement this in gcc, and I believe that we'll want to overload most of the functions on volatile and non-volatile. Here's why:

To let the compiler take advantage of the permission to merge non-volatile atomic operations and reorder atomics in certain, we'll need to tell the compiler backend about exactly which atomic operation was used. So I expect most of the functions of the form atomic_<op>_explicit() (e.g. atomic_load_explicit, atomic_exchange_explicit, atomic_fetch_add_explicit, etc.) to become compiler builtins. A builtin can tell whether its argument was volatile or not, so those functions don't really need extra explicit overloads. However, I don't expect that we'll want to add builtins for every function in chapter 29, since most can be implemented in terms of the _explicit free functions:

    class atomic_int {
      __atomic_int_storage value;
     public:
      int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
        // &value has type "volatile __atomic_int_storage*".
        atomic_fetch_add_explicit(&value, increment, order);
      }
      ...
    };

But now this always calls the volatile builtin version of atomic_fetch_add_explicit(), even if the atomic_int wasn't declared volatile. To preserve volatility and the compiler's permission to optimize, I'd need to write:

    class atomic_int {
      __atomic_int_storage value;
     public:
      int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
        atomic_fetch_add_explicit(&value, increment, order);
      }
      int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
        atomic_fetch_add_explicit(&value, increment, order);
      }
      ...
    };

But this is visibly different from the declarations in the standard because it's now overloaded. (Consider passing &atomic_int::fetch_add as a template parameter.)

The implementation may already have permission to add overloads to the member functions:

> 17.6.4.5 [member.functions] An implementation may declare additional non-virtual member function signatures within a class:
> ...

> - by adding a member function signature for a member function name.

but I don't see an equivalent permission to add overloads to the free functions.

[ 2009-06-16 Lawrence adds: ]

> I recommend allowing non-volatile overloads.

Proposed resolution:

### 1148. Wrong argument type of I/O stream manipulators `setprecision()` and `setw()`

Section: 27.7 [iostream.format] Status: New Submitter: Marc Steinbach Opened: 2009-06-20 Last modified: 2009-07-30

View all other issues in [iostream.format].

View all issues with New status.

Discussion:

The header `<iomanip>` synopsis in 27.7 [iostream.format] specifies

>     T5 setprecision(int n);
>     T6 setw(int n);

The argument types should be streamsize, as in class `ios_base` (see 27.5.2 [ios.base]):

>     streamsize precision() const;
>     streamsize precision(streamsize prec);
>     streamsize width() const;
>     streamsize width(streamsize wide);

(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.)

[ 2009-07-29 Daniel clarified wording. ]

Proposed resolution:

1. In 27.7 [iostream.format], header `<iomanip>` synopsis change as indicated:

   >     T5 setprecision(intstreamsize n);
   >     T6 setw(intstreamsize n);

2. In 27.7.3 [std.manip], just before p. 6 change as indicated:

   >     unspecified setprecision(intstreamsize n);

3. In 27.7.3 [std.manip], just before p. 7 change as indicated:

   >     unspecified setw(intstreamsize n);

### 1150. wchar_t, char16_t and char32_t filenames

Section: 27.9.1.14 [fstream] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-04

View all issues with New status.

Discussion:

Addresses JP 73

Description

It is a problem from C++98, `fstream` cannot appoint a filename of wide character string(`const wchar_t` and `const wstring&`).

Suggestion

Add interface corresponding to `wchar_t`, `char16_t` and `char32_t`.

[ 2009-07-01 Alisdair notes that this is a duplicate of 454 which has more in-depth rationale. ]

Proposed resolution:

### 1151. Behavior of the library in the presence of threads is incompletely specified

Section: 17 [library] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-06-28

View other active issues in [library].

View all other issues in [library].

View all issues with New 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.

Proposed resolution:

### 1152. expressions parsed differently than intended

Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: New Submitter: Seungbeom Kim Opened: 2009-06-27 Last modified: 2009-07-24

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

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

View all issues with New 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.

Proposed resolution:

Change Table 73 — Floating-point conversions in 22.4.2.2.2 [facet.num.put.virtuals]:

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`

### 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: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-04

View other active issues in [library].

View all other issues in [library].

View all issues with New 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.

Proposed resolution:

### 1154. `complex` should accept integral types

Section: 26.4 [complex.numbers] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-04

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

Proposed resolution:

### 1155. Reference should be to C99

Section: C.2 [diff.library] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-25

View other active issues in [diff.library].

View all other issues in [diff.library].

View all issues with New status.

Discussion:

Addresses FR 38

Description

What is ISO/IEC 1990:9899/DAM 1? My guess is that's a typo for ISO/IEC 9899/Amd.1:1995 which I'd have expected to be referenced here (the tables make reference to things which were introduced by Amd.1).

Suggestion

One need probably a reference to the document which introduce `char16_t` and `char32_t` in C (ISO/IEC TR 19769:2004?).

Notes

Create issue. Document in question should be C99, not C90+amendment1. The rest of the section requires careful review for completeness. Example <cstdint> 18.4.1 [cstdint.syn]. Assign to C liasons.

Proposed resolution:

### 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: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-25

View all issues with New 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

Proposed resolution:

### 1157. Local types can now instantiate templates

Section: 17.6.3.2.1 [namespace.std] Status: Review Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-28

View all issues with Review 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. ]

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: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-05

View all issues with New 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. ]

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:

### 1160. `future_error` public constructor is 'exposition only'

Section: 30.6.3 [futures.future_error] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-17

View all issues with Open status.

Discussion:

Addresses UK 331

Description

Not clear what it means for a public constructor to be 'exposition only'. If the intent is purely to support the library calling this constructor then it can be made private and accessed through friendship. Otherwise it should be documented for public consumption.

Suggestion

Declare the constructor as private with a note about intended friendship, or remove the exposition-only comment and document the semantics.

Notes

Create an issue. Assigned to Detlef. Suggested resolution probably makes sense.

[ 2009-07 Frankfurt ]

> Pending a paper from Anthony Williams / Detleff Volleman.

Proposed resolution:

### 1161. Unnecessary `unique_future` limitations

Section: 30.6.5 [futures.unique_future] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-17

View other active issues in [futures.unique_future].

View all other issues in [futures.unique_future].

View all issues with Open status.

Discussion:

Addresses UK 336

Description

It is possible to transfer ownership of the asynchronous result from one unique_future instance to another via the move-constructor. However, it is not possible to transfer it back, and nor is it possible to create a default-constructed unique_future instance to use as a later move target. This unduly limits the use of `unique_future` in code. Also, the lack of a move-assignment operator restricts the use of `unique_future` in containers such as `std::vector` - `vector::insert` requires move-assignable for example.

Suggestion

Add a default constructor with the semantics that it creates a `unique_future` with no associated asynchronous result. Add a move-assignment operator which transfers ownership.

Notes

Create an issue. Detlef will look into it.

[ 2009-07 Frankfurt ]

> Pending a paper from Anthony Williams / Detleff Volleman.

Proposed resolution:

### 1162. `shared_future` should support an efficient move constructor

Section: 30.6.6 [future.shared_future] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-17

View other active issues in [future.shared_future].

View all other issues in [future.shared_future].

View all issues with Open status.

Discussion:

Addresses UK 337

Description

`shared_future` should support an efficient move constructor that can avoid unnecessary manipulation of a reference count, much like `shared_ptr`

Suggestion

Add a move constructor

Notes

Create an issue. Detlef will look into it.

[ 2009-07 Frankfurt ]

> Pending a paper from Anthony Williams / Detleff Volleman.

Proposed resolution:

### 1163. `shared_future` is inconsistent with `shared_ptr`

Section: 30.6.6 [future.shared_future] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-17

View other active issues in [future.shared_future].

View all other issues in [future.shared_future].

View all issues with Open status.

Discussion:

Addresses UK 338

Description

`shared_future` is currently CopyConstructible, but not CopyAssignable. This is inconsistent with `shared_ptr`, and will surprise users. Users will then write work-arounds to provide this behaviour. We should provide it simply and efficiently as part of shared_future. Note that since the shared_future member functions for accessing the state are all declared const, the original usage of an immutable shared_future value that can be freely copied by multiple threads can be retained by declaring such an instance as "`const shared_future`".

Suggestion

Remove "=delete" from the copy-assignment operator of shared_future. Add a move-constructor `shared_future(shared_future&& rhs)`, and a move-assignment operator `shared_future& operator=(shared_future&& rhs)`. The postcondition for the copy-assignment operator is that `*this` has the same associated state as `rhs`. The postcondition for the move-constructor and move assignment is that `*this` has the same associated as `rhs` had before the constructor/assignment call and that `rhs` has no associated state.

Notes

Create an issue. Detlef will look into it.

[ 2009-07 Frankfurt ]

> Pending a paper from Anthony Williams / Detleff Volleman.

Proposed resolution:

### 1165. Unneeded promise move constructor

Section: 30.6.4 [futures.promise] Status: Open Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-17

View other active issues in [futures.promise].

View all other issues in [futures.promise].

View all issues with Open status.

Discussion:

Addresses UK 343

Description

The move constructor of a std::promise object does not need to allocate any memory, so the move-construct-with-allocator overload of the constructor is superfluous.

Suggestion

Remove the constructor with the signature `template <class Allocator> promise(allocator_arg_t, const Allocator& a, promise& rhs);`

Notes

Create an issue. Detlef will look into it. Will solicit feedback from Pablo. Note that “rhs” argument should also be an rvalue reference in any case.

[ 2009-07 Frankfurt ]

> Pending a paper from Anthony Williams / Detleff Volleman.

Proposed resolution:

### 1166. Allocator-specific move/copy break model of move-constructor and move-assignment

Section: X [allocator.propagation], X [allocator.propagation.map], 23 [containers] Status: New Submitter: LWG Opened: 2009-06-28 Last modified: 2009-07-04

View all issues with New status.

Discussion:

Addresses US 77

Description

Allocator-specific move and copy behavior for containers (N2525) complicates a little-used and already-complicated portion of the standard library (allocators), and breaks the conceptual model of move-constructor and move-assignment operations on standard containers being efficient operations. The extensions for allocator-specific move and copy behavior should be removed from the working paper.

With the introduction of rvalue references, we are teaching programmers that moving from a standard container (e.g., a `vector<string>`) is an efficient, constant-time operation. The introduction of N2525 removed that guarantee; depending on the behavior of four different traits (20.8.4), the complexity of copy and move operations can be constant or linear time. This level of customization greatly increases the complexity of standard containers, and benefits only a tiny fraction of the C++ community.

Suggestion

Remove 20.8.4.

Remove 20.8.5.

Remove all references to the facilities in 20.8.4 and 20.8.5 from clause 23.

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-07-28

View all issues with New status.

Discussion:

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.

Proposed resolution:

Change General 21.1 [strings.general] as indicated:

> This Clause describes components for manipulating sequences of any literal 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 shoud be literal

Section: 20.9.3 [time.duration] Status: New Submitter: Alisdair Meredith Opened: 2009-07-06 Last modified: 2009-07-07

View other active issues in [time.duration].

View all other issues in [time.duration].

View all issues with New 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`.

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. ]

### 1172. `select_on_container_(copy|move)_construction` over-constrained

Section: 20.8.2.4 [allocator.concepts.members] Status: New Submitter: Alberto Ganesh Barbati Opened: 2009-07-08 Last modified: 2009-07-14

View all issues with New status.

Discussion:

I believe the two functions `select_on_container_(copy|move)_construction()` are over-constrained. For example, the return value of the "copy" version is (see 20.8.2.4 [allocator.concepts.members]/21):

> Returns: `x` if the allocator should propagate from the existing container to the new container on copy construction, otherwise `X()`.

Consider the case where a user decides to provide an explicit concept map for Allocator to adapt some legacy allocator class, as he wishes to provide customizations that the `LegacyAllocator` concept map template does not provide. Now, although it's true that the legacy class is required to have a default constructor, the user might have reasons to prefer a different constructor to implement `select_on_container_copy_construction()`. However, the current wording requires the use of the default constructor.

Moreover, it's not said explicitly that `x` is supposed to be the allocator of the existing container. A clarification would do no harm.

Proposed resolution:

Replace 20.8.2.4 [allocator.concepts.members]/21 with:

>     X select_on_container_copy_construction(const X& x);

> -21- Returns: `x` if the allocator should propagate from the existing container to the new container on copy construction, otherwise `X()`. an allocator object to be used by the new container on copy construction. [Note: `x` is the allocator of the existing container that is being copied. The most obvious choices for the return value are `x`, if the allocator should propagate from the existing container, and `X()`. — end note]

Replace 20.8.2.4 [allocator.concepts.members]/25 with:

>     X select_on_container_move_construction(X&& x);

> -25- Returns: `move(x)` if the allocator should propagate from the existing container to the new container on move construction, otherwise `X()`. an allocator object to be used by the new container on move construction. [Note: `x` is the allocator of the existing container that is being moved. The most obvious choices for the return value are `move(x)`, if the allocator should propagate from the existing container, and `X()`. — end note]

### 1173. "Equivalence" wishy-washiness

Section: 17 [library] Status: New Submitter: David Abrahams Opened: 2009-07-14 Last modified: 2009-07-14

View other active issues in [library].

View all other issues in [library].

View all issues with New 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 ==.

Proposed resolution:

### 1174. type property predicates

Section: 20.6.4.3 [meta.unary.prop] Status: New Submitter: Jason Merrill Opened: 2009-07-16 Last modified: 2009-07-17

View other active issues in [meta.unary.prop].

View all other issues in [meta.unary.prop].

View all issues with New status.

Discussion:

I've been implementing compiler support for `is_standard_layout`, and noticed a few nits about 20.6.4.3 [meta.unary.prop]:

1. There's no trait for "trivially copyable type", which is now the property that lets you do bitwise copying of a type, and therefore seems useful to be able to query. `has_trivial_assign` && `has_trivial_copy_constructor` && `has_trivial_destructor` is similar, but not identical, specifically with respect to const types.
2. `has_trivial_copy_constructor` and `has_trivial_assign` lack the "or an array of such a class type" language that most other traits in that section, including `has_nothrow_copy_constructor` and `has_nothrow_assign`, have; this seems like an oversight.

[ See the thread starting with c++std-lib-24420 for further discussion. ]

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: New Submitter: Howard Hinnant Opened: 2009-07-18 Last modified: 2009-08-01

View other active issues in [time.duration].

View all other issues in [time.duration].

View all issues with New 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.

Proposed resolution:

[ This proposed resolution addresses 947 and 974. ]

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]

> > Eff�ects: Constructs an object of type `duration`, constructing `rep_` from `duration_cast<duration>(d).count()`.

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.

### 1178. Header dependencies

Section: 17.6.4.2 [res.on.headers] Status: Ready Submitter: Beman Dawes Opened: 2009-07-18 Last modified: 2009-07-18

View all issues with Ready status.

Discussion:

See Frankfurt notes of 1001.

Proposed resolution:

Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:

> A C++ header may include other C++ headers.[footnote] A C++ header shall provide the declarations and definitions that appear in its synopsis (3.2 [basic.def.odr]). A C++ header shown in its synopsis as including other C++ headers shall provide the declarations and definitions that appear in the synopses of those other headers.

> [footnote] C++ headers must include a C++ header that contains any needed definition (3.2).

### 1179. Probably editorial in [structure.specifications]

Section: 17.5.1.4 [structure.specifications] Status: New Submitter: Robert Klarer Opened: 2009-07-21 Last modified: 2009-07-22

View all other issues in [structure.specifications].

View all issues with New status.

Discussion:

While reviewing 971 I noted that 17.5.1.4 [structure.specifications]/7 says:

> -7- Error conditions specify conditions where a function may fail. The conditions are listed, together with a suitable explanation, as the `enum class errc` constants (19.5) that could be used as an argument to function `make_error_condition` (19.5.3.6).

This paragraph should mention `make_error_code` or the text "that could be used as an argument to function `make_error_condition` (19.5.3.6)" should be deleted. I believe this is editorial.

[ 2009-07-21 Chris adds: ]

> I'm not convinced there's a problem there, because as far as the "Error conditions" clauses are concerned, make_error_condition() is used by a user to test for the condition, whereas make_error_code is not. For example:

> >     void foobar(error_code& ec = throws());

> Error conditions:

> > permission_denied - Insufficient privilege to perform operation.

> When a user writes:

> >     error_code ec;
> >     foobar(ec);
> >     if (ec == errc::permission_denied)
> >        ...

> the implicit conversion `errc->error_condition` makes the if-test equivalent to:

> >     if (ec == make_error_condition(errc::permission_denied))

> On the other hand, if the user had written:

> >     if (ec == make_error_code(errc::permission_denied))

> the test is now checking for a specific error code. The test may evaluate to `false` even though `foobar()` failed due to the documented error condition "Insufficient privilege".

Proposed resolution:

### 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.17 [unord.hash] Status: New Submitter: Alisdair Meredith Opened: 2009-07-28 Last modified: 2009-07-30

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.17 [unord.hash].

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.17 [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.17 [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.6 [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.17 [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: New Submitter: Daniel Krügler Opened: 2009-07-28 Last modified: 2009-07-28

View other active issues in [basic.ios.members].

View all other issues in [basic.ios.members].

View all issues with New 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.

Proposed resolution:

Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated (The proposed resolution fixes also two editorial problems: Some wrong letters in "`clear()`" and moving the post conditions into a separate paragraph):

>     void set_rdbuf(basic_streambuf<charT, traits>* sb);

> > Requires: `sb != nullptr`.

> > Effects: Associates the `basic_streambuf` object pointed to by `sb` with this stream without calling `clear()`. Postconditions: rdbuf() == sb.

> > Postconditions: `rdbuf() == sb`.

> > Throws: Nothing.

### 1184. Feature request: dynamic bitset

Section: 23.3.6 [vector] Status: New Submitter: Alisdair Meredith Opened: 2009-07-29 Last modified: 2009-07-29

View other active issues in [vector].

View all other issues in [vector].

View all issues with New status.

Discussion:

Opened at Alisdair's request, steming from 96. Alisdair recommends NAD Future.

Proposed resolution:

### 1185. iterator categories and output iterators

Section: X [iterator.requirements] Status: New Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2009-07-31

View all issues with New status.

Discussion:

(wording relative to N2723 pending new working paper)

According to p3 X [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: New Submitter: Alisdair Meredith Opened: 2009-07-31 Last modified: 2009-08-01

View all issues with New status.

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.

Proposed resolution: