Document number: | WG21 N3806
Date: | 2013-10-14
Project: | Programming Language C++
Reference: | ISO/IEC IS 14882:2003
Reply to: | William M. Miller
| Edison Design Group, Inc.
| wmm@edg.com

## C++ Standard Core Language Active Issues, Revision 86

This document contains the C++ core language issues on which the Committee (J16 + WG21) has not yet acted, that is, issues with status "Ready," "Tentatively Ready," "Review," "Drafting," and "Open."

This document is part of a group of related documents that together describe the issues that have been raised regarding the C++ Standard. The other documents in the group are:

- Closed Issues List, which contains the issues which the Committee has decided are not defects in the International Standard, including a brief rationale explaining the reason for the decision.
- Defect Reports List, which contains the issues that have been categorized by the Committee as Defect Reports, as well as other issues accepted by the Committee, along with their proposed resolutions.
- Table of Contents, which contains a summary listing of all issues in numerical order.
- Index by Section, which contains a summary listing of all issues arranged in the order of the sections of the Standard with which they deal most directly.
- Index by Status, which contains a summary listing of all issues grouped by status.

Section references in this document reflect the section numbering of document WG21 N3690.

The purpose of these documents is to record the disposition of issues that have come before the Core Language Working Group of the ANSI (INCITS PL22.16) and ISO (WG21) C++ Standard Committee.

Some issues represent potential defects in the ISO/IEC IS 14882:2011 document and corrected defects in the earlier 2003 and 1998 documents; others refer to text in the working draft for the next revision of the C++ language and not to any Standard text. Issues are not necessarily formal ISO Defect Reports (DRs). While some issues will eventually be elevated to DR status, others will be disposed of in other ways. (See Issue Status below.)

The most current public version of this document can be found at http://www.open-std.org/jtc1/sc22/wg21. Requests for further information about these documents should include the document number, reference ISO/IEC 14882:2011, and be submitted to the InterNational Committee for Information Technology Standards (INCITS), 1250 Eye Street NW, Suite 200, Washington, DC 20005, USA.

Information regarding C++ standardization can be found at http://isocpp.org/std.

### Revision History

- Revision 86, 2013-10-14: Reflected the deliberations of the September, 2013 (Chicago) meeting. Added new issues 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, and 1795.
- Revision 85, 2013-09-03: Incorporated the results of the drafting review teleconferences held 2013-06-24 and 2013-08-26. Changed the status of issue 583 to "DR" because it was (silently) addressed by N3624. Changed the status of issue 1531 to "DR" because it had been inadvertently overlooked in recording the motions of the April, 2013 meeting. Changed the status of issue 1597 to "accepted" because it is moot after the adoption of N3652. Returned issue 1609 to "open" status in light of additional discussion. Added new information to the description of issue 1335. Added new issues 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, and 1742.
- Revision 84, 2013-05-03: Incorporated the results of the drafting review teleconference held 2013-03-25 and the deliberations of the April, 2013 (Bristol) meeting. Changed issue 1568 to "dup" status. Changed the status of issue 1492 to "drafting" status, although it was approved as a DR at the meeting, because its resolution is to be given by another resolution that was not moved. Similarly, issues 1356 and 1465 were incorrectly moved as defect reports and have been returned to "review" status awaiting the adoption of issue 1351. Also, issue 1531 was moved as a DR but was lacking the proposed resolution in the document in the pre-meeting mailing, so it has been returned to "ready" status to be moved at the next meeting. Changed the resolutions of issues 1374 and 1543 to correct clerical errors transcribing the original proposed resolutions. Began the practice of marking proposed resolutions as "[SUPERSEDED]" when a newer one is added. Added new issues 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, and 1656.
- Revision 83, 2013-03-18: Incorporated the results of the drafting review teleconference held 2013-02-04, including moving issue 1566 to "NAD" status. Moved issues 1417 and 1460 back to "review" status in light of new questions. Updated the “more information” link to refer to `isocpp.org`. Added new issues 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, and 1641.
- Revision 82, 2013-01-14: Incorporated the results of the drafting review teleconference held 2012-12-10. Moved issues 903, 1213, 1358, 1492, 1508, and 1552 to "review" status to allow further consideration in light of subsequent discussion. Added new issues 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, and 1605.
- Revision 81, 2012-11-03: Reflected the deliberations of the October, 2012 (Portland) meeting. Added new issues 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, and 1568.
- Revision 80, 2012-09-24: Added remaining descriptions omitted from issues added in revision 77. Corrected status of issues 915, 1313, 1399, and 1437. Changed the status of issues 616, 903, 1318, 1358, and 1402 in light of additional discussion. Incorporated the results of the drafting review teleconference held 2012-08-13. Moved issue 321 to "dup" status. Moved issue 591 to "open" status after the discussion in "dup" issue 1526. Added additional examples to issue 203. Added new issues 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, and 1559.
- Revision 79, 2012-02-27: Reflected deliberations at the February, 2012 (Kona) meeting. Added descriptions omitted from some issues added in revision 77. Moved issue 1427 to "NAD" status. Moved issue 1377 to "dup" status (with respect to issue 1279). Moved issue 1422 to "dup" status (with respect to issue 912). Added a new status, "concurrency", to track issues that will be considered and resolved by the Concurrency Working Group. Added new issues 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, and 1466.
- Revision 78, 2012-01-17: Reflected the results of the December 5, 2011 teleconference. Changed the status of issues 496, 675, 739, 1268, 1269, 1287, and 1312 from "ready" to "review" in response to further discussion of the proposed resolutions. Added new issues 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, and 1443.
- Revision 77, 2011-09-06: Reflected the deliberations of the August, 2011 (Bloomington) meeting. Added new issues 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, and 1369. (Note that many of the preceding issues are missing descriptions. These will be provided in the next revision of the issues list.)
- Revision 76, 2011-04-10: Reflected the results of the March 7, 2011 teleconference and the March, 2011 (Madrid) meeting, including adding a new status, "FDIS," for issues that are resolved in the draft advanced at that meeting for FDIS balloting. In respect for ISO rules governing work during the balloting process, no new issues have been included in this version of the list.
- Revision 75, 2011-02-28: Reflected results of two between-meetings teleconferences, including moving a number of issues to "tentatively ready" status. Added drafting for a number of issues and moved them to "review" status. Reopened issue 109 in light of recent discussion. Moved issue 1028 back to "open" status after further analysis. Moved issues 1109 and 1127 to "DR" status, as they had been overlooked in the results of the November, 2010 (Batavia) meeting. Added new issues 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, and 1246.
- Revision 74, 2010-11-29: Reflected deliberations at the November, 2010 (Batavia) meeting. Added new issues 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, and 1226.
- Revision 73, 2010-10-18: Moved issues 994 and 1058 back to "open" status for potential reconsideration. Added analysis to issue 1038. Moved issues 1125 and 1127 back to "drafting" status after further discussion revealed problems with the proposed resolution approved at the August, 2010 meeting. Moved issue 1167 to "review" status to allow consideration of extending the resolution to cover a new but related question. Reflected results of two between-meetings teleconferences, including moving a number of issues to "tentatively ready" status. Added new issues 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, and 1210,
- Revision 72, 2010-08-23: Reflected deliberations at the August, 2010 (Rapperswil) meeting. Added new issues 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 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, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, and 1173.
- Revision 71, 2010-08-07: Added new issues 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, and 1090.
- Revision 70, 2010-08-06: Reflected results of between-meetings teleconference, including moving a number of issues to "tentatively ready" status, updating proposed resolutions, and moving issues 341, 355, 472, and 529 to "drafting" status for more work. Changed issue 979 to "CD2" status, which was overlooked in the results of the March, 2010 meeting. Closed issues 1041, 1019, and 507 as duplicates of issues 924, 314, and 260, respectively.
- Revision 69, 2010-03-29: Reflected deliberations at the March, 2010 (Pittsburgh, PA) meeting. Placed all issues with "WP" status and newly-approved "DR" issues into "CD2" status, to reflect advancing the Final Committee Draft for balloting. Added new issues 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, and 1068.
- Revision 68, 2010-02-16: Reflected results of between-meeting teleconferences, including moving many issues to "tentatively ready" status and incorporating draft proposed resolutions for many others. Added new issues 999 and 1000.
- Revision 67, 2009-11-08: Reflected deliberations at the October, 2009 (Santa Cruz, CA) meeting. Added new issues 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, and 998.
- Revision 66, 2009-09-29: Incorporated a new status, "tentatively ready", for issues whose resolutions were reviewed and approved by teleconference between meetings. Changed issue 378 to "CD1" status, as it was resolved by the resolution of issue 276. Added new issues 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, and 971.
- Revision 65, 2009-08-03: Reflected deliberations from the Frankfurt, Germany (July, 2009) meeting. Added a new status, "concepts," for issues related to the concepts proposal that was removed from the working document and moved all concepts-related issues to that status, effectively closing them. Changed the presentation of proposed resolutions to use background colors in addition to font effects to identify changes (i.e., inserted and deleted text). Added new issues 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, and 948.
- Revision 64, 2009-06-19: Fixed incorrect cross-references in issues 867 and 868. Added proposed resolutions for issues 527, 587, 589, 604, 719, 732, and 770 and moved them to "review" status. Added discussion to issues 721, 760, 802, and 872. Added new issues 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, and 921.
- Revision 63, 2009-05-06: Closed issue 839 as a duplicate of issue 803. Added notes to the discussion of issues 325, 626, 667 690, 739, and 841. Moved issue 662 back to "open" status with additional discussion. Added new issues 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, and 888.
- Revision 62, 2009-03-23: Reflected deliberations from the Summit, NJ (March, 2009) meeting. Marked issues directly related to National Body comments on the 2008-10 Committee Draft with a tag identifying the relevant comment; the tag is both printed in the issue body and reflected in the "Index by Status" document. Added new issues 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 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, 839, 840, 841, and 842.
- Revision 61, 2009-02-08: Provided a reference to a paper containing a proposed resolution for issues 695 and 699 and moved them to "review" status. Added new issues 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, and 766.
- Revision 60, 2008-12-09: Revised the resolution of issue 653 and moved to "review" status. Added 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, and 748.
- Revision 59, 2008-10-05: Reflected deliberations from the San Francisco (September, 2008) meeting. Placed all issues with "WP" status and newly-approved "DR" issues into "CD1" status, to reflect advancing the Committee Draft for balloting. Added new proposed resolutions to issues 696, 704, and 705 and moved them to "review" status. Changed issue 265 to "dup" status in favor of issue 353, which was approved in 2003. Added new issues 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, and 723.
- Revision 58, 2008-08-25: Fixed some incorrect section references. Fixed the title of issue 692. Changed the status of issue 603 to "WP", as the paper that resolved it was approved in April, 2007. Moved issue 657 back to "review" status and added proposed wording. Added discussion to issues 693 and 697. Added or revised resolutions for issues 606, 614, 652, 685, and 694 and moved them to "review" status. Added new issues 704, 705, 706, 707, 708, and 709.
- Revision 57, 2008-07-27: Updated the status of issues 222, 309, and 632 to reflect actions at the June, 2008 meeting that were inadvertently omitted in the preceding revision. Added proposed wording for issue 683 and moved it to "review" status. Added new issues 697, 698, 699, 700, 701, 702, and 703.
- Revision 56, 2008-06-29: Reflected deliberations from the Sophia Antipolis (June, 2008) meeting. Added discussion to issues 507 and 527. Added proposed resolution for issue 653. Added new issues 695 and 696.
- Revision 55, 2008-05-18: Added proposed resolutions for issues 220, 257, 292, 341, 539, 554, 570, 571, 576, 597, 621, 624, 626, 633, 634, 639, and 642, and moved them to "review" status. Moved issue 155 to "dup" status in favor of issue 632, which was changed to "review" status in light of its connection with the initializer-list proposal. Moved issues 530 and 551 to "WP" status because they were resolved by the constexpr proposal. Moved issue 646 to "review" status because it appears to be "NAD". Changed issue 240 to "review" status (from "ready") in light of input from WG14 regarding a similar issue. Added new issues 685, 686, 687, 688, 689, 690, 691, 692, 693, and 694.
- Revision 54, 2008-03-17: Reflected deliberations from the Bellevue (February, 2008) meeting. Restructured references inside “definitions” sections (1.3 [intro.defs], 17.3 [definitions]) because the individual definitions are not sections. Returned issue 646 to "open" status (it was previously erroneously in "drafting" status). Moved issues 347, 512, and 236 to "review" status with a recommendation to close them as "NAD." Changed issues 220 and 256 back to "open" status and annotated them to indicate that they have been accepted by EWG and referred to CWG for action for C++0x. Changed issues 6 and 150 back to "open" status and annotated them to indicate that they have been accepted by EWG and referred to CWG for action, but not for C++0x. Closed issues 107, 168, 229, 294, and 359 as "NAD" to reflect the recommendation of EWG. Added new issues 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, and 684.
- Revision 53, 2008-02-03: Updated the proposed resolutions for issues 288 and 342. Updated the status of issues 199 and 430 to reflect actions at the Oxford (April, 2007) meeting. Added proposed resolutions and changed the status to "review" for issues 28, 111, 118, 141, 240, 276, 309, 355, 373, 378, 462, 485, 535, 574, 601, 608, 641, 645, and 651. Added new issues 667, 668, 669, 670, 671, and 672.
- Revision 52, 2007-12-09: Updated the status of issues 568 and 620 to reflect actions at the Toronto (July, 2007) meeting. Fixed a typographical error in the example for issue 606. Added new issues 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, and 666.
- Revision 51, 2007-10-09: Reflected deliberations from the Kona (October, 2007) meeting. Added new issues 652 and 653.
- Revision 50, 2007-09-09: Updated section reference numbers to use the numbering of the most recent working draft and added text identifying the document number of that draft at the beginning of each issues list document. Updated issue 475 with discussion regarding the point at which `std::uncaught_exception()` becomes `false`. Added new issues 642, 643, 644, 645, 646, 647, 648, 649, 650, and 651.
- Revision 49, 2007-08-05: Reflected deliberations from the Toronto (July, 2007) meeting. Added additional discussion to issues 219 and 339. Added new issues 637, 638, 639, 640, and 641.
- Revision 48, 2007-06-24: Added new issues 632, 633, 634, 635, and 636.
- Revision 47, 2007-05-06: Reflected deliberations from the Oxford (April, 2007) meeting. Added new issues 626, 627, 628, 629, 630, and 631.
- Revision 46, 2007-03-11: Added proposed wording to issue 495 and moved it to “review” status. Added new issues 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, and 625.
- Revision 45, 2007-01-14: Changed the status of issue 78 from TC1 to WP. Added new issues 603, 604, 605, 606, 607, 608, 609, 610, and 611.
- Revision 44, 2006-11-05: Reflected deliberations from the Portland (October, 2006) meeting. Added proposed wording for issues 288, 342, and 572, and moved them to “review” status. Added new issues 596, 597, 598, 599, 600, 601, and 602.
- Revision 43, 2006-09-09: Updated issues 218, 357, and 537 with additional discussion and proposed resolutions and moved them to “review” status; added issues 589, 590, 591, 592, 593, 594, and 595.
- Revision 42, 2006-06-23: Updated issues 408 and 561 with additional discussion; added a reference to a paper on the topic to issue 567; and added issues 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, and 588.
- Revision 41, 2006-04-22: Reflected deliberations from the Berlin (April, 2006) meeting. Added issues 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, and 577.
- Revision 40, 2006-02-24: Updated issue 540 to refer to paper J16/06-0022 = WG21 N1952 for its resolution. Updated issue 453 to note the need for additional drafting. Reopened issue 504 and broadened its scope to include object declarations as well. Updated issue 150 (in “extension” status) with additional commentary. Added issues 552, 553, 554, 555, 556, 557, 558, 559, 560, and 561.
- Revision 39, 2005-12-16: Updated issue 488 with additional discussion. Added issues 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, and 551.
- Revision 38, 2005-10-22: Reflected deliberations from the Mont Tremblant (October, 2005) meeting. Added isues 530, 531, 532, 533, 534, 535, 536, and 537.
- Revision 37, 2005-08-27: Added issues 523, 524, 525, 526, 527, 528, and 529.
- Revision 36, 2005-06-27: Reopened issue 484 for additional discussion. Added issues 517, 518, 519, 520, 521, and 522.
- Revision 35, 2005-05-01: Reflected deliberations from the Lillehammer (April, 2005) meeting. Updated issues 189 and 459 with additional discussion. Added new issues 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, and 516.
- Revision 34: 2005-03-06: Closed issue 471 as NAD; updated issues 58, 232, 339, 407, and 494 with additional discussion; and added new issues 498, 499, 500, 501, 502, and 503.
- Revision 33: 2005-01-14: Updated issue 36 with additional discussion. Added new issues 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, and 497.
- Revision 32: 2004-11-07: Reflected deliberations from the Redmond (October, 2004) meeting. Added new issues 475, 476, 477, 478, 479, 480, 481, 482, 483, and 484.
- Revision 31: 2004-09-10: Updated issue 268 with comments from WG14; added comments and changed the status of issue 451 back to “open”; added discussion to issues 334, 341, 385, 399, and 430; and added new issues 470, 471, 472, 473, and 474.
- Revision 30: 2004-04-09: Reflected deliberations from the Sydney (March, 2004) meeting. Added issues 461-469, updated issues 39, 86, 257, 291, 391, 389, 435, 436, 437, 439, 441, 442, 446, 450, 453, and 458.
- Revision 29: 2004-02-13: Added issues 441-460, updated issues 39, 291, 306, 319, 389, 394, 413, and 417.
- Revision 28: 2003-11-15: Reflected deliberations from the Kona (October, 2003) meeting. Added issues 435-438.
- Revision 27: 2003-09-19: Added new issues 412-434, updated issues 54, 301, 372, 382, 391, and 399.
- Revision 26: 2003-04-25: Reflected deliberations from the Oxford (April, 2003) meeting. Added new issues 402-411.
- Revision 25: 2003-03-03: Added new issues 390-401, updated issue 214.
- Revision 24: 2002-11-08: Reflected deliberations from the Santa Cruz (October, 2002) meeting. Added new issues 379-389.
- Revision 23: 2002-09-10: Added new issues 355-378, updated issue 298 and issue 214.
- Revision 22: 2002-05-10: Reflected deliberations from the Curacao (April, 2002) meeting. Added issues 342-354.
- Revision 21: 2002-03-11: Added new issues 314-341, updated issues 132, 214, 244, 245, 254, 255, 283.
- Revision 20: 2001-11-09: Reflected deliberations from the Redmond (October, 2001) meeting. Added issue 313.
- Revision 19: 2001-09-12: Added new issues 289-308, updated issues 222, 261, 270.
- Revision 18: 2001-05-19: Reflected deliberations from the Copenhagen (April, 2001) meeting. Added new issues 282-288.
- Revision 17: 2001-04-29: Added new issues 276-81.
- Revision 16: 2001-03-27: Updated issue 138 to discuss the interaction of using-declarations and "forward declarations." Noted a problem with the proposed resolution of issue 139. Added some new discussion to issue 115. Added proposed resolution for issue 160. Updated address of C++ FAQ. Added new issues 265-275.
- Revision 15: 2000-11-18: Reflected deliberations from the Toronto (October, 2000) meeting; moved the discussion of empty and fully-initialized const objects from issue 78 into new issue 253; added new issues 254-264.
- Revision 14: 2000-10-21: Added issues 246-252; added an extra question to issue 221 and changed its status back to "review."
- Revision 13: 2000-09-16: Added issues 229-245; changed status of issue 106 to "review" because of problem detected in proposal; added wording for issues 87 and 216 and moved to "review" status; updated discussion of issues 5, 78, 198, 203, and 222.
- Revision 12: 2000-05-21: Reflected deliberations from the Tokyo (April, 2000) meeting; added new issues 222-228.
- Revision 11, 2000-04-13: Added proposed wording and moved issues 62, 73, 89, 94, 106, 121, 134, 142, and 145 to "review" status. Moved issue 13 from "extension" to "open" status because of recent additional discussion. Added new issues 217-221.
- Revision 10, 2000-03-21: Split the issues list and indices into multiple documents. Added further discussion to issues 84 and 87. Added proposed wording and moved issues 1, 69, 85, 98, 105, 113, 132, and 178 to "review" status. Added new issues 207-216.
- Revision 9, 2000-02-23: Incorporated decisions from the October, 1999 meeting of the Committee; added issues 174 through 206.
- Revision 8, 1999-10-13: Minor editorial changes to issues 90 and 24; updated issue 89 to include a related question; added issues 169, 170, 171, 172, and 173.
- Revision 7, 1999-09-14: Removed unneeded change to 14.7.3 [temp.expl.spec] paragraph 9 from issue 24; changed issue 85 to refer to 3.4.4 [basic.lookup.elab]; added issues 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, and 168.
- Revision 6, 1999-05-31: Moved issue 72 to "dup" status; added proposed wording and moved issue 90 to "review" status; updated issue 98 with additional question; added issues 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, and 121.
- Revision 5, 1999-05-24: Reordered issues by status; added revision history; first public version.

### Issue status

Issues progress through various statuses as the Core Language Working Group and, ultimately, the full PL22.16 and WG21 committees deliberate and act. For ease of reference, issues are grouped in these documents by their status. Issues have one of the following statuses:

Open: The issue is new or the working group has not yet formed an opinion on the issue. If a Suggested Resolution is given, it reflects the opinion of the issue's submitter, not necessarily that of the working group or the Committee as a whole.

Drafting: Informal consensus has been reached in the working group and is described in rough terms in a Tentative Resolution, although precise wording for the change is not yet available.

Review: Exact wording of a Proposed Resolution is now available for an issue on which the working group previously reached informal consensus.

Ready: The working group has reached consensus that a change in the working draft is required, the Proposed Resolution is correct, and the issue is ready to forward to the full Committee for ratification.

Tentatively Ready: Like "ready" except that the resolution was produced and approved by a subset of the working group membership between meetings. Persons not participating in these between-meeting activities are encouraged to review such resolutions carefully and to alert the working group with any problems that may be found.

DR: The full Committee has approved the item as a proposed defect report. The Proposed Resolution in an issue with this status reflects the best judgment of the Committee at this time regarding the action that will be taken to remedy the defect; however, the current wording of the Standard remains in effect until such time as a Technical Corrigendum or a revision of the Standard is issued by ISO.

Accepted: Like a DR except that the issue concerns the wording of the current Working Paper rather than that of the current International Standard.

TC1: A DR issue included in Technical Corrigendum 1. TC1 is a revision of the Standard issued in 2003.

CD1: A DR issue not resolved in TC1 but included in Committee Draft 1. CD1 was advanced for balloting at the September, 2008 WG21 meeting.

CD2: A DR issue not resolved in CD1 but included in the Final Committee Draft advanced for balloting at the March, 2010 WG21 meeting.

FDIS: A DR issue not resolved in the FCD but included in the Final Draft International Standard advanced for balloting at the March, 2011 WG21 meeting.

DRWP: A DR issue whose resolution is reflected in the current Working Paper. The Working Paper is a draft for a future version of the Standard.

WP: An Accepted issue whose resolution is reflected in the current Working Paper.

Dup: The issue is identical to or a subset of another issue, identified in a Rationale statement.

NAD: The working group has reached consensus that the issue is not a defect in the Standard. A Rationale statement describes the working group's reasoning.

Extension: The working group has reached consensus that the issue is not a defect in the Standard but is a request for an extension to the language. The working group expresses no opinion on the merits of an issue with this status; however, the issue will be maintained on the list for possible future consideration as an extension proposal.

Concepts: The issue relates to the “Concepts” proposal that was removed from the working paper at the Frankfurt (July, 2009) meeting and hence is no longer under consideration.

Concurrency: The issue deals with concurrency and is to be handled by the Concurrency Working Group within WG21.

### Issues with "Ready" Status

#### 1775. Undefined behavior of line splice in raw string literal

Section: 2.2 [lex.phases] Status: ready Submitter: Canada Date: 2013-09-24
N3690 comment CA 26

According to phase 2 of 2.2 [lex.phases] paragraph 1,

> Each instance of a backslash character (`\`) immediately followed by a new-line character is deleted, splicing physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. If, as a result, a character sequence that matches the syntax of a universal-character-name is produced, the behavior is undefined.

There does not appear to be a good reason for the behavior to be undefined when the line splice occurs within a raw string literal, since the splicing will be reverted (2.5 [lex.pptoken] paragraph 3).

Proposed resolution (September, 2013):

Change 2.2 [lex.phases] paragraph 1 phase 2 as follows:

2. Each instance of a backslash character (`\`) immediately followed by a new-line character is deleted, splicing physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. If, as a result, Except for splices reverted in a raw string literal, if a splice results in a character sequence that matches the syntax of a universal-character-name is produced, the behavior is undefined. A source file that is not empty and that does not end in a new-line character, or that ends in a new-line character immediately preceded by a backslash character before any such splicing takes place, shall be processed as if an additional new-line character were appended to the file.

#### 1717. Missing specification of type of binary literal

Section: 2.14.2 [lex.icon] Status: ready Submitter: Richard Smith Date: 2013-07-23
N3690 comment ES 7

Table 6 of 2.14.2 [lex.icon] paragraph 2 covers only decimal, octal, and hexadecimal literals. Binary literals should be treated like the latter two. (It would also be more consistent to refer to these as “literals” instead of “constants.”)

Proposed resolution (September, 2013):

Change the caption and header row of Table 6 in 2.14.2 [lex.icon] paragraph 2 as follows:

Table 6 — Types of integer constants literals

Suffix | Decimal constants literal | Binary, Octal octal, or hexadecimal constant literal
--- | --- | ---

#### 1741. odr-use of class object in lvalue-to-rvalue conversion

Section: 3.2 [basic.def.odr] Status: ready Submitter: Richard Smith Date: 2013-08-21
N3690 comment CA 28

According to 4.1 [conv.lval] paragraph 2,

> if the glvalue has a class type, the [lvalue-to-rvalue] conversion copy-initializes a temporary of type `T` from the glvalue and the result of the conversion is a prvalue for the temporary.

The implications of such a conversion for odr-use do not appear to have been factored into 3.2 [basic.def.odr] paragraph 3, which exempts constant objects that are immediately lvalue-to-rvalue converted. For example, given

      struct S { int n; };
      struct T {
        static constexpr S s = {};
      };
      void f(...);
      void g() { f(T::s); }

Does this odr-use `T::s`, requiring it to have a definition, because of binding it to the reference parameter of `S`'s copy constructor? How about

      struct S { int n; };
      void f(...);
      void g() {
        constexpr S s = {};
        [] { f(s); };
      }

Does `s` need to be captured? There is implementation variance on both these examples.

Proposed resolution (September, 2013):

Change 3.2 [basic.def.odr] paragraph 3 as follows:

> A variable `x` whose name appears as a potentially-evaluated expression `ex` is odr-used unless `x` satisfies the requirements for appearing in a constant expression (5.19 [expr.const]) applying the lvalue-to-rvalue conversion (4.1 [conv.lval]) to `x` yields a constant expression (5.19 [expr.const]) that does not invoke any non-trivial functions and, if `x` is an object, `ex` is an element of the set of potential results of an expression `e`, where either the lvalue-to-rvalue conversion (4.1 [conv.lval]) is applied to `e`, or `e` is a discarded-value expression (Clause 5 [expr]). `this` is odr-used...

#### 1690. Associated namespace for local type

Section: 3.4.2 [basic.lookup.argdep] Status: ready Submitter: Ville Voutilainen Date: 2013-05-27

We can return a lambda or an object of a local class type from a lambda in c++11, and we can return them from normal functions in c++14. If those lambdas and normal functions are in a namespace, the returned lambdas/local-classes apparently aren't in that namespace, or even if they are, ADL won't find them. Is this intended?

(See also issue 1664.)

Proposed resolution (September, 2013):

This issue is resolved by the resolution of issue 1691.

#### 1691. Argument-dependent lookup and opaque enumerations

Section: 3.4.2 [basic.lookup.argdep] Status: ready Submitter: David Krauss Date: 2013-05-27

According to 3.4.2 [basic.lookup.argdep] paragraph 2,

> If `T` is an enumeration type, its associated namespace is the namespace in which it is defined. If it is class member, its associated class is the member's class; else it has no associated class.

This does not take into account opaque enumerations, which can be defined in an enclosing namespace of the one of which is a member.

Proposed resolution (September, 2013):

Change 3.4.2 [basic.lookup.argdep] paragraph 2 as follows:

> ...The sets of namespaces and classes are determined in the following way:

> - ...

> - If `T` is a class type (including unions), its associated classes are: the class itself; the class of which it is a member, if any; and its direct and indirect base classes. Its associated namespaces are the innermost enclosing namespaces of which its associated classes are members. Furthermore..

> - If `T` is an enumeration type, its associated namespace is the innermost enclosing namespace in which it is defined of its declaration. If it is a class member, its associated class is the member's class; else it has no associated class.

> - ...

This resolution also resolves issues 1690 and 1692.

#### 1692. Associated namespaces of doubly-nested classes

Section: 3.4.2 [basic.lookup.argdep] Status: ready Submitter: David Krauss Date: 2013-05-29

According to 3.4.2 [basic.lookup.argdep] paragraph 2,

> If `T` is a class type (including unions), its associated classes are: the class itself; the class of which it is a member, if any; and its direct and indirect base classes. Its associated namespaces are the namespaces of which its associated classes are members.

Consider an example like

      struct A {
        struct B {
          struct C { };
        };
      };

`A` has one associated class, itself, and has the global namespace as its associated namespace. `A::B` has two associated classes, `A` and itself, and by virtue of its association with `A`, has the global namespace as its associated namespace. `A::B::C` has two associated classes, `A::B` and itself. However, because neither `A::B` nor `A::B::C` is a member of a namespace, `A::B::C` has no associated namespaces.

This seems like a defect.

Proposed resolution (September, 2013):

This issue is resolved by the resolution of issue 1691.

#### 1773. Out-of-lifetime lvalue-to-rvalue conversion

Section: 4.1 [conv.lval] Status: ready Submitter: Canada Date: 2013-09-24
N3690 comment CA 14

Consider an example like the following:

      struct Base {
        virtual int call() = 0;
      };
      Base *foo() {
        constexpr int x = 0;
        struct Local : Base {
          virtual int call() { return x; }
        };
        static Local local;
        return &local;
      }

      int main() {
        return foo()->call();
      }

While the likely intention is that the lvalue-to-rvalue conversion of the block-scope constant is implemented by using the value of the constant expression in place of reading from storage, it seems that the wording of 4.1 [conv.lval] paragraph 2 does not prevent this program from being subject to undefined behaviour caused by lifetime violation. In particular, it seems that a name expression that appears in a potentially-evaluated expression such that the object named is not odr-used (by that instance of the name) may still be evaluated, in theory, as an lvalue through which the object named or a subobject thereof is accessed.

Proposed resolution (September, 2013):

Change 4.1 [conv.lval] paragraph 2 as follows:

> When an lvalue-to-rvalue conversion occurs in an unevaluated operand or a subexpression thereof (Clause 5 [expr]) is applied to an expression `e`, and either

> - `e` is not potentially evaluated, or

> - the evaluation of `e` results in the evaluation of a member `ex` of the set of potential results of `e`, and `ex` names a variable `x` that is not odr-used by `ex` (3.2 [basic.def.odr]),

> the value contained in the referenced object is not accessed. [Example:

>       struct S { int n; };
>       auto f() {
>         S x { 1 };
>         constexpr S y { 2 };
>         return [&](bool b) { return (b ? y : x).n; };
>       }
>       auto g = f();
>       int m = g(false); // undefined behavior due to access of x.n outside its lifetime
>       int n = g(true);  // OK, does not access y.n

> —end example] In all other cases, the result of the conversion...

#### 1607. Lambdas in template parameters

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Daniel Krügler Date: 2013-01-19
N3690 comment CA 3

Lambda expressions cannot appear in unevaluated operands nor in evaluated portions of constant expressions. However, the following example appears to circumvent those restrictions:

      template <bool> struct BoolSink { typedef void type; };

      template <typename T, typename U>
      struct AddRvalueReferenceImpl { typedef T type; };

      template <typename T>
      struct AddRvalueReferenceImpl<T, typename BoolSink<false &&
         [] {
           extern T &&tref;
         }>::type> {
        typedef T &&type;
      };

      template <typename T>
      struct AddRvalueReference : AddRvalueReferenceImpl<T, void> { };

      namespace ImplHelpers {
        template <typename T>
        typename AddRvalueReference<T>::type create(void) { }
      }

      template <typename T, typename U, typename ...Args>
      struct IsConstructibleImpl { enum { value = 0 }; };

      template <typename T, typename ...Args>
      struct IsConstructibleImpl<T, typename BoolSink<false &&
         [] {
           T t( ::ImplHelpers::create<Args>() ...);
         }>::type, Args ...> {
        enum { value = 1 };
      };

      template <typename T, typename ...Args>
      struct IsConstructible : IsConstructibleImpl<T, void, Args ...> { };

      struct DestroyMe {
        ~DestroyMe() = delete;
      };

      static_assert(+IsConstructible<int>::value, "error");
      static_assert(!IsConstructible<void>::value, "error");
      static_assert(+IsConstructible<int [1]>::value, "error");
      static_assert(!IsConstructible<DestroyMe>::value, "error");
      static_assert(!IsConstructible<int *, char *>::value, "error");

      static_assert(+IsConstructible<int &&, int>::value, "error");
      static_assert(!IsConstructible<int &&, int &>::value, "error");
      static_assert(+IsConstructible<int &&, int &&>::value, "error");

Is this intended?

Additional notes, April, 2013:

Further discussion has arisen regarding lambda-expressions in function template signatures. Although the restriction that lambda-expressions cannot appear as unevaluated operands (5.1.2 [expr.prim.lambda] paragraph 2) was intended to avert the need to deal with them in function template signatures, the fact that 5.19 [expr.const] treats unevaluated subexpressions separately from unevaluated operands opens another avenue for lambda-expressions in template signatures, e.g.,

      template<typename T>
      void f(int [(0 && [] { for (auto x : T()) {} }, 1)]);

Four possible approaches for dealing with this issue have been suggested:

1. Allow lambda-expressions in function template signatures. This would be costly in some implementations.

2. Give a function template internal linkage if its signature includes a lambda-expression. This would allow SFINAE and redeclaration to work without requiring that lambda-expressions be mangled.

3. Specify that a function signature containing a lambda-expression is not a redeclaration of any other function template, which would allow SFINAE to work but not require declaration matching and mangling.

4. Do not allow lambda-expressions in function template signatures.

If any of these approaches were adopted, the rationale for disallowing lambda-expressions in unevaluated operands would be removed, so it might make sense to remove the restriction at the same time.

Proposed resolution (September, 2013):

Change 5.1.2 [expr.prim.lambda] paragraph 2 as follows:

> ...A lambda-expression shall not appear in an unevaluated operand (Clause 5 [expr]), in a template-argument, in an alias-declaration, in a typedef declaration, or in the declaration of a function or function template outside its function body and default arguments [Note: The intention is to prevent lambdas from appearing in a signature —end note]. [Note: A closure object behaves like a function object (20.10 [function.objects]). —end note]

#### 1612. Implicit lambda capture and anonymous unions

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Michael Wong Date: 2013-01-31
N3690 comment CA 17

It is not clear from the description of capturing in 5.1.2 [expr.prim.lambda] whether an implicit capture resulting from the odr-use of a member of an anonymous union captures that member or the anonymous union, and there is implementation divergence. For example,

      int main() {
        static int result;
        struct A { int x; };
        struct B { int y; };
        union {
          A a; B b;
        };
        a.x = 1;
        [=]() mutable { a.x = 2; result = b.y; }();
        if (result == 1) return 0;
        throw 0;
      }

Notes from the April, 2013 meeting:

CWG decided that an attempt to capture a member of an anonymous union should be ill-formed.

Proposed resolution (September, 2013):

1. Change 5.1.2 [expr.prim.lambda] paragraph 15 as follows:

> ...An array of runtime bound (8.3.4 [dcl.array]) or a member of an anonymous union shall not be captured by copy.

2. Change 5.1.2 [expr.prim.lambda] paragraph 16 as follows:

> ...It is unspecified whether additional unnamed non-static data members are declared in the closure type for entities captured by reference. A member of an anonymous union shall not be captured by reference. [Note:...

#### 1613. Constant expressions and lambda capture

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Michael Wong Date: 2013-01-31
N3690 comment CA 16

Since instances of a variable in constant expressions may be odr-uses, the ordering of:

- constant expression evaluation,

- the determination of implicit captures, and

- the transformation to use closure members for odr-uses of captured variables

may affect the semantics of a program such as the one below.

The transformation under 5.1.2 [expr.prim.lambda] paragraph 17 introduces uses of the `this` pointer of the `operator()` in its function-body. This instances of `this` are invalid under issue 1369 if the transformation is applied before the evaluation of the constant expressions. Without the resolution of issue 1369, another situation occurs where instances of `this` in the compound-statement are transformed into class member access expressions (see the initializations of `addrEqA` and `addrEqB` below).

Also, for the initialization of `nonZero` below, the expression fails to be a constant expression if the transformation is applied before constant expression evaluation.

Finally, the answer to the static assertion changes depending on whether the constant expression evaluation is performed before the transformation as opposed to after and whether the proposed resolution issue 1472 is enabled.

There appears to be implementation divergence regarding

- whether the lexical instances of `this` in the initialization of `addrEqB` is valid and

- whether the static assertion should pass.

Using explicit value captures is not a panacea, since the paragraph 17 transformations only apply to odr-uses. As a result of the resolution of issue 1472, if the reference `r` below happened to have been initialized with a constant expression, the value of its (modifiable) target is not captured; if the same target were specified in the initialization of the reference with a non-constant expression, its value would be captured.

      struct A {
        void foo();
      };

      struct LitType { int val; };
      constexpr int ceFunc(const LitType &x) { return x.val; }

      void A::foo() {
        constexpr LitType y = { 0 };
        static int z;
        int x, &r = z;
        [=] {
         constexpr bool addrEqA = &x == &x;         // ill-formed under issue 1369 after transformation
                                                    // under paragraph 17
         constexpr bool addrEqB = &*this == &*this; // well-formed after transformation under N3290
                                                    // paragraph 17
         constexpr bool nonZero = ceFunc(y);        // lvalue-to-rvalue conversion occurs only after
                                                    // function invocation substitution; the closure member,
                                                    // being not a variable, cannot be constexpr
         static_assert(&r != &z,
           "reference which could be captured by value found to alias target");
                                                    // affected by issue 1472
        };
      }

Proposed resolution (September, 2013):

Add the following bullet to 5.19 [expr.const] paragraph 2:

> A conditional-expression `e` is a core constant expression unless the evaluation of `e`, following the rules of the abstract machine (1.9 [intro.execution]), would evaluate one of the following expressions:

> - ...

> - in a lambda-expression, a reference to `this` or to a variable with automatic storage duration defined outside that lambda-expression, where the reference would be an odr-use (3.2 [basic.def.odr], 5.1.2 [expr.prim.lambda]);

> - a conversion from type cv `void *` to a pointer-to-object type;

> - ...

#### 1662. Capturing function parameter packs

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Michael Wong Date: 2013-04-15
N3690 comment CA 20

The example in 5.1.2 [expr.prim.lambda] paragraph 24 reads,

      template<class... Args>
      void f(Args... args) {
        auto lm = [&, args...] { return g(args...); };
        lm();
      }

However, it's not clear how this example squares with the requirements in paragraph 10,

> The identifier in a simple-capture is looked up using the usual rules for unqualified name lookup (3.4.1 [basic.lookup.unqual]); each such lookup shall find a variable with automatic storage duration declared in the reaching scope of the local lambda expression.

since a function parameter pack is not a variable. Although the requirement might be met in a given specialization of the function template, is there a rule that relaxes it in the context of the function template definition?

Proposed resolution (September, 2013):

1. Change 5.1.2 [expr.prim.lambda] paragraph 10 as follows:

> The identifier in a simple-capture is looked up using the usual rules for unqualified name lookup (3.4.1 [basic.lookup.unqual]); each such lookup shall find an entity. An entity that is designated by a simple-capture is said to be explicitly captured, and shall be `this` or a variable with automatic storage duration declared in the reaching scope of the local lambda expression. An entity (i.e. a variable or `this`) is said to be explicitly captured if it is found by this process.

2. Change 14.5.3 [temp.variadic] paragraph 4 as follows:

> ...Pack expansions can occur in the following contexts:

> - ...

> For the purpose of determining whether a parameter pack satisfies a rule regarding entities other than parameter packs, the parameter pack is considered to be the entity that would result from an instantiation of the pattern in which it appears.

> [Example:

> ...

3. Change 14.5.3 [temp.variadic] paragraph 6 as follows:

> ...Each `E`i is generated by instantiating the pattern and replacing each pack expansion parameter with its ith element. Such an element, in the context of the instantiation, is interpreted as follows:

> - if the pack is a template parameter pack, the element is a template parameter (14.1 [temp.param]) of the corresponding kind (type or non-type) designating the type or value from the template argument; otherwise,

> - if the pack is a function parameter pack, the element is an id-expression designating the function parameter that resulted from the instantiation of the pattern where the pack is declared.

> All of the `E`i become elements in the enclosing list. [Note:...

#### 1664. Argument-dependent lookup of lambdas used in default arguments

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Michael Wong Date: 2013-04-15
N3690 comment CA 18

According to 5.1.2 [expr.prim.lambda] paragraph 3,

> The closure type is declared in the smallest block scope, class scope, or namespace scope that contains the corresponding lambda-expression. [Note: This determines the set of namespaces and classes associated with the closure type (3.4.2 [basic.lookup.argdep]). The parameter types of a lambda-declarator do not affect these associated namespaces and classes. —end note]

However, 14.7.1 [temp.inst] paragraph 13 says,

> If a function template `f` is called in a way that requires a default argument to be used, the dependent names are looked up, the semantics constraints are checked, and the instantiation of any template used in the default argument is done as if the default argument had been an initializer used in a function template specialization with the same scope, the same template parameters and the same access as that of the function template `f` used at that point.

A possibility, then, is that the closure type for a lambda expression in a default argument for a template function (or, presumably, a member function of a class template) is to be considered as having been declared in some block scope in the body of the fictional function template specialization.

Consider the following example:

      namespace J {
        inline namespace K {
          template <typename T> int zap(const T &t) { foo(t); return 0; }
          template <typename T> void zip(int = zap([] { })) { }
        }
        template <typename T> void foo(const T &) { }
      }
      void bar() { J::K::zip<long>(); }

If `zip` were not a template, argument-dependent lookup successfully resolves the lookup for `foo` in all implementations tested; however, there is implementation variance in the handling of the example as written.

(See also issue 1690.)

Proposed resolution (September, 2013):

Change 14.7.1 [temp.inst] paragraph 13 as follows:

> If a function template `f` is called in a way that requires a default argument to be used, the dependent names are looked up, the semantics constraints are checked, and the instantiation of any template used in the default argument is done as if the default argument had been an initializer used in a function template specialization with the same scope, the same template parameters and the same access as that of the function template `f` used at that point, except that the scope in which a closure type is declared (5.12 [expr.xor]) — and therefore its associated namespaces — remain as determined from the context of the definition for the default argument. This analysis is called default argument instantiation. The instantiated default argument is then used as the argument of `f`.

#### 1681. init-captures and nested lambdas

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Richard Smith Date: 2013-05-14

According to 5.1.2 [expr.prim.lambda] paragraph 10,

> The identifier in a simple-capture is looked up using the usual rules for unqualified name lookup (3.4.1 [basic.lookup.unqual]); each such lookup shall find a variable with automatic storage duration declared in the reaching scope of the local lambda expression.

This does not permit a nested lambda to capture the non-static data member of the closure type introduced by an init-capture. A similar restriction applies to implicit capture in paragraph 12.

Presumably such captures should be allowed, capturing the non-static data member directly rather than the `this` pointer from the enclosing lambda's `operator()`.

Proposed resolution (September, 2013):

This issue is resolved by the resolution of issue 1760.

#### 1760. Access of member corresponding to init-capture

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: United Kingdom Date: 2013-09-23
N3690 comment GB 3

The access of the non-static data member corresponding to an init-capture is not specified. The question would be moot if the member were unnamed like the other non-static data members of the closure class.

Proposed resolution (September, 2013):

1. Change 5.1.2 [expr.prim.lambda] paragraph 11 as follows:

> For every init-capture a non-static data member named by the identifier of the init-capture is declared in the closure type. This member is not a bit-field and not `mutable`. The type of that member corresponds to the type of a hypothetical An init-capture behaves as if it declares and explicitly captures a variable declaration of the form “`auto` init-capture ;” whose declarative region is the lambda-expression's compound-statement, except that the variable name (i.e., the identifier of the init-capture) is replaced by a unique identifier.:

> - if the capture is by copy (see below), the non-static data member declared for the capture and the variable are treated as two different ways of referring to the same object, which has the lifetime of the non-static data member, and no additional copy and destruction is performed, and

> - if the capture is by reference, the variable's lifetime ends when the closure object's lifetime ends.

> [Note: This enables an init-capture like “`x = std::move(x)`”; the second “`x`” must bind to a declaration in the surrounding context. —end note] No entity is captured by an init-capture. Within the lambda-expressions lambda-declarator and compound-statement, the identifier in the init-capture hides any declaration of the same name in scopes enclosing the lambda-expression. [Example:...

2. Change 5.1.2 [expr.prim.lambda] paragraph 15 as follows:

> An entity is captured by copy if it is implicitly captured and the capture-default is `=` or if it is explicitly captured with a capture that does not include an `&` is not of the form `&` identifier or `&` identifier initializer. For each entity...

3. Change 5.1.2 [expr.prim.lambda] paragraph 18 as follows:

> Every id-expression within the compound-statement of a lambda-expression that is an odr-use (3.2 [basic.def.odr]) of an entity captured by copy is transformed into an access to the corresponding unnamed data member of the closure type. [Note:...

This resolution also resolves issue 1681.

#### 1772. `__func__` in a lambda body

Section: 5.1.2 [expr.prim.lambda] Status: ready Submitter: Switzerland/Canada Date: 2013-09-24
N3690 comment CH 5
N3690 comment CA 22

It is not clear whether `__func__` in the body of a lambda refers to the `operator()` of the closure class or to the containing function (if any). Since lambdas can appear in non-function scope, it would be preferable for them to refer to the closure class's `operator()`.

Proposed resolution (September, 2013):

Change 5.1.2 [expr.prim.lambda] paragraph 7 as follows:

> The lambda-expression's compound-statement yields the function-body... —end example] Further, a variable `__func__` is implicitly defined at the beginning of the compound-statement of the lambda-expression, with semantics as described in 8.4.1 [dcl.fct.def.general].

#### 1376. `static_cast` of temporary to rvalue reference

Section: 5.2.9 [expr.static.cast] Status: ready Submitter: Michael Wong Date: 2011-08-17
N3690 comment CA 1

In a declaration like

        T&& r = static_cast<T&&>(T());

it is not clear what the lifetime of the `T` temporary should be. According to 5.2.9 [expr.static.cast] paragraph 4, the `static_cast` is equivalent to a declaration of an invented temporary variable `t`. The lifetime of the temporary is extended to that of `t`, but it is not clear what that lifetime should be, nor if the subsequent binding of `t` to `r` would affect the lifetime of the original temporary. (See also issue 1568.)

Notes from the February, 2012 meeting:

The reference is bound to the xvalue result of the `static_cast`, so the lifetime of the temporary is not extended and this example results in a dangling reference.

Proposed resolution (February, 2012) [SUPERSEDED]:

Change 5.2.9 [expr.static.cast] paragraph 4 as follows:

> Otherwise, an expression `e` can be explicitly converted to a type `T` using a `static_cast` of the form `static_cast<T>(e)` if the declaration `T t(e);` is well-formed, for some invented temporary variable `t` (8.5 [dcl.init]). The effect...

Proposed resolution (September, 2013):

Change 5.2.9 [expr.static.cast] paragraph 3 as follows:

> A glvalue, class prvalue, or array prvalue of type “cv1 `T1`” can be cast to type “rvalue reference to cv2 `T2`” if “cv2 `T2`” is reference-compatible with “cv1 `T1`” (8.5.3 [dcl.init.ref]). If the glvalue value is not a bit-field, the result refers to the object or the specified base class subobject thereof; otherwise, the lvalue-to-rvalue conversion (4.1 [conv.lval]) is applied to the bit-field and the resulting prvalue is used as the expression of the `static_cast` for the remainder of this section. If `T2` is an inaccessible (Clause 11 [class.access]) or ambiguous (10.2 [class.member.lookup]) base class of `T1`, a program that necessitates such a cast is ill-formed.

#### 1767. Scoped enumeration in a `switch` statement

Section: 6.4.2 [stmt.switch] Status: ready Submitter: Canada Date: 2013-09-23
N3690 comment CA 8

The description of the `switch` statement and case labels in 6.4.2 [stmt.switch] paragraph 2 apply integral promotions to the condition value and refer to the “promoted type” of the condition. However, the integral promotions (4.5 [conv.prom]) do not describe the result when they are applied to a scoped enumeration value.

Proposed resolution (September, 2013):

Change 6.4.2 [stmt.switch] paragraph 2 as follows:

> The condition shall be of integral type, enumeration type, or class type. If of class type, the condition is contextually implicitly converted (Clause 4 [conv]) to an integral or enumeration type. Integral promotions are performed. If the (possibly converted) type is subject to integral promotions (4.5 [conv.prom]), the condition is converted to the promoted type. Any statement within the `switch` statement can be labeled with one or more case labels as follows:

> `case` constant-expression `:`

> where the constant-expression shall be a converted constant expression (5.19 [expr.const]) of the promoted adjusted type of the switch condition. No two of the case constants in the same switch shall have the same value after conversion to the promoted type of the switch condition.

#### 1765. Overflow of enumeration used as enumerator value

Section: 7.2 [dcl.enum] Status: ready Submitter: Canada Date: 2013-09-23
N3690 comment CA 7

Regarding the value of an enumerator whose enumeration's underlying type is not fixed, 7.2 [dcl.enum] paragraph 5 says,

> the type of the initializing value is the same as the type of the initializing value of the preceding enumerator unless the incremented value is not representable in that type, in which case the type is an unspecified integral type sufficient to contain the incremented value.

It is not clear how this is to be applied when the preceding enumerator value is given by an enumerator whose value is the largest of its enumeration's values, and there is implementation variance on this point.

Proposed resolution (September, 2013):

Change 7.2 [dcl.enum] paragraph 5 as follows:

> ...If the underlying type is fixed, the type of each enumerator enumerator prior to the closing brace is the underlying type and the constant-expression in the enumerator-definition shall be a converted constant expression of the underlying type (5.19 [expr.const]); if the initializing value of an enumerator cannot be represented by the underlying type, the program is ill-formed. If the underlying type is not fixed, the type of each enumerator prior to the closing brace is the type of its initializing value determined as follows:

> - If an initializer is specified for an enumerator, the initializing value the constant-expression shall be an integral constant expression (5.19 [expr.const]). If the expression has unscoped enumeration type, the enumerator has the underlying type of that enumeration type, otherwise it has the same type as the expression and the constant-expression shall be an integral constant expression (5.19 [expr.const]).

> - If no initializer is specified for the first enumerator, the initializing value has its type is an unspecified integral type.

> - Otherwise the type of the initializing value enumerator is the same as the type that of the initializing value of the preceding enumerator unless the incremented value is not representable in that type, in which case the type is an unspecified integral type sufficient to contain the incremented value. If no such type exists, the program is ill-formed.

#### 1761. Runtime check on size of automatic array

Section: 8.3.4 [dcl.array] Status: ready Submitter: USA Date: 2013-09-23
N3690 comment US 10

The runtime check for violating the maximum size of a stack-based array object is ill-advised. Many implementations cannot easily determine the available stack space, and checking against a fixed limit is not helpful.

Proposed resolution (September, 2013):

Change 8.3.4 [dcl.array] paragraph 1 as follows:

> ...The expression is erroneous if:

> - its value before converting...

> - its value is such that the size of the allocated object would exceed the implementation-defined limit for the maximum size of an object (Annex B [implimits]);

> - ...

> ...If the expression is erroneous, an exception of a type that would match a handler (15.3 [except.handle]) of type `std::bad_array_length` (18.6.2.2 [bad.array.length]) is thrown [Footnote: Implementations are encouraged also to throw such an exception if the size of the object would exceed the remaining stack space. —end footnote].

This resolution also resolves issue 1675.

#### 1768. Zero-element array of runtime bound

Section: 8.3.4 [dcl.array] Status: ready Submitter: USA Date: 2013-09-24
N3690 comment US 9

C-style variable-length arrays (which have been widely implemented as extensions to C++) permit a zero-length array. Similarly, arrays created by new-expressions can have a length of zero. Forbidding zero-length arrays of runtime bound is a gratuitous incompatibility.

Proposed resolution (September, 2013):

1. Change 8.3.4 [dcl.array] paragraph 1 as follows:

> ...The expression is erroneous if:

> - its value before converting to `std::size_t` or, in the case of an expression of class type, before application of the second standard conversion (13.3.3.1.2 [over.ics.user]) is less than or equal to zero;

> - ...

> If the expression, after converting to `std::size_t`, is a core constant expression and the expression is erroneous or its value is zero, the program is ill-formed. If the expression... `std::bad_array_length` (18.6.2.2 [bad.array.length]) is thrown. An object of array type If `N` is zero, an object of array type has no elements. Otherwise, it contains a contiguously allocated non-empty set of `N` subobjects of type `T`. The type...

#### 1778. exception-specification in explicitly-defaulted functions

Section: 8.4.2 [dcl.fct.def.default] Status: ready Submitter: USA Date: 2013-09-25
N3690 comment US 23

According to 8.4.2 [dcl.fct.def.default] paragraph 2,

> An explicitly-defaulted function may be declared `constexpr` only if it would have been implicitly declared as `constexpr`, and may have an explicit exception-specification only if it is compatible (15.4 [except.spec]) with the exception-specification on the implicit declaration.

The requirement for exception-specifications has unfortunate consequences for the standard library component `atomic`, as described in LWG issue 2165: the component cannot be used with a `T` unless `T` is nothrow default constructible, even if the `std::atomic<T>` variable is never default initialized.

Proposed resolution (September, 2013):

Change 8.4.2 [dcl.fct.def.default] paragraphs 2 and 3 as follows:

> An explicitly-defaulted function may be declared `constexpr` only if it would have been implicitly declared as `constexpr`, and may have an explicit exception-specification only if it is compatible (15.4 [except.spec]) with the exception-specification on the implicit declaration. If a function is explicitly defaulted on its first declaration,

> - it is implicitly considered to be `constexpr` if the implicit declaration would be, and,

> - it is implicitly considered to have the same exception-specification as if it had been implicitly declared (15.4 [except.spec]).

> If a function that is explicitly defaulted has an explicit exception-specification that is not compatible (15.4 [except.spec]) with the exception-specification on the implicit declaration, then

> - if the function is explicitly defaulted on its first declaration, it is defined as deleted;

> - otherwise, the program is ill-formed.

> [Example:

>       struct S {
>         constexpr S() = default;            // ill-formed: implicit S() is not constexpr
>         S(int a = 0) = default;             // ill-formed: default argument
>         void operator=(const S&) = default; // ill-formed: non-matching return type
>         ~S() throw(int) = default;          // ill-formed deleted: exception specification does not match
>       private:
>         int i;
>         S(S&);                              // OK: private copy constructor
>       };
>       S::S(S&) = default;                   // OK: defines copy constructor

> —end example]

#### 1604. Double temporaries in reference initialization

Section: 8.5.3 [dcl.init.ref] Status: ready Submitter: Nikolay Ivchenkov Date: 2013-01-10
N3690 comment CA 30

Bullet 2 sub-bullet 2 of 8.5.3 [dcl.init.ref] paragraph 5 says,

> Otherwise, a temporary of type “cv1 T1” is created and initialized from the initializer expression using the rules for a non-reference copy-initialization (8.5 [dcl.init]). The reference is then bound to the temporary.

It is not clear what “using the rules for a non-reference copy-initialization” means. If it means that the temporary is initialized as if it were a standalone variable, the last bullet of 8.5 [dcl.init] paragraph 17 could apply:

> Otherwise (i.e., for the remaining copy-initialization cases), user-defined conversion sequences that can convert from the source type to the destination type or (when a conversion function is used) to a derived class thereof are enumerated as described in 13.3.1.4 [over.match.copy], and the best one is chosen through overload resolution (13.3 [over.match]). If the conversion cannot be done or is ambiguous, the initialization is ill-formed. The function selected is called with the initializer expression as its argument; if the function is a constructor, the call initializes a temporary of the cv-unqualified version of the destination type. The temporary is a prvalue. The result of the call (which is the temporary for the constructor case) is then used to direct-initialize, according to the rules above, the object that is the destination of the copy-initialization.

That is, for an example like

      struct X {
        X(int) {}
          X(X const &) = delete;
        };

      void f() {
        X const &x = 0;
      }

the specification requires creation of a temporary `X(0)`, copying that tempoary to another temporary (subject to copy elision), and binding the reference to that second temporary. In the example above, because the copy constructor is deleted, the example is ill-formed, although current implementations fail to diagnose it as an error.

Is this intended?

Proposed resolution (September, 2013):

1. Change the last bullet of 8.5.3 [dcl.init.ref] paragraph 5, breaking it into sub-bullets, and the subsequent example as follows:

- Otherwise:

- If `T1` is a class type, user-defined conversions are considered using the rules for copy-initialization of an object of type “cv1 `T1`” by user-defined conversion (8.5 [dcl.init], 13.3.1.4 [over.match.copy]); the program is ill-formed if the corresponding non-reference copy-initialization would be ill-formed. The result of the call to the conversion function, as described for the non-reference copy-initialization, is then used to direct-initialize the reference. The program is ill-formed if the direct-initialization does not result in a direct binding or if it involves a user-defined conversion.

- If `T1` is a non-class type, a temporary of type “cv1 `T1`” is created and copy-initialized (8.5 [dcl.init]) from the initializer expression using the rules for a non-reference copy-initialization (8.5 [dcl.init]). The reference is then bound to the temporary.

If `T1` is reference-related to `T2`,:

- cv1 shall be the same cv-qualification as, or greater cv-qualification than, cv2.; and

- If `T1` is reference-related to `T2` and if the reference is an rvalue reference, the initializer expression shall not be an lvalue.

[Example:

      struct Banana { };
      struct Enigma { operator const Banana(); };
      void enigmatic() {
        typedef const Banana ConstBanana;
        Banana &&banana1 = ConstBanana(); // ill-formed
        Banana &&banana2 = Enigma();      // ill-formed
      }

      const double& rcd2 = 2;             // rcd2 refers to temporary with value 2.0
      ...

2. Change 13.3.1.4 [over.match.copy] paragraph 1 as follows:

> Under the conditions specified in 8.5 [dcl.init], as part of a copy-initialization of an object of class type, a user-defined conversion can be invoked to convert an initializer expression to the type of the object being initialized. Overload resolution is used to select the user-defined conversion to be invoked. [Note: The conversion performed for indirect binding to a reference to a possibly cv-qualified class type is determined in terms of a corresponding non-reference copy-initialization. —end note] Assuming that

#### 1764. Hiding of function from using-declaration by signature

Section: 10.2 [class.member.lookup] Status: ready Submitter: Canada Date: 2013-09-23
N3690 comment CA 6

According to 7.3.3 [namespace.udecl] paragraph 15,

> When a using-declaration brings names from a base class into a derived class scope, member functions and member function templates in the derived class override and/or hide member functions and member function templates with the same name, parameter-type-list (8.3.5 [dcl.fct]), cv-qualification, and ref-qualifier (if any) in a base class (rather than conflicting).

The algorithm for class-scope name lookup given in 10.2 [class.member.lookup], however, does not implement this requirement; there is nothing that removes a hidden base class member (replacing the using-declaration, per paragraph 3) from the result set.

Proposed resolution (September, 2013):

Change 10.2 [class.member.lookup] paragraph 3 as follows:

> The lookup set for `f` in `C`, called S(f, C), consists of two component sets: the declaration set, a set of members named `f`; and the subobject set, a set of subobjects where declarations of these members (possibly including using-declarations) were found. In the declaration set, using-declarations are replaced by the members they designate set of designated members that are not hidden or overridden by members of the derived class (7.3.3 [namespace.udecl]), and type declarations (including injected-class-names) are replaced by the types they designate...

#### 1344. Adding new special member functions to a class via default arguments

Section: 12.8 [class.copy] Status: ready Submitter: Sean Hunt Date: 2011-08-16
N3690 comment CA 29

If default arguments added in the out-of-class definition of a constructor make it a special member function, this can affect the overload resolution and thus the implicit exception specification and the triviality of an implicitly-declared special member function in a derived class.

See also issue 1496, which should also be addressed by the resolution of this issue.

Notes from the September, 2013 meeting:

It was decided to resolve this issue separately from issue 1496, which is now decoupled from this issue.

Proposed resolution (September, 2013):

1. Change 8.3.6 [dcl.fct.default] paragraph 6 as follows:

> Except for member functions of class templates, the default arguments in a member function definition that appears outside of the class definition are added to the set of default arguments provided by the member function declaration in the class definition; the program is ill-formed if a default constructor (12.1 [class.ctor]), copy or move constructor, or copy or move assignment operator (12.8 [class.copy]) is so declared. Default arguments for a member function of a class template shall be specified on the initial declaration of the member function within the class template. [Example:...

2. Delete the following from 12.8 [class.copy] paragraph 7:

> ...The latter case is deprecated if the class has a user-declared copy assignment operator or a user-declared destructor. Thus, for the class definition

>       struct X {
>         X(const X&, int);
>       };

> a copy constructor is implicitly-declared. If the user-declared constructor is later defined as

>       X::X(const X& x, int i =0) { /* ... */ }

> then any use of `X`'s copy constructor is ill-formed because of the ambiguity; no diagnostic is required.

#### 1493. Criteria for move-construction

Section: 12.8 [class.copy] Status: ready Submitter: John Spicer Date: 2012-04-02
N3690 comment CA 23

The decision in 12.8 [class.copy] paragraph 32 on whether or not a copy must be replaced by a move is phrased largely in terms of when copy elision can be performed, as described in the preceding paragraph. In particular, the fourth bullet of paragraph 31 applies

> when the exception-declaration of an exception handler (Clause 15 [except]) declares an object of the same type (except for cv-qualification) as the exception object (15.1 [except.throw]), the copy/move operation can be omitted by treating the exception-declaration as an alias for the exception object if the meaning of the program will be unchanged except for the execution of constructors and destructors for the object declared by the exception-declaration.

The determination of “when the meaning of the program will be unchanged” is, in the general case, not practical. Copy elision is optional, meaning that the compiler can simply choose not to perform it if the determination is too difficult. Choosing whether to do a copy or a move, however, is mandatory, even if the copy is elided, and such a broad criterion is not appropriate. Probably the best way to address this problem would be to eliminate exception-declarations as a possible target for move-construction.

(See also issue 1579.)

Proposed resolution (September, 2013):

Change 12.8 [class.copy] paragraphs 31 and 32 as follows:

> ...This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies):

> - ...

> - when the exception-declaration of an exception handler (Clause 15 [except]) declares an object of the same type (except for cv-qualification) as the exception object (15.1 [except.throw]), the copy/move operation can be omitted by treating the exception-declaration as an alias for the exception object if the meaning of the program will be unchanged except for the execution of constructors and destructors for the object declared by the exception-declaration. [Note: there cannot be a move from the exception object because it is always an lvalue. —end note]

> [Example:...

> When the criteria for elision of a copy/move operation are met, but not for an exception-declaration, or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. If the first overload resolution fails or was not performed, or if the type of the first parameter of the selected constructor is not an rvalue reference to the object's type (possibly cv-qualified), overload resolution is performed again, considering the object as an lvalue. [Note:...

#### 1579. Return by converting move constructor

Section: 12.8 [class.copy] Status: ready Submitter: Jeffrey Yasskin Date: 2012-10-23
N3690 comment US 13

Currently the conditions for moving from an object returned from a function are tied closely to the criteria for copy elision, which requires that the type of the object being returned be the same as the return type of the function. Another possibility that should be considered is to allow something like

      optional<T> foo() {
        T t;
        ...
        return t;
      }

and allow `optional<T>::optional(T&&)` to be used for the initialization of the return type. Currently this can be achieved explicitly by use of `std::move`, but it would be nice not to have to remember to do so.

Similarly, the current rules apply only to complete objects; it could make sense to allow moving from subobjects of local objects.

(See also issue 1493 for other questions about the criteria for moving from a returned object.)

Rationale (April, 2013):

CWG felt that this suggestion should be considered in a broader context and was thus more appropriate for EWG.

Additional note (September, 2013):

Returned to "open" status in light of CD National Body comment.

Proposed resolution (September, 2013):

Change 12.8 [class.copy] paragraph 32 as follows:

> When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, or when the expression in a `return` statement is a (possibly parenthesized) id-expression that names an object with automatic storage duration declared in the body or parameter-declaration-clause of the innermost enclosing function or lambda-expression, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. If overload resolution fails...

#### 1762. Reserved identifier used in literal-operator-id example

Section: 13.5.8 [over.literal] Status: ready Submitter: Switzerland Date: 2013-09-23
N3690 comment CH 6

The example in 13.5.8 [over.literal] paragraph 8 contains the line

      float operator ""E(const char*); // OK

`E` does not begin with an underscore and thus is a reserved name.

Proposed resolution (September, 2013):

Change the example in 13.5.8 [over.literal] paragraph 8 as follows:

      void operator "" _km(long double);                     // OK
      string operator "" _i18n(const char*, std::size_t);    // OK
      template <char...> double operator "" _\u03C0();       // OK: UCN for lowercase pi
      float operator ""_E(const char*);                      // OK
      float operator ""E(const char*);                       // error: reserved identifier
      float operator " " B(const char*);                     // error: non-empty string-literal
      string operator "" 5X(const char*, std::size_t);       // error: invalid literal suffix identifier
      double operator "" _miles(double);                     // error: invalid parameter-declaration-clause
      template <char...> int operator "" _j(const char*);    // error: invalid parameter-declaration-clause

#### 1770. Type matching of non-type template parameters and arguments

Section: 14.8.2.5 [temp.deduct.type] Status: ready Submitter: Canada Date: 2013-09-24
N3690 comment CA 15

According to 14.8.2.5 [temp.deduct.type] paragraph 17,

> If, in the declaration of a function template with a non-type template-parameter, the non-type template-parameter is used in an expression in the function parameter-list and, if the corresponding template-argument is deduced, the template-argument type shall match the type of the template-parameter exactly, except that a template-argument deduced from an array bound may be of any integral type.

This does not cover return types, leaving the outcome of an example like the following unclear:

      template <int N> struct A;

      template <short N>
      A<N> *foo();

      void bar() {
        A<1> *(*fp)(void) = &foo;
      }

Proposed resolution (September, 2013):

Change 14.8.2.5 [temp.deduct.type] paragraph 17 as follows:

> If, in the declaration of a function template with a non-type template-parameter, the non-type template-parameter is used in an expression in the function parameter-list and, if the corresponding template-argument is deduced, the template-argument type shall match the type of the template-parameter exactly, except that a template-argument deduced from an array bound may be of any integral type `P` has a form that contains `<i>`, and if the type of the corresponding value of `A` differs from the type of `i`, deduction fails. If `P` has a form that contains `[i]`, and if the type of `i` is not an integral type, deduction fails.147 [Example:...

#### 1740. Disambiguation of `noexcept`

Section: 15.4 [except.spec] Status: ready Submitter: Richard Smith Date: 2013-08-13
N3690 comment CA 27

There is an ambiguity between a `noexcept` specifier's optional parenthesized constant-expression and an initializer:

      void f() noexcept;
      void (*p)() noexcept (&f);

Here, we can just about make 8.2 [dcl.ambig.res] paragraph 1's rule fit, and say that the `(&f)` is part of the exception-specification rather than being an initializer. However, this case is much more problematic:

      void (*fp2)() noexcept, (*fp)() noexcept (fp2 = 0);

The `(fp = 0)` here is unambiguously an initializer, because an assignment-expression cannot syntactically be a constant-expression, although current implementations treat it as an ill-formed part of the exception-specification.

Probably the best approach would be to change 15.4 [except.spec] to say that a `(` following `noexcept` is always treated as being part of the noexcept-specification.

Proposed resolution (September, 2013):

Change 15.4 [except.spec] paragraph 1 as follows:

> ...In a noexcept-specification, the constant-expression, if supplied, shall be a constant expression (5.19 [expr.const]) that is contextually converted to bool (Clause 4 [conv]). A noexcept-specification `noexcept` is equivalent to `noexcept( true)`. A `(` token that follows `noexcept` is part of the noexcept-specification (and does not commence an initializer (8.5 [dcl.init]).

#### 1675. Size limit for automatic array object

Section: B [implimits] Status: ready Submitter: Jason Merrill Date: 2013-05-03

8.3.4 [dcl.array] paragraph 1 says,

> The expression is erroneous if:

> - ...

> - its value is such that the size of the allocated object would exceed the implementation-defined limit (Annex B [implimits]);

> - ...

The only relevant limit in B [implimits] is that of the size of an object, but presumably an implementation might want to impose a smaller limit on a stack-based object. This separate quantity is referred to in paragraph 4 when describing an array of unspecified bound:

> If the size of the array exceeds the size of the memory available for objects with automatic storage duration, the behavior is undefined.

but perhaps it needs to be mentioned in B [implimits] as well.

Proposed resolution (September, 2013):

This issue is resolved by the resolution of issue 1761.

### Issues with "Tentatively Ready" Status

#### 1611. Deleted default constructor for abstract class

Section: 12.1 [class.ctor] Status: tentatively ready Submitter: Ville Voutilainen Date: 2013-01-31

Bullet 6 of 12.1 [class.ctor] paragraph 5 gives an abstract class a deleted default constructor when the virtual base has no default constructor, even though the abstract class's default constructor can never construct the virtual base class subobject. This seems parallel to the case described in issue 257 for mem-initializers. Should a similar accommodation be made to avoid deleted default constructors in abstract classes?

Notes from the April, 2013 meeting:

CWG agreed that a virtual base class should not cause an abstract class's default constructor to be defined as deleted.

Proposed resolution (August, 2013):

Change 12.1 [class.ctor] paragraph 4 as follows:

> ...A defaulted default constructor for class `X` is defined as deleted if:

> - ...

> - any direct or virtual base class, or non-static data member with no brace-or-equal-initializer, or any direct base class, or, if `X` is not abstract, any virtual base class, has class type `M` (or array thereof) and either `M` has no default constructor or overload resolution (13.3 [over.match]) as applied to `M`'s default constructor results in an ambiguity or in a function that is deleted or inaccessible from the defaulted default constructor, or

> - ...

### Issues with "Review" Status

#### 1614. Address of pure virtual function vs odr-use

Section: 3.2 [basic.def.odr] Status: review Submitter: Richard Smith Date: 2013-01-31

According to 3.2 [basic.def.odr] paragraph 3,

> A function whose name appears as a potentially-evaluated expression is odr-used if it is the unique lookup result or the selected member of a set of overloaded functions (3.4 [basic.lookup], 13.3 [over.match], 13.4 [over.over]), unless it is a pure virtual function and its name is not explicitly qualified.

In the following example, consequently, `S::f` is odr-used but not defined, and (because it is an undefined odr-used inline function) a diagnostic is required:

      namespace {
        struct S {
          inline virtual void f() = 0;
        };
       void (S::*p) = &S::f;
      }

However, `S::f` cannot be called through such a pointer-to-member, so forming a pointer-to-member should not cause a pure virtual function to be odr-used. There is implementation divergence on this point.

Proposed resolution (April, 2013):

Change 3.2 [basic.def.odr] paragraph 3 as follows:

> ...A virtual member function is odr-used if it is not pure. A function whose name appears as a potentially-evaluated expression is odr-used if it is the unique lookup result or the selected member of a set of overloaded functions (3.4 [basic.lookup], 13.3 [over.match], 13.4 [over.over]), unless it is a pure virtual function and either its name is not explicitly qualified or the expression forms a pointer to member (5.3.1). [Note:...

#### 1603. Errors resulting from giving unnamed namespaces internal linkage

Section: 3.5 [basic.link] Status: review Submitter: Richard Smith Date: 2013-01-09

In C++03, all namespace-scope names had external linkage unless explicitly declared otherwise (via `static`, `const`, or as a member of an anonymous union). C++11 now specifies that members of an unnamed namespace have internal linkage (see issue 1113). This change invalidated a number of assumptions scattered throughout the Standard that need to be adjusted:

1. 3.5 [basic.link] paragraph 5 says,

> a member function, static data member, a named class or enumeration of class scope, or an unnamed class or enumeration defined in a class-scope typedef declaration such that the class or enumeration has the typedef name for linkage purposes (7.1.3 [dcl.typedef]), has external linkage if the name of the class has external linkage.

There is no specification for the linkage of such members of a class with internal linkage. Formally, at least, that leads to the statement in paragraph 8 that such members have no linkage. This omission also contradicts the note in 9.3 [class.mfct] paragraph 3:

> [Note: Member functions of a class in namespace scope have external linkage. Member functions of a local class (9.8 [class.local]) have no linkage. See 3.5 [basic.link]. —end note]

as well as the statement in 9.4.2 [class.static.data] paragraph 5,

> `Static` data members of a class in namespace scope have external linkage (3.5 [basic.link]).

2. The footnote in 3.5 [basic.link] paragraph 8 says,

> A class template always has external linkage, and the requirements of 14.3.1 [temp.arg.type] and 14.3.2 [temp.arg.nontype] ensure that the template arguments will also have appropriate linkage.

This is incorrect, since templates in unnamed namespaces now have internal linkage and template arguments are no longer required to have external linkage.

3. The statement in 7.1.1 [dcl.stc] paragraph 7 is now false:

> A name declared in a namespace scope without a storage-class-specifier has external linkage unless it has internal linkage because of a previous declaration and provided it is not declared `const`.

4. The entire treatment of unique in 7.3.1.1 [namespace.unnamed] is no longer necessary, and the footnote is incorrect:

> Although entities in an unnamed namespace might have external linkage, they are effectively qualified by a name unique to their translation unit and therefore can never be seen from any other translation unit.

Names in unnamed namespaces never have external linkage.

5. According to 11.3 [class.friend] paragraph 4,

> A function first declared in a friend declaration has external linkage (3.5 [basic.link]).

This presumably is incorrect for a class that is a member of an unnamed namespace.

6. According to 14 [temp] paragraph 4,

> A non-member function template can have internal linkage; any other template name shall have external linkage.

Taken literally, this would mean that a template could not be a member of an unnamed namespace.

Proposed resolution (April, 2013):

1. Change 3.5 [basic.link] paragraph 5 as follows:

> In addition, a member function, static data member, a named class or enumeration of class scope, or an unnamed class or enumeration defined in a class-scope typedef declaration such that the class or enumeration has the typedef name for linkage purposes (7.1.3 [dcl.typedef]), has external linkage if the name of the class has external linkage the same linkage, if any, as the name of the class of which it is a member..

2. Change the footnote in 3.5 [basic.link] paragraph 8 as follows:

> 33) A class template always has external linkage, and the requirements of 14.3.1 [temp.arg.type] and 14.3.2 [temp.arg.nontype] ensure that the template arguments will also have appropriate linkage has the linkage of the innermost enclosing class or namespace in which it is declared.

3. Change 7.1.1 [dcl.stc] paragraph 7 as follows:

> A name declared in a namespace scope without a storage-class-specifier has external linkage the same linkage as the namespace unless it has internal linkage because of a previous declaration and provided it is not declared const.

4. Change 7.3.1.1 [namespace.unnamed] paragraph 1 as follows:

> An unnamed-namespace-definition behaves as if it were replaced by

>       inlineopt namespace unique { /* empty body */ }
>       using namespace unique ;
>       namespace unique { namespace-body }

> where `inline` appears if and only if it appears in the unnamed-namespace-definition, and all occurrences of unique in a translation unit are replaced by the same identifier., and this identifier differs from all other identifiers in the entire program. [Footnote: Although entities in an unnamed namespace might have external linkage, they are effectively qualified by a name unique to their translation unit and therefore can never be seen from any other translation unit. —end footnote] [Example:...

5. Change the note in 9.3 [class.mfct] paragraph 3 as follows:

> [Note: Member functions of a class in namespace scope have external linkage the linkage of that class. Member functions of a local class (9.8 [class.local]) have no linkage. See 3.5 [basic.link]. —end note]

6. Change 9.4.2 [class.static.data] paragraph 5 as follows:

> `Static` data members of a class in namespace scope have external linkage the linkage of that class (3.5 [basic.link]).

7. Change 11.3 [class.friend] paragraph 4 as follows:

> A function first declared in a friend declaration has external linkage the linkage of the namespace of which it is a member (3.5 [basic.link]). Otherwise, the function retains its previous linkage (7.1.1 [dcl.stc]).

8. Change 14 [temp] paragraph 4 as follows:

> A template name has linkage (3.5 [basic.link]). A non-member function template can have internal linkage; any other template name shall have external linkage. Specializations (explicit or implicit) of a template that has internal linkage are distinct from all specializations in other translation units...

#### 1686. Which variables are “explicitly declared `const`?”

Section: 3.5 [basic.link] Status: review Submitter: Daniel Krügler Date: 2013-05-17

According to 3.5 [basic.link] paragraph 3,

> A name having namespace scope (3.3.6 [basic.scope.namespace]) has internal linkage if it is the name of

> - ...

> - a non-volatile variable that is explicitly declared `const` or `constexpr` and neither explicitly declared `extern` nor previously declared to have external linkage; or

> - ...

It would be more precise and less confusing if the phrase “explicitly declared `const`” were replaced by saying that its type is const-qualified. This change would also allow removal of the reference to `constexpr`, which was added by issue 1112 because `constexpr` variables are implicitly const-qualified but not covered by the “explicitly declared” phrasing.

Proposed resolution (September, 2013):

Change the second bullet of 3.5 [basic.link] paragraph 3 as follows:

- a non-volatile variable that is explicitly declared `const` or `constexpr` and of non-volatile const-qualified type that is neither explicitly declared `extern` nor previously declared to have external linkage; or

#### 1465. `noexcept` and `std::bad_array_new_length`

Section: 5.3.7 [expr.unary.noexcept] Status: review Submitter: Daniel Krügler Date: 2012-02-12

The list of causes for a `false` result of the `noexcept` operator does not include a new-expression with a non-constant array bound, which could result in an exception even if the allocation function that would be called is declared not to throw (see 5.3.4 [expr.new] paragraph 7).

Proposed resolution (October, 2012):

This issue is resolved by the resolution of issue 1351.

#### 1685. Value category of `noexcept` expression

Section: 5.3.7 [expr.unary.noexcept] Status: review Submitter: Daniel Krügler Date: 2013-05-16

According to 5.3.7 [expr.unary.noexcept] paragraph 2,

> The result of the `noexcept` operator is a constant of type `bool` and is an rvalue.

Obviously, the result should be a prvalue.

(See also issue 1642, which deals with missing specifications of value categories.)

Notes from the September, 2013 meeting:

This issue is being handled editorially and is being placed in "review" status to ensure that the change has been made.

#### 1596. Non-array objects as `array[1]`

Section: 5.9 [expr.rel] Status: review Submitter: Daniel Krügler Date: 2012-12-20

The provision to treat non-array objects as if they were array objects with a bound of 1 is given only for pointer arithmetic in C++ (5.7 [expr.add] paragraph 4). C99 supplies similar wording for the relational and equality operators, explicitly allowing pointers resulting from such implicit-array treatment to be compared. C++ should follow suit.

Proposed resolution (August, 2013):

1. Change 5.3.1 [expr.unary.op] paragraph 3 as follows:

> ...Otherwise, if the type of the expression is `T`, the result has type “pointer to `T`” and is a prvalue that is the address of the designated object (1.7 [intro.memory]) or a pointer to the designated function. [Note: In particular, the address of an object of type “cv `T`” is “pointer to cv `T`”, with the same cv-qualification. —end note] For purposes of pointer arithmetic (5.7 [expr.add]) and comparison (5.9 [expr.rel], 5.10 [expr.eq]), an object that is not an array element whose address is taken in this way is considered to belong to an array with one element of type `T`. [Example:

>       struct A { int i; };
>       struct B : A { };
>       ... &B::i ...        // has type int A::*
>       int a;
>       int* p1 = &a;
>       int* p2 = p1 + 1;    // Defined behavior
>       bool b = p2 > p1;    // Defined behavior, with value true

> —end example] [Note: a pointer to member...

2. Delete 5.7 [expr.add] paragraph 4:

> For the purposes of these operators, a pointer to a nonarray object behaves the same as a pointer to the first element of an array of length one with the type of the object as its element type.

3. Change 5.7 [expr.add] paragraph 5 as follows:

> When an expression that has integral type is added to or subtracted from a pointer, the result has the type of the pointer operand. If the pointer operand points to an element of an array object [Footnote: An object that is not an array element is considered to belong to a single-element array for this purpose; see 5.3.1 [expr.unary.op] —end footnote], and the array is large enough, the result points to an element

4. Change 5.9 [expr.rel] paragraph 3 as follows:

> Comparing pointers to objects [Footnote: An object that is not an array element is considered to belong to a single-element array for this purpose; see 5.3.1 [expr.unary.op] —end footnote] is defined as follows:...

[Drafting note: No change is proposed for 5.10 [expr.eq], since the comparison is phrased in terms of “same address”, not in terms of array elements, so the handling of one-past-the-end addresses falls out of the specification of pointer arithmetic.]

#### 1683. Incorrect example after `constexpr` changes

Section: 5.19 [expr.const] Status: review Submitter: Daniel Krügler Date: 2013-05-15

The example in 5.19 [expr.const] paragraph 6,

      struct A {
        constexpr A(int i) : val(i) { }
        constexpr operator int() { return val; }
        constexpr operator long() { return 43; }
      private:
        int val;
      };
      template<int> struct X { };
      constexpr A a = 42;
      X<a> x;               // OK: unique conversion to int
      int ary[a];           // error: ambiguous conversion

is no longer correct now that `constexpr` does not imply `const` for member functions, since the conversion functions cannot be invoked for the constant `a`.

Notes from the September, 2013 meeting:

This issue is being handled editorially and is being placed in "review" status to ensure that the change has been made.

#### 1694. Restriction on reference to temporary as a constant expression

Section: 5.19 [expr.const] Status: review Submitter: Richard Smith Date: 2013-05-30

We're missing a restriction on the value of a temporary which is bound to a static storage duration reference:

      void f(int n) {
        static constexpr int *&&r = &n;
      }

This is currently valid, because `&n` is a core constant expression, and it is a constant expression because the reference binds to a temporary (of type `int*`) that has static storage duration (because it's lifetime-extended by the reference binding).

The value of `r` is constant here (it's a constant reference to a temporary with a non-constant initializer), but I don't think we should accept this. Generally, I think a temporary which is lifetime-extended by a constexpr variable should also be treated as if it were declared to be a constexpr object.

Proposed resolution (September, 2013):

Change 5.19 [expr.const] paragraph 4 as follows:

> A constant expression is either a glvalue core constant expression whose value refers to an object with static storage duration or to a function entity that is a permitted result of a constant expression, or a prvalue core constant expression whose value is an object where, for that object and its subobjects:

> - each non-static data member of reference type refers to an object with static storage duration or to a function entity that is a permitted result of a constant expression, and

> - if the object or subobject is of pointer type, it contains the address of an object with static storage duration, the address past the end of such an object (5.7 [expr.add]), the address of a function, or a null pointer value.

> An entity is a permitted result of a constant expression if it is an object with static storage duration that is either not a temporary or is a temporary whose value satisfies the above constraints, or it is a function.

#### 1600. Erroneous reference initialization in example

Section: 7.1.6.2 [dcl.type.simple] Status: review Submitter: Niels Dekker Date: 2012-12-30

The example in 7.1.6.2 [dcl.type.simple] paragraph 4 reads, in part,

      const int&& foo();
      int i;
      decltype(foo()) x1 = i; // type is const int&&

The initialization is an ill-formed attempt to bind an rvalue reference to an lvalue.

Proposed resolution (April, 2013):

Change the example in 7.1.6.2 [dcl.type.simple] paragraph 4 as follows:

      const int&& foo();
      int i;
      struct A { double x; };
      const A* a = new A();
      decltype(foo()) x1 = i 17;     // type is const int&&
      decltype(i) x2;                // type is int
      decltype(a->x) x3;             // type is double
      decltype((a->x)) x4 = x3;      // type is const double&

#### 1615. Alignment of types, variables, and members

Section: 7.6.2 [dcl.align] Status: review Submitter: Richard Smith Date: 2013-02-01

According to 7.6.2 [dcl.align] paragraph 5,

> The combined effect of all alignment-specifiers in a declaration shall not specify an alignment that is less strict than the alignment that would be required for the entity being declared if all alignment-specifiers were omitted (including those in other declarations).

Presumably the intent was “other declarations of the same entity,” but the wording as written could be read to make the following example well-formed (assuming `alignof(int)` is 4):

      struct alignas(4) A {
        alignas(8) int n;
      };
      struct alignas(8) B {
        char c;
      };
      alignas(1) B b;
      struct alignas(1) C : B {};
      enum alignas(8) E : int { k };
      alignas(4) E e = k;

Proposed resolution (April, 2013):

> ...if all alignment-specifiers appertaining to that entity were omitted (including those in other declarations. [Example:

>       struct alignas(8) S {};
>       struct alignas(1) U {
>         S s;
>       };   // Error: U requires alignment for U that is less strict than
>            // if the alignas(1) were omitted.

> —end example]

#### 1633. Copy-initialization in member initialization

Section: 8.5 [dcl.init] Status: review Submitter: Vinny Romano Date: 2013-03-04

According to 8.5 [dcl.init] paragraph 16,

> The initialization that occurs in the forms

>       T x(a);
>       T x{a};

> as well as in new expressions (5.3.4 [expr.new]), `static_cast` expressions (5.2.9 [expr.static.cast]), functional notation type conversions (5.2.3 [expr.type.conv]), and base and member initializers (12.6.2 [class.base.init]) is called direct-initialization.

This wording was overlooked when brace-or-equal-initializers were added to the language, permitting copy-initialization of members by use of the `=` form.

Proposed resolution (April, 2013):

Change 8.5 [dcl.init] paragraphs 15-16 as follows:

> The initialization that occurs in the form

>       T x = a;

> as well as in argument passing, function return, throwing an exception (15.1 [except.throw]), handling an exception (15.3 [except.handle]), the `=` form of a brace-or-equal-initializer (12.6.2 [class.base.init]), and aggregate member initialization (8.5.1 [dcl.init.aggr]) is called copy-initialization. [Note: Copy-initialization may invoke a move (12.8). —end note]

> The initialization that occurs in the forms

>       T x(a);
>       T x{a};

> as well as in new expressions (5.3.4 [expr.new]), `static_cast` expressions (5.2.9), functional notation type conversions (5.2.3 [expr.type.conv]), and base and member initializers (12.6.2 [class.base.init]) other than the `=` form of a brace-or-equal-initializer is called direct-initialization.

#### 1517. Unclear/missing description of behavior during construction/destruction

Section: 12.7 [class.cdtor] Status: review Submitter: Daniel Krügler Date: 2012-07-07

The current wording of 12.7 [class.cdtor] paragraph 4 does not describe the behavior of calling a virtual function in a mem-initializer for a base class, only for a non-static data member. Also, the changes for issue 1202 should have been, but were not, applied to the description of the behavior of `typeid` and `dynamic_cast` in paragraphs 5 and 6.

In addition, the resolution of issue 597 allowing the out-of-lifetime conversion of pointers/lvalues to non-virtual base classes, should have been, but were not, applied to paragraph 3.

Proposed resolution (August, 2013):

1. Change 12.7 [class.cdtor] paragraph 1 as follows:

> For an object with a non-trivial constructor, referring to any non-static member or virtual base class of the object before the constructor begins execution results in undefined behavior. For an object with a non-trivial destructor, referring to any non-static member or virtual base class of the object after the destructor finishes execution results in undefined behavior. [Example:

>       struct X { int i; };
>       struct Y : X { Y(); };                       // non-trivial
>       struct A { int a; };
>       struct B : public virtual A { int j; Y y; }; // non-trivial

>       extern B bobj;
>       B* pb = &bobj;                               // OK
>       int* p1 = &bobj.a;                           // undefined, refers to base class member
>       int* p2 = &bobj.y.i;                         // undefined, refers to member's member

>       A* pa = &bobj;                               // undefined, upcast to a virtual base class type
>       B bobj;                                      // definition of bobj

>       extern X xobj;
>       int* p3 = &xobj.i;                           //OK, X is a trivial class
>       X xobj;

2. Change 12.7 [class.cdtor] paragraphs 3-6 as follows:

> To explicitly or implicitly convert a pointer (a glvalue) referring to an object of class `X` to a pointer (reference) to a direct or indirect virtual base class `B` of `X`, the construction of `X` and the construction of all of its direct or indirect bases that directly or indirectly derive from for which `B` is a direct or indirect virtual base shall have started and the destruction of these classes shall not have completed, otherwise the conversion results in undefined behavior. To form a pointer to (or access the value of) a direct non-static member...

> Member functions, including virtual functions (10.3 [class.virtual]), can be called during construction or destruction (12.6.2 [class.base.init]). When a virtual function is called directly or indirectly from a constructor or from a destructor, including during the construction or destruction of the class's non-static data members, and the object to which the call applies is the object (call it `x`) under construction or destruction, the function called is the final overrider in the constructor's or destructor's class and not one overriding it in a more-derived class. If the virtual function call uses an explicit class member access (5.2.5 [expr.ref]) and the object expression refers to the complete object of x or one of that object's base class subobjects but not to `x` or one of its base class subobjects, the behavior is undefined. The period of construction of an object or subobject whose type is a class type `C` begins immediately after the construction of all its base class subobjects is complete and concludes when the last constructor of class `C` exits. The period of destruction of an object or subobject whose type is a class type `C` begins when the destructor for `C` begins execution and concludes immediately before beginning the destruction of its base class subobjects. A polymorphic operation is a virtual function call (5.2.2 [expr.call]), the `typeid` operator (5.2.8 [expr.typeid]) when applied to a glvalue of polymorphic type, or the `dynamic_cast` operator (5.2.7 [expr.dynamic.cast]) when applied to a pointer to or glvalue of a polymorphic type. A polymorphic operand is the object expression in a virtual function call or the operand of a polymorphic `typeid` or `dynamic_cast`.

> During the period of construction or period of destruction of an object or subobject whose type is a class type `C` (call it `x`), the effect of performing a polymorphic operation in which the polymorphic operand designates `x` or a base class subobject thereof is as if the dynamic type of the object were class `C`. [Footnote: This is true even if `C` is an abstract class, which cannot be the type of a most-derived object. —end footnote] If a polymorphic operand refers to an object or subobject having class type `C` before its period of construction begins or after its period of destruction is complete, the behavior is undefined. [Note: This includes the evaluation of an expression appearing in a mem-initializer of `C` in which the mem-initializer-id designates `C` or one of its base classes. —end note] [Example:

>       struct V {
>         V();
>         V(int);
>         virtual void f();
>         virtual void g();
>       };

>       struct A : virtual V {
>         virtual void f();
>         virtual int h();
>         A() : V(h()) { }     // undefined behavior: virtual function h called
>                              // before A's period of construction begins
>       };

>       struct B : virtual V {
>         virtual void g();
>         B(V*, A*);
>       };

>       struct D : A, B {
>         virtual void f();
>         virtual void g();
>         D() : B((A*)this, this) { }
>       };

>       B::B(V* v, A* a) {
>         f();                 // calls V::f, not A::f
>         g();                 // calls B::g, not D::g
>         v->g();              // v is base of B, the call is well-defined, calls B::g
>         a->f();              // undefined behavior, a's type not a base of B
>         typeid(*this);       // type_info for B
>         typeid(*v);          // well-defined: *v has type V, a base of B,
>                              // so its period of construction is complete;
>                              // yields type_info for B
>         typeid(*a);          // undefined behavior: A is not a base of B,
>                              // so its period of construction has not begun
>         dynamic_cast<B*>(v); // well-defined: v has type V*, V is a base of B,
>                              // so its period of construction is complete;
>                              // results in this
>         dynamic_cast<B*>(a); // undefined behavior: A is not a base of B,
>                              // so its period of construction has not begun
>       }

> —end example]

> The `typeid` operator (5.2.8 [expr.typeid]) can be used during construction or destruction (12.6.2 [class.base.init]). When `typeid` is used in a constructor (including the mem-initializer or brace-or-equal-initializer for a non-static data member) or in a destructor, or used in a function called (directly or indirectly) from a constructor or destructor, if the operand of `typeid` refers to the object under construction or destruction, `typeid` yields the `std::type_info` object representing the constructor or destructor's class. If the operand of `typeid` refers to the object under construction or destruction and the static type of the operand is neither the constructor or destructor's class nor one of its bases, the result of `typeid` is undefined.

> `dynamic_cast`s (5.2.7 [expr.dynamic.cast]) can be used during construction or destruction (12.6.2 [class.base.init]). When a `dynamic_cast` is used in a constructor (including the mem-initializer or brace-or-equal-initializer for a non-static data member) or in a destructor, or used in a function called (directly or indirectly) from a constructor or destructor, if the operand of the `dynamic_cast` refers to the object under construction or destruction, this object is considered to be a most derived object that has the type of the constructor or destructor's class. If the operand of the `dynamic_cast` refers to the object under construction or destruction and the static type of the operand is not a pointer to or object of the constructor or destructor's own class or one of its bases, the `dynamic_cast` results in undefined behavior. [Example:

>       struct V {
>         virtual void f();
>       };

>       struct A : virtual V { };

>       struct B : virtual V {
>         B(V*, A*);
>       };

>       struct D : A, B {
>         D() : B((A*)this, this) { }
>       };

>       B::B(V* v, A* a) {
>         typeid(*this);       // type_info for B
>         typeid(*v);          // well-defined: *v has type V, a base of B
>                              // yields type_info for B
>         typeid(*a);          // undefined behavior: type A not a base of B
>         dynamic_cast<B*>(v); // well-defined: v of type V*, V base of B
>                              // results in B*
>         dynamic_cast<B*>(a); // undefined behavior,
>                              // a has type A*, A not a base of B

> —end example]

#### 1590. Bypassing non-copy/move constructor copying

Section: 12.8 [class.copy] Status: review Submitter: Richard Smith Date: 2012-11-26

Copy initialization in some cases uses constructors that are not copy/move constructors (e.g., a specialization of a constructor template might be selected by overload resolution, or in copy-list-initialization, any constructor could be selected). Some ABIs require that an object of certain class types be passed in a register (effectively using the trivial copy/move constructor), even if the class has a non-trivial constructor that would be selected to do the copy. The Standard should be changed to permit this usage.

Proposed resolution (April, 2013):

Add the following as a new paragraph following 12.8 [class.copy] paragraph 1:

> When an object of class type `X` is passed to or returned from a function, if `X` has a trivial, accessible copy or move constructor that is not deleted, and `X` has no non-trivial copy constructors, move constructors, or destructors, implementations are permitted to perform an additional copy or move of the object using the trivial constructor (even if it would not be selected by overload resolution to perform a copy or move of the object). [Note: This latitude is granted to allow objects of class type to be passed to or returned from functions in registers —end note]

#### 1673. Clarifying overload resolution for the second step of copy-initialization

Section: 13.3.3.1 [over.best.ics] Status: review Submitter: Vinny Romano Date: 2013-04-29
N3690 comment CA 5

Currently, 13.3.3.1 [over.best.ics] paragraph 4 reads,

> However, when considering the argument of a constructor or user-defined conversion function that is a candidate by 13.3.1.3 [over.match.ctor] when invoked for the copying/moving of the temporary in the second step of a class copy-initialization, by 13.3.1.7 [over.match.list] when passing the initializer list as a single argument or when the initializer list has exactly one element and a conversion to some class `X` or reference to (possibly cv-qualified) `X` is considered for the first parameter of a constructor of `X`, or by 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] in all cases, only standard conversion sequences and ellipsis conversion sequences are considered.

This is cumbersome and hard to understand. A possible improvement might be:

> However, only standard conversion sequences and ellipsis conversion sequences are considered if:

> - the parameter is the first parameter of a constructor of a class `X`, or

> - the parameter is the implicit object parameter of a user-defined conversion function, and

> - the constructor or user-defined conversion function is a candidate by:

> 13.3.1.3 [over.match.ctor] — when the argument is the temporary being copied/moved in the second step of a class copy-initialization.

> 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] — in all cases.

> 13.3.1.7 [over.match.list] — during phase two, when the argument was the only element in the initializer list, and the parameter is of type `X` or reference to (possibly cv-qualified) `X`.

(Note that this rewording removes the restriction that applies during phase one of 13.3.1.7 [over.match.list], as there is no longer any way to trigger it due to the fact that only initializer-list constructors are candidates. See this bug report for details.)

Proposed resolution (September, 2013):

Change 13.3.3.1 [over.best.ics] paragraph 4 as follows:

> However, when considering the argument of a constructor or user-defined conversion function that is a candidate by 13.3.1.3 [over.match.ctor] when invoked for the copying/moving of the temporary in the second step of a class copy-initialization, by 13.3.1.7 [over.match.list] when passing the initializer list as a single argument or when the initializer list has exactly one element and a conversion to some class `X` or reference to (possibly cv-qualified) `X` is considered for the first parameter of a constructor of `X`, or by 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] in all cases, only standard conversion sequences and ellipsis conversion sequences are considered. if the target is

> - the first parameter of a constructor of a class `X` or

> - the implicit object parameter of a user-defined conversion function,

> and the constructor or user-defined conversion function is a candidate by

> - 13.3.1.3 [over.match.ctor], when the argument is the temporary acting as the source in the second step of a class copy-initialization,

> - 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] (in all cases), or

> - the second phase of 13.3.1.7 [over.match.list] when the initializer list has exactly one element, and the conversion is to `X` or reference to (possibly cv-qualified) `X`,

> user-defined conversion sequences are not considered. [Example:

>       struct X { X(); };
>       struct B { operator X&(); };
>       B b;
>       X x({b}); // error: B::operator X&() is not a candidate

> —end example]

Additional note (October, 2013):

Questions have been raised about several of the bullets in the September, 2013 proposed resolution and whether a note would be preferable instead of or in addition to the example . The issue has been returned to "review" status to allow consideration of these questions.

#### 1484. Unused local classes of function templates

Section: 14.7.1 [temp.inst] Status: review Submitter: Johannes Schaub Date: 2012-03-25

Do local classes of function templates get the same treatment as member classes of class templates? In particular, is their definition only instantiated when they are required? For example,

      template<typename T> void f() {
        struct B {
          T t;
        };
      }

      int main() {
        f<void>();
      }

Implementations vary on this question.

(This question is superficially similar to the one in issue 1253. However, the entities in view in that issue can be named and defined outside the containing template and thus can be explicitly specialized, none of which is true for local classes of function templates.)

It should also be noted that the resolution of this issue should apply as well to local enumeration types.

Proposed resolution (October, 2012):

Change 14.7.1 [temp.inst] paragraph 1 as follows:

> Unless a class template specialization has been explicitly instantiated (14.7.2 [temp.explicit]) or explicitly specialized (14.7.3 [temp.expl.spec]), the class template specialization is implicitly instantiated when the specialization is referenced in a context that requires a completely-defined object type or when the completeness of the class type affects the semantics of the program. [Note: Within a template declaration, a local class or enumeration and the members of a local class are never considered to be entities that can be separately instantiated (this includes their default arguments, exception-specifications, and non-static data member initializers, if any). As a result, the dependent names are looked up, the semantic constraints are checked, and any templates used are instantiated as part of the instantiation of the entity within which the local class or enumeration is declared. —end note] The implicit instantiation of a class template specialization...

Notes from the April, 2013 meeting:

The proposed resolution interacts with N3649 (generic lambdas), adopted at this meeting, and this issue has returned to "review" status to allow any necessary changes to be made.

#### 1584. Deducing function types from cv-qualified types

Section: 14.8.2.1 [temp.deduct.call] Status: review Submitter: Daniel Krügler Date: 2012-11-04

It is not clear whether the following is well-formed or not:

      void foo(){}

      template<class T>
      void deduce(const T*) { }

      int main() {
        deduce(foo);
      }

Implementations vary in their treatment of this example.

Proposed resolution (April, 2013):

Change 14.8.2.5 [temp.deduct.type] paragraph 18 as follows:

> A template-argument can be deduced from a function, pointer to function, or pointer to member function type. [Note: cv-qualification of a deduced function type is ignored; see 8.3.5 [dcl.fct]. —end note] [Example:

>       template<class T> void f(void(*)(T,int));
>       template<class T> void f2(const T*);
>       template<class T> void foo(T,int);
>       void g(int,int);
>       void g(char,int);
>       void g2();

>       void h(int,int,int);
>       void h(char,int);
>       int m() {
>         f(&g);     // error: ambiguous
>         f(&h);     // OK: void h(char,int) is a unique match
>         f(&foo);   // error: type deduction fails because foo is a template
>         f2(g2);    // OK: cv-qualification of deduced function type ignored
>       }

> —end example]

#### 1705. Unclear specification of “more specialized”

Section: 14.8.2.4 [temp.deduct.partial] Status: review Submitter: Johannes Schaub Date: 2013-06-26

The current wording of 14.8.2.4 [temp.deduct.partial] paragraph 10 is:

> If for each type being considered a given template is at least as specialized for all types and more specialized for some set of types and the other template is not more specialized for any types or is not at least as specialized for any types, then the given template is more specialized than the other template. Otherwise, neither template is more specialized than the other.

This is confusing and needs to be clarified.

Proposed resolution (September, 2013):

Change 14.8.2.4 [temp.deduct.partial] paragraphs 9 and 10 as follows:

> If, for a given type, deduction succeeds in both directions (i.e., the types are identical after the transformations above) and both `P` and `A` were reference types (before being replaced with the type referred to above):

> - if the type from the argument template was an lvalue reference and the type from the parameter template was not, the argument type is considered to be more specialized than the other the other type is not considered to be at least as specialized as the argument type; otherwise,

> - if the type from the argument template is more cv-qualified than the type from the parameter template (as described above), the argument type is considered to be more specialized than the other; otherwise, the other type is not considered to be at least as specialized as the argument type.

> - neither type is more specialized than the other.

> If for each type being considered a given template is at least as specialized for all types and more specialized for some set of types and the other template is not more specialized for any types or is not at least as specialized for any types, then the given template is more specialized than the other template. Otherwise, neither template is more specialized than the other. A given template is at least as specialized as another template if it is at least as specialized as the other template for all types being considered. A given template is more specialized than another template if it is at least as specialized as the other template for all types being considered, and the other template is not at least as specialized as the given template for any type being considered.

#### 1769. Catching a base class of the exception object

Section: 15.3 [except.handle] Status: review Submitter: Canada Date: 2013-09-24
N3690 comment CA 13

In saying that the catch-clause parameter is copy-initialized from the exception object, 15.3 [except.handle] paragraph 16 leaves open the possibility that a converting constructor might be used for the initialization when the type of the exception-declaration is a base of the type of the exception object. It should be specified that the parameter is copy-constructed from the corresponding base class subobject in such cases.

Proposed resolution (September, 2013):

Change 15.3 [except.handle] paragraph 16 as follows:

> If the exception-declaration specifies introduces a name, it declares a variable which is copy-initialized (8.5 [dcl.init]) from the exception object. If the exception-declaration denotes an object type but does not specify a name, a temporary (12.2 [class.temporary]) is copy-initialized (8.5 [dcl.init]) from the exception object.; otherwise, an unnamed variable is created. That variable, of type cv `T` or cv `T&`, is initialized from the exception object, of type `E`, as follows:

> - if `T` is a base class of `E`, the variable is copy-initialized from the corresponding base class subobject of the exception object;

> - otherwise, the variable is copy-initialized from the exception object.

> The lifetime of the variable or temporary ends when the handler exits, after the destruction of any automatic objects initialized within the handler.

Additional note (October, 2013):

Additional discussion has pointed out that, although the unnamed handler parameter is no longer called a “temporary” in the proposed resolution, 12.2 [class.temporary] paragraph 1 still lists “entering a handler (15.3 [except.handle])” as one of the contexts in which a temporary is created. A question was also raised as to whether it is necessary to deal with named and unnamed handler parameters separately, since both are now referred to as “variables” in the revised wording. This issue has therefore been returned to "review" status to allow consideration of these points.

#### 1351. Problems with implicitly-declared exception-specifications

Section: 15.4 [except.spec] Status: review Submitter: Richard Smith Date: 2011-08-16

The determination of the exception-specification for an implicitly-declared special member function, as described in 15.4 [except.spec] paragraph 14, does not take into account the fact that nonstatic data member initializers and default arguments in default constructors can contain throw-expressions, which are not part of the exception-specification of any function that is “directly invoked” by the implicit definition. Also, the reference to “directly invoked” functions is not restricted to potentially-evaluated expressions, thus possibly including irrelevant exception-specifications.

Additional note (August, 2012):

The direction established by CWG for resolving this issue was to consider functions called from default arguments and non-static data member initializers in determining the exception-specification. This leads to a problem with ordering: because non-static data member initializers can refer to members declared later, their effect cannot be known until the end of the class. However, a non-static data member initializer could possibly refer to an implicitly-declared constructor, either its own or that of an enclosing class.

Proposed resolution (October, 2012) [SUPERSEDED]:

1. Add the following two new paragraphs and make the indicated changes to 15.4 [except.spec] paragraph 14:

> A set of potential exceptions may contain types and the special value “any.” The set of potential exceptions of an expression is the union of all sets of potential exceptions of each potentially-evaluated subexpression `e`:

> - If `e` is a call to a function, member function, function pointer, or member function pointer (including implicit calls, such as a call to the allocation function in a new-expression):

> - if it has a non-throwing exception-specification or the call is a core constant expression (5.19 [expr.const]), the set is empty;

> - otherwise, if it has a dynamic-exception-specification, the set consists of every type in that dynamic-exception-specification;

> - otherwise, the set consists of “any.”

> - If `e` is a throw-expression (15.1 [except.throw]), the set consists of the type of the exception object that would be initialized by the operand if present, or “any” otherwise.

> - If `e` is a `dynamic_cast` expression that casts to a reference type and requires a run-time check (5.2.7 [expr.dynamic.cast]), the set consists of the type `std::bad_cast`.

> - If `e` is a `typeid` expression applied to a glvalue expression whose type is a polymorphic class type (5.2.8 [expr.typeid]), the set consists of the type `std::bad_typeid`.

> - If `e` is a new-expression with a non-constant expression in the noptr-new-declarator (5.3.4 [expr.new]), the set also includes the type `std::bad_array_new_length`.

> - Otherwise, the set is the empty set.

> The set of potential exceptions of a function `f` of some class `X`, where `f` is an inheriting constructor or an implicitly-declared special member function, is defined as follows:

> - If `f` is a constructor, the set is the union of the sets of potential exceptions of the constructor invocations for `X`'s non-variant non-static data members, for `X`'s direct base classes, and, if `X` is non-abstract (10.4 [class.abstract]), for `X`'s virtual base classes, as selected by overload resolution for the implicit definition of `f` (12.1 [class.ctor]), including default argument expressions used in such invocations. [Note: Even though destructors for fully constructed subobjects are invoked when an exception is thrown during the execution of a constructor (15.2 [except.ctor]), their exception-specifications do not contribute to the exception-specification of the constructor, because an exception thrown from such a destructor could never escape the constructor (15.1 [except.throw], 15.5.1 [except.terminate]). —end note]

> - If `f` is a default constructor or inheriting constructor, the set also contains all members of the sets of potential exceptions of the initialization of non-static data members from brace-or-equal-initializers.

> - If `f` is an assignment operator, the set is the union of the sets of potential exceptions of the assignment operator invocations for `X`'s non-variant non-static data members and for `X`'s virtual and direct base classes, as selected by overload resolution for the implicit definition of `f` (12.8 [class.copy]), including default argument expressions used in such invocations.

> - If `f` is a destructor, the set is the union of the sets of potential exceptions of the destructor invocations for `X`'s non-variant non-static data members and for `X`'s virtual and direct base classes.

> An inheriting constructor (12.9 [class.inhctor]) and an implicitly declared implicitly-declared special member function (Clause 12 [special]) have an are considered to have an implicit exception-specification. If `f` is an inheriting constructor or an implicitly declared default constructor, copy constructor, move constructor, destructor, copy assignment operator, or move assignment operator, its implicit exception-specification specifies the type-id `T` if and only if `T` is allowed by the exception-specification of a function directly invoked by `f`'s implicit definition; `f` allows all exceptions if any function it directly invokes allows all exceptions, and `f` has the exception-specification `noexcept(true)` if every function it directly invokes allows no exceptions. The implicit exception-specification is `noexcept(false)` if the set of potential exceptions of the function contains “any;” otherwise, if that set contains at least one type, the implicit exception-specification specifies each type T contained in the set; otherwise, the implicit exception-specification is `noexcept(true)`. [Note: An instantiation of an inheriting constructor template has an implied exception-specification as if it were a non-template inheriting constructor. —end note] [Example:

>       struct A {
>         A();
>         A(const A&) throw();
>         A(A&&) throw();
>         ~A() throw(X);
>       };
>       struct B {
>         B() throw();
>         B(const B&) throw();
>         B(B&&, int = (throw Y(), 0)) throw(Y) noexcept;
>         ~B() throw(Y);
>       };
>       struct D : public A, public B {
>           // Implicit declaration of D::D();
>           // Implicit declaration of D::D(const D&) noexcept(true);
>           // Implicit declaration of D::D(D&&) throw(Y);
>           // Implicit declaration of D::~D() throw(X, Y);
>       };

> Furthermore, if...

2. Change 5.3.7 [expr.unary.noexcept] paragraph 3 as follows:

> The result of the noexcept operator is `false` if in a potentially-evaluated context the set of potential exceptions of the expression (15.4 [except.spec]) would contain contains “any” or at least one type and `true` otherwise.

> - a potentially evaluated call80 to a function, member function, function pointer, or member function pointer that does not have a non-throwing exception-specification (15.4 [except.spec]), unless the call is a constant expression (5.19 [expr.const]),

> - a potentially evaluated throw-expression (15.1 [except.throw]),

> - a potentially evaluated `dynamic_cast` expression `dynamic_cast<T>(v)`, where `T` is a reference type, that requires a run-time check (5.2.7 [expr.dynamic.cast]), or

> - a potentially evaluated `typeid` expression (5.2.8 [expr.typeid]) applied to a glvalue expression whose type is a polymorphic class type (10.3 [class.virtual]).

> Otherwise, the result is `true`.

(This resolution also resolves issues 1356 and 1465.)

Additional note (October, 2012):

The preceding wording has been modified from the version that was reviewed following the October, 2012 meeting and thus has been returned to "review" status.

Additional note (March, 2013):

It has been suggested that it might be more consistent with other parts of the language, and particularly in view of the deprecation of dynamic-exception-specifications, if a potentially-throwing non-static data member initializer simply made an implicit constructor `noexcept(false)` instead of giving it a set of potential exception types.

Additional note, April, 2013:

One problem with the approach suggested in the preceding note would be something like the following example:

      struct S {
        virtual ~S() throw(int);
      };
      struct D: S { };

This approach would make the example ill-formed, because the derived class destructor would be declared to throw types not permitted by the base class destructor's exception-specification. A further elaboration on the suggestion above that would not have this objection would be to define all dynamic-exception-specifications as simply equivalent to `noexcept(false)`.

(See also issue 1639.)

Proposed resolution, April, 2013:

1. Change 8.4.2 [dcl.fct.def.default] paragraph 2 as follows:

> An explicitly-defaulted function may be declared constexpr only if it would have been implicitly declared as constexpr, and may have an explicit exception-specification only if it is compatible (15.4 [except.spec]) with the exception-specification on the implicit declaration or if the function is defined as deleted. If a function is explicitly defaulted...

2. Change 15.4 [except.spec] paragraph 5 as follows:

> If a virtual function has an exception-specification, all declarations, including the definition, of any function that overrides that virtual function in any derived class shall only allow exceptions that are allowed by the exception-specification of the base class virtual function, unless the overriding function is defined as deleted. [Example:...

3. Add the following two new paragraphs and change 15.4 [except.spec] paragraph 14 as indicated:

> A set of potential exceptions may contain types and the special value “any”. The set of potential exceptions of an expression is the union of all sets of potential exceptions of each potentially-evaluated subexpression `e`:

> - If `e` is a core constant expression (5.19 [expr.const]), the set is empty.

> - Otherwise, if `e` is a function call (5.2.2 [expr.call]) whose postfix-expression is not a (possibly parenthesized) id-expression (5.1.1 [expr.prim.general]) or class member access (5.2.5 [expr.ref]), the set consists of “any”.

> - Otherwise, if `e` invokes a function, member function, or function pointer (including implicit calls, such as to an overloaded operator or to an allocation function in a new-expression):

> - if its declaration has a non-throwing exception-specification, the set is empty;

> - otherwise, if its declaration has a dynamic-exception-specification, the set consists of every type in that dynamic-exception-specification;

> - otherwise, the set consists of “any”.

> - If `e` is a throw-expression (15.1 [except.throw]), the set consists of the type of the exception object that would be initialized by the operand if present, or “any” otherwise.

> - If `e` is a `dynamic_cast` expression that casts to a reference type and requires a run-time check (5.2.7 [expr.dynamic.cast]), the set consists of the type `std::bad_cast`.

> - If `e` is a `typeid` expression applied to a glvalue expression whose type is a polymorphic class type (5.2.8 [expr.typeid]), the set consists of the type `std::bad_typeid`.

> - If `e` is a new-expression with a non-constant expression in the noptr-new-declarator (5.3.4 [expr.new]), the set also includes the type `std::bad_array_new_length`.

> - If none of the previous items applies, the set is the empty set.

> The set of potential exceptions of an implicitly-declared special member function `f` of some class `X` is defined as follows:

> - If `f` is a constructor, the set is the union of the sets of potential exceptions of the constructor invocations for `X`'s non-variant non-static data members, for `X`'s direct base classes, and, if `X` is non-abstract (10.4 [class.abstract]), for `X`'s virtual base classes, as selected by overload resolution for the implicit definition of `f` (12.1 [class.ctor]), including default argument expressions used in such invocations. [Note: Even though destructors for fully constructed subobjects are invoked when an exception is thrown during the execution of a constructor (15.2 [except.ctor]), their exception-specifications do not contribute to the exception-specification of the constructor, because an exception thrown from such a destructor could never escape the constructor (15.1 [except.throw], 15.5.1 [except.terminate]). —end note]

> - If `f` is a default constructor, the set also contains all members of the sets of potential exceptions of the initialization of non-static data members from brace-or-equal-initializers.

> - If `f` is an assignment operator, the set is the union of the sets of potential exceptions of the assignment operator invocations for `X`'s non-variant non-static data members and for `X`'s virtual and direct base classes, as selected by overload resolution for the implicit definition of `f` (12.8 [class.copy]), including default argument expressions used in such invocations.

> - If `f` is a destructor, the set is the union of the sets of potential exceptions of the destructor invocations for `X`'s non-variant non-static data members and for `X`'s virtual and direct base classes.

> An inheriting constructor (12.9 [class.inhctor]) and an implicitly-declared special member function (Clause 12 [special]) have are considered to have an implicit exception-specification. If `f` is an inheriting constructor or an implicitly declared default constructor, copy constructor, move constructor, destructor, copy assignment operator, or move assignment operator, its implicit exception-specification specifies the type-id `T` if and only if `T` is allowed by the exception-specification of a function directly invoked by `f`'s implicit definition; `f` allows all exceptions if any function it directly invokes allows all exceptions, and `f` has the exception-specification `noexcept(true)` if every function it directly invokes allows no exceptions. [Note: It follows that `f` has the exception-specification `noexcept(true)` if it invokes no other functions. —end note] [Note: An instantiation of an inheriting constructor template has an implied exception-specification as if it were a non-template inheriting constructor. —end note] The implicit exception-specification is `noexcept(false)` if the set of potential exceptions of the special member function contains “any”; otherwise, if that set contains at least one type, the implicit exception-specification specifies each type `T` contained in the set; otherwise, the implicit exception-specification is `noexcept(true)`. [Example:

>       struct A {
>         A();
>         A(const A&) throw();
>         A(A&&) throw();
>         ~A() throw(X);
>       };
>       struct B {
>         B() throw();
>         B(const B&) = default; // Declaration of B::B(const B&) noexcept(true) throw();
>         B(B&&, int = (throw Y(), 0)) throw(Y) noexcept;
>         ~B() throw(Y);
>       };
>       struct D : public A, public B {
>           // Implicit declaration of D::D();
>           // Implicit declaration of D::D(const D&) noexcept(true);
>           // Implicit declaration of D::D(D&&) throw(Y);
>           // Implicit declaration of D::~D() throw(X, Y);
>       };

> Furthermore...

4. Change 5.3.7 [expr.unary.noexcept]paragraph 3 as follows:

> The result of the `noexcept` operator is `false` `true` if in a potentially-evaluated context the set of potential exceptions of the expression (15.4 [except.spec]) would contain is empty, and `false` otherwise.

> - a potentially-evaluated call [[Footnote: This includes implicit calls such as the call to an allocation function in a new-expression. —end footnote] to a function, member function, function pointer, or member function pointer that does not have a non-throwing exception-specification (15.4 [except.spec]), unless the call is a constant expression (5.19 [expr.const]),

> - a potentially-evaluated throw-expression (15.1 [except.throw]),

> - a potentially-evaluated `dynamic_cast` expression `dynamic_cast<T>(v)`, where `T` is a reference type, that requires a run-time check (5.2.7 [expr.dynamic.cast]), or

> - a potentially-evaluated `typeid` expression (5.2.8 [expr.typeid]) applied to a glvalue expression whose type is a polymorphic class type (10.3 [class.virtual]).

> Otherwise, the result is `true`.

(This resolution also resolves issues 1356, 1465, and 1639.)

Additional note, April, 2013:

The version of this resolution approved in Bristol assumed the underlying text of the C++11 IS; however, the wording of 15.4 [except.spec] paragraph 14 has been changed by previous resolutions, so this and the related issues are being returned to "review" status.

#### 1356. Exception specifications of copy assignment operators with virtual bases

Section: 15.4 [except.spec] Status: review Submitter: Sean Hunt Date: 2011-08-16

It is unspecified if an implicitly-defined copy assignment operator directly invokes the copy assignment operators of virtual bases. The exception-specification of such a copy assignment operator is thus also unspecified. The specification in 15.4 [except.spec] paragraph 14 should explicitly include the exceptions from the copy assignment operators of virtual base classes, regardless of whether the implicit definition actually invokes the virtual base assignment operators or not.

Proposed resolution (October, 2012):

This issue is resolved by the resolution of issue 1351.

#### 1639. exception-specifications and pointer/pointer-to-member expressions

Section: 15.4 [except.spec] Status: review Submitter: Steve Adamczyk Date: 2013-02-12

The current specification is not clear whether the exception-specification for a function is propagated to the result of taking its address. For example:

      template<class T> struct A {
        void f() noexcept(false) {}
        void g() noexcept(true) {}
      };

      int main() {
        if (noexcept((A<short>().*(&A<short>::f))()))
          return 1;

        if (!noexcept((A<long>().*(&A<long>::g))()))
          return 1;

         return 0;
      }

There is implementation variance on whether `main` returns 0 or 1 for this example. (It also appears that taking the address of a member function of a class template requires instantiating its exception-specification, but it is not clear whether the Standard currently specifies this or not.)

(See also issues 92 and 1351.)

Proposed resolution (April, 2013):

This issue is resolved by the proposed resolution of issue 1351.

### Issues with "Drafting" Status

#### 1343. Sequencing of non-class initialization

Section: 1.9 [intro.execution] Status: drafting Submitter: Johannes Schaub Date: 2011-08-12

The current wording does not indicate that initialization of a non-class object is a full-expression, but presumably should do so.

Additional note, April, 2013:

There is implementation variance in the treatment of the following example:

      struct A {
        A() { puts("ctor"); }
        A(const A&) { puts("copy"); }
        const A&get() const { return *this; }
        ~A() { puts("dtor"); }
      };
      struct B { B(A, A) {} };

      typedef A A2[2];
      A2 a = { A().get(), A().get() };
      B b = { A().get(), A().get() };
      int c = (A2{ A().get(), A().get() }, 0);
      int d = (B{ A().get(), A().get() }, 0);

      int main() {}

#### 1332. Handling of invalid universal-character-names

Section: 2.3 [lex.charset] Status: drafting Submitter: Mike Miller Date: 2011-06-20

According to 2.3 [lex.charset] paragraph 2,

> The character designated by the universal-character-name `\UNNNNNNNN` is that character whose character short name in ISO/IEC 10646 is `NNNNNNNN`; the character designated by the universal-character-name `\uNNNN` is that character whose character short name in ISO/IEC 10646 is `0000NNNN`. If the hexadecimal value for a universal-character-name corresponds to a surrogate code point (in the range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally, if the hexadecimal value for a universal-character-name outside the c-char-sequence, s-char-sequence, or r-char-sequence of a character or string literal corresponds to a control character (in either of the ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the basic source character set, the program is ill-formed.

It is not specified what should happen if the hexadecimal value does not designate a Unicode code point: is that undefined behavior or does it make the program ill-formed?

As an aside, a note should be added explaining why these requirements apply to to an r-char-sequence when, as the footnote at the end of the paragraph explains,

> A sequence of characters resembling a universal-character-name in an r-char-sequence (2.14.5 [lex.string]) does not form a universal-character-name.

#### 369. Are `new`/`delete` identifiers or preprocessing-op-or-punc?

Section: 2.5 [lex.pptoken] Status: drafting Submitter: Martin v. Loewis Date: 30 July 2002

2.5 [lex.pptoken] paragraph 2 specifies that there are 5 categories of tokens in phases 3 to 6. With 2.13 [lex.operators] paragraph 1, it is unclear whether `new` is an identifier or a preprocessing-op-or-punc; likewise for `delete`. This is relevant to answer the question whether

    #define delete foo

is a well-formed control-line, since that requires an identifier after the `define` token.

(See also issue 189.)

#### 1655. Line endings in raw string literals

Section: 2.5 [lex.pptoken] Status: drafting Submitter: Mike Miller Date: 2013-04-26

According to 2.5 [lex.pptoken] paragraph 3,

> If the input stream has been parsed into preprocessing tokens up to a given character:

> - If the next character begins a sequence of characters that could be the prefix and initial double quote of a raw string literal, such as `R"`, the next preprocessing token shall be a raw string literal. Between the initial and final double quote characters of the raw string, any transformations performed in phases 1 and 2 (trigraphs, universal-character-names, and line splicing) are reverted; this reversion shall apply before any d-char, r-char, or delimiting parenthesis is identified.

However, phase 1 is defined as:

> Physical source file characters are mapped, in an implementation-defined manner, to the basic source character set (introducing new-line characters for end-of-line indicators) if necessary. The set of physical source file characters accepted is implementation-defined. Trigraph sequences (2.4 [lex.trigraph]) are replaced by corresponding single-character internal representations. Any source file character not in the basic source character set (2.3 [lex.charset]) is replaced by the universal-character-name that designates that character.

The reversion described in 2.5 [lex.pptoken] paragraph 3 specifically does not mention the replacement of physical end-of-line indicators with new-line characters. Is it intended that, for example, a CRLF in the source of a raw string literal is to be represented as a newline character or as the original characters?

#### 189. Definition of operator and punctuator

Section: 2.13 [lex.operators] Status: drafting Submitter: Mike Miller Date: 20 Dec 1999

The nonterminals operator and punctuator in 2.7 [lex.token] are not defined. There is a definition of the nonterminal operator in 13.5 [over.oper] paragraph 1, but it is apparent that the two nonterminals are not the same: the latter includes keywords and multi-token operators and does not include the nonoverloadable operators mentioned in paragraph 3.

There is a definition of preprocessing-op-or-punc in 2.13 [lex.operators] , with the notation that

> Each preprocessing-op-or-punc is converted to a single token in translation phase 7 (2.1).

However, this list doesn't distinguish between operators and punctuators, it includes digraphs and keywords (can a given token be both a keyword and an operator at the same time?), etc.

Suggested resolution:

1. Change 13.5 [over.oper] to use the term overloadable-operator.
2. Change 2.7 [lex.token] to use the term operator-token instead of operator (since there are operators that are keywords and operators that are composed of more than one token).
3. Change 2.13 [lex.operators] to define the nonterminals operator-token and punctuator.

Additional note (April, 2005):

The resolution for this problem should also address the fact that `sizeof` and `typeid` (and potentially others like `decltype` that may be added in the future) are described in some places as “operators” but are not listed in 13.5 [over.oper] paragraph 3 among the operators that cannot be overloaded.

(See also issue 369.)

#### 1656. Encoding of numerically-escaped characters

Section: 2.14.3 [lex.ccon] Status: drafting Submitter: Mike Miller Date: 2013-04-30

According to 2.14.3 [lex.ccon] paragraph 4,

> The escape `\ooo` consists of the backslash followed by one, two, or three octal digits that are taken to specify the value of the desired character. The escape `\xhhh` consists of the backslash followed by `x` followed by one or more hexadecimal digits that are taken to specify the value of the desired character. There is no limit to the number of digits in a hexadecimal sequence. A sequence of octal or hexadecimal digits is terminated by the first character that is not an octal digit or a hexadecimal digit, respectively. The value of a character literal is implementation-defined if it falls outside of the implementation-defined range defined for `char` (for literals with no prefix), `char16_t` (for literals prefixed by `'u'`), `char32_t` (for literals prefixed by `'U'`), or `wchar_t` (for literals prefixed by `'L'`).

It is not clearly stated whether the “desired character” being specified reflects the source or the target encoding. This particularly affects UTF-8 string literals (2.14.5 [lex.string] paragraph 7):

> A string literal that begins with `u8`, such as `u8"asdf"`, is a UTF-8 string literal and is initialized with the given characters as encoded in UTF-8.

For example, assuming the source encoding is Latin-1, is `u8"\xff"` supposed to specify a three-byte string whose first two bytes are `0xc3 0xbf` (the UTF-8 encoding of `\u00ff`) or a two-byte string whose first byte has the value `0xff`? (At least some current implementations assume the latter interpretation.)

Notes from the September, 2013 meeting:

The second interpretation (that the escape sequence specifies the execution-time code unit) is intended.

#### 1759. UTF-8 code units in plain `char`

Section: 2.14.5 [lex.string] Status: drafting Submitter: United Kingdom Date: 2013-09-23
N3690 comment GB 1

A UTF-8 string literal might result in a code unit with the value `0x80`. However, plain `char` is not guaranteed to be able to represent `0x80`.

#### 1723. Multicharacter user-defined character literals

Section: 2.14.8 [lex.ext] Status: drafting Submitter: Mike Miller Date: 2013-07-31

According to 2.14.3 [lex.ccon] paragraph 1, a multicharacter literal like `'ab'` is conditionally-supported and has type `int`.

According to 2.14.8 [lex.ext] paragraph 6,

> If L is a user-defined-character-literal, let ch be the literal without its ud-suffix. S shall contain a literal operator (13.5.8 [over.literal]) whose only parameter has the type of ch and the literal L is treated as a call of the form

> `operator ""` X`(`ch`)`

A user-defined-character-literal like `'ab'_foo` would thus require a literal operator

`operator "" _foo(int)`

However, that is not one of the signatures permitted by 13.5.8 [over.literal] paragraph 3.

Should multicharacter user-defined-character-literals be conditionally-supported? If so, 13.5.8 [over.literal] paragraph 3 should be adjusted accordingly. If not, a note in 2.14.8 [lex.ext] paragraph 6 saying explicitly that they are not supported would be helpful.

#### 1735. Out-of-range literals in user-defined-literals

Section: 2.14.8 [lex.ext] Status: drafting Submitter: Mike Miller Date: 2013-08-12

The description of the numeric literals occurring as part of user-defined-integer-literals and user-defined-floating-literals in 2.14.8 [lex.ext] says nothing about whether they are required to satisfy the same constraints as literals that are not part of a user-defined-literal. In particular, because it is the spelling, not the value, of the literal that is used for raw literal operators and literal operator templates, there is no particular reason that they should be restricted to the maximum values and precisions that apply to ordinary literals (and one could imagine that this would be a good notation for allowing literals of extended-precision types).

Is this relaxation of limits intended to be required, or is it a quality-of-implementation issue? Should something be said, either normatively or non-normatively, about this question?

#### 1529. Nomenclature for variable vs reference non-static data member

Section: 3 [basic] Status: drafting Submitter: Daniel Krügler Date: 2012-07-24

According to 3 [basic] paragraph 6,

> A variable is introduced by the declaration of a reference other than a non-static data member or of an object.

In other words, non-static data members of reference type are not variables. This complicates the wording in a number of places, where the text refers to “variable or data member,” presumably to cover the reference case, but that phrasing could lead to the mistaken impression that all data members are not variables. It would be better if either there were a term for the current phrase “variable or data member” or if there were a less-unwieldy term for “non-static data member of reference type” that could be used in place of “data member” in the current phrasing.

#### 1581. When are `constexpr` member functions defined?

Section: 3.2 [basic.def.odr] Status: drafting Submitter: Richard Smith Date: 2012-10-29

Clause 12 [special] is perfectly clear that special member functions are only implicitly defined when they are odr-used. This creates a problem for constant expressions in unevaluated contexts:

       struct duration {
         constexpr duration() {}
         constexpr operator int() const { return 0; }
       };
       // duration d = duration(); // #1
       int n = sizeof(short{duration(duration())});

The issue here is that we are not permitted to implicitly define `constexpr duration::duration(duration&&)` in this program, so the expression in the initializer list is not a constant expression (because it invokes a `constexpr` function which has not been defined), so the braced initializer contains a narrowing conversion, so the program is ill-formed.

If we uncomment line #1, the move constructor is implicitly defined and the program is valid. This spooky action at a distance is extremely unfortunate. Implementations diverge on this point.

There are also similar problems with implicit instantiation of `constexpr` functions. It is not clear which contexts require their instantiation. For example:

      template<int N> struct U {};
      int g(int);
      template<typename T> constexpr int h(T) { return T::error; }
      template<typename T> auto f(T t) -> U<g(T()) + h(T())> {}
      int f(...);
      int k = f(0);

There are at least two different ways of modeling the current rules:

- `constexpr` function instantiation is triggered by constant expression evaluation. In that case, the validity of the above program depends on the order in which that evaluation proceeds:

- If the LHS of the `+` is evaluated first, the program might be valid, because the implementation might bail out evaluation before triggering the ill-formed instantiation of `h<int>`.

- If the RHS is evaluated first, the program is invalid, because the instantiation fails.

- `constexpr` function instantiation is triggered whenever a `constexpr` function is referenced from an expression which could be evaluated (note that this is not the same as being potentially-evaluated)

These two approaches can be distinguished by code like this:

      int k = sizeof(U<0 && h(0)>);

Under the first approach, this code is valid; under the second, it is ill-formed.

A possible approach to resolving this issue would be to change the definition of “potentially-evaluated” such that template arguments, array bounds, and braced-init-lists (and any other expressions which are constant evaluated) are always potentially-evaluated, even if they appear within an unevaluated context, and to change 14.7.1 [temp.inst] paragraph 3 to say simply that function template specializations are implicitly instantiated when they are odr-used.

A related question is whether putatively `constexpr` constructors must be instantiated in order to determine whether their class is a literal type or not. See issue 1358.

Jason Merrill:

I'm concerned about unintended side-effects of such a large change to “potentially-evaluated;” I would prefer something that only affects `constexpr`.

It occurs to me that this is parallel to issue 1330: just like we want to instantiate exception specifiers for calls in unevaluated context, we also want to instantiate `constexpr` functions. I think we should define some other term to say when there's a reference to a declaration, and then say that the declaration is odr-used when that happens in potentially-evaluated context.

Notes from the April, 2013 meeting:

An additional question was raised about whether `constexpr` functions should be instantiated as a result of appearing within unevaluated subexpressions of constant expressions. For example:

      #include <type_traits>

      template <class T> constexpr T f(T t) { return +t; }

      struct A { };

      template <class T>
      decltype(std::is_scalar<T>::value ? T::fail : f(T()))
        g() { }

      template <class T>
      void g(...);

      int main()
      {
        g<A>();
      }

If `constexpr` instantiation happens during constant expression evaluation, `f<A>` is never instantiated and the program is well-formed. If `constexpr` instantiation happens during parsing, `f<A>` is instantiated and the program is ill-formed.

#### 554. Definition of “declarative region” and “scope”

Section: 3.3 [basic.scope] Status: drafting Submitter: Gabriel Dos Reis Date: 29 December 2005

The various uses of the term “declarative region” throughout the Standard indicate that the term is intended to refer to the entire block, class, or namespace that contains a given declaration. For example, 3.3 [basic.scope] paragraph 2 says, in part:

> [Example: in

>         int j = 24;
>         int main()
>         {
>             int i = j, j;
>             j = 42;
>         }

> The declarative region of the first `j` includes the entire example... The declarative region of the second declaration of `j` (the `j` immediately before the semicolon) includes all the text between `{` and `}`...

However, the actual definition given for “declarative region” in 3.3 [basic.scope] paragraph 1 does not match this usage:

> Every name is introduced in some portion of program text called a declarative region, which is the largest part of the program in which that name is valid, that is, in which that name may be used as an unqualified name to refer to the same entity.

Because (except in class scope) a name cannot be used before it is declared, this definition contradicts the statement in the example and many other uses of the term throughout the Standard. As it stands, this definition is identical to that of the scope of a name.

The term “scope” is also misused. The scope of a declaration is defined in 3.3 [basic.scope] paragraph 1 as the region in which the name being declared is valid. However, there is frequent use of the phrase “the scope of a class,” not referring to the region in which the class's name is valid but to the declarative region of the class body, and similarly for namespaces, functions, exception handlers, etc. There is even a mention of looking up a name “in the scope of the complete postfix-expression” (3.4.5 [basic.lookup.classref] paragraph 3), which is the exact inverse of the scope of a declaration.

This terminology needs a thorough review to make it logically consistent. (Perhaps a discussion of the scope of template parameters could also be added to section 3.3 [basic.scope] at the same time, as all other kinds of scopes are described there.)

Proposed resolution (November, 2006):

1. Change 3.3 [basic.scope] paragraph 1 as follows:

> Every name is introduced in some portion of program text called a declarative region, which is the largest part of the program in which that name is valid, that is, in which that name may be used as an unqualified name to refer to the same entity a statement, block, function declarator, function-definition, class, handler, template-declaration, template-parameter-list of a template template-parameter, or namespace. In general, each particular name is valid may be used as an unqualified name to refer to the entity of its declaration or to the label only within some possibly discontiguous portion of program text called its scope. To determine the scope of a declaration...

2. Change 3.3 [basic.scope] paragraph 3 as follows:

> The names declared by a declaration are introduced into the scope in which the declaration occurs declarative region that directly encloses the declaration, except that declaration-statements, function parameter names in the declarator of a function-definition, exception-declarations (3.3.3 [basic.scope.block]), the presence of a `friend` specifier (11.3 [class.friend]), certain uses of the elaborated-type-specifier (7.1.6.3 [dcl.type.elab]), and using-directives (7.3.4 [namespace.udir]) alter this general behavior.

3. Change 3.3.3 [basic.scope.block] paragraphs 1-3 and add a new paragraph 4 before the existing paragraph 4 as follows:

> A name declared in a block (6.3 [stmt.block]) is local to that block. Its potential scope begins at its point of declaration (3.3.2 [basic.scope.pdecl]) and ends at the end of its declarative region. The declarative region of a name declared in a declaration-statement is the directly enclosing block (6.3 [stmt.block]). Such a name is local to the block.

> The potential scope declarative region of a function parameter name (including one appearing in the declarator of a function-definition or in a lambda-parameter-declaration-clause) or of a function-local predefined variable in a function definition (8.4 [dcl.fct.def]) begins at its point of declaration. If the function has a function-try-block the potential scope of a parameter or of a function-local predefined variable ends at the end of the last associated handler, otherwise it ends at the end of the outermost block of the function definition. A parameter name is the entire function definition or lambda-expression. Such a name is local to the function definition and shall not be redeclared in the any outermost block of the function definition nor in the outermost block of any handler associated with a function-try-block function-body (including handlers of a function-try-block) or lambda-expression.

> The name in a `catch` exception-declaration The declarative region of a name declared in an exception-declaration is its entire handler. Such a name is local to the handler and shall not be redeclared in the outermost block of the handler.

> The potential scope of any local name begins at its point of declaration (3.3.2 [basic.scope.pdecl]) and ends at the end of its declarative region.

4. Change 3.3.5 [basic.funscope] as indicated:

> Labels (6.1 [stmt.label]) have function scope and may be used anywhere in the function in which they are declared except in members of local classes (9.8 [class.local]) of that function. Only labels have function scope.

5. Change 6.7 [stmt.dcl] paragraph 1 as follows:

> A declaration statement introduces one or more new identifiers names into a block; it has the form

> declaration-statement:
> block-declaration

> [Note: If an identifier a name introduced by a declaration was previously declared in an outer block, the outer declaration is hidden for the remainder of the block, after which it resumes its force (3.3.10 [basic.scope.hiding]). —end note]

[Drafting notes: This resolution deals almost exclusively with the unclear definition of “declarative region.” I've left the ambiguous use of “scope” alone for now. However sections 3.3.x all have headings reading “xxx scope,” but they don't mean the scope of a declaration but the different kinds of declarative regions and their effects on the scope of declarations contained therein. To me, it looks like most of 3.4 should refer to “declarative region” and not to “scope.”

The change to 6.7 fixes an “identifier” misuse (e.g., `extern T operator+(T,T);` at block scope introduces a name but not an identifier) and removes normative redundancy.]

#### 555. Pseudo-destructor name lookup

Section: 3.4 [basic.lookup] Status: drafting Submitter: Krzysztof Zelechowski Date: 26 January 2006

The Standard does not completely specify how to look up the type-name(s) in a pseudo-destructor-name (5.2 [expr.post] paragraph 1, 5.2.4 [expr.pseudo]), and what information it does have is incorrect and/or in the wrong place. Consider, for instance, 3.4.5 [basic.lookup.classref] paragraphs 2-3:

> If the id-expression in a class member access (5.2.5 [expr.ref]) is an unqualified-id, and the type of the object expression is of a class type `C` (or of pointer to a class type `C`), the unqualified-id is looked up in the scope of class `C`. If the type of the object expression is of pointer to scalar type, the unqualified-id is looked up in the context of the complete postfix-expression.

> If the unqualified-id is `~`type-name, and the type of the object expression is of a class type `C` (or of pointer to a class type `C`), the type-name is looked up in the context of the entire postfix-expression and in the scope of class `C`. The type-name shall refer to a class-name. If type-name is found in both contexts, the name shall refer to the same class type. If the type of the object expression is of scalar type, the type-name is looked up in the scope of the complete postfix-expression.

There are at least three things wrong with this passage with respect to pseudo-destructors:

1. A pseudo-destructor call (5.2.4 [expr.pseudo]) is not a “class member access”, so the statements about scalar types in the object expressions are vacuous: the object expression in a class member access is required to be a class type or pointer to class type (5.2.5 [expr.ref] paragraph 2).

2. On a related note, the lookup for the type-name(s) in a pseudo-destructor name should not be described in a section entitled “Class member access.”

3. Although the class member access object expressions are carefully allowed to be either a class type or a pointer to a class type, paragraph 2 mentions only a “pointer to scalar type” (disallowing references) and paragraph 3 deals only with a “scalar type,” presumably disallowing pointers (although it could possibly be a very subtle way of referring to both non-class pointers and references to scalar types at once).

The other point at which lookup of pseudo-destructors is mentioned is 3.4.3 [basic.lookup.qual] paragraph 5:

> If a pseudo-destructor-name (5.2.4 [expr.pseudo]) contains a nested-name-specifier, the type-names are looked up as types in the scope designated by the nested-name-specifier.

Again, this specification is in the wrong location (a pseudo-destructor-name is not a qualified-id and thus should not be treated in the “Qualified name lookup” section).

Finally, there is no place in the Standard that describes the lookup for pseudo-destructor calls of the form `p->T::~T()` and `r.T::~T()`, where `p` and `r` are a pointer and reference to scalar, respectively. To the extent that it gives any guidance at all, 3.4.5 [basic.lookup.classref] deals only with the case where the `~` immediately follows the `.` or `->`, and 3.4.3 [basic.lookup.qual] deals only with the case where the pseudo-destructor-name contains a nested-name-specifier that designates a scope in which names can be looked up.

See document J16/06-0008 = WG21 N1938 for further discussion of this and related issues, including 244, 305, 399, and 414.

Proposed resolution (June, 2008):

1. Add a new paragraph following 5.2 [expr.post] paragraph 2 as follows:

> When a postfix-expression is followed by a dot `.` or arrow `->` operator, the interpretation depends on the type `T` of the expression preceding the operator. If the operator is `.`, `T` shall be a scalar type or a complete class type; otherwise, `T` shall be a pointer to a scalar type or a pointer to a complete class type. When `T` is a (pointer to) a scalar type, the postfix-expression to which the operator belongs shall be a pseudo-destructor call (5.2.4 [expr.pseudo]); otherwise, it shall be a class member access (5.2.5 [expr.ref]).

2. Change 5.2.4 [expr.pseudo] paragraph 2 as follows:

> The left-hand side of the dot operator shall be of scalar type. The left-hand side of the arrow operator shall be of pointer to scalar type. This scalar type The type of the expression preceding the dot operator, or the type to which the expression preceding the arrow operator points, is the object type...

3. Change 5.2.5 [expr.ref] paragraph 2 as follows:

> For the first option (dot) the type of the first expression (the object expression) shall be “class object” (of a complete type) is a class type. For the second option (arrow) the type of the first expression (the pointer expression) shall be “pointer to class object” (of a complete type) is a pointer to a class type. In these cases, the id-expression shall name a member of the class or of one of its base classes.

4. Add a new paragraph following 3.4 [basic.lookup] paragraph 2 as follows:

> In a pseudo-destructor-name that does not include a nested-name-specifier, the type-names are looked up as types in the context of the complete expression.

5. Delete the last sentence of 3.4.5 [basic.lookup.classref] paragraph 2:

> If the id-expression in a class member access (5.2.5 [expr.ref]) is an unqualified-id, and the type of the object expression is of a class type `C`, the unqualified-id is looked up in the scope of class `C`. If the type of the object expression is of pointer to scalar type, the unqualified-id is looked up in the context of the complete postfix-expression.

Notes from the August, 2011 meeting:

The proposed resolution must be updated with respect to the current wording of the WP.

#### 192. Name lookup in parameters

Section: 3.4.1 [basic.lookup.unqual] Status: drafting Submitter: Alan Nash Date: 6 Jan 2000

The description of name lookup in the parameter-declaration-clause of member functions in 3.4.1 [basic.lookup.unqual] paragraphs 7-8 is flawed in at least two regards.

First, both paragraphs 7 and 8 apply to the parameter-declaration-clause of a member function definition and give different rules for the lookup. Paragraph 7 applies to names "used in the definition of a class `X` outside of a member function body...," which includes the parameter-declaration-clause of a member function definition, while paragraph 8 applies to names following the function's declarator-id (see the proposed resolution of issue 41), including the parameter-declaration-clause.

Second, paragraph 8 appears to apply to the type names used in the parameter-declaration-clause of a member function defined inside the class definition. That is, it appears to allow the following code, which was not the intent of the Committee:

        struct S {
            void f(I i) { }
            typedef int I;
        };

Additional note, January, 2012:

brace-or-equal-initializers for non-static data members are intended effectively as syntactic sugar for mem-initializers in constructor definitions; the lookup should be the same.

#### 156. Name lookup for conversion functions

Section: 3.4.5 [basic.lookup.classref] Status: drafting Submitter: Derek Inglis Date: 18 Aug 1999

Paragraph 7 of 3.4.5 [basic.lookup.classref] says,

> If the id-expression is a conversion-function-id, its conversion-type-id shall denote the same type in both the context in which the entire postfix-expression occurs and in the context of the class of the object expression (or the class pointed to by the pointer expression).

Does this mean that the following example is ill-formed?

        struct A { operator int(); } a;
        void foo() {
          typedef int T;
          a.operator T(); // 1) error T is not found in the context
    		      // of the class of the object expression?
        }

The second bullet in paragraph 1 of 3.4.3.1 [class.qual] says,

> a conversion-type-id of an operator-function-id is looked up both in the scope of the class and in the context in which the entire postfix-expression occurs and shall refer to the same type in both contexts

How about:

        struct A { typedef int T; operator T(); };
        struct B : A { operator T(); } b;
        void foo() {
          b.A::operator T(); // 2) error T is not found in the context
    			 // of the postfix-expression?
        }

Is this interpretation correct? Or was the intent for this to be an error only if `T` was found in both scopes and referred to different entities?

If the intent was for these to be errors, how do these rules apply to template arguments?

        template <class T1> struct A { operator T1(); }
        template <class T2> struct B : A<T2> {
          operator T2();
          void foo() {
    	T2 a = A<T2>::operator T2(); // 3) error? when instantiated T2 is not
    				     // found in the scope of the class
    	T2 b = ((A<T2>*)this)->operator T2(); // 4) error when instantiated?
          }
        }

(Note bullets 2 and 3 in paragraph 1 of 3.4.3.1 [class.qual] refer to postfix-expression. It would be better to use qualified-id in both cases.)

Erwin Unruh: The intent was that you look in both contexts. If you find it only once, that's the symbol. If you find it in both, both symbols must be "the same" in some respect. (If you don't find it, its an error).

Mike Miller: What's not clear to me in these examples is whether what is being looked up is `T` or `int`. Clearly the `T` has to be looked up somehow, but the "name" of a conversion function clearly involves the base (non-typedefed) type, not typedefs that might be used in a definition or reference (cf 3 [basic] paragraph 7 and 12.3 [class.conv] paragraph 5). (This is true even for types that must be written using typedefs because of the limited syntax in conversion-type-ids — e.g., the "name" of the conversion function in the following example

        typedef void (*pf)();
        struct S {
    	operator pf();
        };

is `S::operator void(*)()`, even though you can't write its name directly.)

My guess is that this means that in each scope you look up the type named in the reference and form the canonical operator name; if the name used in the reference isn't found in one or the other scope, the canonical name constructed from the other scope is used. These names must be identical, and the conversion-type-id in the canonical operator name must not denote different types in the two scopes (i.e., the type might not be found in one or the other scope, but if it's found in both, they must be the same type).

I think this is all very vague in the current wording.

#### 682. Missing description of lookup of template aliases

Section: 3.4.5 [basic.lookup.classref] Status: drafting Submitter: Daveed Vandevoorde Date: 1 March, 2008

3.4.5 [basic.lookup.classref] does not mention template aliases as the possible result of the lookup but should do so.

#### 1089. Template parameters in member selections

Section: 3.4.5 [basic.lookup.classref] Status: drafting Submitter: Daveed Vandevoorde Date: 2010-06-29

In an example like

        template<typename T> void f(T p)->decltype(p.T::x);

The nested-name-specifier `T::` looks like it refers to the template parameter. However, if this is instantiated with a type like

        struct T { int x; };
        struct S: T { };

the reference will be ambiguous, since it is looked up in both the context of the expression, finding the template parameter, and in the class, finding the base class injected-class-name, and this could be a deduction failure. As a result, the same declaration with a different parameter name

        template<typename U> void f(U p)->decltype(p.U::x);

is, in fact, not a redeclaration because the two can be distinguished by SFINAE.

It would be better to add a new lookup rule that says that if a name in a template definition resolves to a template parameter, that name is not subject to further lookup at instantiation time.

#### 1291. Looking up a conversion-type-id

Section: 3.4.5 [basic.lookup.classref] Status: drafting Submitter: Daveed Vandevoorde Date: 2011-04-10

The Standard talks about looking up a conversion-type-id as if it were an identifier (3.4.5 [basic.lookup.classref] paragraph 7), but that is not exactly accurate. Presumably it should talk instead about looking up names (if any) appearing in the type-specifier-seq of the conversion-type-id.

#### 426. Identically-named variables, one internally and one externally linked, allowed?

Section: 3.5 [basic.link] Status: drafting Submitter: Steve Adamczyk Date: 2 July 2003

An example in 3.5 [basic.link] paragraph 6 creates two file-scope variables with the same name, one with internal linkage and one with external.

      static void f();
      static int i = 0;                       //1
      void g() {
              extern void f();                // internal linkage
              int i;                          //2: i has no linkage
              {
                      extern void f();        // internal linkage
                      extern int i;           //3: external linkage
              }
      }

Is this really what we want? C99 has 6.2.2.7/7, which gives undefined behavior for having an identifier appear with internal and external linkage in the same translation unit. C++ doesn't seem to have an equivalent.

Notes from October 2003 meeting:

We agree that this is an error. We propose to leave the example but change the comment to indicate that line //3 has undefined behavior, and elsewhere add a normative rule giving such a case undefined behavior.

Proposed resolution (October, 2005):

Change 3.5 [basic.link] paragraph 6 as indicated:

> ...Otherwise, if no matching entity is found, the block scope entity receives external linkage. If, within a translation unit, the same entity is declared with both internal and external linkage, the behavior is undefined.

> [Example:

>         static void f();
>         static int i = 0;            // 1
>         void g () {
>             extern void f ();        // internal linkage
>             int i;                   // 2: i has no linkage
>             {
>                 extern void f ();    // internal linkage
>                 extern int i;        // 3: external linkage
>             }
>         }

> There are three objects named `i` in this program. The object with internal linkage introduced by the declaration in global scope (line `//1` ), the object with automatic storage duration and no linkage introduced by the declaration on line `//2`, and the object with static storage duration and external linkage introduced by the declaration on line `//3`. Without the declaration at line `//2`, the declaration at line `//3` would link with the declaration at line `//1`. But because the declaration with internal linkage is hidden, `//3` is given external linkage, resulting in a linkage conflict. —end example]

Notes frum the April 2006 meeting:

According to 3.5 [basic.link] paragraph 9, the two variables with linkage in the proposed example are not “the same entity” because they do not have the same linkage. Some other formulation will be needed to describe the relationship between those two variables.

Notes from the October 2006 meeting:

The CWG decided that it would be better to make a program with this kind of linkage mismatch ill-formed instead of having undefined behavior.

#### 1669. `auto` return type for `main`

Section: 3.6.1 [basic.start.main] Status: drafting Submitter: Richard Smith Date: 2013-04-26

Should it be permitted for `main` to have a deduced return type?

(See also issue 1676.)

#### 1294. Side effects in dynamic/static initialization

Section: 3.6.2 [basic.start.init] Status: drafting Submitter: Daniel Krügler Date: 2011-04-08

According to 3.6.2 [basic.start.init] paragraph 3,

> An implementation is permitted to perform the initialization of a non-local variable with static storage duration as a static initialization even if such initialization is not required to be done statically, provided that

> - the dynamic version of the initialization does not change the value of any other object of namespace scope prior to its initialization, and

> - the static version of the initialization produces the same value in the initialized variable as would be produced by the dynamic initialization if all variables not required to be initialized statically were initialized dynamically.

This does not consider side effects of the initialization in this determination, only the values of namespace-scope variables.

#### 1677. Constant initialization via aggregate initialization

Section: 3.6.2 [basic.start.init] Status: drafting Submitter: Daniel Krügler Date: 2013-05-05

The resolution of issue 1489 added wording regarding value initialization to 3.6.2 [basic.start.init] paragraph 2 in an attempt to clarify the status of an example like

      int a[1000]{};

However, this example is aggregate initialization, not value initialization. Also, now that we allow brace-or-equal-initializers in aggregates, this wording also needs to be updated to allow an aggregate with constant non-static data member initializers to qualify for constant initialization.

#### 1634. Temporary storage duration

Section: 3.7 [basic.stc] Status: drafting Submitter: Richard Smith Date: 2013-03-04

According to 3.7 [basic.stc] paragraph 2,

> Static, thread, and automatic storage durations are associated with objects introduced by declarations (3.1 [basic.def]) and implicitly created by the implementation (12.2 [class.temporary]).

The apparent intent of the reference to 12.2 [class.temporary] is that a temporary whose lifetime is extended to be that of a reference with one of those storage durations is considered also to have that storage duration. This interpretation is buttressed by use of the phrase “an object with the same storage duration as the temporary” (twice) in 12.2 [class.temporary] paragraph 5.

There are two problems, however: first, the specification of lifetime extension of temporaries (also in 12.2 [class.temporary] paragraph 5) does not say anything about storage duration. Also, nothing is said in either of these locations about the storage duration of a temporary whose lifetime is not extended.

The latter point is important because 3.8 [basic.life] makes a distinction between the lifetime of an object and the acquisition and release of the storage the object occupies, at least for objects with non-trivial initialization and/or a non-trivial destructor. The assumption is made in 12.2 [class.temporary] and elsewhere that the storage in which a temporary is created is no longer available for reuse, as specified in 3.8 [basic.life], after the lifetime of the temporary has ended, but this assumption is not explicitly stated. One way to make that assumption explicit would be to define a storage duration for temporaries whose lifetime is not extended.

#### 1338. Aliasing and allocation functions

Section: 3.7.4.1 [basic.stc.dynamic.allocation] Status: drafting Submitter: Jason Merrill Date: 2011-08-03

In 3.7.4.1 [basic.stc.dynamic.allocation] paragraph 2, allocation functions are constrained to return a pointer that is different from any previously returned pointer that has not been passed to a deallocation function. This does not, for instance, prohibit returning a pointer to storage that is part of another object, for example, a pool of storage. The potential implications of this for aliasing should be spelled out.

(See also issues 1027 and 1116.)

Additional note (March, 2013):

One possibility to allow reasonable optimizations would be to require that allocation packages hide their storage in file-static variables, perhaps by adding wording such as:

> Furthermore, `p0` shall point to an object distinct from any other object that is accessible outside the implementation of the allocation and deallocation functions.

Additional note, April, 2013:

Concern was expressed that a pool class might provide an interface for iterating over all the pointers that were given out from the pool, and this usage should be supported.

Notes from the September, 2013 meeting:

CWG agreed that changes for this issue should apply only to non-placement forms.

#### 1676. `auto` return type for allocation and deallocation functions

Section: 3.7.4.1 [basic.stc.dynamic.allocation] Status: drafting Submitter: Richard Smith Date: 2013-05-04

Do we need explicit language to forbid `auto` as the return type of allocation and deallocation functions?

(See also issue 1669.)

#### 1027. Type consistency and reallocation of scalar types

Section: 3.8 [basic.life] Status: drafting Submitter: Gabriel Dos Reis Date: 2010-02-03

Is the following well-formed?

        int f() {
            int i = 3;
            new (&i) float(1.2);
            return i;
        }

The wording that is intended to prevent such shenanigans, 3.8 [basic.life] paragraphs 7-9, doesn't quite apply here. In particular, paragraph 7 reads,

> If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at the storage location which the original object occupied, a pointer that pointed to the original object, a reference that referred to the original object, or the name of the original object will automatically refer to the new object and, once the lifetime of the new object has started, can be used to manipulate the new object, if:

> - the storage for the new object exactly overlays the storage location which the original object occupied, and

> - the new object is of the same type as the original object (ignoring the top-level cv-qualifiers), and...

The problem here is that this wording only applies “after the lifetime of an object has ended and before the storage which the object occupied is reused;” for an object of a scalar type, its lifetime only ends when the storage is reused or released (paragraph 1), so it appears that these restrictions cannot apply to such objects.

(See also issues 1116 and 1338.)

Proposed resolution (August, 2010):

This issue is resolved by the resolution of issue 1116.

#### 1116. Aliasing of union members

Section: 3.8 [basic.life] Status: drafting Submitter: US Date: 2010-08-02
N3092 comment US 27

Related to issue 1027, consider:

        int f() {
          union U { double d; } u1, u2;
          (int&)u1.d = 1;
          u2 = u1;
          return (int&)u2.d;
        }

Does this involve undefined behavior? 3.8 [basic.life] paragraph 4 seems to say that it's OK to clobber `u1` with an `int` object. Then union assignment copies the object representation, possibly creating an `int` object in `u2` and making the return statement well-defined. If this is well-defined, compilers are significantly limited in the assumptions they can make about type aliasing. On the other hand, the variant where `U` has an array of `unsigned char` member must be well-defined in order to support `std::aligned_storage`.

Suggested resolution: Clarify that this case is undefined, but that adding an array of `unsigned char` to union `U` would make it well-defined — if a storage location is allocated with a particular type, it should be undefined to create an object in that storage if it would be undefined to access the stored value of the object through the allocated type.

(See also issues 1027 and 1338.)

Proposed resolution (August, 2010):

1. Change 3.8 [basic.life] paragraph 1 as follows:

> ...The lifetime of an object of type `T` begins when storage with the proper alignment and size for type `T` is obtained, and either:

> - storage with the proper alignment and size for type `T` is obtained, and

> - if the object has non-trivial initialization, its initialization is complete., or

> - if `T` is trivially copyable, the object representation of another `T` object is copied into the storage.

> The lifetime of an object of type `T` ends...

2. Change 3.8 [basic.life] paragraph 4 as follows:

> A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor, the program is not required to call the destructor explicitly before the storage which the object occupies is reused or released; however, if there is no explicit call to the destructor or if a delete-expression (5.3.5 [expr.delete]) is not used to release the storage, the destructor shall not be implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior. If a program obtains storage for an object of a particular type `A` (e.g. with a variable definition or new-expression) and later reuses that storage for an object of another type `B` such that accessing the stored value of the `B` object through a glvalue of type `A` would have undefined behavior (3.10 [basic.lval]), the behavior is undefined. [Example:

>       int i;
>       (double&)i = 1.0; // undefined behavior

>       struct S { unsigned char alignas(double) ar[sizeof (double)]; } s;
>       (double&)s = 1.0; // OK, can access stored double through s because it has an unsigned char subobject

> —end example]

3. Change 3.10 [basic.lval] paragraph 10 as follows:

> If a program attempts to access the stored value of an object through a glvalue of other than one of the following types the behavior is undefined52:

> - the dynamic type of the object,

> - a cv-qualified version of the dynamic type of the object,

> - a type similar (as defined in 4.4 [conv.qual]) to the dynamic type of the object,

> - a type that is the signed or unsigned type corresponding to the dynamic type of the object,

> - a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of the object,

> - a `char` or `unsigned char` type,

> - an aggregate or union type that includes one of the aforementioned types among its elements, bases, or non-static data members (including, recursively, an element, base, or non-static data member of a subaggregate, base, or contained union),.

> - a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,

> - a `char` or `unsigned char` type.

This resolution also resolves issue 1027.

Additional note (August, 2012):

Concerns have been raised regarding the interaction of this change with facilities like `std::aligned_storage` and memory pools. Care must be taken to achieve the proper balance between supporting type-based optimization techniques and allowing practical storage management.

Additional note (January, 2013):

Several questions have been raised about the wording above . In particular:

1. Since aggregates and unions cannot have base classes, why are base classes mentioned?

2. Since unions can now have special member functions, is it still valid to assume that they alias all their member types?

3. Shouldn't standard-layout classes also be considered and not just aggregates?

#### 1284. Should the lifetime of an array be independent of that of its elements?

Section: 3.8 [basic.life] Status: drafting Submitter: Gabriel Dos Reis Date: 2011-04-02

The note in 3.8 [basic.life] paragraph 2 reads,

> [Note: The lifetime of an array object starts as soon as storage with proper size and alignment is obtained, and its lifetime ends when the storage which the array occupies is reused or released. 12.6.2 [class.base.init] describes the lifetime of base and member subobjects. —end note]

This wording reflects an earlier version of paragraph 1 that deferred the start of an object's lifetime only for initialization of objects of class type. The note simply emphasized the implication that that the lifetime of a POD type or an array began immediately, even if lifetime of an array's elements began later.

The decomposition of POD types removed the mention of PODs, leaving only the array types, and when the normative text was changed to include aggregates whose members have non-trivial initialization, the note was overlooked.

It is not clear whether it would be better to update the note to emphasize the distinction between aggregates with non-trivial initialization and those without or to delete it entirely.

A possible related normative change to consider is whether the specification of paragraph 1 is sufficiently clear with respect to multidimensional arrays. The current definition of “non-trivial initialization” is:

> An object is said to have non-trivial initialization if it is of a class or aggregate type and it or one of its members is initialized by a constructor other than a trivial default constructor.

Presumably the top-level array of an N-dimensional array whose ultimate element type is a class type with non-trivial initialization would also have non-trivial initialization, but it's not clear that this wording says that.

A more radical change that came up in the discussion was whether the undefined behavior resulting from an lvalue-to-rvalue conversion of an uninitialized object in 4.1 [conv.lval] paragraph 1 would be better dealt with as a lifetime violation instead.

#### 1530. Member access in out-of-lifetime objects

Section: 3.8 [basic.life] Status: drafting Submitter: Howard Hinnant Date: 2012-07-26

According to 3.8 [basic.life] paragraphs 5 and 6, a program has undefined behavior if a pointer or glvalue designating an out-of-lifetime object

> is used to access a non-static data member or call a non-static member function of the object

It is not clear what the word “access” means in this context. A reasonable interpretation might be using the pointer or glvalue as the left operand of a class member access expression; alternatively, it might mean to read or write the value of that member, allowing a class member access expression that is used only to form an address or bind a reference.

This needs to be clarified. A relevant consideration is the recent adoption of the resolution of issue 597, which eased the former restriction on simple address manipulations involving out-of-lifetime objects: if base-class offset calculations are now allowed, why not non-static data member offset calculations?

(See also issue 1531 for other uses of the term “access.”)

Additional note (January, 2013):

A related question is the meaning of the phrase “before the constructor begins execution” in 12.7 [class.cdtor] paragraph 1 means:

> For an object with a non-trivial constructor, referring to any non-static member or base class of the object before the constructor begins execution results in undefined behavior.

For example:

      struct DerivedMember { ... };

      struct Base {
        Base(DerivedMember const&);
      };

      struct Derived : Base {
        DerivedMember x;
        Derived() : Base(x) {}
      };

      Derived a;

Is the reference to `Derived::x` in the mem-initializer valid?

Additional note (March, 2013):

This clause is phrased in terms of the execution of the constructor. However, it is possible for an aggregate to have a non-trivial default constructor and be initialized without executing a constructor. The wording needs to be updated to allow for non-constructor initialization to avoid appearing to imply undefined behavior for an example like:

      struct X {
        std::string s;
      } x = {};
      std::string t = x.s;  // No constructor called for x: undefined behavior?

#### 1701. Array vs sequence in object representation

Section: 3.9 [basic.types] Status: drafting Submitter: Lawrence Crowl Date: 2013-06-14

According to 3.9 [basic.types] paragraph 4,

> The object representation of an object of type `T` is the sequence of N `unsigned char` objects taken up by the object of type `T`, where N equals `sizeof(T)`.

However, it is not clear that a “sequence” can be indexed, as an array can and as is required for the implementation of `memcpy` and similar code.

#### 636. Dynamic type of objects and aliasing

Section: 3.10 [basic.lval] Status: drafting Submitter: Gabriel Dos Reis Date: 23 May 2007

The aliasing rules given in 3.10 [basic.lval] paragraph 10 rely on the concept of “dynamic type.” The problem is that the dynamic type of an object often cannot be determined (or even sufficiently constrained) at the point at which an optimizer needs to be able to determine whether aliasing might occur or not. For example, consider the function

        void foo(int* p, double* q) {
            *p = 42;
            *q = 3.14;
        }

An optimizer, on the basis of the existing aliasing rules, might decide that an `int*` and a `double*` cannot refer to the same object and reorder the assignments. This reordering, however, could result in undefined behavior if the function `foo` is called as follows:

       void goo() {
          union {
             int i;
             double d;
          } t;

          t.i = 12;

          foo(&t.i, &t.d);

          cout << t.d << endl;
       };

Here, the reference to `t.d` after the call to `foo` will be valid only if the assignments in `foo` are executed in the order in which they were written; otherwise, the union will contain an `int` object rather than a `double`.

One possibility would be to require that if such aliasing occurs, it be done only via member names and not via pointers.

Notes from the July, 2007 meeting:

This is the same issue as C's DR236. The CWG expressed a desire to address the issue the same way C99 does. The issue also occurs in C++ when placement new is used to end the lifetime of one object and start the lifetime of a different object occupying the same storage.

#### 1211. Misaligned lvalues

Section: 3.11 [basic.align] Status: drafting Submitter: David Svoboda Date: 2010-10-20

3.11 [basic.align] speaks of “alignment requirements,” and 3.7.4.1 [basic.stc.dynamic.allocation] requires the result of an allocation function to point to “suitably aligned” storage, but there is no explicit statement of what happens when these requirements are violated (presumably undefined behavior).

#### 617. Lvalue-to-rvalue conversions of uninitialized `char` objects

Section: 4.1 [conv.lval] Status: drafting Submitter: Alan Stokes Date: 6 February 2007

According to 4.1 [conv.lval] paragraph 1, applying the lvalue-to-rvalue conversion to any uninitialized object results in undefined behavior. However, character types are intended to allow any data, including uninitialized objects and padding, to be copied (hence the statements in 3.9.1 [basic.fundamental] paragraph 1 that “For character types, all bits of the object representation participate in the value representation” and in 3.10 [basic.lval] paragraph 15 that `char` and `unsigned char` types can alias any object). The lvalue-to-rvalue conversion should be permitted on uninitialized objects of character type without evoking undefined behavior.

#### 1787. Uninitialized `unsigned char` values

Section: 4.1 [conv.lval] Status: drafting Submitter: United Kingdom Date: 2013-09-28
N3690 comment GB 2

The current wording of 4.1 [conv.lval] gives the result of fetching an uninitialized unsigned character an unspecified value, which is then stable: assigned to a different variable, it will be the same throughout the lifetime of that variable. It would be more helpful to optimizers for the unspecified value to be viral, so that fetching from the second variable would also yield an unspecified result, not necessarily the same each time.

#### 170. Pointer-to-member conversions

Section: 4.11 [conv.mem] Status: drafting Submitter: Mike Stump Date: 16 Sep 1999

The descriptions of explicit (5.2.9 [expr.static.cast] paragraph 9) and implicit (4.11 [conv.mem] paragraph 2) pointer-to-member conversions differ in two significant ways:

1. In a `static_cast`, a conversion in which the class in the target pointer-to-member type is a base of the class in which the member is declared is permitted and required to work correctly, as long as the resulting pointer-to-member is eventually dereferenced with an object whose dynamic type contains the member. That is, the class of the target pointer-to-member type is not required to contain the member referred to by the value being converted. The specification of implicit pointer-to-member conversion is silent on this question.

   (This situation cannot arise in an implicit pointer-to-member conversion where the source value is something like `&X::f`, since you can only implicitly convert from pointer-to-base-member to pointer-to-derived-member. However, if the source value is the result of an explicit "up-cast," the target type of the conversion might still not contain the member referred to by the source value.)

2. The target type in a `static_cast` is allowed to be more cv-qualified than the source type; in an implicit conversion, however, the cv-qualifications of the two types are required to be identical.

The first difference seems like an oversight. It is not clear whether the latter difference is intentional or not.

(See also issue 794.)

#### 536. Problems in the description of id-expressions

Section: 5.1.1 [expr.prim.general] Status: drafting Submitter: Mike Miller Date: 13 October 2005

There are at least a couple of problems in the description of the various id-expressions in 5.1.1 [expr.prim.general]:

1. Paragraph 4 embodies an incorrect assumption about the syntax of qualified-ids:

   > The operator `::` followed by an identifier, a qualified-id, or an operator-function-id is a primary-expression.

   The problem here is that the `::` is actually part of the syntax of qualified-id; consequently, “`::` followed by... a qualified-id” could be something like “`:: ::i`,” which is ill-formed. Presumably this should say something like, “A qualified-id with no nested-name-specifier is a primary-expression.”

2. More importantly, some kinds of id-expressions are not described by 5.1.1 [expr.prim.general]. The structure of this section is that the result, type, and lvalue-ness are specified for each of the cases it covers:

   - paragraph 4 deals with qualified-ids that have no nested-name-specifier

   - paragraph 7 deals with bare identifiers and with qualified-ids containing a nested-name-specifier that names a class

   - paragraph 8 deals with qualified-ids containing a nested-name-specifier that names a namespace

   This treatment leaves unspecified all the non-identifier unqualified-ids (operator-function-id, conversion-function-id, and template-id), as well as (perhaps) “`::` template-id” (it's not clear whether the “`::` followed by a qualified-id” case is supposed to apply to template-ids or not). Note also that the proposed resolution of issue 301 slightly exacerbates this problem by removing the form of operator-function-id that contains a tmeplate-argument-list; as a result, references like “`::operator+<X>`” are no longer covered in 5.1.1 [expr.prim.general].

#### 1249. Cv-qualification of nested lambda capture

Section: 5.1.2 [expr.prim.lambda] Status: drafting Submitter: James Widman Date: 2011-03-02

Consider the following example:

        void f(int i) {
          auto l1 = [i] {
            auto l2 = [&i] {
              ++i;    // Well-formed?
            };
          };
        }

Because the `l1` lambda is not marked as `mutable`, its `operator()` is `const`; however, it is not clear from the wording of 5.1.2 [expr.prim.lambda] paragraph 16 whether the captured member of the enclosing lambda is considered `const` or not.

#### 1468. `typeid`, overload resolution, and implicit lambda capture

Section: 5.1.2 [expr.prim.lambda] Status: drafting Submitter: Doug Gregor Date: 2012-02-08

According to 5.1.2 [expr.prim.lambda] paragraph 11, a variable is implicitly captured if it is odr-used. In the following example,

      struct P {
       virtual ~P();
      };

      P &f(int&);
      int f(const int&);

      void g(int x) {
       [=] {
        typeid(f(x));
       };
      }

`x` is only odr-used if the operand of `typeid` is a polymorphic lvalue; otherwise, the operand is unevaluated (5.2.8 [expr.typeid] paragraphs 2-3). Whether the operand is a polymorphic lvalue depends on overload resolution in this case, which depends on whether `x` is captured or not: if `x` is captured, since the lambda is not `mutable`, the type of `x` in the body of the lambda is `const int`, while if it is not captured, it is just `int`. However, the `const int` version of `f` returns `int` and the `int` version of `f` returns a polymorphic lvalue, leading to a conundrum: `x` is only captured if it is not captured, and vice versa.

Notes from the October, 2012 meeting:

The approach favored by CWG was to specify that the operand of `typeid` is considered to be odr-used for the purpose of determining capture.

#### 1629. Can a closure class be a literal type?

Section: 5.1.2 [expr.prim.lambda] Status: drafting Submitter: John Spicer Date: 2012-02-22

The description of the characteristics of a closure class in 5.1.2 [expr.prim.lambda] leaves open the possibility that such a class might be a literal type, although it could also be a non-literal type. It would probably be good to specify that a closure class is not a literal type, in the interests of portability.

On a related note, it might be wise to remove the implementation freedom to make a closure class either a POD or not a POD; it seems only to be an invitation for portability problems with no real advantage.

Additional note, April, 2013:

Some have expressed the opinion that such portability issues are just “par for the course,” and that specifying these characteristics at this point might unnecessarily limit the ability to extend the language in desirable directions at some point in the future.

Proposed resolution (April, 2013):

Change 5.1.2 [expr.prim.lambda] paragraph 3 as follows:

> ...An implementation may define the closure type differently from what is described below provided this does not alter the observable behavior of the program other than by changing:

> - the size and/or alignment of the closure type,

> - whether the closure type is trivially copyable (Clause 9 [class]),

> - whether the closure type is a literal type (3.9 [basic.types]),

> - whether the closure type is a standard-layout class (Clause 9 [class]), or

> - whether the closure type is a POD class (Clause 9 [class]).

Notes from the September, 2013 meeting:

At the suggestion of EWG, it was decided that closure types should be specified as not literal, rather than being unspecified as in the April, 2013 proposed resolution. The issue has thus been returned to "drafting" status.

#### 1722. Should lambda to function pointer conversion function be `noexcept`?

Section: 5.1.2 [expr.prim.lambda] Status: drafting Submitter: Ville Voutilainen Date: 2013-07-31

According to 5.1.2 [expr.prim.lambda] paragraph 6,

> The closure type for a non-generic lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function with C++ language linkage (7.5 [dcl.link]) having the same parameter and return types as the closure type's function call operator.

This does not specify whether the conversion function is `noexcept(true)` or `noexcept(false)`. It might be helpful to nail that down.

#### 1646. decltype-specifiers, abstract classes, and deduction failure

Section: 5.2.2 [expr.call] Status: drafting Submitter: Jason Merrill Date: 2013-03-28

According to 5.2.2 [expr.call] paragraph 11,

> If a function call is a prvalue of object type:

> - if the function call is either

> - the operand of a decltype-specifier or

> - the right operand of a comma operator that is the operand of a decltype-specifier,

> a temporary object is not introduced for the prvalue. The type of the prvalue may be incomplete. [Note: as a result, storage is not allocated for the prvalue and it is not destroyed; thus, a class type is not instantiated as a result of being the type of a function call in this context. This is true regardless of whether the expression uses function call notation or operator notation (13.3.1.2 [over.match.oper]). —end note] [Note: unlike the rule for a decltype-specifier that considers whether an id-expression is parenthesized (7.1.6.2 [dcl.type.simple]), parentheses have no special meaning in this context. —end note]

> - otherwise, the type of the prvalue shall be complete.

Thus, an example like

      template <class T> struct A: T { };
      template <class T> A<T> f(T) { return A<T>(); };
      decltype(f(42)) *p;

is well-formed. However, a function template specialization in which the return type is an abstract class should be a deduction failure, per 14.8.2 [temp.deduct] paragraph 8, last bullet:

- ...

- Attempting to create a function type in which a parameter type or the return type is an abstract class type (10.4 [class.abstract]).

The requirement that the return type in a function call in a decltype-specifier not be instantiated prevents the detection of this deduction failure in an example like:

      template <class T> struct A { virtual void f() = 0; };
      template <class T> A<T> f(T) { return A<T>(); };
      decltype(f(42)) *p;

It is not clear how this should be resolved.

(See also issue 1640.)

#### 1521. `T{`expr`}` with reference types

Section: 5.2.3 [expr.type.conv] Status: drafting Submitter: Steve Adamczyk Date: 2012-07-10

According to 5.2.3 [expr.type.conv] paragraph 4,

> Similarly, a simple-type-specifier or typename-specifier followed by a braced-init-list creates a temporary object of the specified type direct-list-initialized (8.5.4 [dcl.init.list]) with the specified braced-init-list, and its value is that temporary object as a prvalue.

This wording does not handle the case where `T` is a reference type: it is not possible to create a temporary object of that type, and presumably the result would be an xvalue, not a prvalue.

#### 1739. Conversion of floating point to enumeration

Section: 5.2.9 [expr.static.cast] Status: drafting Submitter: Ville Voutilainen Date: 2013-08-18

The specification of conversion from integral or enumeration type in 5.2.9 [expr.static.cast] paragraph 10 uses the phrase “explicitly converted,” while the description of conversion from floating point to enumeration omits the word “explicitly.” Presumably these should be harmonized.

#### 232. Is indirection through a null pointer undefined behavior?

Section: 5.3.1 [expr.unary.op] Status: drafting Submitter: Mike Miller Date: 5 Jun 2000

At least a couple of places in the IS state that indirection through a null pointer produces undefined behavior: 1.9 [intro.execution] paragraph 4 gives "dereferencing the null pointer" as an example of undefined behavior, and 8.3.2 [dcl.ref] paragraph 4 (in a note) uses this supposedly undefined behavior as justification for the nonexistence of "null references."

However, 5.3.1 [expr.unary.op] paragraph 1, which describes the unary "*" operator, does not say that the behavior is undefined if the operand is a null pointer, as one might expect. Furthermore, at least one passage gives dereferencing a null pointer well-defined behavior: 5.2.8 [expr.typeid] paragraph 2 says

> If the lvalue expression is obtained by applying the unary * operator to a pointer and the pointer is a null pointer value (4.10 [conv.ptr]), the `typeid` expression throws the `bad_typeid` exception (18.7.3 [bad.typeid]).

This is inconsistent and should be cleaned up.

Bill Gibbons:

At one point we agreed that dereferencing a null pointer was not undefined; only using the resulting value had undefined behavior.

For example:

        char *p = 0;
        char *q = &*p;

Similarly, dereferencing a pointer to the end of an array should be allowed as long as the value is not used:

        char a[10];
        char *b = &a[10];   // equivalent to "char *b = &*(a+10);"

Both cases come up often enough in real code that they should be allowed.

Mike Miller:

I can see the value in this, but it doesn't seem to be well reflected in the wording of the Standard. For instance, presumably `*p` above would have to be an lvalue in order to be the operand of "`&`", but the definition of "lvalue" in 3.10 [basic.lval] paragraph 2 says that "an lvalue refers to an object." What's the object in `*p`? If we were to allow this, we would need to augment the definition to include the result of dereferencing null and one-past-the-end-of-array.

Tom Plum:

Just to add one more recollection of the intent: I was very happy when (I thought) we decided that it was only the attempt to actually fetch a value that creates undefined behavior. The words which (I thought) were intended to clarify that are the first three sentences of the lvalue-to-rvalue conversion, 4.1 [conv.lval]:

> An lvalue (3.10 [basic.lval]) of a non-function, non-array type `T` can be converted to an rvalue. If `T` is an incomplete type, a program that necessitates this conversion is ill-formed. If the object to which the lvalue refers is not an object of type `T` and is not an object of a type derived from `T`, or if the object is uninitialized, a program that necessitates this conversion has undefined behavior.

In other words, it is only the act of "fetching", of lvalue-to-rvalue conversion, that triggers the ill-formed or undefined behavior. Simply forming the lvalue expression, and then for example taking its address, does not trigger either of those errors. I described this approach to WG14 and it may have been incorporated into C 1999.

Mike Miller:

If we admit the possibility of null lvalues, as Tom is suggesting here, that significantly undercuts the rationale for prohibiting "null references" -- what is a reference, after all, but a named lvalue? If it's okay to create a null lvalue, as long as I don't invoke the lvalue-to-rvalue conversion on it, why shouldn't I be able to capture that null lvalue as a reference, with the same restrictions on its use?

I am not arguing in favor of null references. I don't want them in the language. What I am saying is that we need to think carefully about adopting the permissive approach of saying that it's all right to create null lvalues, as long as you don't use them in certain ways. If we do that, it will be very natural for people to question why they can't pass such an lvalue to a function, as long as the function doesn't do anything that is not permitted on a null lvalue.

If we want to allow `&*(p=0)`, maybe we should change the definition of "`&`" to handle dereferenced null specially, just as `typeid` has special handling, rather than changing the definition of lvalue to include dereferenced nulls, and similarly for the array_end+1 case. It's not as general, but I think it might cause us fewer problems in the long run.

Notes from the October 2003 meeting:

See also issue 315, which deals with the call of a static member function through a null pointer.

We agreed that the approach in the standard seems okay: `p = 0; *p;` is not inherently an error. An lvalue-to-rvalue conversion would give it undefined behavior.

Proposed resolution (October, 2004):

(Note: the resolution of issue 453 also resolves part of this issue.)

1. Add the indicated words to 3.10 [basic.lval] paragraph 2:

   > An lvalue refers to an object or function or is an empty lvalue (5.3.1 [expr.unary.op]).

2. Add the indicated words to 5.3.1 [expr.unary.op] paragraph 1:

   > The unary `*` operator performs indirection: the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points, if any. If the pointer is a null pointer value (4.10 [conv.ptr]) or points one past the last element of an array object (5.7 [expr.add]), the result is an empty lvalue and does not refer to any object or function. An empty lvalue is not modifiable. If the type of the expression is “pointer to `T`,” the type of the result is “`T`.” [Note: a pointer to an incomplete type (other than cv void) can be dereferenced. The lvalue thus obtained can be used in limited ways (to initialize a reference, for example); this lvalue must not be converted to an rvalue, see 4.1 [conv.lval].—end note]

3. Add the indicated words to 4.1 [conv.lval] paragraph 1:

   > If the object to which the lvalue refers is not an object of type `T` and is not an object of a type derived from `T`, or if the object is uninitialized, or if the lvalue is an empty lvalue (5.3.1 [expr.unary.op]), a program that necessitates this conversion has undefined behavior.

4. Change 1.9 [intro.execution] as indicated:

   > Certain other operations are described in this International Standard as undefined (for example, the effect of dereferencing the null pointer division by zero).

Note (March, 2005):

The 10/2004 resolution interacts with the resolution of issue 73. We added wording to 3.9.2 [basic.compound] paragraph 3 to the effect that a pointer containing the address one past the end of an array is considered to “point to” another object of the same type that might be located there. The 10/2004 resolution now says that it would be undefined behavior to use such a pointer to fetch the value of that object. There is at least the appearance of conflict here; it may be all right, but it at needs to be discussed further.

Notes from the April, 2005 meeting:

The CWG agreed that there is no contradiction between this direction and the resolution of issue 73. However, “not modifiable” is a compile-time concept, while in fact this deals with runtime values and thus should produce undefined behavior instead. Also, there are other contexts in which lvalues can occur, such as the left operand of `.` or `.*`, which should also be restricted. Additional drafting is required.

(See also issue 1102.)

#### 1653. Removing deprecated increment of `bool`

Section: 5.3.2 [expr.pre.incr] Status: drafting Submitter: Bjarne Stroustrup Date: 2013-04-19

The preincrement (5.3.2 [expr.pre.incr]) and postincrement (5.2.6 [expr.post.incr]) operators can be applied to operands of type `bool`, setting the operand to `true`, but this use is deprecated. Can it now be removed altogether?

#### 901. Deleted `operator delete`

Section: 5.3.4 [expr.new] Status: drafting Submitter: John Spicer Date: 20 May, 2009

It is not clear from 5.3.4 [expr.new] whether a deleted `operator delete` is referenced by a new-expression in which there is no initialization or in which the initialization cannot throw an exception, rendering the program ill-formed. (The question also arises as to whether such a new-expression constitutes a “use” of the deallocation function in the sense of 3.2 [basic.def.odr].)

Notes from the July, 2009 meeting:

The rationale for defining a deallocation function as deleted would presumably be to prevent such objects from being freed. Treating the new-expression as a use of such a deallocation function would mean that such objects could not be created in the first place. There is already an exemption from freeing an object if “a suitable deallocation function [cannot] be found;” a deleted deallocation function should be treated similarly.

#### 1469. Omitted bound in array new-expression

Section: 5.3.4 [expr.new] Status: drafting Submitter: Johannes Schaub Date: 2012-02-12

The syntax for noptr-new-declarator in 5.3.4 [expr.new] paragraph 1 requires an expression, even though the bound could be inferred from a braced-init-list initializer. It is not clear whether 8.5.1 [dcl.init.aggr] paragraph 4,

> An array of unknown size initialized with a brace-enclosed initializer-list containing `n` initializer-clauses, where `n` shall be greater than zero, is defined as having `n` elements (8.3.4 [dcl.array]).

should be considered to apply to the new-type-id variant, e.g.,

      new (int[]){1, 2, 3}

Additional note (August, 2012):

The consensus during the 2012-08-13 drafting review teleconference was that this issue should be referred to the Evolution Working Group and not handled by the Core Working Group.

#### 1786. Effect of merging allocations on memory leakage

Section: 5.3.4 [expr.new] Status: drafting Submitter: United Kingdom Date: 2013-09-28
N3690 comment GB 4

The strategy of merging allocations could turn a small memory leak into a big one. For example,

      class P {
        int x;
      };
      class Q {
      public:
        Q(){ throw 42; }
      private:
        int x[LARGE_NUMBER];
      };

      {
        P* p1 = new P();
        Q* q1 = new Q(); // bang :-(
        // don't get here
        delete q1;
        delete p1;
      }

Instead of just leaking the first allocation, this could result in leaking the combined allocation.

Notes from the September, 2013 meeting:

EWG was not so concerned with memory leaks, but there are problems with the current wording dealing with lifetime issues. In particular, the existing wording did not guarantee that all of the merged allocations would, in fact, be executed. The intended direction is to relax the strict lifetime containment requirement from the current wording but to ensure that all of the allocations and frees will be executed, which requires that the allocation and initialization of later objects be non-throwing.

#### 1598. Criterion for equality of pointers to members

Section: 5.10 [expr.eq] Status: drafting Submitter: Richard Smith Date: 2012-12-21

According to 5.10 [expr.eq] paragraph 2, pointers to data members compare equal

> if and only if they would refer to the same member of the same most derived object (1.8 [intro.object]) or the same subobject if indirection with a hypothetical object of the associated class type were performed.

This specification is overly constrained. For data members, most implementations simply compare the offsets of the members involved, violating the “only if” part of the specification. For example:

      struct A {};
      struct B : A { int x; };
      struct C : A { int x; };

      int A::*bx = (int(A::*))&B::x;
      int A::*cx = (int(A::*))&C::x;

      bool b1 = bx == cx;

The existing wording requires `b1` to have the value `false`, even though the offsets of the members are the same. It would be better if the result of the comparison were unspecified unless the class containing the original member for the LHS is a base or derived class of the class containing the original member for the RHS.

#### 1652. Object addresses in `constexpr` expressions

Section: 5.10 [expr.eq] Status: drafting Submitter: Richard Smith Date: 2013-04-15

Pointer equality is defined by reference to the addresses of the objects designated by the pointer values, reflecting the implementation technique of most/all compilers. However, this definition is intrinsically a runtime property, and such a description is inappropriate with respect to `constexpr` expressions, which must deal with pointer comparisons without necessarily knowing the runtime layout of the objects involved. A better definition usable at compile time is needed.

#### 1542. Compound assignment of braced-init-list

Section: 5.17 [expr.ass] Status: drafting Submitter: Mike Miller Date: 2012-08-21

The specification of 5.17 [expr.ass] paragraph 9 is presumably intended to allow use of a braced-init-list as the operand of a compound assignment operator as well as a simple assignment operator, although the normative wording does not explicitly say so. (The example in that paragraph does include

      complex<double> z;
      z += { 1, 2 };      // meaning z.operator+=({1,2})

for instance, which could be read to imply compound assignment operators for scalar types as well.)

However, the details of how this is to be implemented are not clear. Paragraph 7 says,

> The behavior of an expression of the form `E1` op `=` `E2` is equivalent to `E1 = E1` op `E2` except that `E1` is evaluated only once.

Applying this pattern literally to a braced-init-list yields invalid code: `x += {1}` would become `x = x + {1}`, which is non-syntactic.

Another problem is how to apply the prohibition against narrowing conversions to a compound assignment. For example,

      char c;
      c += {1};

would presumably always be a narrowing error, because after integral promotions, the type of `c+1` is `int`. The similar issue 1078 was classified as "NAD" because the workaround was simply to add a cast to suppress the error; however, there is no place to put a similar cast in a compound assignment.

Notes from the October, 2012 meeting:

The incorrect description of the meaning of a compound assignment with a braced-init-list should be fixed by CWG. The question of whether it makes sense to apply narrowing rules to such assignments is better addressed by EWG.

#### 1255. Definition problems with `constexpr` functions

Section: 5.19 [expr.const] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-08

The current wording of the Standard is not sufficiently clear regarding the interaction of class scope (which treats the bodies of member functions as effectively appearing after the class definition is complete) and the use of `constexpr` member functions within the class definition in contexts requiring constant expressions. For example, an array bound cannot use a `constexpr` member function that relies on the completeness of the class or on members that have not yet been declared, but the current wording does not appear to state that.

Additional note (October, 2013):

This question also affects function return type deduction (the `auto` specifier) in member functions. For example, the following should presumably be prohibited, but the current wording is not clear:

      struct S {
        static auto f() {
          return 42;
        }
        auto g() -> decltype(f()) {
          return f();
        }
      };

#### 1452. Value-initialized objects may be constants

Section: 5.19 [expr.const] Status: drafting Submitter: Richard Smith Date: 2011-12-24

Some classes that would produce a constant when initialized by value-initialization are not considered literal types. For example:

       struct A { int a; }; // non-constexpr default constructor
       struct B : A {};     // non-literal type

#### 1480. Constant initialization via non-constant temporary

Section: 5.19 [expr.const] Status: drafting Submitter: Daniel Krügler Date: 2012-03-17

The following initializations appear to be well-formed:

      struct C {
       int m;
       constexpr C(int m ) : m{m} {};
       constexpr int get() { return m; };
      };

      C&& rr = C{1};
      constexpr int k1 = rr.get();

      const C& cl = C{1};
      constexpr int k2 = cl.get();

They appear to fall under the bullet of 5.19 [expr.const] paragraph 2,

- an lvalue-to-rvalue conversion (4.1 [conv.lval]) unless it is applied to

- ...

- a non-volatile glvalue of literal type that refers to a non-volatile temporary object whose lifetime has not ended, initialized with a constant expression;

The problem in this example is that the referenced temporary object is not a constant, so it would be well-defined for intervening code to modify its value before it was used in the later initialization.

Additional note (February, 2013):

The intent is that non-const references to temporaries should be allowed within constant expressions, e.g., across `constexpr` function calls, but not as the result of a constant expression.

#### 1626. `constexpr` member functions in brace-or-equal-initializers

Section: 5.19 [expr.const] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-02-19

The Standard should make clear that a `constexpr` member function cannot be used in a constant expression until its class is complete. For example:

      template<typename T> struct C {
        template<typename T2> static constexpr bool _S_chk() {
          return false;
        }
        static const bool __value = _S_chk<int>();
      };

      C<double> c;

Current implementations accept this, although they reject the corresponding non-template case:

      struct C {
        static constexpr bool _S_chk() { return false; }
        static const bool __value = _S_chk();
      };

      C c;

Presumably the template case should be handled consistently with the non-template case.

#### 1732. Defining types in conditions and range-based `for` statements

Section: 6.4 [stmt.select] Status: drafting Submitter: Richard Smith Date: 2013-08-08

The interaction of various issue resolutions has inadvertently resulted in the loss of the prohibition of defining types in conditions (6.4 [stmt.select] paragraph 1) and in a range-based `for` (6.5 [stmt.iter] paragraph 1). Issue 686 addressed a patchwork of restrictions by banning type definitions in type-specifier-seqs. Issue 948 then changed the definition of condition to use a decl-specifier-seq instead of a type-specifier-seq in order to permit the `constexpr` specifier. A similar change was made for range-based `for` statements by issue 1204.

The restrictions against type definitions in these contexts should be restored.

#### 1274. Common nonterminal for expression and braced-init-list

Section: 6.5.4 [stmt.ranged] Status: drafting Submitter: Daniel Krügler Date: 2011-03-25

It would be helpful to have a single grammar term for expression and braced-init-list, which often occur together in the text. In particular, 6.5.4 [stmt.ranged] paragraph 1 allows both, but the description of `__RangeT` refers only to the expression case; such errors would be less likely if the common term were available.

#### 1523. Point of declaration in range-based `for`

Section: 6.5.4 [stmt.ranged] Status: drafting Submitter: John Spicer Date: 2012-07-16

According to the general rule for declarations in 3.3.2 [basic.scope.pdecl] paragraph 1,

> The point of declaration for a name is immediately after its complete declarator (Clause 8 [dcl.decl]) and before its initializer (if any), except as noted below.

However, the rewritten expansion of the range-based `for` statement in 6.5.4 [stmt.ranged] paragraph 1 contradicts this general rule, so that the index variable is not visible in the range-init:

      for (int i : {i}) ;   // error: i not in scope

(See also issue 1498 for another question regarding the rewritten form of the range-based `for`.)

Notes from the October, 2012 meeting:

EWG is discussing issue 900 and the outcome of that discussion should be taken into consideration in addressing this issue.

Notes from the April, 2013 meeting:

The approach favored by CWG for resolving this issue is to change the point of declaration of the variable in the for-range-declaration to be after the `)`.

#### 1680. Including `<initializer_list>` for range-based `for`

Section: 6.5.4 [stmt.ranged] Status: drafting Submitter: Richard Smith Date: 2013-05-13

A simple example like

      int main() {
        int k = 0;
        for (auto x : { 1, 2, 3 })
          k += x;
        return k;
      }

requires that the `<initializer_list>` header be included, because the expansion of the range-based `for` involves a declaration of the form

      auto &&__range = { 1, 2, 3 };

and a braced-init-list causes `auto` to be deduced as a specialization of `std::initializer_list`. This seems unnecessary and could be eliminated by specifying that `__range` has an array type for cases like this.

(It should be noted that EWG is considering a proposal to change `auto` deduction for cases involving braced-init-lists, so resolution of this issue should be coordinated with that effort.)

Notes from the September, 2013 meeting:

CWG felt that this issue should be resolved by using the array variant of the range-based `for` implementation.

#### 1223. Syntactic disambiguation and trailing-return-types

Section: 6.8 [stmt.ambig] Status: drafting Submitter: Michael Wong Date: 2010-11-08

Because the restriction that a trailing-return-type can appear only in a declaration with “the single type-specifier `auto`” (8.3.5 [dcl.fct] paragraph 2) is a semantic, not a syntactic, restriction, it does not influence disambiguation, which is “purely syntactic” (6.8 [stmt.ambig] paragraph 3). Consequently, some previously unambiguous expressions are now ambiguous. For example:

    struct A {
      A(int *);
      A *operator()(void);
      int B;
    };

    int *p;
    typedef struct BB { int C[2]; } *B, C;

    void foo() {
    // The following line becomes invalid under C++0x:
      A (p)()->B;  // ill-formed function declaration

    // In the following,
    // - B()->C is either type-id or class member access expression
    // - B()->C[1] is either type-id or subscripting expression
    // N3126 subclause 8.2 [dcl.ambig.res] does not mention an ambiguity
    // with these forms of expression
      A a(B ()->C);  // function declaration or object declaration
      sizeof(B ()->C[1]);  // sizeof(type-id) or sizeof on an expression
    }

Notes from the March, 2011 meeting:

CWG agreed that the presence of `auto` should be considered in disambiguation, even though it is formally handled semantically rather than syntactically.

#### 1616. Disambiguation parsing and template parameters

Section: 6.8 [stmt.ambig] Status: drafting Submitter: Johannes Schaub Date: 2013-02-01

According to 6.8 [stmt.ambig] paragraph 3,

> The disambiguation is purely syntactic; that is, the meaning of the names occurring in such a statement, beyond whether they are type-names or not, is not generally used in or changed by the disambiguation. Class templates are instantiated as necessary to determine if a qualified name is a type-name. Disambiguation precedes parsing, and a statement disambiguated as a declaration may be an ill-formed declaration. If, during parsing, a name in a template parameter is bound differently than it would be bound during a trial parse, the program is ill-formed. No diagnostic is required. [Note: This can occur only when the name is declared earlier in the declaration. —end note]

The statement about template parameters is confusing (and not helped by the fact that the example that follows illustrates the general rule for declarations and does not involve any template parameters). It is attempting to say that a program is ill-formed if a template argument of a class template specialization has a different value in the two parses. With `decltype` this can now apply to other kinds of templates as well, so the wording should be clarified and made more general.

#### 1325. Omitted declarator in `friend` declarations

Section: 7 [dcl.dcl] Status: drafting Submitter: Johannes Schaub Date: 2011-05-27

According to 7 [dcl.dcl] paragraph 3,

> In a simple-declaration, the optional init-declarator-list can be omitted only when declaring a class (Clause 9 [class]) or enumeration (7.2 [dcl.enum]), that is, when the decl-specifier-seq contains either a class-specifier, an elaborated-type-specifier with a class-key (9.1 [class.name]), or an enum-specifier.

This does not allow for the new simplified `friend` declaration syntax (11.3 [class.friend] paragraph 3), which permits the forms

`friend` simple-type-specifier `;`
`friend` typename-specifier `;`

#### 1247. Restriction on alias name appearing in type-id

Section: 7.1.3 [dcl.typedef] Status: drafting Submitter: James Widman Date: 2011-02-26

With the resolution of issue 1044, there is no need to say that the name of the alias cannot appear in the type-id of the declaration.

#### 1684. Static `constexpr` member functions for non-literal classes

Section: 7.1.5 [dcl.constexpr] Status: drafting Submitter: Richard Smith Date: 2013-05-15

The current wording of 7.1.5 [dcl.constexpr] paragraph 8 is:

> The `constexpr` specifier has no effect on the type of a `constexpr` function or a `constexpr` constructor. The class of which a `constexpr` function is a member shall be a literal type (3.9 [basic.types]).

The previous version of this wording made clear that the restriction on the class type applied only to non-static member functions; consequently, the new formulation has inadvertently banned static `constexpr` member functions of non-literal classes.

#### 1712. `constexpr` variable template declarations

Section: 7.1.5 [dcl.constexpr] Status: drafting Submitter: Richard Smith Date: 2013-07-08

According to 7.1.5 [dcl.constexpr] paragraph 1,

> If any declaration of a function, function template, or variable template has a `constexpr` specifier, then all its declarations shall contain the `constexpr` specifier.

This requirement does not make sense applied to variable templates. The `constexpr` specifier requires that there be an initializer, and a variable template declaration with an initializer is a definition, so there cannot be more than one declaration of a variable template with the `constexpr` specifier.

#### 1707. `template` in elaborated-type-specifier without nested-name-specifier

Section: 7.1.6.3 [dcl.type.elab] Status: drafting Submitter: Richard Smith Date: 2013-06-27

The grammar for elaborated-type-specifier in 7.1.6.3 [dcl.type.elab] reads, in part,

elaborated-type-specifier:

class-key nested-name-specifieropt `template` opt simple-template-id

This allows use of the `template` keyword without a nested-name-specifier, e.g., `struct template S<int>`. This is inconsistent with other uses of the `template` keyword. It might be better to split the production in two and only allow the keyword following a nested-name-specifier, i.e.,

elaborated-type-specifier:

class-key simple-template-id
class-key nested-name-specifier `template` opt simple-template-id

#### 1348. Use of `auto` in a trailing-return-type

Section: 7.1.6.4 [dcl.spec.auto] Status: drafting Submitter: Richard Smith Date: 2011-08-16

It is not clear whether the `auto` specifier can appear in a trailing-return-type.

#### 1674. Return type deduction for address of function

Section: 7.1.6.4 [dcl.spec.auto] Status: drafting Submitter: Richard Smith Date: 2013-05-02

The following example appears in 7.1.6.4 [dcl.spec.auto] paragraph 12:

      template <class T> auto f(T t) { return t; } // return type deduced at instantiation time
      typedef decltype(f(1)) fint_t;               // instantiates f<int> to deduce return type
      template<class T> auto f(T* t) { return *t; }
      void g() { int (*p)(int*) = &f; }            // instantiates both fs to determine return types,
                                                   // chooses second

This is the desired behavior, but the current wording does not achieve that effect. One possible way this could work would be:

- `auto` is treated as a non-deduced context

- in 14.8.2.2 [temp.deduct.funcaddr], the deduced `A` is produced by substituting the deduced template arguments into the original function template, rather than substituting them into `P`, and the deduced `A` is the type of the produced function declaration (triggering instantiation of a definition as needed to complete the type)

#### 1485. Out-of-class definition of member unscoped opaque enumeration

Section: 7.2 [dcl.enum] Status: drafting Submitter: Richard Smith Date: 2012-03-26

The scope in which the names of enumerators are entered for a member unscoped opaque enumeration is not clear. According to 7.2 [dcl.enum] paragraph 10,

> Each enum-name and each unscoped enumerator is declared in the scope that immediately contains the enum-specifier.

In the case of a member opaque enumeration defined outside its containing class, however, it is not clear whether the enumerator names are declared in the class scope or in the lexical scope containing the definition. Declaring them in the class scope would be a violation of 9.2 [class.mem] paragraph 1:

> The member-specification in a class definition declares the full set of members of the class; no member can be added elsewhere.

Declaring the names in the lexical scope containing the definition would be contrary to the example in 14.5.1.4 [temp.mem.enum] paragraph 1:

      template<class T> struct A {
        enum E : T;
      };
      A<int> a;
      template<class T> enum A<T>::E : T { e1, e2 };
      A<int>::E e = A<int>::e1;

There also appear to be problems with the rules for dependent types and members of the current instantiation.

#### 1636. Bits required for negative enumerator values

Section: 7.2 [dcl.enum] Status: drafting Submitter: Hyman Rosen Date: 2013-03-07

According to 7.2 [dcl.enum] paragraph 7,

> For an enumeration whose underlying type is fixed, the values of the enumeration are the values of the underlying type. Otherwise, for an enumeration where emin is the smallest enumerator and emax is the largest, the values of the enumeration are the values in the range bmin to bmax, defined as follows: Let K be 1 for a two's complement representation and 0 for a one's complement or sign-magnitude representation. bmax is the smallest value greater than or equal to max(|emin|-K,|emax|) and equal to 2M-1, where M is a non-negative integer. bmin is zero if emin is non-negative and -(bmax+K) otherwise. The size of the smallest bit-field large enough to hold all the values of the enumeration type is max(M,1) if bmin is zero and M+1 otherwise.

The result of these calculations is that the number of bits required for

      enum { N = -1, Z = 0 }

is 1, but the number required for

      enum { N = -1 }

is 2. This is surprising. This could be fixed by changing |emax| to emax.

#### 1638. Declaring an explicit specialization of a scoped enumeration

Section: 7.2 [dcl.enum] Status: drafting Submitter: Richard Smith Date: 2013-03-12

There is no syntax currently for declaring an explicit specialization of a member scoped enumeration. A declaration (not a definition) of such an explicit specialization most resembles an opaque-enum-declaration, but the grammar for that requires that the name be a simple identifier, which will not be the case for an explicit specialization of a member enumeration. This could be remedied by adding a nested-name-specifier to the grammar with a restriction that a nested-name-specifier only appear in an explicit specialization.

#### 138. Friend declaration name lookup

Section: 7.3.1.2 [namespace.memdef] Status: drafting Submitter: Martin von Loewis Date: 14 Jul 1999

7.3.1.2 [namespace.memdef] paragraph 3 says,

> If a `friend` declaration in a non-local class first declares a class or function the friend class or function is a member of the innermost enclosing namespace... When looking for a prior declaration of a class or a function declared as a `friend`, scopes outside the innermost enclosing namespace scope are not considered.

It is not clear from this passage how to determine whether an entity is "first declared" in a `friend` declaration. One question is whether a using-declaration influences this determination. For instance:

        void foo();
        namespace A{
          using ::foo;
          class X{
    	friend void foo();
          };
        }

Is the `friend` declaration a reference to `::foo` or a different `foo`?

Part of the question involves determining the meaning of the word "synonym" in 7.3.3 [namespace.udecl] paragraph 1:

> A using-declaration introduces a name into the declarative region in which the using-declaration appears. That name is a synonym for the name of some entity declared elsewhere.

Is "`using ::foo;`" the declaration of a function or not?

More generally, the question is how to describe the lookup of the name in a `friend` declaration.

John Spicer: When a declaration specifies an unqualified name, that name is declared, not looked up. There is a mechanism in which that declaration is linked to a prior declaration, but that mechanism is not, in my opinion, via normal name lookup. So, the friend always declares a member of the nearest namespace scope regardless of how that name may or may not already be declared there.

Mike Miller: 3.4.1 [basic.lookup.unqual] paragraph 7 says:

> A name used in the definition of a class `X` outside of a member function body or nested class definition shall be declared in one of the following ways:... [Note: when looking for a prior declaration of a class or function introduced by a `friend` declaration, scopes outside of the innermost enclosing namespace scope are not considered.]

The presence of this note certainly implies that this paragraph describes the lookup of names in `friend` declarations.

John Spicer: It most certainly does not. If that section described the friend lookup it would yield the incorrect results for the friend declarations of `f` and `g` below. I don't know why that note is there, but it can't be taken to mean that that is how the friend lookup is done.

        void f(){}
        void g(){}
        class B {
            void g();
        };
        class A : public B {
            void f();
            friend void f(); // ::f not A::f
            friend void g(); // ::g not B::g
        };

Mike Miller: If so, the lookups for friend functions and classes behave differently. Consider the example in 3.4.4 [basic.lookup.elab] paragraph 3:

        struct Base {
            struct Data;         // OK: declares nested Data
            friend class Data;   // OK: nested Data is a friend
        };

If the `friend` declaration is not a reference to `::foo`, there is a related but separate question: does the `friend` declaration introduce a conflicting (albeit "invisible") declaration into namespace `A`, or is it simply a reference to an as-yet undeclared (and, in this instance, undeclarable) `A::foo`? Another part of the example in 3.4.4 [basic.lookup.elab] paragraph 3 is related:

        struct Data {
            friend struct Glob;  // OK: Refers to (as yet) undeclared Glob
                                 // at global scope.
        };

John Spicer: You can't refer to something that has not yet been declared. The friend is a declaration of `Glob`, it just happens to declare it in a such a way that its name cannot be used until it is redeclared.

(A somewhat similar question has been raised in connection with issue 36. Consider:

        namespace N {
            struct S { };
        }
        using N::S;
        struct S;          // legal?

According to 9.1 [class.name] paragraph 2,

> A declaration consisting solely of class-key identifier ; is either a redeclaration of the name in the current scope or a forward declaration of the identifier as a class name.

Should the elaborated type declaration in this example be considered a redeclaration of `N::S` or an invalid forward declaration of a different class?)

(See also issues 95, 136, 139, 143, 165, and 166, as well as paper J16/00-0006 = WG21 N1229.)

#### 386. Friend declaration of name brought in by using-declaration

Section: 7.3.3 [namespace.udecl] Status: drafting Submitter: Herb Sutter Date: 8 Oct 2002

The following came up recently on comp.lang.c++.moderated (edited for brevity):

      namespace N1 {
        template<typename T> void f( T* x ) {
          // ... other stuff ...
          delete x;
        }
      }

      namespace N2 {
        using N1::f;

        template<> void f<int>( int* ); // A: ill-formed

        class Test {
          ~Test() { }
          friend void f<>( Test* x );   // B: ill-formed?
        };
      }

I strongly suspect, but don't have standardese to prove, that the friend declaration in line B is ill-formed. Can someone show me the text that allows or disallows line B?

Here's my reasoning: Writing "using" to pull the name into namespace N2 merely allows code in N2 to use the name in a call without qualification (per 7.3.3 [namespace.udecl]). But just as declaring a specialization must be done in the namespace where the template really lives (hence line A is ill-formed), I suspect that declaring a specialization as a friend must likewise be done using the original namespace name, not obliquely through a "using". I see nothing in 7.3.3 [namespace.udecl] that would permit this use. Is there?

Andrey Tarasevich: 14.5.4 [temp.friend] paragraph 2 seems to get pretty close: "A friend declaration that is not a template declaration and in which the name of the friend is an unqualified 'template-id' shall refer to a specialization of a function template declared in the nearest enclosing namespace scope".

Herb Sutter: OK, thanks. Then the question in this is the word "declared" -- in particular, we already know we cannot declare a specialization of a template in any other namespace but the original one.

John Spicer: This seems like a simple question, but it isn't.

First of all, I don't think the standard comments on this usage one way or the other.

A similar example using a namespace qualified name is ill-formed based on 8.3 [dcl.meaning] paragraph 1:

      namespace N1 {
            void f();
      }

      namespace N2 {
            using N1::f;
            class A {
                    friend void N2::f();
            };
      }

Core issue 138 deals with this example:

      void foo();
      namespace A{
        using ::foo;
        class X{
          friend void foo();
        };
      }

The proposed resolution (not yet approved) for issue 138 is that the friend declares a new foo that conflicts with the using-declaration and results in an error.

Your example is different than this though because the presence of the explicit argument list means that this is not declaring a new f but is instead using a previously declared f.

One reservation I have about allowing the example is the desire to have consistent rules for all of the "declaration like" uses of template functions. Issue 275 (in DR status) addresses the issue of unqualified names in explicit instantiation and explicit specialization declarations. It requires that such declarations refer to templates from the namespace containing the explicit instantiation or explicit specialization. I believe this rule is necessary for those directives but is not really required for friend declarations -- but there is the consistency issue.

Notes from April 2003 meeting:

This is related to issue 138. John Spicer is supposed to update his paper on this topic. This is a new case not covered in that paper. We agreed that the B line should be allowed.

#### 1708. overly-strict requirements for names with C language linkage

Section: 7.5 [dcl.link] Status: drafting Submitter: Richard Smith Date: 2013-06-29

According to 7.5 [dcl.link] paragraph 6,

> An entity with C language linkage shall not be declared with the same name as an entity in global scope, unless both declarations denote the same entity; no diagnostic is required if the declarations appear in different translation units.

This restriction is too broad; it does not allow for the so-called `stat` hack, where a C-linkage function and a class are both declared in global scope, and it does not allow for function overloading, either. It should be revised to apply only to variables.

#### 1689. Syntactic nonterminal for operand of `alignas`

Section: 7.6.1 [dcl.attr.grammar] Status: drafting Submitter: Richard Smith Date: 2013-05-26

Issue 1323 dealt with correcting the specification of the operand of `alignas`, which was originally given as the nonexistent term alignment-expression. It was corrected editorially to match the use of assignment-expression in 7.6.2 [dcl.align]

In 7.6.2 [dcl.align] paragraph 2, the expression is semantically constrained to be an integral constant expression. Since a constant-expression is syntactically a conditional-expression rather than an assignment-expression, it would probably make sense to change the syntactic nonterminal for the operand of `alignas` to be either a constant-expression or a conditional-expression.

#### 1342. Order of initialization with multiple declarators

Section: 8 [dcl.decl] Status: drafting Submitter: Alberto Ganesh Barbati Date: 2011-08-11

It is not clear what, if anything, in the existing specification requires that the initialization of multiple init-declarators within a single declaration be performed in declaration order.

#### 1488. abstract-pack-declarators in type-ids

Section: 8.1 [dcl.name] Status: drafting Submitter: Richard Smith Date: 2012-03-28

The grammar for type-id in 9.1 [class.name] paragraph 1 has two problems. First, the fact that we allow an abstract-pack-declarator makes some uses of type-id (template arguments, alignment specifiers, exception-specifications) ambiguous: `T...` could be parsed either as a type-id, including the ellipsis, or as the type-id `T` with a following ellipsis. There does not appear to be any rule to disambiguate these parses.

The other problem is that we do not allow parentheses in an abstract-pack-declarator, which makes

      template<typename...Ts> void f(Ts (&...)[4]);

ill-formed because `(&...)()` is not an abstract-pack-declarator. There is implementation variance on this point.

#### 453. References may only bind to “valid” objects

Section: 8.3.2 [dcl.ref] Status: drafting Submitter: Gennaro Prota Date: 18 Jan 2004

8.3.2 [dcl.ref] paragraph 4 says:

> A reference shall be initialized to refer to a valid object or function. [Note: in particular, a null reference cannot exist in a well-defined program, because the only way to create such a reference would be to bind it to the "object" obtained by dereferencing a null pointer, which causes undefined behavior ...]

What is a "valid" object? In particular the expression "valid object" seems to exclude uninitialized objects, but the response to Core Issue 363 clearly says that's not the intent. This is an example (overloading construction on constness of *this) by John Potter, which I think is supposed to be legal C++ though it binds references to objects that are not initialized yet:

     struct Fun {
        int x, y;
        Fun (int x, Fun const&) : x(x), y(42) { }
        Fun (int x, Fun&) : x(x), y(0) { }
      };
      int main () {
        const Fun f1 (13, f1);
        Fun f2 (13, f2);
        cout << f1.y << " " << f2.y << "\n";
      }

Suggested resolution: Changing the final part of 8.3.2 [dcl.ref] paragraph 4 to:

> A reference shall be initialized to refer to an object or function. From its point of declaration on (see 3.3.2 [basic.scope.pdecl]) its name is an lvalue which refers to that object or function. The reference may be initialized to refer to an uninitialized object but, in that case, it is usable in limited ways (3.8 [basic.life], paragraph 6) [Note: On the other hand, a declaration like this:

>         int & ref = *(int*)0;

> is ill-formed because ref will not refer to any object or function ]

I also think a "No diagnostic is required." would better be added (what about something like int& r = r; ?)

Proposed Resolution (October, 2004):

(Note: the following wording depends on the proposed resolution for issue 232.)

Change 8.3.2 [dcl.ref] paragraph 4 as follows:

> A reference shall be initialized to refer to a valid object or function. If an lvalue to which a reference is directly bound designates neither an existing object or function of an appropriate type (8.5.3 [dcl.init.ref]), nor a region of memory of suitable size and alignment to contain an object of the reference's type (1.8 [intro.object], 3.8 [basic.life], 3.9 [basic.types]), the behavior is undefined. [Note: in particular, a null reference cannot exist in a well-defined program, because the only way to create such a reference would be to bind it to the “object” empty lvalue obtained by dereferencing a null pointer, which causes undefined behavior. As does not designate an object or function. Also, as described in 9.6 [class.bit], a reference cannot be bound directly to a bit-field. ]

> The name of a reference shall not be used in its own initializer. Any other use of a reference before it is initialized results in undefined behavior. [Example:

>       int& f(int&);
>       int& g();

>       extern int& ir3;
>       int* ip = 0;

>       int& ir1 = *ip;     // undefined behavior: null pointer
>       int& ir2 = f(ir3);  // undefined behavior: ir3 not yet initialized
>       int& ir3 = g();
>       int& ir4 = f(ir4);  // ill-formed: ir4 used in its own initializer

> —end example]

Rationale: The proposed wording goes beyond the specific concerns of the issue. It was noted that, while the current wording makes cases like `int& r = r;` ill-formed (because `r` in the initializer does not "refer to a valid object"), an inappropriate initialization can only be detected, if at all, at runtime and thus "undefined behavior" is a more appropriate treatment. Nevertheless, it was deemed desirable to continue to require a diagnostic for obvious compile-time cases.

It was also noted that the current Standard does not say anything about using a reference before it is initialized. It seemed reasonable to address both of these concerns in the same wording proposed to resolve this issue.

Notes from the April, 2005 meeting:

The CWG decided that whether to require an implementation to diagnose initialization of a reference to itself should be handled as a separate issue (504) and also suggested referring to “storage” instead of “memory” (because 1.8 [intro.object] defines an object as a “region of storage”).

Proposed Resolution (April, 2005):

(Note: the following wording depends on the proposed resolution for issue 232.)

Change 8.3.2 [dcl.ref] paragraph 4 as follows:

> A reference shall be initialized to refer to a valid object or function. If an lvalue to which a reference is directly bound designates neither an existing object or function of an appropriate type (8.5.3 [dcl.init.ref]), nor a region of storage of suitable size and alignment to contain an object of the reference's type (1.8 [intro.object], 3.8 [basic.life], 3.9 [basic.types]), the behavior is undefined. [Note: in particular, a null reference cannot exist in a well-defined program, because the only way to create such a reference would be to bind it to the “object” empty lvalue obtained by dereferencing a null pointer, which causes undefined behavior. As does not designate an object or function. Also, as described in 9.6 [class.bit], a reference cannot be bound directly to a bit-field. ]

> Any use of a reference before it is initialized results in undefined behavior. [Example:

>       int& f(int&);
>       int& g();

>       extern int& ir3;
>       int* ip = 0;

>       int& ir1 = *ip;     // undefined behavior: null pointer
>       int& ir2 = f(ir3);  // undefined behavior: ir3 not yet initialized
>       int& ir3 = g();
>       int& ir4 = f(ir4);  // undefined behavior: ir4 used in its own initializer

> —end example]

Note (February, 2006):

The word “use” in the last paragraph of the proposed resolution was intended to refer to the description in 3.2 [basic.def.odr] paragraph 2. However, that section does not define what it means for a reference to be “used,” dealing only with objects and functions. Additional drafting is required to extend 3.2 [basic.def.odr] paragraph 2 to apply to references.

Additional note (May, 2008):

The proposed resolution for issue 570 adds wording to define “use” for references.

Note, January, 2012:

The resolution should also probably deal with the fact that the “one-past-the-end” address of an array does not designate a valid object (even if such a pointer might “point to” an object of the correct type, per 3.9.2 [basic.compound]) and thus is not suuitable for the lvalue-to-rvalue conversion.

#### 1640. Array of abstract instance of class template

Section: 8.3.4 [dcl.array] Status: drafting Submitter: Richard Smith Date: 2013-03-14

According to 8.3.4 [dcl.array] paragraph 1, an array declarator whose element type is an abstract class is ill-formed. However, if the element type is a class template specialization, it may not be known that the class is abstract; because forming an array of an incomplete type is permitted (3.9 [basic.types] paragraphs 5-6), the class template is not required to be instantiated in order to use it as an element type. The expected handling if the class template is later instantiated is unclear; should the compiler issue an error about the earlier array array type at the point at which the class template is instantiated?

This also affects overload resolution:

      template<typename> struct Abstract {
        virtual void f() = 0;
        typedef int type;
      };
      template<typename T> char &abstract_test(T[1]);      // #1
      template<typename T> char (&abstract_test(...))[2];  // #2
      // Abstract<int>::type n;
      static_assert(sizeof(abstract_test<Abstract<int>>(nullptr)) == 2, "");

Overload resolution will select #1 and fail the assertion; if the commented line is uncommented, there is implementation variance, but presumably #2 should be selected and satisfy the assertion.

These effects of completing the type are troublesome. Would it be better to allow array types of abstract element type and simply prohibit creation of objects of such arrays?

(See also issue 1646.)

#### 1001. Parameter type adjustment in dependent parameter types

Section: 8.3.5 [dcl.fct] Status: drafting Submitter: Jason Merrill Date: 2009-11-08

According to 8.3.5 [dcl.fct] paragraph 5, top-level cv-qualifiers on parameter types are deleted when determining the function type. It is not clear how or whether this adjustment should be applied to parameters of function templates when the parameter has a dependent type, however. For example:

        template<class T> struct A {
           typedef T arr[3];
        };

        template<class T> void f(const typename A<T>::arr) { } // #1

        template void f<int>(const A<int>::arr);

        template <class T> struct B {
           void g(T);
        };

        template <class T> void B<T>::g(const T) { } // #2

If the `const` in #1 is dropped, `f<int>` has a parameter type of `A*` rather than the `const A*` specified in the explicit instantiation. If the `const` in #2 is not dropped, we fail to match the definition of `B::g` to its declaration.

Rationale (November, 2010):

The CWG agreed that this behavior is intrinsic to the different ways cv-qualification applies to array types and non-array types.

Notes, January, 2012:

Additional discussion of this issue arose regarding the following example:

        template<class T> struct A {
          typedef double Point[2];
          virtual double calculate(const Point point) const = 0;
        };

        template<class T> struct B : public A<T> {
          virtual double calculate(const typename A<T>::Point point) const {
            return point[0];
          }
        };

        int main() {
          B<int> b;
          return 0;
        }

The question is whether the member function in `B<int>` has the same type as that in `A<int>`: is the parameter-type-list instantiated directly (i.e., using the adjusted types) or regenerated from the individual parameter types?

(See also issue 1322.)

#### 1668. Parameter type determination still not clear enough

Section: 8.3.5 [dcl.fct] Status: drafting Submitter: Daniel Krügler Date: 2013-04-25

According to 8.3.5 [dcl.fct] paragraph 5,

> The type of a function is determined using the following rules. The type of each parameter (including function parameter packs) is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type “array of `T`” or “function returning `T`” is adjusted to be “pointer to `T`” or “pointer to function returning `T`,” respectively. After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type. The resulting list of transformed parameter types and the presence or absence of the ellipsis or a function parameter pack is the function's parameter-type-list. [Note: This transformation does not affect the types of the parameters. For example, `int(*)(const int p, decltype(p)*)` and `int(*)(int, const int*)` are identical types. —end note]

This is not sufficiently clear to specify the intended handling of an example like

      void f(int a[10], decltype(a) *p );

Should the type of `p` be `int(*)[10]` or `int**`? The latter is the intended result, but the phrase “after determining the type of each parameter” makes it sound as if the adjustments are performed after all the parameter types have been determined from the decl-specifier-seq and declarator instead of for each parameter individually.

#### 325. When are default arguments parsed?

Section: 8.3.6 [dcl.fct.default] Status: drafting Submitter: Nathan Sidwell Date: 27 Nov 2001

The standard is not precise enough about when the default arguments of member functions are parsed. This leads to confusion over whether certain constructs are legal or not, and the validity of certain compiler implementation algorithms.

8.3.6 [dcl.fct.default] paragraph 5 says "names in the expression are bound, and the semantic constraints are checked, at the point where the default argument expression appears"

However, further on at paragraph 9 in the same section there is an example, where the salient parts are

      int b;
      class X {
        int mem2 (int i = b); // OK use X::b
        static int b;
      };

which appears to contradict the former constraint. At the point the default argument expression appears in the definition of X, X::b has not been declared, so one would expect ::b to be bound. This of course appears to violate 3.3.7 [basic.scope.class] paragraph 1(2) "A name N used in a class S shall refer to the same declaration in its context and when reevaluated in the complete scope of S. No diagnostic is required."

Furthermore 3.3.7 [basic.scope.class] paragraph 1(1) gives the scope of names declared in class to "consist not only of the declarative region following the name's declarator, but also of .. default arguments ...". Thus implying that X::b is in scope in the default argument of X::mem2 previously.

That previous paragraph hints at an implementation technique of saving the token stream of a default argument expression and parsing it at the end of the class definition (much like the bodies of functions defined in the class). This is a technique employed by GCC and, from its behaviour, in the EDG front end. The standard leaves two things unspecified. Firstly, is a default argument expression permitted to call a static member function declared later in the class in such a way as to require evaluation of that function's default arguments? I.e. is the following well formed?

      class A {
        static int Foo (int i = Baz ());
        static int Baz (int i = Bar ());
        static int Bar (int i = 5);
     };

If that is well formed, at what point does the non-sensicalness of

      class B {
        static int Foo (int i = Baz ());
        static int Baz (int i = Foo());
      };

become detected? Is it when B is complete? Is it when B::Foo or B::Baz is called in such a way to require default argument expansion? Or is no diagnostic required?

The other problem is with collecting the tokens that form the default argument expression. Default arguments which contain template-ids with more than one parameter present a difficulty in determining when the default argument finishes. Consider,

      template <int A, typename B> struct T { static int i;};
      class C {
        int Foo (int i = T<1, int>::i);
      };

The default argument contains a non-parenthesized comma. Is it required that this comma is seen as part of the default argument expression and not the beginning of another of argument declaration? To accept this as part of the default argument would require name lookup of T (to determine that the '<' was part of a template argument list and not a less-than operator) before C is complete. Furthermore, the more pathological

      class D {
        int Foo (int i = T<1, int>::i);
        template <int A, typename B> struct T {static int i;};
      };

would be very hard to accept. Even though T is declared after Foo, T is in scope within Foo's default argument expression.

Suggested resolution:

Append the following text to 8.3.6 [dcl.fct.default] paragraph 8.

> The default argument expression of a member function declared in the class definition consists of the sequence of tokens up until the next non-parenthesized, non-bracketed comma or close parenthesis. Furthermore such default argument expressions shall not require evaluation of a default argument of a function declared later in the class.

This would make the above A, B, C and D ill formed and is in line with the existing compiler practice that I am aware of.

Notes from the October, 2005 meeting:

The CWG agreed that the first example (`A`) is currently well-formed and that it is not unreasonable to expect implementations to handle it by processing default arguments recursively.

Additional notes, May, 2009:

Presumably the following is ill-formed:

        int f(int = f());

However, it is not clear what in the Standard makes it so. Perhaps there needs to be a statement to the effect that a default argument only becomes usable after the complete declarator of which it is a part.

Notes from the August, 2011 meeting:

In addition to default arguments, commas in template argument lists also cause problems in initializers for nonstatic data members:

        struct S {
          int n = T<a,b>(c);  // ill-formed declarator for member b
                              // or template argument?
        };

(This is from #16 of the `IssuesFoundImplementingC0x.pdf` document on the Bloomington wiki.

Additional notes (August, 2011):

See also issues 1352 and 361.

Notes from the February, 2012 meeting:

It was decided to handle the question of parsing an initializer like `T<a,b>(c)` (a template-id or two declarators) in this issue and the remaining questions in issue 361. For this issue, a template-id will only be recognized if there is a preceding declaration of a template.

#### 1580. Default arguments in explicit instantiations

Section: 8.3.6 [dcl.fct.default] Status: drafting Submitter: Daveed Vandevoorde Date: 2012-10-29

It is not clear, either from 8.3.6 [dcl.fct.default] or 14.7.2 [temp.explicit], whether it is permitted to add a default argument in an explicit instantiation of a function template:

      template<typename T> void f(T, int) { }
      template void f<int>(int, int=0);  // Permitted?

Notes from the April, 2013 meeting:

The intent is to prohibit default arguments in explicit instantiations.

#### 1716. When are default arguments evaluated?

Section: 8.3.6 [dcl.fct.default] Status: drafting Submitter: David Krauss Date: 2013-07-17

According to 8.3.6 [dcl.fct.default] paragraph 9,

> Default arguments are evaluated each time the function is called.

Obviously, what was intended by this is that the default argument is evaluated only if no corresponding actual argument is provided, but this could be read as indicating that the default argument is evaluated and discarded by every function call.

#### 1552. exception-specifications and defaulted special member functions

Section: 8.4.2 [dcl.fct.def.default] Status: drafting Submitter: Daveed Vandevoorde Date: 2012-09-07

The current wording of 8.4.2 [dcl.fct.def.default] paragraph 2 has some surprising implications:

> An explicitly-defaulted function may be declared `constexpr` only if it would have been implicitly declared as `constexpr`, and may have an explicit exception-specification only if it is compatible (15.4 [except.spec]) with the exception-specification on the implicit declaration.

In an example like

      struct A {
        A& operator=(A&);
      };
      A& A::operator=(A&) = default;

presumably the exception-specification of `A::operator=(A&)` is `noexcept(false)`. However, attempting to make that exception-specification explicit,

      A& A::operator=(A&) noexcept(false) = default;

is an error. Is this intentional?

Proposed resolution (October, 2012):

Change 15.4 [except.spec] paragraph 4 as follows:

> ...If any declaration of a pointer to function, reference to function, or pointer to member function has an exception-specification, all occurrences of that declaration shall have a compatible exception-specification. If a declaration of a function has an implicit exception-specification, other declarations of the function shall not specify an exception-specification. In an explicit instantiation...

(This resolution also resolves issue 1492.)

Additional note (January, 2013):

The resolution conflicts with the current specification of `operator delete`: in 3.7.4 [basic.stc.dynamic] paragraph 2, the two `operator delete` overloads are declared with an implicit exception specification, while in 18.6 [support.dynamic] paragraph 1, they are declared as `noexcept`.

#### 1733. Return type and value for `operator=` with ref-qualifier

Section: 8.4.2 [dcl.fct.def.default] Status: drafting Submitter: James Widman Date: 2013-08-09

8.4.2 [dcl.fct.def.default] paragraph 1 specifies that an explicitly-defaulted function shall

> have the same declared function type (except for possibly differing ref-qualifiers and except that in the case of a copy constructor or copy assignment operator, the parameter type may be “reference to non-const `T`”, where `T` is the name of the member function's class) as if it had been implicitly declared...

This allows an example like

      struct A {
        A& operator=(A const&) && = default;
      };

but forbids

      struct B {
        B&& operator=(B const&) && = default;
      };

which seems backward.

In addition, 12.8 [class.copy] paragraph 22 only specifies the return value for implicitly-declared copy/move assignment operators, not for explicitly-defaulted ones.

#### 253. Why must empty or fully-initialized const objects be initialized?

Section: 8.5 [dcl.init] Status: drafting Submitter: Mike Miller Date: 11 Jul 2000

Paragraph 9 of 8.5 [dcl.init] says:

> If no initializer is specified for an object, and the object is of (possibly cv-qualified) non-POD class type (or array thereof), the object shall be default-initialized; if the object is of const-qualified type, the underlying class type shall have a user-declared default constructor. Otherwise, if no initializer is specified for an object, the object and its subobjects, if any, have an indeterminate initial value; if the object or any of its subobjects are of const-qualified type, the program is ill-formed.

What if a const POD object has no non-static data members? This wording requires an empty initializer for such cases:

        struct Z {
            // no data members
            operator int() const { return 0; }
        };

        void f() {
            const Z z1;         // ill-formed: no initializer
            const Z z2 = { };   // well-formed
        }

Similar comments apply to a non-POD const object, all of whose non-static data members and base class subobjects have default constructors. Why should the class of such an object be required to have a user-declared default constructor?

(See also issue 78.)

Additional note (February, 2011):

This issue should be brought up again in light of constexpr constructors and non-static data member initializers.

Notes from the August, 2011 meeting:

If the implicit default constructor initializes all subobjects, no initializer should be required.

#### 1630. Multiple default constructor templates

Section: 8.5 [dcl.init] Status: drafting Submitter: Nikolay Ivchenkov Date: 2013-03-01

It is unclear whether code like the following is supposed to be supported or not:

      #include <iostream>
      #include <type_traits>

      #define ENABLE_IF(...) \
        typename std::enable_if<__VA_ARGS__, int>::type = 0
      #define PRINT_VALUE(...) \
        std::cout << #__VA_ARGS__ " = " << __VA_ARGS__ << std::endl

      struct undefined {};

      template <class T>
        undefined special_default_value(T *);

      template <class T>
        struct has_special_default_value :
          std::integral_constant
          <
            bool,
            !std::is_same
              <
                decltype(special_default_value((T *)0)),
                undefined
              >{}
          > {};

      template <class T> struct X {
        template <class U = T, ENABLE_IF(!has_special_default_value<U>{})>
          X() : value() {}
        template <class U = T, ENABLE_IF(has_special_default_value<U>{})>
          X() : value(special_default_value((T *)0)) {}
        T value;
      };

      enum E {
        e1 = 1,
        e2 = 2
      };

      E special_default_value(E *) { return e1; }

      int main() {
        X<int> x_int;
        X<E> x_E;
        PRINT_VALUE(x_int.value);
        PRINT_VALUE(x_E.value);

        PRINT_VALUE(X<int>().value);
        PRINT_VALUE(X<E>().value);
      }

The intent is that `X<int>` should call the first default constructor and `X<E>` should call the second.

If this is intended to work, the rules for making it do so are not clear; current wording reads as if a class can have only a single default constructor, and there appears to be no mechanism for using overload resolution to choose between variants.

#### 1622. Empty aggregate initializer for union

Section: 8.5.1 [dcl.init.aggr] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-02-14

According to 8.5.1 [dcl.init.aggr] paragraph 15,

> When a union is initialized with a brace-enclosed initializer, the braces shall only contain an initializer-clause for the first non-static data member of the union.

This would appear to preclude using `{}` as the initializer for a union, which would otherwise have reasonable semantics. Is there a reason for this restriction?

Also, paragraph 7 reads,

> If there are fewer initializer-clauses in the list than there are members in the aggregate, then each member not explicitly initialized shall be initialized from an empty initializer list (8.5.4 [dcl.init.list]).

There should presumably be special treatment for unions, so that only a single member is initialized in such cases.

(See also issue 1460.)

#### 1304. Omitted array bound with string initialization

Section: 8.5.2 [dcl.init.string] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-04-26

The example in 8.5.2 [dcl.init.string] paragraph 1 says,

>       char msg[] = "Syntax error on line %s\n";

> shows a character array whose members are initialized with a string-literal. Note that because `'\n'` is a single character and because a trailing `'\0'` is appended, `sizeof(msg)` is `25`.

However, there appears to be no normative specification of how the size of the array is to be calculated.

#### 1414. Binding an rvalue reference to a reference-unrelated lvalue

Section: 8.5.3 [dcl.init.ref] Status: drafting Submitter: Mike Miller Date: 2011-11-09

Currently an attempt to bind an rvalue reference to a reference-unrelated lvalue succeeds, binding the reference to a temporary initialized from the lvalue by copy-initialization. This appears to be intentional, as the accompanying example contains the lines

        int i3 = 2;
        double&& rrd3 = i3;  // rrd3 refers to temporary with value 2.0

This violates the expectations of some who expect that rvalue references can be initialized only with rvalues. On the other hand, it is parallel with the handling of an lvalue reference-to-const (and is handled by the same wording). It also can add efficiency without requiring existing code to be rewritten: the implicitly-created temporary can be moved from, just as if the call had been rewritten to create a prvalue temporary from the lvalue explicitly.

On a related note, assuming the binding is permitted, the intent of the overload tiebreaker found in 13.3.3.2 [over.ics.rank] paragraph 3 is not clear:

- Standard conversion sequence `S1` is a better conversion sequence than standard conversion sequence `S2` if

- ...

- `S1` and `S2` are reference bindings (8.5.3 [dcl.init.ref]) and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier, and `S1` binds an rvalue reference to an rvalue and `S2` binds an lvalue reference.

At question is what “to an rvalue” means here. If it is referring to the value category of the initializer itself, before conversions, then the supposed performance advantage of the binding under discussion does not occur because the competing rvalue and lvalue reference overloads will be ambiguous:

        void f(int&&);    // #1
        void f(const int&);
        void g(double d) {
            f(d);         // ambiguous: #1 does not bind to an rvalue
        }

On the other hand, if “to an rvalue” refers to the actual object to which the reference is bound, i.e., to the temporary in the case under discussion, the phrase would seem to be vacuous because an rvalue reference can never bind directly to an lvalue.

Notes from the February, 2012 meeting:

CWG agreed that the binding rules are correct, allowing creation of a temporary when binding an rvalue reference to a non-reference-related lvalue. The phrase “to an rvalue” in 13.3.3.2 [over.ics.rank] paragraph 3 is a leftover from before binding an rvalue reference to an lvalue was prohibited and should be removed. A change is also needed to handle the following case:

        void f(const char (&)[1]);         // #1
        template<typename T> void f(T&&);  // #2
        void g() {
          f("");                           //calls #2, should call #1
        }

Additional note (October, 2012):

Removing “to an rvalue,” as suggested, would have the effect of negating the preference for binding a function lvalue to an lvalue reference instead of an rvalue reference because the case would now fall under the preceding bullet of 13.3.3.2 [over.ics.rank] paragraph 3 bullet 1, sub-bullets 4 and 5:

> Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:

> - Standard conversion sequence `S1` is a better conversion sequence than standard conversion sequence `S2` if

> - ...

> - `S1` and `S2` are reference bindings (8.5.3 [dcl.init.ref]) and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier, and `S1` binds an rvalue reference to an rvalue and `S2` binds an lvalue reference... or, if not that,

> - `S1` and `S2` are reference bindings (8.5.3 [dcl.init.ref]) and `S1` binds an lvalue reference to a function lvalue and `S2` binds an rvalue reference to a function lvalue.

Presumably if the suggested resolution is adopted, the order of these two bullets should be inverted.

#### 1571. cv-qualification for indirect reference binding via conversion function

Section: 8.5.3 [dcl.init.ref] Status: drafting Submitter: Michael Wong Date: 2012-02-06

In the case of indirect reference binding, 8.5.3 [dcl.init.ref] paragraph 5 only requires that the cv-qualification of the referred-to type be the same or greater than that of the initializer expression when the types are reference-related. This leads to the following anomaly:

      class A {
      public:
        operator volatile int &();
      };
      A a;

      const int & ir1a = a.operator volatile int&(); // error!
      const int & ir2a = a; // allowed! ir = a.operator volatile int&();

Is this intended?

Notes from the April, 2013 meeting:

CWG felt that the declaration of `ir2a` should also be an error.

#### 1572. Incorrect example for rvalue reference binding via conversion function

Section: 8.5.3 [dcl.init.ref] Status: drafting Submitter: Michael Wong Date: 2012-10-15

The example just before the final bullet of 8.5.4 [dcl.init.list] paragraph 5 is incorrect. It reads, in part,

      struct X {
        operator int&();
      } x;
      int&& rri2 = X(); // error: lvalue-to-rvalue conversion applied to the
                        // result of operator int&

In fact, according to 13.3.1.6 [over.match.ref] (as clarified by the proposed resolution of issue 1328, although the intent was arguably the same for the previous wording), `X::operator int&()` is not a candidate for the initialization of `rri2`, so the case falls into the last bullet, creating an `int` temporary.

It is not clear whether the lvalue-to-rvalue conversion whose prohibition is intended to be illustrated by that example could actually occur, given the specification of candidate functions in 13.3.1.6 [over.match.ref].

#### 1467. List-initialization of aggregate from same-type object

Section: 8.5.4 [dcl.init.list] Status: drafting Submitter: Jason Merrill Date: 2012-02-06

The current list-initialization rules do not provide for list-initialization of an aggregate from an object of the same type:

      struct X {
        X() = default;
        X(const X&) = default;
      #ifdef OK
        X(int) { }
      #endif
      };

      X x;
      X x2{x}; // error, {x} is not a valid aggregate initializer for X

Suggested resolution:

Change 8.5.4 [dcl.init.list] paragraph 3 as follows:

> List-initialization of an object or reference of type `T` is defined as follows:

> - If `T` is a class type and the initializer list has a single element of type cv `T` or a class type derived from `T`, the object is initialized from that element.

> - If Otherwise, if T is an aggregate...

Additional notes (September, 2012):

(See messages 22368, 22371 through 22373, 22388, and 22494.)

It appears that 13.3.3.1.5 [over.ics.list] will also need to be updated in parallel with this change. Alternatively, it may be better to change 8.5.1 [dcl.init.aggr] instead of 8.5.4 [dcl.init.list] and 13.3.3.1.5 [over.ics.list].

In a related note, given

      struct NonAggregate {
        NonAggregate() {}
      };

      struct WantsIt {
        WantsIt(NonAggregate);
      };

      void f(NonAggregate n);
      void f(WantsIt);

      int main() {
        NonAggregate n;
        // ambiguous!
        f({n});
      }

13.3.3.1.5 [over.ics.list] paragraph 3 says that the call to `f(NonAggregate)` is a user-defined conversion, the same as the call to `f(WantsIt)` and thus ambiguous. Also,

        NonAggregate n;
        // #1 (n -> NonAggregate = Identity conversion)
        NonAggregate m{n};
        // #2 ({n} -> NonAggregate = User-defined conversion}
        // (copy-ctor not considered according to 13.3.3.1 [over.best.ics] paragraph 4)
        NonAggregate m{{n}};

Finally, the suggested resolution simply says “initialized from,” without specifying whether that means direct initialization or copy initialization. It should be explicit about which is intended, e.g., if it reflects the kind of list-initialization being done.

#### 1490. List-initialization from a string literal

Section: 8.5.4 [dcl.init.list] Status: drafting Submitter: Daveed Vandevoorde Date: 2012-03-29

Initialization of an array of characters from a string literal is handled by the third bullet of 8.5 [dcl.init] paragraph 16, branching off to 8.5.2 [dcl.init.string]. However, list initialization is handled by the first bullet, branching off to 8.5.4 [dcl.init.list], and there is no corresponding special case in 8.5.4 [dcl.init.list] paragraph 3 for an array of characters initialized by a brace-enclosed string literal. That is, an initialization like

      char s[4]{"abc"};

is ill-formed, which could be surprising. Similarly,

      std::initializer_list<char>{"abc"};

is plausible but also not permitted.

Notes from the October, 2012 meeting:

CWG agreed that the first example should be permitted, but not the second.

#### 1518. Explicit default constructors and copy-list-initialization

Section: 8.5.4 [dcl.init.list] Status: drafting Submitter: Richard Smith Date: 2012-07-08

Consider the following example:

      struct A {
       explicit A() = default;
      };

      struct B : A {
       explicit B() = default;
      };

      struct C {
       explicit C();
      };

      struct D : A {
       C c;
       explicit D() = default;
      };

      template<typename T> void f() {
       T t = {};
      }
      template<typename T> void g() {
       void x(T t);
       x({});
      }

The question is whether `f<B>`, f`<C>`, `f<D>`, `g<B>`, `g<C>`, and `g<D>` are well-formed or ill-formed.

The crux here is whether 13.3.1.7 [over.match.list] is the governing law in each of these cases. If it is, the initialization is ill-formed, because copy-list-initialization has selected an explicit constructor. The standard seems clear that `f<A>` and `g<A>` are valid (because `A` is an aggregate, so 13.3.1.7 [over.match.list] is not reached nor applicable), `f<B>` is valid (because value-initialization does not call the default constructor, so 13.3.1.7 [over.match.list] is not reached), and that `g<B>`, `g<C>`, and `g<D>` are ill-formed (because 13.3.1.7 [over.match.list] is reached from 13.3.3.1.5 [over.ics.list] and selects an explicit constructor). The difference between `f<B>` and `g<B>` is troubling.

For `f<C>` and `f<D>`, it's not clear whether the default constructor call within value-initialization within list-initialization uses 13.3.1.7 [over.match.list] — but some form of overload resolution seems to be implied, since presumably we want to apply SFINAE to variadic constructor templates, diagnose classes which have multiple default constructors through the addition of default arguments, and the like.

It has been suggested that perhaps we are supposed to reach 13.3.1.7 [over.match.list] for an empty initializer list for a non-aggregate class with a default constructor only when we're coming from 13.3.3.1.5 [over.ics.list], and not when 8.5.4 [dcl.init.list] delegates to value-initialization. That would make all the `f`s valid, but `g<B>`, `g<C>`, and `g<D>` ill-formed.

12.3.1 [class.conv.ctor] paragraph 2 says explicit constructors are only used for direct-initialization or casts, which argues for at least `f<C>`, `f<D>`, `g<C>` and `g<D>` being ill-formed.

#### 1565. Copy elision and lifetime of `initializer_list` underlying array

Section: 8.5.4 [dcl.init.list] Status: drafting Submitter: Steve Adamczyk Date: 2012-10-10

If an `initializer_list` object is copied and the copy is elided, is the lifetime of the underlying array object extended? E.g.,

      void f() {
        std::initializer_list<int> L =
            std::initializer_list<int>{1, 2, 3}; // Lifetime of array extended?
      }

The current wording is not clear.

Notes from the October, 2012 meeting:

The consensus of CWG was that the behavior should be the same, regardless of whether the copy is elided or not.

#### 1496. Triviality with deleted and missing default constructors

Section: 9.1 [class.name] Status: drafting Submitter: Daniel Krügler Date: 2012-04-25

A default constructor that is defined as deleted is trivial, according to 12.1 [class.ctor] paragraph 5. This means that, according to 9 [class] paragraph 6, such a class can be trivial. If, however, the class has no default constructor because it has a user-declared constructor, the class is not trivial. Since both cases prevent default construction of the class, it is not clear why there is a difference in triviality between the cases.

Notes from the October, 2012 meeting:

It was observed that this issue was related to issue 1344, as the current specification allows adding a default constructor by adding default arguments to the definition of a constructor. The resolution of that issue should also resolve this one.

Notes from the September, 2013 meeting:

It was decided to resolve issue 1344 separately from this issue, so this issue now requires its own resolution.

#### 1341. Bit-field initializers

Section: 9.2 [class.mem] Status: drafting Submitter: James Widman Date: 2011-08-10

The grammar for member-declarator (9.2 [class.mem]) does not, but should, allow for a brace-or-equal-initializer on a bit-field declarator.

#### 1397. Class completeness in non-static data member initializers

Section: 9.2 [class.mem] Status: drafting Submitter: Jason Merrill Date: 2011-09-23

In Bloomington there was general agreement that given a class that uses non-static data member initializers, the exception-specification for the default constructor depends on whether those initializers are noexcept. However, according to 9.2 [class.mem] paragraph 2, the class is regarded as complete within the brace-or-equal-initializers for non-static data members.

This suggests that we need to finish processing the class before parsing the NSDMI, but our direction on issue 1351 suggests that we need to parse the NSDMI in order to finish processing the class. Can't have both...

Additional note (March, 2013):

A specific example:

      struct A {
        void *p = A{};
        operator void*() const { return nullptr; }
      };

Perhaps the best way of addressing this would be to make it ill-formed for a non-static data member initializer to use a defaulted constructor of its class.

See also issue 1360.

Notes from the September, 2013 meeting:

One approach that might be considered would be to parse deferred portions lazily, on demand, and then issue an error if this results in a cycle.

#### 1672. Layout compatibility with multiple empty bases

Section: 9.2 [class.mem] Status: drafting Submitter: Richard Smith Date: 2013-04-27

The layout compatibility rules of 9.2 [class.mem] paragraph 16 are phrased only in terms of non-static data members, ignoring the existence of base classes:

> Two standard-layout struct (Clause 9 [class]) types are layout-compatible if they have the same number of non-static data members and corresponding non-static data members (in declaration order) have layout-compatible types (3.9 [basic.types]).

However, this means that in an example like

      struct empty {};
      struct A { char a; };
      struct also_empty : empty {};
      struct C : empty, also_empty { char c; };
      union U {
        struct X { A a1, a2; } x;
        struct Y { C c1, c2; } y;
      } u;

`u.x.a2.a` and `u.y.c2.c` must have the same address, even though `sizeof(A)` would typically be 1 and `sizeof(B)` would need to be at least 2 to give the `empty` subobjects different addresses.

#### 1693. Superfluous semicolons in class definitions

Section: 9.2 [class.mem] Status: drafting Submitter: Richard Smith Date: 2013-05-29

The grammar in 9.2 [class.mem] and 8.4.1 [dcl.fct.def.general] paragraph 1 are (in part):

member-declaration:

function-definition `;`opt

function-definition:

function-body

function-body:

`= default ;`
`= delete ;`

This leads to the following curiosity:

      struct A {
        void f1() = delete;   // #1, ok
        void f2() = delete;;  // #2, ok
        void f3() = delete;;; // #3, error, extraneous semicolon
      };

This could be addressed by moving the semicolon into the productions for function-body for the non-`default`/`delete` forms or by adding empty-declaration to the list of member-declaration productions, as is done with namespace-scope declarations.

#### 1283. Static data members of classes with typedef name for linkage purposes

Section: 9.4.2 [class.static.data] Status: drafting Submitter: Mike Miller Date: 2011-03-29

According to 9.4.2 [class.static.data] paragraph 4,

> Unnamed classes and classes contained directly or indirectly within unnamed classes shall not contain static data members.

There is no such restriction on member functions, and there is no rationale for this difference, given that both static data members and member functions can be defined outside a unnamed class with a typedef name for linkage purposes. (Issue 406 acknowledged the lack of rationale by removing the specious note in 9.4.2 [class.static.data] that attempted to explain the restriction but left the normative prohibition in place.)

It would be more consistent to remove the restriction for classes with a typedef name for linkage purposes.

Additional note (August, 2012):

It was observed that, since no definition of a `const` static data member is required if it is not odr-used, there is no reason to prohibit such members in an unnamed class even without a typedef name for linkage purposes.

#### 1721. Diagnosing ODR violations for static data members

Section: 9.4.2 [class.static.data] Status: drafting Submitter: Mike Miller Date: 2013-07-31

Describing the handling of static data members with brace-or-equal-initializers, 9.4.2 [class.static.data] paragraph 3 says,

> The member shall still be defined in a namespace scope if it is odr-used (3.2 [basic.def.odr]) in the program and the namespace scope definition shall not contain an initializer.

The word “shall” implies a required diagnostic, but this is describing an ODR violation (the static data member might be defined in a different translation unit) and thus should be “no diagnostic required.”

#### 1404. Object reallocation in unions

Section: 9.5 [class.union] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-10-19

According to 9.5 [class.union] paragraph 4,

> [Note: In general, one must use explicit destructor calls and placement new operators to change the active member of a union. —end note] [Example: Consider an object `u` of a union type `U` having non-static data members `m` of type `M` and `n` of type `N`. If `M` has a non-trivial destructor and `N` has a non-trivial constructor (for instance, if they declare or inherit virtual functions), the active member of `u` can be safely switched from `m` to `n` using the destructor and placement new operator as follows:

>       u.m.~M();
>       new (&u.n)  N;

> —end example]

This pattern is only “safe” if the original object that is being destroyed does not involve any const-qualified or reference types, i.e., satisfies the requirements of 3.8 [basic.life] paragraph 7, bullet 3:

- the type of the original object is not const-qualified, and, if a class type, does not contain any non-static data member whose type is const-qualified or a reference type

Although paragraph 4 of 9.5 [class.union] is a note and an example, it should at least refer to the lifetime issues described in 3.8 [basic.life].

Additional note (October, 2013):

See also issue 1776, which suggests possibly changing the restriction in 3.8 [basic.life]. If such a change is made, this issue may become moot.

#### 1702. Rephrasing the definition of “anonymous union”

Section: 9.5 [class.union] Status: drafting Submitter: Richard Smith Date: 2013-06-17

9.5 [class.union] paragraph 5 defines an anonymous union as follows:

> A union of the form

> `union {` member-specification `} ;`

> is called an anonymous union; it defines an unnamed object of unnamed type.

It is obviously intended that a declaration like

        static union { int i; float f; };

is a declaration of that form (cf paragraph 6, which requires the `static` keyword for anonymous unions declared in namespace scope). However, it would be clearer if the definition were recast in more descriptive terms, e.g.,

> An anonymous union is an unnamed class that is defined with the class-key `union` in a simple-declaration in which the init-declarator-list is omitted. Such a simple-declaration is treated as if it contained a single declarator declaring an unnamed variable of the union's type.

(Note that this definition would require some additional tweaking to apply to class member anonymous union declarations, since simple-declarations are not included as member-declarations.)

As a related point, it is not clear how the following examples are to be treated, and there is implementation variance on some:

       void f() { thread_local union { int a; }; }
       void g() { extern union { int b; }; }
       thread_local union { int c; }; // static is implied by thread_local
       static thread_local union { int d; };
       static const union { int e = 0; }; // is e const? Clang says yes, gcc says no
       static constexpr union { int f = 0; };

#### 1714. odr-use of `this` from a local class

Section: 9.8 [class.local] Status: drafting Submitter: David Krauss Date: 2013-07-10

According to 9.8 [class.local] paragraph 1,

> Declarations in a local class shall not odr-use (3.2 [basic.def.odr]) a variable with automatic storage duration from an enclosing scope.

This restriction should apply as well to the `this` pointer when the class is local to a non-static member function.

#### 1710. Missing `template` keyword in class-or-decltype

Section: 10 [class.derived] Status: drafting Submitter: Richard Smith Date: 2013-07-03

A class-or-decltype is used as a base-specifier and as a mem-initializer-id that names a base class. It is specified in 10 [class.derived] paragraph 1 as:

class-or-decltype:

nested-name-specifieropt class-name
decltype-specifier

Consequently, a declaration like

      template<typename T> struct D : T::template B<int>::template C<int> {};

is ill-formed, although most implementations accept it; some actually require the use of the `template` keyword, although the relevant wording in 14.2 [temp.names] paragraph 4 only requires it in a qualified-id, not in a class-or-decltype. It would probably be good to add a production like

nested-name-specifier `template` simple-template-id

to the definition of class-or-decltype and explicitly mention those contexts in 14.2 [temp.names] as not requiring use of the `template` keyword.

#### 952. Insufficient description of “naming class”

Section: 11.2 [class.access.base] Status: drafting Submitter: James Widman Date: 7 August, 2009

The access rules in 11.2 [class.access.base] do not appear to handle references in nested classes and outside of nonstatic member functions correctly. For example,

        struct A {
            typedef int I;    // public
        };
        struct B: private A { };
        struct C: B {
            void f() {
                I i1;         // error: access violation
            }
            I i2;             // OK
            struct D {
                I i3;         // OK
                void g() {
                    I i4;     // OK
                }
            };
        };

The reason for this discrepancy is that the naming class in the reference to `I` is different in these cases. According to 11.2 [class.access.base] paragraph 5,

> The access to a member is affected by the class in which the member is named. This naming class is the class in which the member name was looked up and found.

In the case of `i1`, the reference to `I` is subject to the transformation described in 9.3.1 [class.mfct.non-static] paragraph 3:

> Similarly during name lookup, when an unqualified-id (5.1 [expr.prim]) used in the definition of a member function for class `X` resolves to a `static` member, an enumerator or a nested type of class `X` or of a base class of `X`, the unqualified-id is transformed into a qualified-id (5.1 [expr.prim]) in which the nested-name-specifier names the class of the member function.

As a result, the reference to `I` in the declaration of `i1` is transformed to `C::I`, so that the naming class is `C`, and `I` is inacessible in `C`. In the remaining cases, however, the transformation does not apply. Thus, the naming class of `I` in these references is `A`, and `I` is publicly accessible in `A`.

Presumably either the definition of “naming class” must be changed or the transformation of unqualified-ids must be broadened to include all uses within the scope of a class and not just within nonstatic member functions (and following the declarator-id in the definition of a static member, per 9.4 [class.static] paragraph 4).

#### 1699. Does befriending a class befriend its friends?

Section: 11.3 [class.friend] Status: drafting Submitter: David Krauss Date: 2013-06-12

According to 11.3 [class.friend] paragraph 2,

> Declaring a class to be a friend implies that the names of private and protected members from the class granting friendship can be accessed in the base-specifiers and member declarations of the befriended class.

A `friend` declaraton is a member-declaration, but it is not clear how far the granting of friendship goes in a `friend` declaration. For example:

      class c {
        class n {};
        friend struct s;
      };

      struct s {
        friend class c::n;          // #1
        friend c::n g();            // #2
        friend void f() { c::n(); } // #3
      };

In particular, if a friend function is defined inside the class definition, as in #3, does its definition have access to the private and protected members of the befriending class? Implementations vary on this point.

#### 472. Casting across protected inheritance

Section: 11.4 [class.protected] Status: drafting Submitter: Mike Miller Date: 16 Jun 2004

Does the restriction in 11.4 [class.protected] apply to upcasts across protected inheritance, too? For instance,

        struct B {
            int i;
        };
        struct I: protected B { };
        struct D: I {
            void f(I* ip) {
                B* bp = ip;    // well-formed?
                bp->i = 5;     // aka "ip->i = 5;"
            }
        };

I think the rationale for the 11.4 [class.protected] restriction applies equally well here — you don't know whether `ip` points to a `D` object or not, so `D::f` can't be trusted to treat the protected `B` subobject consistently with the policies of its actual complete object type.

The current treatment of “accessible base class” in 11.2 [class.access.base] paragraph 4 clearly makes the conversion from `I*` to `B*` well-formed. I think that's wrong and needs to be fixed. The rationale for the accessibility of a base class is whether “an invented public member” of the base would be accessible at the point of reference, although we obscured that a bit in the reformulation; it seems to me that the invented member ought to be considered a non-static member for this purpose and thus subject to 11.4 [class.protected].

(See also issues 385 and 471.).

Notes from October 2004 meeting:

The CWG tentatively agreed that casting across protective inheritance should be subject to the additional restriction in 11.4 [class.protected].

Proposed resolution (April, 2011)

Change 11.2 [class.access.base] paragraph 4 as follows:

> A base class `B` of `N` is accessible at R, if

> - an invented public member of `B` would be a public member of `N`, or

> - R occurs in a member or friend of class `N`, and an invented public member of `B` would be a private or protected member of `N`, or

> - R occurs in a member or friend of a class `P` derived from `N`, and an invented public member of `B` would be a private or (but not a protected [Footnote: A protected invented member is disallowed here for the same reason the additional check of 11.4 [class.protected] is applied to member access: it would allow casting a pointer to a derived class to a protected base class that might be a subobject of an object of a class that is different from the class context in which the reference occurs. —end footnote]) member of `P`, or

> - there exists a class `S` such that `B` is a base class of `S` accessible at R and `S` is a base class of `N` accessible at R.

> [Example:

>         class B {
>         public:
>           int m;
>         };

>         class S: private B {
>           friend class N;
>         };
>         class N: private S {
>           void f() {
>             B* p = this;    // OK because class S satisfies the fourth condition
>                             // above: B is a base class of N accessible in f() because
>                             // B is an accessible base class of S and S is an accessible
>                             // base class of N.
>           }
>         };

>         class N2: protected B { };

>         class P2: public N2 {
>           void f2(N2* n2p) {
>             B* bp = n2p;    // error: invented member would be protected and naming
>                             // class N2 not the same as or derived from the referencing
>                             // class P2
>             n2p->m = 0;     // error (cf 11.4 [class.protected]) for the same reason
>           }
>         };

> —end example]

#### 1353. Array and variant members and deleted special member functions

Section: 12.1 [class.ctor] Status: drafting Submitter: Sean Hunt Date: 2011-08-16

The specification of when a defaulted special member function is to be defined as deleted sometimes overlooks variant and array members.

#### 1360. `constexpr` defaulted default constructors

Section: 12.1 [class.ctor] Status: drafting Submitter: Richard Smith Date: 2011-08-16

According to 12.1 [class.ctor] paragraph 6, a defaulted default constructor is `constexpr` if the corresponding user-written constructor would satisfy the `constexpr` requirements. However, the requirements apply to the definition of a constructor, and a defaulted constructor is defined only if it is odr-used, leaving it indeterminate at declaration time whether the defaulted constructor is `constexpr` or not.

(See also issue 1358.)

Additional notes (February, 2013):

As an example of this issue, consider:

      struct S {
        int i = sizeof(S);
      };

You can't determine the value of the initializer, and thus whether the initializer is a constant expression, until the class is complete, but you can't complete the class without declaring the default constructor, and whether that constructor is `constexpr` or not depends on whether the member initializer is a constant expression.

A similar issue arises with the following example:

      struct A {
        int x = 37;
        struct B { int x = 37; } b;
        B b2[2][3] = { { } };
      };

This introduces an order dependency that is not specified in the current text: determining whether the default constructor of `A` is `constexpr` requires first determining the characteristics of the initializer of `B::x` and whether `B::B()` is `constexpr` or not.

The problem is exacerbated with class templates, since the current direction of CWG is to instantiate member initializers only when they are needed (see issue 1396). For a specific example:

      struct S;
      template<class T> struct X {
        int i = T().i;
      };
      unsigned n = sizeof(X<S>); // Error?
      struct S { int i; };

This also affects determining whether a class template specialization is a literal type or not; presumably getting the right answer to that requires instantiating the class and all its nonstatic data member initializers.

See also issues 1397 and 1594.

Notes from the September, 2013 meeting:

This issue should be resolved together with issue 1397.

#### 1623. Deleted default union constructor and member initializers

Section: 12.1 [class.ctor] Status: drafting Submitter: Vinny Romano Date: 2013-02-15

According to 12.1 [class.ctor] paragraph 5,

> A defaulted default constructor for class `X` is defined as deleted if:

> - `X` is a union-like class that has a variant member with a non-trivial default constructor,

> - ...

> - `X` is a union and all of its variant members are of const-qualified type (or array thereof),

> - `X` is a non-union class and all members of any anonymous union member are of const-qualified type (or array thereof),

> - ...

Because the presence of a non-static data member initializer is the moral equivalent of a mem-initializer, these rules should probably be modified not to define the generated constructor as deleted when a union member has a non-static data member initializer. (Note the non-normative references in 9.5 [class.union] paragraphs 2-3 and 7.1.6.1 [dcl.type.cv] paragraph 2 that would also need to be updated if this restriction is changed.)

It would also be helpful to add a requirement to 9.5 [class.union] requiring either a non-static data member initializer or a user-provided constructor if all the members of the union have const-qualified types.

On a more general note, why is the default constructor defined as deleted just because a member has a non-trivial default constructor? The union itself doesn't know which member is the active one, and default construction won't initialize any members (assuming no brace-or-equal-initializer). It is up to the “owner” of the union to control the lifetime of the active member (if any), and requiring a user-provided constructor is forcing a design pattern that doesn't make sense. Along the same lines, why is the default destructor defined as deleted just because a member has a non-trivial destructor? I would agree with this restriction if it only applied when the union also has a user-provided constructor.

See also issues 1460, 1562, 1587, and 1621.

#### 1658. Deleted default constructor for abstract class via destructor

Section: 12.1 [class.ctor] Status: drafting Submitter: Richard Smith Date: 2013-08-26

While reviewing the resolution of issue 1611, it was noticed that the final bullet of 12.1 [class.ctor] paragraph 4 has a similar issue:

> ...A defaulted default constructor for class `X` is defined as deleted if:

> - ...

> - any direct or virtual base class or non-static data member has a type with a destructor that is deleted or inaccessible from the defaulted default constructor.

Presumably destructors for virtual bases of abstract classes should not be considered in making this determination.

A question was also raised regarding whether odr-use is correctly defined for destructors of virtual bases of abstract classes. 3.2 [basic.def.odr] paragraph 3 simply refers to 12.4 [class.dtor], where the relevant passage (paragraph 8) reads,

> After executing the body of the destructor and destroying any automatic objects allocated within the body, a destructor for class `X` calls the destructors for `X`'s direct non-variant non-static data members, the destructors for `X`'s direct base classes and, if `X` is the type of the most derived class (12.6.2 [class.base.init]), its destructor calls the destructors for `X`'s virtual base classes.

It could be argued, particularly in light of the reference to 12.6.2 [class.base.init], that this is clear enough that the destructor for an abstract class does not invoke destructors for its virtual bases, but a note to that effect might be helpful.

#### 1299. “Temporary objects” vs “temporary expressions”

Section: 12.2 [class.temporary] Status: drafting Submitter: Johannes Schaub Date: 2011-04-16

The Standard is insufficiently precise in dealing with temporaries. It is not always clear when the term “temporary” is referring to an expression whose result is a prvalue and when it is referring to a temporary object.

(See also issue 1568.)

#### 1651. Lifetime extension of temporary via reference to subobject

Section: 12.2 [class.temporary] Status: drafting Submitter: Richard Smith Date: 2013-04-15

The resolution of issues 616 and 1213, making the result of a member access or subscript expression applied to a prvalue an xvalue, means that binding a reference to such a subobject of a temporary does not extend the temporary's lifetime. 12.2 [class.temporary] should be revised to ensure that it does.

#### 1695. Lifetime extension via init-capture

Section: 12.2 [class.temporary] Status: drafting Submitter: Richard Smith Date: 2013-05-31

If an init-capture binds a const reference to a temporary, is the lifetime of the temporary extended to match that of the lambda? For example,

       struct S { ~S(); };
       const S f();
       auto &&lambda = [&x(f())] () -> auto& { return x; };
       auto &y = lambda(); // ok?

Notes from the September, 2013 meeting:

CWG agreed that there is no lifetime extension in this example.

#### 1697. Lifetime extension and copy elision

Section: 12.2 [class.temporary] Status: drafting Submitter: Richard Smith Date: 2013-06-01

In an example like,

      struct S { ~S(); };
      struct X { X(); X(const X&); };
      struct T { S &&s; X x; };
      void f();
      void g() { T t = T{ {}, {} }; f(); }

it appears that the current wording allows two ways of handling this:

1. The copy to `t` in `g` is not elided. `X(const X&)` is called, then `~S()` is called, then `f()` is called.

2. The copy to `t` in `g` is elided, so the temporary and `t` are the same object. Thus, the `S` object's lifetime is extended to the lifetime of the reference `t.s`, so first `f()` is called, then `~S()` is called (and `X(const X&)` is not called).

However, EDG and g++ produce a third behavior: they do not call `X(const X&)`, but they destroy the `S()` temporary at the end of its full-expression. The current wording does not appear to permit this behavior, but it seems preferable that lifetime extension does not depend on whether copy elision is done.

#### 1726. Declarator operators and conversion function

Section: 12.3.2 [class.conv.fct] Status: drafting Submitter: James Widman Date: 2013-08-02

Presumably the following example is intended to be ill-formed:

      struct A {
        (*operator int*());
      };
      A a;
      int *x = a; // Ok?

It is not clear, however, which rule is supposed to reject such a member-declaration.

#### 399. Destructor lookup redux

Section: 12.4 [class.dtor] Status: drafting Submitter: John Spicer Date: 17 Jan 2003

Mark Mitchell raised a number of issues related to the resolution of issue 244 and of destructor lookup in general.

Issue 244 says:

> ... in a qualified-id of the form:
> ::opt nested-name-specifieropt class-name :: ~ class-name
> the second class-name is looked up in the same scope as the first.

But if the reference is "`p->X::~X()`", the first class-name is looked up in two places (normal lookup and a lookup in the class of p). Does the new wording mean:

1. You look up the second class-name in the scope that you found the first one.
2. You look up the second class-name using the same kind of lookup that found the first one (normal vs. class).
3. If you did a dual lookup for the first you do a dual lookup for the second.

This is a test case that illustrates the issue:

      struct A {
        typedef A C;
      };

      typedef A B;

      void f(B* bp) {
        bp->B::~B();  // okay B found by normal lookup
        bp->C::~C();  // okay C found by class lookup
        bp->B::~C();  // B found by normal lookup C by class -- okay?
        bp->C::~B();  // C found by class lookup B by normal -- okay?
      }

A second issue concerns destructor references when the class involved is a template class.

      namespace N {
        template <typename T> struct S {
          ~S();
        };
      }

      void f(N::S<int>* s) {
        s->N::S<int>::~S();
      }

The issue here is that the grammar uses "~class-name" for destructor names, but in this case S is a template name when looked up in N.

Finally, what about cases like:

      template <typename T> void f () {
        typename T::B x;
        x.template A<T>::template B<T>::~B();
      }

When parsing the template definition, what checks can be done on "~B"?

Sandor Mathe adds :

The standard correction for issue 244 (now in DR status) is still incomplete.

Paragraph 5 of 3.4.3 [basic.lookup.qual] is not applicable for p->T::~T since there is no nested-name-specifier. Section 3.4.5 [basic.lookup.classref] describes the lookup of p->~T but p->T::~T is still not described. There are examples (which are non-normative) that illustrate this sort of lookup but they still leave questions unanswered. The examples imply that the name after ~ should be looked up in the same scope as the name before the :: but it is not stated. The problem is that the name to the left of the :: can be found in two different scopes. Consider the following:

      struct S {
        struct C { ~C() { } };
      };

      typedef S::C D;

      int main() {
        D* p;
        p->C::~D();  // valid?
      }

Should the destructor call be valid? If there were a nested name specifier, then D should be looked for in the same scope as C. But here, C is looked for in 2 different ways. First, it is searched for in the type of the left hand side of -> and it is also looked for in the lexical context. It is found in one or if both, they must match. So, C is found in the scope of what p points at. Do you only look for D there? If so, this is invalid. If not, you would then look for D in the context of the expression and find it. They refer to the same underlying destructor so this is valid. The intended resolution of the original defect report of the standard was that the name before the :: did not imply a scope and you did not look for D inside of C. However, it was not made clear whether this was to be resolved by using the same lookup mechanism or by introducing a new form of lookup which is to look in the left hand side if that is where C was found, or in the context of the expression if that is where C was found. Of course, this begs the question of what should happen when it is found in both? Consider the modification to the above case when C is also found in the context of the expression. If you only look where you found C, is this now valid because it is in 1 of the two scopes or is it invalid because C was in both and D is only in 1?

      struct S {
        struct C { ~C() { } };
      };

      typedef S::C D;
      typedef S::C C;

      int main() {
        D* p;
        p->C::~D();  // valid?
      }

I agree that the intention of the committee is that the original test case in this defect is broken. The standard committee clearly thinks that the last name before the last :: does not induce a new scope which is our current interpretation. However, how this is supposed to work is not defined. This needs clarification of the standard.

Martin Sebor adds this example (September 2003), along with errors produced by the EDG front end:

    namespace N {
        struct A { typedef A NA; };
        template <class T> struct B { typedef B NB; typedef T BT; };
        template <template <class> class T> struct C { typedef C NC; typedef T<A> CA; };
    }

    void foo (N::A *p)
    {
        p->~NA ();
        p->NA::~NA ();
    }

    template <class T>
    void foo (N::B<T> *p)
    {
        p->~NB ();
        p->NB::~NB ();
    }

    template <class T>
    void foo (typename N::B<T>::BT *p)
    {
        p->~BT ();
        p->BT::~BT ();
    }

    template <template <class> class T>
    void foo (N::C<T> *p)
    {
        p->~NC ();
        p->NC::~NC ();
    }

    template <template <class> class T>
    void foo (typename N::C<T>::CA *p)
    {
        p->~CA ();
        p->CA::~CA ();
    }

    Edison Design Group C/C++ Front End, version 3.3 (Sep  3 2003 11:54:55)
    Copyright 1988-2003 Edison Design Group, Inc.

    "t.cpp", line 16: error: invalid destructor name for type "N::B<T>"
          p->~NB ();
              ^

    "t.cpp", line 17: error: qualifier of destructor name "N::B<T>::NB" does not
              match type "N::B<T>"
          p->NB::~NB ();
                  ^

    "t.cpp", line 30: error: invalid destructor name for type "N::C<T>"
          p->~NC ();
              ^

    "t.cpp", line 31: error: qualifier of destructor name "N::C<T>::NC" does not
              match type "N::C<T>"
          p->NC::~NC ();
                  ^

    4 errors detected in the compilation of "t.cpp".

John Spicer: The issue here is that we're unhappy with the destructor names when doing semantic analysis of the template definitions (not during an instantiation).

My personal feeling is that this is reasonable. After all, why would you call p->~NB for a class that you just named as N::B<T> and you could just say p->~B?

Additional note (September, 2004)

The resolution for issue 244 removed the discussion of `p->N::~S`, where `N` is a namespace-name. However, the resolution did not make this construct ill-formed; it simply left the semantics undefined. The meaning should either be defined or the construct made ill-formed.

See also issues 305 and 466.

#### 1492. Exception specifications on template destructors

Section: 12.4 [class.dtor] Status: drafting Submitter: Jason Merrill Date: 2012-04-01

According to 12.4 [class.dtor] paragraph 3,

> A declaration of a destructor that does not have an exception-specification is implicitly considered to have the same exception-specification as an implicit declaration (15.4 [except.spec]).

The implications of this are not clear for the destructor of a class template. For example,

      template <class T> struct B: T {
        ~B();
      };
      template <class T> B<T>::~B() noexcept {}

The implicit exception-specification of the in-class declaration of the destructor depends on the characteristics of the template argument. Does this mean that the out-of-class definition of the destructor is ill-formed, or will it be ill-formed only in specializations where the template argument causes the implicit exception-specification to be other than `noexcept`?

Proposed resolution (October, 2012):

This issue is resolved by the resolution of issue 1552.

Notes from the April, 2013 meeting:

This issue was approved as a DR at the April, 2013 (Bristol) meeting, but it was not noticed that issue 1552 was not being moved at that time. It is being returned to "drafting" status pending the resolution of that issue.

#### 1586. Naming a destructor via `decltype`

Section: 12.4 [class.dtor] Status: drafting Submitter: Steve Clamage Date: 2012-11-14

Use of a decltype-specifier to name a destructor in an explicit destructor call is explicitly permitted in 12.4 [class.dtor] paragraph 13. However, the most straightforward attempt to do so, e.g.,

      p->~decltype(*p)()

does not work, because `*p` is an lvalue and thus `decltype(*p)` is a reference type, not a class type. Even simply eliminating the reference is not sufficient, because `p` could be a pointer to a cv-qualified class type.

Either the provision for decltype-specifiers in explicit destructor calls should be removed or the specification should be expanded to allow reference and cv-qualified types to be considered as “denot[ing] the destructor's class type.”

Notes from the April, 2013 meeting:

CWG favored replacing the existing syntax with something more flexible, for example, `p->~auto()`. This new syntax would also apply to pseudo destructors.

#### 255. Placement deallocation functions and lookup ambiguity

Section: 12.5 [class.free] Status: drafting Submitter: Mike Miller Date: 26 Oct 2000

Paragraph 4 of 12.5 [class.free] speaks of looking up a deallocation function. While it is an error if a placement deallocation function alone is found by this lookup, there seems to be an assumption that a placement deallocation function and a usual deallocation function can both be declared in a given class scope without creating an ambiguity. The normal mechanism by which ambiguity is avoided when functions of the same name are declared in the same scope is overload resolution; however, there is no mention of overload resolution in the description of the lookup. In fact, there appears to be nothing in the current wording that handles this case. That is, the following example appears to be ill-formed, according to the current wording:

        struct S {
            void operator delete(void*);
            void operator delete(void*, int);
        };
        void f(S* p) {
            delete p;    // ill-formed: ambiguous operator delete
        }

Suggested resolution (Mike Miller, March 2002):

I think you might get the right effect by replacing the last sentence of 12.5 [class.free] paragraph 4 with something like:

> After removing all placement deallocation functions, the result of the lookup shall contain an unambiguous and accessible deallocation function.

Additional notes (October, 2012):

This issue should be reconsidered in list of paper N3396, as it would add additional overloads for allocation and deallocation functions.

The term “usual deallocation function” is defined in 3.7.4.2 [basic.stc.dynamic.deallocation] paragraph 2; perhaps it could be used to good effect in 5.3.5 [expr.delete] paragraph 7. The specifications in 12.5 [class.free] paragraphs 4 and 5 should probably also be moved into 5.3.5 [expr.delete].

#### 1621. Member initializers in anonymous unions

Section: 12.6.2 [class.base.init] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-02-12

The effect of a non-static data member initializer in an anonymous union is not clearly described in the current wording. Consider the following example:

      struct A {
        struct B {
          union {
            int x = 37;
          };
          union {
            int y = x + 47;  // Well-formed?
          };
        } a;
      };

Does an anonymous union have a constructor that applies a non-static data member initializer? Or is the initialization performed by the constructor of the class in which the anonymous union appears? In particular, is the reference to `x` in the initializer for `y` well-formed or not? If the initialization of `y` is performed by `B`'s constructor, there is no problem because `B::x` is a member of the object being initialized. If an anonymous union has its own constructor, `B::x` is just a member of the containing class and is a reference to a non-static data member without an object, which is ill-formed. Implementations currently appear to take the latter interpretation and report an error for that initializer.

As a further example, consider:

      union {       // #1
        union {     // #2
          union {   // #3
            int y = 32;
          };
        };
      } a { } ;

One interpretation might be that union #3 has a non-trivial default constructor because of the initializer of `y`, which would give union #2 a deleted default constructor, which would make the example ill-formed.

As yet another example, consider:

      union {
        union {
          int x;
        };
        union {
          int y = 3;
        };
        union {
          int z;
        };
      } a { };

Assuming the current proposed resolution of issue 1502, what is the correct interpretation of this code? Is it well-formed, and if so, what initialization is performed?

Finally, consider

      struct S {
        union { int x = 1; };
        union { int y = 2; };
      } s{};

Does this violate the prohibition of aggregates containing member initializers in 8.5.1 [dcl.init.aggr] paragraph 1?

See also issues 1460, 1562, 1587, and 1623.

#### 1092. Cycles in overload resolution during instantiation

Section: 12.8 [class.copy] Status: drafting Submitter: Jason Merrill Date: 2010-07-15

Moving to always doing overload resolution for determining exception specifications and implicit deletion creates some unfortunate cycles:

        template<typename T> struct A {
           T t;
        };

        template <typename T> struct B {
           typename T::U u;
        };

        template <typename T> struct C {
           C(const T&);
        };

        template <typename T> struct D {
           C<B<T> > v;
        };

        struct E {
           typedef A<D<E> > U;
        };

        extern A<D<E> > a;
        A<D<E> > a2(a);

If declaring the copy constructor for `A<D<E>>` is part of instantiating the class, then we need to do overload resolution on `D<E>`, and thus `C<B<E>>`. We consider `C(const B<E>&)`, and therefore look to see if there's a conversion from `C<B<E>>` to `B<E>`, which instantiates `B<E>`, which fails because it has a field of type `A<D<E>>` which is already being instantiated.

Even if we wait until `A<D<E>>` is considered complete before finalizing the copy constructor declaration, declaring the copy constructor for `B<E>` will want to look at the copy constructor for `A<D<E>>`, so we still have the cycle.

I think that to avoid this cycle we need to short-circuit consideration of `C(const T&)` somehow. But I don't see how we can do that without breaking

        struct F {
           F(F&);
        };

        struct G;
        struct G2 {
           G2(const G&);
        };

        struct G {
           G(G&&);
           G(const G2&);
        };

        struct H: F, G { };

        extern H h;
        H h2(h);

Here, since `G`'s move constructor suppresses the implicit copy constructor, the defaulted `H` copy constructor calls `G(const G2&)` instead. If the move constructor did not suppress the implicit copy constructor, I believe the implicit copy constructor would always be viable, and therefore a better match than a constructor taking a reference to another type.

So perhaps the answer is to reconsider that suppression and then disqualify any constructor taking (a reference to) a type other than the constructor's class from consideration when looking up a subobject constructor in an implicitly defined constructor. (Or assignment operator, presumably.)

Another possibility would be that when we're looking for a conversion from `C<B<E>>` to `B<E>` we could somehow avoid considering, or even declaring, the `B<E>` copy constructor. But that seems a bit dodgy.

Additional note (October, 2010):

An explicitly declared move constructor/op= should not suppress the implicitly declared copy constructor/op=; it should cause it to be deleted instead. This should prevent a member function taking a (reference to) an un-reference-related type from being chosen by overload resolution in a defaulted member function.

And we should clarify that member functions taking un-reference-related types are not even considered during overload resolution in a defaulted member function, to avoid requiring their parameter types to be complete.

#### 1491. Move construction and rvalue reference members

Section: 12.8 [class.copy] Status: drafting Submitter: Richard Smith Date: 2012-03-30

According to 12.8 [class.copy] paragraph 11, the last bullet, a defaulted move constructor for a class is defined as deleted if

> a non-static data member or direct or virtual base class with a type that does not have a move constructor and is not trivially copyable.

This means that an example like

      struct S { S(); int &&r; } s{S()};

is ill-formed. This is probably not intended.

(Note that the February, 2012 proposed resolution for issue 1402 also makes this example ill-formed, because the move constructor is not declared and the copy constructor is defined as deleted because of the rvalue-reference member.)

#### 1499. Missing case for deleted move assignment operator

Section: 12.8 [class.copy] Status: drafting Submitter: John Spicer Date: 2012-04-27

Bullet 4 of 12.8 [class.copy] paragraph 23 says that a defaulted copy/move assignment operator is defined as deleted if the class has

> a non-static data member of class type `M` (or array thereof) that cannot be copied/moved because overload resolution (13.3 [over.match]), as applied to `M`'s corresponding assignment operator, results in an ambiguity or a function that is deleted or inaccessible from the defaulted assignment operator

The intent of this is that if overload resolution fails to find a corresponding copy/move assignment operator that can validly be called to copy/move a member, the class's assignment operator will be defined as deleted. However, this wording does not cover an example like the following:

      struct A {
        A();
      };

      struct B {
        B();
        const A a;
      };

      typedef B& (B::*pmf)(B&&);

      pmf p =&B::operator=;

Here, the problem is simply that overload resolution failed to find a callable function, which is not one of the cases listed in the current wording. A similar problem exists for base classes in the fifth bullet.

Additional note (January, 2013):

A similar omission exists in paragraph 11 for copy constructors.

#### 1548. Copy/move construction and conversion functions

Section: 12.8 [class.copy] Status: drafting Submitter: Nikolay Ivchenkov Date: 2012-09-02

The current wording of 12.8 [class.copy] paragraph 31 refers only to constructors and destructors:

> When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the constructor selected for the copy/move operation and/or the destructor for the object have side effects.

However, in some cases (e.g., `auto_ptr`) a conversion function is also involved in the copying, and it could presumably also have visible side effects that would be eliminated by copy elision. (Some additional contexts that may also require changes in this regard are mentioned in the resolution of issue 535.)

Additional note (September, 2012):

The default arguments of an elided constructor can also have side effects and should be mentioned, as well; however, the elision should not change the odr-use status of functions and variables appearing in those default arguments.

#### 1594. Lazy declaration of special members vs overload errors

Section: 12.8 [class.copy] Status: drafting Submitter: Richard Smith Date: 2012-12-06

The implicit declaration of a special member function sometimes requires overload resolution, in order to select a special member to use for base classes and non-static data members. This can be required to determine whether the member is or would be deleted, and whether the member is trivial, for instance. The standard appears to require such overload resolution be performed at the end of the definition of the class, but in practice, implementations perform it lazily. This optimization appears to be non-conforming, in the case where overload resolution would hit an error. In order to enable this optimization, such errors should be “no diagnostic required.”

Additional note (March, 2013):

See also issue 1360.

Notes from the September, 2013 meeting:

The problem with this approach is that hard errors (not in the immediate context) can occur, affecting portability. There are some cases, such as a virtual assignment operator in the base class, where lazy evaluation cannot be done, so it cannot be mandated.

#### 1734. Nontrivial deleted copy functions

Section: 12.8 [class.copy] Status: drafting Submitter: James Widman Date: 2013-08-09

The intent was for PODs in C++11 to be a superset of C++03 PODs. Consequently, in the following example, `C` should be a POD but isn't:

      struct A {
        const int m;
        A& operator=(A const&) = default; // deleted and trivial, so A is a
                                          // POD, as it would be in 2003
                                          // without this explicit op= decl
      };
      static_assert(__is_trivially_copyable(A), "");

      struct B {
        int i;
        B& operator=(B &) & = default;      // non-trivial
        B& operator=(B const&) & = default; // trivial
      };

      struct C {
        const B m;
        C& operator=(C const& r) = default; // deleted (apparently), but non-trivial (apparently)
        /* Notionally:
          C& operator=(C const& r) {
            (*this).m.operator=(r.m);
            return *this;
          }
        */
      };
      static_assert(!__is_trivially_copyable(C), "");

This is because of the following text from 12.8 [class.copy] paragraph 25:

> for each non-static data member of `X` that is of class type (or array thereof), the assignment operator selected to copy/move that member is trivial;

In this case, overload resolution fails, so no assignment operator is selected, so `C::operator=(const C&)` is non-trivial.

#### 1573. Inherited constructor characteristics

Section: 12.9 [class.inhctor] Status: drafting Submitter: Jason Merrill Date: 2012-10-15

Issue 1350 clarified that the exception-specification for an inheriting constructor is determined like defaulted functions, but we should also say something similar for deleted, and perhaps constexpr.

Also, the description of the semantics of inheriting constructors don't seem to allow for C-style variadic functions, so the text should be clearer that such constructors are only inherited without their ellipsis.

#### 1645. Identical inheriting constructors via default arguments

Section: 12.9 [class.inhctor] Status: drafting Submitter: Richard Smith Date: 2013-03-18

For an example like

      struct A {
        constexpr A(int, float = 0);
        explicit A(int, int = 0);
        A(int, int, int = 0) = delete;
      };

      struct B : A {
        using A::A;
      };

it is not clear from 12.9 [class.inhctor] what should happen: is `B::B(int)` `constexpr` and/or `explicit`? Is `B::B(int, int)` `explicit` and/or deleted? Although the rationale given in the note in paragraph 7,

> If two using-declarations declare inheriting constructors with the same signatures, the program is ill-formed (9.2 [class.mem], 13.1 [over.load]), because an implicitly-declared constructor introduced by the first using-declaration is not a user-declared constructor and thus does not preclude another declaration of a constructor with the same signature by a subsequent using-declaration.

might be thought to apply, paragraph 1 talks about a set of candidate constructors based on their parameter types, so presumably such a set would contain only a single declaration of `A::A(int)` and one for `A::A(int, int)`. The constructor characteristics of that declaration, however, are not specified.

One possibility might be to declare such a constructor, resulting from the transformation of more than one base class constrctor, to be deleted, so there would be an error only if it were used.

Notes from the April, 2013 meeting:

CWG agreed with the direction of defining such constructors as deleted.

#### 1715. Access and inherited constructor templates

Section: 12.9 [class.inhctor] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-07-16

Consider the following example:

      template<class T> struct S {
      private:
        typedef int X;
        friend struct B;
      };

      struct B {
        template<class T> B(T, typename T::X);
      };

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

      S<int> s;
      B b(s, 2); // Okay, thanks to friendship.
      D d(s, 2); // Error: friendship is not inherited.

My understanding is that the construction of `d` fails because `typename T::X` expands to `S<int>::X` in this case, and that is not accessible from `D`.

However, I'm not sure that makes sense from a usability perspective. The user of `D` just wanted to be able to wrap class `B`, and the fact that friendship was granted to `B` to enable its constructor parameter seems like just an implementation detail that `D` shouldn't have to cope with.

Would it perhaps be better to suspend access checking during the instantiation of inheriting member function template declarations (not definitions), since real access problems (e.g., the selection of a private constructor) would presumably be revealed when doing the full instantiation?

#### 1736. Inheriting constructor templates in a local class

Section: 12.9 [class.inhctor] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-08-13

A local class cannot, according to 14.5.2 [temp.mem] paragraph 2, have member templates. Presumably, then, an example like the following is ill-formed:

      struct S {
        template<class T> S(T) {
          struct L: S {
            using S::S;
          };
        }
      };

It is accepted by current implementations, however. Does something need to be said about this case in 12.9 [class.inhctor], either to explicitly allow or forbid it, or is the restriction in 14.5.2 [temp.mem] sufficient?

#### 1738. Explicit instantiation/specialization of inheriting constructor templates

Section: 12.9 [class.inhctor] Status: drafting Submitter: Daveed Vandevoorde Date: 2013-08-16

It is not clear whether it is permitted to explicitly instantiate or explicitly specialize specializations of inheriting constructor templates. Since inheriting constructors are considered to be implicitly declared (12.9 [class.inhctor] paragraph 1), it might be inferred that 14.7.2 [temp.explicit] paragraph 4 forbids their explicit instantiation:

> If the declaration of the explicit instantiation names an implicitly-declared special member function (Clause 12 [special]), the program is ill-formed.

Similarly, an explicit specialization provides a definition for the specialized member, and 12 [special] paragraph 1 forbids defining an implicitly-declared special member function.

These inferences do not seem conclusive, however, so an explicit statement in 12.9 [class.inhctor] would be helpful.

(See also issue 1780.)

#### 1252. Overloading member function templates based on dependent return type

Section: 13.1 [over.load] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-06

The Standard does not allow overloading of member functions that differ only in their return type (cf `enable_if`).

#### 1278. Incorrect treatment of contrived object

Section: 13.3.1.1.1 [over.call.func] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-27

Footnote 127 of 13.3.1.1.1 [over.call.func] paragraph 3 reads,

> An implied object argument must be contrived to correspond to the implicit object parameter attributed to member functions during overload resolution. It is not used in the call to the selected function. Since the member functions all have the same implicit object parameter, the contrived object will not be the cause to select or reject a function.

It is not true that “the member functions all have the same implicit object parameter.” This statement does not take into account member functions brought into the class by using-declarations or cv-qualifiers and ref-qualifiers on the non-static member functions:

        struct B
        {
          char f();         // B &
        };

        struct D : B
        {
          using B::f;
          long f();         // D &

          char g() const;   // D const &
          long g();         // D &

          char h() &;       // D &
          long h() &&;      // D &&
        };

        int main()
        {
          // D::f() has better match than B::f()
          decltype(D().f()) *p1 = (long *)0;

          // D::g() has better match than D::g() const
          decltype(D().g()) *p2 = (long *)0;

          // D::h() & is not viable function
          // D::h() && is viable function
          decltype(D().h()) *p3 = (long *)0;
        }

The value category of a contrived object expression is not specified by the rules and, probably, cannot be properly specified in presence of ref-qualifiers, so the statement “the contrived object will not be the cause to select or reject a function” should be normative rather than informative:

        struct X
        {
          static void f(double) {}
          void f(int) & {}
          void f(int) && {}
        };

        int main()
        {
          X::f(0); // ???
        }

#### 1687. Conversions of operands of built-in operators

Section: 13.3.1.2 [over.match.oper] Status: drafting Submitter: Richard Smith Date: 2013-05-17

Consider an example like:

      struct Y {
        operator int*();
      };

      extern int *p;
      int *a = p + 100.0;   // #1
      int *b = Y() + 100.0; // #2

#1 is ill-formed because it violates the requirement of 5.7 [expr.add] that the non-pointer operand have integral or enumeration type. It appears that #2 is well-formed, however, because 13.3.1.2 [over.match.oper] paragraph 7 says,

> If a built-in candidate is selected by overload resolution, the operands are converted to the types of the corresponding parameters of the selected operation function. Then the operator is treated as the corresponding built-in operator and interpreted according to Clause 5 [expr].

In this case, the selected operation function is

      int *operator+(int *, std::ptrdiff_t)

`100.0` is thus converted to `std::ptrdiff_t` before reaching 5.7 [expr.add].

This problem could be addressed by restricting the conversion to the class or enumeration operand rather than both operands.

#### 455. Partial ordering and non-deduced arguments

Section: 13.3.3 [over.match.best] Status: drafting Submitter: Rani Sharoni Date: 19 Jan 2004

It's not clear how overloading and partial ordering handle non-deduced pairs of corresponding arguments. For example:

    template<typename T>
    struct A { typedef char* type; };

    template<typename T> char* f1(T, typename A<T>::type);  // #1
    template<typename T> long* f1(T*, typename A<T>::type*); // #2

    long* p1 = f1(p1, 0); // #3

I thought that #3 is ambiguous but different compilers disagree on that. Comeau C/C++ 4.3.3 (EDG 3.0.3) accepted the code, GCC 3.2 and BCC 5.5 selected #1 while VC7.1+ yields ambiguity.

I intuitively thought that the second pair should prevent overloading from triggering partial ordering since both arguments are non-deduced and has different types - (char*, char**). Just like in the following:

    template<typename T> char* f2(T, char*);   // #3
    template<typename T> long* f2(T*, char**); // #4

    long* p2 = f2(p2, 0); // #5

In this case all the compilers I checked found #5 to be ambiguous. The standard and DR 214 is not clear about how partial ordering handle such cases.

I think that overloading should not trigger partial ordering (in step 13.3.3 [over.match.best]/1/5) if some candidates have non-deduced pairs with different (specialized) types. In this stage the arguments are already adjusted so no need to mention it (i.e. array to pointer). In case that one of the arguments is non-deuced then partial ordering should only consider the type from the specialization:

    template<typename T> struct B { typedef T type; };

    template<typename T> char* f3(T, T);                   // #7
    template<typename T> long* f3(T, typename B<T>::type); // #8

    char* p3 = f3(p3, p3); // #9

According to my reasoning #9 should yield ambiguity since second pair is (T, long*). The second type (i.e. long*) was taken from the specialization candidate of #8. EDG and GCC accepted the code. VC and BCC found an ambiguity.

John Spicer: There may (or may not) be an issue concerning whether nondeduced contexts are handled properly in the partial ordering rules. In general, I think nondeduced contexts work, but we should walk through some examples to make sure we think they work properly.

Rani's description of the problem suggests that he believes that partial ordering is done on the specialized types. This is not correct. Partial ordering is done on the templates themselves, independent of type information from the specialization.

Notes from October 2004 meeting:

John Spicer will investigate further to see if any action is required.

(See also issue 885.)

#### 1536. Overload resolution with temporary from initializer list

Section: 13.3.3.1.5 [over.ics.list] Status: drafting Submitter: Mike Miller Date: 2012-08-14

In determining the implicit conversion sequence for an initializer list argument passed to a reference parameter, the intent is that a temporary of the appropriate type will be created and bound to the reference, as reflected in 13.3.3.1.5 [over.ics.list] paragraph 5:

> Otherwise, if the parameter is a reference, see 13.3.3.1.4 [over.ics.ref]. [Note: The rules in this section will apply for initializing the underlying temporary for the reference. —end note]

However, 13.3.3.1.4 [over.ics.ref] deals only with expression arguments, not initializer lists:

> When a parameter of reference type binds directly (8.5.3 [dcl.init.ref]) to an argument expression, the implicit conversion sequence is the identity conversion, unless the argument expression has a type that is a derived class of the parameter type, in which case the implicit conversion sequence is a derived-to-base Conversion (13.3.3.1 [over.best.ics])... If the parameter binds directly to the result of applying a conversion function to the argument expression, the implicit conversion sequence is a user-defined conversion sequence (13.3.3.1.2 [over.ics.user]), with the second standard conversion sequence either an identity conversion or, if the conversion function returns an entity of a type that is a derived class of the parameter type, a derived-to-base Conversion.

> When a parameter of reference type is not bound directly to an argument expression, the conversion sequence is the one required to convert the argument expression to the underlying type of the reference according to 13.3.3.1 [over.best.ics]. Conceptually, this conversion sequence corresponds to copy-initializing a temporary of the underlying type with the argument expression. Any difference in top-level cv-qualification is subsumed by the initialization itself and does not constitute a conversion.

(Note in particular that the reference binding refers to 8.5.3 [dcl.init.ref], which also does not handle initializer lists, and not to 8.5.4 [dcl.init.list].)

Either 13.3.3.1.4 [over.ics.ref] needs to be revised to handle binding references to initializer list arguments or 13.3.3.1.5 [over.ics.list] paragraph 5 needs to be clearer on how the expression specification is intended to be applied to initializer lists.

#### 1631. Incorrect overload resolution for single-element initializer-list

Section: 13.3.3.1.5 [over.ics.list] Status: drafting Submitter: Johannes Schaub Date: 2013-03-03

According to bullet 1 of 13.3.3.1.5 [over.ics.list] paragraph 6,

> Otherwise, if the parameter type is not a class:

> - if the initializer list has one element, the implicit conversion sequence is the one required to convert the element to the parameter type;

> - ...

This wording ignores the possibility that the element might be an initializer list (as opposed to an expression with a type, as illustrated in the example). This oversight affects an example like:

      struct A { int a[1]; };
      struct B { B(int); };
      void f(B, int);
      void f(int, A);

      int main() {
        f({0}, {{1}});
      }

#### 1589. Ambiguous ranking of list-initialization sequences

Section: 13.3.3.2 [over.ics.rank] Status: drafting Submitter: Johannes Schaub Date: 2012-11-21

The interpretation of the following example is unclear in the current wording:

       void f(long);
       void f(initializer_list<int>);
       int main() { f({1L});

The problem is that a list-initialization sequence can also be a standard conversion sequence, depending on the types of the elements and the type of the parameter, so more than one bullet in the list in 13.3.3.2 [over.ics.rank] paragraph 3 applies:

> Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:

> - Standard conversion sequence `S1` is a better conversion sequence than standard conversion sequence `S2` if

> - ...

> - the rank of `S1` is better than the rank of `S2`, or `S1` and `S2` have the same rank and are distinguishable by the rules in the paragraph below, or, if not that,

> - ...

> - ...

> - List-initialization sequence `L1` is a better conversion sequence than list-initialization sequence `L2` if `L1` converts to `std::initializer_list<X>` for some `X` and `L2` does not.

These bullets give opposite results for the example above, and there is implementation variance in which is selected.

Notes from the April, 2013 meeting:

CWG determined that the latter bullet should apply only if the first one does not.

#### 205. Templates and static data members

Section: 14 [temp] Status: drafting Submitter: Mike Miller Date: 11 Feb 2000

Static data members of template classes and of nested classes of template classes are not themselves templates but receive much the same treatment as template. For instance, 14 [temp] paragraph 1 says that templates are only "classes or functions" but implies that "a static data member of a class template or of a class nested within a class template" is defined using the template-declaration syntax.

There are many places in the clause, however, where static data members of one sort or another are overlooked. For instance, 14 [temp] paragraph 6 allows static data members of class templates to be declared with the `export` keyword. I would expect that static data members of (non-template) classes nested within class templates could also be exported, but they are not mentioned here.

Paragraph 8, however, overlooks static data members altogether and deals only with "templates" in defining the effect of the `export` keyword; there is no description of the semantics of defining a static data member of a template to be exported.

These are just two instances of a systematic problem. The entire clause needs to be examined to determine which statements about "templates" apply to static data members, and which statements about "static data members of class templates" also apply to static data members of non-template classes nested within class templates.

(The question also applies to member functions of template classes; see issue 217, where the phrase "non-template function" in 8.3.6 [dcl.fct.default] paragraph 4 is apparently intended not to include non-template member functions of template classes. See also issue 108, which would benefit from understanding nested classes of class templates as templates. Also, see issue 249, in which the usage of the phrase "member function template" is questioned.)

Notes from the 4/02 meeting:

Daveed Vandevoorde will propose appropriate terminology.

#### 1444. Type adjustments of non-type template parameters

Section: 14.1 [temp.param] Status: drafting Submitter: Johannes Schaub Date: 2012-01-15

The type adjustment of template non-type parameters described in 14.1 [temp.param] paragraph 8 appears to be underspecified. For example, implementations vary in their treatment of

      template<typename T, T[T::size]> struct A {};
      int dummy;
      A<int, &dummy> a;

and

      template<typename T, T[1]> struct A;
      template<typename T, T*> struct A {};
      int dummy;
      A<int, &dummy> a;

See also issue 1322.

#### 1635. How similar are template default arguments to function default arguments?

Section: 14.1 [temp.param] Status: drafting Submitter: Richard Smith Date: 2013-03-06

Default function arguments are instantiated only when needed. Is the same true of default template arguments? For example, is the following well-formed?

      #include <type_traits>

      template<class T>
      struct X {
        template<class U = typename T::type>
        static void foo(int){}
        static void foo(...){}
      };

      int main(){
        X<std::enable_if<false>>::foo(0);
      }

Also, is the effect on lookup the same? E.g.,

      struct S {
        template<typename T = U> void f();
        struct U {};
      };

#### 314. `template` in base class specifier

Section: 14.2 [temp.names] Status: drafting Submitter: Mark Mitchell Date: 23 Aug 2001

The EDG front-end accepts:

    template <typename T>
    struct A {
      template <typename U>
      struct B {};
    };

    template <typename T>
    struct C : public A<T>::template B<T> {
    };

It rejects this code if the base-specifier is spelled `A<T>::B<T>`.

However, the grammar for a base-specifier does not allow the `template` keyword.

Suggested resolution:

It seems to me that a consistent approach to the solution that looks like it will be adopted for issue 180 (which deals with the `typename` keyword in similar contexts) would be to assume that `B` is a template if it is followed by a "<". After all, an expression cannot appear in this context.

Notes from the 4/02 meeting:

We agreed that `template` must be allowed in this context. The syntax needs to be changed. We also opened the related issue 343.

Additional note (August, 2010):

The same considerations apply to mem-initializer-ids, as noted in issue 1019.

#### 1478. `template` keyword for dependent template template arguments

Section: 14.2 [temp.names] Status: drafting Submitter: Johannes Schaub Date: 2012-03-10

According to 14.2 [temp.names] paragraph 4,

> When the name of a member template specialization appears after `.` or `->` in a postfix-expression or after a nested-name-specifier in a qualified-id, and the object expression of the postfix-expression is type-dependent or the nested-name-specifier in the qualified-id refers to a dependent type, but the name is not a member of the current instantiation (14.6.2.1 [temp.dep.type]), the member template name must be prefixed by the keyword `template`.

In other words, the `template` keyword is only required when forming a template-id. However, current compilers reject an example like:

      template<typename T, template<typename> class U = T::X> struct A;

and require the `template` keyword before `X`. Should the rule be amended to require the `template` keyword in cases like this?

#### 1666. Address constant expressions

Section: 14.3.2 [temp.arg.nontype] Status: drafting Submitter: Daniel Krügler Date: 2013-04-24

The term “address constant expression” was removed by paper N3652, but it is still referenced in the list of permissible nontype template arguments in 14.3.2 [temp.arg.nontype] paragraph 1:

- an address constant expression of type `std::nullptr_t`.

#### 1729. Matching declarations and definitions of variable templates

Section: 14.5 [temp.decls] Status: drafting Submitter: Larisse Voufo Date: 2013-08-05

The relationship between declarations and definitions of variable templates is not clear. For example:

      template<typename T> auto var0 = T();  // #1a.
      template<typename T> extern T var0;    // #1b.

      template<typename T> T var1;           // #2a.
      template<typename T> extern auto var1; // #2b.
      template<typename T> extern T var1;    // #2c.
      template<typename T> T var1;           // #2d.

Questions:

1. When is a variable template declaration a definition and when a non-defining declaration?

2. What declarations are valid?

3. Should `auto` declarations be allowed?

4. To what extent, if any, do these involve type matching?

5. How are types matched, especially in the presence of `auto`?

#### 1730. Can a variable template have an unnamed type?

Section: 14.5 [temp.decls] Status: drafting Submitter: Larisse Voufo Date: 2013-08-05

Is it permitted for a variable template to have an unnamed type?

#### 1432. Newly-ambiguous variadic template expansions

Section: 14.5.3 [temp.variadic] Status: drafting Submitter: Daniel Krügler Date: 2011-12-17

With the new core rules in regard to variadic pack expansions the library specification of the traits template `common_type` is now broken, the reason is that it is defined as a series of specializations of the primary template

        template <class ...T>
        struct common_type;

The broken one is this pair:

      template <class T, class U>
      struct common_type<T, U> {
       typedef decltype(true ? declval<T>() : declval<U>()) type;
      };

      template <class T, class U, class... V>
      struct common_type<T, U, V...> {
       typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
      };

With the new rules both specializations would now be ambiguous for an instantiation like `common_type<X, Y>`.

(See also issue 1395.)

Notes from the October, 2012 meeting:

It is possible that 14.5.5.2 [temp.class.order] may resolve this problem.

#### 1545. `friend` function templates defined in class templates

Section: 14.5.4 [temp.friend] Status: drafting Submitter: Daniel Krügler Date: 2012-08-25

The status of an example like the following is not clear:

       template<class> struct x {
         template<class T>
         friend bool operator==(x<T>, x<T>) { return false; }
      };

      int main() {
        x<int> x1;
        x<double> x2;
        x1 == x1;
        x2 == x2;
      }

Such a `friend` definition is permitted by 14.5.4 [temp.friend] paragraph 2:

> A friend function template may be defined within a class or class template...

Paragraph 4 appears to be related, but deals only with friend functions, not friend function templates:

> When a function is defined in a friend function declaration in a class template, the function is instantiated when the function is odr-used. The same restrictions on multiple declarations and definitions that apply to non-template function declarations and definitions also apply to these implicit definitions.

#### 1315. Restrictions on non-type template arguments in partial specializations

Section: 14.5.5 [temp.class.spec] Status: drafting Submitter: Johannes Schaub Date: 2011-05-12

The rationale for the restriction in 14.5.5 [temp.class.spec] paragraph 8, first bullet is not clear:

- A partially specialized non-type argument expression shall not involve a template parameter of the partial specialization except when the argument expression is a simple identifier. [Example:

      template <int I, int J> struct A {};
      template <int I> struct A<I+5, I*2> {}; // error
      template <int I, int J> struct B {};
      template <int I> struct B<I, I> {};     // OK

—end example]

In the example, it's clear that `I` is non-deducible, but this rule prevents plausible uses like:

      template <int I, int J> struct A {};
      template <int I> struct A<I, I*2> {};

#### 1647. Type agreement of non-type template arguments in partial specializations

Section: 14.5.5 [temp.class.spec] Status: drafting Submitter: John Spicer Date: 2013-04-04

The Standard appears to be silent on whether the types of non-type template arguments in a partial specialization must be the same as those of the primary template or whether conversions are permitted. For example,

      template<char...> struct char_values {};
      template<int C1, char C3>
      struct char_values<C1, 12, C3> {
        static const unsigned value = 1;
      };
      int check0[char_values<1, 12, 3>::value == 1? 1 : -1];

The closest the current wording comes to dealing with this question is 14.5.5 [temp.class.spec] paragraph 8 bullet 1:

- A partially specialized non-type argument expression shall not involve a template parameter of the partial specialization except when the argument expression is a simple identifier.

In this example, one might think of the first template argument in the partial specialization as `(char)C1`, which would violate the requirement, but that reasoning is tenuous.

It would be reasonable to require the types to match in cases like this. If this kind of usage is allowed it could get messy if the primary template were `int...` and the partial specialization had a parameter that was `char` because not all of the possible values from the primary template could be represented in the parameter of the partial specialization. A similar issue exists if the primary template takes `signed char` and the partial specialization takes `unsigned int`.

There is implementation variance in the treatment of this example.

#### 549. Non-deducible parameters in partial specializations

Section: 14.5.5.1 [temp.class.spec.match] Status: drafting Submitter: Martin Sebor Date: 18 November 2005

In the following example, the template parameter in the partial specialization is non-deducible:

        template <class T> struct A { typedef T U; };
        template <class T> struct C { };
        template <class T> struct C<typename A<T>::U> { };

Several compilers issue errors for this case, but there appears to be nothing in the Standard that would make this ill-formed; it simply seems that the partial specialization will never be matched, so the primary template will be used for all specializations. Should it be ill-formed?

(See also issue 1246.)

Notes from the April, 2006 meeting:

It was noted that there are similar issues for constructors and conversion operators with non-deducible parameters, and that they should probably be dealt with similarly.

#### 1446. Member function with no ref-qualifier and non-member function with rvalue reference

Section: 14.5.6.2 [temp.func.order] Status: drafting Submitter: Jason Merrill Date: 2012-02-07

A member function with no ref-qualifier can be called for a class prvalue, as can a non-member function whose first parameter is an rvalue reference to that class type. However, 14.5.6.2 [temp.func.order] does not handle this case.

#### 1286. Equivalence of alias templates

Section: 14.5.7 [temp.alias] Status: drafting Submitter: Gabriel Dos Reis Date: 2011-04-03

Issue 1244 was resolved by changing the example in 14.4 [temp.type] paragraph 1 from

      template<template<class> class TT> struct X { };
      template<class> struct Y { };
      template<class T> using Z = Y<T>;
      X<Y> y;
      X<Z> z;

to

      template<class T> struct X { };
      template<class> struct Y { };
      template<class T> using Z = Y<T>;
      X<Y<int> > y;
      X<Z<int> > z;

In fact, the original intent was that the example should have been correct as written; however, the normative wording to make it so was missing. The current wording of 14.5.7 [temp.alias] deals only with the equivalence of a specialization of an alias template with the type-id after substitution. Wording needs to be added specifying under what circumstances an alias template itself is equivalent to a class template.

Proposed resolution (September, 2012):

1. Add the following as a new paragraph following 14.5.7 [temp.alias] paragraph 2:

> When the type-id in the declaration of alias template (call it `A`) consists of a simple-template-id in which the template-argument-list consists of a list of identifiers naming each template-parameter of `A` exactly once in the same order in which they appear in `A`'s template-parameter-list, the alias template is equivalent to the template named in the simple-template-id (call it `T`) if `A` and `T` have the same number of template-parameters. [Footnote: This rule is transitive: if an alias template `A` is equivalent to another alias template `B` that is equivalent to a class template `C`, then `A` is also equivalent to `C`, and `A` and `B` are also equivalent to each other. —end footnote] [Example:

>       template<typename T, U = T> struct A;

>       template<typename V, typename W>
>         using B = A<V, W>;                // equivalent to A

>       template<typename V, typename W>
>         using C = A<V>;                   // not equivalent to A:
>                                           // not all parameters used

>       template<typename V>
>         using D = A<V>;                   // not equivalent to A:
>                                           // different number of parameters

>       template<typename V, typename W>
>         using E = A<W, V>;                // not equivalent to A:
>                                           // template-arguments in wrong order

>       template<typename V, typename W = int>
>         using F = A<V, W>;                // equivalent to A:
>                                           // default arguments not considered

>       template<typename V, typename W>
>         using G = A<V, W>;                // equivalent to A and B

>       template<typename V, typename W>
>         using H = E<V, W>;                // equivalent to E

>       template<typename V, typename W>
>         using I = A<V, typename W::type>; // not equivalent to A:
>                                           // argument not identifier

> —end example]

2. Change 14.4 [temp.type] paragraph 1 as follows:

> Two template-ids refer to the same class or function if

> - ...

> - their corresponding template template-arguments refer to the same or equivalent (14.5.7 [temp.alias]) templates.

> [Example:

> ...declares `x2` and `x3` to be of the same type. Their type differs from the types of `x1` and `x4`.

>       template<class T template<class> class TT> struct X { };
>       template<class> struct Y { };
>       template<class T> using Z = Y<T>;
>       X<Y<int> Y> y;
>       X<Z<int> Z> z;

> declares `y` and `z` to be of the same type. —end example]

#### 1349. Consistency of alias template redeclarations

Section: 14.5.7 [temp.alias] Status: drafting Submitter: Richard Smith Date: 2011-08-16

There appears to be no requirement that a redeclaration of an alias template must be equivalent to the earlier one. An alias-declaration is not a definition (3.1 [basic.def] paragraph 2), so presumably an alias template declaration is also not a definition and thus the ODR does not apply.

#### 1430. Pack expansion into fixed alias template parameter list

Section: 14.5.7 [temp.alias] Status: drafting Submitter: Jason Merrill Date: 2011-12-13

Originally, a pack expansion could not expand into a fixed-length template parameter list, but this was changed in N2555. This works fine for most templates, but causes issues with alias templates.

In most cases, an alias template is transparent; when it's used in a template we can just substitute in the dependent template arguments. But this doesn't work if the template-id uses a pack expansion for non-variadic parameters. For example:

        template<class T, class U, class V>
        struct S {};

        template<class T, class V>
        using A = S<T, int, V>;

        template<class... Ts>
        void foo(A<Ts...>);

There is no way to express `A<Ts...>` in terms of `S`, so we need to hold onto the `A` until we have the `Ts` to substitute in, and therefore it needs to be handled in mangling.

Currently, EDG and Clang reject this testcase, complaining about too few template arguments for A. G++ did as well, but I thought that was a bug. However, on the ABI list John Spicer argued that it should be rejected.

(See also issue 1558.)

Notes from the October, 2012 meeting:

The consensus of CWG was that this usage should be prohibited, disallowing use of an alias template when a dependent argument can't simply be substituted directly into the type-id.

Additional note, April, 2013:

For another example, consider:

      template<class... x> class list{};
      template<class a, class... b> using tail=list<b...>;
      template <class...T> void f(tail<T...>);

      int main() {
        f<int,int>({});
      }

There is implementation variance in the handling of this example.

#### 1554. Access and alias templates

Section: 14.5.7 [temp.alias] Status: drafting Submitter: Jason Merrill Date: 2012-09-17

The interaction of alias templates and access control is not clear from the current wording of 14.5.7 [temp.alias]. For example:

      template <class T> using foo = typename T::foo;

      class B {
        typedef int foo;
        friend struct C;
      };

      struct C {
        foo<B> f;    // Well-formed?
      };

Is the substitution of `B::foo` for `foo<B>` done in the context of the befriended class `C`, making the reference well-formed, or is the access determined independently of the context in which the alias template specialization appears?

If the answer to this question is that the access is determined independently from the context, care must be taken to ensure that an access failure is still considered to be “in the immediate context of the function type” (14.8.2 [temp.deduct] paragraph 8) so that it results in a deduction failure rather than a hard error.

Notes from the October, 2012 meeting:

The consensus of CWG was that instantiation (lookup and access) for alias templates should be as for other templates, in the definition context rather than in the context where they are used. They should still be expanded immediately, however.

#### 1558. Unused arguments in alias template specializations

Section: 14.5.7 [temp.alias] Status: drafting Submitter: Nikolay Ivchenkov Date: 2012-09-19

The treatment of unused arguments in an alias template specialization is not specified by the current wording of 14.5.7 [temp.alias]. For example:

      #include <iostream>

      template <class T, class...>
        using first_of = T;

      template <class T>
        first_of<void, typename T::type> f(int)
          { std::cout << "1\n"; }

      template <class T>
        void f(...)
          { std::cout << "2\n"; }

      struct X { typedef void type; };

      int main() {
        f<X>(0);
        f<int>(0);
      }

Is the reference to `first_of<void, T::type>` with `T` being `int` equivalent to simply `void`, or is it a substitution failure?

(See also issues 1430, 1520, and 1554.)

Notes from the October, 2012 meeting:

The consensus of CWG was to treat this case as substitution failure.

#### 560. Use of the `typename` keyword in return types

Section: 14.6 [temp.res] Status: drafting Submitter: Greg Comeau Date: 11 February 2006

Consider the following example:

        template <class T> struct Outer {
            struct Inner {
                Inner* self();
            };
        };
        template <class T> Outer<T>::Inner*
            Outer<T>::Inner::self() { return this; }

According to 14.6 [temp.res] paragraph 3 (before the salient wording was inadvertently removed, see issue 559),

> A qualified-id that refers to a type and in which the nested-name-specifier depends on a template-parameter (14.6.2 [temp.dep]) but does not refer to a member of the current instantiation (14.6.2.1 [temp.dep.type]) shall be prefixed by the keyword `typename` to indicate that the qualified-id denotes a type, forming a typename-specifier.

Because `Outer<T>::Inner` is a member of the current instantiation, the Standard does not currently require that it be prefixed with `typename` when it is used in the return type of the definition of the `self()` member function. However, it is difficult to parse this definition correctly without knowing that the return type is, in fact, a type, which is what the `typename` keyword is for. Should the Standard be changed to require `typename` in such contexts?

#### 1271. Imprecise wording regarding dependent types

Section: 14.6 [temp.res] Status: drafting Submitter: Daveed Vandevoorde Date: 2011-03-24

According to 14.6 [temp.res] paragraph 3,

> When a qualified-id is intended to refer to a type that is not a member of the current instantiation (14.6.2.1 [temp.dep.type]) and its nested-name-specifier refers to a dependent type, it shall be prefixed by the keyword `typename`, forming a typename-specifier. If the qualified-id in a typename-specifier does not denote a type, the program is ill- formed.

The intent of the programmer cannot form the basis for a compiler determining whether to issue a diagnostic or not.

Suggested resolution:

> Let `N` be a qualified-id with a nested-name-specifier that denotes a dependent type. If `N` is not prefixed by the keyword `typename`, `N` shall refer to a member of the current instantiation or it shall not refer to a type.

> typename-specifier:
> `typename` nested-name-specifier identifier
> `typename` nested-name-specifier `template` opt simple-template-id

> If the qualified-id in a typename-specifier does not denote a type, the program is ill-formed.

(See also issues 590 and 591.)

#### 591. When a dependent base class is the current instantiation

Section: 14.6.2 [temp.dep] Status: drafting Submitter: James Widman Date: 24 August 2006

Is the following example well-formed?

        template<class T> struct A {
             typedef int M;
             struct B {
                 typedef void M;
                 struct C;
             };
        };

        template<class T> struct A<T>::B::C : A<T> {
             M  // A<T>::M or A<T>::B::M?
                 p[2];
        };

14.6.2 [temp.dep] paragraph 3 says the use of `M` should refer to `A<T>::B::M` because the base class `A<T>` is not searched because it's dependent. But in this case `A<T>` is also the current instantiation (14.6.2.1 [temp.dep.type]) so it seems like it should be searched.

Notes from the August, 2011 meeting:

The recent changes to the handling of the current instantiation may have sufficiently addressed this issue.

Additional note (September, 2012):

See also issue 1526 for additional analysis demonstrating that this issue is still current despite the changes to the description of the current instantiation. The status has consequently been changed back to "open" for further consideration.

#### 1292. Dependent calls with braced-init-lists containing a pack expansion

Section: 14.6.2 [temp.dep] Status: drafting Submitter: James Widman Date: 2011-04-10

The discussion of issue 1233 revealed that the dependency of function calls involving a braced-init-list containing a pack expansion is not adequately addressed by the existing wording.

#### 1309. Incorrect note regarding lookup of a member of the current instantiation

Section: 14.6.2.1 [temp.dep.type] Status: drafting Submitter: Johannes Schaub Date: 2011-05-05

The note in 14.6.2.1 [temp.dep.type] paragraph 7 reads,

> [Note: the result of name lookup differs only when the member of the current instantiation was found in a non-dependent base class of the current instantiation and a member with the same name is also introduced by the substitution for a dependent base class of the current instantiation. —end note]

However, this is not correct. Consider the following example:

      struct Y { int X; };

      template<typename T>
      struct A : Y {
       enum B : int;
       void f() { A::X; } // finds Y::X here!
      };

      template<typename T>
      enum A<T>::B : int {
       X // introduces member A::X into A<T>!
      };

      void g() { A<int> a; a.f(); }

`A::X` is a member of the current instantiation, so paragraph 7 requires it to be looked up again when instantiating and to give a diagnostic if the lookup differs from the lookup in the definition context. The note incorrectly indicates that this can only happen if the conflicting name was introduced by a dependent base class.

Proposed resolution (August, 2011):

Change 14.6.2.1 [temp.dep.type] paragraph 7 as follows:

> ...If the result of this lookup differs from the result of name lookup in the template definition context, name lookup is ambiguous. [Note: the result of name lookup differs only when the member of the current instantiation was found in a non-dependent base class of the current instantiation and a member with the same name is also introduced by the substitution for a dependent base class of the current instantiation. —end note] [Example:

>       struct A {
>         int m;
>       };

>       struct B {
>         int m;
>       };

>       template<typename T>
>       struct C : A, T {
>         int f() { return this->m; } // finds A::m in the template definition context
>       };

>       int g(C<B> cb) {
>         return cb.f();              // error: finds both A::m and B::m in the template instantiation context
>       }

> —end example]

Notes from the December, 2011 teleconference:

Changes to the exposition were suggested and the issue returned to "drafting" status.

#### 1390. Dependency of alias template specializations

Section: 14.6.2.1 [temp.dep.type] Status: drafting Submitter: Johannes Schaub Date: 2011-09-04

According to 14.6.2.1 [temp.dep.type] paragraph 8, a type is dependent (among other things) if it is

- a simple-template-id in which either the template name is a template parameter or any of the template arguments is a dependent type or an expression that is type-dependent or value-dependent

This applies to alias template specializations, even if the resulting type does not depend on the template argument:

        struct B { typedef int type; };
        template<typename> using foo = B;
        template<typename T> void f() {
          foo<T>::type * x;  //error: typename required
        }

Is a change to the rules for cases like this warranted?

Notes from the October, 2012 meeting:

CWG agreed that no `typename` should be required in this case. In some ways, an alias template specialization is like the current instantiation and can be known at template definition time.

#### 1524. Incompletely-defined class template base

Section: 14.6.2.1 [temp.dep.type] Status: drafting Submitter: Jason Merrill Date: 2012-07-17

The correct handling of an example like the following is unclear:

      template<typename T> struct A {
        struct B: A { };
      };

A type used as a base must be complete (10 [class.derived] paragraph 2). The fact that the base class in this example is the current instantiation could be interpreted as indicating that it should be available for lookup, and thus the normal rule should apply, as members declared after the nested class would not be visible.

On the other hand, 14.6.2 [temp.dep] paragraph 3 says,

> In the definition of a class or class template, if a base class depends on a template-parameter, the base class scope is not examined during unqualified name lookup either at the point of definition of the class template or member or during an instantiation of the class template or member.

This wording refers not to a dependent type, which would permit lookup in the current instantiation, but simply to a type that “depends on a template-parameter,” and the current instantiation is such a type.

Implementations vary on the handling of this example.

(See also issue 1526 for another case related to the distinction between a “dependent type” and a “type that depends on a template-parameter.”)

Notes from the October, 2012 meeting:

CWG determined that the example should be ill-formed.

#### 1737. Type dependence of call to a member of the current instantiation

Section: 14.6.2.1 [temp.dep.type] Status: drafting Submitter: Richard Smith Date: 2013-08-14

Since we don't deduce the return type of a function temploid until it is instantiated, it seems that a call to such a function as a member of the current instantiation must have a dependent type, but 14.6.2.2 [temp.dep.expr] doesn't appear to say that. For example:

       template<typename T> struct X { typedef int type; };
       template<typename T> struct S {
         auto f() { return 0; }
         void g() {
           X<decltype(f())>::type x; // typename presumably needed here
         }
       }

Presumably there should be a bullet in 14.6.2.1 [temp.dep.type] paragraph 8 for this case.

#### 2. How can dependent names be used in member declarations that appear outside of the class template definition?

Section: 14.6.4 [temp.dep.res] Status: drafting Submitter: unknown Date: unknown

        template <class T> class Foo {

           public:
           typedef int Bar;
           Bar f();
        };
        template <class T> typename Foo<T>::Bar Foo<T>::f() { return 1;}
                           --------------------

In the class template definition, the declaration of the member function is interpreted as:

       int Foo<T>::f();

In the definition of the member function that appears outside of the class template, the return type is not known until the member function is instantiated. Must the return type of the member function be known when this out-of-line definition is seen (in which case the definition above is ill-formed)? Or is it OK to wait until the member function is instantiated to see if the type of the return type matches the return type in the class template definition (in which case the definition above is well-formed)?

Suggested resolution: (John Spicer)

My opinion (which I think matches several posted on the reflector recently) is that the out-of-class definition must match the declaration in the template. In your example they do match, so it is well formed.

I've added some additional cases that illustrate cases that I think either are allowed or should be allowed, and some cases that I don't think are allowed.

        template <class T> class A { typedef int X; };

        template <class T> class Foo {
         public:
           typedef int Bar;
           typedef typename A<T>::X X;
           Bar f();
           Bar g1();
           int g2();
           X h();
           X i();
           int j();
         };

         // Declarations that are okay
         template <class T> typename Foo<T>::Bar Foo<T>::f()
                                                         { return 1;}
         template <class T> typename Foo<T>::Bar Foo<T>::g1()
                                                         { return 1;}
         template <class T> int Foo<T>::g2() { return 1;}
         template <class T> typename Foo<T>::X Foo<T>::h() { return 1;}

         // Declarations that are not okay
         template <class T> int Foo<T>::i() { return 1;}
         template <class T> typename Foo<T>::X Foo<T>::j() { return 1;}

In general, if you can match the declarations up using only information from the template, then the declaration is valid.

Declarations like `Foo::i` and `Foo::j` are invalid because for a given instance of `A<T>`, `A<T>::X` may not actually be int if the class is specialized.

This is not a problem for `Foo::g1` and `Foo::g2` because for any instance of `Foo<T>` that is generated from the template you know that Bar will always be int. If an instance of `Foo` is specialized, the template member definitions are not used so it doesn't matter whether a specialization defines `Bar` as int or not.

#### 287. Order dependencies in template instantiation

Section: 14.6.4.1 [temp.point] Status: drafting Submitter: Martin Sebor Date: 17 May 2001

Implementations differ in their treatment of the following code:

        template <class T>
        struct A {
    	typename T::X x;
        };

        template <class T>
        struct B {
    	typedef T* X;
    	A<B> a;
        };

        int main ()
        {
    	B<int> b;
        }

Some implementations accept it. At least one rejects it because the instantiation of `A<B<int> >` requires that `B<int>` be complete, and it is not at the point at which `A<B<int> >` is being instantiated.

Erwin Unruh:

In my view the programm is ill-formed. My reasoning:

- you need a complete type `B<int>` because you declare a variable in `main`
- `B<int>` contains a member of type `A<B<int> >`, so you need that complete.
- `A<B<int> >` tries to access `B<int>::X`, which in turn needs `B<int>` being complete.

So each class needs the other to be complete.

The problem can be seen much easier if you replace the typedef with

        typedef T (*X) [sizeof(B::a)];

Now you have a true recursion. The compiler cannot easily distinguish between a true recursion and a potential recursion.

John Spicer:

Using a class to form a qualified name does not require the class to be complete, it only requires that the named member already have been declared. In other words, this kind of usage is permitted:

        class A {
            typedef int B;
            A::B ab;
        };

In the same way, once `B` has been declared in `A`, it is also visible to any template that uses `A` through a template parameter.

The standard could be more clear in this regard, but there are two notes that make this point. Both 3.4.3.1 [class.qual] and 5.1.1 [expr.prim.general] paragraph 7 contain a note that says "a class member can be referred to using a qualified-id at any point in its potential scope (3.3.7 [basic.scope.class])." A member's potential scope begins at its point of declaration.

In other words, a class has three states: incomplete, being completed, and complete. The standard permits a qualified name to be used once a name has been declared. The quotation of the notes about the potential scope was intended to support that.

So, in the original example, class `A` does not require the type of `T` to be complete, only that it have already declared a member `X`.

Bill Gibbons:

The template and non-template cases are different. In the non-template case the order in which the members become declared is clear. In the template case the members of the instantiation are conceptually all created at the same time. The standard does not say anything about trying to mimic the non-template case during the instantiation of a class template.

Mike Miller:

I think the relevant specification is 14.6.4.1 [temp.point] paragraph 3, dealing with the point of instantiation:

> For a class template specialization... if the specialization is implicitly instantiated because it is referenced from within another template specialization, if the context from which the specialization is referenced depends on a template parameter, and if the specialization is not instantiated previous to the instantiation of the enclosing template, the point of instantiation is immediately before the point of instantiation of the enclosing template. Otherwise, the point of instantiation for such a specialization immediately precedes the namespace scope declaration or definition that refers to the specialization.

That means that the point of instantiation of `A<B<int> >` is before that of `B<int>`, not in the middle of `B<int>` after the declaration of `B::X`, and consequently a reference to `B<int>::X` from `A<B<int> >` is ill-formed.

To put it another way, I believe John's approach requires that there be an instantiation stack, with the results of partially-instantiated templates on the stack being available to instantiations above them. I don't think the Standard mandates that approach; as far as I can see, simply determining the implicit instantiations that need to be done, rewriting the definitions at their respective points of instantiation with parameters substituted (with appropriate "forward declarations" to allow for non-instantiating references), and compiling the result normally should be an acceptable implementation technique as well. That is, the implicit instantiation of the example (using, e.g., `B_int` to represent the generated name of the `B<int>` specialization) could be something like

            struct B_int;

            struct A_B_int {
                B_int::X x;    // error, incomplete type
            };

            struct B_int {
                typedef int* X;
                A_B_int a;
            };

Notes from 10/01 meeting:

This was discussed at length. The consensus was that the template case should be treated the same as the non-template class case it terms of the order in which members get declared/defined and classes get completed.

Proposed resolution:

In 14.6.4.1 [temp.point] paragraph 3 change:

> the point of instantiation is immediately before the point of instantiation of the enclosing template. Otherwise, the point of instantiation for such a specialization immediately precedes the namespace scope declaration or definition that refers to the specialization.

To:

> the point of instantiation is the same as the point of instantiation of the enclosing template. Otherwise, the point of instantiation for such a specialization immediately precedes the nearest enclosing declaration. [Note: The point of instantiation is still at namespace scope but any declarations preceding the point of instantiation, even if not at namespace scope, are considered to have been seen.]

Add following paragraph 3:

> If an implicitly instantiated class template specialization, class member specialization, or specialization of a class template references a class, class template specialization, class member specialization, or specialization of a class template containing a specialization reference that directly or indirectly caused the instantiation, the requirements of completeness and ordering of the class reference are applied in the context of the specialization reference.

and the following example

      template <class T> struct A {
              typename T::X x;
      };

      struct B {
              typedef int X;
              A<B> a;
      };

      template <class T> struct C {
              typedef T* X;
              A<C> a;
      };

      int main ()
      {
              C<int> c;
      }

Notes from the October 2002 meeting:

This needs work. Moved back to drafting status.

See also issues 595 and 1330.

#### 1258. “Instantiation context” differs from dependent lookup rules

Section: 14.6.4.1 [temp.point] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-10

C++11 expanded the lookup rules for dependent function calls (14.6.4.2 [temp.dep.candidate] paragraph 1 bullet 2) to include functions with internal linkage; previously only functions with external linkage were considered. However, 14.6.4.1 [temp.point] paragraph 6 still says,

> The instantiation context of an expression that depends on the template arguments is the set of declarations with external linkage declared prior to the point of instantiation of the template specialization in the same translation unit.

Presumably this wording was overlooked and should be harmonized with the new specification.

#### 1253. Generic non-template members

Section: 14.7 [temp.spec] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-06

Many statements in the Standard apply only to templates, for example, 14.6 [temp.res] paragraph 8:

> If no valid specialization can be generated for a template definition, and that template is not instantiated, the template definition is ill-formed, no diagnostic required.

This clearly should apply to non-template member functions of class templates, not just to templates per se. Terminology should be established to refer to these generic entities that are not actually templates.

Additional notes (August, 2012):

Among the generic entities that should be covered by such a term are default function arguments, as they can be instantiated independently. If issue 1330 is resolved as expected, exception-specifications should also be covered by the same term.

See also issue 1484.

#### 212. Implicit instantiation is not described clearly enough

Section: 14.7.1 [temp.inst] Status: drafting Submitter: Christophe de Dinechin Date: 7 Mar 2000

Three points have been raised where the wording in 14.7.1 [temp.inst] may not be sufficiently clear.

1. In paragraph 4, the statement is made that

   > A class template specialization is implicitly instantiated... if the completeness of the class type affects the semantics of the program...

   It is not clear what it means for the "completeness... [to affect] the semantics." Consider the following example:

               template<class T> struct A;
               extern A<int> a;

               void *foo() { return &a; }

               template<class T> struct A
               {
               #ifdef OPTION
                       void *operator &() { return 0; }
               #endif
               };

   The question here is whether it is necessary for template class `A` to declare an `operator &` for the semantics of the program to be affected. If it does not do so, the meaning of `&a` will be the same whether the class is complete or not and thus arguably the semantics of the program are not affected.

   Presumably what was intended is whether the presence or absence of certain member declarations in the template class might be relevant in determining the meaning of the program. A clearer statement may be desirable.

2. Paragraph 5 says,

   > If the overload resolution process can determine the correct function to call without instantiating a class template definition, it is unspecified whether that instantiation actually takes place.

   The intent of this wording, as illustrated in the example in that paragraph, is to allow a "smart" implementation not to instantiate class templates if it can determine that such an instantiation will not affect the result of overload resolution, even though the algorithm described in clause 13 [over] requires that all the viable functions be enumerated, including functions that might be found as members of specializations.

   Unfortunately, the looseness of the wording allowing this latitude for implementations makes it unclear what "the overload resolution process" is — is it the algorithm in 13 [over] or something else? — and what "the correct function" is.

3. According to paragraph 6,

   > If an implicit instantiation of a class template specialization is required and the template is declared but not defined, the program is ill-formed.

   Here, it is not clear what conditions "require" an implicit instantiation. From the context, it would appear that the intent is to refer to the conditions in paragraph 4 that cause a specialization to be instantiated.

   This interpretation, however, leads to different treatment of template and non-template incomplete classes. For example, by this interpretation,

           class A;
           template <class T> struct TA;
           extern A a;
           extern TA<int> ta;

           void f(A*);
           void f(TA<int>*);

           int main()
           {
               f(&a);    // well-formed; undefined if A
                         // has operator &() member
               f(&ta);   // ill-formed: cannot instantiate
           }

   A different approach would be to understand "required" in paragraph 6 to mean that a complete type is required in the expression. In this interpretation, if an incomplete type is acceptable in the context and the class template definition is not visible, the instantiation is not attempted and the program is well-formed.

   The meaning of "required" in paragraph 6 must be clarified.

(See also issues 204 and 63.)

Notes on 10/01 meeting:

It was felt that item 1 is solved by addition of the word "might" in the resolution for issue 63; item 2 is not much of a problem; and item 3 could be solved by changing "required" to "required to be complete".

#### 1396. Deferred instantiation and checking of non-static data member initializers

Section: 14.7.1 [temp.inst] Status: drafting Submitter: Jason Merrill Date: 2011-09-22

Non-static data member initializers get the same late parsing as member functions and default arguments, but are they also instantiated as needed like them? And when is their validity checked?

Notes from the October, 2012 meeting:

CWG agreed that non-static data member initializers should be handled like default arguments.

Additional note (March, 2013):

Determining whether a defaulted constructor is `constexpr` or not requires parsing the class's non-static data member initializers; see also issue 1360.

#### 1665. Declaration matching in explicit instantiations

Section: 14.7.2 [temp.explicit] Status: drafting Submitter: Richard Smith Date: 2013-04-19

Consider a case like

      struct X {
        template<typename T> void f(T);
        void f(int);
      };
      template void X::f(int);

or

      template<typename T> void f(T) {}
      void f(int);
      template void f(int);

Presumably in both these cases the explicit instantiation should refer to the template and not to the non-template; however, 14.5.2 [temp.mem] paragraph 2 says,

> A normal (non-template) member function with a given name and type and a member function template of the same name, which could be used to generate a specialization of the same type, can both be declared in a class. When both exist, a use of that name and type refers to the non-template member unless an explicit template argument list is supplied.

This would appear to give the wrong answer for the first example. It's not clearly stated, but consistency would suggest a similar wrong answer for the second. Presumably a statement is needed somewhere that an explicit instantiation directive applies to a template and not a non-template function if both are visible.

#### 1704. Type checking in explicit instantiation of variable templates

Section: 14.7.2 [temp.explicit] Status: drafting Submitter: Richard Smith Date: 2013-06-20

It is not clear whether the following is well-formed or not:

      template<typename T> int arr[sizeof(T)] = {};
      template int arr<int>[];

Are we supposed to instantiate the specialization and treat the explicit instantiation declaration as if it were a redeclaration (in which case the omitted array bound would presumably be OK), or is the type of the explicit instantiation declaration required to exactly match the type that the instantiated specialization has (in which case the omitted bound would presumably not be OK)? Or something else?

(See also issue 1728.)

#### 1728. Type of an explicit instantiation of a variable template

Section: 14.7.2 [temp.explicit] Status: drafting Submitter: Larisse Voufo Date: 2013-08-05

It is not clear to what extent the type in an explicit instantiation must match that of a variable template. For example:

      template<typename T> T var = T();
      template float var<float>;   // #1.
      template int* var<int>;      // #2.
      template auto var<char>;     // #3.

(See also issue 1704.)

#### 529. Use of `template<>` with “explicitly-specialized” class templates

Section: 14.7.3 [temp.expl.spec] Status: drafting Submitter: James Widman Date: 16 August 2005

Paragraph 17 of 14.7.3 [temp.expl.spec] says,

> A member or a member template may be nested within many enclosing class templates. In an explicit specialization for such a member, the member declaration shall be preceded by a `template<>` for each enclosing class template that is explicitly specialized.

This is curious, because paragraph 3 only allows explicit specialization of members of implicitly-instantiated class specializations, not explicit specializations. Furthermore, paragraph 4 says,

> Definitions of members of an explicitly specialized class are defined in the same manner as members of normal classes, and not using the explicit specialization syntax.

Paragraph 18 provides a clue for resolving the apparent contradiction:

> In an explicit specialization declaration for a member of a class template or a member template that appears in namespace scope, the member template and some of its enclosing class templates may remain unspecialized, except that the declaration shall not explicitly specialize a class member template if its enclosing class templates are not explicitly specialized as well. In such explicit specialization declaration, the keyword `template` followed by a template-parameter-list shall be provided instead of the `template<>` preceding the explicit specialization declaration of the member.

It appears from this and the following example that the phrase “explicitly specialized” in paragraphs 17 and 18, when referring to enclosing class templates, does not mean that explicit specializations have been declared for them but that their names in the qualified-id are followed by template argument lists. This terminology is confusing and should be changed.

Proposed resolution (October, 2005):

1. Change 14.7.3 [temp.expl.spec] paragraph 17 as indicated:

> A member or a member template may be nested within many enclosing class templates. In an explicit specialization for such a member, the member declaration shall be preceded by a `template<>` for each enclosing class template that is explicitly specialized specialization. [Example:...

2. Change 14.7.3 [temp.expl.spec] paragraph 18 as indicated:

> In an explicit specialization declaration for a member of a class template or a member template that appears in namespace scope, the member template and some of its enclosing class templates may remain unspecialized, except that the declaration shall not explicitly specialize a class member template if its enclosing class templates are not explicitly specialized as well that is, the template-id naming the template may be composed of template parameter names rather than template-arguments. In For each unspecialized template in such an explicit specialization declaration, the keyword `template` followed by a template-parameter-list shall be provided instead of the `template<>` preceding the explicit specialization declaration of the member. The types of the template-parameters in the template-parameter-list shall be the same as those specified in the primary template definition. In such declarations, an unspecialized template-id shall not precede the name of a template specialization in the qualified-id naming the member. [Example:...

Notes from the April, 2006 meeting:

The revised wording describing “unspecialized” templates needs more work to ensure that the parameter names in the template-id are in the correct order; the distinction between template arguments and parameters is also probably not clear enough. It might be better to replace this paragraph completely and avoid the “unspecialized” wording altogether.

Proposed resolution (February, 2010):

1. Change 14.7.3 [temp.expl.spec] paragraph 17 as follows:

> A member or a member template may be nested within many enclosing class templates. In an explicit specialization for such a member, the member declaration shall be preceded by a `template<>` for each enclosing class template that is explicitly specialized specialization. [Example:...

2. Change 14.7.3 [temp.expl.spec] paragraph 18 as follows:

> In an explicit specialization declaration for a member of a class template or a member template that appears in namespace scope, the member template and some of its enclosing class templates may remain unspecialized, except that the declaration shall not explicitly specialize a class member template if its enclosing class templates are not explicitly specialized as well. In such explicit specialization declaration, the keyword `template` followed by a template-parameter-list shall be provided instead of the `template<>` preceding the explicit specialization declaration of the member. The types of the template-parameters in the template-parameter-list shall be the same as those specified in the primary template definition. that is, the corresponding template prefix may specify a template-parameter-list instead of `template<>` and the template-id naming the template be written using those template-parameters as template-arguments. In such a declaration, the number, kinds, and types of the template-parameters shall be the same as those specified in the primary template definition, and the template-parameters shall be named in the template-id in the same order that they appear in the template-parameter-list. An unspecialized template-id shall not precede the name of a template specialization in the qualified-id naming the member. [Example:...

#### 1391. Conversions to parameter types with non deduced template arguments

Section: 14.8.1 [temp.arg.explicit] Status: drafting Submitter: Jason Merrill Date: 2011-09-08

According to 14.8.1 [temp.arg.explicit] paragraph 6,

> Implicit conversions (Clause 4 [conv]) will be performed on a function argument to convert it to the type of the corresponding function parameter if the parameter type contains no template-parameters that participate in template argument deduction. [Note: Template parameters do not participate in template argument deduction if they are explicitly specified...

But this isn't clear about when these conversions are done. Consider

        template<class T> struct A {
           typename T::N n;
        };
        template<class T> struct B { };

        template<class T, class T2>
        void foo(const A<T>& r); // #1
        template<class T>
        void foo(const B<T>& r); // #2

        void baz() {
           B<char> b;
           foo(b); // OK
           foo<char>(b); // error
        }

With the explicit template argument, the first parameter of #1 no longer participates in template argument deduction, so implicit conversions are done. If we check for the implicit conversion during the deduction process, we end up instantiating `A<char>`, resulting in a hard error. If we wait until later to check the conversion, we can reject #1 because `T2` is not deduced and never need to consider the conversion.

But if we just accept the parameter and leave it up to normal overload resolution to reject an unsuitable candidate, that breaks this testcase:

        template<class T>
        struct A {
           typename T::N n;
        };

        template<class T>
        struct B { };

        template <class T, class... U>
        typename A<T>::value_t bar(int, T, U...);

        template <class T>
        T bar(T, T);

        void baz()
        {
           B<char> b;
           bar(b, b);
        }

Here, if deduction succeeds, we substitute in the deduced arguments of `T = B<char>, U = { }`, and end up instantiating `A<B<char>>`, which fails.

EDG and GCC currently reject the first testcase and accept the second; clang accepts both.

Notes from the October, 2012 meeting:

The position initially favored by CWG was that implicit conversions are not considered during deduction but are only applied afterwards, so the second example is ill-formed, and that the normative wording of the referenced paragraph should be moved into the note. This approach does not handle some examples currently accepted by some implementations, however; for example:

       template <class T> struct Z {
        typedef T::x xx;
       };
       template <class T> Z<T>::xx f(void *, T);
       template <class T> void f(int, T);
       struct A {} a;
       int main() {
         f(1, a); // If the implementation rules out the first overload
                  // because of the invalid conversion from int to void*,
                  // the error instantiating Z<A> will be avoided
       }

Additional discussion is required.

Notes from the April, 2013 meeting:

The approach needed to accept this code appears to be doing the convertibility check between deduction and substitution.

#### 1172. “instantiation-dependent” constructs

Section: 14.8.2 [temp.deduct] Status: drafting Submitter: Adamczyk Date: 2010-08-05

There are certain constructs that are not covered by the existing categories of “type dependent” and “value dependent.” For example, the expression `sizeof(sizeof(T()))` is neither type-dependent nor value-dependent, but its validity depends on whether `T` can be value-constructed. We should be able to overload on such characteristics and select via deduction failure, but we need a term like “instantiation-dependent” to describe these cases in the Standard. The phrase “expression involving a template parameter” seems to come pretty close to capturing this idea.

Notes from the November, 2010 meeting:

The CWG favored extending the concepts of “type-dependent” and “value-dependent” to cover these additional cases, rather than adding a new concept.

Notes from the March, 2011 meeting:

The CWG reconsidered the direction from the November, 2010 meeting, as it would make more constructs dependent, thus requiring more `template` and `typename` keywords, resulting in worse error messages, etc.

Notes from the August, 2011 meeting:

The following example (from issue 1273) was deemed relevant for this issue:

        template <class T> struct C;

        class A {
           int i;
           friend struct C<int>;
        } a;

        class B {
           int i;
           friend struct C<float>;
        } b;

        template <class T>
        struct C {
           template <class U> decltype (a.i) f() { } // #1
           template <class U> decltype (b.i) f() { } // #2
        };

        int main() {
           C<int>().f<int>();     // calls #1
           C<float>().f<float>(); // calls #2
        }

#### 1322. Function parameter type decay in templates

Section: 14.8.2 [temp.deduct] Status: drafting Submitter: Jason Merrill Date: 2011-05-19

The discussion of issue 1001 seemed to have settled on the approach of doing the 8.3.5 [dcl.fct] transformations immediately to the function template declaration, so that the original form need not be remembered. However, the example in 14.8.2 [temp.deduct] paragraph 8 suggests otherwise:

      template <class T> int f(T[5]);
      int I = f<int>(0);
      int j = f<void>(0); // invalid array

One way that might be addressed would be to separate the concepts of the type of the template that participates in overload resolution and function matching from the type of the template that is the source for template argument substitution. (See also the example in paragraph 3 of the same section.)

Notes, January, 2012:

#### 1582. Template default arguments and deduction failure

Section: 14.8.2 [temp.deduct] Status: drafting Submitter: John Spicer Date: 2012-10-31

According to 14.8.2 [temp.deduct] paragraph 5,

> The resulting substituted and adjusted function type is used as the type of the function template for template argument deduction. If a template argument has not been deduced and its corresponding template parameter has a default argument, the template argument is determined by substituting the template arguments determined for preceding template parameters into the default argument. If the substitution results in an invalid type, as described above, type deduction fails.

This leaves the impression that default arguments are used after deduction failure leaves an argument undeduced. For example,

      template<typename T> struct Wrapper;
      template<typename T = int> void f(Wrapper<T>*);
      void g() {
        f(0);
      }

Deduction fails for `T`, so presumably `int` is used. However, some implementations reject this code. It appears that the intent would be better expressed as something like

> ...If a template argument is used only in a non-deduced context and its corresponding template parameter has a default argument...

#### 1724. Unclear rules for deduction failure

Section: 14.8.2 [temp.deduct] Status: drafting Submitter: James Widman Date: 2013-07-31

According to 14.8.2 [temp.deduct] paragraph 8,

> If a substitution results in an invalid type or expression, type deduction fails. An invalid type or expression is one that would be ill-formed, with a diagnostic required, if written using the substituted arguments.

Presumably the phrase “if written” refers to rewriting the template declaration in situ with the substituted arguments, rather than writing that type or expression at some arbitrary location, e.g.,

      void g(double) = delete;

      template<class T> auto f(T t) -> decltype(g(t));

      void g(int);

      void h() {
        typedef int T;
        T t = 42;
        g(t);  // Ok (I “wrote the substituted arguments”, and it seems fine)
        f(42); // Presumably substitution is meant to fail.
      }

Perhaps a clearer formulation could be used?

#### 1513. `initializer_list` deduction failure

Section: 14.8.2.1 [temp.deduct.call] Status: drafting Submitter: Steve Adamczyk Date: 2012-06-28

According to 14.8.2.1 [temp.deduct.call] paragraph 1,

> If removing references and cv-qualifiers from `P` gives `std::initializer_list<P'>` for some `P'` and the argument is an initializer list (8.5.4 [dcl.init.list]), then deduction is performed instead for each element of the initializer list, taking `P'` as a function template parameter type and the initializer element as its argument. Otherwise, an initializer list argument causes the parameter to be considered a non-deduced context (14.8.2.5 [temp.deduct.type]).

It is not entirely clear whether the deduction for an initializer list meeting a `std::initializer_list<T>` is a recursive subcase, or part of the primary deduction. A relevant question is: if the deduction on that part fails, does the entire deduction fail, or is the parameter to be considered non-deduced?

Notes from the October, 2012 meeting:

CWG determined that the entire deduction fails in this case.

#### 1591. Deducing array bound and element type from initializer list

Section: 14.8.2.1 [temp.deduct.call] Status: drafting Submitter: Peter Dimov Date: 2012-12-01

Currently, 14.8.2.1 [temp.deduct.call] paragraph 1 says,

> Template argument deduction is done by comparing each function template parameter type (call it `P`) with the type of the corresponding argument of the call (call it `A`) as described below. If removing references and cv-qualifiers from `P` gives `std::initializer_list<`P'`>` for some P' and the argument is an initializer list (8.5.4 [dcl.init.list]), then deduction is performed instead for each element of the initializer list, taking P' as a function template parameter type and the initializer element as its argument. Otherwise, an initializer list argument causes the parameter to be considered a non-deduced context (14.8.2.5 [temp.deduct.type]).

It would seem reasonable, however, to allow an array bound to be deduced from the number of elements in the initializer list, e.g.,

      template<int N> void g(int const (&)[N]);
      void f() {
        g( { 1, 2, 3, 4 } );
      }

Additional note (March, 2013):

The element type should also be deducible.

#### 1486. Base-derived conversion in member pointer deduction

Section: 14.8.2.2 [temp.deduct.funcaddr] Status: drafting Submitter: John Spicer Date: 2012-03-26

The rules for deducing template arguments when taking the address of a function template in 14.8.2.2 [temp.deduct.funcaddr] do not appear to allow for a base-to-derived conversion in a case like:

      struct Base {
        template<class U> void f(U);
      };

      struct Derived : Base { };

      int main() {
        void (Derived::*pmf)(int) = &Derived::f;
      }

Most implementations appear to allow this adjustment, however.

#### 1610. Cv-qualification in deduction of reference to array

Section: 14.8.2.4 [temp.deduct.partial] Status: drafting Submitter: Richard Smith Date: 2013-01-28

Given

       template<class C> void foo(const C* val) {}
       template<int N> void foo(const char (&t)[N]) {}

it is intuitive that the second template is more specialized than the first. However, the current rules make them unordered. In 14.8.2.4 [temp.deduct.partial] paragraph 4, we have P as `const C*` and A as `const char (&)[N]`. Paragraph 5 transforms A to `const char[N]`. Finally, paragraph 7 removes top-level cv-qualification; since a cv-qualified array element type is considered to be cv-qualification of the array (3.9.3 [basic.type.qualifier] paragraph 5, cf issue 1059), A becomes `char[N]`. P remains `const C*`, so deduction fails because of the missing `const` in A.

Notes from the April, 2013 meeting:

CWG agreed that the `const` should be preserved in the array type.

#### 1395. Partial ordering of variadic templates reconsidered

Section: 14.8.2.5 [temp.deduct.type] Status: drafting Submitter: John Spicer Date: 2011-09-21

The resolution of issue 692 (found in document N3281) made the following example ambiguous and thus ill-formed:

        template<class T>
        void print(ostream &os, const T &t) {
            os << t;
        }

        template <class T, class... Args>
        void print(ostream &os, const T &t, const Args&... rest) {
            os << t << ", ";
            print(os, rest...);
        }

        int main() {
            print(cout, 42);
            print(cout, 42, 1.23);
        }

This pattern seems fairly intuitive; is it reason to reconsider or modify the outcome of issue 692?

(See also issue 1432.)

Notes from the October, 2012 meeting:

CWG agreed that the example should be accepted, handling this case as a late tiebreaker, preferring an omitted parameter over a parameter pack.

Additional note (March, 2013):

For another example:

      template<typename ...T> int f(T*...) {
        return 1;
      }
      template<typename T> int f(const T&) {
        return 2;
      }
      int main() {
        if (f((int*)0) != 1) {
           return 1;
        }
        return 0;
      }

This worked as expected prior to the resolution of issue 692.

#### 1436. Interaction of constant expression changes with preprocessor expressions

Section: 16.1 [cpp.cond] Status: drafting Submitter: Richard Smith Date: 2012-01-02

It appears that some of the recent changes to the description of constant expressions have allowed constructs into preprocessor expressions that do not belong there. Some changes are required to restrict the current capabilities of constant expressions to what is intended to be allowed in preprocessor expressions.

Proposed resolution (February, 2012):

1. Change 16.1 [cpp.cond] paragraph 2 as follows:

> Each preprocessing token that remains (in the list of preprocessing tokens that will become the controlling expression) after all macro replacements have occurred shall be in the lexical form of a token (2.7 [lex.token]). Any such token that is a literal (2.14.1 [lex.literal.kinds]) shall be an integer-literal, a character-literal, or a boolean-literal.

2. Change 16.1 [cpp.cond] paragraph 4 as follows:

> ...using arithmetic that has at least the ranges specified in 18.3 [support.limits]. The only operators permitted in the controlling constant expression are `?:`, `||`, `&&`, `|`, `^`, `&`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `<<`, `>>`, `-`, `+`, `*`, `/`, `%`, `!`, and `~`. For the purposes of this token conversion...

#### 1335. Stringizing, extended characters, and universal-character-names

Section: 16.3.2 [cpp.stringize] Status: drafting Submitter: Johannes Schaub Date: 2011-07-03

When a string literal containing an extended character is stringized (16.3.2 [cpp.stringize]), the result contains a universal-character-name instead of the original extended character. The reason is that the extended character is translated to a universal-character-name in translation phase 1 (2.2 [lex.phases]), so that the string literal `"@"` (where `@` represents an extended character) becomes `"\uXXXX"`. Because the preprocessing token is a string literal, when the stringizing occurs in translation phase 4, the `\` is doubled, and the resulting string literal is `"\"\\uXXXX\""`. As a result, the universal-character-name is not recognized as such when the translation to the execution character set occurs in translation phase 5. (Note that phase 5 translation does occur if the stringized extended character does not appear in a string literal.) Existing practice appears to ignore these rules and preserve extended characters in stringized string literals, however.

See also issue 578.

Additional note (August, 2013):

Implementations are granted substantial latitude in their handling of extended characters and universal-character-names in 2.2 [lex.phases] paragraph 1 phase 1, i.e.,

> (An implementation may use any internal encoding, so long as an actual extended character encountered in the source file, and the same extended character expressed in the source file as a universal-character-name (i.e., using the `\uXXXX` notation), are handled equivalently except where this replacement is reverted in a raw string literal.)

However, this freedom is mostly nullified by the requirements of stringizing in 16.3.2 [cpp.stringize] paragraph 2:

> If, in the replacement list, a parameter is immediately preceded by a `#` preprocessing token, both are replaced by a single character string literal preprocessing token that contains the spelling of the preprocessing token sequence for the corresponding argument.

This means that, in order to handle a construct like

      #define STRINGIZE_LITERAL( X ) # X
      #define STRINGIZE( X ) STRINGIZE_LITERAL( X )

      STRINGIZE( STRINGIZE( identifier_\u00fC\U000000Fc ) )

an implementation must recall the original spelling, including the form of UCN and the capitalization of any non-numeric hexadecimal digits, rather than simply translating the characters into a convenient internal representation.

To effect the freedom asserted in 2.2 [lex.phases], the description of stringizing should make the spelling of a universal-character-name implementation-defined.

#### 1709. Stringizing raw string literals containing newline

Section: 16.3.2 [cpp.stringize] Status: drafting Submitter: David Krauss Date: 2013-07-01

Stringizing a raw string literal containing a newline produces an invalid (unterminated) string literal and hence results in undefined behavior. It should be specified that a newline in a string literal is transformed to the two characters `'\' 'n'` in the resulting string literal.

A slightly related case involves stringizing a bare backslash character: because backslashes are only escaped within a string or character literal, a stringized bare backslash becomes `"\"`, which is invalid and hence results in undefined behavior.

#### 1279. Additional differences between C++ 2003 and C++ 2011

Section: C.2 [diff.cpp03] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-27

A number of differences between C++03 and C++11 were omitted from C.2 [diff.cpp03]:

- New keywords. Although these are said in C.2.1 [diff.cpp03.lex] only to invalidate C++03 code, they can also change the meaning, e.g., `thread_local x(y)`, which would declare a variable `thread_local` initialized with `y` in C++03 and a thread-local variable `y` in C++11.

- New deduction rules.

- Removal of the deprecated string literal conversion.

- When a `friend` function defined in a class template is actually defined (i.e., with each instantiation or only when odr-used).

- Removal of access declarations.

- Use of the injected-class-name of a class template as a template template-argument.

Additional note (January, 2012):

In addition to the items previously mentioned, access declarations were removed from C++11 but are not mentioned in C.2 [diff.cpp03].

Proposed (partial) resolution (February, 2012):

Add the following as a new section in C.2 [diff.cpp03]:

> C.2.5 Clause 11 [class.access]: member access control | pdiff.cpp03.class.access

> Change: Remove access declarations.

> Rationale: Removal of feature deprecated since C++ 1998.

> Effect on original feature: Valid C++ 2003 code that uses access declarations is ill-formed in this International Standard. Instead, using-declarations (7.3.3 [namespace.udecl]) can be used.

### Issues with "Open" Status

#### 916. Does a reference type have a destructor?

Section: _N2914_.14.10.2.1 [concept.map.fct] Status: open Submitter: James Widman Date: 12 June, 2009

Is the following well-formed?

        auto concept HasDestructor<typename T> {
          T::~T();
        }

        concept_map HasDestructor<int&> { }

According to _N2914_.14.10.2.1 [concept.map.fct] paragraph 4, the destructor requirement in the concept map results in an expression `x.~X()`, where `X` is the type `int&`. According to 5.2.4 [expr.pseudo], this expression is ill-formed because the object type and the type-name must be the same type, but the object type cannot be a reference type (references are dropped from types used in expressions, 5 [expr] paragraph 5).

It is not clear whether this should be addressed by changing 5.2.4 [expr.pseudo] or _N2914_.14.10.2.1 [concept.map.fct].

#### 783. Definition of “argument”

Section: 1.3 [intro.defs] Status: open Submitter: UK Date: 3 March, 2009
N2800 comment UK 3

The definition of an argument does not seem to cover many assumed use cases, and we believe that is not intentional. There should be answers to questions such as: Are lambda-captures arguments? Are type names in a throw-spec arguments? “Argument” to casts, typeid, alignof, alignas, decltype and sizeof? why in x[arg] arg is not an argument, but the value forwarded to operator[]() is? Does not apply to operators as call-points not bounded by parentheses? Similar for copy initialization and conversion? What are deduced template “arguments?” what are “default arguments?” can attributes have arguments? What about concepts, requires clauses and concept_map instantiations? What about user-defined literals where parens are not used?

#### 949. Requirements for freestanding implementations

Section: 1.4 [intro.compliance] Status: open Submitter: Detlef Vollman Date: 2 August, 2009

According to 1.4 [intro.compliance] paragraph 7,

> A freestanding implementation is one in which execution may take place without the benefit of an operating system, and has an implementation-defined set of libraries that includes certain language-support libraries (17.6.1.3 [compliance]).

This definition links two relatively separate topics: the lack of an operating system and the minimal set of libraries. Furthermore, 3.6.1 [basic.start.main] paragraph 1 says:

> [Note: in a freestanding environment, start-up and termination is implementation-defined; start-up contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration. —end note]

It would be helpful if the two characteristics (lack of an operating system and restricted set of libraries) were named separately and if these statements were clarified to identify exactly what is implementation-defined.

Notes from the October, 2009 meeting:

The CWG felt that it needed a specific proposal in a paper before attempting to resolve this issue.

#### 698. The definition of “sequenced before” is too narrow

Section: 1.9 [intro.execution] Status: open Submitter: Jens Maurer Date: 13 July, 2008

According to 1.9 [intro.execution] paragraph 14, “sequenced before” is a relation between “evaluations.” However, 3.6.3 [basic.start.term] paragraph 3 says,

> If the completion of the initialization of a non-local object with static storage duration is sequenced before a call to `std::atexit` (see `<cstdlib>`, 18.5 [support.start.term]), the call to the function passed to `std::atexit` is sequenced before the call to the destructor for the object. If a call to `std::atexit` is sequenced before the completion of the initialization of a non-local object with static storage duration, the call to the destructor for the object is sequenced before the call to the function passed to `std::atexit`. If a call to `std::atexit` is sequenced before another call to `std::atexit`, the call to the function passed to the second `std::atexit` call is sequenced before the call to the function passed to the first `std::atexit` call.

Except for the calls to `std::atexit`, these events do not correspond to “evaluation” of expressions that appear in the program. If the “sequenced before” relation is to be applied to them, a more comprehensive definition is needed.

#### 578. Phase 1 replacement of characters with universal-character-names

Section: 2.2 [lex.phases] Status: open Submitter: Martin Vejnár Date: 7 May 2006

According to 2.2 [lex.phases] paragraph 1, in translation phase 1,

> Any source file character not in the basic source character set (2.3 [lex.charset]) is replaced by the universal-character-name that designates that character.

If a character that is not in the basic character set is preceded by a backslash character, for example

        "\á"

the result is equivalent to

        "\\u00e1"

that is, a backslash character followed by the spelling of the universal-character-name. This is different from the result in C99, which accepts characters from the extended source character set without replacing them with universal-character-names.

See also issue 1335.

#### 1698. Files ending in `\`

Section: 2.2 [lex.phases] Status: open Submitter: David Krauss Date: 2013-06-10

The description of how to handle file not ending in a newline in 2.2 [lex.phases] paragraph 1, phase 2, is:

2. Each instance of a backslash character (`\`) immediately followed by a new-line character is deleted, splicing physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. If, as a result, a character sequence that matches the syntax of a universal-character-name is produced, the behavior is undefined. A source file that is not empty and that does not end in a new-line character, or that ends in a new-line character immediately preceded by a backslash character before any such splicing takes place, shall be processed as if an additional new-line character were appended to the file.

This is not clear regarding what happens if the last character in the file is a backslash. In such a case, presumably the result of adding the newline should not be a line splice but rather a backslash preprocessing-token (that will be diagnosed as an invalid token in phase 7), but that should be spelled out.

#### 1403. Universal-character-names in comments

Section: 2.8 [lex.comment] Status: open Submitter: David Krauss Date: 2011-10-05

According to 2.3 [lex.charset] paragraph 2,

> If the hexadecimal value for a universal-character-name corresponds to a surrogate code point (in the range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally, if the hexadecimal value for a universal-character-name outside the c-char-sequence, s-char-sequence, or r-char-sequence of a character or string literal corresponds to a control character (in either of the ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the basic source character set, the program is ill-formed.

These restrictions should not apply to comment text. Arguably the prohibitions of control characters and characters in the basic character set already do not apply, as they require that the preprocessing tokens for literals have already been recognized; this occurs in phase 3, which also replaces comments with single spaces. However, the prohibition of surrogate code points is not so limited and might conceivably be applied within comments.

Probably the most straightforward way of addressing this problem would be simply to state in 2.8 [lex.comment] that character sequences that resemble universal-character-names are not recognized as such within comment text.

#### 411. Use of universal-character-name in character versus string literals

Section: 2.14.5 [lex.string] Status: open Submitter: James Kanze Date: 23 Apr 2003

2.14.5 [lex.string] paragraph 5 reads

> Escape sequences and universal-character-names in string literals have the same meaning as in character literals, except that the single quote ' is representable either by itself or by the escape sequence \', and the double quote " shall be preceded by a \. In a narrow string literal, a universal-character-name may map to more than one char element due to multibyte encoding.

The first sentence refers us to 2.14.3 [lex.ccon], where we read in the first paragraph that "An ordinary character literal that contains a single c-char has type char [...]." Since the grammar shows that a universal-character-name is a c-char, something like '\u1234' must have type char (and thus be a single char element); in paragraph 5, we read that "A universal-character-name is translated to the encoding, in the execution character set, of the character named. If there is no such encoding, the universal-character-name is translated to an implemenation-defined encoding."

This is in obvious contradiction with the second sentence. In addition, I'm not really clear what is supposed to happen in the case where the execution (narrow-)character set is UTF-8. Consider the character \u0153 (the oe in the French word oeuvre). Should '\u0153' be a char, with an "error" value, say '?' (in conformance with the requirement that it be a single char), or an int, with the two char values 0xC5, 0x93, in an implementation defined order (in conformance with the requirement that a character representable in the execution character set be represented). Supposing the former, should "\u0153" be the equivalent of "?" (in conformance with the first sentence), or "\xC5\x93" (in conformance with the second).

Notes from October 2003 meeting:

We decided we should forward this to the C committee and let them resolve it. Sent via e-mail to John Benito on November 14, 2003.

Reply from John Benito:

> I talked this over with the C project editor, we believe this was handled by the C committee before publication of the current standard.

> WG14 decided there needed to be a more restrictive rule for one-to-one mappings: rather than saying "a single c-char" as C++ does, the C standard says "a single character that maps to a single-byte execution character"; WG14 fully expect some (if not many or even most) UCNs to map to multiple characters.

> Because of the fundamental differences between C and C++ character types, I am not sure the C committee is qualified to answer this satisfactorily for WG21. WG14 is willing to review any decision reached for compatibility.

> I hope this helps.

(See also issue 912 for a related question.)

#### 1266. user-defined-integer-literal overflow

Section: 2.14.8 [lex.ext] Status: open Submitter: Michael Wong Date: 2011-03-20

The decimal-literal in a user-defined-integer-literal might be too large for an `unsigned long long` to represent (in implementations with extended integer types). In such cases, the original intent appears to have been to call a raw literal operator or a literal operator template; however, the existing wording of 2.14.8 [lex.ext] paragraph 3 always calls the `unsigned long long` literal operator if it exists, regardless of the value of the decimal-literal.

#### 1209. Is a potentially-evaluated expression in a template definition a “use?”

Section: 3.2 [basic.def.odr] Status: open Submitter: Johannes Schaub Date: 2010-10-08

Consider the following complete program:

        void f();
        template<typename T> void g() { f(); }
        int main() { }

Must `f()` be defined to make this program well-formed? The current wording of 3.2 [basic.def.odr] does not make any special provision for expressions that appear only in uninstantiated template definitions.

(See also issue 1254.)

#### 191. Name lookup does not handle complex nesting

Section: 3.4.1 [basic.lookup.unqual] Status: open Submitter: Alan Nash Date: 29 Dec 1999

The current description of unqualified name lookup in 3.4.1 [basic.lookup.unqual] paragraph 8 does not correctly handle complex cases of nesting. The Standard currently reads,

> A name used in the definition of a function that is a member function (9.3) of a class `X` shall be declared in one of the following ways:
> - before its use in the block in which it is used or in an enclosing block (6.3), or
> - shall be a member of class `X` or be a member of a base class of `X` (10.2), or
> - if `X` is a nested class of class `Y` (9.7), shall be a member of `Y`, or shall be a member of a base class of `Y` (this lookup applies in turn to `Y`'s enclosing classes, starting with the innermost enclosing class), or
> - if `X` is a local class (9.8) or is a nested class of a local class, before the definition of class `X` in a block enclosing the definition of class `X`, or
> - if `X` is a member of namespace `N`, or is a nested class of a class that is a member of `N`, or is a local class or nested class within a local class of a function that is a member of `N`, before the member function definition, in namespace `N` or in one of `N`'s enclosing namespaces.

In particular, this formulation does not handle the following example:

        struct outer {
            static int i;
            struct inner {
                void f() {
                    struct local {
                        void g() {
                            i = 5;
                        }
                    };
                }
            };
        };

Here the reference to `i` is from a member function of a local class of a member function of a nested class. Nothing in the rules allows `outer::i` to be found, although intuitively it should be found.

A more comprehensive formulation is needed that allows traversal of any combination of blocks, local classes, and nested classes. Similarly, the final bullet needs to be augmented so that a function need not be a (direct) member of a namespace to allow searching that namespace when the reference is from a member function of a class local to that function. That is, the current rules do not allow the following example:

        int j;    // global namespace
        struct S {
            void f() {
                struct local2 {
                    void g() {
                        j = 5;
                    }
                };
            }
        };

#### 405. Unqualified function name lookup

Section: 3.4.1 [basic.lookup.unqual] Status: open Submitter: William M. Miller Date: 14 Apr 2003

There seems to be some confusion in the Standard regarding the relationship between 3.4.1 [basic.lookup.unqual] (Unqualified name lookup) and 3.4.2 [basic.lookup.argdep] (Argument-dependent lookup). For example, 3.4.1 [basic.lookup.unqual] paragraph 3 says,

> The lookup for an unqualified name used as the postfix-expression of a function call is described in 3.4.2 [basic.lookup.argdep].

In other words, nothing in 3.4.1 [basic.lookup.unqual] applies to function names; the entire lookup is described in 3.4.2 [basic.lookup.argdep].

3.4.2 [basic.lookup.argdep] does not appear to share this view of its responsibility. The closest it comes is in 3.4.2 [basic.lookup.argdep] paragraph 2a:

> ...the set of declarations found by the lookup of the function name is the union of the set of declarations found using ordinary unqualified lookup and the set of declarations found in the namespaces and classes associated with the argument types.

Presumably, "ordinary unqualified lookup" is a reference to the processing described in 3.4.1 [basic.lookup.unqual], but, as noted above, 3.4.1 [basic.lookup.unqual] explicitly precludes applying that processing to function names. The details of "ordinary unqualified lookup" of function names are not described anywhere.

The other clauses that reference 3.4.2 [basic.lookup.argdep], clauses 13 [over] and 14 [temp], are split over the question of the relationship between 3.4.1 [basic.lookup.unqual] and 3.4.2 [basic.lookup.argdep]. 13.3.1.1.1 [over.call.func] paragraph 3, for instance, says

> The name is looked up in the context of the function call following the normal rules for name lookup in function calls (3.4.2 [basic.lookup.argdep]).

I.e., this reference assumes that 3.4.2 [basic.lookup.argdep] is self-contained. The same is true of 13.3.1.2 [over.match.oper] paragraph 3, second bullet:

> The set of non-member candidates is the result of the unqualified lookup of operator@ in the context of the expression according to the usual rules for name lookup in unqualified function calls (3.4.2 [basic.lookup.argdep]), except that all member functions are ignored.

On the other hand, however, 14.6.4.2 [temp.dep.candidate] paragraph 1 explicitly assumes that 3.4.1 [basic.lookup.unqual] and 3.4.2 [basic.lookup.argdep] are both involved in function name lookup and do different things:

> For a function call that depends on a template parameter, if the function name is an unqualified-id but not a template-id, the candidate functions are found using the usual lookup rules (3.4.1 [basic.lookup.unqual], 3.4.2 [basic.lookup.argdep]) except that:
> - For the part of the lookup using unqualified name lookup (3.4.1 [basic.lookup.unqual]), only function declarations with external linkage from the template definition context are found.
> - For the part of the lookup using associated namespaces (3.4.2 [basic.lookup.argdep]), only function declarations with external linkage found in either the template definition context or the template instantiation context are found.

Suggested resolution:

Change 3.4.1 [basic.lookup.unqual] paragraph 1 from

> ...name lookup ends as soon as a declaration is found for the name.

to

> ...name lookup ends with the first scope containing one or more declarations of the name.

Change the first sentence of 3.4.1 [basic.lookup.unqual] paragraph 3 from

> The lookup for an unqualified name used as the postfix-expression of a function call is described in 3.4.2 [basic.lookup.argdep].

to

> An unqualified name used as the postfix-expression of a function call is looked up as described below. In addition, argument-dependent lookup (3.4.2 [basic.lookup.argdep]) is performed on this name to complete the resulting set of declarations.

#### 1200. Lookup rules for template parameters

Section: 3.4.1 [basic.lookup.unqual] Status: open Submitter: Johannes Schaub Date: 2010-09-18

Although 3.3.9 [basic.scope.temp] now describes the scope of a template parameter, the description of unqualified name lookup in 3.4.1 [basic.lookup.unqual] do not cover uses of template parameter names. The note in 3.4.1 [basic.lookup.unqual] paragraph 16 says,

> the rules for name lookup in template definitions are described in 14.6 [temp.res].

but the rules there cover dependent and non-dependent names, not template parameters themselves.

#### 1753. decltype-specifier in nested-name-specifier of destructor

Section: 3.4.3 [basic.lookup.qual] Status: open Submitter: John Spicer Date: 2013-09-18

One of the forms of pseudo-destructor-name is

nested-name-specifieropt `~` type-name

Presumably the intent of this form is to allow the nested-name-specifier to designate a namespace; otherwise the

nested-name-specifieropt type-name `:: ~` type-name

production would be used.

Since one of the forms of nested-name-specifier is

decltype-specifier `::`

one can write something like `p->decltype(x)::~Y()`. However, the lookup rules in 3.4.3 [basic.lookup.qual] paragraph 6 are inappropriate for the decltype-specifier case:

> If a pseudo-destructor-name (5.2.4 [expr.pseudo]) contains a nested-name-specifier, the type-names are looked up as types in the scope designated by the nested-name-specifier.

Since this form appears to be useless (use of a decltype-specifier is permitted after a `~`, but only with no nested-name-specifer — but see issue 1586), perhaps it should be made ill-formed.

#### 1771. Restricted lookup in nested-name-specifier

Section: 3.4.3 [basic.lookup.qual] Status: open Submitter: Canada Date: 2013-09-24
N3690 comment CA 21

Consider the following example:

      template <typename T> struct B { };
      namespace N {
        namespace L {
          template <int> void A();
        }
        namespace M {
          template <int> struct A { typedef int y; };
        }
        using namespace L;
        using namespace M;
      }
      B<N::/*template */A<0>::y> (x);

Which `A` is referenced in the last line? According to 3.4.3 [basic.lookup.qual] paragraph 1,

> If a `::` scope resolution operator in a nested-name-specifier is not preceded by a decltype-specifier, lookup of the name preceding that `::` considers only namespaces, types, and templates whose specializations are types.

It is not clear whether this applies to the example or not, and the interpretation of the `<` token depends on the result of the lookup.

Notes from the September, 2013 meeting:

The restricted lookup mentioned in 3.4.3 [basic.lookup.qual] paragraph 1 is based on a one-token lookahead; because the next token following `A` in the example is not `::`, the restricted lookup does not apply, and the result is ambiguous. Uncommenting the `template` keyword in the example does not affect the lookup.

#### 562. qualified-ids in non-expression contexts

Section: 3.4.3.1 [class.qual] Status: open Submitter: Mike Miller Date: 6 April 2006

Both 3.4.3.1 [class.qual] and 3.4.3.2 [namespace.qual] specify that some lookups are to be performed “in the context of the entire postfix-expression,” ignoring the fact that qualified-ids can appear outside of expressions.

It was suggested in document J16/05-0156 = WG21 N1896 that these uses be changed to “the context in which the qualified-id occurs,” but it isn't clear that this formulation adequately covers all the places a qualified-id can occur.

#### 278. External linkage and nameless entities

Section: 3.5 [basic.link] Status: open Submitter: Daveed Vandevoorde Date: 12 Apr 2000

It is unclear to what extent entities without names match across translation units. For example,

        struct S {
           int :2;
           enum { a, b, c } x;
           static class {} *p;
        };

If this declaration appears in multiple translation units, are all these members "the same" in each declaration?

A similar question can be asked about non-member declarations:

        // Translation unit 1:
        extern enum { d, e, f } y;

        // Translation unit 2:
        extern enum { d, e, f } y;

        // Translation unit 3:
        enum { d, e, f } y;

Is this valid C++? Is it valid C?

James Kanze: `S::p` cannot be defined, because to do so requires a type specifier and the type cannot be named. `::y` is valid C because C only requires compatible, not identical, types. In C++, it appears that there is a new type in each declaration, so it would not be valid. This differs from `S::x` because the unnamed type is part of a named type — but I don't know where or if the Standard says that.

John Max Skaller: It's not valid C++, because the type is a synthesised, unique name for the enumeration type which differs across translation units, as if:

        extern enum _synth1 { d,e,f} y;
        ..
        extern enum _synth2 { d,e,f} y;

had been written.

However, within a class, the ODR implies the types are the same:

        class X { enum { d } y; };

in two translation units ensures that the type of member `y` is the same: the two `X`'s obey the ODR and so denote the same class, and it follows that there's only one member `y` and one type that it has.

(See also issues 132 and 216.)

#### 279. Correspondence of "names for linkage purposes"

Section: 3.5 [basic.link] Status: open Submitter: Daveed Vandevoorde Date: 4 Apr 2001

The standard says that an unnamed class or enum definition can be given a "name for linkage purposes" through a typedef. E.g.,

        typedef enum {} E;
        extern E *p;

can appear in multiple translation units.

How about the following combination?

        // Translation unit 1:
        struct S;
        extern S *q;

        // Translation unit 2:
        typedef struct {} S;
        extern S *q;

Is this valid C++?

Also, if the answer is "yes", consider the following slight variant:

        // Translation unit 1:
        struct S {};  // <<-- class has definition
        extern S *q;

        // Translation unit 2:
        typedef struct {} S;
        extern S *q;

Is this a violation of the ODR because two definitions of type `S` consist of differing token sequences?

#### 338. Enumerator name with linkage used as class name in other translation unit

Section: 3.5 [basic.link] Status: open Submitter: Daveed Vandevoorde Date: 26 Feb 2002

The following declarations are allowed within a translation unit:

      struct S;
      enum { S };

However, 3.5 [basic.link] paragraph 9 seems to say these two declarations cannot appear in two different translation units. That also would mean that the inclusion of a header containing the above in two different translation units is not valid C++.

I suspect this is an oversight and that users should be allowed to have the declarations above appear in different translation units. (It is a fairly common thing to do, I think.)

Mike Miller: I think you meant "`enum E { S };`" -- enumerators only have external linkage if the enumeration does (3.5 [basic.link] paragraph 4), and 3.5 [basic.link] paragraph 9 only applies to entities with external linkage.

I don't remember why enumerators were given linkage; I don't think it's necessary for mangling non-type template arguments. In any event, I can't think why cross-TU name collisions between enumerators and other entities would cause a problem, so I guess a change here would be okay. I can think of three changes that would have that effect:

1. Saying that enumerators do not have linkage.
2. Removing enumerators from the list of entities in the first sentence of 3.5 [basic.link] paragraph 9.
3. Saying that it's okay for an enumerator in one TU to have the same name as a class type in another TU only if the enumerator hides that same class type in both TUs (the example you gave).

Daveed Vandevoorde: I don't think any of these are sufficient in the sense that the problem isn't limited to enumerators. E.g.:

      struct X;
      extern void X();

shouldn't create cross-TU collisions either.

Mike Miller: So you're saying that cross-TU collisions should only be prohibited if both names denote entities of the same kind (both functions, both objects, both types, etc.), or if they are both references (regardless of what they refer to, presumably)?

Daveed Vandevoorde: Not exactly. Instead, I'm saying that if two entities (with external linkage) can coexist when they're both declared in the same translation unit (TU), then they should also be allowed to coexist when they're declared in two different translation units.

For example:

      int i;
      void i();  // Error

This is an error within a TU, so I don't see a reason to make it valid across TUs.

However, "tag names" (class/struct/union/enum) can sometimes coexist with identically named entities (variables, functions & enumerators, but not namespaces, templates or type names).

#### 371. Interleaving of constructor calls

Section: 3.6.2 [basic.start.init] Status: open Submitter: Matt Austern Date: 7 August 2002

Is a compiler allowed to interleave constructor calls when performing dynamic initialization of nonlocal objects? What I mean by interleaving is: beginning to execute a particular constructor, then going off and doing something else, then going back to the original constructor. I can't find anything explicit about this in clause 3.6.2 [basic.start.init].

I'll present a few different examples, some of which get a bit wild. But a lot of what this comes down to is exactly what the standard means when it talks about the order of initialization. If it says that some object x must be initialized before a particular event takes place, does that mean that x's constructor must be entered before that event, or does it mean that it must be exited before that event? If object x must be initialized before object y, does that mean that x's constructor must exit before y's constructor is entered?

(The answer to that question might just be common sense, but I couldn't find an answer in clause 3.6.2 [basic.start.init]. Actually, when I read 3.6.2 [basic.start.init] carefully, I find there are a lot of things I took for granted that aren't there.)

OK, so a few specific scenerios.

1. We have a translation unit with nonlocal objects A and B, both of which require dynamic initialization. A comes before B. A must be initialized before B. May the compiler start to construct A, get partway through the constructor, then construct B, and then go back to finishing A?
2. We have a translation unit with nonlocal object A and function f. Construction of A is deferred until after the first statement of main. A must be constructed before the first use of f. Is the compiler permitted to start constructing A, then execute f, then go back to constructing A?
3. We have nonlocal objects A and B, in two different translation units. The order in which A and B are constructed is unspecified by the Standard. Is the compiler permitted to begin constructing A, then construct B, then finish A's constructor? Note the implications of a 'yes' answer. If A's and B's constructor both call some function f, then the call stack might look like this:

          <runtime gunk>
            <Enter A's constructor>
               <Enter f>
                  <runtime gunk>
                     <Enter B's constructor>
                        <Enter f>
                        <Leave f>
                     <Leave B's constructor>
               <Leave f>
            <Leave A's constructor>

   The implication of a 'yes' answer for users is that any function called by a constructor, directly or indirectly, must be reentrant.
4. This last example is to show why a 'no' answer to #3 might be a problem too. New scenerio: we've got one translation unit containing a nonlocal object A and a function f1, and another translation unit containing a nonlocal object B and a function f2. A's constructor calls f2. Initialization of A and B is deferred until after the first statement of main(). Someone in main calls f1. Question: is the compiler permitted to start constructing A, then go off and construct B at some point before f2 gets called, then go back and finish constructing A? In fact, is the compiler required to do that? We've got an unpleasant tension here between the bad implications of a 'yes' answer to #3, and the explicit requirement in 3.6.2 [basic.start.init] paragraph 3.

At this point, you might be thinking we could avoid all of this nonsense by removing compilers' freedom to defer initialization until after the beginning of main(). I'd resist that, for two reasons. First, it would be a huge change to make after the standard has been out. Second, that freedom is necessary if we want to have support for dynamic libraries. I realize we don't yet say anything about dynamic libraries, but I'd hate to make decisions that would make such support even harder.

#### 1659. Initialization order of thread_local template static data members

Section: 3.6.2 [basic.start.init] Status: open Submitter: Richard Smith Date: 2013-04-14

According to 3.6.2 [basic.start.init] paragraph 5,

> It is implementation-defined whether the dynamic initialization of a non-local variable with static or thread storage duration is done before the first statement of the initial function of the thread. If the initialization is deferred to some point in time after the first statement of the initial function of the thread, it shall occur before the first odr-use (3.2 [basic.def.odr]) of any variable with thread storage duration defined in the same translation unit as the variable to be initialized.

This doesn't consider that initialization of instantiations of static data members of class templates (which can be `thread_local`) are unordered. Presumably odr-use of such a static data member should not trigger the initialization of any `thread_local` variable other than that one?

#### 1744. Unordered initialization for variable template specializations

Section: 3.6.2 [basic.start.init] Status: open Submitter: Richard Smith Date: 2013-09-03

According to 3.6.2 [basic.start.init] paragraph 2,

> Definitions of explicitly specialized class template static data members have ordered initialization. Other class template static data members (i.e., implicitly or explicitly instantiated specializations) have unordered initialization.

This is not clear whether it is referring to static data members of explicit specializations of class templates or to explicit specializations of static data members of class template specializations. It also does not apply to static data member templates and non-member variable templates.

Suggested resolution:

Change 3.6.2 [basic.start.init] paragraph 2 as follows:

> ...Dynamic initialization of a non-local variable with static storage duration is either ordered or unordered. Definitions of explicitly specialized class template static data members have ordered initializa-tion. Other class template static data members (i.e., implicitly or explicitly instantiated specializations) have unordered initialization. Other non-local variables with static storage duration have ordered initialization unordered if the variable is an implicitly or explicitly instantiated specialization, and otherwise is ordered [Note: an explicitly specialized static data member or variable template specialization has ordered initialization. —end note]. Variables with ordered initialization...

#### 1747. Constant initialization of reference to function

Section: 3.6.2 [basic.start.init] Status: open Submitter: Daniel Krügler Date: 2013-09-10

According to 3.6.2 [basic.start.init] paragaph 2,

> ...Constant initialization is performed:

> - if each full-expression (including implicit conversions) that appears in the initializer of a reference with static or thread storage duration is a constant expression (5.19 [expr.const]) and the reference is bound to an lvalue designating an object with static storage duration or to a temporary (see 12.2 [class.temporary]);

> - ...

This wording, presumably inadvertently, excludes a reference to a function from being constant initialization.

#### 1749. Confusing definition for constant initializer

Section: 3.6.2 [basic.start.init] Status: open Submitter: Daniel Krügler Date: 2013-09-12

According to 3.6.2 [basic.start.init] paragraph 2,

> A constant initializer for an object `o` is an expression that is a constant expression, except that it may also invoke `constexpr` constructors for `o` and its subobjects even if those objects are of non-literal class types [Note: such a class may have a non-trivial destructor —end note].

This would be clearer if worded as something like,

> A constant initializer for an object `o` is an expression that would be a constant expression if every `constexpr` constructor invoked for `o` and its subobjects were a constructor for a literal class type.

#### 640. Accessing destroyed local objects of static storage duration

Section: 3.6.3 [basic.start.term] Status: open Submitter: Howard Hinnant Date: 30 July 2007

3.6.3 [basic.start.term] paragraph 2 says,

> If a function contains a local object of static storage duration that has been destroyed and the function is called during the destruction of an object with static storage duration, the program has undefined behavior if the flow of control passes through the definition of the previously destroyed local object.

I would like to turn this behavior from undefined to well-defined behavior for the purpose of achieving a graceful shutdown, especially in a multi-threaded world.

Background: Alexandrescu describes the “phoenix singleton” in Modern C++ Design. This is a class used as a function local static, that will reconstruct itself, and reapply itself to the `atexit` chain, if the program attempts to use it after it is destructed in the `atexit` chain. It achieves this by setting a “destructed flag” in its own state in its destructor. If the object is later accessed (and a member function is called on it), the member function notes the state of the “destructed flag” and does the reconstruction dance. The phoenix singleton pattern was designed to address issues only in single-threaded code where accesses among static objects can have a non-scoped pattern. When we throw in multi-threading, and the possibility that threads can be running after `main` returns, the chances of accessing a destroyed static significantly increase.

The very least that I would like to see happen is to standardize what I believe is existing practice: When an object is destroyed in the `atexit` chain, the memory the object occupied is left in whatever state the destructor put it in. If this can only be reliably done for objects with standard layout, that would be an acceptable compromise. This would allow objects to set “I'm destructed” flags in their state and then do something well-defined if accessed, such as throw an exception.

A possible refinement of this idea is to have the compiler set up a 3-state flag around function-local statics instead of the current 2-state flag:

- Not constructed yet
- Constructed but not destroyed yet
- Destroyed

We have the first two states today. We might choose to add the third state, and if execution passes over a function-local static with “destroyed” state, an exception could be thrown. This would mean that we would not have to guarantee memory stability in destroyed objects of static duration.

This refinement would break phoenix singletons, and is not required for the `~mutex()`/`~condition()` I've described and prototyped. But it might make it easier for Joe Coder to apply this kind of guarantee to his own types.

#### 365. Storage duration and temporaries

Section: 3.7 [basic.stc] Status: open Submitter: James Kanze Date: 24 July 2002

There are several problems with 3.7 [basic.stc]:

- 3.7 [basic.stc] paragraph 2 says that "Static and automatic storage durations are associated with objects introduced by declarations (3.1 [basic.def]) and implicitly created by the implementation (12.2 [class.temporary])."

  In fact, objects "implicitly created by the implementation" are the temporaries described in (12.2 [class.temporary]), and have neither static nor automatic storage duration, but a totally different duration, described in 12.2 [class.temporary].

- 3.7 [basic.stc] uses the expression "local object" in several places, without ever defining it. Presumably, what is meant is "an object declared at block scope", but this should be said explicitly.

  In a recent discussion in comp.lang.c++.moderated, on poster interpreted "local objects" as including temporaries. This would require them to live until the end of the block in which they are created, which contradicts 12.2 [class.temporary]. If temporaries are covered by this section, and the statement in 3.7 [basic.stc] seems to suggest, and they aren't local objects, then they must have static storage duration, which isn't right either.

  I propose adding a fourth storage duration to the list after 3.7 [basic.stc] paragraph 1:

  - temporary storage duration

  And rewriting the second paragraph of this section as follows:

  > Temporary storage duration is associated with objects implicitly created by the implementation, and is described in 12.2 [class.temporary]. Static and automatic storage durations are associated with objects defined by declarations; in the following, an object defined by a declaration with block scope is a local object. The dynamic storage duration is associated with objects created by the `operator new`.

Steve Adamczyk: There may well be an issue here, but one should bear in mind the difference between storage duration and object lifetime. As far as I can see, there is no particular problem with temporaries having automatic or static storage duration, as appropriate. The point of 12.2 [class.temporary] is that they have an unusual object lifetime.

Notes from Ocrober 2002 meeting:

It might be desirable to shorten the storage duration of temporaries to allow reuse of them. The as-if rule allows some reuse, but such reuse requires analysis, including noting whether the addresses of such temporaries have been taken.

Notes from the August, 2011 meeting:

The CWG decided that further consideration of this issue would be deferred until someone produces a paper explaining the need for action and proposing specific changes.

#### 967. Exception specification of replacement allocation function

Section: 3.7.4 [basic.stc.dynamic] Status: open Submitter: Steve Clamage Date: 15 September, 2009

The global allocation functions are implicitly declared in every translation unit with exception-specifications (3.7.4 [basic.stc.dynamic] paragraph 2). It is not clear what should happen if a replacement allocation function is declared without an exception-specification. Is that a conflict with the implicitly-declared function (as it would be with explicitly-declared functions, and presumably is if the `<new>` header is included)? Or does the new declaration replace the implicit one, including the lack of an exception-specification? Or does the implicit declaration prevail? (Regardless of the exception-specification or lack thereof, it is presumably undefined behavior for an allocation function to exit with an exception that cannot be caught by a handler of type `std::bad_alloc` (3.7.4.1 [basic.stc.dynamic.allocation] paragraph 3).)

#### 1682. Overly-restrictive rules on function templates as allocation functions

Section: 3.7.4.1 [basic.stc.dynamic.allocation] Status: open Submitter: Jason Merrill Date: 2009-03-03

Requirements for allocation functions are given in 3.7.4.1 [basic.stc.dynamic.allocation] paragraph 1:

> An allocation function can be a function template. Such a template shall declare its return type and first parameter as specified above (that is, template parameter types shall not be used in the return type and first parameter type). Template allocation functions shall have two or more parameters.

There are a couple of problems with this description. First, it is instances of function templates that can be allocation functions, not the templates themselves (cf 3.7.4.2 [basic.stc.dynamic.deallocation] paragraph 2, which uses the correct terminology regarding deallocation functions).

More importantly, this specification was written before template metaprogramming was understood and hence prevents use of SFINAE on the return type or parameter type to select among function template specializations. (The parallel passage for deallocation functions in 3.7.4.2 [basic.stc.dynamic.deallocation] paragraph 2 shares this deficit.)

(See also issue 1628.)

#### 523. Can a one-past-the-end pointer be invalidated by deleting an adjacent object?

Section: 3.7.4.2 [basic.stc.dynamic.deallocation] Status: open Submitter: comp.std.c++ Date: 8 July 2005

When an object is deleted, 3.7.4.2 [basic.stc.dynamic.deallocation] says that the deallocation “[renders] invalid all pointers referring to any part of the deallocated storage.” According to 3.9.2 [basic.compound] paragraph 3, a pointer whose address is one past the end of an array is considered to point to an unrelated object that happens to reside at that address. Does this need to be clarified to specify that the one-past-the-end pointer of an array is not invalidated by deleting the following object? (See also 5.3.5 [expr.delete] paragraph 4, which also mentions that the system deallocation function renders a pointer invalid.)

#### 419. Can cast to virtual base class be done on partially-constructed object?

Section: 3.8 [basic.life] Status: open Submitter: Judy Ward Date: 2 June 2003

Consider

      extern "C" int printf (const char *,...);

      struct Base { Base();};
      struct Derived: virtual public Base {
         Derived() {;}
      };

      Derived d;
      extern Derived& obj = d;

      int i;

      Base::Base() {
        if ((Base *) &obj) i = 4;
        printf ("i=%d\n", i);
      }

      int main() { return 0; }

12.7 [class.cdtor] paragraph 2 makes this valid, but 3.8 [basic.life] paragraph 5 implies that it isn't valid.

Steve Adamczyk: A second issue:

      extern "C" int printf(const char *,...);
      struct A                      { virtual ~A(); int x; };
      struct B : public virtual A   { };
      struct C : public B           { C(int); };
      struct D : public C           { D(); };

      int main()                    { D t; printf("passed\n");return 0; }

      A::~A()                       {}
      C::C(int)                     {}
      D::D() : C(this->x)           {}

Core issue 52 almost, but not quite, says that in evaluating "this->x" you do a cast to the virtual base class A, which would be an error according to 12.7 [class.cdtor] paragraph 2 because the base class B constructor hasn't started yet. 5.2.5 [expr.ref] should be clarified to say that the cast does need to get done.

James Kanze submitted the same issue via comp.std.c++ on 11 July 2003:

> Richard Smith: Nonsense. You can use "this" perfectly happily in a constructor, just be careful that (a) you're not using any members that are not fully initialised, and (b) if you're calling virtual functions you know exactly what you're doing.

In practice, and I think in intent, you are right. However, the standard makes some pretty stringent restrictions in 3.8 [basic.life]. To start with, it says (in paragraph 1):

> The lifetime of an object is a runtime property of the object. The lifetime of an object of type T begins when:
> - storage with the proper alignment and size for type T is obtained, and
> - if T is a class type with a non-trivial constructor, the constructor calls has COMPLETED.
> The lifetime of an object of type T ends when:
> - if T is a class type with a non-trivial destructor, the destructor call STARTS, or
> - the storage which the object occupies is reused or released.

(Emphasis added.) Then when we get down to paragraph 5, it says:

> Before the lifetime of an object has started but after the storage which the object will occupy has been allocated [which sounds to me like it would include in the constructor, given the text above] or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that refers to the storage location where the object will be or was located may be used but only in limited ways. [...] If the object will be or was of a non-POD class type, the program has undefined behavior if:

> [...]

> - the pointer is implicitly converted to a pointer to a base class type, or [...]

I can't find any exceptions for the this pointer.

Note that calling a non-static function in the base class, or even constructing the base class in initializer list, involves an implicit conversion of this to a pointer to the base class. Thus undefined behavior. I'm sure that this wasn't the intent, but it would seem to be what this paragraph is saying.

#### 1285. Trivial destructors and object lifetime

Section: 3.8 [basic.life] Status: open Submitter: Johannes Schaub Date: 2011-04-02

The Standard is self-contradictory regarding which destructor calls end the lifetime of an object. 3.8 [basic.life] paragraph 1 says,

> The lifetime of an object of type T ends when:

> - if `T` is a class type with a non-trivial destructor (12.4 [class.dtor]), the destructor call starts, or

> - the storage which the object occupies is reused or released.

i.e., the lifetime of an object of a class type with a trivial destructor persists until its storage is reused or released. However, 12.4 [class.dtor] paragraph 15 says,

> Once a destructor is invoked for an object, the object no longer exists; the behavior is undefined if the destructor is invoked for an object whose lifetime has ended (3.8 [basic.life]).

implying that invoking any destructor, even a trivial one, ends the lifetime of the associated object. Similarly, 12.7 [class.cdtor] paragraph 1 says,

> For an object with a non-trivial destructor, referring to any non-static member or base class of the object after the destructor finishes execution results in undefined behavior.

A similar question arises for pseudo-destructors for non-class types.

Notes from the August, 2011 meeting:

CWG will need a paper exploring this topic before it can act on the issue.

#### 1751. Non-trivial operations vs non-trivial initialization

Section: 3.8 [basic.life] Status: open Submitter: Nico Josuttis Date: 2013-09-15

The description of `is_trivially_constructible` in 20.11.4.3 [meta.unary.prop] paragraph 3 says,

> `is_constructible<T, Args...>::value` is `true` and the variable definition for `is_constructible`, as defined below, is known to call no operation that is not trivial ( 3.9 [basic.types], 12 [special]).

This risks confusion when compared with the wording in 3.8 [basic.life] paragraph 1,

> An object is said to have non-trivial initialization if it is of a class or aggregate type and it or one of its members is initialized by a constructor other than a trivial default constructor. [Note: initialization by a trivial copy/move constructor is non-trivial initialization. —end note]

The latter was written long before “trivial” became an important concept in its own right and uses the term differently from how it is used elsewhere in the Standard (as evidenced by the note referring to copy/move construction). The intent is to capture the idea that there is some actual initialization occurring; it should be rephrased to avoid the potential of confusion with the usage of “trivial” elsewhere.

#### 1776. Replacement of class objects containing reference members

Section: 3.8 [basic.life] Status: open Submitter: Finland Date: 2013-09-24
N3690 comment FI 15

The rules given in 3.8 [basic.life] paragraph 7 for when an object's lifetime can be ended and a new object created in its storage include the following restriction:

> the type of the original object is not const-qualified, and, if a class type, does not contain any non-static data member whose type is const-qualified or a reference type

The intent of this restriction is to permit optimizers to rely upon the original values of `const` and reference members in their analysis of subsequent code. However, this makes it difficult to implement certain desirable functionality such as `optional<T>`; see this discussion for more details.

This rule should be reconsidered, at least as far as it applies to unions. If it is decided to keep the rule, acceptable programming techniques for writing safe code when replacing such objects should be outlined in a note.

(See also issue 1404, which will become moot if the restriction is lifted.)

#### 350. `signed char` underlying representation for objects

Section: 3.9 [basic.types] Status: open Submitter: Noah Stein Date: 16 April 2002

Sent in by David Abrahams:

Yes, and to add to this tangent, 3.9.1 [basic.fundamental] paragraph 1 states "Plain char, signed char, and unsigned char are three distinct types." Strangely, 3.9 [basic.types] paragraph 2 talks about how "... the underlying bytes making up the object can be copied into an array of char or unsigned char. If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value." I guess there's no requirement that this copying work properly with signed chars!

Notes from October 2002 meeting:

We should do whatever C99 does. 6.5p6 of the C99 standard says "array of character type", and "character type" includes signed char (6.2.5p15), and 6.5p7 says "character type". But see also 6.2.6.1p4, which mentions (only) an array of unsigned char.

Proposed resolution (April 2003):

Change 3.8 [basic.life] paragraph 5 bullet 3 from

- the pointer is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) (except when the conversion is to `void*`, or to `void*` and subsequently to `char*`, or `unsigned` `char*`).

to

- the pointer is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) (except when the conversion is to `void*`, or to `void*` and subsequently to a pointer to byte-character type).

Change 3.8 [basic.life] paragraph 6 bullet 3 from

- the lvalue is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) (except when the conversion is ultimately to `char&` or `unsigned` `char&`), or

to

- the lvalue is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) (except when the conversion is ultimately to a reference to byte-character type), or

Change the beginning of 3.9 [basic.types] paragraph 2 from

> For any object (other than a base-class subobject) of POD type `T`, whether or not the object holds a valid value of type `T`, the underlying bytes (1.7 [intro.memory]) making up the object can be copied into an array of `char` or `unsigned` `char`.

to

> For any object (other than a base-class subobject) of POD type `T`, whether or not the object holds a valid value of type `T`, the underlying bytes (1.7 [intro.memory]) making up the object can be copied into an array of byte-character type.

Add the indicated text to 3.9.1 [basic.fundamental] paragraph 1:

> Objects declared as characters (`char`) shall be large enough to store any member of the implementation's basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value of the single character literal form of that character. It is implementation-defined whether a `char` object can hold negative values. Characters can be explicitly declared `unsigned` or `signed`. Plain `char`, `signed char`, and `unsigned char` are three distinct types, called the byte-character types. A `char`, a `signed char`, and an `unsigned char` occupy the same amount of storage and have the same alignment requirements (3.9 [basic.types]); that is, they have the same object representation. For byte-character types, all bits of the object representation participate in the value representation. For unsigned byte-character types, all possible bit patterns of the value representation represent numbers. These requirements do not hold for other types. In any particular implementation, a plain `char` object can take on either the same values as a `signed char` or an `unsigned char`; which one is implementation-defined.

Change 3.10 [basic.lval] paragraph 15 last bullet from

- a `char` or `unsigned` `char` type.

to

- a byte-character type.

Notes from October 2003 meeting:

It appears that in C99 signed char may have padding bits but no trap representation, whereas in C++ signed char has no padding bits but may have -0. A memcpy in C++ would have to copy the array preserving the actual representation and not just the value.

March 2004: The liaisons to the C committee have been asked to tell us whether this change would introduce any unnecessary incompatibilities with C.

Notes from October 2004 meeting:

The C99 Standard appears to be inconsistent in its requirements. For example, 6.2.6.1 paragraph 4 says:

> The value may be copied into an object of type `unsigned char [`n`]` (e.g., by `memcpy`); the resulting set of bytes is called the object representation of the value.

On the other hand, 6.2 paragraph 6 says,

> If a value is copied into an object having no declared type using `memcpy` or `memmove`, or is copied as an array of character type, then the effective type of the modified object for that access and for subsequent accesses that do not modify the value is the effective type of the object from which the value is copied, if it has one.

Mike Miller will investigate further.

Proposed resolution (February, 2010):

1. Change 3.8 [basic.life] paragraph 5 bullet 4 as follows:

> ...The program has undefined behavior if:

> - ...

> - the pointer is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) (except when the conversion is to cv `void*`, or to cv `void*` and subsequently to `char*`, or `unsigned char*` a pointer to a cv-qualified or cv-unqualified byte-character type (3.9.1 [basic.fundamental])), or

> - ...

2. Change 3.8 [basic.life] paragraph 6 bullet 4 as follows:

> ...The program has undefined behavior if:

> - ...

> - the lvalue is used as the operand of a `static_cast` (5.2.9 [expr.static.cast]) except when the conversion is ultimately to cv `char&` or cv `unsigned char&` a reference to a cv-qualified or cv-unqualified byte-character type (3.9.1 [basic.fundamental]) or an array thereof, or

> - ...

3. Change 3.9 [basic.types] paragraph 2 as follows:

> For any object (other than a base-class subobject) of trivially copyable type `T`, whether or not the object holds a valid value of type `T`, the underlying bytes (1.7 [intro.memory]) making up the object can be copied into an array of `char` or `unsigned char` a byte-character type (3.9.1 [basic.fundamental]).39 If the content of the that array of `char` or `unsigned char` is copied back into the object, the object shall subsequently hold its original value. [Example:...

4. Change 3.9.1 [basic.fundamental] paragraph 1 as follows:

> ...Characters can be explicitly declared `unsigned` or `signed`. Plain `char`, `signed char`, and `unsigned char` are three distinct types, called the byte-character types. A `char`, a `signed char`, and an `unsigned char` occupy the same amount of storage and have the same alignment requirements (3.11 [basic.align]); that is, they have the same object representation. For byte-character types, all bits of the object representation participate in the value representation. For unsigned character types `unsigned char`, all possible bit patterns of the value representation represent numbers...

5. Change 3.10 [basic.lval] paragraph 15 final bullet as follows:

> If a program attempts to access the stored value of an object through an lvalue of other than one of the following types the behavior is undefined 52

> - ...

> - a `char` or `unsigned char` byte-character type (3.9.1 [basic.fundamental]).

6. Change 3.11 [basic.align] paragraph 6 as follows:

> The alignment requirement of a complete type can be queried using an `alignof` expression (5.3.6 [expr.alignof]). Furthermore, the byte-character types (3.9.1 [basic.fundamental]) `char`, `signed char`, and `unsigned char` shall have the weakest alignment requirement. [Note: this enables the byte-character types to be used as the underlying type for an aligned memory area (7.6.2 [dcl.align]). —end note]

7. Change 5.3.4 [expr.new] paragraph 10 as follows:

> ...For arrays of `char` and `unsigned char` a byte-character type (3.9.1 [basic.fundamental]), the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the strictest fundamental alignment requirement (3.11 [basic.align]) of any object type whose size is no greater than the size of the array being created. [Note: Because allocation functions are assumed to return pointers to storage that is appropriately aligned for objects of any type with fundamental alignment, this constraint on array allocation overhead permits the common idiom of allocating byte-character arrays into which objects of other types will later be placed. —end note]

Notes from the March, 2010 meeting:

The CWG was not convinced that there was a need to change the existing specification at this time. Some were concerned that there might be implementation difficulties with giving `signed char` the requisite semantics; implementations for which that is true can currently make `char` equivalent to `unsigned char` and avoid those problems, but the suggested change would undermine that strategy.

#### 1746. Are volatile scalar types trivially copyable?

Section: 3.9 [basic.types] Status: open Submitter: Walter Brown Date: 2013-09-06

According to 3.9 [basic.types] paragraph 9,

> Arithmetic types (3.9.1 [basic.fundamental]), enumeration types, pointer types, pointer to member types (3.9.2 [basic.compound]), `std::nullptr_t`, and cv-qualified versions of these types (3.9.3 [basic.type.qualifier]) are collectively called scalar types... Scalar types, trivially copyable class types (Clause 9 [class]), arrays of such types, and non-volatile const-qualified versions of these types (3.9.3 [basic.type.qualifier]) are collectively called trivially copyable types.

This is confusing, because “scalar types” include volatile-qualified types, but the intent of the definition of “trivially copyable type” appears to be to exclude volatile-qualified types. Perhaps the second quoted sentence should read something like,

> A non-volatile type `T` or an array of such `T` is called a trivially copyable type if `T` is either a scalar type or a trivially copyable class type.

(Note that the following sentence, defining “trivial type,” has a similar formal issue, although it has no actual significance because all cv-qualifiers are permitted.)

#### 146. Floating-point zero

Section: 3.9.1 [basic.fundamental] Status: open Submitter: Andy Sawyer Date: 23 Jul 1999

3.9.1 [basic.fundamental] does not impose a requirement on the floating point types that there be an exact representation of the value zero. This omission is significant in 4.12 [conv.bool] paragraph 1, in which any non-zero value converts to the `bool` value `true`.

Suggested resolution: require that all floating point types have an exact representation of the value zero.

#### 251. How many signed integer types are there?

Section: 3.9.1 [basic.fundamental] Status: open Submitter: Beman Dawes Date: 18 Oct 2000

3.9.1 [basic.fundamental] paragraph 2 says that

> There are four signed integer types: "`signed char`", "`short int`", "`int`", and "`long int`."

This would indicate that `const int` is not a signed integer type.

#### 689. Maximum values of signed and unsigned integers

Section: 3.9.1 [basic.fundamental] Status: open Submitter: James Kanze Date: 30 March, 2008

The relationship between the values representable by corresponding signed and unsigned integer types is not completely described, but 3.9 [basic.types] paragraph 4 says,

> The value representation of an object is the set of bits that hold the value of type `T`.

and 3.9.1 [basic.fundamental] paragraph 3 says,

> The range of nonnegative values of a signed integer type is a subrange of the corresponding unsigned integer type, and the value representation of each corresponding signed/unsigned type shall be the same.

I.e., the maximum value of each unsigned type must be larger than the maximum value of the corresponding signed type.

C90 doesn't have this restriction, and C99 explicitly says (6.2.6.2, paragraph 2),

> For signed integer types, the bits of the object representation shall be divided into three groups: value bits, padding bits, and the sign bit. There need not be any padding bits; there shall be exactly one sign bit. Each bit that is a value bit shall have the same value as the same bit in the object representation of the corresponding unsigned type (if there are M value bits in the signed type and N in the unsigned type, then M <= N).

Unlike C++, the sign bit is not part of the value, and on an architecture that does not have native support of unsigned types, an implementation can emulate unsigned integers by simply ignoring what would be the sign bit in the signed type and be conforming.

The question is whether we intend to make a conforming implementation on such an architecture impossible. More generally, what range of architectures do we intend to support? And to what degree do we want to follow C99 in its evolution since C89?

(See paper J16/08-0141 = WG21 N2631.)

#### 1076. Value categories and lvalue temporaries

Section: 3.10 [basic.lval] Status: open Submitter: Daniel Krügler Date: 2010-06-10

The taxonomy of value categories in 3.10 [basic.lval] classifies temporaries as prvalues. However, some temporaries are explicitly referred to as lvalues (cf 15.1 [except.throw] paragraph 3).

#### 330. Qualification conversions and pointers to arrays of pointers

Section: 4.4 [conv.qual] Status: open Submitter: Roger Orr Date: 2 Jan 2002

Section 4.4 [conv.qual] covers the case of multi-level pointers, but does not appear to cover the case of pointers to arrays of pointers. The effect is that arrays are treated differently from simple scalar values.

Consider for example the following code: (from the thread "Pointer to array conversion question" begun in comp.lang.c++.moderated)

      int main()
      {
         double *array2D[2][3];

         double       *       (*array2DPtr1)[3] = array2D;     // Legal
         double       * const (*array2DPtr2)[3] = array2DPtr1; // Legal
         double const * const (*array2DPtr3)[3] = array2DPtr2; // Illegal
      }

and compare this code with:-

      int main()
      {
         double *array[2];

         double       *       *ppd1 = array; // legal
         double       * const *ppd2 = ppd1;  // legal
         double const * const *ppd3 = ppd2;  // certainly legal (4.4/4)
      }

The problem appears to be that the pointed to types in example 1 are unrelated since nothing in the relevant section of the standard covers it - 4.4 [conv.qual] does not mention conversions of the form "cv array of N pointer to T" into "cv array of N pointer to cv T"

It appears that reinterpret_cast is the only way to perform the conversion.

Suggested resolution:

Artem Livshits proposed a resolution :-

"I suppose if the definition of "similar" pointer types in 4.4 [conv.qual] paragraph 4 was rewritten like this:

> T1 is cv1,0 P0 cv1,1 P1 ... cv1,n-1 Pn-1 cv1,n T

> and

> T2 is cv1,0 P0 cv1,1 P1 ... cv1,n-1 Pn-1 cv1,n T

> where Pi is either a "pointer to" or a "pointer to an array of Ni"; besides P0 may be also a "reference to" or a "reference to an array of N0" (in the case of P0 of T2 being a reference, P0 of T1 may be nothing).

it would address the problem.

In fact I guess Pi in this notation may be also a "pointer to member", so 4.4 [conv.qual]/{4,5,6,7} would be nicely wrapped in one paragraph."

#### 238. Precision and accuracy constraints on floating point

Section: 5 [expr] Status: open Submitter: Christophe de Dinechin Date: 31 Jul 2000

It is not clear what constraints are placed on a floating point implementation by the wording of the Standard. For instance, is an implementation permitted to generate a "fused multiply-add" instruction if the result would be different from what would be obtained by performing the operations separately? To what extent does the "as-if" rule allow the kinds of optimizations (e.g., loop unrolling) performed by FORTRAN compilers?

#### 1642. Missing requirements for prvalue operands

Section: 5 [expr] Status: open Submitter: Joseph Mansfield Date: 2013-03-15

Although the note in 3.10 [basic.lval] paragraph 1 states that

> The discussion of each built-in operator in Clause 5 [expr] indicates the category of the value it yields and the value categories of the operands it expects

in fact, many of the operators that take prvalue operands do not make that requirement explicit. Possible approaches to address this failure could be a blanket statement that an operand whose value category is not stated is assumed to be a prvalue; adding prvalue requirements to each operand description for which it is missing; or changing the description of the usual arithmetic conversions to state that they imply the lvalue-to-rvalue conversion, which would cover the majority of the omissions.

(See also issue 1685, which deals with an inaccurately-specified value category.)

#### 1632. Lambda capture in member initializers

Section: 5.1.2 [expr.prim.lambda] Status: open Submitter: Vinny Romano Date: 2013-03-04

According to 5.1.2 [expr.prim.lambda] paragraph 9,

> A lambda-expression whose smallest enclosing scope is a block scope (3.3.3 [basic.scope.block]) is a local lambda expression; any other lambda-expression shall not have a capture-list in its lambda-introducer. The reaching scope of a local lambda expression is the set of enclosing scopes up to and including the innermost enclosing function and its parameters.

Consequently, lambdas appearing in mem-initializers and brace-or-equal-initializers cannot have a capture-list. However, these expressions are evaluated in the context of the constructor and are permitted to access `this` and non-static data members.

Should the definition of a local lambda be modified to permit capturing lambdas within these contexts?

Notes from the April, 2013 meeting:

CWG agreed with the intent of this issue.

#### 1743. init-captures in nested lambdas

Section: 5.1.2 [expr.prim.lambda] Status: open Submitter: Faisal Vali Date: 2013-08-30

According to 5.2.1 [expr.sub] paragraph 11,

> No entity is captured by an init-capture.

It should be made clearer that a variable, odr-used by an init-capture in a nested lambda, is still captured by the containing lambda as a result of the init-capture.

#### 1780. Explicit instantiation/specialization of generic lambda `operator()`

Section: 5.1.2 [expr.prim.lambda] Status: open Submitter: Hubert Tong Date: 2013-09-26

Similarly to issue 1738, it is not clear whether it is permitted to explicitly instantiate or specialize the call operator of a polymorphic lambda (via `decltype`).

#### 943. Is `T()` a temporary?

Section: 5.2.3 [expr.type.conv] Status: open Submitter: Miller Date: 14 July, 2009

According to 5.2.3 [expr.type.conv] paragraphs 1 and 3 (stated directly or by reference to another section of the Standard), all the following expressions create temporaries:

        T(1)
        T(1, 2)
        T{1}
        T{}

However, paragraph 2 says,

> The expression `T()`, where `T` is a simple-type-specifier or typename-specifier for a non-array complete effective object type or the (possibly cv-qualified) `void` type, creates an rvalue of the specified type, which is value-initialized (8.5 [dcl.init]; no initialization is done for the `void()` case).

This does not say that the result is a temporary, which means that the lifetime of the result is not specified by 12.2 [class.temporary]. Presumably this is just an oversight.

Notes from the October, 2009 meeting:

The specification in 5.2.3 [expr.type.conv] is in error, not because it fails to state that `T()` is a temporary but because it requires a temporary for the other cases with fewer than two operands. The case where `T` is a class type is covered by 12.2 [class.temporary] paragraph 1 (“a conversion that creates an rvalue”), and a temporary should not be created when `T` is not a class type.

#### 742. Postfix increment/decrement with long bit-field operands

Section: 5.2.6 [expr.post.incr] Status: open Submitter: Mike Miller Date: 11 November, 2008

Given the following declarations:

        struct S {
            signed long long sll: 3;
        };
        S s = { -1 };

the expressions `s.sll-- < 0u` and `s.sll < 0u` have different results. The reason for this is that `s.sll--` is an rvalue of type `signed long long` (5.2.6 [expr.post.incr]), which means that the usual arithmetic conversions (5 [expr] paragraph 10) convert `0u` to `signed long long` and the result is `true`. `s.sll`, on the other hand, is a bit-field lvalue, which is promoted (4.5 [conv.prom] paragraph 3) to `int`; both operands of `<` have the same rank, so `s.sll` is converted to `unsigned int` to match the type of `0u` and the result is `false`. This disparity seems undesirable.

#### 282. Namespace for `extended_type_info`

Section: 5.2.8 [expr.typeid] Status: open Submitter: Jens Maurer Date: 01 May 2001

The original proposed resolution for issue 160 included changing `extended_type_info` (5.2.8 [expr.typeid] paragraph 1, footnote 61) to `std::extended_type_info`. There was no consensus on whether this name ought to be part of namespace `std` or in a vendor-specific namespace, so the question was moved into a separate issue.

#### 528. Why are incomplete class types not allowed with `typeid`?

Section: 5.2.8 [expr.typeid] Status: open Submitter: Dave Abrahams Date: 18 May 2005

5.2.8 [expr.typeid] paragraph 4 says,

> When `typeid` is applied to a type-id, the result refers to a `std::type_info` object representing the type of the type-id. If the type of the type-id is a reference type, the result of the `typeid` expression refers to a `std::type_info` object representing the referenced type. If the type of the type-id is a class type or a reference to a class type, the class shall be completely-defined.

I'm wondering whether this is not overly restrictive. I can't think of a reason to require that `T` be completely-defined in `typeid(T)` when `T` is a class type. In fact, several popular compilers enforce that restriction for `typeid(T)`, but not for `typeid(T&)`. Can anyone explain this?

Nathan Sidwell: I think this restriction is so that whenever the compiler has to emit a typeid object of a class type, it knows what the base classes are, and can therefore emit an array of pointers-to-base-class typeids. Such a tree is necessary to implement `dynamic_cast` and exception catching (in a commonly implemented and obvious manner). If the class could be incomplete, the compiler might have to emit a typeid for incomplete `Foo` in one object file and a typeid for complete `Foo` in another object file. The compilation system will then have to make sure that (a) those compare equal and (b) the complete `Foo` gets priority, if that is applicable.

Unfortunately, there is a problem with exceptions that means there still can be a need to emit typeids for incomplete class. Namely one can throw a pointer-to-pointer-to-incomplete. To implement the matching of pointer-to-derived being caught by pointer-to-base, it is necessary for the typeid of a pointer type to contain a pointer to the typeid of the pointed-to type. In order to do the qualification matching on a multi-level pointer type, one has a chain of pointer typeids that can terminate in the typeid of an incomplete type. You cannot simply NULL-terminate the chain, because one must distinguish between different incomplete types.

Dave Abrahams: So if implementations are still required to be able to do it, for all practical purposes, why aren't we letting the user have the benefits?

Notes from the April, 2006 meeting:

There was some concern expressed that this might be difficult under the IA64 ABI. It was also observed that while it is necessary to handle exceptions involving incomplete types, there is no requirement that the RTTI data structures be used for exception handling.

#### 944. `reinterpret_cast` for all types with the same size and alignment

Section: 5.2.10 [expr.reinterpret.cast] Status: open Submitter: Miller Date: 15 July, 2009

During the discussion of issue 799, which specified the result of using `reinterpret_cast` to convert an operand to its own type, it was observed that it is probably reasonable to allow `reinterpret_cast` between any two types that have the same size and alignment.

#### 1230. Confusing description of ambiguity of destructor name

Section: 5.3.1 [expr.unary.op] Status: open Submitter: Johannes Schaub Date: 2010-12-13

According to 5.3.1 [expr.unary.op] paragraph 10,

> There is an ambiguity in the unary-expression `~X()`, where `X` is a class-name or decltype-specifier. The ambiguity is resolved in favor of treating `~` as a unary complement rather than treating `~X` as referring to a destructor.

It is not clear whether this is intended to apply to an expression like `(~S)()`. In large measure, that depends on whether a class-name is an id-expression or not. If it is, the ambiguity described in 5.3.1 [expr.unary.op] paragraph 10 does apply; if not, the expression is an unambiguous reference to the destructor for class `S`. There are several places in the Standard that indicate that the name of a type is an id-expression, but that might be more confusing than helpful.

#### 267. Alignment requirement for new-expressions

Section: 5.3.4 [expr.new] Status: open Submitter: James Kuyper Date: 4 Dec 2000

Requirements for the alignment of pointers returned by new-expressions are given in 5.3.4 [expr.new] paragraph 10:

> For arrays of `char` and `unsigned char`, the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the most stringent alignment requirement (3.9 [basic.types]) of any object type whose size is no greater than the size of the array being created.

The intent of this wording is that the pointer returned by the new-expression will be suitably aligned for any data type that might be placed into the allocated storage (since the allocation function is constrained to return a pointer to maximally-aligned storage). However, there is an implicit assumption that each alignment requirement is an integral multiple of all smaller alignment requirements. While this is probably a valid assumption for all real architectures, there's no reason that the Standard should require it.

For example, assume that `int` has an alignment requirement of 3 bytes and `double` has an alignment requirement of 4 bytes. The current wording only requires that a buffer that is big enough for an `int` or a `double` be aligned on a 4-byte boundary (the more stringent requirement), but that would allow the buffer to be allocated on an 8-byte boundary — which might not be an acceptable location for an `int`.

Suggested resolution: Change "of any object type" to "of every object type."

A similar assumption can be found in 5.2.10 [expr.reinterpret.cast] paragraph 7:

> ...converting an rvalue of type "pointer to `T1`" to the type "pointer to `T2`" (where ... the alignment requirements of `T2` are no stricter than those of `T1`) and back to its original type yields the original pointer value...

Suggested resolution: Change the wording to

> ...converting an rvalue of type "pointer to `T1`" to the type "pointer to `T2`" (where ... the alignment requirements of `T1` are an integer multiple of those of `T2`) and back to its original type yields the original pointer value...

The same change would also be needed in paragraph 9.

#### 473. Block-scope declarations of allocator functions

Section: 5.3.4 [expr.new] Status: open Submitter: John Spicer Date: 12 Jul 2004

Looking up `operator new` in a new-expression uses a different mechanism from ordinary lookup. According to 5.3.4 [expr.new] paragraph 9,

> If the new-expression begins with a unary `::` operator, the allocation function's name is looked up in the global scope. Otherwise, if the allocated type is a class type `T` or array thereof, the allocation function's name is looked up in the scope of `T`. If this lookup fails to find the name, or if the allocated type is not a class type, the allocation function's name is looked up in the global scope.

Note in particular that the scope in which the new-expression occurs is not considered. For example,

        void f() {
            void* operator new(std::size_t, void*);
            int* i = new int;    // okay?
        }

In this example, the implicit reference to `operator new(std::size_t)` finds the global declaration, even though the block-scope declaration of `operator new` with a different signature would hide it from an ordinary reference.

This seems strange; either the block-scope declaration should be ill-formed or it should be found by the lookup.

Notes from October 2004 meeting:

The CWG agreed that the block-scope declaration should not be found by the lookup in a new-expression. It would, however, be found by ordinary lookup if the allocation function were invoked explicitly.

#### 1628. Deallocation function templates

Section: 5.3.4 [expr.new] Status: open Submitter: Richard Smith Date: 2013-02-22

According to 5.3.4 [expr.new] paragraphs 18-20, an exception thrown during the initialization of an object allocated by a new-expression will cause a deallocation function to be called for the object's storage if a matching deallocation function can be found. The rules deal only with functions, however; nothing is said regarding a mechanism by which a deallocation function template might be instantiated to free the storage, although 3.7.4.2 [basic.stc.dynamic.deallocation] paragraph 2 indicates that a deallocation function can be an instance of a function template.

One possibility for this processing might be to perform template argument deduction on any deallocation function templates; if there is a specialization that matches the allocation function, by the criteria listed in paragraph 20, that function template would be instantiated and used, although a matching non-template function would take precedence as is the usual outcome of overloading between function template specializations and non-template functions.

Another possibility might be to match non-template deallocation functions with non-template allocation functions and template deallocation functions with template allocation functions.

There is a slightly related wording problem in 5.3.4 [expr.new] paragraph 21:

> If a placement deallocation function is called, it is passed the same additional arguments as were passed to the placement allocation function, that is, the same arguments as those specified with the new-placement syntax.

This wording ignores the possibility of default arguments in the allocation function, in which case the arguments passed to the deallocation function might be a superset of those specified in the new-placement.

(See also issue 1682.)

#### 1748. Placement new with a null pointer

Section: 5.3.4 [expr.new] Status: open Submitter: Marc Glisse Date: 2013-09-11

According to 5.3.4 [expr.new] paragraph 15,

> [Note: unless an allocation function is declared with a non-throwing exception-specification (15.4 [except.spec]), it indicates failure to allocate storage by throwing a `std::bad_alloc` exception (Clause 15 [except], 18.6.2.1 [bad.alloc]); it returns a non-null pointer otherwise. If the allocation function is declared with a non-throwing exception-specification, it returns null to indicate failure to allocate storage and a non-null pointer otherwise. —end note] If the allocation function returns null, initialization shall not be done, the deallocation function shall not be called, and the value of the new-expression shall be null.

This wording applies even to the non-replaceable placement forms defined in 18.6.1.3 [new.delete.placement] that simply return the supplied pointer as the result of the allocation function. Compilers are thus required to check for a null pointer and avoid the initialization if one is used. This test is unnecessary overhead; it should be the user's responsibility to ensure that a null pointer is not used in these forms of placement new, just as for other cases when a pointer is dereferenced.

#### 196. Arguments to deallocation functions

Section: 5.3.5 [expr.delete] Status: open Submitter: Matt Austern Date: 20 Jan 2000

5.3.4 [expr.new] paragraph 10 says that the result of an array allocation function and the value of the array new-expression from which it was invoked may be different, allowing for space preceding the array to be used for implementation purposes such as saving the number of elements in the array. However, there is no corresponding description of the relationship between the operand of an array delete-expression and the argument passed to its deallocation function.

3.7.4.2 [basic.stc.dynamic.deallocation] paragraph 3 does state that

> the value supplied to `operator delete[](void*)` in the standard library shall be one of the values returned by a previous invocation of either `operator new[](std::size_t)` or `operator new[](std::size_t, const std::nothrow_t&)` in the standard library.

This statement might be read as requiring an implementation, when processing an array delete-expression and calling the deallocation function, to perform the inverse of the calculation applied to the result of the allocation function to produce the value of the new-expression. (5.3.5 [expr.delete] paragraph 2 requires that the operand of an array delete-expression "be the pointer value which resulted from a previous array new-expression.") However, it is not completely clear whether the "shall" expresses an implementation requirement or a program requirement (or both). Furthermore, there is no direct statement about user-defined deallocation functions.

Suggested resolution: A note should be added to 5.3.5 [expr.delete] to clarify that any offset added in an array new-expression must be subtracted in the array delete-expression.

#### 1788. Sized deallocation of array of non-class type

Section: 5.3.5 [expr.delete] Status: open Submitter: Richard Smith Date: 2013-09-29

The changes from N3778 require use of a sized deallocator for a case like

      char *p = new char[32];
      void f() { delete [] p; }

That is unimplementable under current ABIs, which do not store the array size for such allocations. It should instead be unspecified or implementation-defined whether the sized form of `operator[]` is used for a pointer to a type other than a class with a non-trivial destructor or array thereof.

#### 242. Interpretation of old-style casts

Section: 5.4 [expr.cast] Status: open Submitter: Mike Miller Date: 30 Aug 2000

The meaning of an old-style cast is described in terms of `const_cast`, `static_cast`, and `reinterpret_cast` in 5.4 [expr.cast] paragraph 5. Ignoring `const_cast` for the moment, it basically says that if the conversion performed by a given old-style cast is one of those performed by `static_cast`, the conversion is interpreted as if it were a `static_cast`; otherwise, it's interpreted as if it were a `reinterpret_cast`, if possible. The following example is given in illustration:

        struct A {};
        struct I1 : A {};
        struct I2 : A {};
        struct D : I1, I2 {};
        A *foo( D *p ) {
    	return (A*)( p ); // ill-formed static_cast interpretation
        }

The obvious intent here is that a derived-to-base pointer conversion is one of the conversions that can be performed using `static_cast`, so `(A*)(p)` is equivalent to `static_cast<A*>(p)`, which is ill-formed because of the ambiguity.

Unfortunately, the description of `static_cast` in 5.2.9 [expr.static.cast] does NOT support this interpretation. The problem is in the way 5.2.9 [expr.static.cast] lists the kinds of casts that can be performed using `static_cast`. Rather than saying something like "All standard conversions can be performed using `static_cast`," it says

> An expression e can be explicitly converted to a type `T` using a `static_cast` of the form `static_cast<T>(e)` if the declaration "`T t(e);`" is well-formed, for some invented temporary variable `t`.

Given the declarations above, the hypothetical declaration

        A* t(p);

is NOT well-formed, because of the ambiguity. Therefore the old-style cast `(A*)(p)` is NOT one of the conversions that can be performed using `static_cast`, and `(A*)(p)` is equivalent to `reinterpret_cast<A*>(p)`, which is well-formed under 5.2.10 [expr.reinterpret.cast] paragraph 7.

Other situations besides ambiguity which might raise similar questions include access violations, casting from virtual base to derived, and casting pointers-to-members when virtual inheritance is involved.

#### 1256. Unevaluated operands are not necessarily constant expressions

Section: 5.19 [expr.const] Status: open Submitter: Nikolay Ivchenkov Date: 2011-03-08

The current definition of constant expressions appears to make unevaluated operands constant expressions; for example, `new char[10]` would seem to be a constant expression if it appears as the operand of `sizeof`. This seems wrong.

#### 1757. Const integral subobjects

Section: 5.19 [expr.const] Status: open Submitter: Richard Smith Date: 2013-09-20

The requirements for a constant expression in 5.19 [expr.const] permit an lvalue-to-rvalue conversion on

> a non-volatile glvalue of integral or enumeration type that refers to a non-volatile const object with a preceding initialization, initialized with a constant expression

This does not exclude subobjects of objects that are not compile-time constants, for example:

      int f();
      struct S {
        S() : a(f()), b(5) {}
        int a, b;
      };
      const S s;
      constexpr int k = s.b;

This rule is intended to provide backward compatibility with pre-`constexpr` C++, but it should be restricted to complete objects. Care should be taken in resolving this issue not to break the handling of string literals, since use of their elements in constant expressions depends on the current form of this rule.

#### 157. Omitted typedef declarator

Section: 7 [dcl.dcl] Status: open Submitter: Daveed Vandevoorde Date: 19 Aug 1999

7 [dcl.dcl] paragraph 3 reads,

> In a simple-declaration, the optional init-declarator-list can be omitted only when... the decl-specifier-seq contains either a class-specifier, an elaborated-type-specifier with a class-key (9.1 [class.name] ), or an enum-specifier. In these cases and whenever a class-specifier or enum-specifier is present in the decl-specifier-seq, the identifiers in those specifiers are among the names being declared by the declaration... In such cases, and except for the declaration of an unnamed bit-field (9.6 [class.bit] ), the decl-specifier-seq shall introduce one or more names into the program, or shall redeclare a name introduced by a previous declaration. [Example:

>         enum { };           // ill-formed
>         typedef class { };  // ill-formed

> —end example]

In the absence of any explicit restrictions in 7.1.3 [dcl.typedef] , this paragraph appears to allow declarations like the following:

        typedef struct S { };    // no declarator
        typedef enum { e1 };     // no declarator

In fact, the final example in 7 [dcl.dcl] paragraph 3 would seem to indicate that this is intentional: since it is illustrating the requirement that the decl-specifier-seq must introduce a name in declarations in which the init-declarator-list is omitted, presumably the addition of a class name would have made the example well-formed.

On the other hand, there is no good reason to allow such declarations; the only reasonable scenario in which they might occur is a mistake on the programmer's part, and it would be a service to the programmer to require that such errors be diagnosed.

#### 498. Storage class specifiers in definitions of class members

Section: 7.1.1 [dcl.stc] Status: open Submitter: Matt Austern Date: 13 Jan 2005

Suppose we've got this class definition:

        struct X {
           void f();
           static int n;
        };

I think I can deduce from the existing standard that the following member definitions are ill-formed:

        static void X::f() { }
        static int X::n;

To come to that conclusion, however, I have to put together several things in different parts of the standard. I would have expected to find an explicit statement of this somewhere; in particular, I would have expected to find it in 7.1.1 [dcl.stc]. I don't see it there, or anywhere.

Gabriel Dos Reis: Or in 3.5 [basic.link] which is about linkage. I would have expected that paragraph to say that that members of class types have external linkage when the enclosing class has an external linkage. Otherwise 3.5 [basic.link] paragraph 8:

> Names not covered by these rules have no linkage.

might imply that such members do not have linkage.

Notes from the April, 2005 meeting:

The question about the linkage of class members is already covered by 3.5 [basic.link] paragraph 5.

#### 1793. `thread_local` in explicit specializations

Section: 7.1.1 [dcl.stc] Status: open Submitter: Mike Herrick Date: 2013-10-02

According to 7.1.1 [dcl.stc] paragraph 1,

> ...If `thread_local` appears in any declaration of a variable it shall be present in all declarations of that entity... A storage-class-specifier shall not be specified in an explicit specialization (14.7.3 [temp.expl.spec]) or an explicit instantiation (14.7.2 [temp.explicit]) directive.

These two requirements appear to be in conflict when an explicit instantiation or explicit specialization names a `thread_local` variable. For example,

      template <class T> struct S {
        thread_local static int tlm;
      };
      template <> int S<int>::tlm = 0;
      template <> thread_local int S<float>::tlm = 0;

which of the two explicit specializations is correct?

#### 1745. `thread_local constexpr` variable

Section: 7.1.5 [dcl.constexpr] Status: open Submitter: John Spicer Date: 2013-09-05

Neither 7.1.5 [dcl.constexpr] nor 7.1.1 [dcl.stc] forbids combining the `thread_local` and `constexpr` specifiers in the declaration of a variable. Should this combination be permitted?

#### 609. What is a “top-level” cv-qualifier?

Section: 7.1.6.1 [dcl.type.cv] Status: open Submitter: Dawn Perchik Date: 5 November 2006

The phrase “top-level cv-qualifier” is used numerous times in the Standard, but it is not defined. The phrase could be misunderstood to indicate that the `const` in something like `const T&` is at the “top level,” because where it appears is the highest level at which it is permitted: `T& const` is ill-formed.

#### 144. Position of `friend` specifier

Section: 7.1.6.3 [dcl.type.elab] Status: open Submitter: Daveed Vandevoorde Date: 22 Jul 1999

7.1.6.3 [dcl.type.elab] paragraph 1 seems to impose an ordering constraint on the elements of friend class declarations. However, the general rule is that declaration specifiers can appear in any order. Should

        class C friend;

be well-formed?

#### 1670. `auto` as conversion-type-id

Section: 7.1.6.4 [dcl.spec.auto] Status: open Submitter: Richard Smith Date: 2013-04-26
N3690 comment FI 4

The current wording allows something like

      struct S {
        operator auto() { return 0; }
      } s;

If it is intended to be permitted, the details of its handling are not clear. Also, a similar syntax has been discussed as a possible future extension for dealing with proxy types in deduction which, if adopted, could cause confusion.

#### 1766. Values outside the range of the values of an enumeration

Section: 7.2 [dcl.enum] Status: open Submitter: CWG Date: 2013-09-23

Although issue 1094 clarified that the value of an expression of enumeration type might not be within the range of the values of the enumeration after a conversion to the enumeration type (see 5.2.9 [expr.static.cast] paragraph 10), the result is simply an unspecified value. This should probably be strengthened to produce undefined behavior, in light of the fact that undefined behavior makes an expression non-constant. See also 9.6 [class.bit] paragraph 4.

#### 987. Which declarations introduce namespace members?

Section: 7.3 [basic.namespace] Status: open Submitter: Michael Wong Date: 19 October, 2009

According to 7.3 [basic.namespace] paragraph 1,

> The name of a namespace can be used to access entities declared in that namespace; that is, the members of the namespace.

implying that all declarations in a namespace, including definitions of members of nested namespaces, explicit instantiations, and explicit specializations, introduce members of the containing namespace. 7.3.1.2 [namespace.memdef] paragraph 3 clarifies the intent somewhat:

> Every name first declared in a namespace is a member of that namespace.

However, current changes to clarify the behavior of deleted functions (which must be deleted on their “first declaration”) state that an explicit specialization of a function template is its first declaration.

#### 1795. Disambiguating original-namespace-definition and extension-namespace-definition

Section: 7.3.1 [namespace.def] Status: open Submitter: Richard Smith Date: 2013-10-04

According to 7.3.1 [namespace.def] paragraph 2,

> The identifier in an original-namespace-definition shall not have been previously defined in the declarative region in which the original-namespace-definition appears.

Apparently the intent of this requirement is to say that, given the declarations

      namespace N { }
      namespace N { }

the second declaration is to be taken as an extension-namespace-definition and not an original-namespace-definition, since the general rules in 3.3.1 [basic.scope.declarative] cover the case in which the identifier has been previously declared as something other than a namespace.

This use of “shall” for disambiguation is novel, however, and it would be better to replace it with a specific statement addressing disambiguation in paragraphs 2 and 3.

#### 1021. Definitions of namespace members

Section: 7.3.1.2 [namespace.memdef] Status: open Submitter: Michael Wong Date: 2010-01-14

According to 7.3.1.2 [namespace.memdef] paragraphs 1 and 2 read,

> Members (including explicit specializations of templates (14.7.3 [temp.expl.spec])) of a namespace can be defined within that namespace.

> Members of a named namespace can also be defined outside that namespace by explicit qualification (3.4.3.2 [namespace.qual]) of the name being defined, provided that the entity being defined was already declared in the namespace and the definition appears after the point of declaration in a namespace that encloses the declaration's namespace.

It is not clear what these specifications mean for the following pair of examples:

        namespace N {
            struct A;
        }
        using N::A;
        struct A { };

Although this does not satisfy the “by explicit qualification” requirement, it is accepted by major implementations.

        struct S;
        namespace A {
            using ::S;
            struct S  { };
        }

Is this a definition “within that namespace,” or should that wording be interpreted as “directly within” the namespace?

#### 36. using-declarations in multiple-declaration contexts

Section: 7.3.3 [namespace.udecl] Status: open Submitter: Andrew Koenig Date: 20 Aug 1998

Section 7.3.3 [namespace.udecl] paragraph 8 says:

> A using-declaration is a declaration and can therefore be used repeatedly where (and only where) multiple declarations are allowed.

It contains the following example:

        namespace A {
                int i;
        }

        namespace A1 {
                using A::i;
                using A::i;             // OK: double declaration
        }

        void f()
        {
                using A::i;
                using A::i;             // error: double declaration
        }

However, if "`using A::i;`" is really a declaration, and not a definition, it is far from clear that repeating it should be an error in either context. Consider:

        namespace A {
                int i;
                void g();
        }

        void f() {
                using A::g;
                using A::g;
        }

Surely the definition of f should be analogous to

        void f() {
                void g();
                void g();
        }

which is well-formed because "`void g();`" is a declaration and not a definition.

Indeed, if the double using-declaration for `A::i` is prohibited in `f`, why should it be allowed in namespace `A1`?

Proposed Resolution (04/99): Change the comment "`// error: double declaration`" to "`// OK: double declaration`". (This should be reviewed against existing practice.)

Notes from 04/00 meeting:

The core language working group was unable to come to consensus over what kind of declaration a using-declaration should emulate. In a straw poll, 7 members favored allowing using-declarations wherever a non-definition declaration could appear, while 4 preferred to allow multiple using-declarations only in namespace scope (the rationale being that the permission for multiple using-declarations is primarily to support its use in multiple header files, which are seldom included anywhere other than namespace scope). John Spicer pointed out that `friend` declarations can appear multiple times in class scope and asked if using-declarations would have the same property under the "like a declaration" resolution.

As a result of the lack of agreement, the issue was returned to "open" status.

See also issues 56, 85, and 138..

Additional notes (January, 2005):

Some related issues have been raised concerning the following example (modified from a C++ validation suite test):

        struct A
        {
            int i;
            static int j;
        };

        struct B : A { };
        struct C : A { };

        struct D : virtual B, virtual C
        {
            using B::i;
            using C::i;
            using B::j;
            using C::j;
        };

Currently, it appears that the using-declarations of `i` are ill-formed, on the basis of 7.3.3 [namespace.udecl] paragraph 10:

> Since a using-declaration is a declaration, the restrictions on declarations of the same name in the same declarative region (3.3 [basic.scope]) also apply to using-declarations.

Because the using-declarations of `i` refer to different objects, declaring them in the same scope is not permitted under 3.3 [basic.scope]. It might, however, be preferable to treat this case as many other ambiguities are: allow the declaration but make the program ill-formed if a name reference resolves to the ambiguous declarations.

The status of the using-declarations of `j`, however, is less clear. They both declare the same entity and thus do not violate the rules of 3.3 [basic.scope]. This might (or might not) violate the restrictions of 9.2 [class.mem] paragraph 1:

> Except when used to declare friends (11.3 [class.friend]) or to introduce the name of a member of a base class into a derived class (7.3.3 [namespace.udecl], _N3225_.11.3 [class.access.dcl]), member-declarations declare members of the class, and each such member-declaration shall declare at least one member name of the class. A member shall not be declared twice in the member-specification, except that a nested class or member class template can be declared and then later defined.

Do the using-declarations of `j` repeatedly declare the same member? Or is the preceding sentence an indication that a using-declaration is not a declaration of a member?

#### 813. `typename` in a using-declaration with a non-dependent name

Section: 7.3.3 [namespace.udecl] Status: open Submitter: UK Date: 3 March, 2009
N2800 comment UK 101

7.3.3 [namespace.udecl] paragraph 20 says,

> If a using-declaration uses the keyword `typename` and specifies a dependent name (14.6.2 [temp.dep]), the name introduced by the using-declaration is treated as a typedef-name (7.1.3 [dcl.typedef]).

This wording does not address use of `typename` in a using-declaration with a non-dependent name; the primary specification of the `typename` keyword in 14.6 [temp.res] does not appear to describe this case, either.

#### 852. using-declarations and dependent base classes

Section: 7.3.3 [namespace.udecl] Status: open Submitter: Michael Wong Date: 2 April, 2009

The status of an example like the following is unclear in the current Standard:

        struct B {
            void f();
        };
        template<typename T> struct S: T {
            using B::f;
        };

7.3.3 [namespace.udecl] does not deal explicitly with dependent base classes, but does say in paragraph 3,

> In a using-declaration used as a member-declaration, the nested-name-specifier shall name a base class of the class being defined. If such a using-declaration names a constructor, the nested-name-specier shall name a direct base class of the class being defined; otherwise it introduces the set of declarations found by member name lookup (10.2 [class.member.lookup], 3.4.3.1 [class.qual]).

In the definition of `S`, `B::f` is not a dependent name but resolves to an apparently unrelated class. However, because `S` could be instantiated as `S<B>`, presumably 14.6 [temp.res] paragraph 8 would apply:

> No diagnostic shall be issued for a template definition for which a valid specialization can be generated.

Note also the resolution of issue 515, which permitted a similar use of a dependent base class named with a non-dependent name.

#### 1742. using-declarations and scoped enumerators

Section: 7.3.3 [namespace.udecl] Status: open Submitter: Richard Smith Date: 2013-08-28

A using-declaration cannot name a scoped enumerator, according to 7.3.3 [namespace.udecl] paragraph 7. This is presumably because a scoped enumerator belongs to an enumeration scope and thus logically cannot belong to the non-enumeration scope in which the using-declaration appears. It seems inconsistent, however, to permit using-declarations to name unscoped enumerators but not scoped enumerators.

Also, 7.3.3 [namespace.udecl] paragraph 3 says,

> In a using-declaration used as a member-declaration, the nested-name-specifier shall name a base class of the class being defined.

The consequence of this is that

      enum E { e0 };
      void f() {
        using E::e0;
      }

is well-formed, but

      struct B {
        enum E { e0 };
      };
      struct D : B {
        using B::E::e0;
      };

is not. Again, this seems inconsistent. Should these rules be relaxed?

#### 563. Linkage specification for objects

Section: 7.5 [dcl.link] Status: open Submitter: Daveed Vandevoorde Date: 8 March 2006

It is not clear whether some of the wording in 7.5 [dcl.link] that applies only to function types and names ought also to apply to object names. In particular, paragraph 3 says,

> Every implementation shall provide for linkage to functions written in the C programming language, `"C"`, and linkage to C++ functions, `"C++"`.

Nothing is said about variable names, apparently meaning that implementations need not provide C (or even C++!) linkage for variable names. Also, paragraph 5 says,

> Except for functions with C++ linkage, a function declaration without a linkage specification shall not precede the first linkage specification for that function. A function can be declared without a linkage specification after an explicit linkage specification has been seen; the linkage explicitly specified in the earlier declaration is not affected by such a function declaration.

There doesn't seem to be a good reason for these provisions not to apply to variable names, as well.

#### 1713. Linkage of variable template specializations

Section: 7.5 [dcl.link] Status: open Submitter: Richard Smith Date: 2013-07-08

Given a namespace-scope declaration like

      template<typename T> T var = T();

should `T<const int>` have internal linkage by virtue of its const-qualified type? Or should it inherit the linkage of the template?

#### 1706. `alignas` pack expansion syntax

Section: 7.6.1 [dcl.attr.grammar] Status: open Submitter: Daveed Vandevoorde Date: 2013-06-26

The grammar for alignment-specifier in 7.6.1 [dcl.attr.grammar] paragraph 1 is:

alignment-specifier:

`alignas (` type-id `...`opt`)`
`alignas (` assignment-expression `...`opt`)`

where the ellipsis indicates pack expansion. Naively, one would expect that the expansion would result in forms like

        alignas()
        alignas(1, 2)
        alignas(int, double)

but none of those forms is given any meaning by the current wording. Instead, 14.5.3 [temp.variadic] paragraph 4 says,

> In an alignment-specifier (7.6.2 [dcl.align]); the pattern is the alignment-specifier without the ellipsis.

Presumably this means that something like `alignas(T...)` would expand to something like

        alignas(int) alignas(double)

This is counterintuitive and should be reexamined.

See also messages 24016 through 24021.

#### 1617. `alignas` and non-defining declarations

Section: 7.6.2 [dcl.align] Status: open Submitter: Richard Smith Date: 2012-02-02

According to 7.6.2 [dcl.align] paragraph 6,

> If the defining declaration of an entity has an alignment-specifier, any non-defining declaration of that entity shall either specify equivalent alignment or have no alignment-specifier. Conversely, if any declaration of an entity has an alignment-specifier, every defining declaration of that entity shall specify an equivalent alignment. No diagnostic is required if declarations of an entity have different alignment-specifiers in different translation units.

Because this is phrased in terms of the definition of an entity, an example like the following is presumably well-formed (even though there can be no definition of `n`):

       alignas(8) extern int n;
       alignas(16) extern int n;

Is this intentional?

#### 504. Should use of a variable in its own initializer require a diagnostic?

Section: 8.3.2 [dcl.ref] Status: open Submitter: Bjarne Stroustrup Date: 14 Apr 2005

Split off from issue 453.

It is in general not possible to determine at compile time whether a reference is used before it is initialized. Nevertheless, there is some sentiment to require a diagnostic in the obvious cases that can be detected at compile time, such as the name of a reference appearing in its own initializer. The resolution of issue 453 originally made such uses ill-formed, but the CWG decided that this question should be a separate issue.

Rationale (October, 2005):

The CWG felt that this error was not likely to arise very often in practice. Implementations can warn about such constructs, and the resolution for issue 453 makes executing such code undefined behavior; that seemed to address the situation adequately.

Note (February, 2006):

Recent discussions have suggested that undefined behavior be reduced. One possibility (broadening the scope of this issue to include object declarations as well as references) was to require a diagnostic if the initializer uses the value, but not just the address, of the object or reference being declared:

        int i = i;        // Ill-formed, diagnostic required
        void* p = &p;     // Okay

#### 393. Pointer to array of unknown bound in template argument list in parameter

Section: 8.3.5 [dcl.fct] Status: open Submitter: Mark Mitchell Date: 12 Dec 2002

EDG rejects this code:

      template <typename T>
      struct S {};

      void f (S<int (*)[]>);

G++ accepts it.

This is another case where the standard isn't very clear:

The language from 8.3.5 [dcl.fct] is:

> If the type of a parameter includes a type of the form "pointer to array of unknown bound of T" or "reference to array of unknown bound of T," the program is ill-formed.

Since "includes a type" is not a term defined in the standard, we're left to guess what this means. (It would be better if this were a recursive definition, the way a type theoretician would do it:

- Every type includes itself.
- T* includes T
- T[] includes T
- ...

)

Notes from April 2003 meeting:

We agreed that the example should be allowed.

Additional note (January, 2013):

Additional discussion of this issue has arisen . For example, the following is permissible:

      T (*p) [] = (U(*)[])0;

but the following is not:

      template<class T>
      void sp_assert_convertible( T* ) {}

      sp_assert_convertible<T[]>( (U(*)[])0 );

#### 550. Pointer to array of unknown bound in parameter declarations

Section: 8.3.5 [dcl.fct] Status: open Submitter: Daveed Vandevoorde Date: 22 November 2005

The current wording of 8.3.5 [dcl.fct] paragraph 6 encompasses more than it should:

> If the type of a parameter includes a type of the form “pointer to array of unknown bound of `T`” or “reference to array of unknown bound of `T`,” the program is ill-formed. [Footnote: This excludes parameters of type “ptr-arr-seq `T2`” where `T2` is “pointer to array of unknown bound of `T`” and where ptr-arr-seq means any sequence of “pointer to” and “array of” derived declarator types. This exclusion applies to the parameters of the function, and if a parameter is a pointer to function or pointer to member function then to its parameters also, etc. —end footnote]

The normative wording (contrary to the intention expressed in the footnote) excludes declarations like

        template<class T> struct S {};
        void f(S<int (*)[]>);

and

        struct S {};
        void f(int(*S::*)[]);

but not

        struct S {};
        void f(int(S::*)[]);

#### 1790. Ellipsis following function parameter pack

Section: 8.3.5 [dcl.fct] Status: open Submitter: Daryle Walker Date: 2013-10-01

Although the current wording permits an ellipsis to immediately follow a function parameter pack, it is not clear that the `<cstdarg>` facilities permit access to the ellipsis arguments.

#### 361. Forward reference to default argument

Section: 8.3.6 [dcl.fct.default] Status: open Submitter: Steve Clamage Date: 17 June 2002

Is this program well-formed?

      struct S {
        static int f2(int = f1()); // OK?
        static int f1(int = 2);
      };
      int main()
      {
        return S::f2();
      }

A class member function can in general refer to class members that are declared lexically later. But what about referring to default arguments of member functions that haven't yet been declared?

It seems to me that if f2 can refer to f1, it can also refer to the default argument of f1, but at least one compiler disagrees.

Notes from the February, 2012 meeting:

Implementations seem to have come to agreement that this example is ill-formed.

Additional note (March, 2013):

Additional discussion has occurred suggesting the following examples as illustrations of this issue:

      struct B {
       struct A { int a = 0; };
       B(A = A());    // Not permitted?
      };

as well as

      struct C {
       struct A { int a = C().n; }; // can we use the default argument here?
       C(int k = 0);
       int n;
      };

      bool f();
      struct D {
       struct A { bool a = noexcept(B()); }; // can we use the default initializer here?
       struct B { int b = f() ? throw 0 : 0; };
      };

(See also issue 325.)

Additional note (October, 2013):

Issue 1330 treats exception-specifications like default arguments, evaluated in the completed class type. That raises the same questions regarding self-referential `noexcept` clauses that apply to default arguments.

#### 1609. Default arguments and function parameter packs

Section: 8.3.6 [dcl.fct.default] Status: open Submitter: Jonathan Caves Date: 2013-01-25

It is not clear from 8.3.6 [dcl.fct.default] whether the following is well-formed or not:

      template<typename... T>
      void f2(int a = 0, T... b, int c = 1);

      f2<>(); // parameter a has the value 0 and parameter c has the value 1

(`T... b` is a non-deduced context per 14.8.2.5 [temp.deduct.type] paragraph 5, so the template arguments must be specified explicitly.)

Notes from the April, 2013 meeting:

CWG agreed that the example should be ill-formed.

Additional note (August, 2013):

8.3.6 [dcl.fct.default] paragraph 4 explicitly allows for a function parameter pack to follow a parameter with a default argument:

> In a given function declaration, each parameter subsequent to a parameter with a default argument shall have a default argument supplied in this or a previous declaration or shall be a function parameter pack.

However, any instantiation of such a function template with a non-empty pack expansion would result in a function declaration in which one or more parameters without default arguments (from the pack expansion) would follow a parameter with a default argument and thus would be ill-formed. Such a function template declaration thus violates 14.6 [temp.res] paragraph 8:

> If every valid specialization of a variadic template requires an empty template parameter pack, the template is ill-formed, no diagnostic required.

Although the drafting review teleconference of 2013-08-26 suggested closing the issue as NAD, it is being kept open to discuss and resolve this apparent contradiction.

Notes from the September, 2013 meeting:

CWG agreed that this example should be accepted; the restriction on default arguments applies to the template declaration itself, not to its specializations.

#### 1791. Incorrect restrictions on cv-qualifier-seq and ref-qualifier

Section: 8.4.1 [dcl.fct.def.general] Status: open Submitter: David Krauss Date: 2013-10-01

Paragraph 5 of 8.4.1 [dcl.fct.def.general] says,

> A cv-qualifier-seq or a ref-qualifier (or both) can be part of a non-static member function declaration, non-static member function definition, or pointer to member function only (8.3.5 [dcl.fct]); see 9.3.2 [class.this].

This is redundant with the specification in 8.3.5 [dcl.fct] paragraph 6 and is factually incorrect, since the list there contains other permissible constructs. It should be at most a note or possibly removed altogether.

#### 670. Copy initialization via derived-to-base conversion in the second step

Section: 8.5 [dcl.init] Status: open Submitter: Jason Merrill Date: 20 December 2007

In this example:

        struct A {};

        struct B: A {
           B(int);
           B(B&);
           B(A);
        };

        void foo(B);

        void bar() {
           foo(0);
        }

we are copy-initializing a `B` from `0`. So by 13.3.1.4 [over.match.copy] we consider all the converting constructors of `B`, and choose `B(int)` to create a `B`. Then, by 8.5 [dcl.init] paragraph 15, we direct-initialize the parameter from that temporary `B`. By 13.3.1.3 [over.match.ctor] we consider all constructors. The copy constructor cannot be called with a temporary, but `B(A)` is callable.

As far as I can tell, the Standard says that this example is well-formed, and calls `B(A)`. EDG and G++ have rejected this example with a message about the copy constructor not being callable, but I have been unsuccessful in finding anything in the Standard that says that we only consider the copy constructor in the second step of copy-initialization. I wouldn't mind such a rule, but it doesn't seem to be there. And implementing issue 391 causes G++ to start accepting the example.

This question came up before in a GCC bug report; in the discussion of that bug Nathan Sidwell said that some EDG folks explained to him why the testcase is ill-formed, but unfortunately didn't provide that explanation in the bug report.

I think the resolution of issue 391 makes this example well-formed; it was previously ill-formed because in order to bind the temporary `B(0)` to the argument of `A(const A&)` we needed to make another temporary `B`, and that's what made the example ill-formed. If we want this example to stay ill-formed, we need to change something else.

Steve Adamczyk:

I tracked down my response to Nathan at the time, and it related to my paper N1232 (on the `auto_ptr` problem). The change that came out of that paper is in 13.3.3.1 [over.best.ics] paragraph 4:

> However, when considering the argument of a user-defined conversion function that is a candidate by 13.3.1.3 [over.match.ctor] when invoked for the copying of the temporary in the second step of a class copy-initialization, or by 13.3.1.4 [over.match.copy], 13.3.1.5 [over.match.conv], or 13.3.1.6 [over.match.ref] in all cases, only standard conversion sequences and ellipsis conversion sequences are allowed.

This is intended to prevent use of more than one implicit user- defined conversion in an initialization.

I told Nathan `B(A)` can't be called because its argument would require yet another user-defined conversion, but I was wrong. I saw the conversion from `B` to `A` and immediately thought “user-defined,” but in fact because `B` is a derived class of `A` the conversion according to 13.3.3.1 [over.best.ics] paragraph 6 is a derived-to-base Conversion (even though it will be implemented by calling a copy constructor).

So I agree with you: with the analysis above and the change for issue 391 this example is well-formed. We should discuss whether we want to make a change to keep it ill-formed.

#### 1782. Form of initialization for `nullptr_t` to `bool` conversion

Section: 8.5 [dcl.init] Status: open Submitter: Hubert Tong Date: 2013-02-26

According to 8.5 [dcl.init] paragraph 14,

> The form of initialization (using parentheses or `=`) is generally insignificant, but does matter when the initializer or the entity being initialized has a class type; see below.

This does not consider conversions from `std::nullptr_t` to `bool`, which are permitted only for direct-initialization (4.12 [conv.bool]).

#### 233. References vs pointers in UDC overload resolution

Section: 8.5.3 [dcl.init.ref] Status: open Submitter: Matthias Meixner Date: 9 Jun 2000

There is an inconsistency in the handling of references vs pointers in user defined conversions and overloading. The reason for that is that the combination of 8.5.3 [dcl.init.ref] and 4.4 [conv.qual] circumvents the standard way of ranking conversion functions, which was probably not the intention of the designers of the standard.

Let's start with some examples, to show what it is about:

        struct Z { Z(){} };

        struct A {
           Z x;

           operator Z *() { return &x; }
           operator const Z *() { return &x; }
        };

        struct B {
           Z x;

           operator Z &() { return x; }
           operator const Z &() { return x; }
        };

        int main()
        {
           A a;
           Z *a1=a;
           const Z *a2=a; // not ambiguous

           B b;
           Z &b1=b;
           const Z &b2=b; // ambiguous
        }

So while both classes `A` and `B` are structurally equivalent, there is a difference in operator overloading. I want to start with the discussion of the pointer case (`const Z *a2=a;`): 13.3.3 [over.match.best] is used to select the best viable function. Rule 4 selects `A::operator const Z*()` as best viable function using 13.3.3.2 [over.ics.rank] since the implicit conversion sequence `const Z*` -> `const Z*` is a better conversion sequence than `Z*` -> `const Z*`.

So what is the difference to the reference case? Cv-qualification conversion is only applicable for pointers according to 4.4 [conv.qual]. According to 8.5.3 [dcl.init.ref] paragraphs 4-7 references are initialized by binding using the concept of reference-compatibility. The problem with this is, that in this context of binding, there is no conversion, and therefore there is also no comparing of conversion sequences. More exactly all conversions can be considered identity conversions according to 13.3.3.1.4 [over.ics.ref] paragraph 1, which compare equal and which has the same effect. So binding `const Z*` to `const Z*` is as good as binding `const Z*` to `Z*` in terms of overloading. Therefore `const Z &b2=b;` is ambiguous. [13.3.3.1.4 [over.ics.ref] paragraph 5 and 13.3.3.2 [over.ics.rank] paragraph 3 rule 3 (S1 and S2 are reference bindings ...) do not seem to apply to this case]

There are other ambiguities, that result in the special treatment of references: Example:

        struct A {int a;};
        struct B: public A { B() {}; int b;};

        struct X {
           B x;
           operator A &() { return x; }
           operator B &() { return x; }
        };

        main()
        {
           X x;
           A &g=x; // ambiguous
        }

Since both references of class `A` and `B` are reference compatible with references of class `A` and since from the point of ranking of implicit conversion sequences they are both identity conversions, the initialization is ambiguous.

So why should this be a defect?

- References behave fundamentally different from pointers in combination with user defined conversions, although there is no reason to have this different treatment.
- This difference only shows up in combination with user defined conversion sequences, for all other cases, there are special rules, e.g. 13.3.3.2 [over.ics.rank] paragraph 3 rule 3.

So overall I think this was not the intention of the authors of the standard.

So how could this be fixed? For comparing conversion sequences (and only for comparing) reference binding should be treated as if it was a normal assignment/initialization and cv-qualification would have to be defined for references. This would affect 8.5.3 [dcl.init.ref] paragraph 6, 4.4 [conv.qual] and probably 13.3.3.2 [over.ics.rank] paragraph 3.

Another fix could be to add a special case in 13.3.3 [over.match.best] paragraph 1.

#### 1650. Class prvalues in reference initialization

Section: 8.5.3 [dcl.init.ref] Status: open Submitter: Michael Wong Date: 2013-04-15

As described in the “additional note, January, 2012” in issue 1287, questions were raised regarding the treatment of class prvalues in the original proposed resolution and the proposed resolution was revised (February, 2012) to address those concerns. The revised resolution raised its own set of concerns with regard to slicing and performance, however, and the issue was moved back to "review" status to allow further discussion.

At the April, 2013 meeting, it was decided to proceed with the original resolution of issue 1287 and split off the concerns regarding class prvalues into this issue.

Notes from the September, 2013 meeting:

The resolution for issue 1604 results in indirect binding to a subobject and will no longer cause slicing.

#### 1599. Lifetime of `initializer_list` underlying array

Section: 8.5.4 [dcl.init.list] Status: open Submitter: Johannes Schaub Date: 2012-02-10

The normative wording of 8.5.4 [dcl.init.list] regarding the lifetime of the array underlying an `initializer_list` object does not match the intent as specified in the example in paragraph 6 of that section, even after application of the resolution of issue 1290. That example contains the lines:

      void f() {
        std::initializer_list<int> i3 = { 1, 2, 3 };
      }

The commentary indicates that the lifetime of the array created for the initialization of `i3` “persists for the lifetime of the variable.” However, that is not the effect of the normative wording. According to paragraph 3,

> if `T` is a specialization of `std::initializer_list<E>`, an `initializer_list` object is constructed as described below and used to initialize the object according to the rules for initialization of an object from a class of the same type (8.5 [dcl.init]).

In other words, the underlying array for `{1,2,3}` in the example is associated with the temporary and shares its lifetime; its lifetime is not extended to that of the variable.

#### 1756. Direct-list-initialization of a non-class object

Section: 8.5.4 [dcl.init.list] Status: open Submitter: Richard Smith Date: 2013-09-20

The wording of 8.5.4 [dcl.init.list] paragraph 3,

> if the initializer list has a single element of type `E` and either `T` is not a reference type or its referenced type is reference-related to `E`, the object or reference is initialized from that element

does not specify whether the initialization is direct-initialization, copy-initialization, or the same kind of initialization that applied to the list-initialization. This matters when `E` is a class type with an explicit conversion function. (Note that aggregate initialization performs copy-initialization on its subobjects, but it's not clear whether that should be the pattern followed for this case.)

#### 511. POD-structs with template assignment operators

Section: 9 [class] Status: open Submitter: Alisdair Meredith Date: 19 Mar 2005

A POD-struct is not permitted to have a user-declared copy assignment operator (9 [class] paragraph 4). However, a template assignment operator is not considered a copy assignment operator, even though its specializations can be selected by overload resolution for performing copy operations (12.8 [class.copy] paragraph 9 and especially footnote 114). Consequently, `X` in the following code is a POD, notwithstanding the fact that copy assignment (for a non-const operand) is a member function call rather than a bitwise copy:

        struct X {
          template<typename T> const X& operator=(T&);
        };
        void f() {
          X x1, x2;
          x1 = x2;  // calls X::operator=<X>(X&)
        }

Is this intentional?

#### 1660. member-declaration requirements and unnamed bit-fields

Section: 9.2 [class.mem] Status: open Submitter: Richard Smith Date: 2013-04-15

According to 9.2 [class.mem] paragraph 1,

> Except when used to declare friends (11.3 [class.friend]) or to introduce the name of a member of a base class into a derived class (7.3.3 [namespace.udecl]), member-declarations declare members of the class, and each such member-declaration shall declare at least one member name of the class.

Unnamed bit-fields (9.6 [class.bit] paragraph 2) are described as not being members, and they obviously do not declare a member name; presumably they should therefore be included among the exceptions to this rule.

Additional note (October, 2013):

Curiously, the exemption for an unnamed bit-field not introducing names is in 7 [dcl.dcl] paragraph 3, referring to a simple-declaration. However, a simple-declaration is not a member-declaration and thus does not apply.

#### 1719. Layout compatibility and cv-qualification revisited

Section: 9.2 [class.mem] Status: open Submitter: Jeffrey Yasskin Date: 2013-07-24

When the effect of cv-qualification on layout compatibility was previously discussed (see issue 1334), the question was resolved by reference to the historical origin of layout compatibility: it was a weakening of type correctness that was added for C compatibility, mimicking exactly the corresponding C specification of compatible types in this context and going no further. Because cv-qualified and cv-unqualified types are not compatible in C, they were not made layout-compatible in C++.

Because of specific use-cases involving `std::pair` and the like, however, and in consideration of the fact that cv-qualified and cv-unqualified versions of types are aliasable by the rules of 3.10 [basic.lval], the outcome of that question is worthy of reconsideration.

#### 57. Empty unions

Section: 9.5 [class.union] Status: open Submitter: Steve Adamczyk Date: 13 Oct 1998

There doesn't seem to be a prohibition in 9.5 [class.union] against a declaration like

        union { int : 0; } x;

Should that be valid? If so, 8.5 [dcl.init] paragraph 5 third bullet, which deals with default-initialization of unions, should say that no initialization is done if there are no data members.

What about:

        union { } x;
        static union { };

If the first example is well-formed, should either or both of these cases be well-formed as well?

(See also the resolution for issue 151.)

Notes from 10/00 meeting: The resolution to issue 178, which was accepted as a DR, addresses the first point above (default initialization). The other questions have not yet been decided, however.

#### 380. Definition of "ambiguous base class" missing

Section: 10.2 [class.member.lookup] Status: open Submitter: Jason Merrill Date: 22 Oct 2002

The term "ambiguous base class" doesn't seem to be actually defined anywhere. 10.2 [class.member.lookup] paragraph 7 seems like the place to do it.

#### 600. Does access control apply to members or to names?

Section: 11 [class.access] Status: open Submitter: Alisdair Meredith Date: 3 October 2006

Referring to a private member of a class, 11 [class.access] paragraph 1 says,

> its name can be used only by members and friends of the class in which it is declared.

That wording does not appear to reflect the intent of access control, however. Consider the following:

        struct S {
            void f(int);
        private:
            void f(double);
        };

        void g(S* sp) {
            sp->f(2);        // Ill-formed?
        }

The statement from 11 [class.access] paragraph 1 says that the name `f` can be used only by members and friends of `S`. Function `g` is neither, and it clearly contains a use of the name `f`. That appears to make it ill-formed, in spite of the fact that overload resolution will select the public member.

A related question is whether the use of the term “name” in the description of the effect of access control means that it does not apply to constructors and destructors, which do not have names.

Mike Miller: The phrase “its name can be used” should be understood as “it can be referred to by name.” Paragraph 4, among other places, makes it clear that access control is applied after overload resolution. The “name” phrasing is there to indicate that access control does not apply where the name is not used (in a call via a pointer, for example).

#### 360. Using-declaration that reduces access

Section: 11.2 [class.access.base] Status: open Submitter: Steve Clamage Date: 4 June 2002

I have heard a claim that the following code is valid, but I don't see why.

      struct A {
        int foo ();
      };

      struct B: A {
      private:
        using A::foo;
      };

      int main ()
      {
        return B ().foo ();
      }

It seems to me that the using declaration in B should hide the public foo in A. Then the call to B::foo should fail because B::foo is not accessible in main.

Am I missing something?

Steve Adamczyk: This is similar to the last example in 11.2 [class.access.base]. In prose, the rule is that if you have access to cast to a base class and you have access to the member in the base class, you are given access in the derived class. In this case, A is a public base class of B and foo is public in A, so you can access foo through a B object. The actual permission for this is in the fourth bullet in 11.2 [class.access.base] paragraph 4.

The wording changes for issue 9 make this clearer, but I believe even without them this example could be discerned to be valid.

See my paper J16/96-0034, WG21/N0852 on this topic.

Steve Clamage: But a using-declaration is a declaration (7.3.3 [namespace.udecl]). Compare with

      struct B : A {
      private:
        int foo();
      };

In this case, the call would certainly be invalid, even though your argument about casting B to an A would make it OK. Your argument basically says that an access adjustment to make something less accessible has no effect. That also doesn't sound right.

Steve Adamczyk: I agree that is strange. I do think that's what 11.2 [class.access.base] says, but perhaps that's not what we want it to say.

#### 718. Non-class, non-function friend declarations

Section: 11.3 [class.friend] Status: open Submitter: John Spicer Date: 18 September, 2008

With the change from a scope-based to an entity-based definition of friendship (see issues 372 and 580), it could well make sense to grant friendship to enumerations and variables, for example:

        enum E: int;
        class C {
          static const int i = 5;  // Private
          friend E;
          friend int x;
        };
        enum E { e = C::i; };      // OK: E is a friend
        int x = C::i;              // OK: x is a friend

According to the current wording of 11.3 [class.friend] paragraph 3, the friend declaration of `E` is well-formed but ignored, while the friend declaration of `x` is ill-formed.

#### 581. Can a templated constructor be explicitly instantiated or specialized?

Section: 12.1 [class.ctor] Status: open Submitter: Mark Mitchell Date: 19 May 2006

Although it is not possible to specify a constructor's template arguments in a constructor invocation (because the constructor has no name but is invoked by use of the constructor's class's name), it is possible to “name” the constructor in declarative contexts: per 3.4.3.1 [class.qual] paragraph 2,

> In a lookup in which the constructor is an acceptable lookup result, if the nested-name-specifier nominates a class `C`, and the name specified after the nested-name-specifier, when looked up in `C`, is the injected-class-name of `C` (clause 9 [class]), the name is instead considered to name the constructor of class `C`... Such a constructor name shall be used only in the declarator-id of a declaration that names a constructor.

Should it therefore be possible to specify template-arguments for a templated constructor in an explicit instantiation or specialization? For example,

        template <int dim> struct T {};
        struct X {
          template <int dim> X (T<dim> &) {};
        };

        template X::X<> (T<2> &);

If so, that should be clarified in the text. In particular, 12.1 [class.ctor] paragraph 1 says,

> Constructors do not have names. A special declarator syntax using an optional sequence of function-specifiers (7.1.2 [dcl.fct.spec]) followed by the constructor's class name followed by a parameter list is used to declare or define the constructor.

This certainly sounds as if the parameter list must immediately follow the class name, with no allowance for a template argument list.

It would be worthwhile in any event to revise this wording to utilize the “considered to name” approach of 3.4.3.1 [class.qual]; as it stands, this wording sounds as if the following would be acceptable:

        struct S {
            S();
        };
        S() { }    // qualified-id not required?

Notes from the October, 2006 meeting:

It was observed that explicitly specifying the template arguments in a constructor declaration is never actually necessary because the arguments are, by definition, all deducible and can thus be omitted.

#### 1696. Temporary lifetime and non-static data member initializers

Section: 12.2 [class.temporary] Status: open Submitter: Richard Smith Date: 2013-05-31

Presumably a temporary bound to a reference in a non-static data member initializer should be treated analogously with what happens in a ctor-initializer, but the current wording of 12.2 [class.temporary] paragraph 5 is not clear on this point.

#### 344. Naming destructors

Section: 12.4 [class.dtor] Status: open Submitter: Jamie Schmeiser Date: 25 April 2002

Note that destructors suffer from similar problems as those of constructors dealt with in issue 194 and in 263 (constructors as friends). Also, the wording in 12.4 [class.dtor], paragraph 1 does not permit a destructor to be defined outside of the memberlist.

Change 12.4 [class.dtor], paragraph 1 from

> ...A special declarator syntax using an optional function-specifier (7.1.2 [dcl.fct.spec]) followed by `~` followed by the destructor's class name followed by an empty parameter list is used to declare the destructor in a class definition. In such a declaration, the `~` followed by the destructor's class name can be enclosed in optional parentheses; such parentheses are ignored....

to

> ...A special declarator syntax using an optional sequence of function-specifiers (7.1.2 [dcl.fct.spec]), an optional friend keyword, an optional sequence of function-specifiers (7.1.2 [dcl.fct.spec]) followed by an optional `::` scope-resolution-operator followed by an optional nested-name-specifier followed by `~` followed by the destructor's class name followed by an empty parameter list is used to declare the destructor. The optional nested-name-specifier shall not be specified in the declaration of a destructor within the member-list of the class of which the destructor is a member. In such a declaration, the optional `::` scope-resolution-operator followed by an optional nested-name-specifier followed by `~` followed by the destructor's class name can be enclosed in optional parentheses; such parentheses are ignored....

#### 1783. Why are virtual destructors non-trivial?

Section: 12.4 [class.dtor] Status: open Submitter: Jeffrey Yasskin Date: 2013-09-26

According to 12.4 [class.dtor] paragraph 5,

> A destructor is trivial if it is not user-provided and if:

> - the destructor is not `virtual`,

> - ...

It is not clear why this restriction is needed, and it should be removed if it is not needed.

#### 607. Lookup of mem-initializer-ids

Section: 12.6.2 [class.base.init] Status: open Submitter: Richard Corden Date: 5 December 2006

In an example like,

        struct Y {};

        template <typename T>
        struct X : public virtual Y { };

        template <typename T>
        class A : public X<T> {
          template <typename S>
          A (S)
            : S ()
          {
          }
        };

        template A<int>::A (Y);

Should `S` be found? (`S` is a dependent name, so if it resolves to a base class type in the instantiated template, it should satisfy the requirements.) All the compilers I tried allowed this example, but 12.6.2 [class.base.init] paragraph 2 says,

> Names in a mem-initializer-id are looked up in the scope of the constructor's class and, if not found in that scope, are looked up in the scope containing the constructor's definition.

The name `S` is not declared in those scopes.

Mike Miller: Here's another example that is accepted by most/all compilers but not by the current wording:

        namespace N {
          struct B { B(int); };
          typedef B typedef_B;
          struct D: B {
            D();
          };
        }

        N::D::D(): typedef_B(0) { }

Except for the fact that the constructor function parameter names are ignored (see paragraph 7), what the compilers seem to be doing is essentially ordinary unqualified name lookup.

Notes from the October, 2009 meeting:

The eventual resolution of this issue should take into account the template parameter scope introduced by the resolution of issue 481.

#### 1752. Right-recursion in mem-initializer-list

Section: 12.6.2 [class.base.init] Status: open Submitter: Christof Meerwald Date: 2013-09-16

The grammar for mem-initializer-list in 12.6.2 [class.base.init] paragraph 1 (after the resolution of issue 1649) is right-recursive:

mem-initializer-list:

mem-initializer `...`opt
mem-initializer `...`opt `,` mem-initializer-list

In general, however, such lists elsewhere in the Standard are described using a left-recursive grammar, e.g., for initializer-list in 8.5 [dcl.init] paragraph 1:

initializer-list:

initializer-clause `...`opt
initializer-list `,` initializer-clause `...`opt

It would be better to be consistent in the definition of mem-initializer-list.

#### 6. Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?

Section: 12.8 [class.copy] Status: open Submitter: unknown Date: unknown

[Picked up by evolution group at October 2002 meeting.]

(See also paper J16/99-0005 = WG21 N1182.)

At the London meeting, 12.8 [class.copy] paragraph 31 was changed to limit the optimization described to only the following cases:

- the source is a temporary object
- the return value optimization

One other case was deemed desirable as well:

- aliasing a parameter in an inline function call to the function call argument.

However, there are cases when this aliasing was deemed undesirable and, at the London meeting, the committee was not able to clearly delimit which cases should be allowed and which ones should be prohibited.

Can we find an appropriate description for the desired cases?

Rationale (04/99): The absence of this optimization does not constitute a defect in the Standard, although the proposed resolution in the paper should be considered when the Standard is revised.

Note (March, 2008):

The Evolution Working Group has accepted the intent of this issue and referred it to CWG for action (not for C++0x). See paper J16/07-0033 = WG21 N2173.

Notes from the June, 2008 meeting:

The CWG decided to take no action on this issue until an interested party produces a paper with analysis and a proposal.

#### 1049. Copy elision through reference parameters of inline functions

Section: 12.8 [class.copy] Status: open Submitter: Jason Merrill Date: 2010-03-10

Consider the following example:

        int c;

        struct A {
           A() { ++c; }
           A(const A&) { ++c; }
        };

        struct B {
           A a;
           B(const A& a): a(a) { }
        };

        int main() {
           (B(A()));
           return c - 1;
        }

Here we would like to be able to avoid the copy and just construct the `A()` directly into the `A` subobject of `B`. But we can't, because it isn't allowed by 12.8 [class.copy] paragraph 34 bullet 3:

- when a temporary class object that has not been bound to a reference (12.2 [class.temporary]) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

The part about not being bound to a reference was added for an unrelated reason by issue 185. If that resolution were recast to require that the temporary object is not accessed after the copy, rather than banning the reference binding, this optimization could be applied.

The similar example using pass by value is also not one of the allowed cases, which could be considered part of issue 6.

#### 545. User-defined conversions and built-in operator overload resolution

Section: 13.3.1.2 [over.match.oper] Status: open Submitter: Steve Clamage Date: 31 October 2005

Consider the following example:

        class B1 {};
        typedef void (B1::*PB1) (); // memptr to B1

        class B2 {};
        typedef void (B2::*PB2) (); // memptr to B2

        class D1 : public B1, public B2 {};
        typedef void (D1::*PD) (); // memptr to D1

        struct S {
             operator PB1(); // can be converted to PD
        } s;
        struct T {
             operator PB2(); // can be converted to PD
        } t;

        void foo() {
             s == t; // Is this an error?
        }

According to 13.6 [over.built] paragraph 16, there is an `operator==` for `PD` (“For every pointer to member type...”), so why wouldn't it be used for this comparison?

Mike Miller: The problem, as I understand it, is that 13.3.1.2 [over.match.oper] paragraph 3, bullet 3, sub-bullet 3 is broader than it was intended to be. It says that candidate built-in operators must “accept operand types to which the given operand or operands can be converted according to 13.3.3.1 [over.best.ics].” 13.3.3.1.2 [over.ics.user] describes user-defined conversions as having a second standard conversion sequence, and there is nothing to restrict that second standard conversion sequence.

My initial thought on addressing this would be to say that user-defined conversion sequences whose second standard conversion sequence contains a pointer conversion or a pointer-to-member conversion are not considered when selecting built-in candidate operator functions. They would still be applicable after the hand-off to Clause 5 (e.g., in bringing the operands to their common type, 5.10 [expr.eq], or composite pointer type, 5.9 [expr.rel]), just not in constructing the list of built-in candidate operator functions.

I started to suggest restricting the second standard conversion sequence to conversions having Promotion or Exact Match rank, but that would exclude the Boolean conversions, which are needed for `!`, `&&`, and `||`. (It would have also restricted the floating-integral conversions, though, which might be a good idea. They can't be used implicitly, I think, because there would be an ambiguity among all the promoted integral types; however, none of the compilers I tested even tried those conversions because the errors I got were not ambiguities but things like “floating point operands not allowed for `%`”.)

Bill Gibbons: I recall seeing this problem before, though possibly not in committee discussions. As written this rule makes the set of candidate functions dependent on what classes have been defined, including classes not otherwise required to have been defined in order for "==" to be meaningful. For templates this implies that the set is dependent on what templates have been instantiated, e.g.

      template<class T> class U : public T { };
      U<B1> u;  // changes the set of candidate functions to include
                // operator==(U<B1>,U<B1>)?

There may be other places where the existence of a class definition, or worse, a template instantiation, changes the semantics of an otherwise valid program (e.g. pointer conversions?) but it seems like something to be avoided.

(See also issue 954.)

#### 1750. “Argument” vs “parameter”

Section: 13.3.1.4 [over.match.copy] Status: open Submitter: Mike Miller Date: 2013-09-13

The current wording of the second bullet of paragraph 1 of 13.3.1.4 [over.match.copy] contains the phrase,

> When initializing a temporary to be bound to the first parameter of a constructor that takes a reference to possibly cv-qualified `T` as its first argument...

Presumably “argument” should be “parameter.”

#### 1781. Converting from `nullptr_t` to `bool` in overload resolution

Section: 13.3.1.5 [over.match.conv] Status: open Submitter: Hubert Tong Date: 2013-09-26

According to 13.3.1.5 [over.match.conv] paragraph 1, when a class type `S` is used as an initializer for an object of type `T`,

> The conversion functions of `S` and its base classes are considered. Those non-explicit conversion functions that are not hidden within `S` and yield type `T` or a type that can be converted to type `T` via a standard conversion sequence (13.3.3.1.1 [over.ics.scs]) are candidate functions.

Because conversion from `std::nullptr_t` to `bool` is only permitted in direct-initialization (4.12 [conv.bool]), it is not clear whether there is a standard conversion sequence from `std::nullptr_t` to `bool`, considering that an implicit conversion sequence is intended to model copy-initialization. Should 13.3.1.5 [over.match.conv] be understood to refer only to conversions permitted in copy-initialization, or should the form of the initialization be considered? For example,

      struct SomeType {
        operator std::nullptr_t();
      };
      bool b{ SomeType() };    // Well-formed?

Note also 13.3.3.2 [over.ics.rank] paragraph 4, which may bear on the intent (or, alternatively, might describe a situation that cannot arise):

> A conversion that does not convert a pointer, a pointer to member, or `std::nullptr_t` to `bool` is better than one that does.

#### 1758. Explicit conversion in copy/move list initialization

Section: 13.3.1.7 [over.match.list] Status: open Submitter: Richard Smith Date: 2013-09-21

Consider the following example:

      struct X { X(); };
      struct Y { explicit operator X(); } y;
      X x{y};

This appears to be ill-formed, although the corresponding case with parentheses is well-formed. There seem to be two factors that prevent this from being accepted:

First, the special provision allowing an explicit conversion function to be used when initializing the parameter of a copy/move constructor is in 13.3.1.4 [over.match.copy], and this case takes us to 13.3.1.7 [over.match.list] instead.

Second, 13.3.3.1 [over.best.ics] paragraph 4 says that in this case, because we are in 13.3.1.7 [over.match.list], and we have a single argument, and we are calling a copy/move constructor, we are not allowed to consider a user-defined conversion sequence for the argument.

Similarly, in an example like

      struct A {
       A() {}
       A(const A &) {}
      };
      struct B {
       operator A() { return A(); }
      } b;
      A a{b};

the wording in 13.3.3.1 [over.best.ics] paragraph 4 with regard to 13.3.1.7 [over.match.list] prevents considering `B`'s conversion function when initializing the first parameter of `A`'s copy constructor, thereby making this code ill-formed.

#### 418. Imperfect wording on error on multiple default arguments on a called function

Section: 13.3.3 [over.match.best] Status: open Submitter: Chris Bowler Date: 27 May 2003

According to 13.3.3 [over.match.best] paragraph 4, the following program appears to be ill-formed:

      void f(int, int=0);
      void f(int=0, int);

      void g() {
        f();
      }

Though I do not expect this is the intent of this paragraph in the standard.

13.3.3 [over.match.best] paragraph 4:

> If the best viable function resolves to a function for which multiple declarations were found, and if at least two of these declarations or the declarations they refer to in the case of using-declarations specify a default argument that made the function viable, the program is ill-formed. [Example:

>     namespace A {
>       extern "C" void f(int = 5);
>     }
>     namespace B {
>       extern "C" void f(int = 5);
>     }
>     using A::f;
>     using B::f;
>     void use() {
>     f(3); //OK, default argument was not used for viability
>     f(); //Error: found default argument twice
>     }

> end example]

#### 1459. Reference-binding tiebreakers in overload resolution

Section: 13.3.3.2 [over.ics.rank] Status: open Submitter: Jason Merrill Date: 2012-02-07

Both paragraph 3 and paragraph 4 of 13.3.3.2 [over.ics.rank] have overload resolution tiebreakers for reference binding. It might be possible to merge those into a single treatment.

#### 1789. Array reference vs array decay in overload resolution

Section: 13.3.3.2 [over.ics.rank] Status: open Submitter: Faisal Vali Date: 2013-10-01

The current rules make an example like

      template<class T, size_t N> void foo(T (&)[N]);
      template<class T> void foo(T *t);

      int arr[3]{1, 2, 3};
      foo(arr);

ambiguous, even though the first is an identity match and the second requires an lvalue transformation. Is this desirable?

#### 1038. Overload resolution of `&x.static_func`

Section: 13.4 [over.over] Status: open Submitter: Mike Miller Date: 2010-03-02

The Standard is not clear whether the following example is well-formed or not:

        struct S {
            static void f(int);
            static void f(double);
        };
        S s;
        void (*pf)(int) = &s.f;

According to 5.2.5 [expr.ref] paragraph 4 bullet 3, you do function overload resolution to determine whether `x.f` is a static or non-static member function. 5.3.1 [expr.unary.op] paragraph 6 says that you can only take the address of an overloaded function in a context that determines the overload to be chosen, and the initialization of a function pointer is such a context (13.4 [over.over] paragraph 1). The problem is that 13.4 [over.over] is phrased in terms of “an overloaded function name,” and this is a member access expression, not a name.

There is variability among implementations as to whether this example is accepted; some accept it as written, some only if the `&` is omitted, and some reject it in both forms.

Additional note (October, 2010):

A related question concerns an example like

        struct S {
            static void g(int*) {}
            static void g(long) {}
        } s;

        void foo() {
            (&s.g)(0L);
        }

Because the address occurs in a call context and not in one of the contexts mentioned in 13.4 [over.over] paragraph 1, the call expression in `foo` is presumably ill-formed. Contrast this with the similar example

        void g1(int*) {}
        void g1(long) {}

        void foo1() {
            (&g1)(0L);
        }

This call presumably is well-formed because 13.3.1.1 [over.match.call] applies to “the address of a set of overloaded functions.” (This was clearer in the wording prior to the resolution of issue 704: “...in this context using `&F` behaves the same as using the name `F` by itself.”) It's not clear that there's any reason to treat these two cases differently.

This question also bears on the original question of this issue, since the original wording of 13.3.1.1 [over.match.call] also described the case of an ordinary member function call like `s.g(0L)` as involving the “name” of the function, even though the postfix-expression is a member access expression and not a “name.” Perhaps the reference to “name” in 13.4 [over.over] should be similarly understood as applying to member access expressions?

#### 1549. Overloaded comma operator with `void` operand

Section: 13.5.2 [over.binary] Status: open Submitter: Nikolay Ivchenkov Date: 2012-09-04

Even though a function cannot take a parameter of type `void`, the current rules for overload resolution require consideration of overloaded operators when one operand has a user-defined or enumeration type and the other has type `void`. This can result in side effects and possibly errors, for example:

      template <class T> struct A {
        T t;
        typedef T type;
      };

      struct X {
        typedef A<void> type;
      };

      template <class T> void operator ,(typename T::type::type, T) {}

      int main() {
        X(), void(); // OK
        void(), X(); // error: A<void> is instantiated with a field of
                     // type void
      }

#### 1620. User-defined literals and extended integer types

Section: 13.5.8 [over.literal] Status: open Submitter: Jason Merrill Date: 2013-02-12

Although numeric literals can have extended integer types, user-defined literal operators cannot have a parameter of an extended integer type. This seems like an oversight.

#### 260. User-defined conversions and built-in `operator=`

Section: 13.6 [over.built] Status: open Submitter: Scott Douglas Date: 4 Nov 2000

According to the Standard (although not implemented this way in most implementations), the following code exhibits non-intuitive behavior:

      struct T {
        operator short() const;
        operator int() const;
      };

      short s;

      void f(const T& t) {
        s = t;  // surprisingly calls T::operator int() const
      }

The reason for this choice is 13.6 [over.built] paragraph 18:

> For every triple (L, VQ, R), where L is an arithmetic type, VQ is either `volatile` or empty, and R is a promoted arithmetic type, there exist candidate operator functions of the form

> VQ L`& operator=(`VQ L`&,` R`);`

Because R is a "promoted arithmetic type," the second argument to the built-in assignment operator is `int`, causing the unexpected choice of conversion function.

Suggested resolution: Provide built-in assignment operators for the unpromoted arithmetic types.

Related to the preceding, but not resolved by the suggested resolution, is the following problem. Given:

        struct T {
    	 operator int() const;
    	 operator double() const;
        };

I believe the standard requires the following assignment to be ambiguous (even though I expect that would surprise the user):

        double x;
        void f(const T& t) { x = t; }

The problem is that both of these built-in `operator=()`s exist (13.6 [over.built] paragraph 18):

        double& operator=(double&, int);
        double& operator=(double&, double);

Both are an exact match on the first argument and a user conversion on the second. There is no rule that says one is a better match than the other.

The compilers that I have tried (even in their strictest setting) do not give a peep. I think they are not following the standard. They pick `double& operator=(double&, double)` and use `T::operator double() const`.

I hesitate to suggest changes to overload resolution, but a possible resolution might be to introduce a rule that, for built-in `operator=` only, also considers the conversion sequence from the second to the first type. This would also resolve the earlier question.

It would still leave `x += t` etc. ambiguous -- which might be the desired behavior and is the current behavior of some compilers.

Notes from the 04/01 meeting:

The difference between initialization and assignment is disturbing. On the other hand, promotion is ubiquitous in the language, and this is the beginning of a very slippery slope (as the second report above demonstrates).

Additional note (August, 2010):

See issue 507 for a similar example involving comparison operators.

#### 954. Overload resolution of conversion operator templates with built-in types

Section: 13.6 [over.built] Status: open Submitter: Steve Clamage Date: 19 August, 2009

Consider the following example:

        struct NullClass {
            template<typename T> operator T () { return 0 ; }
        };

        int main() {
            NullClass n;
            n==5;        // #1
            return 0;
        }

The comparison at #1 is, according to the current Standard, ambiguous. According to 13.6 [over.built] paragraph 12, the candidates for `operator==(L, R)` include functions “for every pair of promoted arithmetic types,” so `L` could be either `int` or `long`, and the conversion operator template will provide an exact match for either.

Some implementations unambiguously choose the `int` candidate. Perhaps the overload resolution rules could be tweaked to prefer candidates in which `L` and `R` are the same type?

(See also issue 545.)

#### 110. Can template functions and classes be declared in the same scope?

Section: 14 [temp] Status: open Submitter: John Spicer Date: 28 Apr 1999

According to 14 [temp] paragraph 5,

> Except that a function template can be overloaded either by (non-template) functions with the same name or by other function templates with the same name (14.8.3 [temp.over] ), a template name declared in namespace scope or in class scope shall be unique in that scope.

3.3.10 [basic.scope.hiding] paragraph 2 agrees that only functions, not function templates, can hide a class name declared in the same scope:

> A class name (9.1 [class.name] ) or enumeration name (7.2 [dcl.enum] ) can be hidden by the name of an object, function, or enumerator declared in the same scope.

However, 3.3 [basic.scope] paragraph 4 treats functions and template functions together in this regard:

> Given a set of declarations in a single declarative region, each of which specifies the same unqualified name,
> - they shall all refer to the same entity, or all refer to functions and function templates; or
> - exactly one declaration shall declare a class name or enumeration name that is not a typedef name and the other declarations shall all refer to the same object or enumerator, or all refer to functions and function templates; in this case the class name or enumeration name is hidden

John Spicer: You should be able to take an existing program and replace an existing function with a function template without breaking unrelated parts of the program. In addition, all of the compilers I tried allow this usage (EDG, Sun, egcs, Watcom, Microsoft, Borland). I would recommend that function templates be handled exactly like functions for purposes of name hiding.

Martin O'Riordan: I don't see any justification for extending the purview of what is decidedly a hack, just for the sake of consistency. In fact, I think we should go further and in the interest of consistency, we should deprecate the hack, scheduling its eventual removal from the C++ language standard.

The hack is there to allow old C programs and especially the 'stat.h' file to compile with minimum effort (also several other Posix and X headers). People changing such older programs have ample opportunity to "do it right". Indeed, if you are adding templates to an existing program, you should probably be placing your templates in a 'namespace', so the issue disappears anyway. The lookup rules should be able to provide the behaviour you need without further hacking.

#### 343. Make `template` optional in contexts that require a type

Section: 14.2 [temp.names] Status: open Submitter: Steve Adamczyk Date: 23 April 2002

By analogy with `typename`, the keyword `template` used to indicate that a dependent name will be a template name should be optional in contexts where a type is required, e.g., base class lists. We could also consider member and parameter declarations.

This was suggested by issue 314.

#### 579. What is a “nested” `>` or `>>`?

Section: 14.2 [temp.names] Status: open Submitter: Daveed Vandevoorde Date: 11 May 2006

The Standard does not normatively define which `>` and `>>` tokens are to be taken as closing a template-argument-list; instead, 14.2 [temp.names] paragraph 3 uses the undefined and imprecise term “non-nested:”

> When parsing a template-id, the first non-nested `>` is taken as the end of the template-argument-list rather than a greater-than operator. Similarly, the first non-nested `>>` is treated as two consecutive but distinct `>` tokens, the first of which is taken as the end of the template-argument-list and completes the template-id.

The (non-normative) footnote clarifies that

> A `>` that encloses the type-id of a `dynamic_cast`, `static_cast`, `reinterpret_cast` or `const_cast`, or which encloses the template-arguments of a subsequent template-id, is considered nested for the purpose of this description.

Aside from the questionable wording of this footnote (e.g., in what sense does a single terminating character “enclose” anything, and is a nested template-id “subsequent?”) and the fact that it is non-normative, it does not provide a complete definition of what “nesting” is intended to mean. For example, is the first `>` in this putative template-id “nested” or not?

        X<a ? b > c : d>

#### 1794. `template` keyword and alias templates

Section: 14.2 [temp.names] Status: open Submitter: Jonathan Caves Date: 2013-10-04

The current wording of 14.2 [temp.names] paragraph 5 is:

> A name prefixed by the keyword template shall be a template-id or the name shall refer to a class template.

Presumably this should also allow `template` before alias templates. For example,

      template<template<typename> class Template>
      struct Internal {
              template<typename Arg>
              using Bind = Template<Arg>;
      };

      template<template<typename> class Template, typename Arg>
      using Instantiate = Template<Arg>;

      template<template<typename> class Template, typename Argument>
      using Bind = Instantiate<Internal<Template>::template Bind, Argument>;

#### 440. Allow implicit pointer-to-member conversion on nontype template argument

Section: 14.3 [temp.arg] Status: open Submitter: David Abrahams Date: 13 Nov 2003

None of my compilers accept this, which surprised me a little. Is the base-to-derived member function conversion considered to be a runtime-only thing?

      template <class D>
      struct B
      {
          template <class X> void f(X) {}
          template <class X, void (D::*)(X) = &B<D>::f<X> >
          struct row {};
      };
      struct D : B<D>
      {
          void g(int);
          row<int,&D::g> r1;
          row<char*> r2;
      };

John Spicer: This is not among the permitted conversions listed in 14.3.

I'm not sure there is a terribly good reason for that. Some of the template argument rules for external entities were made conservatively because of concerns about issues of mangling template argument names.

David Abrahams: I'd really like to see that restriction loosened. It is a serious inconvenience because there appears to be no way to supply a usable default in this case. Zero would be an OK default if I could use the function pointer's equality to zero as a compile-time switch to choose an empty function implementation:

      template <bool x> struct tag {};

      template <class D>
      struct B
      {
          template <class X> void f(X) {}

          template <class X, void (D::*pmf)(X) = 0 >
          struct row {
              void h() { h(tag<(pmf == 0)>(), pmf); }
              void h(tag<1>, ...) {}
              void h(tag<0>, void (D::*q)(X)) { /*something*/}
          };
      };

      struct D : B<D>
      {
          void g(int);
          row<int,&D::g> r1;
          row<char*> r2;
      };

But there appears to be no way to get that effect either. The result is that you end up doing something like:

          template <class X, void (D::*pmf)(X) = 0 >
          struct row {
              void h() { if (pmf) /*something*/ }
          };

which invariably makes compilers warn that you're switching on a constant expression.

#### 150. Template template parameters and default arguments

Section: 14.3.3 [temp.arg.template] Status: open Submitter: Mike Miller Date: 3 Aug 1999

[Picked up by evolution group at October 2002 meeting.]

How are default template arguments handled with respect to template template parameters? Two separate questions have been raised:

1. Do default template arguments allow a template argument to match a template parameter with fewer template parameters, and can the template template parameter be specialized using the smaller number of template arguments? For example,

           template <class T, class U = int>
           class ARG { };

           template <class X, template <class Y> class PARM>
           void f(PARM<X>) { }    // specialization permitted?

           void g() {
               ARG<int> x;        // actually ARG<int, int>
               f(x);              // does ARG (2 parms, 1 with default)
                                  // match PARM (1 parm)?

   Template template parameters are deducible (14.8.2.5 [temp.deduct.type] paragraph 9), but 14.3.3 [temp.arg.template] does not specify how matching is done.

   Jack Rouse: I implemented template template parameters assuming template signature matching is analogous to function type matching. This seems like the minimum reasonable implementation. The code in the example would not be accepted by this compiler. However, template default arguments are compile time entities so it seems reasonable to relax the matching rules to allow cases like the one in the example. But I would consider this to be an extension to the language.

   Herb Sutter: An open issue in the LWG is that the standard doesn't explicitly permit or forbid implementations' adding additional template-parameters to those specified by the standard, and the LWG may be leaning toward explicitly permitting this. [Under this interpretation,] if the standard is ever modified to allow additional template-parameters, then writing "a template that takes a standard library template as a template template parameter" won't be just ugly because you have to mention the defaulted parameters; it would not be (portably) possible at all except possibly by defining entire families of overloaded templates to account for all the possible numbers of parameters `vector<>` (or anything else) might actually have. That seems unfortunate.

2. Are default arguments permitted in the template parameter list of a template template parameter? For example,

           template <template <class T, class U = int> class PARM>
           class C {
               PARM<int> pi;
           };

   Jack Rouse: I decided they could not in the compiler I support. This continues the analogy with function type matching. Also, I did not see a strong need to allow default arguments in this context.

   A class template used as a template template argument can have default template arguments from its declarations. How are the two sources of default arguments to be reconciled? The default arguments from the template template formal could override. But it could be cofusing if a template-id using the argument template, `ARG<int>`, behaves differently from a template-id using the template formal name, `FORMAL<int>`.

Rationale (10/99): Template template parameters are intended to be handled analogously to function function parameters. Thus the number of parameters in a template template argument must match the number of parameters in a template template parameter, regardless of whether any of those paramaters have default arguments or not. Default arguments are allowed for the parameters of a template template parameter, and those default arguments alone will be considered in a specialization of the template template parameter within a template definition; any default arguments for the parameters of a template template argument are ignored.

Note (Mark Mitchell, February, 2006):

Perhaps it is already obvious to all, but it seems worth noting that this extension would change the meaning of conforming programs:

        struct Dense { static const unsigned int dim = 1; };

        template <template <typename> class View,
                  typename Block>
        void operator+(float, View<Block> const&);

        template <typename Block,
                  unsigned int Dim = Block::dim>
        struct Lvalue_proxy { operator float() const; };

        void test_1d (void) {
            Lvalue_proxy<Dense> p;
            float b;
            b + p;
        }

If `Lvalue_proxy` is allowed to bind to `View`, then the template `operator+` will be used to perform addition; otherwise, `Lvalue_proxy`'s implicit conversion to float, followed by the built-in addition on floats will be used.

Note (March, 2008):

The Evolution Working Group has accepted the intent of this issue and referred it to CWG for action (not for C++0x). See paper J16/07-0033 = WG21 N2173.

Notes from the June, 2008 meeting:

The CWG decided to take no action on this issue until an interested party produces a paper with analysis and a proposal.

#### 708. Partial specialization of member templates of class templates

Section: 14.5.5 [temp.class.spec] Status: open Submitter: James Widman Date: 8 Aug, 2008

The Standard does not appear to specify clearly the effect of a partial specialization of a member template of a class template. For example:

        template<class T> struct B {
             template<class U> struct A { // #1
                 void h() {}
             };
             template<class U> struct A<U*> {  // #2
                 void f() {}
             };
        };

        template<> template<class U> struct B<int>::A { // #3
             void g() {}
        };

        void q(B<int>::A<char*>& p) {
             p.f();  // #4
        }

The explicit specialization at #3 replaces the primary member template #1 of `B<int>`; however, it is not clear whether the partial specialization #2 should be considered to apply to the explicitly-specialized member template of `A<int>` (thus allowing the call to `p.f()` at #4) or whether the partial specialization will be used only for specializations of `B` that are implicitly instantiated (meaning that #4 could call `p.g()` but not `p.f()`).

#### 1711. Missing specification of variable template partial specializations

Section: 14.5.5 [temp.class.spec] Status: open Submitter: Richard Smith Date: 2013-07-08

It appears that partial specializations of variable templates are intended to be supported, as 14.3.3 [temp.arg.template] paragraph 2 says,

> Any partial specializations (14.5.5 [temp.class.spec]) associated with the primary class template or primary variable template are considered when a specialization based on the template template-parameter is instantiated.

However, there is no explicit specification for how they are to be handled, and the wording in 14.5.5 [temp.class.spec] and its subsections explicitly applies only to partial specializations of class templates.

#### 1754. Declaration of partial specialization of static data member template

Section: 14.5.5 [temp.class.spec] Status: open Submitter: Richard Smith Date: 2013-09-19

There does not appear to be a way to declare (not define) a partial specialization of a static data member template outside outside its class. The rule for explicit specializations (14.7.3 [temp.expl.spec] paragraph 13) is that the presence or absence of an initializer determines whether the explicit specialization is a definition or not. Applying this rule to the partial specialization case, however, would conflict with being able to provide an initializer on the declaration within the class.

Do we need to support declaring partial specializations of static data member templates outside their class?

#### 1755. Out-of-class partial specializations of member templates

Section: 14.5.5.3 [temp.class.spec.mfunc] Status: open Submitter: Richard Smith Date: 2013-09-19

According to 14.5.5.3 [temp.class.spec.mfunc] paragraph 2,

> If a member template of a class template is partially specialized, the member template partial specializations are member templates of the enclosing class template; if the enclosing class template is instantiated (14.7.1 [temp.inst], 14.7.2 [temp.explicit]), a declaration for every member template partial specialization is also instantiated as part of creating the members of the class template specialization.

Does this imply that only partial specializations of member templates that are declared before the enclosing class is instantiated are considered? For example, in

      template<typename A> struct X { template<typename B> struct Y; };
      template struct X<int>;
      template<typename A> template<typename B> struct X<A>::Y<B*> { int n; };
      int k = X<int>::Y<int*>().n;

is the last line valid? There is implementation variance on this point. Similarly, for an example like

      template<typename A> struct Outer {
       template<typename B, typename C> struct Inner;
      };
      Outer<int> outer;
      template<typename A> template<typename B>
        struct Outer<A>::Inner<typename A::error, B> {};

at what point, if at all, is the declaration of the partial specialization instantiated? Again, there is implementation variance in the treatment of this example.

#### 310. Can function templates differing only in parameter cv-qualifiers be overloaded?

Section: 14.5.6.1 [temp.over.link] Status: open Submitter: Andrei Iltchenko Date: 29 Aug 2001

I get the following error diagnostic [from the EDG front end]:

    line 8: error: function template "example<T>::foo<R,A>(A)" has
              already been declared
         R  foo(const A);
            ^

when compiling this piece of code:

    struct  example  {
       template<class R, class A>   // 1-st member template
       R  foo(A);
       template<class R, class A>   // 2-nd member template
       const R  foo(A&);
       template<class R, class A>   // 3-d  member template
       R  foo(const A);
    };

    /*template<> template<>
    int  example<char>::foo(int&);*/

    int  main()
    {
       int  (example<char>::* pf)(int&) =
          &example<char>::foo;
    }

The implementation complains that

       template<class R, class A>   // 1-st member template
       R  foo(A);
       template<class R, class A>   // 3-d  member template
       R  foo(const A);

cannot be overloaded and I don't see any reason for it since it is function template specializations that are treated like ordinary non-template functions, meaning that the transformation of a parameter-declaration-clause into the corresponding parameter-type-list is applied to specializations (when determining its type) and not to function templates.

What makes me think so is the contents of 14.5.6.1 [temp.over.link] and the following sentence from 14.8.2.1 [temp.deduct.call] "If P is a cv-qualified type, the top level cv-qualifiers of P are ignored for type deduction". If the transformation was to be applied to function templates, then there would be no reason for having that sentence in 14.8.2.1 [temp.deduct.call].

14.8.2.2 [temp.deduct.funcaddr], which my example is based upon, says nothing about ignoring the top level cv-qualifiers of the function parameters of the function template whose address is being taken.

As a result, I expect that template argument deduction will fail for the 2-nd and 3-d member templates and the 1-st one will be used for the instantiation of the specialization.

#### 1644. Equivalent exception-specifications in function template declarations

Section: 14.5.6.1 [temp.over.link] Status: open Submitter: Richard Smith Date: 2013-03-17

Although 15.4 [except.spec] paragraph 3 says,

> Two exception-specifications are compatible if:

> - ...

> - both have the form `noexcept(`constant-expression`)` and the constant-expressions are equivalent, or

> - ...

it is not clear whether “equivalent” in this context should be taken as a reference to the definition of equivalent given in 14.5.6.1 [temp.over.link] paragraph 5:

> Two expressions involving template parameters are considered equivalent if two function definitions containing the expressions would satisfy the one definition rule (3.2 [basic.def.odr]), except that the tokens used to name the template parameters may differ as long as a token used to name a template parameter in one expression is replaced by another token that names the same template parameter in the other expression.

since the context there is expressions that appear in function template parameters and return types.

There is implementation variance on this question.

#### 402. More on partial ordering of function templates

Section: 14.5.6.2 [temp.func.order] Status: open Submitter: Nathan Sidwell Date: 7 Apr 2003

This was split off from issue 214 at the April 2003 meeting.

Nathan Sidwell: John Spicer's proposed resolution does not make the following well-formed.

      template <typename T> int Foo (T const *) {return 1;} //#1
      template <unsigned I> int Foo (char const (&)[I]) {return 2;} //#2

      int main ()
      {
        return Foo ("a") != 2;
      }

Both #1 and #2 can deduce the "a" argument, #1 deduces T as char and #2 deduces I as 2. However, neither is more specialized because the proposed rules do not have any array to pointer decay.

#1 is only deduceable because of the rules in 14.8.2.1 [temp.deduct.call] paragraph 2 that decay array and function type arguments when the template parameter is not a reference. Given that such behaviour happens in deduction, I believe there should be equivalent behaviour during partial ordering. #2 should be resolved as more specialized as #1. The following alteration to the proposed resolution of DR214 will do that.

Insert before,

- If A is a cv-qualified type, A is replaced by the cv-unqualified version of A.

the following

- If P was not originally a reference type,
  - If A is an array type, A is replaced by the pointer type produced by the array to pointer conversion
  - If A is a function type, A is replaced by the pointer type produced by the function to pointer conversion

For the example above, this change results in deducing 'T const *' against 'char const *' in one direction (which succeeds), and 'char [I]' against 'T const *' in the other (which fails).

John Spicer: I don't consider this a shortcoming of my proposed wording, as I don't think this is part of the current rules. In other words, the resolution of 214 might make it clearer how this case is handled (i.e., clearer that it is not allowed), but I don't believe it represents a change in the language.

I'm not necessarily opposed to such a change, but I think it should be reviewed by the core group as a related change and not a defect in the proposed resolution to 214.

Notes from the October 2003 meeting:

There was some sentiment that it would be desirable to have this case ordered, but we don't think it's worth spending the time to work on it now. If we look at some larger partial ordering changes at some point, we will consider this again.

#### 1157. Partial ordering of function templates is still underspecified

Section: 14.5.6.2 [temp.func.order] Status: open Submitter: CA Date: 2010-08-03
N3092 comment CA 7

14.5.6.2 [temp.func.order] paragraph 3 says,

> To produce the transformed template, for each type, non-type, or template template parameter (including template parameter packs (14.5.3 [temp.variadic]) thereof) synthesize a unique type, value, or class template respectively and substitute it for each occurrence of that parameter in the function type of the template.

The characteristics of the synthesized entities and how they are determined is not specified. For example, members of a dependent type referred to in non-deduced contexts are not specified to exist, even though the transformed function type would be invalid in their absence.

Example 1:

      template<typename T, typename U> struct A;
      template<typename T> void foo(A<T, typename T::u> *) { } // #1
        // synthetic T1 has member T1::u
      template <typename T> void foo(A<T, typename T::u::v> *) { } // #2
        // synthetic T2 has member T2::u and member T2::u::v
        // T in #1 deduces to synthetic T2 in partial ordering;
        // deduced A for the parameter is A<T2, T2::u> * --this is not necessarily compatible
        // with A<T2, T2::u::v> * and it does not need to be. See Note 1. The effect is that
        // (in the call below) the compatibility of B::u and B::u::v is respected.
        // T in #2 cannot be successfully deduced in partial ordering from A<T1, T1::u> *;
        // invalid type T1::u::v will be formed when T1 is substituted into non-deduced contexts.
      struct B {
        struct u { typedef u v; };
      };
      int main() {
        foo((A<B, B::u> *)0); // calls #2
      }

Note 1: Template argument deduction is an attempt to match a `P` and a deduced `A`; however, template argument deduction is not specified to fail if the `P` and the deduced `A` are incompatible. This may occur in the presence of non-deduced contexts. Notwithstanding the parenthetical statement in 14.8.2.4 [temp.deduct.partial] paragraph 9, template argument deduction may succeed in determining a template argument for every template parameter while producing a deduced `A` that is not compatible with the corresponding `P`.

Example 2:

      template <typename T, typename U, typename V> struct A;
      template <typename T>
        void foo(A<T, struct T::u, struct T::u::u> *); // #2.1
          // synthetic T1 has member non-union class T1::u
      template <typename T, typename U>
        void foo(A<T, U , U> *); // #2.2
          // synthetic T2 and U2 has no required properties
          // T in #2.1 cannot be deduced in partial ordering from A<T2, U2, U2> *;
          // invalid types T2::u and T2::u::u will be formed when T2 is substituted in nondeduced contexts.
          // T and U in #2.2 deduces to, respectively, T1 and T1::u from A<T1, T1::u, struct
    T1::u::u> * unless
          // struct T1::u::u does not refer to the injected-class-name of the class T1::u (if that is possible).
      struct B {
        struct u { };
      };
      int main() {
        foo((A<B, B::u, struct B::u::u> *)0); // calls #2.1
      }

It is, however, unclear to what extent an implementation will have to go to determine these minimal properties.

#### 1257. Instantiation via non-dependent references in uninstantiated templates

Section: 14.6 [temp.res] Status: open Submitter: Johannes Schaub Date: 2011-03-09

The Standard does not appear to specify whether a non-dependent reference to a template specialization in a template definition that is never instantiated causes the implicit instantiation of the referenced specialization.

#### 1785. Conflicting diagnostic requirements for template definitions

Section: 14.6 [temp.res] Status: open Submitter: CWG Date: 2013-09-28

According to 14.6 [temp.res] paragraph 8,

> No diagnostic shall be issued for a template for which a valid specialization can be generated.

One sentence later, it says,

> If every valid specialization of a variadic template requires an empty template parameter pack, the template is ill-formed, no diagnostic required.

This appears to be a contradiction: in the latter case, there is postulated to exist a “valid” specialization (with an empty pack expansion), for which a diagnostic might or might not be issued. The first quoted sentence, however, forbids issuing a diagnostic for a template that has at least one valid specialization.

#### 186. Name hiding and template template-parameters

Section: 14.6.1 [temp.local] Status: open Submitter: John Spicer Date: 11 Nov 1999

The standard prohibits a class template from having the same name as one of its template parameters (14.6.1 [temp.local] paragraph 4). This prohibits

        template <class X> class X;

for the reason that the template name would hide the parameter, and such hiding is in general prohibited.

Presumably, we should also prohibit

        template <template <class T> class T> struct A;

for the same reason.

#### 459. Hiding of template parameters by base class members

Section: 14.6.1 [temp.local] Status: open Submitter: Daveed Vandevoorde Date: 2 Feb 2004

Currently, member of nondependent base classes hide references to template parameters in the definition of a derived class template.

Consider the following example:

       class B {
          typedef void *It;    // (1)
          // ...
        };

        class M: B {};

        template<typename> X {};

        template<typename It> struct S   // (2)
            : M, X<It> {   // (3)
          S(It, It);   // (4)
          // ...
        };

As the C++ language currently stands, the name "It" in line (3) refers to the template parameter declared in line (2), but the name "It" in line (4) refers to the typedef in the private base class (declared in line (1)).

This situation is both unintuitive and a hindrance to sound software engineering. (See also the Usenet discussion at http://tinyurl.com/32q8d .) Among other things, it implies that the private section of a base class may change the meaning of the derived class, and (unlike other cases where such things happen) there is no way for the writer of the derived class to defend the code against such intrusion (e.g., by using a qualified name).

Changing this can break code that is valid today. However, such code would have to:

1. name a template parameter and not use it after the opening brace, and
2. use that same name to access a base-class name within the braces.

I personally have no qualms breaking such a program.

It has been suggested to make situations like these ill-formed. That solution is unattractive however because it still leaves the writer of a derived class template without defense against accidental name conflicts with base members. (Although at least the problem would be guaranteed to be caught at compile time.) Instead, since just about everyone's intuition agrees, I would like to see the rules changed to make class template parameters hide members of the same name in a base class.

See also issue 458.

Notes from the March 2004 meeting:

We have some sympathy for a change, but the current rules fall straightforwardly out of the lookup rules, so they're not “wrong.” Making private members invisible also would solve this problem. We'd be willing to look at a paper proposing that.

Additional discussion (April, 2005):

John Spicer: Base class members are more-or-less treated as members of the class, [so] it is only natural that the base [member] would hide the template parameter.

Daveed Vandevoorde: Are base class members really “more or less” members of the class from a lookup perspective? After all, derived class members can hide base class members of the same name. So there is some pretty definite boundary between those two sets of names. IMO, the template parameters should either sit between those two sets, or they should (for lookup purposes) be treated as members of the class they parameterize (I cannot think of a practical difference between those two formulations).

John Spicer: How is [hiding template parameters] different from the fact that namespace members can be hidden by private parts of a base class? The addition of `int C` to `N::A` breaks the code in namespace `M` in this example:

        namespace N {
           class A {
        private:
             int C;
           };
        }

        namespace M {
           typedef int C;
           class B : public N::A {
             void f() {
                 C c;
             }
           };
        }

Daveed Vandevoorde: C++ has a mechanism in place to handle such situations: qualified names. There is no such mechanism in place for template parameters.

Nathan Myers: What I see as obviously incorrect ... is simply that a name defined right where I can see it, and directly attached to the textual scope of `B`'s class body, is ignored in favor of something found in some other file. I don't care that `C1` is defined in `A`, I have a `C1` right here that I have chosen to use. If I want `A::C1`, I can say so.

I doubt you'll find any regular C++ coder who doesn't find the standard behavior bizarre. If the meaning of any code is changed by fixing this behavior, the overwhelming majority of cases will be mysterious bugs magically fixed.

John Spicer: I have not heard complaints that this is actually a cause of problems in real user code. Where is the evidence that the status quo is actually causing problems?

In this example, the `T2` that is found is the one from the base class. I would argue that this is natural because base class members are found as part of the lookup in class `B`:

        struct A {
                 typedef int T2;
        };
        template <class T2> struct B : public A {
                 typedef int T1;
                 T1 t1;
                 T2 t2;
        };

This rule that base class members hide template parameters was formalized about a dozen years ago because it fell out of the principle that base class members should be found at the same stage of lookup as derived class members, and that to do otherwise would be surprising.

Gabriel Dos Reis: The bottom line is that:

1. the proposed change is a silent change of meaning;
2. the proposed change does not make the language any more regular; the current behavior is consistent with everything else, however “surprising” that might be;
3. the proposed change does have its own downsides.

Unless presented with real major programming problems the current rules exhibit, I do not think the simple rule “scopes nest” needs a change that silently mutates program meaning.

Mike Miller: The rationale for the current specification is really very simple:

1. “Unless redeclared in the derived class, members of a base class are also considered to be members of the derived class.” (10 [class.derived] paragraph 2)
2. In class scope, members hide nonmembers.

That's it. Because template parameters are not members, they are hidden by member names (whether inherited or not). I don't find that “bizarre,” or even particularly surprising.

I believe these rules are straightforward and consistent, so I would be opposed to changing them. However, I am not unsympathetic toward Daveed's concern about name hijacking from base classes. How about a rule that would make a program ill-formed if a direct or inherited member hides a template parameter?

Unless this problem is a lot more prevalent than I've heard so far, I would not want to change the lookup rules; making this kind of collision a diagnosable error, however, would prevent hijacking without changing the lookup rules.

Erwin Unruh: I have a different approach that is consistent and changes the interpretation of the questionable code. At present lookup is done in this sequence:

block scope
derived class scope
base class scope
template parameters
namespace scope

If we change this order to

template parameters
block scope
derived class scope
base class scope
namespace scope

it is still consistent in that no lookup is placed between the base class and the derived class. However, it introduces another inconsistency: now scopes do not nest the same way as curly braces nest — but base classes are already inconsistent this way.

Nathan Myers: This looks entirely satisfactory. If even this seems like too big a change, it would suffice to say that finding a different name by this search order makes the program ill-formed. Of course, a compiler might issue only a portability warning in that case and use the name found Erwin's way, anyhow.

Gabriel Dos Reis: It is a simple fact, even without templates, that a writer of a derived class cannot protect himself against declaration changes in the base class.

Richard Corden: If a change is to be made, then making it ill-formed is better than just changing the lookup rules.

        struct B
        {
          typedef int T;
          virtual void bar (T const & );
        };

        template <typename T>
        struct D : public B
        {
          virtual void bar (T const & );
        };

        template class D<float>;

I think changing the semantics of the above code silently would result in very difficult-to-find problems.

Mike Miller: Another case that may need to be considered in deciding on Erwin's suggestion or the “ill-formed” alternative is the treatment of `friend` declarations described in 3.4.1 [basic.lookup.unqual] paragraph 10:

        struct A {
            typedef int T;
            void f(T);
        };
        template<typename T> struct B {
            friend void A::f(T);  // Currently T is A::T
        };

Notes from the October, 2005 meeting:

The CWG decided not to consider a change to the existing rules at this time without a paper exploring the issue in more detail.

#### 1619. Definition of current instantiation

Section: 14.6.2.1 [temp.dep.type] Status: open Submitter: Johannes Schaub Date: 2013-02-04

The definition of the current instantiation, given in 14.6.2.1 [temp.dep.type] paragraph 1, is phrased in terms of the meaning of a name (“A name refers to the current instantiation if it is...”); it does not define when a type is the current instantiation. Thus the interpretation of `*this` and of phrases like “member of a class that is the current instantiation” is not formally specified.

#### 1779. Type dependency of `__func__`

Section: 14.6.2.2 [temp.dep.expr] Status: open Submitter: John Spicer Date: 2013-09-25

The length of the `__func__` array is implementation-defined but potentially depends on the signature of the function in which it occurs. However, `__func__` is not listed among the type-dependent id-expressions in 14.6.2.2 [temp.dep.expr] paragraph 3.

#### 1028. Dependent names in non-defining declarations

Section: 14.6.4 [temp.dep.res] Status: open Submitter: Sean Hunt Date: 2010-02-03

The current wording of 14.6.4 [temp.dep.res] seems to assume that dependent names can only appear in the definition of a template:

> In resolving dependent names, names from the following sources are considered:

> - Declarations that are visible at the point of definition of the template.

> - Declarations from namespaces associated with the types of the function arguments both from the instantiation context (14.6.4.1 [temp.point]) and from the definition context.

However, dependent names can occur in non-defining declarations of the template as well; for instance,

        template<typename T>
        T foo(T, decltype(bar(T())));

`bar` needs to be looked up, even though there is no definition of `foo` in the translation unit.

Additional note (February, 2011):

The resolution of this issue can't simply replace the word “definition” with the word “declaration,” mutatis mutandis, because there can be multiple declarations in a translation unit (which isn't true of “the definition”). As a result, the issue was moved back to "open" status for further consideration.

#### 1500. Name lookup of dependent conversion function

Section: 14.6.4.2 [temp.dep.candidate] Status: open Submitter: Johannes Schaub Date: 2012-04-27

Consider the following example:

      template<typename T>
      struct A {
       operator int() { return 0; }

       void f() {
        operator T();
       }
      };

      int main() {
       A<int> a;
       a.f();
      }

One might expect this to call `operator int` when instantiating. But since `operator T` is a dependent name, it is looked up by unqualified lookup only in the definition context, where it will find no declaration. Argument-dependent lookup will not find anything in the instantiation context either, so this code is ill-formed. If we change `operator int()` to `operator T()`, which is a seemingly unrelated change, the code becomes well-formed.

There is implementation variability on this point.

#### 1378. When is an instantiation required?

Section: 14.7.1 [temp.inst] Status: open Submitter: Jason Merrill Date: 2011-08-18

A template instantiation can be “required” without there being a need for it at link time if it can appear in a constant expression:

        template <class T> struct A {
           static const T t;
        };
        template <class T> const T A<T>::t = 0;
        template <int I> struct B { };
        int a = sizeof(B<A<int>::t>);

        template <class T> constexpr T f(T t) { return t; }
        int b = sizeof(B<f(42)>);

It seems like it might be useful to define a term other than odr-used for this sort of use, which is like odr-used but doesn't depend on potentially evaluated context or lvalue-rvalue conversions.

Nikolay Ivchenkov:

Another possibility would be to introduce the extension described in the closed issue 1272 and then change 3.2 [basic.def.odr] paragraph 2 as follows:

> An expression `E` is potentially evaluated unless it is an unevaluated operand (Clause 5 [expr]) or a subexpression thereof. if and only if

> - `E` is a full-expression, or

> - `E` appears in a context where a constant expression is required, or

> - `E` is a direct subexpression of a potentially-evaluated expression and `E` is not an unevaluated operand.

> An expression `S` is a direct subexpression of an expression `E` if and only if `S` and `E` are different expressions, `S` is a subexpression of `E`, and there is no expression `X` such that `X` differs from both `S` and `E`, `S` is a subexpression of `X`, and `X` is a subexpression of `E`. A variable whose name appears as a potentially-evaluated expression is odr-used unless it is an object that satisfies the requirements for appearing in a constant expression (5.19 [expr.const]) and the lvalue-to-rvalue conversion (4.1) is immediately applied...

> [Example:

>         template <class T> struct X {
>             static int const m = 1;
>             static int const n;
>         };
>         template <class T> int const X<T>::n = 2;

>         int main() {
>             // X<void>::m is odr-used,
>             // X<void>::m is defined implicitly
>             std::cout << X<void>::m << std::endl;

>             // X<void>::n is odr-used,
>             // X<void>::n is defined explicitly
>             std::cout << X<void>::n << std::endl;

>             // OK (issue 712 is not relevant here)
>             std::cout << (1 ? X<void>::m : X<void>::n) << std::endl;
>         }

(See also issues 712 and 1254.)

#### 1602. Linkage of specialization vs linkage of template arguments

Section: 14.7.1 [temp.inst] Status: open Submitter: Richard Smith Date: 2013-01-09

The Standard does not appear to specify the linkage of a template specialization. 14.7.1 [temp.inst] paragraph 11 does say,

> Implicitly instantiated class and function template specializations are placed in the namespace where the template is defined.

which could be read as implying that the specialization has the same linkage as the template itself. Implementation practice seems to be that the weakst linkage of the template and the arguments is used for the specialization.

#### 293. Syntax of explicit instantiation/specialization too permissive

Section: 14.7.2 [temp.explicit] Status: open Submitter: Mark Mitchell Date: 27 Jun 2001

14.7.2 [temp.explicit] defines an explicit instantiation as

explicit-instantiation:

`template` declaration

Syntactically, that allows things like:

        template int S<int>::i = 5, S<int>::j = 7;

which isn't what anyone actually expects. As far as I can tell, nothing in the standard explicitly forbids this, as written. Syntactically, this also allows:

        template namespace N { void f(); }

although perhaps the surrounding context is enough to suggest that this is invalid.

Suggested resolution:

I think we should say:

explicit-instantiation:

type-specifier-seqopt declaratoropt `;`

[Steve Adamczyk: presumably, this should have `template` at the beginning.]

and then say that:

- The declarator can be omitted only when the type-specifier-seq consists solely of an elaborated-type-specifier for a class type, in which case the instantiation is for the named class. If the declarator is present the instantiation is for the named entity.
- The type-specifier-seq can be omitted only when the declarator is for a constructor, destructor, or conversion operator.
- The type-specifier-seq cannot define any new types.

There are similar problems in 14.7.3 [temp.expl.spec]:

explicit-specialization:

`template` <> declaration

Here, I think we want:

explicit-specialization:

decl-specifier-seqopt init-declaratoropt `;`

with similar restrictions as above.

[Steve Adamczyk: This also needs to have `template <>` at the beginning, possibly repeated.]

#### 1046. What is a “use” of a class specialization?

Section: 14.7.2 [temp.explicit] Status: open Submitter: Michael Wong Date: 2010-03-08

According to 14.7.2 [temp.explicit] paragraph 10,

> An entity that is the subject of an explicit instantiation declaration and that is also used in the translation unit shall be the subject of an explicit instantiation definition somewhere in the program; otherwise the program is ill-formed, no diagnostic required.

The term “used” is too vague and needs to be defined. In particular, “use” of a class template specialization as an incomplete type — to form a pointer, for instance — should not require the presence of an explicit instantiation definition elsewhere in the program.

#### 727. In-class explicit specializations

Section: 14.7.3 [temp.expl.spec] Status: open Submitter: Faisal Vali Date: 5 October, 2008

14.7.3 [temp.expl.spec] paragraph 2 requires that explicit specializations of member templates be declared in namespace scope, not in the class definition. This restriction does not apply to partial specializations of member templates; that is,

        struct A {
          template<class T> struct B;
          template <class T> struct B<T*> { }; // well-formed
          template <> struct B<int*> { }; // ill-formed
        };

There does not seem to be a good reason for this inconsistency.

Additional note (October, 2013):

EWG has requested CWG to consider resolving this issue. See EWG issue 41.

#### 1792. Incorrect example of explicit specialization of member enumeration

Section: 14.7.3 [temp.expl.spec] Status: open Submitter: John Spicer Date: 2013-10-01

The example in 14.7.3 [temp.expl.spec] paragraph 6 reads, in part,

      template<class T> struct A {
        enum E : T;
        enum class S : T;
      };
      template<> enum A<int>::E : int { eint };         // OK
      template<> enum class A<int>::S : int { sint };   // OK
      template<class T> enum A<T>::E : T { eT };
      template<class T> enum class A<T>::S : T { sT };
      template<> enum A<char>::E : int { echar };       // ill-formed, A<char>::E was instantiated
                                                        // when A<char> was instantiated
      template<> enum class A<char>::S : int { schar }; // OK

The `int` enum-base in the last two lines appears to be incorrect; the reference to `A<char>` in the nested-name-specifier will have instantiated the declarations of `E` and `S` with an enum-base of `char`, and the explicit specializations must agree.

#### 264. Unusable template constructors and conversion functions

Section: 14.8.1 [temp.arg.explicit] Status: open Submitter: John Spicer Date: 17 Nov 2000

The note in paragraph 5 of 14.8.1 [temp.arg.explicit] makes clear that explicit template arguments cannot be supplied in invocations of constructors and conversion functions because they are called without using a name. However, there is nothing in the current wording of the Standard that makes declaring a constructor or conversion operator that is unusable because of nondeduced parameters (i.e., that would need to be specified explicitly) ill-formed. It would be a service to the programmer to diagnose this useless construct as early as possible.

#### 271. Explicit instantiation and template argument deduction

Section: 14.8.2 [temp.deduct] Status: open Submitter: John Spicer Date: 20 Feb 2001

Nicolai Josuttis sent me an example like the following:

        template <typename RET, typename T1, typename T2>
        const RET& min (const T1& a, const T2& b)
        {
    	return (a < b ? a : b);
        }
        template const int& min<int>(const int&,const int&);  // #1
        template const int& min(const int&,const int&);       // #2

Among the questions was whether explicit instantiation #2 is valid, where deduction is required to determine the type of `RET`.

The first thing I realized when researching this is that the standard does not really spell out the rules for deduction in declarative contexts (friend declarations, explicit specializations, and explicit instantiations). For explicit instantiations, 14.7.2 [temp.explicit] paragraph 2 does mention deduction, but it doesn't say which set of deduction rules from 14.8.2 [temp.deduct] should be applied.

Second, Nicolai pointed out that 14.7.2 [temp.explicit] paragraph 6 says

> A trailing template-argument can be left unspecified in an explicit instantiation provided it can be deduced from the type of a function parameter (14.8.2 [temp.deduct]).

This prohibits cases like #2, but I believe this was not considered in the wording as there is no reason not to include the return type in the deduction process.

I think there may have been some confusion because the return type is excluded when doing deduction on a function call. But there are contexts where the return type is included in deduction, for example, when taking the address of a function template specialization.

Suggested resolution:

1. Update 14.8.2 [temp.deduct] to include a section "Deducing template arguments from a declaration" that describes how deduction is done when finding a template that matches a declaration. This should, I believe, include the return type.
2. Update 14.7.2 [temp.explicit] to make reference to the new rules in 14.8.2 [temp.deduct] and remove the description of the deduction details from 14.7.2 [temp.explicit] paragraph 6.

#### 297. Which template does an explicit specialization specialize?

Section: 14.8.2 [temp.deduct] Status: open Submitter: Andrei Iltchenko Date: 7 Jul 2001

Andrei Iltchenko points out that the standard has no wording that defines how to determine which template is specialized by an explicit specialization of a function template. He suggests "template argument deduction in such cases proceeds in the same way as when taking the address of a function template, which is described in 14.8.2.2 [temp.deduct.funcaddr]."

John Spicer points out that the same problem exists for all similar declarations, i.e., friend declarations and explicit instantiation directives. Finding a corresponding placement `operator delete` may have a similar problem.

John Spicer: There are two aspects of "determining which template" is referred to by a declaration: determining the function template associated with the named specialization, and determining the values of the template arguments of the specialization.

        template <class T> void f(T);  #1
        template <class T> void f(T*); #2
        template <> void f(int*);

In other words, which `f` is being specialized (#1 or #2)? And then, what are the deduced template arguments?

14.5.6.2 [temp.func.order] does say that partial ordering is done in contexts such as this. Is this sufficient, or do we need to say more about the selection of the function template to be selected?

14.8.2 [temp.deduct] probably needs a new section to cover argument deduction for cases like this.

#### 697. Deduction rules apply to more than functions

Section: 14.8.2 [temp.deduct] Status: open Submitter: Doug Gregor Date: 6 June, 2008

14.8.2 [temp.deduct] is all about function types, but these rules also apply, e.g., when matching a class template partial specialization. We should add a note stating that we could be doing substitution into the template-id for a class template partial specialization.

Additional note (August 2008):

According to 14.5.5.1 [temp.class.spec.match] paragraph 2, argument deduction is used to determine whether a given partial specialization matches a given argument list. However, there is nothing in 14.5.5.1 [temp.class.spec.match] nor in 14.8.2 [temp.deduct] and its subsections that describes exactly how argument deduction is to be performed in this case. It would seem that more than just a note is required to clarify this processing.

#### 503. Cv-qualified function types in template argument deduction

Section: 14.8.2.1 [temp.deduct.call] Status: open Submitter: Gabriel Dos Reis Date: 22 Feb 2005

Consider the following program:

        template <typename T> int ref (T&)                { return 0; }
        template <typename T> int ref (const T&)          { return 1; }
        template <typename T> int ref (const volatile T&) { return 2; }
        template <typename T> int ref (volatile T&)       { return 4; }

        template <typename T> int ptr (T*)                { return 0; }
        template <typename T> int ptr (const T*)          { return 8; }
        template <typename T> int ptr (const volatile T*) { return 16; }
        template <typename T> int ptr (volatile T*)       { return 32; }

        void foo() {}

        int main()
        {
            return ref(foo) + ptr(&foo);
        }

The Standard appears to specify that the value returned from `main` is 2. The reason for this result is that references and pointers are handled differently in template argument deduction.

For the reference case, 14.8.2.1 [temp.deduct.call] paragraph 3 says that “If `P` is a reference type, the type referred to by `P` is used for type deduction.” Because of issue 295, all four of the types for the `ref` function parameters are the same, with no cv-qualification; overload resolution does not find a best match among the parameters and thus the most-specialized function is selected.

For the pointer type, argument deduction does not get as far as forming a cv-qualified function type; instead, argument deduction fails in the cv-qualified cases because of the cv-qualification mismatch, and only the cv-unqualified version of `ptr` survives as a viable function.

I think the choice of ignoring cv-qualifiers in the reference case but not the pointer case is very troublesome. The reason is that when one considers function objects as function parameters, it introduces a semantic difference whether the function parameter is declared a reference or a pointer. In all other contexts, it does not matter: a function name decays to a pointer and the resulting semantics are the same.

(See also issue 1584.)

#### 1221. Partial ordering and reference collapsing

Section: 14.8.2.4 [temp.deduct.partial] Status: open Submitter: Michael Wong Date: 2010-11-08

The current partial ordering rules produce surprising results in the presence of reference collapsing.

Since partial ordering is currently based solely on the signature of the function templates, the lack of difference following substitution of the template type parameter in the following is not taken into account.

Especially unsettling is that the allegedly "more specialized" template (#2) is not a candidate in the first call where template argument deduction fails for it despite a lack of non-deduced contexts.

        template <typename T>
        void foo(T&&);  // #1

        template <typename T>
        void foo(volatile T&&);  // #2

        int main(void) {
          const int x = 0;
          foo(x);  // calls #1 with T='const int &'
          foo<const int &>(x);  // calls #2
        }

#### 1763. Length mismatch in template type deduction

Section: 14.8.2.5 [temp.deduct.type] Status: open Submitter: Canada Date: 2013-09-23
N3690 comment CA 4

It is not clear how an example like the following is to be handled:

      template <typename U>
      struct A {
        template <typename V> operator A<V>();
      };

      template <typename T>
      void foo(A<void (T)>);

      void foo();

      int main() {
        A<void (int, char)> a;
        foo<int>(a);
        foo(a); // deduces T to be int
      }

In subclause 14.8.2.5 [temp.deduct.type] paragraph 10, deduction from a function type considers P/A pairs from the parameter-type-list only where the "P" function type has a parameter. Deduction is not specified to fail if there are additional parameters in the corresponding "A" function type.

Notes from the September, 2013 meeting:

CWG agreed that this example should not be accepted. The existing rules seem to cover this case (deduction is not specified to “succeed,” so it's a reasonable conclusion that it fails), but it might be helpful to be clearer.

#### 1774. Discrepancy between subobject destruction and stack unwinding

Section: 15.2 [except.ctor] Status: open Submitter: Canada Date: 2013-09-24
N3690 comment CA 24

The current wording of 15.5.1 [except.terminate] paragraph 2 affords implementations a significant degree of freedom when exception handling results in a call to `std::terminate:`

> In the situation where no matching handler is found, it is implementation-defined whether or not the stack is unwound before `std::terminate()` is called. In the situation where the search for a handler (15.3 [except.handle]) encounters the outermost block of a function with a noexcept-specification that does not allow the exception (15.4 [except.spec]), it is implementation-defined whether the stack is unwound, unwound partially, or not unwound at all before `std::terminate()` is called. In all other situations, the stack shall not be unwound before std::terminate() is called.

This contrasts with the treatment of subobjects and objects constructed via delegating constructos in 15.2 [except.ctor] paragraph 2:

> An object of any storage duration whose initialization or destruction is terminated by an exception will have destructors executed for all of its fully constructed subobjects (excluding the variant members of a union-like class), that is, for subobjects for which the principal constructor (12.6.2 [class.base.init]) has completed execution and the destructor has not yet begun execution. Similarly, if the non-delegating constructor for an object has completed execution and a delegating constructor for that object exits with an exception, the object's destructor will be invoked.

Here the destructors must be called. It would be helpful if these requirements were harmonized.

Notes from the September, 2013 meeting:

Although the Canadian NB comment principally was a request to reconsider the resolution of issue 1424, which CWG decided to retain, the comment also raised the question above, which CWG felt merited its own issue.

#### 1777. Empty pack expansion in dynamic-exception-specification

Section: 15.4 [except.spec] Status: open Submitter: Richard Smith Date: 2013-09-24

According to 14.5.3 [temp.variadic] paragraph 6, describing an empty pack expansion,

> When N is zero, the instantiation of the expansion produces an empty list. Such an instantiation does not alter the syntactic interpretation of the enclosing construct, even in cases where omitting the list entirely would otherwise be ill-formed or would result in an ambiguity in the grammar.

This leaves open the question of whether something like

      template<typename...T> void f() throw(T...);

should be considered to have a non-throwing exception-specification when `T...` is empty. The definition in 15.4 [except.spec] paragraph 12 appears to be syntactic regarding dynamic-exception-specifications:

> An exception-specification is non-throwing if it is of the form `throw()`, `noexcept`, or `noexcept(`constant-expression `)` where the constant-expression yields `true`. A function with a non-throwing exception-specification does not allow any exceptions.

It seems evident, however, that a dynamic-exception-specification with an empty pack expansion “does not allow any exceptions.”

#### 596. Replacing an exception object

Section: 15.5.2 [except.unexpected] Status: open Submitter: Alisdair Meredith Date: 12 September 2006

When a function throws an exception that is not in its exception-specification, `std::unexpected()` is called. According to 15.5.2 [except.unexpected] paragraph 2,

> If [`std::unexpected()`] throws or rethrows an exception that the exception-specification does not allow then the following happens: If the exception-specification does not include the class `std::bad_exception` (18.8.2 [bad.exception]) then the function `std::terminate()` is called, otherwise the thrown exception is replaced by an implementation-defined object of the type `std::bad_exception,` and the search for another handler will continue at the call of the function whose exception-specification was violated.

The “replaced by” wording is imprecise and undefined. For example, does this mean that the destructor is called for the existing exception object, or is it simply abandoned? Is the replacement in situ, so that a pointer to the existing exception object will now point to the `std::bad_exception` object?

Mike Miller: The call to `std::unexpected()` is not described as analogous to invoking a handler, but if it were, that would resolve this question; it is clearly specified what happens to the previous exception object when a new exception is thrown from a handler (15.1 [except.throw] paragraph 4).

This approach would also clarify other questions that have been raised regarding the requirements for stack unwinding. For example, 15.5.1 [except.terminate] paragraph 2 says that

> In the situation where no matching handler is found, it is implementation-defined whether or not the stack is unwound before `std::terminate()` is called.

This requirement could be viewed as in conflict with the statement in 15.5.2 [except.unexpected] paragraph 1 that

> If a function with an exception-specification throws an exception that is not listed in the exception-specification, the function `std::unexpected()` is called (D.11 [exception.unexpected]) immediately after completing the stack unwinding for the former function.

If it is implementation-defined whether stack unwinding occurs before calling `std::terminate()` and `std::unexpected()` is called only after doing stack unwinding, does that mean that it is implementation-defined whether `std::unexpected()` is called if there is ultimately no handler found?

Again, if invoking `std::unexpected()` were viewed as essentially invoking a handler, the answer to this would be clear, because unwinding occurs before invoking a handler.

#### 925. Type of character literals in preprocessor expressions

Section: 16.1 [cpp.cond] Status: open Submitter: Michael Wong Date: 29 June, 2009

According to 16.1 [cpp.cond] paragraph 4,

> The resulting tokens comprise the controlling constant expression which is evaluated according to the rules of 5.19 [expr.const] using arithmetic that has at least the ranges specified in 18.3 [support.limits], except that all signed and unsigned integer types act as if they have the same representation as, respectively, `intmax_t` or `uintmax_t` (_N3035_.18.4.2 [stdinth]). This includes interpreting character literals, which may involve converting escape sequences into execution character set members.

Ordinary character literals with a single c-char have the type `char`, which is neither a signed nor an unsigned integer type. Although 4.5 [conv.prom] paragraph 1 is clear that `char` values promote to `int`, regardless of whether the implementation treats `char` as having the values of `signed char` or `unsigned char`, 16.1 [cpp.cond] paragraph 4 isn't clear on whether character literals should be treated as signed or unsigned values. In C99, such literals have type `int`, so the question does not arise. If an implementation in which plain `char` has the values of `unsigned char` were to treat character literals as unsigned, an expression like `'0'-'1'` would thus have different values in C and C++, namely -1 in C and some large unsigned value in C++.

#### 1718. Macro invocation spanning end-of-file

Section: 16.3 [cpp.replace] Status: open Submitter: David Krauss Date: 2013-07-23

Although it seems to be common implementation practice to reject a macro invocation that begins in a header file and whose closing right parenthesis appears in the file that included it, there does not seem to be a prohibition of this case in the specification of function-style macros. Should this be accepted?

#### 1625. Adding spaces between tokens in stringizing

Section: 16.3.2 [cpp.stringize] Status: open Submitter: Chandler Carruth Date: 2013-02-18

Given the following input,

      #define F(A, B, C) A ## x.B ## y.C ## z
      #define STRINGIFY(x) #x
      #define EXPAND_AND_STRINGIFY(x) STRINGIFY(x)
      char v[] = EXPAND_AND_STRINGIFY(F(a, b, c))

there is implementation variance in the value of `v`: some produce the string `"ax.by.cz"` and others produce the string `"ax. by. cz"`. Although 16.3.2 [cpp.stringize] paragraph 2 is explicit in its treatment of leading and trailing white space, it is not clear whether there is latitude for inserting spaces between tokens, as some implementations do, since the description otherwise is written solely in terms of preprocessing tokens. There may be cases in which such spaces would be needed to preserve the original tokenization, but it is not clear whether the result of stringization needs to produce something that would lex to the same tokens.

Notes from the April, 2013 meeting:

Because the preprocessor specification is primarily copied directly from the C Standard, this issue has been referred to the C liaison for consultation with WG14.

#### 268. Macro name suppression in rescanned replacement text

Section: 16.3.4 [cpp.rescan] Status: open Submitter: Bjarne Stroustrup Date: 18 Jan 2001

It is not clear from the Standard what the result of the following example should be:

>     #define NIL(xxx) xxx
>     #define G_0(arg) NIL(G_1)(arg)
>     #define G_1(arg) NIL(arg)
>     G_0(42)

The relevant text from the Standard is found in 16.3.4 [cpp.rescan] paragraph 2:

> If the name of the macro being replaced is found during this scan of the replacement list (not including the rest of the source file's preprocessing tokens), it is not replaced. Further, if any nested replacements encounter the name of the macro being replaced, it is not replaced. These nonreplaced macro name preprocessing tokens are no longer available for further replacement even if they are later (re)examined in contexts in which that macro name preprocessing token would otherwise have been replaced.

The sequence of expansion of `G0(42)` is as follows:

>     G0(42)
>     NIL(G_1)(42)
>     G_1(42)
>     NIL(42)

The question is whether the use of `NIL` in the last line of this sequence qualifies for non-replacement under the cited text. If it does, the result will be `NIL(42)`. If it does not, the result will be simply `42`.

The original intent of the J11 committee in this text was that the result should be `42`, as demonstrated by the original pseudo-code description of the replacement algorithm provided by Dave Prosser, its author. The English description, however, omits some of the subtleties of the pseudo-code and thus arguably gives an incorrect answer for this case.

Suggested resolution (Mike Miller): Replace the cited paragraph with the following:

> As long as the scan involves only preprocessing tokens from a given macro's replacement list, or tokens resulting from a replacement of those tokens, an occurrence of the macro's name will not result in further replacement, even if it is later (re)examined in contexts in which that macro name preprocessing token would otherwise have been replaced.

> Once the scan reaches the preprocessing token following a macro's replacement list — including as part of the argument list for that or another macro — the macro's name is once again available for replacement. [Example:

>         #define NIL(xxx) xxx
>         #define G_0(arg) NIL(G_1)(arg)
>         #define G_1(arg) NIL(arg)
>         G_0(42)                         // result is 42, not NIL(42)

> The reason that `NIL(42)` is replaced is that `(42)` comes from outside the replacement list of `NIL(G_1)`, hence the occurrence of `NIL` within the replacement list for `NIL(G_1)` (via the replacement of `G_1(42)`) is not marked as nonreplaceable. —end example]

(Note: The resolution of this issue must be coordinated with J11/WG14.)

Notes (via Tom Plum) from April, 2004 WG14 Meeting:

Back in the 1980's it was understood by several WG14 people that there were tiny differences between the "non-replacement" verbiage and the attempts to produce pseudo-code. The committee's decision was that no realistic programs "in the wild" would venture into this area, and trying to reduce the uncertainties is not worth the risk of changing conformance status of implementations or programs.

#### 745. Effect of ill-formedness resulting from `#error`

Section: 16.5 [cpp.error] Status: open Submitter: Clark Nelson Date: 13 November, 2008

C99 is very clear that a `#error` directive causes a translation to fail: Clause 4 paragraph 4 says,

> The implementation shall not successfully translate a preprocessing translation unit containing a `#error` preprocessing directive unless it is part of a group skipped by conditional inclusion.

C++, on the other hand, simply says that a `#error` directive “renders the program ill-formed” (16.5 [cpp.error]), and the only requirement for an ill-formed program is that a diagnostic be issued; the translation may continue and succeed. (Noted in passing: if this difference between C99 and C++ is addressed, it would be helpful for synchronization purposes in other contexts as well to introduce the term “preprocessing translation unit.”)

#### 897. `_Pragma` and extended string-literals

Section: 16.9 [cpp.pragma.op] Status: open Submitter: Daniel Krügler Date: 9 May, 2009

The specification of how the string-literal in a `_Pragma` operator is handled does not deal with the new kinds of string literals. 16.9 [cpp.pragma.op] says,

> The string literal is destringized by deleting the `L` prefix, if present, deleting the leading and trailing double-quotes, replacing each escape sequence...

The various other prefixes should either be handled or prohibited.

Additional note (October, 2013):

If raw string literals are supported, the question of how to handle line splicing is relevant. The wording says that “the characters are processed through translation phase 3,” which is a bit ambiguous as to whether that includes phases 1 and 2 or not. It would be better to be explicit and say that the processing of phase 3 or of phases 1 through 3 is applied.

#### 1248. Updating Annex C to C99

Section: C.1 [diff.iso] Status: open Submitter: Jonathan Wakely Date: 2011-02-28

The description of incompatibilities with C in Annex C.1 [diff.iso] refers to C89, but there are a number of new features in C99 that should be covered.

### Issues with "Concurrency" Status

#### 1441. Unclear wording for signal handler restrictions

Section: 1.9 [intro.execution] Status: concurrency Submitter: Alisdair Meredith Date: 2012-01-06

The wording of 1.9 [intro.execution] paragraph 6 is intended to describe the values of objects upon entry to and exit from the handler — i.e., that signal handler cannot rely on non-atomic objects being in a consistent state upon entry, nor can it reliably set the value of non-atomic objects and expect that they will continue to have those values after the handler exits. However, the wording could be read as saying even during the execution of the handler it cannot set and use non-atomic objects. The wording should be clarified.

#### 1466. Visible sequences of side effects are redundant

Section: 1.10 [intro.multithread] Status: concurrency Submitter: Mark Batty Date: 2012-02-21

[The following is reproduced verbatim from WG14 DR406 as a C-liaison issue.]

It has been mathematically proved that a simplification can be made to the memory model as it is specified in the final draft of the C++11 standard. Essentially, the restriction defining visible sequence of side effects (vsse) is redundant and can be removed with no ill effects. The main motivation for doing this is that the current restriction is misleading. 5.1.2.4p22 defines vsse's:

> The visible sequence of side effects on an atomic object M, with respect to a value computation B of M, is a maximal contiguous sub-sequence of side effects in the modification order of M, where the first side effect is visible with respect to B, and for every subsequent side effect, it is not the case that B happens before it. The value of an atomic object M, as determined by evaluation B, shall be the value stored by some operation in the visible sequence of M with respect to B.

The wording of this paragraph makes it seem as if the vsse identifies the writes that an atomic read is allowed to read from, but this is not the case. There can be writes in the vsse that cannot be read due to the coherence requirements (to be included in C, 1.10p15 through 1.10p18 in C++ N3291). Consequently this is even more confusing than it at first appears.

Also propose changing 5.1.2.4p22 to the following:

> The value of an atomic object M, as determined by evaluation B, shall be the value stored by some side effect A that modifies M, where B does not happen before A.

With a note to remind the reader of the coherence requirements:

> NOTE: The set of side effects that a given evaluation might take its value from is also restricted by the rest of the rules described here, and in particular, by the coherence requirements below

If the committee is concerned about allowing a differing text from C++11, then a note could be added to assure the reader:

> NOTE: Although the rules for multi-threaded executions differ here from those of C++11, the executions they allow are precisely the same. Visible sequences of side effects are a redundant restriction.

Proposed resolution (September, 2013):

1. Change 1.10 [intro.multithread] paragraph 14 as follows:

> The visible sequence of side effects on an atomic object M, with respect to a value computation B of M, is a maximal contiguous sub-sequence of side effects in the modification order of M, where the first side effect is visible with respect to B, and for every side effect, it is not the case that B happens before it. The value of an atomic object M, as determined by evaluation B, shall be the value stored by some operation in the visible sequence of M with respect to B side effect A that modifies M, where B does not happen before A. [Note: It can be shown that the visible sequence of side effects of a value computation is unique given The set of side effects that a given evaluation might take its value from is also restricted by the rest of the rules described here, and in particular, by the coherence requirements below. —end note]

2. Change 1.10 [intro.multithread] paragraph 20 as follows:

> [Note: The visible sequence of side effects value observed by a load of an atomic depends on the “happens before” relation, which depends on the values observed by loads of atomics, which we are restricting here. The intended reading is that there must exist an association of atomic loads with modifications they observe that, together with suitably chosen modification orders and the “happens before” relation derived as described above, satisfy the resulting constraints as imposed here. —end note]

3. Change 1.10 [intro.multithread] paragraph 22 as follows:

> [Note: Compiler transformations that introduce assignments to a potentially shared memory location that would not be modified by the abstract machine are generally precluded by this standard, since such an assignment might overwrite another assignment by a different thread in cases in which an abstract machine execution would not have encountered a data race. This includes implementations of data member assignment that overwrite adjacent members in separate memory locations. Reordering of atomic loads in cases in which the atomics in question may alias is also generally precluded, since this may violate the “visible sequence” coherence rules. —end note]

4. Change 29.3 [atomics.order] paragraph 3 as follows:

> There shall be a single total order S on all `memory_order_seq_cst` operations, consistent with the “happens before” order and modification orders for all affected locations, such that each `memory_order_seq_cst` operation B that loads a value from an atomic object M observes one of the following values:

> - the result of the last modification A of M that precedes B in S, if it exists, or

> - if A exists, the result of some modification of M in the visible sequence of side effects with respect to B that is not `memory_order_seq_cst` and that does not happen before A, or

> - if A does not exist, the result of some modification of M in the visible sequence of side effects with respect to B that is not `memory_order_seq_cst`.

> [Note:...

#### 1661. Preservation of infinite loops

Section: 1.10 [intro.multithread] Status: concurrency Submitter: Daniel Krügler Date: 2013-04-15

According to 1.10 [intro.multithread] paragraph 24,

> The implementation may assume that any thread will eventually do one of the following:

> - terminate,

> - make a call to a library I/O function,

> - access or modify a volatile object, or

> - perform a synchronization operation or an atomic operation.

> [Note: This is intended to allow compiler transformations such as removal of empty loops, even when termination cannot be proven. —end note]

Some programmers find this liberty afforded to implementations to be disadvantageous; see this blog post for a discussion of the subject.

#### 1784. Concurrent execution during static local initialization

Section: 6.7 [stmt.dcl] Status: concurrency Submitter: Jens Maurer Date: 2013-09-27

Regarding initialization of a block-scope static variable, 6.7 [stmt.dcl] paragraph 4 says,

> If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

This specification does not use the terminology of 1.10 [intro.multithread], so the meaning of “wait” is not clear. For example, will a concurrent thread that “waited” see (in the sense of happens-before) the result of the initialization (including side effects caused during the initialization)?

Perhaps the “synchronizes-with” terminology could be used here.