Index: include/clang/AST/Decl.h =================================================================== --- include/clang/AST/Decl.h +++ include/clang/AST/Decl.h @@ -2729,6 +2729,11 @@ /// bit-fields. bool isZeroLengthBitField(const ASTContext &Ctx) const; + /// Determine if this field is a subobject of zero size, that is, either a + /// zero-length bit-field or a field of empty class type with the + /// [[no_unique_address]] attribute. + bool isZeroSize(const ASTContext &Ctx) const; + /// Get the kind of (C++11) default member initializer that this field has. InClassInitStyle getInClassInitStyle() const { InitStorageKind storageKind = InitStorage.getInt(); Index: include/clang/AST/DeclCXX.h =================================================================== --- include/clang/AST/DeclCXX.h +++ include/clang/AST/DeclCXX.h @@ -334,10 +334,12 @@ /// True when this class is a POD-type. unsigned PlainOldData : 1; - /// true when this class is empty for traits purposes, - /// i.e. has no data members other than 0-width bit-fields, has no - /// virtual function/base, and doesn't inherit from a non-empty - /// class. Doesn't take union-ness into account. + /// True when this class is empty for traits purposes, that is: + /// * has no data members other than 0-width bit-fields and empty fields + /// marked [[no_unique_address]] + /// * has no virtual function/base, and + /// * doesn't inherit from a non-empty class. + /// Doesn't take union-ness into account. unsigned Empty : 1; /// True when this class is polymorphic, i.e., has at Index: include/clang/Basic/Attr.td =================================================================== --- include/clang/Basic/Attr.td +++ include/clang/Basic/Attr.td @@ -14,6 +14,7 @@ } def DocCatFunction : DocumentationCategory<"Function Attributes">; def DocCatVariable : DocumentationCategory<"Variable Attributes">; +def DocCatField : DocumentationCategory<"Field Attributes">; def DocCatType : DocumentationCategory<"Type Attributes">; def DocCatStmt : DocumentationCategory<"Statement Attributes">; def DocCatDecl : DocumentationCategory<"Declaration Attributes">; @@ -338,6 +339,11 @@ def TargetWindows : TargetArch<["x86", "x86_64", "arm", "thumb", "aarch64"]> { let OSes = ["Win32"]; } +def TargetItaniumCXXABI : TargetSpec { + // FIXME: Call isItaniumFamily rather than duplicating it here. + let CXXABIs = ["GenericItanium", "GenericARM", "iOS", "iOS64", "WatchOS", + "GenericAArch64", "GenericMIPS", "WebAssembly"]; +} def TargetMicrosoftCXXABI : TargetArch<["x86", "x86_64", "arm", "thumb", "aarch64"]> { let CXXABIs = ["Microsoft"]; } @@ -1408,6 +1414,12 @@ let ASTNode = 0; } +def NoUniqueAddress : InheritableAttr, TargetSpecificAttr { + let Spellings = [CXX11<"", "no_unique_address", 201803>]; + let Subjects = SubjectList<[NonBitField], ErrorDiag>; + let Documentation = [NoUniqueAddressDocs]; +} + def ReturnsTwice : InheritableAttr { let Spellings = [GCC<"returns_twice">]; let Subjects = SubjectList<[Function]>; Index: include/clang/Basic/AttrDocs.td =================================================================== --- include/clang/Basic/AttrDocs.td +++ include/clang/Basic/AttrDocs.td @@ -1009,6 +1009,18 @@ }]; } +def NoUniqueAddressDocs : Documentation { + let Category = DocCatField; + let Content = [{ +The ``no_unique_address`` attribute allows tail padding in a non-static data +member to overlap other members of the enclosing class (and in the special +case when the type is empty, permits it to fully overlap other members). +The field is laid out as if a base class were encountered at the corresponding +point within the class (except that it does not share a vptr with the enclosing +object). + }]; +} + def ObjCRequiresSuperDocs : Documentation { let Category = DocCatFunction; let Content = [{ Index: lib/AST/Decl.cpp =================================================================== --- lib/AST/Decl.cpp +++ lib/AST/Decl.cpp @@ -3913,6 +3913,44 @@ getBitWidthValue(Ctx) == 0; } +bool FieldDecl::isZeroSize(const ASTContext &Ctx) const { + if (isZeroLengthBitField(Ctx)) + return true; + + // C++2a [intro.object]p7: + // An object has nonzero size if it + // -- is not a potentially-overlapping subobject, or + if (!hasAttr()) + return false; + + // -- is not of class type, or + const auto *RT = getType()->getAs(); + if (!RT) + return false; + const RecordDecl *RD = RT->getDecl()->getDefinition(); + if (!RD) { + assert(isInvalidDecl() && "valid field has incomplete type"); + return false; + } + + // -- [has] virtual member functions or virtual base classes, or + // -- has subobjects of nonzero size or bit-fields of nonzero length + if (const auto *CXXRD = dyn_cast(RD)) { + if (!CXXRD->isEmpty()) + return false; + } else { + for (const FieldDecl *FD : RD->fields()) + if (!FD->isZeroSize(Ctx)) + return false; + } + + // Otherwise, [...] the circumstances under which the object has zero size + // are implementation-defined. + // FIXME: This might be Itanium ABI specific; we don't yet know what the MS + // ABI will do. + return true; +} + unsigned FieldDecl::getFieldIndex() const { const FieldDecl *Canonical = getCanonicalDecl(); if (Canonical != this) Index: lib/AST/DeclCXX.cpp =================================================================== --- lib/AST/DeclCXX.cpp +++ lib/AST/DeclCXX.cpp @@ -605,14 +605,19 @@ // that sure looks like a wording bug. // -- If X is a non-union class type with a non-static data member - // [recurse to] the first non-static data member of X + // [recurse to each field] that is either of zero size or is the + // first non-static data member of X // -- If X is a union type, [recurse to union members] + bool IsFirstField = true; for (auto *FD : X->fields()) { // FIXME: Should we really care about the type of the first non-static // data member of a non-union if there are preceding unnamed bit-fields? if (FD->isUnnamedBitfield()) continue; + if (!IsFirstField && !FD->isZeroSize(Ctx)) + continue; + // -- If X is n array type, [visit the element type] QualType T = Ctx.getBaseElementType(FD->getType()); if (auto *RD = T->getAsCXXRecordDecl()) @@ -620,7 +625,7 @@ return true; if (!X->isUnion()) - break; + IsFirstField = false; } } @@ -1068,6 +1073,10 @@ if (T->isReferenceType()) data().DefaultedMoveAssignmentIsDeleted = true; + // Bitfields of length 0 are also zero-sized, but we already bailed out for + // those because they are always unnamed. + bool IsZeroSize = Field->isZeroSize(Context); + if (const auto *RecordTy = T->getAs()) { auto *FieldRec = cast(RecordTy->getDecl()); if (FieldRec->getDefinition()) { @@ -1183,7 +1192,8 @@ // A standard-layout class is a class that: // [...] // -- has no element of the set M(S) of types as a base class. - if (data().IsStandardLayout && (isUnion() || IsFirstField) && + if (data().IsStandardLayout && + (isUnion() || IsFirstField || IsZeroSize) && hasSubobjectAtOffsetZeroOfEmptyBaseType(Context, FieldRec)) data().IsStandardLayout = false; @@ -1265,8 +1275,10 @@ } // C++14 [meta.unary.prop]p4: - // T is a class type [...] with [...] no non-static data members - data().Empty = false; + // T is a class type [...] with [...] no non-static data members other + // than subobjects of zero size + if (data().Empty && !IsZeroSize) + data().Empty = false; } // Handle using declarations of conversion functions. Index: lib/AST/RecordLayoutBuilder.cpp =================================================================== --- lib/AST/RecordLayoutBuilder.cpp +++ lib/AST/RecordLayoutBuilder.cpp @@ -127,9 +127,10 @@ CharUnits Offset, bool PlacingEmptyBase); void UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD, - const CXXRecordDecl *Class, - CharUnits Offset); - void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset); + const CXXRecordDecl *Class, CharUnits Offset, + bool PlacingOverlappingField); + void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset, + bool PlacingOverlappingField); /// AnyEmptySubobjectsBeyondOffset - Returns whether there are any empty /// subobjects beyond the given offset. @@ -351,7 +352,7 @@ continue; CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo); - UpdateEmptyFieldSubobjects(*I, FieldOffset); + UpdateEmptyFieldSubobjects(*I, FieldOffset, PlacingEmptyBase); } } @@ -471,20 +472,25 @@ return false; // We are able to place the member variable at this offset. - // Make sure to update the empty base subobject map. - UpdateEmptyFieldSubobjects(FD, Offset); + // Make sure to update the empty field subobject map. + UpdateEmptyFieldSubobjects(FD, Offset, FD->hasAttr()); return true; } -void EmptySubobjectMap::UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD, - const CXXRecordDecl *Class, - CharUnits Offset) { +void EmptySubobjectMap::UpdateEmptyFieldSubobjects( + const CXXRecordDecl *RD, const CXXRecordDecl *Class, CharUnits Offset, + bool PlacingOverlappingField) { // We know that the only empty subobjects that can conflict with empty - // field subobjects are subobjects of empty bases that can be placed at offset - // zero. Because of this, we only need to keep track of empty field - // subobjects with offsets less than the size of the largest empty - // subobject for our class. - if (Offset >= SizeOfLargestEmptySubobject) + // field subobjects are subobjects of empty bases and potentially-overlapping + // fields that can be placed at offset zero. Because of this, we only need to + // keep track of empty field subobjects with offsets less than the size of + // the largest empty subobject for our class. + // + // (Proof: we will only consider placing a subobject at offset zero or at + // >= the current dsize. The only cases where the earlier subobject can be + // placed beyond the end of dsize is if it's an empty base or a + // potentially-overlapping field.) + if (!PlacingOverlappingField && Offset >= SizeOfLargestEmptySubobject) return; AddSubobjectAtOffset(RD, Offset); @@ -499,7 +505,8 @@ const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl(); CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl); - UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset); + UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset, + PlacingOverlappingField); } if (RD == Class) { @@ -508,7 +515,8 @@ const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl(); CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl); - UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset); + UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset, + PlacingOverlappingField); } } @@ -521,15 +529,15 @@ CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo); - UpdateEmptyFieldSubobjects(*I, FieldOffset); + UpdateEmptyFieldSubobjects(*I, FieldOffset, PlacingOverlappingField); } } -void EmptySubobjectMap::UpdateEmptyFieldSubobjects(const FieldDecl *FD, - CharUnits Offset) { +void EmptySubobjectMap::UpdateEmptyFieldSubobjects( + const FieldDecl *FD, CharUnits Offset, bool PlacingOverlappingField) { QualType T = FD->getType(); if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) { - UpdateEmptyFieldSubobjects(RD, RD, Offset); + UpdateEmptyFieldSubobjects(RD, RD, Offset, PlacingOverlappingField); return; } @@ -552,10 +560,12 @@ // offset zero. Because of this, we only need to keep track of empty field // subobjects with offsets less than the size of the largest empty // subobject for our class. - if (ElementOffset >= SizeOfLargestEmptySubobject) + if (!PlacingOverlappingField && + ElementOffset >= SizeOfLargestEmptySubobject) return; - UpdateEmptyFieldSubobjects(RD, RD, ElementOffset); + UpdateEmptyFieldSubobjects(RD, RD, ElementOffset, + PlacingOverlappingField); ElementOffset += Layout.getSize(); } } @@ -622,6 +632,10 @@ CharUnits NonVirtualSize; CharUnits NonVirtualAlignment; + /// If we've laid out a field but not included its tail padding in Size yet, + /// this is the size up to the end of that field. + CharUnits PaddedFieldSize; + /// PrimaryBase - the primary base class (if one exists) of the class /// we're laying out. const CXXRecordDecl *PrimaryBase; @@ -670,7 +684,8 @@ UnfilledBitsInLastUnit(0), LastBitfieldTypeSize(0), MaxFieldAlignment(CharUnits::Zero()), DataSize(0), NonVirtualSize(CharUnits::Zero()), - NonVirtualAlignment(CharUnits::One()), PrimaryBase(nullptr), + NonVirtualAlignment(CharUnits::One()), + PaddedFieldSize(CharUnits::Zero()), PrimaryBase(nullptr), PrimaryBaseIsVirtual(false), HasOwnVFPtr(false), HasPackedField(false), FirstNearlyEmptyVBase(nullptr) {} @@ -980,7 +995,6 @@ // Round up the current record size to pointer alignment. setSize(getSize().alignTo(BaseAlign)); - setDataSize(getSize()); // Update the alignment. UpdateAlignment(BaseAlign, UnpackedBaseAlign); @@ -1172,6 +1186,7 @@ // Query the external layout to see if it provides an offset. bool HasExternalLayout = false; if (UseExternalLayout) { + // FIXME: This appears to be reversed. if (Base->IsVirtual) HasExternalLayout = External.getExternalNVBaseOffset(Base->Class, Offset); else @@ -1342,8 +1357,8 @@ // We start laying out ivars not at the end of the superclass // structure, but at the next byte following the last field. - setSize(SL.getDataSize()); - setDataSize(getSize()); + setDataSize(SL.getDataSize()); + setSize(getDataSize()); } InitializeLayout(D); @@ -1729,32 +1744,49 @@ UnfilledBitsInLastUnit = 0; LastBitfieldTypeSize = 0; + auto *FieldClass = D->getType()->getAsCXXRecordDecl(); + bool PotentiallyOverlapping = D->hasAttr() && FieldClass; + bool IsOverlappingEmptyField = PotentiallyOverlapping && FieldClass->isEmpty(); bool FieldPacked = Packed || D->hasAttr(); - CharUnits FieldOffset = - IsUnion ? CharUnits::Zero() : getDataSize(); + + CharUnits FieldOffset = (IsUnion || IsOverlappingEmptyField) + ? CharUnits::Zero() + : getDataSize(); CharUnits FieldSize; CharUnits FieldAlign; + // The amount of this class's dsize occupied by the field. + // This is equal to FieldSize unless we're permitted to pack + // into the field's tail padding. + CharUnits EffectiveFieldSize; if (D->getType()->isIncompleteArrayType()) { // This is a flexible array member; we can't directly // query getTypeInfo about these, so we figure it out here. // Flexible array members don't have any size, but they // have to be aligned appropriately for their element type. - FieldSize = CharUnits::Zero(); + EffectiveFieldSize = FieldSize = CharUnits::Zero(); const ArrayType* ATy = Context.getAsArrayType(D->getType()); FieldAlign = Context.getTypeAlignInChars(ATy->getElementType()); } else if (const ReferenceType *RT = D->getType()->getAs()) { unsigned AS = Context.getTargetAddressSpace(RT->getPointeeType()); - FieldSize = + EffectiveFieldSize = FieldSize = Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(AS)); FieldAlign = Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(AS)); } else { std::pair FieldInfo = Context.getTypeInfoInChars(D->getType()); - FieldSize = FieldInfo.first; + EffectiveFieldSize = FieldSize = FieldInfo.first; FieldAlign = FieldInfo.second; + // A potentially-overlapping field occupies its dsize or nvsize, whichever + // is larger. + if (PotentiallyOverlapping) { + const ASTRecordLayout &Layout = Context.getASTRecordLayout(FieldClass); + EffectiveFieldSize = + std::max(Layout.getNonVirtualSize(), Layout.getDataSize()); + } + if (IsMsStruct) { // If MS bitfield layout is required, figure out what type is being // laid out and align the field to the width of that type. @@ -1834,7 +1866,12 @@ // Check if we can place the field at this offset. while (!EmptySubobjects->CanPlaceFieldAtOffset(D, FieldOffset)) { // We couldn't place the field at the offset. Try again at a new offset. - FieldOffset += FieldAlign; + // We try offset 0 (for an empty field) and then dsize(C) onwards. + if (FieldOffset == CharUnits::Zero() && + getDataSize() != CharUnits::Zero()) + FieldOffset = getDataSize().alignTo(FieldAlign); + else + FieldOffset += FieldAlign; } } } @@ -1853,18 +1890,23 @@ if (FieldSize % ASanAlignment) ExtraSizeForAsan += ASanAlignment - CharUnits::fromQuantity(FieldSize % ASanAlignment); - FieldSize += ExtraSizeForAsan; + EffectiveFieldSize = FieldSize = FieldSize + ExtraSizeForAsan; } // Reserve space for this field. - uint64_t FieldSizeInBits = Context.toBits(FieldSize); - if (IsUnion) - setDataSize(std::max(getDataSizeInBits(), FieldSizeInBits)); - else - setDataSize(FieldOffset + FieldSize); + if (!IsOverlappingEmptyField) { + uint64_t EffectiveFieldSizeInBits = Context.toBits(EffectiveFieldSize); + if (IsUnion) + setDataSize(std::max(getDataSizeInBits(), EffectiveFieldSizeInBits)); + else + setDataSize(FieldOffset + EffectiveFieldSize); - // Update the size. - setSize(std::max(getSizeInBits(), getDataSizeInBits())); + PaddedFieldSize = std::max(PaddedFieldSize, FieldOffset + FieldSize); + setSize(std::max(getSizeInBits(), getDataSizeInBits())); + } else { + setSize(std::max(getSizeInBits(), + (uint64_t)Context.toBits(FieldOffset + FieldSize))); + } // Remember max struct/class alignment. UnadjustedAlignment = std::max(UnadjustedAlignment, FieldAlign); @@ -1885,6 +1927,10 @@ setSize(CharUnits::One()); } + // If we have any remaining field tail padding, include that in the overall + // size. + setSize(std::max(getSizeInBits(), (uint64_t)Context.toBits(PaddedFieldSize))); + // Finally, round the size of the record up to the alignment of the // record itself. uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastUnit; Index: lib/CodeGen/CGExpr.cpp =================================================================== --- lib/CodeGen/CGExpr.cpp +++ lib/CodeGen/CGExpr.cpp @@ -3872,12 +3872,27 @@ return EmitLValueForField(LambdaLV, Field); } +/// Get the address of a zero-sized field within a record. The resulting +/// address doesn't necessarily have the right type. +static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base, + const FieldDecl *Field) { + CharUnits Offset = CGF.getContext().toCharUnitsFromBits( + CGF.getContext().getFieldOffset(Field)); + if (Offset.isZero()) + return Base; + Base = CGF.Builder.CreateElementBitCast(Base, CGF.Int8Ty); + return CGF.Builder.CreateConstInBoundsByteGEP(Base, Offset); +} + /// Drill down to the storage of a field without walking into /// reference types. /// /// The resulting address doesn't necessarily have the right type. static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base, const FieldDecl *field) { + if (field->isZeroSize(CGF.getContext())) + return emitAddrOfZeroSizeField(CGF, base, field); + const RecordDecl *rec = field->getParent(); unsigned idx = Index: lib/CodeGen/CGExprAgg.cpp =================================================================== --- lib/CodeGen/CGExprAgg.cpp +++ lib/CodeGen/CGExprAgg.cpp @@ -1846,15 +1846,32 @@ return LV; } +AggValueSlot::Overlap_t +CodeGenFunction::overlapForFieldInit(const FieldDecl *FD) { + if (!FD->hasAttr() || !FD->getType()->isRecordType()) + return AggValueSlot::DoesNotOverlap; + + // If the field lies entirely within the enclosing class's nvsize, its tail + // padding cannot overlap any already-initialized object. (The only subobjects + // with greater addresses that might already be initialized are vbases.) + const RecordDecl *ClassRD = FD->getParent(); + const ASTRecordLayout &Layout = getContext().getASTRecordLayout(ClassRD); + if (Layout.getFieldOffset(FD->getFieldIndex()) + + getContext().getTypeSize(FD->getType()) <= + (uint64_t)getContext().toBits(Layout.getNonVirtualSize())) + return AggValueSlot::DoesNotOverlap; + + // The tail padding may contain values we need to preserve. + return AggValueSlot::MayOverlap; +} + AggValueSlot::Overlap_t CodeGenFunction::overlapForBaseInit( const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual) { - // Virtual bases are initialized first, in address order, so there's never - // any overlap during their initialization. - // - // FIXME: Under P0840, this is no longer true: the tail padding of a vbase - // of a field could be reused by a vbase of a containing class. + // If the most-derived object is a field declared with [[no_unique_address]], + // the tail padding of any virtual base could be reused for other subobjects + // of that field's class. if (IsVirtual) - return AggValueSlot::DoesNotOverlap; + return AggValueSlot::MayOverlap; // If the base class is laid out entirely within the nvsize of the derived // class, its tail padding cannot yet be initialized, so we can issue Index: lib/CodeGen/CGExprConstant.cpp =================================================================== --- lib/CodeGen/CGExprConstant.cpp +++ lib/CodeGen/CGExprConstant.cpp @@ -675,11 +675,12 @@ ++FieldNo; // If this is a union, skip all the fields that aren't being initialized. - if (RD->isUnion() && ILE->getInitializedFieldInUnion() != Field) + if (RD->isUnion() && + !declaresSameEntity(ILE->getInitializedFieldInUnion(), Field)) continue; - // Don't emit anonymous bitfields, they just affect layout. - if (Field->isUnnamedBitfield()) + // Don't emit anonymous bitfields or zero-sized fields. + if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext())) continue; // Get the initializer. A struct can include fields without initializers, @@ -720,6 +721,10 @@ if (!AppendField(Field, Layout.getFieldOffset(FieldNo), EltInit, AllowOverwrite)) return false; + // After emitting a non-empty field with [[no_unique_address]], we may + // need to overwrite its tail padding. + if (Field->hasAttr()) + AllowOverwrite = true; } else { // Otherwise we have a bitfield. if (auto *CI = dyn_cast(EltInit)) { @@ -793,14 +798,15 @@ unsigned FieldNo = 0; uint64_t OffsetBits = CGM.getContext().toBits(Offset); + bool AllowOverwrite = false; for (RecordDecl::field_iterator Field = RD->field_begin(), FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) { // If this is a union, skip all the fields that aren't being initialized. if (RD->isUnion() && !declaresSameEntity(Val.getUnionField(), *Field)) continue; - // Don't emit anonymous bitfields, they just affect layout. - if (Field->isUnnamedBitfield()) + // Don't emit anonymous bitfields or zero-sized fields. + if (Field->isUnnamedBitfield() || Field->isZeroSize(CGM.getContext())) continue; // Emit the value of the initializer. @@ -814,12 +820,16 @@ if (!Field->isBitField()) { // Handle non-bitfield members. if (!AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, - EltInit)) + EltInit, AllowOverwrite)) return false; + // After emitting a non-empty field with [[no_unique_address]], we may + // need to overwrite its tail padding. + if (Field->hasAttr()) + AllowOverwrite = true; } else { // Otherwise we have a bitfield. if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, - cast(EltInit))) + cast(EltInit), AllowOverwrite)) return false; } } @@ -2216,7 +2226,7 @@ for (const auto *Field : record->fields()) { // Fill in non-bitfields. (Bitfields always use a zero pattern, which we // will fill in later.) - if (!Field->isBitField()) { + if (!Field->isBitField() && !Field->isZeroSize(CGM.getContext())) { unsigned fieldIndex = layout.getLLVMFieldNo(Field); elements[fieldIndex] = CGM.EmitNullConstant(Field->getType()); } Index: lib/CodeGen/CGOpenMPRuntime.cpp =================================================================== --- lib/CodeGen/CGOpenMPRuntime.cpp +++ lib/CodeGen/CGOpenMPRuntime.cpp @@ -7797,7 +7797,7 @@ for (const auto *Field : RD->fields()) { // Fill in non-bitfields. (Bitfields always use a zero pattern, which we // will fill in later.) - if (!Field->isBitField()) { + if (!Field->isBitField() && !Field->isZeroSize(CGF.getContext())) { unsigned FieldIndex = RL.getLLVMFieldNo(Field); RecordLayout[FieldIndex] = Field; } Index: lib/CodeGen/CGRecordLayoutBuilder.cpp =================================================================== --- lib/CodeGen/CGRecordLayoutBuilder.cpp +++ lib/CodeGen/CGRecordLayoutBuilder.cpp @@ -347,18 +347,21 @@ void CGRecordLowering::accumulateFields() { for (RecordDecl::field_iterator Field = D->field_begin(), FieldEnd = D->field_end(); - Field != FieldEnd;) + Field != FieldEnd;) { if (Field->isBitField()) { RecordDecl::field_iterator Start = Field; // Iterate to gather the list of bitfields. for (++Field; Field != FieldEnd && Field->isBitField(); ++Field); accumulateBitFields(Start, Field); - } else { + } else if (!Field->isZeroSize(Context)) { Members.push_back(MemberInfo( bitsToCharUnits(getFieldBitOffset(*Field)), MemberInfo::Field, getStorageType(*Field), *Field)); ++Field; + } else { + ++Field; } + } } void @@ -590,10 +593,17 @@ if (!Member->Data && Member->Kind != MemberInfo::Scissor) continue; if (Member->Offset < Tail) { - assert(Prior->Kind == MemberInfo::Field && !Prior->FD && + assert(Prior->Kind == MemberInfo::Field && "Only storage fields have tail padding!"); - Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo( - cast(Prior->Data)->getIntegerBitWidth(), 8))); + if (!Prior->FD || Prior->FD->isBitField()) + Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo( + cast(Prior->Data)->getIntegerBitWidth(), 8))); + else { + assert(Prior->FD->hasAttr() && + "should not have reused this field's tail padding"); + Prior->Data = getByteArrayType( + Context.getTypeInfoDataSizeInChars(Prior->FD->getType()).first); + } } if (Member->Data) Prior = Member; @@ -797,6 +807,10 @@ for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) { const FieldDecl *FD = *it; + // Ignore zero-sized fields. + if (FD->isZeroSize(getContext())) + continue; + // For non-bit-fields, just check that the LLVM struct offset matches the // AST offset. if (!FD->isBitField()) { @@ -810,10 +824,6 @@ if (!FD->getDeclName()) continue; - // Don't inspect zero-length bitfields. - if (FD->isZeroLengthBitField(getContext())) - continue; - const CGBitFieldInfo &Info = RL->getBitFieldInfo(FD); llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD)); Index: lib/CodeGen/CodeGenFunction.h =================================================================== --- lib/CodeGen/CodeGenFunction.h +++ lib/CodeGen/CodeGenFunction.h @@ -2318,14 +2318,7 @@ } /// Determine whether a field initialization may overlap some other object. - AggValueSlot::Overlap_t overlapForFieldInit(const FieldDecl *FD) { - // FIXME: These cases can result in overlap as a result of P0840R0's - // [[no_unique_address]] attribute. We can still infer NoOverlap in the - // presence of that attribute if the field is within the nvsize of its - // containing class, because non-virtual subobjects are initialized in - // address order. - return AggValueSlot::DoesNotOverlap; - } + AggValueSlot::Overlap_t overlapForFieldInit(const FieldDecl *FD); /// Determine whether a base class initialization may overlap some other /// object. Index: lib/Parse/ParseDeclCXX.cpp =================================================================== --- lib/Parse/ParseDeclCXX.cpp +++ lib/Parse/ParseDeclCXX.cpp @@ -3912,6 +3912,7 @@ case ParsedAttr::AT_Deprecated: case ParsedAttr::AT_FallThrough: case ParsedAttr::AT_CXX11NoReturn: + case ParsedAttr::AT_NoUniqueAddress: return true; case ParsedAttr::AT_WarnUnusedResult: return !ScopeName && AttrName->getName().equals("nodiscard"); Index: lib/Sema/SemaDeclAttr.cpp =================================================================== --- lib/Sema/SemaDeclAttr.cpp +++ lib/Sema/SemaDeclAttr.cpp @@ -6813,6 +6813,9 @@ case ParsedAttr::AT_NoSplitStack: handleSimpleAttribute(S, D, AL); break; + case ParsedAttr::AT_NoUniqueAddress: + handleSimpleAttribute(S, D, AL); + break; case ParsedAttr::AT_NonNull: if (auto *PVD = dyn_cast(D)) handleNonNullAttrParameter(S, PVD, AL); Index: test/CodeGenCXX/no-unique-address.cpp =================================================================== --- /dev/null +++ test/CodeGenCXX/no-unique-address.cpp @@ -0,0 +1,79 @@ +// RUN: %clang_cc1 -std=c++2a %s -emit-llvm -o - -triple x86_64-linux-gnu | FileCheck %s + +struct A { ~A(); int n; char c[3]; }; +struct B { [[no_unique_address]] A a; char k; }; +// CHECK-DAG: @b = global { i32, [3 x i8], i8 } { i32 1, [3 x i8] c"\02\03\04", i8 5 } +B b = {1, 2, 3, 4, 5}; + +struct C : A {}; +struct D : C {}; +struct E { int e; [[no_unique_address]] D d; char k; }; +// CHECK-DAG: @e = global { i32, i32, [3 x i8], i8 } { i32 1, i32 2, [3 x i8] c"\03\04\05", i8 6 } +E e = {1, 2, 3, 4, 5, 6}; + +struct Empty1 {}; +struct Empty2 {}; +struct Empty3 {}; +struct HasEmpty { + [[no_unique_address]] Empty1 e1; + int a; + [[no_unique_address]] Empty2 e2; + int b; + [[no_unique_address]] Empty3 e3; +}; +// CHECK-DAG: @he = global %{{[^ ]*}} { i32 1, i32 2 } +HasEmpty he = {{}, 1, {}, 2, {}}; + +struct HasEmptyDuplicates { + [[no_unique_address]] Empty1 e1; // +0 + int a; + [[no_unique_address]] Empty1 e2; // +4 + int b; + [[no_unique_address]] Empty1 e3; // +8 +}; +// CHECK-DAG: @off1 = global i64 0 +Empty1 HasEmptyDuplicates::*off1 = &HasEmptyDuplicates::e1; +// CHECK-DAG: @off2 = global i64 4 +Empty1 HasEmptyDuplicates::*off2 = &HasEmptyDuplicates::e2; +// CHECK-DAG: @off3 = global i64 8 +Empty1 HasEmptyDuplicates::*off3 = &HasEmptyDuplicates::e3; + +// CHECK-DAG: @hed = global %{{[^ ]*}} { i32 1, i32 2, [4 x i8] undef } +HasEmptyDuplicates hed = {{}, 1, {}, 2, {}}; + +struct __attribute__((packed, aligned(2))) PackedAndPadded { + ~PackedAndPadded(); + char c; + int n; +}; +struct WithPackedAndPadded { + [[no_unique_address]] PackedAndPadded pap; + char d; +}; +// CHECK-DAG: @wpap = global <{ i8, i32, i8 }> <{ i8 1, i32 2, i8 3 }> +WithPackedAndPadded wpap = {1, 2, 3}; + +struct FieldOverlap { + [[no_unique_address]] Empty1 e1, e2, e3, e4; + int n; +}; +static_assert(sizeof(FieldOverlap) == 4); +// CHECK-DAG: @fo = global %{{[^ ]*}} { i32 1234 } +FieldOverlap fo = {{}, {}, {}, {}, 1234}; + +// CHECK-DAG: @e1 = constant %[[E1:[^ ]*]]* bitcast (%[[FO:[^ ]*]]* @fo to %[[E1]]*) +Empty1 &e1 = fo.e1; +// CHECK-DAG: @e2 = constant %[[E1]]* bitcast (i8* getelementptr (i8, i8* bitcast (%[[FO]]* @fo to i8*), i64 1) to %[[E1]]*) +Empty1 &e2 = fo.e2; + +// CHECK-LABEL: accessE1 +// CHECK: %[[RET:.*]] = bitcast %[[FO]]* %{{.*}} to %[[E1]]* +// CHECK: ret %[[E1]]* %[[RET]] +Empty1 &accessE1(FieldOverlap &fo) { return fo.e1; } + +// CHECK-LABEL: accessE2 +// CHECK: %[[AS_I8:.*]] = bitcast %[[FO]]* %{{.*}} to i8* +// CHECK: %[[ADJUSTED:.*]] = getelementptr inbounds i8, i8* %[[AS_I8]], i64 1 +// CHECK: %[[RET:.*]] = bitcast i8* %[[ADJUSTED]] to %[[E1]]* +// CHECK: ret %[[E1]]* %[[RET]] +Empty1 &accessE2(FieldOverlap &fo) { return fo.e2; } Index: test/CodeGenCXX/tail-padding.cpp =================================================================== --- test/CodeGenCXX/tail-padding.cpp +++ test/CodeGenCXX/tail-padding.cpp @@ -32,3 +32,47 @@ // CHECK: store i32 {{.*}} @_ZTVN16InitWithinNVSize1CE // CHECK: store i8 } + +namespace NoUniqueAddr { + struct A { char c; A(const A&); }; + struct B { int n; char c[3]; ~B(); }; + struct C : virtual A { B b; }; + struct D : virtual A { [[no_unique_address]] B b; }; + struct E : virtual A { [[no_unique_address]] B b; char x; }; + static_assert(sizeof(C) == sizeof(void*) + 8 + alignof(void*)); + static_assert(sizeof(D) == sizeof(void*) + 8); + static_assert(sizeof(E) == sizeof(void*) + 8 + alignof(void*)); + + // CHECK: define {{.*}} @_ZN12NoUniqueAddr1CC1EOS0_ + // CHECK: call void @_ZN12NoUniqueAddr1AC2ERKS0_( + // CHECK: store i32 {{.*}} @_ZTVN12NoUniqueAddr1CE + // Copy the full size of B. + // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 8, i1 false) + C f(C c) { return c; } + + // CHECK: define {{.*}} @_ZN12NoUniqueAddr1DC1EOS0_ + // CHECK: call void @_ZN12NoUniqueAddr1AC2ERKS0_( + // CHECK: store i32 {{.*}} @_ZTVN12NoUniqueAddr1DE + // Copy just the data size of B, to avoid overwriting the A base class. + // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 7, i1 false) + D f(D d) { return d; } + + // CHECK: define {{.*}} @_ZN12NoUniqueAddr1EC1EOS0_ + // CHECK: call void @_ZN12NoUniqueAddr1AC2ERKS0_( + // CHECK: store i32 {{.*}} @_ZTVN12NoUniqueAddr1EE + // We can copy the full size of B here. (As it happens, we fold the copy of 'x' into + // this memcpy, so we're copying 8 bytes either way.) + // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 8, i1 false) + E f(E e) { return e; } + + struct F : virtual A { + F(const F &o) : A(o), b(o.b) {} + [[no_unique_address]] B b; + }; + + // CHECK: define {{.*}} @_ZN12NoUniqueAddr1FC1ERKS0_ + // CHECK: call void @_ZN12NoUniqueAddr1AC2ERKS0_( + // CHECK: store i32 {{.*}} @_ZTVN12NoUniqueAddr1FE + // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 7, i1 false) + F f(F x) { return x; } +} Index: test/Layout/no-unique-address.cpp =================================================================== --- /dev/null +++ test/Layout/no-unique-address.cpp @@ -0,0 +1,265 @@ +// RUN: %clang_cc1 -std=c++2a -fsyntax-only -triple x86_64-linux-gnu -fdump-record-layouts %s | FileCheck %s + +namespace Empty { + struct A {}; + struct B { [[no_unique_address]] A a; char b; }; + static_assert(sizeof(B) == 1); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::B + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: 0 | char b + // CHECK-NEXT: | [sizeof=1, dsize=1, align=1, + // CHECK-NEXT: | nvsize=1, nvalign=1] + + struct C {}; + struct D { + [[no_unique_address]] A a; + [[no_unique_address]] C c; + char d; + }; + static_assert(sizeof(D) == 1); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::D + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: 0 | struct Empty::C c (empty) + // CHECK-NEXT: 0 | char d + // CHECK-NEXT: | [sizeof=1, dsize=1, align=1, + // CHECK-NEXT: | nvsize=1, nvalign=1] + + struct E { + [[no_unique_address]] A a1; + [[no_unique_address]] A a2; + char e; + }; + static_assert(sizeof(E) == 2); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::E + // CHECK-NEXT: 0 | struct Empty::A a1 (empty) + // CHECK-NEXT: 1 | struct Empty::A a2 (empty) + // CHECK-NEXT: 0 | char e + // CHECK-NEXT: | [sizeof=2, dsize=2, align=1, + // CHECK-NEXT: | nvsize=2, nvalign=1] + + struct F { + ~F(); + [[no_unique_address]] A a1; + [[no_unique_address]] A a2; + char f; + }; + static_assert(sizeof(F) == 2); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::F + // CHECK-NEXT: 0 | struct Empty::A a1 (empty) + // CHECK-NEXT: 1 | struct Empty::A a2 (empty) + // CHECK-NEXT: 0 | char f + // CHECK-NEXT: | [sizeof=2, dsize=1, align=1, + // CHECK-NEXT: | nvsize=2, nvalign=1] + + struct G { [[no_unique_address]] A a; ~G(); }; + static_assert(sizeof(G) == 1); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::G + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: | [sizeof=1, dsize=0, align=1, + // CHECK-NEXT: | nvsize=1, nvalign=1] + + struct H { [[no_unique_address]] A a, b; ~H(); }; + static_assert(sizeof(H) == 2); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::H + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: 1 | struct Empty::A b (empty) + // CHECK-NEXT: | [sizeof=2, dsize=0, align=1, + // CHECK-NEXT: | nvsize=2, nvalign=1] + + struct OversizedEmpty : A { + ~OversizedEmpty(); + [[no_unique_address]] A a; + }; + static_assert(sizeof(OversizedEmpty) == 2); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::OversizedEmpty + // CHECK-NEXT: 0 | struct Empty::A (base) (empty) + // CHECK-NEXT: 1 | struct Empty::A a (empty) + // CHECK-NEXT: | [sizeof=2, dsize=0, align=1, + // CHECK-NEXT: | nvsize=2, nvalign=1] + + struct HasOversizedEmpty { + [[no_unique_address]] OversizedEmpty m; + }; + static_assert(sizeof(HasOversizedEmpty) == 2); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::HasOversizedEmpty + // CHECK-NEXT: 0 | struct Empty::OversizedEmpty m (empty) + // CHECK-NEXT: 0 | struct Empty::A (base) (empty) + // CHECK-NEXT: 1 | struct Empty::A a (empty) + // CHECK-NEXT: | [sizeof=2, dsize=0, align=1, + // CHECK-NEXT: | nvsize=2, nvalign=1] + + struct EmptyWithNonzeroDSize { + [[no_unique_address]] A a; + int x; + [[no_unique_address]] A b; + int y; + [[no_unique_address]] A c; + }; + static_assert(sizeof(EmptyWithNonzeroDSize) == 12); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::EmptyWithNonzeroDSize + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: 0 | int x + // CHECK-NEXT: 4 | struct Empty::A b (empty) + // CHECK-NEXT: 4 | int y + // CHECK-NEXT: 8 | struct Empty::A c (empty) + // CHECK-NEXT: | [sizeof=12, dsize=12, align=4, + // CHECK-NEXT: | nvsize=12, nvalign=4] + + struct EmptyWithNonzeroDSizeNonPOD { + ~EmptyWithNonzeroDSizeNonPOD(); + [[no_unique_address]] A a; + int x; + [[no_unique_address]] A b; + int y; + [[no_unique_address]] A c; + }; + static_assert(sizeof(EmptyWithNonzeroDSizeNonPOD) == 12); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct Empty::EmptyWithNonzeroDSizeNonPOD + // CHECK-NEXT: 0 | struct Empty::A a (empty) + // CHECK-NEXT: 0 | int x + // CHECK-NEXT: 4 | struct Empty::A b (empty) + // CHECK-NEXT: 4 | int y + // CHECK-NEXT: 8 | struct Empty::A c (empty) + // CHECK-NEXT: | [sizeof=12, dsize=8, align=4, + // CHECK-NEXT: | nvsize=9, nvalign=4] +} + +namespace POD { + // Cannot reuse tail padding of a PDO type. + struct A { int n; char c[3]; }; + struct B { [[no_unique_address]] A a; char d; }; + static_assert(sizeof(B) == 12); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct POD::B + // CHECK-NEXT: 0 | struct POD::A a + // CHECK-NEXT: 0 | int n + // CHECK-NEXT: 4 | char [3] c + // CHECK-NEXT: 8 | char d + // CHECK-NEXT: | [sizeof=12, dsize=12, align=4, + // CHECK-NEXT: | nvsize=12, nvalign=4] +} + +namespace NonPOD { + struct A { int n; char c[3]; ~A(); }; + struct B { [[no_unique_address]] A a; char d; }; + static_assert(sizeof(B) == 8); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct NonPOD::B + // CHECK-NEXT: 0 | struct NonPOD::A a + // CHECK-NEXT: 0 | int n + // CHECK-NEXT: 4 | char [3] c + // CHECK-NEXT: 7 | char d + // CHECK-NEXT: | [sizeof=8, dsize=8, align=4, + // CHECK-NEXT: | nvsize=8, nvalign=4] +} + +namespace NVSizeGreaterThanDSize { + // The nvsize of an object includes the complete size of its empty subobjects + // (although it's unclear why). Ensure this corner case is handled properly. + struct alignas(8) A { ~A(); }; // dsize 0, nvsize 0, size 8 + struct B : A { char c; }; // dsize 1, nvsize 8, size 8 + static_assert(sizeof(B) == 8); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct NVSizeGreaterThanDSize::B + // CHECK-NEXT: 0 | struct NVSizeGreaterThanDSize::A (base) (empty) + // CHECK-NEXT: 0 | char c + // CHECK-NEXT: | [sizeof=8, dsize=1, align=8, + // CHECK-NEXT: | nvsize=8, nvalign=8] + + struct V { int n; }; + + // V is at offset 16, not offset 12, because B's tail padding is strangely not + // usable for virtual bases. + struct C : B, virtual V {}; + static_assert(sizeof(C) == 24); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct NVSizeGreaterThanDSize::C + // CHECK-NEXT: 0 | (C vtable pointer) + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::B (base) + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::A (base) (empty) + // CHECK-NEXT: 8 | char c + // CHECK-NEXT: 16 | struct NVSizeGreaterThanDSize::V (virtual base) + // CHECK-NEXT: 16 | int n + // CHECK-NEXT: | [sizeof=24, dsize=20, align=8, + // CHECK-NEXT: | nvsize=16, nvalign=8] + + struct D : virtual V { + [[no_unique_address]] B b; + }; + static_assert(sizeof(D) == 24); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct NVSizeGreaterThanDSize::D + // CHECK-NEXT: 0 | (D vtable pointer) + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::B b + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::A (base) (empty) + // CHECK-NEXT: 8 | char c + // CHECK-NEXT: 16 | struct NVSizeGreaterThanDSize::V (virtual base) + // CHECK-NEXT: 16 | int n + // CHECK-NEXT: | [sizeof=24, dsize=20, align=8, + // CHECK-NEXT: | nvsize=16, nvalign=8] + + struct X : virtual A { [[no_unique_address]] A a; }; + struct E : virtual A { + [[no_unique_address]] A a; + // Here, we arrange for X to hang over the end of the nvsize of E. This + // should force the A vbase to be laid out at offset 24, not 16. + [[no_unique_address]] X x; + }; + static_assert(sizeof(E) == 32); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct NVSizeGreaterThanDSize::E + // CHECK-NEXT: 0 | (E vtable pointer) + // CHECK-NEXT: 0 | struct NVSizeGreaterThanDSize::A a (empty) + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::X x + // CHECK-NEXT: 8 | (X vtable pointer) + // CHECK-NEXT: 8 | struct NVSizeGreaterThanDSize::A a (empty) + // CHECK-NEXT: 16 | struct NVSizeGreaterThanDSize::A (virtual base) (empty) + // CHECK-NEXT: 24 | struct NVSizeGreaterThanDSize::A (virtual base) (empty) + // CHECK-NEXT: | [sizeof=32, dsize=16, align=8, + // CHECK-NEXT: | nvsize=16, nvalign=8] +} + +namespace RepeatedVBase { + struct alignas(16) A { ~A(); }; + struct B : A {}; + struct X : virtual A, virtual B {}; + struct Y { [[no_unique_address]] X x; char c; }; + static_assert(sizeof(Y) == 32); + + // CHECK:*** Dumping AST Record Layout + // CHECK: 0 | struct RepeatedVBase::Y + // CHECK-NEXT: 0 | struct RepeatedVBase::X x + // CHECK-NEXT: 0 | (X vtable pointer) + // CHECK-NEXT: 0 | struct RepeatedVBase::A (virtual base) (empty) + // CHECK-NEXT: 16 | struct RepeatedVBase::B (virtual base) (empty) + // CHECK-NEXT: 16 | struct RepeatedVBase::A (base) (empty) + // CHECK-NEXT: 8 | char c + // CHECK-NEXT: | [sizeof=32, dsize=9, align=16, + // CHECK-NEXT: | nvsize=9, nvalign=16] +} Index: test/SemaCXX/cxx2a-no-unique-address.cpp =================================================================== --- /dev/null +++ test/SemaCXX/cxx2a-no-unique-address.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -std=c++2a %s -verify -triple x86_64-linux-gnu +// RUN: %clang_cc1 -std=c++2a %s -verify=unsupported -triple x86_64-windows + +[[no_unique_address]] int a; // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} +[[no_unique_address]] void f(); // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} +struct [[no_unique_address]] S { // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} + [[no_unique_address]] int a; // unsupported-warning {{unknown}} + [[no_unique_address]] void f(); // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} + [[no_unique_address]] static int sa;// expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} + [[no_unique_address]] static void sf(); // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} + [[no_unique_address]] int b : 3; // expected-error {{only applies to non-bit-field non-static data members}} unsupported-warning {{unknown}} + + [[no_unique_address, no_unique_address]] int duplicated; // expected-error {{cannot appear multiple times}} + // unsupported-error@-1 {{cannot appear multiple times}} unsupported-warning@-1 2{{unknown}} + [[no_unique_address]] [[no_unique_address]] int duplicated2; // unsupported-warning 2{{unknown}} + [[no_unique_address()]] int arglist; // expected-error {{cannot have an argument list}} unsupported-warning {{unknown}} + + int [[no_unique_address]] c; // expected-error {{cannot be applied to types}} unsupported-error {{cannot be applied to types}} +}; Index: utils/TableGen/ClangAttrEmitter.cpp =================================================================== --- utils/TableGen/ClangAttrEmitter.cpp +++ utils/TableGen/ClangAttrEmitter.cpp @@ -2810,7 +2810,7 @@ // Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test' // parameter with only a single check type, if applicable. -static void GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test, +static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test, std::string *FnName, StringRef ListName, StringRef CheckAgainst, @@ -2830,7 +2830,9 @@ *FnName += Part; } Test += ")"; + return true; } + return false; } // Generate a conditional expression to check if the current target satisfies @@ -2838,10 +2840,12 @@ // those checks to the Test string. If the FnName string pointer is non-null, // append a unique suffix to distinguish this set of target checks from other // TargetSpecificAttr records. -static void GenerateTargetSpecificAttrChecks(const Record *R, +static bool GenerateTargetSpecificAttrChecks(const Record *R, std::vector &Arches, std::string &Test, std::string *FnName) { + bool AnyTargetChecks = false; + // It is assumed that there will be an llvm::Triple object // named "T" and a TargetInfo object named "Target" within // scope that can be used to determine whether the attribute exists in @@ -2851,6 +2855,7 @@ // differently because GenerateTargetRequirements needs to combine the list // with ParseKind. if (!Arches.empty()) { + AnyTargetChecks = true; Test += " && ("; for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) { StringRef Part = *I; @@ -2865,16 +2870,19 @@ } // If the attribute is specific to particular OSes, check those. - GenerateTargetSpecificAttrCheck(R, Test, FnName, "OSes", "T.getOS()", - "llvm::Triple::"); + AnyTargetChecks |= GenerateTargetSpecificAttrCheck( + R, Test, FnName, "OSes", "T.getOS()", "llvm::Triple::"); // If one or more CXX ABIs are specified, check those as well. GenerateTargetSpecificAttrCheck(R, Test, FnName, "CXXABIs", "Target.getCXXABI().getKind()", "TargetCXXABI::"); // If one or more object formats is specified, check those. - GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats", - "T.getObjectFormat()", "llvm::Triple::"); + AnyTargetChecks |= + GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats", + "T.getObjectFormat()", "llvm::Triple::"); + + return AnyTargetChecks; } static void GenerateHasAttrSpellingStringSwitch( @@ -3510,7 +3518,7 @@ std::string FnName = "isTarget"; std::string Test; - GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName); + bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName); // If this code has already been generated, simply return the previous // instance of it. @@ -3520,7 +3528,8 @@ return *I; OS << "static bool " << FnName << "(const TargetInfo &Target) {\n"; - OS << " const llvm::Triple &T = Target.getTriple();\n"; + if (UsesT) + OS << " const llvm::Triple &T = Target.getTriple();\n"; OS << " return " << Test << ";\n"; OS << "}\n\n"; Index: www/cwg_index.html =================================================================== --- /dev/null +++ www/cwg_index.html @@ -0,0 +1,21640 @@ + + + +C++ Standard Core Language Issue Index by Section + + +
+

+ C++ Standard Core Language Issue Index by Section, Revision + 101

+

+ This document contains a summary listing of all the C++ Core Language + issues arranged in the order of the sections of the Standard with + which they deal most directly. + It 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: +

+
    +
  • Active Issues List, which contains + explanatory material for the entire document group and a list of + the issues that have not yet been acted upon by the Committee. +
    • +
  • Defect Reports List, which contains + the issues that have been categorized by the Committee as Defect + Reports, as well as other issues that have been accepted by the + Committee, along with their proposed resolutions. +
    • +
  • 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. +
    • +
  • Table of Contents, which contains a + summary listing of all issues in numerical order. +
    • +
  • Index by Status, which contains a + summary listing of all issues grouped by status. +
    • +
+

+ For more information, including a description of the meaning of + the issue status codes and instructions on reporting new issues, + please see the Active Issues List. +

+

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



+
+

+ Index by Section +

+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SectionIssueStatusTitle
_N2691_.E131TC1 +Typo in Lao characters +
_N2691_.E248C++11 +Identifier characters +
_N2691_.E663CD1 +Valid Cyrillic identifier characters +
_N2914_.14.10.1.1889concepts +Default implementations of associated functions +
_N2914_.14.10.2780concepts +Questions regarding the point of definition of a concept map +
_N2914_.14.10.2911concepts +late_check and concept map templates +
_N2914_.14.10.2.1870concepts +Context of expression when satisfying an associated function requirement +
_N2914_.14.10.2.1871concepts +Satisfying associated functions with built-in operators +
_N2914_.14.10.2.1916open +Does a reference type have a destructor? +
_N2914_.14.10.2.1918concepts +Declaration/expression ambiguity in associated function expressions +
_N2914_.14.10.2.2907concepts +Default types in requirements in auto concepts +
_N2914_.14.10.3.2841concepts +Ill-formed concept refinement example +
_N2914_.14.10.4825concepts +TriviallyCopyableType concept +
_N2914_.14.11848concepts +Unconstrained template template parameters in constrained contexts +
_N2914_.14.11.1826concepts +Accept boolean constant expressions as constraints +
_N2914_.14.11.1827concepts +Use of && as requirement separator +
_N2914_.14.11.1.1890concepts +Missing requirement in example +
_N2914_.14.11.1.2857concepts +Implying requirements from enclosing scopes +
_N2914_.14.11.2781concepts +Missing requirement in constrained function example +
_N2914_.14.11.2.1748concepts +Always-complete archetypes +
_N2914_.14.11.2.1895concepts +Missing destructor requirements +
_N2914_.14.11.4894concepts +Incorrect example for constrained overload resolution +
_N2960_.3.3.9856concepts +Overlapping concept and requirements scopes +
_N2960_.6.9859concepts +Incomplete comment in late_check example +
_N3225_.7.6.4816CD2 +Diagnosing violations of [[final]] +
_N3225_.7.6.4817CD2 +Meaning of [[final]] applied to a class definition +
_N3225_.7.6.51063C++11 +[[hiding]] with non-attribute declarations +
_N3225_.7.6.51065C++11 +[[hiding]] with [[override]] +
_N3225_.7.6.51067NAD +[[hiding]], using-declarations, and multiple inheritance +
_N3225_.7.6.51133C++11 +Keywords vs attributes for control of hiding and overriding +
_N3225_.11.31144C++11 +Remove access declarations +
_N3225_.D.2167NAD +Deprecating static functions +
_N3225_.D.2174NAD +Undeprecating global static +
_N4140_.2.4789CD2 +Deprecating trigraphs +
_N4140_.17.6.4.3.21882CD4 +Reserved names without library use +
_N4527_.12.91150NAD +Inheriting constructors have not been implemented +
_N4527_.12.91350CD3 +Incorrect exception specification for inherited constructors +
_N4527_.12.91487CD3 +When are inheriting constructors declared? +
_N4527_.12.91567C++14 +Inheriting constructors and copy/move constructors +
_N4527_.12.91573CD4 +Inherited constructor characteristics +
_N4527_.12.91645CD4 +Identical inheriting constructors via default arguments +
_N4527_.12.91715CD4 +Access and inherited constructor templates +
_N4527_.12.91736CD4 +Inheriting constructor templates in a local class +
_N4527_.12.91738C++14 +Explicit instantiation/specialization of inheriting constructor templates +
_N4527_.12.91941CD4 +SFINAE and inherited constructor default arguments +
_N4527_.12.91959CD4 +Inadvertently inherited copy constructor +
_N4527_.12.91991CD4 +Inheriting constructors vs default arguments +
_N4567_.5.1.1122CD1 +template-ids as unqualified-ids +
_N4567_.5.1.1123TC1 +Bad cross-reference +
_N4567_.5.1.1125CD1 +Ambiguity in friend declaration syntax +
_N4567_.5.1.1147TC1 +Naming the constructor +
_N4567_.5.1.1536drafting +Problems in the description of id-expressions +
_N4567_.5.1.1687extension +template keyword with unqualified-ids +
_N4567_.5.1.1743CD2 +Use of decltype in a nested-name-specifier +
_N4567_.5.1.1760CD2 +this inside a nested class of a non-static member function +
_N4567_.5.1.1850CD2 +Restrictions on use of non-static data members +
_N4567_.5.1.1945C++11 +Use of this in a late-specified return type +
_N4567_.5.1.11440CD3 +Acceptable decltype-specifiers used as nested-name-specifiers +
_N4567_.5.1.11836DRWP +Use of class type being defined in trailing-return-type +
_N4567_.5.1.11837drafting +Use of this in friend and local class declarations +
_N4567_.5.1.11929CD4 +template keyword following namespace nested-name-specifier +
_N4567_.5.1.12134NAD +Objectless references to non-static member functions +
_N4606_.15.5.2596NAD +Replacing an exception object +
_N4750_.15.86open +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? +
_N4750_.15.820TC1 +Some clarifications needed for 12.8 para 15 +
_N4750_.15.826NAD +Copy constructors and default arguments +
_N4750_.15.8111NAD +Copy constructors and cv-qualifiers +
_N4750_.15.8185TC1 +"Named" temporaries and copy elision +
_N4750_.15.8356NAD +Wording of behavior of generated copy constructor for scalar members +
_N4750_.15.8444NAD +Overriding and the generated copy assignment operator +
_N4750_.15.8535CD3 +Copy construction without a copy constructor +
_N4750_.15.8574NAD +Definition of “copy assignment operator” +
_N4750_.15.8653CD2 +Copy assignment of unions +
_N4750_.15.8667CD2 +Trivial special member functions that cannot be implicitly defined +
_N4750_.15.8680CD2 +What is a move constructor? +
_N4750_.15.8683CD1 +Requirements for trivial subobject special functions +
_N4750_.15.8733NAD +Reference qualification of copy assignment operators +
_N4750_.15.8887CD2 +Move construction of thrown object +
_N4750_.15.8910CD2 +Move constructors and implicitly-declared copy constructors +
_N4750_.15.8992NAD +Inheriting explicitness +
_N4750_.15.81020C++11 +Implicitly-defined copy constructors and explicit base class constructors +
_N4750_.15.81049open +Copy elision through reference parameters of inline functions +
_N4750_.15.81051C++11 +Reference members and generated copy constructors +
_N4750_.15.81052dup +const non-static data member and PODness +
_N4750_.15.81064C++11 +Defaulted move constructor for a union +
_N4750_.15.81066C++11 +When is a copy/move assignment operator implicitly defined? +
_N4750_.15.81080C++11 +Confusing relationship between templates and copy constructors +
_N4750_.15.81082C++11 +Implicit copy function if subobject has none? +
_N4750_.15.81084NAD +Conditions for a deleted move function +
_N4750_.15.81085NAD +Move assignment operators and virtual bases +
_N4750_.15.81092drafting +Cycles in overload resolution during instantiation +
_N4750_.15.81148C++11 +Copy elision and move construction of function parameters +
_N4750_.15.81149C++11 +Trivial non-public copy operators in subobjects +
_N4750_.15.81224C++11 +constexpr defaulted copy constructors +
_N4750_.15.81331extension +const mismatch with defaulted copy constructor +
_N4750_.15.81344C++14 +Adding new special member functions to a class via default arguments +
_N4750_.15.81402CD3 +Move functions too often deleted +
_N4750_.15.81491CD3 +Move construction and rvalue reference members +
_N4750_.15.81493C++14 +Criteria for move-construction +
_N4750_.15.81499drafting +Missing case for deleted move assignment operator +
_N4750_.15.81548drafting +Copy/move construction and conversion functions +
_N4750_.15.81579C++14 +Return by converting move constructor +
_N4750_.15.81590CD4 +Bypassing non-copy/move constructor copying +
_N4750_.15.81593C++14 +“Parameter type” of special member functions +
_N4750_.15.81594drafting +Lazy declaration of special members vs overload errors +
_N4750_.15.81731NAD +is_trivially_X and definitions of special member functions +
_N4750_.15.81734CD4 +Nontrivial deleted copy functions +
_N4750_.15.81806CD4 +Virtual bases and move-assignment +
_N4750_.15.81831NAD +Explicitly vs implicitly deleted move constructors +
_N4750_.15.81916CD4 +“Same cv-unqualified type” +
_N4750_.15.81928NAD +Triviality of deleted special member functions +
_N4750_.15.81967CD4 +Temporary lifetime and move-elision +
_N4750_.15.82094C++17 +Trivial copy/move constructor for class with volatile member +
_N4750_.15.82125extension +Copy elision and comma operator +
_N4750_.15.82132extension +Deprecated default generated copy constructors +
_N4750_.15.82171CD4 +Triviality of copy constructor with less-qualified parameter +
_N4750_.15.82180CD4 +Virtual bases in destructors and defaulted assignment operators +
_N4750_.15.82197review +Overload resolution and deleted special member functions +
_N4750_.15.82203drafting +Defaulted copy/move constructors and UDCs +
_N4750_.15.82264drafting +Memberwise copying with indeterminate value +
_N4750_.15.82315DRWP +What is the “corresponding special member” of a variant member? +
_N4750_.C.1.31251CD3 +C compatibility: casting to unqualified void* +
_N4750_.C.3.52114CD3 +Missing description of incompatibility from aggregate NSDMIs +
3357CD1 +Definition of signature should include name +
3449NAD +Consistency in use of hyphen with names of "non" entities +
3537CD1 +Definition of “signature” +
3616CD3 +Definition of “indeterminate value” +
3690CD2 +The dynamic type of an rvalue reference +
3783open +Definition of “argument” +
31476CD3 +Definition of user-defined type +
31509C++14 +Definition of “non-template function” +
31531CD3 +Definition of “access” (verb) +
3.232124CD4 +Signature of constructor template +
4.1949open +Requirements for freestanding implementations +
4.11938DR +Should hosted/freestanding be implementation-defined? +
4.2784C++11 +List of incompatibilities with the previous Standard +
5.2362CD1 +Order of initialization in instantiation units +
5.2578open +Phase 1 replacement of characters with universal-character-names +
5.2787CD2 +Unnecessary lexical undefined behavior +
5.21103C++11 +Reversion of phase 1 and 2 transformations in raw string literals +
5.21698open +Files ending in \ +
5.21775C++14 +Undefined behavior of line splice in raw string literal +
5.21999CD4 +Representation of source characters as universal-character-names +
5.3173TC1 +Constraints on execution character set +
5.3558CD1 +Excluded characters in universal character names +
5.3630CD2 +Equality of narrow and wide character values in the basic character set +
5.3788CD2 +Relationship between locale and values of the execution character set +
5.31332drafting +Handling of invalid universal-character-names +
5.31796CD4 +Is all-bits-zero for null characters a meaningful requirement? +
5.4369drafting +Are new/delete identifiers or preprocessing-op-or-punc? +
5.41655drafting +Line endings in raw string literals +
5.42000CD4 +header-name outside #include directive +
5.5985C++11 +Alternative tokens and user-defined literals +
5.51104C++11 +Global-scope template arguments vs the <: digraph +
5.61901drafting +punctuator referenced but not defined +
5.71403open +Universal-character-names in comments +
5.9832CD2 +Value of preprocessing numbers +
5.101105C++11 +Issues relating to TR 10176:2003 +
5.101963CD4 +Implementation-defined identifier characters +
5.101972open +Identifier character restrictions in non-identifiers +
5.12189drafting +Definition of operator and punctuator +
5.131924review +Definition of “literal” and kinds of literals +
5.13.21717C++14 +Missing specification of type of binary literal +
5.13.21947NAD +Digit separators following non-octal prefix +
5.13.3505CD1 +Conditionally-supported behavior for unknown character escapes +
5.13.3912CD3 +Character literals and universal-character-names +
5.13.3933CD2 +32-bit UCNs with 16-bit wchar_t +
5.13.31024CD3 +Limits on multicharacter literals +
5.13.31422dup +Type of character literals containing universal-character-names +
5.13.31656drafting +Encoding of numerically-escaped characters +
5.13.32333drafting +Escape sequences in UTF-8 character literals +
5.13.32402drafting +When is the restriction to a single c-char in a Unicode literal enforced? +
5.13.5411open +Use of universal-character-name in character versus string literals +
5.13.5790CD2 +Concatenation of raw and non-raw string literals +
5.13.5834CD2 +What is an “ordinary string literal”? +
5.13.5872CD2 +Lexical issues with raw strings +
5.13.5932CD2 +UCNs in closing delimiters of raw string literals +
5.13.51759C++14 +UTF-8 code units in plain char +
5.13.51802CD4 +char16_t string literals and surrogate pairs +
5.13.51859NAD +UTF-16 in char16_t string literals +
5.13.71106C++11 +Need more detail in nullptr keyword description +
5.13.8931CD2 +Confusing reference to the length of a user-defined string literal +
5.13.8937NAD +Restrictions on values of template arguments in user-defined literals +
5.13.81107C++11 +Overload resolution for user-defined integer literals +
5.13.81108NAD +User-defined literals have not been implemented +
5.13.81175C++11 +Disambiguating user-defined literals +
5.13.81239C++11 +Hexadecimal floating-point literals vs user-defined literals +
5.13.81266open +user-defined-integer-literal overflow +
5.13.81474NAD +User-defined literals and <inttypes.h> format macros +
5.13.81723drafting +Multicharacter user-defined character literals +
5.13.81735drafting +Out-of-range literals in user-defined-literals +
5.13.81810CD4 +Invalid ud-suffixes +
5.13.81871extension +Non-identifier characters in ud-suffix +
5.13.82152NAD +Can an alternative token be used as a ud-suffix? +
6309CD1 +Linkage of entities whose names are not simply identifiers, in introduction +
6485CD1 +What is a “name”? +
6633CD2 +Specifications for variables that should also apply to references +
6719CD2 +Specifications for operator-function-id that should also apply to literal-operator-id +
6942CD2 +Is this an entity? +
61529drafting +Nomenclature for variable vs reference non-static data member +
6.1676C++11 +static_assert-declarations and general requirements for declarations +
6.1758C++11 +Missing cases of declarations that are not definitions +
6.11201C++11 +Are deleted and defaulted functions definitions? +
6.11870CD4 +Contradictory wording about definitions vs explicit specialization/instantiation +
6.12371open +Use of the English term “attributes” is confusing +
6.250NAD +Converting pointer to incomplete type to same type +
6.282dup +Definition of "using" a constant expression +
6.2261CD1 +When is a deallocation function "used?" +
6.2289CD1 +Incomplete list of contexts requiring a complete type +
6.2570CD2 +Are references subject to the ODR? +
6.2678C++11 +Language linkage of member function parameter types and the ODR +
6.2712CD3 +Are integer constant operands of a conditional-expression “used?” +
6.21109C++11 +When is “use” a reference to the ODR meaning? +
6.21110NAD +Incomplete return type should be allowed in decltype operand +
6.21174C++11 +When is a pure virtual function “used?” +
6.21192C++11 +Inadvertent change to ODR and templates +
6.21209open +Is a potentially-evaluated expression in a template definition a “use?” +
6.21254NAD +odr-use vs template arguments and constexpr functions +
6.21260CD3 +Incorrect use of term “overloaded” in description of odr-use +
6.21362CD3 +Complete type required for implicit conversion to T& +
6.21472CD3 +odr-use of reference variables +
6.21511CD3 +const volatile variables and the one-definition rule +
6.21581DRWP +When are constexpr member functions defined? +
6.21614CD4 +Address of pure virtual function vs odr-use +
6.21741C++14 +odr-use of class object in lvalue-to-rvalue conversion +
6.21849drafting +Variable templates and the ODR +
6.21897drafting +ODR vs alternative tokens +
6.21926CD4 +Potential results of subscript operator +
6.22020DR +Inadequate description of odr-use of implicitly-invoked functions +
6.22083DR +Incorrect cases of odr-use +
6.22085CD4 +Invalid example of adding special member function via default argument +
6.22103DR +Lvalue-to-rvalue conversion is irrelevant in odr-use of a reference +
6.22104CD4 +Internal-linkage constexpr references and ODR requirements +
6.22170DR +Unclear definition of odr-use for arrays +
6.22240NAD +this is not odr-used in a constant expression +
6.22242drafting +ODR violation with constant initialization possibly omitted +
6.22300drafting +Lambdas in multiple definitions +
6.22353DR +Potential results of a member access expression for a static data member +
6.22367open +Lambdas in default arguments vs the ODR +
6.22380DR +capture-default makes too many references odr-usable +
6.3481CD2 +Scope of template parameters +
6.3554drafting +Definition of “declarative region” and “scope” +
6.3.12063CD4 +Type/nontype hiding in class scope +
6.3.12165drafting +Namespaces, declarative regions, and translation units +
6.3.12289DR +Uniqueness of structured binding names +
6.3.2433CD1 +Do elaborated type specifiers in templates inject into enclosing namespace scope? +
6.3.21044C++11 +Point of declaration for an alias-declaration +
6.3.21210C++11 +Injection of elaborated-type-specifier in enumeration scope +
6.3.21433extension +trailing-return-type and point of declaration +
6.3.21482CD3 +Point of declaration of enumeration +
6.3.3642CD2 +Definition and use of “block scope” and “local scope” +
6.3.742NAD +Redefining names from base classes +
6.3.7432CD1 +Is injected class name visible in base class specifier list? +
6.3.71352CD3 +Inconsistent class scope and completeness rules +
6.3.71875CD4 +Reordering declarations in class scope +
6.3.72009open +Unclear specification of class scope +
6.3.72331DR +Redundancy in description of class scope +
6.3.91429NAD +Scope of a member template's template parameter +
6.3.102164DRWP +Name hiding and using-directives +
6.4555drafting +Pseudo-destructor name lookup +
6.42218C++17 +Ambiguity and namespace aliases +
6.4.141TC1 +Clarification of lookup of names after declarator-id +
6.4.1139CD1 +Error in friend lookup example +
6.4.1191open +Name lookup does not handle complex nesting +
6.4.1192drafting +Name lookup in parameters +
6.4.1231NAD +Visibility of names after using-directives +
6.4.1405open +Unqualified function name lookup +
6.4.1490CD2 +Name lookup in friend declarations +
6.4.1514CD1 +Is the initializer for a namespace member in the scope of the namespace? +
6.4.11200open +Lookup rules for template parameters +
6.4.11906NAD +Name lookup in member friend declaration +
6.4.12357NAD +Lookup in member function declarations +
6.4.12370drafting +friend declarations of namespace-scope functions +
6.4.212dup +Default arguments on different declarations for the same function and the Koenig lookup +
6.4.233TC1 +Argument dependent lookup and overloaded functions +
6.4.290TC1 +Should the enclosing class be an "associated class" too? +
6.4.291NAD +A union's associated types should include the union itself +
6.4.2143CD1 +Friends and Koenig lookup +
6.4.2164TC1 +Overlap between Koenig and normal lookup +
6.4.2218CD1 +Specification of Koenig lookup +
6.4.2225NAD +Koenig lookup and fundamental types +
6.4.2321dup +Associated classes and namespaces for argument-dependent lookup +
6.4.2384NAD +Argument-dependent lookup and operator functions +
6.4.2403CD1 +Reference to a type as a template-id +
6.4.2557CD1 +Does argument-dependent lookup cause template instantiation? +
6.4.2598CD2 +Associated namespaces of overloaded functions and function templates +
6.4.2705CD2 +Suppressing argument-dependent lookup via parentheses +
6.4.2997C++11 +Argument-dependent lookup and dependent function template parameter types +
6.4.21015C++11 +Template arguments and argument-dependent lookup +
6.4.21690C++14 +Associated namespace for local type +
6.4.21691C++14 +Argument-dependent lookup and opaque enumerations +
6.4.21692C++14 +Associated namespaces of doubly-nested classes +
6.4.22136NAD +Argument-dependent lookup and initializer lists +
6.4.22142NAD +Missing definition of associated classes and namespaces +
6.4.3724concepts +Qualified name lookup in a constrained context +
6.4.31753CD4 +decltype-specifier in nested-name-specifier of destructor +
6.4.31771open +Restricted lookup in nested-name-specifier +
6.4.31828drafting +nested-name-specifier ambiguity +
6.4.3.1298CD1 +T::x when T is cv-qualified +
6.4.3.1318CD1 +struct A::A should not name the constructor of A +
6.4.3.1562open +qualified-ids in non-expression contexts +
6.4.3.1635NAD +Names of constructors and destructors of templates +
6.4.3.11000CD2 +Mistaking member typedefs for constructors +
6.4.3.11310CD3 +What is an “acceptable lookup result?” +
6.4.3.12070drafting +using-declaration with dependent nested-name-specifier +
6.4.3.2400CD1 +Using-declarations and the "struct hack" +
6.4.3.2861CD2 +Unintended ambiguity in inline namespace lookup +
6.4.485TC1 +Redeclaration of member class +
6.4.4245CD1 +Name lookup in elaborated-type-specifiers +
6.4.4254CD1 +Definitional problems with elaborated-type-specifiers +
6.4.5141CD1 +Non-member function templates in member access expressions +
6.4.5156drafting +Name lookup for conversion functions +
6.4.5305CD1 +Name lookup in destructor call +
6.4.5381CD1 +Incorrect example of base class member lookup +
6.4.5414CD1 +Multiple types found on destructor lookup +
6.4.5682drafting +Missing description of lookup of template aliases +
6.4.51089drafting +Template parameters in member selections +
6.4.51111C++11 +Remove dual-scope lookup of member template names +
6.4.51220C++11 +Looking up conversion-type-ids +
6.4.51291drafting +Looking up a conversion-type-id +
6.4.51835drafting +Dependent member lookup before < +
6.4.51908drafting +Dual destructor lookup and template-ids +
6.4.6373C++11 +Lookup on namespace qualified name in using-directive +
6.5132NAD +Local types and linkage +
6.5216CD1 +Linkage of nameless class-scope enumeration types +
6.5278open +External linkage and nameless entities +
6.5279open +Correspondence of "names for linkage purposes" +
6.5319CD1 +Use of names without linkage in declaring entities with linkage +
6.5338open +Enumerator name with linkage used as class name in other translation unit +
6.5389CD1 +Unnamed types in entities with linkage +
6.5426C++17 +Identically-named variables, one internally and one externally linked, allowed? +
6.5474CD1 +Block-scope extern declarations in namespace members +
6.5527CD2 +Problems with linkage of types +
6.5571CD2 +References declared const +
6.5757CD2 +Types without linkage in declarations +
6.5791concepts +Linkage of concept names +
6.5966CD2 +Nested types without linkage +
6.51112C++11 +constexpr variables should have internal linkage like const +
6.51113C++11 +Linkage of namespace member of unnamed namespace +
6.51415CD3 +Missing prohibition of block-scope definition of extern object +
6.51603CD4 +Errors resulting from giving unnamed namespaces internal linkage +
6.51686CD4 +Which variables are “explicitly declared const?” +
6.51839drafting +Lookup of block-scope extern declarations +
6.51884drafting +Unclear requirements for same-named external-linkage entities +
6.52058drafting +More errors from internal-linkage namespaces +
6.52198C++17 +Linkage of enumerators +
6.52230NAD +Linkage of extern "C" function in unnamed namespace +
6.52372DR +Incorrect matching rules for block-scope extern declarations +
6.52387DR +Linkage of const-qualified variable template +
6.6.11953open +Data races and common initial sequence +
6.6.2513CD1 +Non-class “most-derived” objects +
6.6.21189C++11 +Address of distinct base class subobjects +
6.6.22151CD4 +Exception object is not created +
6.6.22324drafting +Size of base class subobject +
6.6.22325drafting +std::launder and reuse of character buffers +
6.6.22334open +Creation of objects by typeid +
6.6.389TC1 +Object lifetime does not account for reference rebinding +
6.6.393TC1 +Missing word in 3.8 basic.life paragraph 2 +
6.6.3119CD1 +Object lifetime and aggregate initialization +
6.6.3234NAD +Reuse of base class subobjects +
6.6.3274CD1 +Cv-qualification and char-alias access to out-of-lifetime objects +
6.6.3404CD1 +Unclear reference to construction with non-trivial constructor +
6.6.3419open +Can cast to virtual base class be done on partially-constructed object? +
6.6.3594CD1 +Coordinating issues 119 and 404 with delegating constructors +
6.6.3597CD3 +Conversions applied to out-of-lifetime non-POD lvalues +
6.6.3793CD2 +Use of class members during destruction +
6.6.31027drafting +Type consistency and reallocation of scalar types +
6.6.31050NAD +Effects of thread support on object lifetime +
6.6.31114C++11 +Incorrect use of placement new in example +
6.6.31116CD4 +Aliasing of union members +
6.6.31280NAD +Object reallocation and reference members +
6.6.31284CD4 +Should the lifetime of an array be independent of that of its elements? +
6.6.31285open +Trivial destructors and object lifetime +
6.6.31530drafting +Member access in out-of-lifetime objects +
6.6.31751CD4 +Non-trivial operations vs non-trivial initialization +
6.6.31776CD4 +Replacement of class objects containing reference members +
6.6.31853drafting +Defining “allocated storage” +
6.6.32256DR +Lifetime of trivially-destructible objects +
6.6.32258open +Storage deallocation during period of destruction +
6.6.4365open +Storage duration and temporaries +
6.6.41634drafting +Temporary storage duration +
6.6.42012CD4 +Lifetime of references +
6.6.4.31956CD4 +Reuse of storage of automatic variables +
6.6.4.4967NAD +Exception specification of replacement allocation function +
6.6.4.41948NAD +exception-specification of replacement global new +
6.6.4.4.1521CD1 +Requirements for exceptions thrown by allocation functions +
6.6.4.4.11338CD4 +Aliasing and allocation functions +
6.6.4.4.11676drafting +auto return type for allocation and deallocation functions +
6.6.4.4.11682open +Overly-restrictive rules on function templates as allocation functions +
6.6.4.4.11910DRWP +“Shall” requirement applied to runtime behavior +
6.6.4.4.12073drafting +Allocating memory for exception objects +
6.6.4.4.12207drafting +Alignment of allocation function return value +
6.6.4.4.12238NAD +Contradictory alignment requirements for allocation +
6.6.4.4.2220CD1 +All deallocation functions should be required not to throw +
6.6.4.4.2312CD3 +“use” of invalid pointer value not defined +
6.6.4.4.2348CD1 +delete and user-written deallocation functions +
6.6.4.4.2523open +Can a one-past-the-end pointer be invalidated by deleting an adjacent object? +
6.6.4.4.2623CD3 +Use of pointers to deallocated storage +
6.6.4.4.22042drafting +Exceptions and deallocation functions +
6.6.4.4.3735CD2 +Missing case in specification of safely-derived pointers +
6.6.4.4.3853CD2 +Support for relaxed pointer safety +
6.6.4.4.31190C++11 +Operations on non-safely-derived pointers +
6.6.4.4.31438CD3 +Non-dereference use of invalid pointers +
6.6.4.4.31575C++14 +Incorrect definition of “strict pointer safety” +
6.6.4.52019CD4 +Member references omitted from description of storage duration +
6.6.5649CD1 +Optionally ill-formed extended alignment requests +
6.6.51090C++11 +Alignment of subobjects +
6.6.51115C++11 +C-compatible alignment specification +
6.6.51180C++11 +Over-aligned class types +
6.6.51211drafting +Misaligned lvalues +
6.6.51879NAD +Inadequate definition of alignment requirement +
6.6.52354DR +Extended alignment and object representation +
6.6.686CD1 +Lifetime of temporaries in query expressions +
6.6.6117NAD +Timing of destruction of temporaries +
6.6.6124CD1 +Lifetime of temporaries in default initialization of class arrays +
6.6.6199CD1 +Order of destruction of temporaries +
6.6.6201CD1 +Order of destruction of temporaries in initializers +
6.6.6320CD1 +Question on copy constructor elision example +
6.6.6392CD1 +Use of full expression lvalue before temporary destruction +
6.6.6443CD1 +Wording nit in description of lifetime of temporaries +
6.6.6462CD3 +Lifetime of temporaries bound to comma expressions +
6.6.6464CD1 +Wording nit on lifetime of temporaries to which references are bound +
6.6.6650CD2 +Order of destruction for temporaries bound to the returned value of a function +
6.6.6900extension +Lifetime of temporaries in range-based for +
6.6.61237C++11 +Deprecated implicit copy assignment in example +
6.6.61299DRWP +“Temporary objects” vs “temporary expressions” +
6.6.61568dup +Temporary lifetime extension with intervening cast +
6.6.61651NAD +Lifetime extension of temporary via reference to subobject +
6.6.61695NAD +Lifetime extension via init-capture +
6.6.61696CD4 +Temporary lifetime and non-static data member initializers +
6.6.61697CD4 +Lifetime extension and copy elision +
6.6.62107CD4 +Lifetime of temporaries for default arguments in array copying +
6.6.62257DR +Lifetime extension of references vs exceptions +
6.743TC1 +Copying base classes (PODs) using memcpy +
6.7290NAD +Should memcpy be allowed into a POD with a const member? +
6.7350open +signed char underlying representation for objects +
6.7496CD3 +Is a volatile-qualified type really a POD? +
6.7619C++11 +Completeness of array types +
6.7644CD1 +Should a trivial class type be a literal type? +
6.7646NAD +Can a class with a constexpr copy constructor be a literal type? +
6.7883CD2 +std::memcpy vs std::memmove +
6.7981C++11 +Constexpr constructor templates and literal types +
6.71071C++11 +Literal class types and trivial default constructors +
6.71181C++11 +What is a “built-in type?” +
6.71198C++11 +Literal types and copy constructors +
6.71219C++11 +Non-static data member initializers in constant expressions +
6.71334NAD +Layout compatibility and cv-qualification +
6.71361CD3 +Requirement on brace-or-equal-initializers of literal types +
6.71405CD3 +constexpr and mutable members of literal types +
6.71453CD3 +Volatile members in literal classes? +
6.71654dup +Literal types and constexpr defaulted constructors +
6.71701drafting +Array vs sequence in object representation +
6.71746C++14 +Are volatile scalar types trivially copyable? +
6.71951CD4 +Cv-qualification and literal types +
6.72096CD4 +Constraints on literal unions +
6.72323WP +Expunge POD +
6.7.1146open +Floating-point zero +
6.7.1251open +How many signed integer types are there? +
6.7.1483CD3 +Normative requirements on integral ranges +
6.7.1627NAD +Values behaving as types +
6.7.1689open +Maximum values of signed and unsigned integers +
6.7.11055C++11 +Permissible uses of void +
6.7.11276NAD +Reference to stdint.h +
6.7.11302CD3 +noexcept applied to expression of type void +
6.7.11448NAD +Integral values of type bool +
6.7.11515CD3 +Modulo 2n arithmetic for implicitly-unsigned types +
6.7.11539CD3 +Definition of “character type” +
6.7.11797CD4 +Are all bit patterns of unsigned char distinct numbers? +
6.7.12185open +Cv-qualified numeric types +
6.7.12214C++17 +Missing requirement on representation of integer values +
6.7.22006CD4 +Cv-qualified void types +
6.7.22287DRWP +Pointer-interconvertibility in non-standard-layout unions +
6.7.31059CD3 +Cv-qualified array types (with rvalues) +
6.7.31428CD3 +Dynamic const objects +
6.7.32201C++17 +Cv-qualification of array types +
6.8.1129CD3 +Stability of uninitialized auto variables +
6.8.1612CD2 +Requirements on a conforming implementation +
6.8.1637CD1 +Sequencing rules and example disagree +
6.8.1639CD1 +What makes side effects “different” from one another? +
6.8.1698open +The definition of “sequenced before” is too narrow +
6.8.1785CD2 +“Execution sequence” is inappropriate phraseology +
6.8.11102C++11 +Better example of undefined behavior +
6.8.11173C++11 +Unclear specification of effects of signal handling +
6.8.11343C++17Sequencing of non-class initialization +
6.8.11441C++14 +Unclear wording for signal handler restrictions +
6.8.11583C++14 +Incorrect example of unspecified behavior +
6.8.11949CD4 +“sequenced after” instead of “sequenced before” +
6.8.12146CD4 +Scalar object vs memory location in definition of “unsequenced” +
6.8.2726CD2 +Atomic and non-atomic objects in the memory model +
6.8.2740CD2 +Incorrect note on data races +
6.8.2786CD2 +Definition of “thread” +
6.8.21040NAD +Memory model issues +
6.8.21176C++11 +Definition of release sequence +
6.8.21177C++11 +Intra-thread dependency-ordered-before +
6.8.21466C++14 +Visible sequences of side effects are redundant +
6.8.21470NAD +Thread migration +
6.8.21661NAD +Preservation of infinite loops +
6.8.21842concurrency +Unevaluated operands and “carries a dependency” +
6.8.21961C++17 +Potentially-concurrent actions within a signal handler +
6.8.22046C++17 +Incomplete thread specifications +
6.8.2.12297open +Unclear specification of atomic operations +
6.8.2.12298concurrency +Actions and expression evaluation +
6.8.32026CD4 +Zero-initialization and constexpr +
6.8.3.1792CD2 +Effects of std::quick_exit +
6.8.3.1882CD2 +Defining main as deleted +
6.8.3.11003CD3 +Acceptable definitions of main +
6.8.3.11669C++14 +auto return type for main +
6.8.3.11886CD4 +Language linkage for main() +
6.8.3.2269NAD +Order of initialization of multiply-defined static data members +of class templates +
6.8.3.2270CD1 +Order of initialization of static data members of class templates +
6.8.3.2371open +Interleaving of constructor calls +
6.8.3.2441CD1 +Ordering of static reference initialization +
6.8.3.2465NAD +May constructors of global objects call exit()? +
6.8.3.2688CD1 +Constexpr constructors and static initialization +
6.8.3.21187C++11 +Problems in initialization example +
6.8.3.21294drafting +Side effects in dynamic/static initialization +
6.8.3.21489CD3 +Is value-initialization of an array constant initialization? +
6.8.3.21659open +Initialization order of thread_local template static data members +
6.8.3.21677C++17 +Constant initialization via aggregate initialization +
6.8.3.21744CD4 +Unordered initialization for variable template specializations +
6.8.3.21747C++14 +Constant initialization of reference to function +
6.8.3.21749NAD +Confusing definition for constant initializer +
6.8.3.21834CD4 +Constant initialization binding a reference to an xvalue +
6.8.3.21986drafting +odr-use and delayed initialization +
6.8.3.22148drafting +Thread storage duration and order of initialization +
6.8.3.22366drafting +Can default initialization be constant initialization? +
6.8.3.328CD1 +'exit', 'signal' and static object destruction +
6.8.3.3640open +Accessing destroyed local objects of static storage duration +
6.8.3.3776CD2 +Delegating constructors, destructors, and std::exit +
6.8.3.3946CD2 +Order of destruction of local static objects and calls to std::atexit +
771NAD +Incorrect cross reference +
7222CD1 +Sequence points and lvalue-returning operators +
7238CD4 +Precision and accuracy constraints on floating point +
7351CD1 +Sequence point error: unspecified or undefined? +
7438CD2 +Possible flaw in wording for multiple accesses to object between sequence points +
7451CD1 +Expressions with invalid results and ill-formedness +
7695CD2 +Compile-time calculation errors in constexpr functions +
7835CD2 +Scoped enumerations and the “usual arithmetic conversions” +
7858CD2 +Example binding an rvalue reference to an lvalue +
71117C++11 +Incorrect note about xvalue member access expressions +
71261CD3 +Explicit handling of cv-qualification with non-class prvalues +
71383CD3 +Clarifying discarded-value expressions +
71576C++14 +Discarded-value volatile xvalues +
71642open +Missing requirements for prvalue operands +
72206C++17 +Composite type of object and function pointers +
7.2.1158CD1 +Aliasing and qualification conversions +
7.2.1584NAD +Unions and aliasing +
7.2.1636CD4 +Dynamic type of objects and aliasing +
7.2.1846CD2 +Rvalue references to functions +
7.2.1964C++11 +Incorrect description of when the lvalue-to-rvalue conversion applies +
7.2.11026NAD +Cv-qualified non-class rvalues +
7.2.11076DRWP +Value categories and lvalue temporaries +
7.2.11534dup +cv-qualification of prvalue of type “array of class” +
7.2.11998NAD +Additional sources of xvalue expressions +
7.2.12051DR +Simplifying alias rules +
7.2.12122CD4 +Glvalues of void type +
7.2.22381DR +Composite pointer type of pointers to plain and noexcept member functions +
7.3572C++11 +Standard conversions for non-built-in types +
7.31981CD4 +Implicit contextual conversions and explicit +
7.3.1240CD3 +Uninitialized values and undefined behavior +
7.3.1617drafting +Lvalue-to-rvalue conversions of uninitialized char objects +
7.3.11013CD3 +Uninitialized std::nullptr_t objects +
7.3.11773C++14 +Out-of-lifetime lvalue-to-rvalue conversion +
7.3.11787C++14 +Uninitialized unsigned char values +
7.3.12140CD4 +Lvalue-to-rvalue conversion of std::nullptr_t +
7.3.2693CD2 +New string types and deprecated conversion +
7.3.5330CD4 +Qualification conversions and pointers to arrays of pointers +
7.3.6303NAD +Integral promotions on bit-fields +
7.3.6685CD2 +Integral promotion of enumeration ignores fixed underlying type +
7.3.61601C++14 +Promotion of enumeration with fixed underlying type +
7.3.81816CD4 +Unclear specification of bit-field values +
7.3.10566NAD +Conversion of negative floating point values to integer type +
7.3.10707CD2 +Undefined behavior in integral-to-floating conversions +
7.3.102139NAD +Floating-point requirements for integer representation +
7.3.11149TC1 +Accessibility and ambiguity +
7.3.11456NAD +Is initialized const int or const bool variable a null pointer constant? +
7.3.11519CD1 +Null pointer preservation in void* conversions +
7.3.11654CD1 +Conversions to and from nullptr_t +
7.3.11917concepts +Pointer conversions between archetypes +
7.3.112310DR +Type completeness and derived-to-base pointer conversions +
7.3.12170drafting +Pointer-to-member conversions +
7.3.12480CD1 +Is a base of a virtual base also virtual? +
7.3.12794extension +Base-derived conversion in member type of pointer-to-member conversion +
7.3.131423CD3 +Convertibility of nullptr to bool +
7.3.132133DRWP +Converting std::nullptr_t to bool +
7.5.4.12249DRWP +identifiers and id-expressions +
7.5.4.22385DR +Lookup for conversion-function-ids +
7.5.4.22396open +Lookup of names in complex conversion-type-ids +
7.5.5720CD2 +Need examples of lambda-expressions +
7.5.5750CD2 +Implementation constraints on reference-only closure objects +
7.5.5751CD2 +Deriving from closure classes +
7.5.5752CD2 +Name lookup in nested lambda-expressions +
7.5.5753CD2 +Array names in lambda capture sets +
7.5.5754CD2 +Lambda expressions in default arguments of block-scope function declarations +
7.5.5755CD3 +Generalized lambda-captures +
7.5.5756CD2 +Dropping cv-qualification on members of closure objects +
7.5.5759CD2 +Destruction of closure objects +
7.5.5761CD2 +Inferred return type of closure object call operator +
7.5.5762CD2 +Name lookup in the compound-statement of a lambda expression +
7.5.5763CD2 +Is a closure object's operator() inline? +
7.5.5764CD2 +Capturing unused variables in a lambda expression +
7.5.5766CD2 +Where may lambda expressions appear? +
7.5.5767CD2 +void and other unnamed lambda-parameters +
7.5.5768CD2 +Ellipsis in a lambda parameter list +
7.5.5769CD2 +Initialization of closure objects +
7.5.5771CD2 +Move-construction of reference members of closure objects +
7.5.5772CD2 +capture-default in lambdas in local default arguments +
7.5.5774CD2 +Can a closure class be a POD? +
7.5.5775CD2 +Capturing references to functions +
7.5.5779CD2 +Rvalue reference members of closure objects? +
7.5.5782CD2 +Lambda expressions and argument-dependent lookup +
7.5.5795NAD +Dependency of lambdas on <functional> +
7.5.5796CD2 +Lifetime of a closure object with members captured by reference +
7.5.5797CD2 +Converting a no-capture lambda to a function type +
7.5.5904CD2 +Parameter packs in lambda-captures +
7.5.5955CD2 +Can a closure type's operator() be virtual? +
7.5.5958NAD +Lambdas and decltype +
7.5.5974CD3 +Default arguments for lambdas +
7.5.5975CD3 +Restrictions on return type deduction for lambdas +
7.5.51034C++11 +Attributes for return statements in lambdas +
7.5.51048CD3 +auto deduction and lambda return type deduction. +
7.5.51062C++11 +Syntax of attribute-specifiers in lambdas +
7.5.51118NAD +Implicit lambda capture via explicit copy constructor +
7.5.51249drafting +Cv-qualification of nested lambda capture +
7.5.51468drafting +typeid, overload resolution, and implicit lambda capture +
7.5.51557CD3 +Language linkage of converted lambda function pointer +
7.5.51607C++14 +Lambdas in template parameters +
7.5.51612C++14 +Implicit lambda capture and anonymous unions +
7.5.51613C++14 +Constant expressions and lambda capture +
7.5.51629C++14 +Can a closure class be a literal type? +
7.5.51632DRWP +Lambda capture in member initializers +
7.5.51662C++14 +Capturing function parameter packs +
7.5.51663NAD +Capturing an empty pack expansion +
7.5.51664C++14 +Argument-dependent lookup of lambdas used in default arguments +
7.5.51681C++14 +init-captures and nested lambdas +
7.5.51722CD4 +Should lambda to function pointer conversion function be noexcept? +
7.5.51743NAD +init-captures in nested lambdas +
7.5.51760C++14 +Access of member corresponding to init-capture +
7.5.51772C++14 +__func__ in a lambda body +
7.5.51780CD4 +Explicit instantiation/specialization of generic lambda operator() +
7.5.51822open +Lookup of parameter names in lambda-expressions +
7.5.51891CD4 +Move constructor/assignment for closure class +
7.5.51913DRWP +decltype((x)) in lambda-expressions +
7.5.51927dup +Lifetime of temporaries in init-captures +
7.5.51931extension +Default-constructible and copy-assignable closure types +
7.5.51937DR +Incomplete specification of function pointer from lambda +
7.5.51942CD4 +Incorrect reference to trailing-return-type +
7.5.51973drafting +Which parameter-declaration-clause in a lambda-expression? +
7.5.52011C++17 +Unclear effect of reference capture of reference +
7.5.52086drafting +Reference odr-use vs implicit capture +
7.5.52095CD4 +Capturing rvalue references to functions by copy +
7.5.52097extension +Lambdas and noreturn attribute +
7.5.52121drafting +More flexible lambda syntax +
7.5.52159NAD +Lambda capture and local thread_local variables +
7.5.52162CD3 +Capturing this by reference +
7.5.52211C++17 +Hiding by lambda captures and parameters +
7.5.52247C++17 +Lambda capture and variable argument list +
7.5.5.22358DR +Explicit capture of value +
7.5.5.22378drafting +Inconsistent grammar for reference init-capture of pack +
7.6.1863CD2 +Rvalue reference cast to incomplete type +
7.6.1.1798C++11 +Overloaded subscript operator described in clause 5 +
7.6.1.11213CD3 +Array subscripting and xvalues +
7.6.1.2113CD1 +Visibility of called function +
7.6.1.2118CD1 +Calls via pointers to virtual member functions +
7.6.1.2506CD1 +Conditionally-supported behavior for non-POD objects passed to ellipsis +
7.6.1.2634CD1 +Conditionally-supported behavior for non-POD objects passed to ellipsis redux +
7.6.1.2722CD2 +Can nullptr be passed to an ellipsis? +
7.6.1.21083C++11 +Passing an object to ellipsis with non-trivial move constructor +
7.6.1.21516CD3 +Definition of “virtual function call” +
7.6.1.21555extension +Language linkage and function type compatibility +
7.6.1.21646drafting +decltype-specifiers, abstract classes, and deduction failure +
7.6.1.21880drafting +When are parameter objects destroyed? +
7.6.1.21885CD4 +Return value of a function is underspecified +
7.6.1.22029dup +Abstract class return type in decltype operand +
7.6.1.22176CD4 +Destroying the returned object when a destructor throws +
7.6.1.22215review +Redundant description of language linkage in function call +
7.6.1.22241DRWP +Overload resolution is not invoked with a single function +
7.6.1.22284open +Sequencing of braced-init-list arguments +
7.6.1.22347drafting +Passing short scoped enumerations to ellipsis +
7.6.1.3914extension +Value-initialization of array types +
7.6.1.3943DRWP +Is T() a temporary? +
7.6.1.31300dup +T() for array types +
7.6.1.31521drafting +T{expr} with reference types +
7.6.1.31525NAD +Array bound inference in temporary array +
7.6.1.31893DRWP +Function-style cast with braced-init-lists and empty pack expansions +
7.6.1.32283drafting +Missing complete type requirements +
7.6.1.32351DRWP +void{} +
7.6.1.4466CD1 +cv-qualifiers on pseudo-destructor type +
7.6.1.41920CD4 +Qualification mismatch in pseudo-destructor-name +
7.6.1.42393NAD +Pseudo-destructors and object lifetime +
7.6.1.552TC1 +Non-static members, member selection and access checking +
7.6.1.5421CD1 +Is rvalue.field an rvalue? +
7.6.1.5731CD2 +Omitted reference qualification of member function type +
7.6.1.51119C++11 +Missing case in description of member access ambiguity +
7.6.1.51585NAD +Value category of member access of rvalue reference member +
7.6.1.52231NAD +Class member access to static data member template +
7.6.1.6742open +Postfix increment/decrement with long bit-field operands +
7.6.1.7665CD2 +Problems in the specification of dynamic_cast +
7.6.1.71269CD3 +dynamic_cast of an xvalue operand +
7.6.1.71965drafting +Explicit casts to reference types +
7.6.1.72365DR +Confusing specification for dynamic_cast +
7.6.1.8282open +Namespace for extended_type_info +
7.6.1.8492CD1 +typeid constness inconsistent with example +
7.6.1.8528open +Why are incomplete class types not allowed with typeid? +
7.6.1.81416CD3 +Function cv-qualifiers and typeid +
7.6.1.81954open +typeid null dereference check in subexpressions +
7.6.1.953TC1 +Lvalue-to-rvalue conversion before certain static_casts +
7.6.1.954CD1 +Static_cast from private base to derived class +
7.6.1.9128TC1 +Casting between enum types +
7.6.1.9137TC1 +static_cast of cv void* +
7.6.1.9294NAD +Can static_cast drop exception specifications? +
7.6.1.9427CD1 +static_cast ambiguity: conversion versus cast to derived +
7.6.1.9439CD1 +Guarantees on casting pointer back to cv-qualified version of original type +
7.6.1.9671CD1 +Explicit conversion from a scoped enumeration type to integral type +
7.6.1.9833CD2 +Explicit conversion of a scoped enumeration value to a floating type +
7.6.1.91011C++11 +Standard conversions that cannot be inverted +
7.6.1.91094C++11 +Converting floating-point values to scoped enumeration types +
7.6.1.91320CD3 +Converting scoped enumerations to bool +
7.6.1.91376C++14 +static_cast of temporary to rvalue reference +
7.6.1.91412CD3 +Problems in specifying pointer conversions +
7.6.1.91447CD3 +static_cast of bit-field lvalue to rvalue reference +
7.6.1.91739C++14 +Conversion of floating point to enumeration +
7.6.1.91832CD4 +Casting to incomplete enumeration +
7.6.1.92048open +C-style casts that cast away constness vs static_cast +
7.6.1.92224C++17 +Member subobjects and base-class casts +
7.6.1.92243drafting +Incorrect use of implicit conversion sequence +
7.6.1.92338DRWP +Undefined behavior converting to short enums with fixed underlying types +
7.6.1.10195CD1 +Converting between function and object pointers +
7.6.1.10463CD1 +reinterpret_cast<T*>(0) +
7.6.1.10573C++11 +Conversions between function pointers and void* +
7.6.1.10658CD2 +Defining reinterpret_cast for pointer types +
7.6.1.10734CD2 +Are unique addresses required for namespace-scope variables? +
7.6.1.10799CD2 +Can reinterpret_cast be used to cast an operand to its own type? +
7.6.1.10800NAD +Safely-derived pointers and object pointers converted from function pointers +
7.6.1.10842CD2 +Casting to rvalue reference type +
7.6.1.10944extension +reinterpret_cast for all types with the same size and alignment +
7.6.1.101120C++11 +reinterpret_cast and void* +
7.6.1.101268CD3 +reinterpret_cast of an xvalue operand +
7.6.1.102225NAD +reinterpret_cast to same floating-point type +
7.6.1.102342DRWP +Reference reinterpret_cast and pointer-interconvertibility +
7.6.1.11801CD2 +Casting away constness in a cast to rvalue reference type +
7.6.1.11891CD2 +const_cast to rvalue reference from objectless rvalue +
7.6.1.111086C++11 +const_cast to rvalue reference to function type +
7.6.2342CD3 +Terminology: "indirection" versus "dereference" +
7.6.2.1203NAD +Type of address-of-member expression +
7.6.2.1232drafting +Is indirection through a null pointer undefined behavior? +
7.6.2.1324CD1 +Can "&" be applied to assignment to bit-field? +
7.6.2.1610NAD +Computing the negative of 0U +
7.6.2.1802concepts +Problems with restrictions on taking the address of a member of a concept map +
7.6.2.1983CD2 +Ambiguous pointer-to-member constant +
7.6.2.11121C++11 +Unnecessary ambiguity error in formation of pointer to member +
7.6.2.11230open +Confusing description of ambiguity of destructor name +
7.6.2.11458CD3 +Address of incomplete type vs operator&() +
7.6.2.11800CD4 +Pointer to member of nested anonymous union +
7.6.2.11923extension +Lvalues of type void +
7.6.2.11971CD4 +Unclear disambiguation of destructor and operator~ +
7.6.2.21653CD4 +Removing deprecated increment of bool +
7.6.2.3803CD2 +sizeof an enumeration type with a fixed underlying type +
7.6.2.3839dup +sizeof with opaque enumerations +
7.6.2.31122C++11 +Circular definition of std::size_t +
7.6.2.31553CD3 +sizeof and xvalue bit-fields +
7.6.2.31606NAD +sizeof closure class +
7.6.2.31678NAD +Naming the type of an array of runtime bound +
7.6.2.431NAD +Looking up new/delete +
7.6.2.474TC1 +Enumeration value in direct-new-declarator +
7.6.2.4127TC1 +Ambiguity in description of matching deallocation function +
7.6.2.4130NAD +Sequence points and new-expressions +
7.6.2.4256CD1 +Overflow in size calculations +
7.6.2.4267open +Alignment requirement for new-expressions +
7.6.2.4292CD3 +Deallocation on exception in new before arguments evaluated +
7.6.2.4299CD1 +Conversion on array bound expression in new +
7.6.2.4313dup +Class with single conversion function to integral as array size in new +
7.6.2.4429CD1 +Matching deallocation function chosen based on syntax or signature? +
7.6.2.4473open +Block-scope declarations of allocator functions +
7.6.2.4476extension +Determining the buffer size for placement new +
7.6.2.4624CD1 +Overflow in calculating size of allocation +
7.6.2.4672CD2 +Sequencing of initialization in new-expressions +
7.6.2.4804CD2 +Deducing the type in new auto(x) +
7.6.2.4805CD2 +Which exception to throw for overflow in array size calculation +
7.6.2.4901drafting +Deleted operator delete +
7.6.2.41061C++11 +Negative array bounds in a new-expression +
7.6.2.41464CD3 +Negative array bound in a new-expression +
7.6.2.41469extension +Omitted bound in array new-expression +
7.6.2.41559CD3 +String too long in initializer list of new-expression +
7.6.2.41566NAD +Should new std::initializer_list<T> be ill-formed? +
7.6.2.41628open +Deallocation function templates +
7.6.2.41748CD4 +Placement new with a null pointer +
7.6.2.41786C++14 +Effect of merging allocations on memory leakage +
7.6.2.41851CD4 +decltype(auto) in new-expressions +
7.6.2.41935drafting +Reuse of placement arguments in deallocation +
7.6.2.41992CD4 +new (std::nothrow) int[N] can throw +
7.6.2.42102drafting +Constructor checking in new-expression +
7.6.2.42112drafting +new auto{x} +
7.6.2.42130CD4 +Over-aligned types in new-expressions +
7.6.2.42141CD4 +Ambiguity in new-expression with elaborated-type-specifier +
7.6.2.42177DRWP +Placement operator delete and parameter copies +
7.6.2.42280review +Matching a usual deallocation function with placement new +
7.6.2.42281drafting +Consistency of aligned operator delete replacement +
7.6.2.42282drafting +Consistency with mismatched aligned/non-over-aligned allocation/deallocation functions +
7.6.2.42382review +Array allocation overhead for non-allocating placement new +
7.6.2.5196open +Arguments to deallocation functions
7.6.2.5265dup +Destructors, exceptions, and deallocation +
7.6.2.5288CD1 +Misuse of "static type" in describing pointers +
7.6.2.5353CD1 +Is deallocation routine called if destructor throws exception in delete? +
7.6.2.5442CD1 +Incorrect use of null pointer constant in description of delete operator +
7.6.2.5599CD2 +Deleting a null function pointer +
7.6.2.51037C++11 +Requirements for operands of delete-expressions and deallocation functions +
7.6.2.51259NAD +Deleting a POD via a pointer to base +
7.6.2.51788CD4 +Sized deallocation of array of non-class type +
7.6.2.52239NAD +Sized deallocation with a trivial destructor +
7.6.2.52248C++17 +Problems with sized delete +
7.6.2.6659CD1 +Alignment of function types +
7.6.2.6930CD2 +alignof with incomplete array type +
7.6.2.61008extension +Querying the alignment of an object +
7.6.2.61305CD3 +alignof applied to array of unknown size +
7.6.2.71123C++11 +Destructors should be noexcept by default +
7.6.2.71354CD3 +Destructor exceptions for temporaries in noexcept expressions +
7.6.2.71465CD4 +noexcept and std::bad_array_new_length +
7.6.2.71685NAD +Value category of noexcept expression +
7.6.3242CD4 +Interpretation of old-style casts +
7.6.3520CD1 +Old-style casts between incomplete class types +
7.6.3909NAD +Old-style casts with conversion functions +
7.6.4497CD1 +Missing required initialization in example +
7.6.41091C++11 +Inconsistent use of the term “object expression” +
7.6.41124NAD +Error in description of value category of pointer-to-member expression +
7.6.41340CD3 +Complete type in member pointer expressions +
7.6.5614CD1 +Results of integer / and % +
7.6.51450CD3 +INT_MIN % -1 +
7.6.655NAD +Adding/subtracting pointer and enumeration value +
7.6.6179TC1 +Function pointers and subtraction +
7.6.6567NAD +Can size_t and ptrdiff_t be larger than long? +
7.6.61314NAD +Pointer arithmetic within standard-layout objects +
7.6.61504CD3 +Pointer arithmetic after derived-base conversion +
7.6.61865CD4 +Pointer arithmetic and multi-level qualification conversions +
7.6.62013drafting +Pointer subtraction in large array +
7.6.62182drafting +Pointer arithmetic in array-like containers +
7.6.7854CD2 +Left shift and unsigned extended types +
7.6.71457CD3 +Undefined behavior in left-shift +
7.6.71857drafting +Additional questions about bits +
7.6.72087NAD +Left shift of negative value by zero bits +
7.6.9583CD3 +Relational pointer comparisons against the null pointer constant +
7.6.9622NAD +Relational comparisons of arbitrary pointers +
7.6.9661CD1 +Semantics of arithmetic comparisons +
7.6.9963CD2 +Comparing nullptr with 0 +
7.6.91512CD3 +Pointer comparison vs qualification conversions +
7.6.91596CD4 +Non-array objects as array[1] +
7.6.1073TC1 +Pointer equality +
7.6.101400NAD +Function pointer equality +
7.6.101598C++14 +Criterion for equality of pointers to members +
7.6.101652CD4 +Object addresses in constexpr expressions +
7.6.101858CD4 +Comparing pointers to union members +
7.6.102302NAD +Address comparison between different member subobjects +
7.6.16446CD1 +Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary? +
7.6.16587CD2 +Lvalue operands of a conditional expression differing only in cv-qualification +
7.6.161550CD3 +Parenthesized throw-expression operand of conditional-expression +
7.6.161560CD3 +Gratuitous lvalue-to-rvalue conversion in conditional-expression with throw-expression operand +
7.6.161805CD4 +Conversions of array operands in conditional-expressions +
7.6.161843CD4 +Bit-field in conditional operator with throw operand +
7.6.161895CD4 +Deleted conversions in conditional operator operands +
7.6.161932CD4 +Bit-field results of conditional operators +
7.6.162023drafting +Composite reference result type of conditional operator +
7.6.162226DRWP +Xvalues vs lvalues in conditional expressions +
7.6.162316drafting +Simplifying class conversions in conditional expressions +
7.6.162321DRWP +Conditional operator and cv-qualified class prvalues +
7.6.18556CD2 +Conflicting requirements for acceptable aliasing +
7.6.18855CD2 +Incorrect comments in braced-init-list assignment example +
7.6.181527CD3 +Assignment from braced-init-list +
7.6.181538CD3 +C-style cast in braced-init-list assignment +
7.6.181542drafting +Compound assignment of braced-init-list +
7.6.182286NAD +Assignment evaluation order +
7.6.182399drafting +Unclear referent of “expression” in assignment-expression +
7.6.19188TC1 +Comma operator and rvalue conversion +
7.6.191925CD4 +Bit-field prvalues +
7.794TC1 +Inconsistencies in the descriptions of constant expressions +
7.797NAD +Use of bool constants in integral constant expressions +
7.7236NAD +Explicit temporaries and integral constant expressions +
7.7339CD1 +Overload resolution in operand of sizeof in constant expression +
7.7366CD1 +String literal allowed in integral constant expression? +
7.7367CD1 +throw operator allowed in constant expression? +
7.7457CD1 +Wording nit on use of const variables in constant expressions +
7.7487NAD +Operator overloading in constant expressions +
7.7530CD1 +Nontype template arguments in constant expressions +
7.7652CD2 +Compile-time evaluation of floating-point expressions +
7.7684CD1 +Constant expressions involving the address of an automatic variable +
7.7715CD2 +Class member access constant expressions +
7.7721CD2 +Where must a variable be initialized to be used in a constant expression? +
7.7806CD2 +Enumeration types in integral constant expressions +
7.7807NAD +typeid expressions in constant expressions +
7.71010CD2 +Address of object with dynamic storage duration in constant expression +
7.71060C++11 +Scoped enumerators in integral constant expressions +
7.71098C++11 +Pointer conversions in constant expressions +
7.71099C++11 +Infinite recursion in constexpr functions +
7.71100C++11 +constexpr conversion functions and non-type template arguments +
7.71125C++11 +Unclear definition of “potential constant expression” +
7.71126C++11 +constexpr functions in const initializers +
7.71127C++11 +Overload resolution in constexpr functions +
7.71188C++11 +Type punning in constant expressions +
7.71193C++11 +Use of address-constant pointers in constant expressions +
7.71197C++11 +Constexpr arrays +
7.71255drafting +Definition problems with constexpr functions +
7.71256open +Unevaluated operands are not necessarily constant expressions +
7.71264CD3 +Use of this in constexpr constructor +
7.71293CD3 +String literals in constant expressions +
7.71311CD3 +Volatile lvalues in constant expressions +
7.71312CD3 +Simulated reinterpret_cast in constant expressions +
7.71313CD3 +Undefined pointer arithmetic in constant expressions +
7.71364CD3 +constexpr function parameters +
7.71365CD3 +Calling undefined constexpr functions +
7.71367CD3 +Use of this in a constant expression +
7.71384NAD +reinterpret_cast in constant expressions +
7.71407NAD +Integral to bool conversion in converted constant expressions +
7.71452drafting +Value-initialized objects may be constants +
7.71454CD3 +Passing constants through constexpr functions via references +
7.71455CD3 +Lvalue converted constant expressions +
7.71456CD3 +Address constant expression designating the one-past-the-end address +
7.71480CD3 +Constant initialization via non-constant temporary +
7.71535CD3 +typeid in core constant expressions +
7.71537CD3 +Optional compile-time evaluation of constant expressions +
7.71540NAD +Use of address constants in constant expressions +
7.71626drafting +constexpr member functions in brace-or-equal-initializers +
7.71683CD4 +Incorrect example after constexpr changes +
7.71694CD4 +Restriction on reference to temporary as a constant expression +
7.71757CD4 +Const integral subobjects +
7.71826NAD +const floating-point in constant expressions +
7.71921NAD +constexpr constructors and point of initialization of const variables +
7.71952CD4 +Constant expressions and library undefined behavior +
7.71968NAD +Address of typeid in constant expressions +
7.72004CD4 +Unions with mutable members in constant expressions +
7.72005NAD +Incorrect constexpr reference initialization requirements +
7.72022CD4 +Copy elision in constant expressions +
7.72126drafting +Lifetime-extended temporaries in constant expressions +
7.72129CD4 +Non-object prvalues and constant expressions +
7.72166drafting +Unclear meaning of “undefined constexpr function” +
7.72167CD4 +Non-member references with lifetimes within the current evaluation +
7.72186drafting +Unclear point that “preceding initialization” must precede +
7.72192open +Constant expressions and order-of-eval undefined behavior +
7.72278DR +Copy elision in constant expressions reconsidered +
7.72301open +Value-initialization and constexpr constructor evaluation +
7.72364drafting +Constant expressions, aggregate initialization, and modifications +
7.72368DR +Differences in relational and three-way constant comparisons +
7.72392open +new-expression size check and constant evaluation +
7.72400drafting +Constexpr virtual functions and temporary objects +
82349NAD +Class/enumeration names vs conditions +
8.21054C++11 +Lvalue-to-rvalue conversions in expression statements +
8.4227TC1 +How many scopes in an if statement? +
8.4948C++11 +constexpr in conditions +
8.41732C++14 +Defining types in conditions and range-based for statements +
8.42344NAD +Redeclaration of names in init-statements +
8.4.1631CD3 +Jumping into a “then” clause +
8.4.12274NAD +Generic lambda capture vs constexpr if +
8.4.12320extension +constexpr if and boolean conversions +
8.4.12345review +Jumping across initializers in init-statements and conditions +
8.4.12348NAD +Non-templated constexpr if +
8.4.21767C++14 +Scoped enumeration in a switch statement +
8.51204C++11 +Specifiers in a for-range-declaration +
8.5.4864C++11 +braced-init-list in the range-based for statement +
8.5.4866concepts +Concept maps and the range-based for +
8.5.41274CD4 +Common nonterminal for expression and braced-init-list +
8.5.41442CD3 +Argument-dependent lookup in the range-based for +
8.5.41445dup +Argument-dependent lookup of begin and end +
8.5.41498dup +Lifetime of temporaries in range-based for +
8.5.41523DRWP +Point of declaration in range-based for +
8.5.41679NAD +Range-based for and array of runtime bound +
8.5.41680drafting +Including <initializer_list> for range-based for +
8.5.42220C++17 +Hiding index variable in range-based for +
8.6276CD1 +Order of destruction of parameters and temporaries +
8.6378CD1 +Wording that says temporaries are declared +
8.62115drafting +Order of implicit destruction vs release of automatic storage +
8.6.31541CD3 +cv void return types +
8.6.32017CD4 +Flowing off end is not equivalent to no-expression return +
8.7467NAD +Jump past initialization of local static variable +
8.7723concepts +Archetypes in skipped declarations +
8.71784C++17 +Concurrent execution during static local initialization +
8.72123open +Omitted constant initialization of local static variables +
8.81223drafting +Syntactic disambiguation and trailing-return-types +
8.81616drafting +Disambiguation parsing and template parameters +
9157open +Omitted typedef declarator +
9435NAD +Change "declararation or definition" to "declaration" +
9569CD2 +Spurious semicolons at namespace scope should be allowed +
91018C++11 +Ambiguity between simple-declaration and attribute-declaration +
91042C++11 +Attributes in alias-declarations +
91325NAD +Omitted declarator in friend declarations +
91830CD4 +Repeated specifiers +
91990CD4 +Ambiguity due to optional decl-specifier-seq +
92188open +empty-declaration ambiguity +
92288NAD +Contradictory optionality in simple-declaration +
92341extension +Structured bindings with static storage duration +
9.1808CD2 +Non-type decl-specifiers versus max-munch +
9.11128C++11 +attribute-specifiers in decl-specifier-seqs +
9.1.169TC1 +Storage class specifiers on template declarations +
9.1.1154NAD +Anonymous unions in unnamed namespaces +
9.1.1498open +Storage class specifiers in definitions of class members +
9.1.1717CD2 +Unintentional restrictions on the use of thread_local +
9.1.1809CD2 +Deprecation of the register keyword +
9.1.1810CD2 +Block-scope thread_local variables should be implicitly static +
9.1.1940CD2 +Global anonymous unions +
9.1.11544CD3 +Linkage of member of unnamed namespace +
9.1.11648C++14 +thread_local vs block extern declarations +
9.1.11793CD4 +thread_local in explicit specializations +
9.1.11799CD4 +mutable and non-explicit const qualification +
9.1.11930CD4 +init-declarator-list vs member-declarator-list +
9.1.12050NAD +Consolidate specification of linkage +
9.1.12232open +thread_local anonymous unions +
9.1.2281CD1 +inline specifier in friend declarations +
9.1.2317CD1 +Can a function be declared inline after it has been called? +
9.1.2376NAD +Class "definition" versus class "declaration" +
9.1.2396CD1 +Misleading note regarding use of auto for disambiguation +
9.1.2397CD1 +Same address for string literals from default arguments in inline functions? +
9.1.2412NAD +Can a replacement allocation function be inline? +
9.1.2477CD1 +Can virtual appear in a friend declaration? +
9.1.2765CD2 +Local types in inline functions with external linkage +
9.1.21823CD4 +String literal uniqueness in inline functions +
9.1.356TC1 +Redeclaring typedefs within classes +
9.1.3407C++11 +Named class with associated typedef: two names or one? +
9.1.3422NAD +Is a typedef redeclaration allowed with a template type that might be the same? +
9.1.3424CD1 +Wording problem with issue 56 resolution on redeclaring typedefs in class scope +
9.1.3576CD2 +Typedefs in function definitions +
9.1.31247CD4 +Restriction on alias name appearing in type-id +
9.1.31437CD3 +alignas in alias-declaration +
9.1.31820open +Qualified typedef names +
9.1.31894open +typedef-names and using-declarations +
9.1.31964NAD +opaque-enum-declaration in alias-declaration? +
9.1.32071CD4 +typedef with no declarator +
9.1.32199drafting +Typedefs and tags +
9.1.32212open +Typedef changing linkage after use +
9.1.5647CD1 +Non-constexpr instances of constexpr constructor templates +
9.1.5648CD1 +Constant expressions in constexpr initializers +
9.1.5699CD2 +Must constexpr member functions be defined in the class member-specification? +
9.1.5700C++11 +Constexpr member functions of class templates +
9.1.5837C++11 +Constexpr functions and return braced-init-list +
9.1.5860C++11 +Explicit qualification of constexpr member functions +
9.1.5892C++11 +Missing requirements for constexpr constructors +
9.1.5898C++11 +Declarations in constexpr functions +
9.1.5991CD2 +Reference parameters of constexpr functions and constructors +
9.1.51129C++11 +Default nothrow for constexpr functions +
9.1.51186C++11 +Non-dependent constexpr violations in function templates +
9.1.51194C++11 +Constexpr references +
9.1.51195C++11 +References to non-literal types in constexpr functions +
9.1.51199C++11 +Deleted constexpr functions +
9.1.51225C++11 +constexpr constructors and virtual bases +
9.1.51316NAD +constexpr function requirements and class scope +
9.1.51358CD3 +Unintentionally ill-formed constexpr function template instances +
9.1.51359CD3 +constexpr union constructors +
9.1.51366CD3 +Deleted constexpr constructors and virtual base classes +
9.1.51369CD3 +Function invocation substitution of this +
9.1.51587C++14 +constexpr initialization and nested anonymous unions +
9.1.51595C++14 +Constructors “involved in” subobject initialization +
9.1.51597CD3 +Misleading constexpr example +
9.1.51637NAD +Recursion in constexpr template default constructor +
9.1.51684C++14 +Static constexpr member functions for non-literal classes +
9.1.51688NAD +Volatile constexpr variables +
9.1.51712CD4 +constexpr variable template declarations +
9.1.51745NAD +thread_local constexpr variable +
9.1.51872CD4 +Instantiations of constexpr templates that cannot appear in constant expressions +
9.1.51911CD4 +constexpr constructor with non-literal base class +
9.1.52117drafting +Explicit specializations and constexpr function templates +
9.1.52163CD4 +Labels in constexpr functions +
9.1.52217NAD +constexpr constructors for non-literal types +
9.1.52268C++17 +Unions with mutable members in constant expressions revisited +
9.1.52299DRWP +constexpr vararg functions +
9.1.52309DR +Restrictions on nested statements within constexpr functions +
9.1.7539CD3 +Constraints on type-specifier-seq +
9.1.7.176TC1 +Are const volatile variables considered "constant expressions"? +
9.1.7.1609CD4 +What is a “top-level” cv-qualifier? +
9.1.7.1811CD2 +Unclear implications of const-qualification +
9.1.7.12195open +Unsolicited reading of trailing volatile members +
9.1.7.2283CD1 +Template type-parameters are not syntactically type-names +
9.1.7.2516CD1 +Use of signed in bit-field declarations +
9.1.7.2643NAD +Use of decltype in a class member-specification +
9.1.7.2651CD1 +Problems in decltype specification and examples +
9.1.7.2669NAD +Confusing specification of the meaning of decltype +
9.1.7.2950CD2 +Use of decltype as a class-name +
9.1.7.2988CD2 +Reference-to-reference collapsing with decltype +
9.1.7.21075C++11 +Grammar does not allow template alias in type-name +
9.1.7.21130C++11 +Function parameter type adjustments and decltype +
9.1.7.21212C++11 +Non-function-call xvalues and decltype +
9.1.7.21600CD4 +Erroneous reference initialization in example +
9.1.7.21852CD4 +Wording issues regarding decltype(auto) +
9.1.7.22332DR +template-name as simple-type-name vs injected-class-name +
9.1.7.368TC1 +Grammar does not allow "friend class A<int>;" +
9.1.7.3144open +Position of friend specifier +
9.1.7.3962CD2 +Attributes appertaining to class and enum types +
9.1.7.31131C++11 +Template aliases in elaborated-type-specifiers +
9.1.7.31707C++14 +template in elaborated-type-specifier without nested-name-specifier +
9.1.7.32157CD4 +Further disambiguation of enumeration elaborated-type-specifier +
9.1.7.32213drafting +Forward declaration of partial specializations +
9.1.7.4625CD2 +Use of auto as a template-argument +
9.1.7.4629CD1 +auto parsing ambiguity +
9.1.7.4706NAD +Use of auto with rvalue references +
9.1.7.4711CD2 +auto with braced-init-list +
9.1.7.4746CD2 +Use of auto in new-expressions +
9.1.7.4984CD2 +“Deduced type” is unclear in auto type deduction +
9.1.7.41265CD3 +Mixed use of the auto specifier +
9.1.7.41346CD3 +expression-list initializers and the auto specifier +
9.1.7.41347CD3 +Consistency of auto in multiple-declarator declarations +
9.1.7.41348drafting +Use of auto in a trailing-return-type +
9.1.7.41564NAD +Template argument deduction from an initializer list +
9.1.7.41588CD3 +Deducing cv-qualified auto +
9.1.7.41670drafting +auto as conversion-type-id +
9.1.7.41674C++14 +Return type deduction for address of function +
9.1.7.41725NAD +Trailing return type with nested function declarator +
9.1.7.41868drafting +Meaning of “placeholder type” +
9.1.7.41877CD4 +Return type deduction from return with no operand +
9.1.7.41878CD4 +operator auto template +
9.1.7.41892CD4 +Use of auto in function type +
9.1.7.41957extension +decltype(auto) with direct-list-initialization +
9.1.7.41958CD4 +decltype(auto) with parenthesized initializer +
9.1.7.42044CD4 +decltype(auto) and void +
9.1.7.42053drafting +auto in non-generic lambdas +
9.1.7.42059DRWP +Linkage and deduced return types +
9.1.7.42060NAD +Deduced return type for explicit specialization +
9.1.7.42081DRWP +Deduced return type in redeclaration or specialization of function template +
9.1.7.42389open +Agreement of deduced and explicitly-specified variable types +
9.2736NAD +Is the & ref-qualifier needed? +
9.2770CD2 +Ambiguity in late-specified return type +
9.2979CD2 +Position of attribute-specifier in declarator syntax +
9.21243C++11 +Misleading footnote regarding multiple-declarator declarations +
9.21297CD3 +Misplaced function attribute-specifier +
9.21342drafting +Order of initialization with multiple declarators +
9.21382CD3 +Dead code for constructor names +
9.21528CD3 +Repeated cv-qualifiers in declarators +
9.22036NAD +Refactoring parameters-and-qualifiers +
9.22040CD4 +trailing-return-type no longer ambiguous +
9.2.1686CD1 +Type declarations/definitions in type-specifier-seqs and type-ids +
9.2.11234C++11 +abstract-declarator does not permit ... after ptr-operator +
9.2.11240C++11 +constexpr defaulted constructors +
9.2.11488drafting +abstract-pack-declarators in type-ids +
9.2.2160CD1 +Missing std:: qualification +
9.2.2333NAD +Ambiguous use of "declaration" in disambiguation section +
9.2.2340NAD +Unclear wording in disambiguation section
9.2.21867NAD +Function/expression ambiguity with qualified parameter name +
9.2.21970NAD +Ambiguity resolution for (T())*x +
9.2.22175CD4 +Ambiguity with attribute in conversion operator declaration +
9.2.22228review +Ambiguity resolution for cast to function type +
9.2.22259C++17 +Unclear context describing ambiguity +
9.2.340TC1 +Syntax of declarator-id +
9.2.3159TC1 +Namespace qualification in declarators +
9.2.3374CD2 +Can explicit specialization outside namespace use qualified name? +
9.2.3482CD3 +Qualified declarators in redeclarations +
9.2.3548dup +qualified-ids in declarations +
9.2.3920CD2 +Interaction of inline namespaces and using-declarations +
9.2.31435CD3 +template-id as the declarator for a class template constructor +
9.2.31900drafting +Do friend declarations count as “previous declarations”? +
9.2.32113CD4 +Incompete specification of types for declarators +
9.2.3.2453drafting +References may only bind to “valid” objects +
9.2.3.2504open +Should use of a variable in its own initializer require a diagnostic? +
9.2.3.21510CD3 +cv-qualified references via decltype +
9.2.3.4112CD1 +Array types and cv-qualifiers +
9.2.3.4478NAD +May a function parameter be an array of an abstract class type? +
9.2.3.4701CD2 +When is the array-to-pointer conversion applied? +
9.2.3.41222NAD +Unnecessary restriction on auto array types +
9.2.3.41640drafting +Array of abstract instance of class template +
9.2.3.41761NAD +Runtime check on size of automatic array +
9.2.3.41768NAD +Zero-element array of runtime bound +
9.2.3.42099CD4 +Inferring the bound of an array static data member +
9.2.3.42397drafting +auto specifier for pointers and references to arrays +
9.2.3.518NAD +f(TYPE) where TYPE is void should be allowed +
9.2.3.5135TC1 +Class type in in-class member function definitions +
9.2.3.5140CD1 +Agreement of parameter declarations +
9.2.3.5262CD1 +Default arguments and ellipsis +
9.2.3.5295CD1 +cv-qualifiers on function types +
9.2.3.5332CD3 +cv-qualified void parameter types +
9.2.3.5393CD4 +Pointer to array of unknown bound in template argument list in parameter +
9.2.3.5547C++11 +Partial specialization on member function types +
9.2.3.5550dup +Pointer to array of unknown bound in parameter declarations +
9.2.3.5577CD3 +void in an empty parameter list +
9.2.3.5681CD1 +Restrictions on declarators with late-specified return types +
9.2.3.5713CD2 +Unclear note about cv-qualified function types +
9.2.3.5725concepts +When should the requirement for std::Returnable<T>, etc., apply? +
9.2.3.5818CD2 +Function parameter packs in non-final positions +
9.2.3.5956CD2 +Function prototype scope with late-specified return types +
9.2.3.5994C++11 +braced-init-list as a default argument +
9.2.3.5998dup +Function parameter transformations and template functions +
9.2.3.51001drafting +Parameter type adjustment in dependent parameter types +
9.2.3.51069C++11 +Incorrect function type with trailing-return-type +
9.2.3.51183C++11 +Expansion of parameter packs in declarators +
9.2.3.51380CD3 +Type definitions in template-parameter parameter-declarations +
9.2.3.51389NAD +Recursive reference in trailing-return-type +
9.2.3.51394CD3 +Incomplete types as parameters of deleted functions +
9.2.3.51417C++14 +Pointers/references to functions with cv-qualifiers or ref-qualifier +
9.2.3.51668drafting +Parameter type determination still not clear enough +
9.2.3.51790extension +Ellipsis following function parameter pack +
9.2.3.51824CD4 +Completeness of return type vs point of instantiation +
9.2.3.61TC1 +What if two using-declarations refer to the same function but the declarations introduce different default-arguments? +
9.2.3.615dup +Default arguments for parameters of function templates +
9.2.3.665TC1 +Typo in default argument example +
9.2.3.666NAD +Visibility of default args vs overloads added after using-declaration +
9.2.3.6136CD1 +Default arguments and friend declarations +
9.2.3.6217TC1 +Default arguments for non-template member functions of class templates +
9.2.3.6325drafting +When are default arguments parsed? +
9.2.3.6361open +Forward reference to default argument +
9.2.3.6777CD2 +Default arguments and parameter packs +
9.2.3.61226CD3 +Converting a braced-init-list default argument +
9.2.3.61443NAD +Default arguments and non-static data members +
9.2.3.61580drafting +Default arguments in explicit instantiations +
9.2.3.61609open +Default arguments and function parameter packs +
9.2.3.61716C++14 +When are default arguments evaluated? +
9.2.3.61814CD4 +Default arguments in lambda-expressions +
9.2.3.62082CD4 +Referring to parameters in unevaluated operands of default arguments +
9.2.3.62233DRWP +Function parameter packs following default arguments +
9.2.3.62346DRWP +Local variables in default arguments +
9.35CD1 +CV-qualifiers and type conversions +
9.335TC1 +Definition of default-initialization +
9.378CD1 +Section 8.5 paragraph 9 should state it only applies to non-static objects +
9.3151TC1 +Terminology of zero-initialization +
9.3155dup +Brace initializer for scalar +
9.3177CD1 +Lvalues vs rvalues in copy-initialization +
9.3178TC1 +More on value-initialization +
9.3253C++17 +Why must empty or fully-initialized const objects be initialized? +
9.3277CD1 +Zero-initialization of pointers +
9.3302CD1 +Value-initialization and generation of default constructor +
9.3304TC1 +Value-initialization of a reference +
9.3508C++11 +Non-constructed value-initialized objects +
9.3509CD1 +Dead code in the specification of default initialization +
9.3543CD1 +Value initialization and default constructors +
9.3611CD2 +Zero-initializing references +
9.3615C++11 +Incorrect description of variables that can be initialized +
9.3670open +Copy initialization via derived-to-base conversion in the second step +
9.3694C++11 +Zero- and value-initialization of union objects +
9.3869CD2 +Uninitialized thread_local objects +
9.31093CD3 +Value-initializing non-objects +
9.31214C++11 +Kinds of initializers +
9.31301CD3 +Value initialization of union +
9.31324CD3 +Value initialization and defaulted constructors +
9.31339NAD +Parenthesized braced-init-list and arrays +
9.31368CD3 +Value initialization and defaulted constructors (part 2) +
9.31434NAD +Parenthesized braced-init-list +
9.31502CD3 +Value initialization of unions with member initializers +
9.31507CD3 +Value initialization with trivial inaccessible default constructor +
9.31578NAD +Value-initialization of aggregates +
9.31630CD4 +Multiple default constructor templates +
9.31633CD4 +Copy-initialization in member initialization +
9.31782CD4 +Form of initialization for nullptr_t to bool conversion +
9.31997drafting +Placement new and previous initialization +
9.32196C++17 +Zero-initialization with virtual base classes +
9.32327drafting +Copy elision for direct-initialization with a conversion function +
9.3.1163TC1 +Description of subaggregate initializer +
9.3.1430CD1 +Ordering of expression evaluation in initializer list +
9.3.1491CD1 +Initializers for empty-class aggregrate members +
9.3.1632CD1 +Brace-enclosed initializer for scalar member of aggregate +
9.3.1886CD2 +Member initializers and aggregates +
9.3.1938C++11 +Initializer lists and array new +
9.3.11030C++11 +Evaluation order in initializer-lists used in aggregate initialization +
9.3.11070C++11 +Missing initializer clauses in aggregate initialization +
9.3.11097NAD +Aggregate initialization of function parameters +
9.3.11497NAD +Aggregate initialization with parenthesized string literal +
9.3.11561extension +Aggregates with empty base classes +
9.3.11622C++17 +Empty aggregate initializer for union +
9.3.11815CD4 +Lifetime extension in aggregate initialization +
9.3.11985NAD +Unknown bound array member with brace-or-equal-initializer +
9.3.12116drafting +Direct or copy initialization for omitted aggregate initializers +
9.3.12128drafting +Imprecise rule for reference member initializer +
9.3.12149drafting +Brace elision and array length deduction +
9.3.12269dup +Additional recursive references in aggregate DMIs +
9.3.12272C++17 +Implicit initialization of aggregate members of reference type +
9.3.12295extension +Aggregates with deleted defaulted constructors +
9.3.12359WP +Unintended copy initialization with designated initializers +
9.3.2737CD2 +Uninitialized trailing characters in string initialization +
9.3.2936CD2 +Array initialization with new string literals +
9.3.21304drafting +Omitted array bound with string initialization +
9.3.3233open +References vs pointers in UDC overload resolution +
9.3.3291CD1 +Overload resolution needed when binding reference to class rvalue +
9.3.3391CD1 +Require direct binding of short-lived references to rvalues +
9.3.3434NAD +Unclear suppression of standard conversions while binding reference to lvalue +
9.3.3450CD1 +Binding a reference to const to a cv-qualified array rvalue +
9.3.3589CD2 +Direct binding of class and array rvalues in reference initialization +
9.3.3656CD2 +Direct binding to the result of a conversion operator +
9.3.3664CD2 +Direct binding of references to non-class rvalue references +
9.3.3896CD2 +Rvalue references and rvalue-reference conversion functions +
9.3.31058NAD +Reference binding of incompatible array types +
9.3.31138C++11 +Rvalue-ness check for rvalue reference binding is wrong +
9.3.31139C++11 +Rvalue reference binding to scalar xvalues +
9.3.31236C++11 +Inconsistently-interrelated examples +
9.3.31263NAD +Mismatch between rvalue reference binding and overload resolution +
9.3.31287C++14 +Direct initialization vs “implicit” conversion in reference binding +
9.3.31295CD3 +Binding a reference to an rvalue bit-field +
9.3.31328CD3 +Conflict in reference binding vs overload resolution +
9.3.31401CD3 +Similar types and reference compatibility +
9.3.31414drafting +Binding an rvalue reference to a reference-unrelated lvalue +
9.3.31571CD4 +cv-qualification for indirect reference binding via conversion function +
9.3.31572CD4 +Incorrect example for rvalue reference binding via conversion function +
9.3.31604C++14 +Double temporaries in reference initialization +
9.3.31650NAD +Class prvalues in reference initialization +
9.3.31827drafting +Reference binding with ambiguous conversions +
9.3.32018drafting +Qualification conversion vs reference binding +
9.3.32111extension +Array temporaries in reference binding +
9.3.32267DR +Copy-initialization of temporary in reference direct-initialization +
9.3.32352DR +Similar types and reference binding +
9.3.4703CD2 +Narrowing for literals that cannot be exactly represented +
9.3.4865CD2 +Initializing a std::initializer_list +
9.3.4934CD2 +List-initialization of references +
9.3.4982NAD +Initialization with an empty initializer list +
9.3.4989CD2 +Misplaced list-initialization example +
9.3.4990CD2 +Value initialization with multiple initializer-list constructors +
9.3.41078NAD +Narrowing and the usual arithmetic conversions +
9.3.41095C++11 +List-initialization of references +
9.3.41232C++11 +Creation of array temporaries using a braced-init-list +
9.3.41270CD3 +Brace elision in array temporary initialization +
9.3.41288CD3 +Reference list initialization +
9.3.41290CD3 +Lifetime of the underlying array of an initializer_list member +
9.3.41379NAD +Is std::initializer_list an aggregate? +
9.3.41418CD3 +Type of initializer_list backing array
9.3.41419NAD +Evaluation order in aggregate initialization +
9.3.41421NAD +Full expressions and aggregate initialization +
9.3.41449CD3 +Narrowing conversion of negative value to unsigned type +
9.3.41461NAD +Narrowing conversions to bit-fields +
9.3.41467CD4 +List-initialization of aggregate from same-type object +
9.3.41490CD4 +List-initialization from a string literal +
9.3.41494CD3 +Temporary initialization for reference binding in list-initialization +
9.3.41501NAD +Nested braces in list-initialization +
9.3.41505dup +Direct binding of reference to temporary in list-initialization +
9.3.41506CD3 +Value category of initializer_list object +
9.3.41508C++14 +Template initializer-list constructors +
9.3.41518CD4 +Explicit default constructors and copy-list-initialization +
9.3.41522CD3 +Access checking for initializer_list array initialization +
9.3.41565NAD +Copy elision and lifetime of initializer_list underlying array +
9.3.41599CD4 +Lifetime of initializer_list underlying array +
9.3.41756CD4 +Direct-list-initialization of a non-class object +
9.3.41864extension +List-initialization of array objects +
9.3.41984NAD +Lossless narrowing conversions +
9.3.41996drafting +Reference list-initialization ignores conversion functions +
9.3.42137CD4 +List-initialization from object of same type +
9.3.42150CD3 +Initializer list array lifetime +
9.3.42168open +Narrowing conversions and +/- infinity +
9.3.42251C++17 +Unreachable enumeration list-initialization +
9.3.42252review +Enumeration list-initialization from the same type +
9.3.42374drafting +Overly permissive specification of enum direct-list-initialization +
9.4732CD2 +Late-specified return types in function definitions +
9.4845CD2 +What is the “first declaration” of an explicit specialization? +
9.4906CD2 +Which special member functions can be defaulted? +
9.4908CD2 +Deleted global allocation and deallocation functions +
9.4915CD2 +Deleted specializations of member function templates +
9.4928CD2 +Defaulting a function that would be implicitly defined as deleted +
9.4.11791CD4 +Incorrect restrictions on cv-qualifier-seq and ref-qualifier +
9.4.11962extension +Type of __func__ +
9.4.12144drafting +Function/variable declaration ambiguity +
9.4.12145CD4 +Parenthesized declarator in function definition +
9.4.12362extension +__func__ should be constexpr +
9.4.21134C++11 +When is an explicitly-defaulted function defined? +
9.4.21135C++11 +Explicitly-defaulted non-public special member functions +
9.4.21136C++11 +Explicitly-defaulted explicit constructors +
9.4.21137C++11 +Explicitly-defaulted virtual special member functions +
9.4.21327CD3 +virt-specifier in a defaulted definition +
9.4.21333CD3 +Omission of const in a defaulted copy constructor +
9.4.21355CD3 +Aggregates and “user-provided” constructors +
9.4.21426extension +Allowing additional parameter types in defaulted functions +
9.4.21552CD4 +exception-specifications and defaulted special member functions +
9.4.21574NAD +Explicitly-defaulted constexpr functions in wrapper templates +
9.4.21733drafting +Return type and value for operator= with ref-qualifier +
9.4.21778C++14 +exception-specification in explicitly-defaulted functions +
9.4.21846CD4 +Declaring explicitly-defaulted implicitly-deleted functions +
9.4.21854drafting +Disallowing use of implicitly-deleted functions +
9.4.21912extension +exception-specification of defaulted function +
9.4.22221review +Copying volatile objects +
9.4.31217NAD +Are deleted functions implicitly noexcept? +
9.4.32015CD4 +odr-use of deleted virtual functions +
9.52285DRWP +Issues with structured bindings +
9.52308NAD +Structured bindings and lambda capture +
9.52312drafting +Structured bindings and mutable +
9.52313DRWP +Redeclaration of structured binding reference variables +
9.52314dup +Structured bindings and lambda capture +
9.52339DRWP +Underspecified template arguments in structured bindings +
9.52340open +Reference collapsing and structured bindings +
9.52386DR +tuple_size requirements for structured binding +
9.6172CD1 +Unsigned int as underlying type of enum +
9.6377CD1 +Enum whose enumerators will not fit in any integral type +
9.6518CD1 +Trailing comma following enumerator-list +
9.6628CD2 +The values of an enumeration with no enumerator +
9.6660CD1 +Unnamed scoped enumerations +
9.6862CD2 +Undefined behavior with enumerator value overflow +
9.6893NAD +Brace syntax for enumerator-definitions +
9.6977CD3 +When is an enumeration type complete? +
9.61022C++11 +Can an enumeration variable have values outside the values of the enumeration? +
9.61317NAD +Unnamed scoped enumerations +
9.61485drafting +Out-of-class definition of member unscoped opaque enumeration +
9.61618C++14 +Gratuitously-unsigned underlying enum type +
9.61636DRWP +Bits required for negative enumerator values +
9.61638CD4 +Declaring an explicit specialization of a scoped enumeration +
9.61765C++14 +Overflow of enumeration used as enumerator value +
9.61766CD4 +Values outside the range of the values of an enumeration +
9.61917drafting +decltype-qualified enumeration names +
9.61966CD4 +Colon following enumeration elaborated-type-specifier +
9.62131drafting +Ambiguity with opaque-enum-declaration +
9.62156CD4 +Definition of enumeration declared by using-declaration +
9.7171TC1 +Global namespace scope +
9.7987CD4 +Which declarations introduce namespace members? +
9.7.1311NAD +Using qualified name to reopen nested namespace +
9.7.1540CD1 +Propagation of cv-qualifiers in reference-to-reference collapse +
9.7.1812CD2 +Duplicate names in inline namespaces +
9.7.1919CD2 +Contradictions regarding inline namespaces +
9.7.1921CD2 +Unclear specification of inline namespaces +
9.7.11657CD4 +Attributes for namespaces and enumerators +
9.7.11795CD4 +Disambiguating original-namespace-definition and extension-namespace-definition +
9.7.12061CD4 +Inline namespace after simplifications +
9.7.1.1926CD2 +Inline unnamed namespaces +
9.7.1.11012C++11 +Undeprecating static +
9.7.1.295NAD +Elaborated type specifiers referencing names declared in friend decls +
9.7.1.2138drafting +Friend declaration name lookup +
9.7.1.2165NAD +Definitions of friends and block-scope externs +
9.7.1.2166TC1 +Friend declarations of template-ids +
9.7.1.2553NAD +Problems with friend allocation and deallocation functions +
9.7.1.2673NAD +Injection of names from elaborated-type-specifiers in friend declarations +
9.7.1.21021CD4 +Definitions of namespace members +
9.7.1.21077extension +Explicit specializations in non-containing namespaces +
9.7.1.21439CD3 +Lookup and friend template declarations +
9.7.1.21477CD3 +Definition of a friend outside its namespace +
9.7.1.21838CD4 +Definition via unqualified-id and using-declaration +
9.7.1.22155C++17 +Defining classes and enumerations via using-declarations +
9.7.21976NAD +Ambiguity of namespace-aliases +
9.7.3103TC1 +Is it extended-namespace-definition or extension-namespace-definition ? +
9.7.3986CD2 +Transitivity of using-directives versus qualified lookup +
9.811CD1 +How do the keywords typename/template interact with using-declarations? +
9.836open +using-declarations in multiple-declaration contexts +
9.8101TC1 +Redeclaration of extern "C" names via using-declarations +
9.8109NAD +Allowing ::template in using-declarations +
9.8169NAD +template-ids in using-declarations +
9.8258CD1 +using-declarations and cv-qualifiers +
9.8386drafting +Friend declaration of name brought in by using-declaration +
9.8460CD1 +Can a using-declaration name a namespace? +
9.8565CD3 +Conflict rules for using-declarations naming function templates +
9.8813open +typename in a using-declaration with a non-dependent name +
9.8852open +using-declarations and dependent base classes +
9.81551C++14 +Wording problems in using-declaration specification +
9.81742open +using-declarations and scoped enumerators +
9.81887CD4 +Problems with :: as nested-name-specifier +
9.81903CD4 +What declarations are introduced by a non-member using-declaration? +
9.81907drafting +using-declarations and default arguments +
9.81960NAD +Visibility of entity named in class-scope using-declaration +
9.9461NAD +Make asm conditionally-supported +
9.92262C++17 +Attributes for asm-definition +
9.104CD1 +Does extern "C" affect the linkage of function names with internal linkage? +
9.1013NAD +extern "C" for Parameters of Function Templates +
9.1014NAD +extern "C" functions and declarations in different namespaces +
9.1029CD1 +Linkage of locally declared functions +
9.10107NAD +Linkage of operator functions +
9.10168NAD +C linkage for static member functions +
9.10341C++11 +extern "C" namespace member function versus global variable +
9.10358NAD +Namespaces and extern "C" +
9.10563open +Linkage specification for objects +
9.10564CD2 +Agreement of language linkage or linkage-specifications? +
9.101185C++11 +Misleading description of language linkage and member function types +
9.101703NAD +Language linkage of names of functions with internal linkage +
9.101708CD4 +overly-strict requirements for names with C language linkage +
9.101713drafting +Linkage of variable template specializations +
9.101817drafting +Linkage specifications and nested scopes +
9.101818open +Visibility and inherited language linkage +
9.101869NAD +thread_local vs linkage-specifications +
9.11814CD2 +Attribute to indicate that a function throws nothing +
9.11951CD2 +Problems with attribute-specifiers +
9.11970CD2 +Consistent use of “appertain” and “apply” +
9.111914extension +Duplicate standard attributes +
9.11.1815CD2 +Parameter pack expansion inside attributes +
9.11.1957CD2 +Alternative tokens and attribute-tokens +
9.11.1968CD2 +Syntactic ambiguity of the attribute notation +
9.11.1972C++11 +Allowing multiple attribute-specifiers +
9.11.11031C++11 +Optional elements in attributes +
9.11.11323NAD +Nonexistent nonterminal in alignment-specifier grammar +
9.11.11689C++14 +Syntactic nonterminal for operand of alignas +
9.11.11706drafting +alignas pack expansion syntax +
9.11.12079CD4 +[[ appearing in a balanced-token-seq +
9.11.12205C++17 +Restrictions on use of alignas +
9.11.12279NAD +Multiple attribute-specifiers in one attribute-list +
9.11.12388drafting +Applicability of contract-attribute-specifiers +
9.11.2959CD2 +Alignment attribute for class and enumeration types +
9.11.21033C++11 +Restrictions on alignment attributes +
9.11.21036C++11 +Alignment attribute in an exception-declaration +
9.11.21039dup +Coordinating C and C++ alignment specifications +
9.11.21615CD4 +Alignment of types, variables, and members +
9.11.21617open +alignas and non-defining declarations +
9.11.21627NAD +Agreement of dependent alignas specifiers +
9.11.22027CD4 +Unclear requirements for multiple alignas specifiers +
9.11.22223drafting +Multiple alignas specifiers +
9.11.3965CD2 +Limiting the applicability of the carries_dependency attribute +
9.11.31475CD3 +Errors in [[carries_dependency]] example +
9.11.82360DR +[[maybe_unused]] and structured bindings +
9.11.10836NAD +[[noreturn]] applied to function types +
9.11.101132NAD +Keyword vs attribute for noreturn +
10148TC1 +POD classes and pointers to members +
10175CD1 +Class name injection and base name access +
10176TC1 +Name injection and templates +
10273CD1 +POD classes and operator&() +
10284CD1 +qualified-ids in class declarations +
10327CD1 +Use of "structure" without definition +
10355C++11 +Global-scope :: in nested-name-specifier +
10379CD1 +Change "class declaration" to "class definition" +
10383CD1 +Is a class with a declared but not defined destructor a POD? +
10413CD1 +Definition of "empty class" +
10511open +POD-structs with template assignment operators +
10538CD1 +Definition and usage +of structure, POD-struct, POD-union, +and POD class +
10568CD1 +Definition of POD is too strict +
10905CD2 +Explicit defaulted copy constructors and trivial copyability +
101140C++11 +Incorrect redefinition of POD class +
101215C++11 +Definition of POD struct +
101318CD3 +Syntactic ambiguities with final +
101363CD3 +Triviality vs multiple default constructors +
101411CD3 +More on global scope :: in nested-name-specifier +
101813CD4 +Direct vs indirect bases in standard-layout classes +
101881CD4 +Standard-layout classes and unnamed bit-fields +
102120CD4 +Array as first non-static data member in standard-layout class +
102234DRWP +Missing rules for simple-template-id as class-name +
102293DRWP +Requirements for simple-template-id used as a class-name +
10.2417CD1 +Using derived-class qualified name in out-of-class nested class definition +
10.21496CD4 +Triviality with deleted and missing default constructors +
10.375TC1 +In-class initialized members must be const +
10.380TC1 +Class members with same name as class +
10.3190TC1 +Layout-compatible POD-struct types +
10.3328CD1 +Missing requirement that class member types be complete +
10.3437CD1 +Is type of class allowed in member function exception specification? +
10.3613CD1 +Unevaluated uses of non-static class members +
10.3620CD1 +Declaration order in layout-compatible POD structs +
10.3645CD2 +Are bit-field and non-bit-field members layout compatible? +
10.3844concepts +Is a constrained member function a template? +
10.3874CD2 +Class-scope definitions of enumeration types +
10.3924C++11 +alias-declaration as a class member +
10.31035C++11 +Omitted and required decl-specifiers +
10.31041dup +alias-declarations as class members +
10.31072C++11 +Scoped enumerator with the same name as its containing class +
10.31141NAD +Non-static data member initializers have not been implemented +
10.31308CD3 +Completeness of class type within an exception-specification +
10.31341NAD +Bit-field initializers +
10.31357CD3 +brace-or-equal-initializers for function and typedef members +
10.31397CD4 +Class completeness in non-static data member initializers +
10.31425CD3 +Base-class subobjects of standard-layout structs +
10.31660C++14 +member-declaration requirements and unnamed bit-fields +
10.31672CD4 +Layout compatibility with multiple empty bases +
10.31693C++14 +Superfluous semicolons in class definitions +
10.31719CD4 +Layout compatibility and cv-qualification revisited +
10.31803drafting +opaque-enum-declaration as member-declaration +
10.31821open +Qualified redeclarations in a class member-specification +
10.31890drafting +Member type depending on definition of member function +
10.31909CD4 +Member class template with the same name as the class +
10.31983DRWP +Inappropriate use of virt-specifier +
10.32153CD4 +pure-specifier in friend declaration +
10.32154CD4 +Ambiguity of pure-specifier +
10.32208NAD +static_assert-declaration does not declare a member +
10.32254DRWP +Standard-layout classes and bit-fields +
10.3.11142C++11 +friend declaration of member function of containing class +
10.3.21005NAD +Qualified name resolution in member functions of class templates +
10.3.21017C++11 +Member access transformation in unevaluated operands +
10.3.21143NAD +Move semantics for *this have not been implemented +
10.3.21207C++11 +Type of class member in trailing-return-type +
10.3.21208C++11 +Explicit noexcept in defaulted definition +
10.3.2.1452CD1 +Wording nit on description of this +
10.3.2.11306CD3 +Modifying an object within a const member function +
10.3.3819NAD +Access control and deleted implicitly-declared special member functions +
10.3.4194TC1 +Identifying constructors +
10.3.4263CD1 +Can a constructor be declared a friend? +
10.3.4326CD1 +Wording for definition of trivial constructor +
10.3.4331CD1 +Allowed copy constructor signatures +
10.3.4738C++11 +constexpr not permitted by the syntax of constructor declarations +
10.3.4922CD2 +Implicit default constructor definitions and const variant members +
10.3.4927CD2 +Implicitly-deleted default constructors and member initializers +
10.3.41145C++11 +Defaulting and triviality +
10.3.41191C++11 +Deleted subobject destructors and implicitly-defined constructors +
10.3.41353drafting +Array and variant members and deleted special member functions +
10.3.41360drafting +constexpr defaulted default constructors +
10.3.41427NAD +Default constructor and deleted or inaccessible destructors +
10.3.41611C++14 +Deleted default constructor for abstract class +
10.3.41623drafting +Deleted default union constructor and member initializers +
10.3.41658C++14 +Deleted default constructor for abstract class via destructor +
10.3.41808drafting +Constructor templates vs default constructors +
10.3.41888CD4 +Implicitly-declared default constructors and explicit +
10.3.42084CD4 +NSDMIs and deleted union default constructors +
10.3.42237WP +Can a template-id name a constructor? +
10.3.42271C++17 +Aliasing this +
10.3.42273DRWP +Inheriting constructors vs implicit default constructor +
10.3.4.12394DR +Const-default-constructible for members +
10.3.52329drafting +Virtual base classes and generated assignment operators +
10.3.6193TC1 +Order of destruction of local automatics of destructor +
10.3.6244CD1 +Destructor lookup +
10.3.6252CD1 +Looking up deallocation functions in virtual destructors +
10.3.6272CD1 +Explicit destructor invocation and qualified-ids +
10.3.6344CD3 +Naming destructors +
10.3.6399drafting +Destructor lookup redux +
10.3.6677CD1 +Deleted operator delete and virtual destructors +
10.3.61029C++11 +Type of a destructor call +
10.3.61081C++11 +Defaulted destructor and unusable operator delete +
10.3.61146C++11 +exception-specifications of defaulted functions +
10.3.61147C++11 +Destructors should be default nothrow +
10.3.61241C++11 +Which members does a destructor destroy? +
10.3.61492CD4 +Exception specifications on template destructors +
10.3.61586NAD +Naming a destructor via decltype +
10.3.61605CD3 +Misleading parenthetical comment for explicit destructor call +
10.3.61783NAD +Why are virtual destructors non-trivial? +
10.3.61811CD4 +Lookup of deallocation function in a virtual destructor definition +
10.3.61848CD4 +Parenthesized constructor and destructor declarators +
10.3.61969open +Missing exclusion of ~S as an ordinary function name +
10.3.61977drafting +Contradictory results of failed destructor lookup +
10.3.62068CD4 +When can/must a defaulted virtual destructor be defined? +
10.3.62069CD4 +Do destructors have names? +
10.3.62158drafting +Polymorphic behavior during destruction +
10.3.7.1152TC1 +explicit copy constructors +
10.3.7.11336CD3 +Definition of “converting constructor” +
10.3.7.11978CD4 +Redundant description of explicit constructor use +
10.3.7.2296CD1 +Can conversion functions be static? +
10.3.7.2395NAD +Conversion operator template syntax +
10.3.7.2875concepts +Associated conversion functions converting to the same type +
10.3.7.21726drafting +Declarator operators and conversion function +
10.3.7.22016CD4 +Confusing wording in description of conversion function +
10.3.867TC1 +Evaluation of left side of object-expression +
10.3.8.1315NAD +Is call of static member function through null pointer undefined? +
10.3.8.248TC1 +Definitions of unused static members +
10.3.8.2406CD1 +Static data member in class with name for linkage purposes +
10.3.8.2454CD1 +When is a definition of a static data member required? +
10.3.8.2714CD2 +Static const data members and braced-init-lists +
10.3.8.2902NAD +In-class initialization of non-constant static data members +
10.3.8.21101C++11 +Non-integral initialized static data members +
10.3.8.21203dup +Misleading note regarding initialized static data members +
10.3.8.21272NAD +Implicit definition of static data member of const literal type +
10.3.8.21283drafting +Static data members of classes with typedef name for linkage purposes +
10.3.8.21721drafting +Diagnosing ODR violations for static data members +
10.3.8.21987NAD +constexpr static data members across translation units +
10.3.8.22335drafting +Deduced return types vs member types +
10.3.8.22375NAD +Multiple redeclarations of constexpr static data members +
10.3.958CD1 +Signedness of bit fields of enum type +
10.3.9436CD1 +Problem in example in 9.6 paragraph 4 +
10.3.9675CD3 +Signedness of bit-field with typedef or template parameter type +
10.3.9739CD3 +Signedness of plain bit-fields +
10.3.9741C++11 +“plain” long long bit-fields +
10.3.91514C++14 +Ambiguity between enumeration definition and zero-length bit-field +
10.3.91861CD4 +Values of a bit-field +
10.3.91943open +Unspecified meaning of “bit” +
10.3.92229DRWP +Volatile unnamed bit-fields +
10.3.92253DRWP +Unnamed bit-fields and zero-initialization +
10.3.10347NAD +Use of derived class name in defining base class nested class +
10.457open +Empty unions +
10.4359NAD +Type definition in anonymous union +
10.4512NAD +Union members with user-declared non-default constructors +
10.4716CD2 +Specifications that should apply only to non-static union data members +
10.41375CD3 +Reference to anonymous union? +
10.41404drafting +Object reallocation in unions +
10.41460C++14 +What is an empty union? +
10.41702drafting +Rephrasing the definition of “anonymous union” +
10.41801drafting +Kind of expression referring to member of anonymous union +
10.41860C++17 +What is a “direct member?” +
10.41940CD4 +static_assert in anonymous unions +
10.42080drafting +Example with empty anonymous union member +
10.5198CD1 +Definition of "use" in local and nested classes +
10.5696C++11 +Use of block-scope constants in local classes +
10.51714NAD +odr-use of this from a local class +
10.6484CD1 +Can a base-specifier name a cv-qualified class type? +
10.61019dup +Dependent simple-template-ids in base-specifiers and mem-initializers +
10.61710C++17 +Missing template keyword in class-or-decltype +
10.6.2608CD2 +Determining the final overrider of a virtual function +
10.6.2939CD2 +Explicitly checking virtual function overriding +
10.6.2960CD2 +Covariant functions and lvalue/rvalue references +
10.6.21250CD3 +Cv-qualification of incomplete virtual function return types +
10.6.22119NAD +Disambiguation of multi-level covariant return type +
10.6.3230NAD +Calls to pure virtual functions +
10.6.3390CD1 +Pure virtual must be defined when implicitly called +
10.6.31420NAD +Abstract final classes +
10.739CD1 +Conflicting ambiguity rules +
10.7306CD1 +Ambiguity by class name injection +
10.7380open +Definition of "ambiguous base class" missing +
10.71764C++14 +Hiding of function from using-declaration by signature +
10.72078NAD +Name lookup of mem-initilizer-id +
10.88CD1 +Access to template arguments used in a function return type and in the nested name specifier +
10.8494CD1 +Problems with the resolution of issue 45 +
10.8580C++11 +Access in template-parameters of member and friend definitions +
10.8600open +Does access control apply to members or to names? +
10.8.27NAD +Can a class with a private virtual base class be derived from? +
10.8.29CD1 +Clarification of access to base class members +
10.8.216CD1 +Access to members of indirect private base classes +
10.8.217NAD +Footnote 99 should discuss the naming class when describing members that can be accessed from friends +
10.8.2142TC1 +Injection-related errors in access example +
10.8.2207CD1 +using-declarations and protected access +
10.8.2360open +Using-declaration that reduces access +
10.8.2471NAD +Conflicting inherited access specifications +
10.8.2747dup +Access of protected base classes +
10.8.2952drafting +Insufficient description of “naming class” +
10.8.21873CD4 +Protected member access from derived class friends +
10.8.22030NAD +Access of injected-class-name with template arguments +
10.8.22246drafting +Access of indirect virtual base class constructors +
10.8.377CD1 +The definition of friend does not allow nested classes to be friends +
10.8.3209NADMust friend declaration names be +accessible?
10.8.3445NAD +Wording issue on friend declarations +
10.8.3500CD1 +Access in base-specifiers of friend and nested classes +
10.8.3501NAD +Visibility of friend declarations within the befriending class +
10.8.3585NAD +Friend template template parameters +
10.8.3718open +Non-class, non-function friend declarations +
10.8.31699drafting +Does befriending a class befriend its friends? +
10.8.31833NAD +friend declarations naming implicitly-declared member functions +
10.8.32363NAD +Opaque enumeration friend declarations +
10.8.419NAD +Clarify protected member access +
10.8.4161TC1 +Access to protected nested type +
10.8.4385CD1 +How does protected member check of 11.5 interact with using-declarations? +
10.8.4472drafting +Casting across protected inheritance +
10.8.41007NAD +Protected access and pointers to members +
10.8.41883drafting +Protected access to constructors in mem-initializers +
10.8.42187drafting +Protected members and access via qualified-id +
10.8.42244open +Base class access in aggregate initialization +
10.8.710CD1 +Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class? +
10.8.745CD1 +Access to nested classes +
10.9510CD1 +Default initialization of POD classes? +
10.9542CD2 +Value initialization of arrays of POD-structs +
10.9.1363NAD +Initialization of class from self +
10.9.2235TC1 +Assignment vs initialization +
10.9.2257CD2 +Abstract base constructors and virtual base initialization +
10.9.2607open +Lookup of mem-initializer-ids +
10.9.2655C++11 +Initialization not specified for forwarding constructors +
10.9.2838C++11 +Use of this in a brace-or-equal-initializer +
10.9.2888CD2 +Union member initializers +
10.9.21242C++11 +Initializing variant class members +
10.9.21345CD3 +Initialization of anonymous union class members +
10.9.21562C++14 +Non-static data member initializers and union ctor-initializer +
10.9.21621drafting +Member initializers in anonymous unions +
10.9.21641NAD +Assignment in member initializer +
10.9.21649C++14 +Error in the syntax of mem-initializer-list +
10.9.21752CD4 +Right-recursion in mem-initializer-list +
10.9.21915extension +Potentially-invoked destructors in non-throwing constructors +
10.9.22056drafting +Member function calls in partially-initialized class objects +
10.9.22135NAD +mem-initializers for virtual bases of abstract classes +
10.9.22204NAD +Naming delegated constructors +
10.9.22227DRWP +Destructor access and default member initializers +
10.9.22317DR +Self-referential default member initializers +
10.9.4307NAD +Initialization of a virtual base class subobject +
10.9.4710CD2 +Data races during construction +
10.9.41202C++11 +Calling virtual functions during destruction +
10.9.41517drafting +Unclear/missing description of behavior during construction/destruction +
10.9.41855dup +Out-of-lifetime access to nonstatic data members +
10.11255drafting +Placement deallocation functions and lookup ambiguity +
111016C++11 +Overloadable declarations, function templates, and references +
11.11252drafting +Overloading member function templates based on dependent return type +
11.21898drafting +Use of “equivalent” in overload resolution +
11.3999CD2 +“Implicit” or “implied” object argument/parameter? +
11.3.12290DRWP +Unclear specification for overload resolution and deleted special member functions +
11.3.12356DRWP +Base class copy and move constructors should not be inherited +
11.3.1.1162CD1 +(&C::f)() with nonstatic members +
11.3.1.1704CD2 +To which postfix-expressions does overload resolution apply? +
11.3.1.1.1239CD1 +Footnote 116 and Koenig lookup +
11.3.1.1.1364CD1 +Calling overloaded function with static in set, with no object +
11.3.1.1.11278drafting +Incorrect treatment of contrived object +
11.3.1.1.2280CD1 +Access and surrogate call functions +
11.3.1.1.22189open +Surrogate call template +
11.3.1.2102NAD +Operator lookup rules do not work well with parts of the library +
11.3.1.2416CD1 +Class must be complete to allow operator lookup? +
11.3.1.2423NAD +Can a conversion be done on the left operand of a compound assignment? +
11.3.1.2545open +User-defined conversions and built-in operator overload resolution +
11.3.1.21385CD3 +Syntactic forms of conversion functions for surrogate call functions +
11.3.1.21608C++14 +Operator lookup in trailing return type +
11.3.1.21687C++14 +Conversions of operands of built-in operators +
11.3.1.21919open +Overload resolution for ! with explicit conversion operator +
11.3.1.22007drafting +Argument-dependent lookup for operator= +
11.3.1.22089drafting +Restricting selection of builtin overloaded operators +
11.3.1.3604CD2 +Argument list for overload resolution in copy-initialization +
11.3.1.459TC1 +Clarification of overloading and UDC to reference type +
11.3.1.4899CD2 +Explicit conversion functions in direct class initialization +
11.3.1.41087C++11 +Additional applications of issue 899 +
11.3.1.41556CD3 +Constructors and explicit conversion functions in direct initialization +
11.3.1.41750CD4 +“Argument” vs “parameter” +
11.3.1.51781DRWP +Converting from nullptr_t to bool in overload resolution +
11.3.1.61373dup +Overload resolution changes matching reference-binding changes +
11.3.1.61392CD3 +Explicit conversion functions for references and non-references +
11.3.1.62028drafting +Converting constructors in rvalue reference initialization +
11.3.1.62108drafting +Conversions to non-class prvalues in reference initialization +
11.3.1.71151C++11 +Overload resolution with initializer-list and non-list constructors +
11.3.1.71228NAD +Copy-list-initialization and explicit constructors +
11.3.1.71229C++11 +Overload resolution with empty braced-init-list argument +
11.3.1.71758CD4 +Explicit conversion in copy/move list initialization +
11.3.1.72194review +Impossible case in list initialization +
11.3.1.72311open +Missed case for guaranteed copy elision +
11.3.1.82376drafting +Class template argument deduction with array declarator +
11.3.2641CD2 +Overload resolution and conversion-to-same-type operators +
11.3.2877CD2 +Viable functions and binding references to rvalues +
11.3.21152C++11 +Rules for determining existence of implicit conversion sequence +
11.3.22377NAD +Explicit copy constructor vs function viability +
11.3.351TC1 +Overloading and user-defined conversions +
11.3.3418open +Imperfect wording on error on multiple default arguments on a called function +
11.3.3455drafting +Partial ordering and non-deduced arguments +
11.3.3495CD2 +Overload resolution with template and non-template conversion functions +
11.3.3.184TC1 +Overloading and conversion loophole used by auto_ptr +
11.3.3.1978CD2 +Incorrect specification for copy initialization +
11.3.3.11673C++14 +Clarifying overload resolution for the second step of copy-initialization +
11.3.3.11902CD4 +What makes a conversion “otherwise ill-formed”? +
11.3.3.12076CD4 +List-initialization of arguments for constructor parameters +
11.3.3.12291dup +Implicit conversion sequences in non-call contexts +
11.3.3.12304NAD +Incomplete type vs overload resolution +
11.3.3.12319drafting +Nested brace initialization from same type +
11.3.3.1.2243NAD +Weighting of conversion functions in direct-initialization +
11.3.3.1.460CD1 +Reference binding and valid conversion sequences +
11.3.3.1.4953CD2 +Rvalue references and function viability +
11.3.3.1.41205dup +Lvalue reference binding and function viability +
11.3.3.1.42077drafting +Overload resolution and invalid rvalue-reference initialization +
11.3.3.1.51307C++14 +Overload resolution based on size of array initializer-list +
11.3.3.1.51409CD3 +What is the second standard conversion sequence of a list-initialization sequence? +
11.3.3.1.51536drafting +Overload resolution with temporary from initializer list +
11.3.3.1.51543CD3 +Implicit conversion sequence for empty initializer list +
11.3.3.1.51631CD4 +Incorrect overload resolution for single-element initializer-list +
11.3.3.1.52075CD4 +Passing short initializer lists to array reference parameters +
11.3.3.1.52169extension +Narrowing conversions and overload resolution +
11.3.3.283TC1 +Overloading and deprecated conversion of string literal +
11.3.3.2153TC1 +Misleading wording (rank of conversion) +
11.3.3.2702CD2 +Preferring conversion to std::initializer_list +
11.3.3.2961CD2 +Overload resolution and conversion of std::nullptr_t to bool +
11.3.3.21079C++11 +Overload resolution involving aggregate initialization +
11.3.3.21238C++11 +Overloading ambiguity binding reference to function +
11.3.3.21298CD3 +Incorrect example in overload resolution +
11.3.3.21374CD3 +Qualification conversion vs difference in reference binding +
11.3.3.21408CD3 +What is “the same aggregate initialization?” +
11.3.3.21410CD3 +Reference overload tiebreakers should apply to rvalue references +
11.3.3.21459open +Reference-binding tiebreakers in overload resolution +
11.3.3.21589CD4 +Ambiguous ranking of list-initialization sequences +
11.3.3.21789drafting +Array reference vs array decay in overload resolution +
11.3.3.21950NAD +Restructuring description of ranks of conversion sequences +
11.3.3.22110drafting +Overload resolution for base class conversion and reference/non-reference +
11.3.3.22277DRWP +Ambiguity inheriting constructors with default arguments +
11.3.3.22337open +Incorrect implication of logic ladder for conversion sequence tiebreakers +
11.461NAD +Address of static member function "&p->f" +
11.4115CD1 +Address of template-id +
11.4202TC1 +Use of overloaded function name +
11.4247NAD +Pointer-to-member casts and function overload resolution +
11.4250TC1 +Address of function template specialization with non-deduced template arguments +
11.41038open +Overload resolution of &x.static_func +
11.41153C++11 +Type matching in address of overloaded function +
11.41563CD3 +List-initialization and overloaded function disambiguation +
11.51989drafting +Insufficient restrictions on parameters of postfix operators +
11.52052CD4 +Template argument deduction vs overloaded operators +
11.5.21549open +Overloaded comma operator with void operand +
11.5.3221CD1 +Must compound assignment operators be member functions? +
11.5.6420CD1 +postfixexpression->scalar_type_dtor() inconsistent +
11.5.71481CD3 +Increment/decrement operators with reference parameters +
11.5.8935CD2 +Missing overloads for character types for user-defined literals +
11.5.81473CD3 +Syntax of literal-operator-id +
11.5.81479CD3 +Literal operators and default arguments +
11.5.81620open +User-defined literals and extended integer types +
11.5.81762C++14 +Reserved identifier used in literal-operator-id example +
11.627NAD +Overload ambiguities for builtin ?: prototypes +
11.6260open +User-defined conversions and built-in operator= +
11.6425CD1 +Set of candidates for overloaded built-in operator with float operand +
11.6507dup +Ambiguity assigning class object to built-in type +
11.6749CD2 +References to function types with a cv-qualifier or ref-qualifier +
11.6878concepts +Effective class types in built-in pointer-to-member operator +
11.6879CD2 +Missing built-in comparison operators for pointer types +
11.6880CD2 +Built-in conditional operator for scoped enumerations +
11.6954open +Overload resolution of conversion operator templates with built-in types +
1232TC1 +Clarification of explicit instantiation of non-exported templates +
1272dup +Linkage and storage class specifiers for templates +
12105TC1 +Meaning of "template function" +
12110open +Can template functions and classes be declared in the same scope? +
12134TC1 +Template classes and declarator-ids +
12204CD1 +Exported class templates +
12205drafting +Templates and static data members +
12323CD1 +Where must export appear? +
12335CD1 +Allowing export on template members of nontemplate classes +
12534CD1 +template-names and operator-function-ids +
12728extension +Restrictions on local classes +
12820CD2 +Deprecation of export +
12821concepts +Exported concept map templates? +
12822NAD +Additional contexts for template aliases +
121009C++11 +Missing cases in the declarator-id of a function template declaration +
121096C++11 +Missing requirement for template definitions +
121303NAD +C language linkage for template with internal linkage +
121463extension +extern "C" alias templates +
12.121TC1 +Can a default argument for a template parameter appear in a friend declaration? +
12.149TC1 +Restriction on non-type, non-value template arguments +
12.1184CD1 +Default arguments in template template-parameters +
12.1187TC1 +Scope of template parameter names +
12.1215CD1 +Template parameters are not allowed in nested-name-specifiers +
12.1226CD1 +Default template arguments for function templates +
12.1401CD1 +When is access for template parameter default arguments checked? +
12.1691C++11 +Template parameter packs in class template partial specializations +
12.1778C++11 +Template parameter packs in non-type template parameters +
12.1840CD2 +Rvalue references as nontype template parameters +
12.1881concepts +Inconsistent requirement for naming template parameters +
12.11006C++11 +std::nullptr_t as a non-type template parameter +
12.11068C++11 +Template aliases with default arguments and template parameter packs +
12.11179NAD +Cv-qualification of non-type template parameters +
12.11246C++11 +Non-deduced non-final parameter packs +
12.11275CD3 +Incorrect comment in example of template parameter pack restriction +
12.11319NAD +Error in pack expansion example +
12.11444drafting +Type adjustments of non-type template parameters +
12.11635drafting +How similar are template default arguments to function default arguments? +
12.11643extension +Default arguments for template parameter packs +
12.11874CD4 +Type vs non-type template parameters with class keyword +
12.11904NAD +Default template arguments for members of class templates +
12.12032CD4 +Default template-arguments of variable templates +
12.12178NAD +Substitution of dependent template arguments in default template arguments +
12.12343extension +void* non-type template parameters +
12.12383NAD +Variadic member functions of variadic class templates +
12.12395open +Parameters following a pack expansion +
12.230TC1 +Valid uses of "::template" +
12.238TC1 +Explicit template arguments and operator functions +
12.296C++11 +Syntactic disambiguation using the template keyword +
12.2228CD1 +Use of template keyword with non-member templates +
12.2301CD1 +Syntax for template-name +
12.2314C++17 +template in base class specifier +
12.2343C++17 +Make template optional in contexts that require a type +
12.2431C++11 +Defect in wording in 14.2 +
12.2468CD1 +Allow ::template outside of templates +
12.2552NAD +Use of typename in the type in a non-type parameter-declaration +
12.2579open +What is a “nested” > or >>? +
12.2867concepts +Naming a specialization of a constrained template +
12.2868concepts +Specifying a concept map in the name of a specialization +
12.21478drafting +template keyword for dependent template template arguments +
12.21794C++17 +template keyword and alias templates +
12.21812C++17 +Omission of template in a typename-specifier +
12.22292DRWP +simple-template-id is ambiguous between class-name and type-name +
12.3246CD1 +Jumps in function-try-block handlers +
12.3372CD1 +Is access granted by base class specifiers available in following base class specifiers? +
12.3440open +Allow implicit pointer-to-member conversion on nontype template argument +
12.32008CD4 +Default template-arguments underspecified +
12.32105open +When do the arguments for a parameter pack end? +
12.3.162CD1 +Unnamed members of classes used as type parameters +
12.3.12106CD4 +Unclear restrictions on use of function-type template arguments +
12.3.2100TC1 +Clarify why string literals are not allowed as template arguments +
12.3.2354CD1 +Null as nontype template argument +
12.3.2773C++11 +Parentheses in address non-type template arguments +
12.3.2823CD2 +Literal types with constexpr conversions as non-type template arguments +
12.3.21023dup +thread_local objects as non-type template arguments +
12.3.21025C++11 +Use of a reference as a non-type template argument +
12.3.21154C++11 +Address of thread_local variable as non-type template argument +
12.3.21155C++11 +Internal-linkage non-type template arguments +
12.3.21398CD3 +Non-type template parameters of type std::nullptr_t +
12.3.21451extension +Objects with no linkage in non-type template arguments +
12.3.21570C++14 +Address of subobject as non-type template argument +
12.3.21666C++14 +Address constant expressions +
12.3.22043drafting +Generalized template arguments and array-to-pointer decay +
12.3.22049drafting +List initializer in non-type template default argument +
12.3.22401open +Array decay vs prohibition of subobject non-type arguments +
12.3.3150C++17 +Template template parameters and default arguments +
12.3.3744CD2 +Matching template arguments with template template parameters with parameter packs +
12.3.3849concepts +Constraints and template template parameters +
12.3.31592C++14 +When do template parameters match? +
12.3.32057drafting +Template template arguments with default arguments +
12.3.32398open +Template template parameter matching and deduction +
12.5603CD1 +Type equivalence and unsigned overflow +
12.5679CD1 +Equivalence of template-ids and operator function templates +
12.51244C++11 +Equivalence of alias templates and class templates +
12.52037drafting +Alias templates and template declaration matching +
12.52064CD4 +Conflicting specifications for dependent decltype-specifiers +
12.61729drafting +Matching declarations and definitions of variable templates +
12.61730drafting +Can a variable template have an unnamed type? +
12.6.1824concepts +Constrained special member functions +
12.6.1843concepts +Unclear interaction of constraints and special member functions +
12.6.11206C++11 +Defining opaque enumeration members of class templates +
12.6.12062drafting +Class template redeclaration requirements +
12.6.1.1249TC1 +What is a member function template? +
12.6.1.11245C++11 +Matching declarations involving decltype +
12.6.1.3408CD2 +sizeof applied to unknown-bound array static data member of template +
12.6.2114NAD +Virtual overriding by template member function specializations +
12.6.2582CD1 +Template conversion functions +
12.6.31002NAD +Pack expansion for function arguments +
12.6.31032C++11 +Empty pack expansions +
12.6.31182C++11 +Incorrect description of pack expansion syntax +
12.6.31231C++11 +Variadic templates requiring an empty pack expansion +
12.6.31393extension +Pack expansions in using-declarations +
12.6.31432drafting +Newly-ambiguous variadic template expansions +
12.6.31519NAD +Conflicting default and variadic constructors +
12.6.31533CD3 +Function pack expansion for member initialization +
12.6.32391DUP +Additional template parameters following pack expansion +
12.6.447NAD +Template friend issues +
12.6.4329CD1 +Evaluation of friends of templates +
12.6.4410CD1 +Paragraph missed in changes for issue 166 +
12.6.4638CD2 +Explicit specialization and friendship +
12.6.4674C++11 +“matching specialization” for a friend declaration +
12.6.41545drafting +friend function templates defined in class templates +
12.6.41804CD4 +Partial specialization and friendship +
12.6.41862DRWP +Determining “corresponding members” for friendship +
12.6.41918open +friend templates with dependent scopes +
12.6.41945open +Friend declarations naming members of class templates in non-templates +
12.6.42174C++17 +Unclear rules for friend definitions in templates +
12.6.42261extension +Explicit instantiation of in-class friend definition +
12.6.42306NAD +Nested friend templates of class templates +
12.6.42379DR +Missing prohibition against constexpr in friend declaration +
12.6.5229NAD +Partial specialization of function templates +
12.6.5286CD1 +Incorrect example in partial specialization +
12.6.5517CD1 +Partial specialization following explicit instantiation +
12.6.5708open +Partial specialization of member templates of class templates +
12.6.5996C++11 +Ambiguous partial specializations of member class templates +
12.6.51315CD4 +Restrictions on non-type template arguments in partial specializations +
12.6.51495CD3 +Partial specialization of variadic class template +
12.6.51577NAD +Unnecessary restrictions on partial specializations +
12.6.51647drafting +Type agreement of non-type template arguments in partial specializations +
12.6.51711drafting +Missing specification of variable template partial specializations +
12.6.51754NAD +Declaration of partial specialization of static data member template +
12.6.51819CD4 +Acceptable scopes for definition of partial specialization +
12.6.52033CD4 +Redundant restriction on partial specialization argument +
12.6.52127drafting +Partial specialization and nullptr +
12.6.52173open +Partial specialization with non-deduced contexts +
12.6.52179drafting +Required diagnostic for partial specialization after first use +
12.6.5.1549drafting +Non-deducible parameters in partial specializations +
12.6.5.12035CD3 +Multi-section example is confusing +
12.6.5.31755drafting +Out-of-class partial specializations of member templates +
12.6.6.1116TC1 +Equivalent and functionally-equivalent function templates +
12.6.6.1310open +Can function templates differing only in parameter cv-qualifiers be overloaded? +
12.6.6.11321CD3 +Equivalency of dependent calls +
12.6.6.11644open +Equivalent exception-specifications in function template declarations +
12.6.6.12021dup +Function template redeclaration via alias template +
12.6.6.12025dup +Declaration matching via alias templates +
12.6.6.12045drafting +“Identical” template parameter lists +
12.6.6.223NAD +Some questions regarding partial ordering of function templates +
12.6.6.2200dup +Partial ordering and explicit arguments +
12.6.6.2214CD1 +Partial ordering of function templates is underspecified +
12.6.6.2402open +More on partial ordering of function templates +
12.6.6.2532C++11 +Member/nonmember operator template partial ordering +
12.6.6.21156C++11 +Partial ordering in a non-call context +
12.6.6.21157open +Partial ordering of function templates is still underspecified +
12.6.6.21235C++11 +“Unused” ellipsis and default arguments in partial ordering +
12.6.6.21406CD3 +ref-qualifiers and added parameters of non-static member function templates +
12.6.6.21446CD4 +Member function with no ref-qualifier and non-member function with rvalue reference +
12.6.6.22160open +Issues with partial ordering +
12.6.6.22373DRWP +Incorrect handling of static member function templates in partial ordering +
12.6.7851concepts +Constraints and template aliases +
12.6.7929CD2 +What is a template alias? +
12.6.71056C++11 +Template aliases, member definitions, and the current instantiation +
12.6.71158C++11 +Recursive instantiation via alias template +
12.6.71159C++11 +Class and enumeration definitions in template aliases +
12.6.71286drafting +Equivalence of alias templates +
12.6.71349dup +Consistency of alias template redeclarations +
12.6.71430drafting +Pack expansion into fixed alias template parameter list +
12.6.71520NAD +Alias template specialization vs pack expansion +
12.6.71554drafting +Access and alias templates +
12.6.71558CD4 +Unused arguments in alias template specializations +
12.6.71896drafting +Repeated alias templates +
12.6.71979drafting +Alias template specialization in template member definition +
12.6.71980drafting +Equivalent but not functionally-equivalent redeclarations +
12.6.72236drafting +When is an alias template specialization dependent? +
12.7120TC1 +Nonexistent non-terminal qualified-name +
12.7121TC1 +Dependent type names with non-dependent nested-name-specifiers +
12.7180CD1 +typename and elaborated types +
12.7183TC1 +typename in explicit specializations +
12.7345CD1 +Misleading comment on example in templates chapter +
12.7375dup +Confusing example on lookup with typename +
12.7382CD1 +Allow typename outside of templates +
12.7409CD1 +Obsolete paragraph missed by changes for issue 224 +
12.7559CD1 +Editing error in issue 382 resolution +
12.7560drafting +Use of the typename keyword in return types +
12.7666CD1 +Dependent qualified-ids without the typename keyword +
12.71161C++11 +Dependent nested-name-specifier in a pointer-to-member declarator +
12.71162NAD +Dependent elaborated-type-specifiers in non-deduced contexts +
12.71257open +Instantiation via non-dependent references in uninstantiated templates +
12.71271DRWP +Imprecise wording regarding dependent types +
12.71296CD3 +Ill-formed template declarations (not just definitions) +
12.71483NAD +Non-dependent static_assert-declarations +
12.71547NAD +typename keyword in alias-declarations +
12.71785NAD +Conflicting diagnostic requirements for template definitions +
12.71850CD4 +Differences between definition context and point of instantiation +
12.71974open +Redundant specification of non-type typename-specifier +
12.72067open +Generated variadic templates requiring empty pack +
12.7.1186open +Name hiding and template template-parameters +
12.7.1316NAD +Injected-class-name of template used as template template parameter +
12.7.1448C++11 +Set of template functions in call with dependent explicit argument +
12.7.1458C++11 +Hiding of member template parameters by other members +
12.7.1459open +Hiding of template parameters by base class members +
12.7.1602C++11 +When is the injected-class-name of a class template a template? +
12.7.11004C++11 +Injected-class-names as arguments for template template parameters +
12.7.11841drafting +< following template injected-class-name +
12.7.11922CD4 +Injected class template names and default arguments +
12.7.2213TC1 +Lookup in dependent base classes +
12.7.2515CD1 +Non-dependent references to base class members +
12.7.2524CD1 +Can function-notation calls to operator functions be dependent? +
12.7.2544NAD +Base class lookup in explicit specialization +
12.7.2588CD2 +Searching dependent bases of classes local to function templates +
12.7.2591CD4 +When a dependent base class is the current instantiation +
12.7.21233C++11 +Pack expansions and dependent calls +
12.7.21292CD4 +Dependent calls with braced-init-lists containing a pack expansion +
12.7.21526dup +Dependent-class lookup in the current instantiation +
12.7.21936drafting +Dependent qualified-ids +
12.7.22101CD4 +Incorrect description of type- and value-dependence +
12.7.2.1108TC1 +Are classes nested in templates dependent? +
12.7.2.1224CD1 +Definition of dependent names +
12.7.2.1502C++11 +Dependency of nested enumerations and enumerators +
12.7.2.1590C++11 +Nested classes and the “current instantiation” +
12.7.2.11043C++11 +Qualified name lookup in the current instantiation +
12.7.2.11057C++11 +decltype and the current instantiation +
12.7.2.11160C++11 +Definitions of template members and the current instantiation +
12.7.2.11281NAD +Virtual and dependent base classes +
12.7.2.11289NAD +Can an alias template name the current instantiation? +
12.7.2.11309CD4 +Incorrect note regarding lookup of a member of the current instantiation +
12.7.2.11390drafting +Dependency of alias template specializations +
12.7.2.11471CD3 +Nested type of non-dependent base +
12.7.2.11524drafting +Incompletely-defined class template base +
12.7.2.11619open +Definition of current instantiation +
12.7.2.11737C++14 +Type dependence of call to a member of the current instantiation +
12.7.2.11829open +Dependent unnamed types +
12.7.2.11905MAD +Dependent types and injected-class-names +
12.7.2.11988CD4 +Ambiguity between dependent and non-dependent bases in implicit member access +
12.7.2.12024CD4 +Dependent types and unexpanded parameter packs +
12.7.2.12065drafting +Current instantiation of a partial specialization +
12.7.2.12074drafting +Type-dependence of local class of function template +
12.7.2.12143C++17 +Value-dependency via injected-class-name +
12.7.2.12266DR +Has dependent type vs is type-dependent +
12.7.2.12307DRWP +Unclear definition of “equivalent to a nontype template parameter” +
12.7.2.2334NAD +Is a comma-expression dependent if its first operand is? +
12.7.2.2541CD2 +Dependent function types +
12.7.2.21779CD4 +Type dependency of __func__ +
12.7.2.22275drafting +Type-dependence of function template +
12.7.2.22294DRWP +Dependent auto static data members +
12.7.2.3447CD1 +Is offsetof type-dependent? +
12.7.2.3903CD3 +Value-dependent integral null pointer constants +
12.7.2.31047C++11 +When is typeid value-dependent? +
12.7.2.31074C++11 +Value-dependent noexcept-expressions +
12.7.2.31088C++11 +Dependent non-type template arguments +
12.7.2.31413CD3 +Missing cases of value-dependency +
12.7.2.31899CD4 +Value-dependent constant expressions +
12.7.2.32066CD4 +Does type-dependent imply value-dependent? +
12.7.2.32100C++17 +Value-dependent address of static data member of class template +
12.7.2.32109CD4 +Value dependence underspecified +
12.7.2.32276C++17 +Dependent noexcept and function type-dependence +
12.7.2.42090drafting +Dependency via non-dependent base class +
12.7.3206TC1 +Semantic constraints on non-dependent names +
12.7.42drafting +How can dependent names be used in member declarations that appear outside of the class template definition? +
12.7.422TC1 +Template parameter with a default argument that refers to itself +
12.7.41028open +Dependent names in non-defining declarations +
12.7.4.1287drafting +Order dependencies in template instantiation +
12.7.4.1993C++11 +Freedom to perform instantiation at the end of the translation unit +
12.7.4.11258drafting +“Instantiation context” differs from dependent lookup rules +
12.7.4.11845drafting +Point of instantiation of a variable template specialization +
12.7.4.12245drafting +Point of instantiation of incomplete class template +
12.7.4.12250open +Implicit instantiation, destruction, and TUs +
12.7.4.2197CD1 +Issues with two-stage lookup of dependent names +
12.7.4.2561CD2 +Internal linkage functions in dependent name lookup +
12.7.4.21500open +Name lookup of dependent conversion function +
12.7.5387CD1 +Errors in example in 14.6.5 +
12.7.52118open +Stateful metaprogramming via friend injection +
12.8259CD1 +Restrictions on explicit specialization and instantiation +
12.81253drafting +Generic non-template members +
12.82255DRWP +Instantiated static data member templates +
12.82330DR +Missing references to variable templates +
12.8.134NAD +Argument dependent lookup and points of instantiation +
12.8.163CD1 +Class instantiation from pointer conversion to void*, null and self +
12.8.1212CD4 +Implicit instantiation is not described clearly enough +
12.8.1489NAD +Must member function templates be instantiated during overload resolution? +
12.8.1525CD1 +Missing * in example +
12.8.11378open +When is an instantiation required? +
12.8.11396drafting +Deferred instantiation and checking of non-static data member initializers +
12.8.11484CD4 +Unused local classes of function templates +
12.8.11602open +Linkage of specialization vs linkage of template arguments +
12.8.11856open +Indirect nested classes of class templates +
12.8.12072drafting +Default argument instantiation for member functions of templates +
12.8.12202drafting +When does default argument instantiation occur? +
12.8.12222drafting +Additional contexts where instantiation is not required +
12.8.12263drafting +Default argument instantiation for friends +
12.8.12265drafting +Delayed pack expansion and member redeclarations +
12.8.246NAD +Explicit instantiation of member templates +
12.8.2237CD1 +Explicit instantiation and base class members +
12.8.2293open +Syntax of explicit instantiation/specialization too permissive +
12.8.2470CD1 +Instantiation of members of an explicitly-instantiated class template +
12.8.2546C++11 +Explicit instantiation of class template members +
12.8.2551CD1 +When is inline permitted in an explicit instantiation? +
12.8.2969CD2 +Explicit instantiation declarations of class template specializations +
12.8.2980CD2 +Explicit instantiation of a member of a class template +
12.8.2995CD2 +Incorrect example for using-declaration and explicit instantiation +
12.8.21045NAD +Requiring explicit instantiation declarations +
12.8.21046open +What is a “use” of a class specialization? +
12.8.21163NAD +extern template prevents inlining functions not marked inline +
12.8.21196C++11 +Definition required for explicit instantiation after explicit specialization? +
12.8.21532CD3 +Explicit instantiation and member templates +
12.8.21665drafting +Declaration matching in explicit instantiations +
12.8.21704DRWP +Type checking in explicit instantiation of variable templates +
12.8.21728DRWP +Type of an explicit instantiation of a variable template +
12.8.22161NAD +Explicit instantiation declaration and “preceding initialization” +
12.8.22270extension +Non-inline functions and explicit instantiation declarations +
12.8.22305DRWP +Explicit instantiation of constexpr or inline variable template +
12.8.33NAD +The template compilation model rules render some explicit specialization declarations not visible during instantiation +
12.8.324TC1 +Errors in examples in 14.7.3 +
12.8.344CD1 +Member specializations +
12.8.364TC1 +Partial ordering to disambiguate explicit specialization +
12.8.388NAD +Specialization of member constant templates +
12.8.3182NAD +Access checking on explicit specializations +
12.8.3275CD1 +Explicit instantiation/specialization and using-directives +
12.8.3285NAD +Identifying a function template being specialized +
12.8.3336CD1 +Explicit specialization examples are still incorrect +
12.8.3529drafting +Use of template<> with “explicitly-specialized” class templates +
12.8.3531C++11 +Defining members of explicit specializations +
12.8.3605C++11 +Linkage of explicit specializations +
12.8.3621C++11 +Template argument deduction from function return types +
12.8.3727C++17 +In-class explicit specializations +
12.8.3730CD2 +Explicit specializations of members of non-template classes +
12.8.3884CD2 +Defining an explicitly-specialized static data member +
12.8.3923CD2 +Inline explicit specializations +
12.8.3941C++11 +Explicit specialization of deleted function template +
12.8.31727NAD +Type of a specialization of a variable template +
12.8.31792NAD +Incorrect example of explicit specialization of member enumeration +
12.8.31840drafting +Non-deleted explicit specialization of deleted function template +
12.8.31876extension +Preventing explicit specialization +
12.8.31993drafting +Use of template<> defining member of explicit specialization +
12.8.31994dup +Confusing wording regarding multiple template<> prefixes +
12.8.32041CD4 +Namespace for explicit class template specialization +
12.8.32138NAD +Explicit member specialization vs implicit instantiation +
12.8.32260DRWP +Explicit specializations of deleted member functions +
12.9.1241TC1 +Error in example in 14.8.1 +
12.9.1264open +Unusable template constructors and conversion functions +
12.9.1581DR +Can a templated constructor be explicitly instantiated or specialized? +
12.9.11386NAD +Explicitly-specified partial argument list with multiple parameter packs +
12.9.11391CD4 +Conversions to parameter types with non-deduced template arguments +
12.9.11982NAD +Deduction extending parameter pack +
12.9.12055drafting +Explicitly-specified non-deduced parameter packs +
12.9.12200NAD +Conversions in template argument deduction +
12.9.2271open +Explicit instantiation and template argument deduction +
12.9.2297open +Which template does an explicit specialization specialize? +
12.9.2337CD1 +Attempt to create array of abtract type should cause deduction to fail +
12.9.2368CD1 +Uses of non-type parameters that should cause deduction to fail +
12.9.2398CD1 +Ambiguous wording on naming a type in deduction +
12.9.2486CD1 +Invalid return types and template argument deduction +
12.9.2488CD1 +Local types, overload resolution, and template argument deduction +
12.9.2575C++11 +Criteria for deduction failure +
12.9.2657CD2 +Abstract class parameter in synthesized declaration +
12.9.2662NAD +Forming a pointer to a reference type +
12.9.2697open +Deduction rules apply to more than functions +
12.9.2709C++11 +Enumeration names as nested-name-specifiers in deduction failure +
12.9.21170C++11 +Access checking during template argument deduction +
12.9.21172drafting +“instantiation-dependent” constructs +
12.9.21227CD3 +Mixing immediate and non-immediate contexts in deduction failure +
12.9.21262CD3 +Default template arguments and deduction failure +
12.9.21273NAD +Accessibility and function signatures +
12.9.21322drafting +Function parameter type decay in templates +
12.9.21330CD3 +Delayed instantiation of noexcept specifiers +
12.9.21462CD3 +Deduction failure vs “ill-formed, no diagnostic required” +
12.9.21546NAD +Errors in function template default arguments +
12.9.21582drafting +Template default arguments and deduction failure +
12.9.21724drafting +Unclear rules for deduction failure +
12.9.21809CD4 +Narrowing and template argument deduction +
12.9.21844drafting +Defining “immediate context” +
12.9.22054open +Missing description of class SFINAE +
12.9.22296extension +Are default argument instantiation failures in the “immediate context”? +
12.9.22322DRWP +Substitution failure and lexical order +
12.9.22369drafting +Ordering between constraints and substitution +
12.9.2.199NAD +Partial ordering, references and cv-qualifiers +
12.9.2.1352CD1 +Nondeduced contexts +
12.9.2.1503open +Cv-qualified function types in template argument deduction +
12.9.2.1522CD1 +Array-to-pointer decay in template argument deduction +
12.9.2.1606CD1 +Template argument deduction for rvalue references +
12.9.2.1847CD2 +Error in rvalue reference deduction example +
12.9.2.1876CD2 +Type references in rvalue reference deduction specification +
12.9.2.11014NAD +Overload resolution between const T& and T&& +
12.9.2.11164C++11 +Partial ordering of f(T&) and f(T&&) +
12.9.2.11184C++11 +Argument conversions to nondeduced parameter types +
12.9.2.11326extension +Deducing an array bound from an initializer-list +
12.9.2.11388CD3 +Missing non-deduced context following a function parameter pack +
12.9.2.11399CD3 +Deduction with multiple function parameter packs +
12.9.2.11513drafting +initializer_list deduction failure +
12.9.2.11584drafting +Deducing function types from cv-qualified types +
12.9.2.11591CD4 +Deducing array bound and element type from initializer list +
12.9.2.11671NAD +Unclear rules for deduction with cv-qualification +
12.9.2.11700NAD +Does the special rvalue-reference deduction apply to alias templates? +
12.9.2.11939drafting +Argument conversions to nondeduced parameter types revisited +
12.9.2.12147CD4 +Initializer-list arguments and pack deduction +
12.9.2.12303DR +Partial ordering and recursive variadic inheritance +
12.9.2.12326dup +Type deduction with initializer list containing ambiguous functions +
12.9.2.21486drafting +Base-derived conversion in member pointer deduction +
12.9.2.3322CD1 +Deduction of reference conversions +
12.9.2.3349CD1 +Template argument deduction for conversion functions and qualification conversions +
12.9.2.3493CD2 +Type deduction from a bool context +
12.9.2.3913CD2 +Deduction rules for array- and function-type conversion functions +
12.9.2.3976CD2 +Deduction for const T& conversion operators +
12.9.2.31372CD3 +Cross-references incorrect in conversion function template argument deduction +
12.9.2.32384DR +Conversion function templates and qualification conversions +
12.9.2.4885NAD +Partial ordering of function templates with unordered parameter pairs +
12.9.2.41221open +Partial ordering and reference collapsing +
12.9.2.41337dup +Partial ordering and non-deduced parameters +
12.9.2.41610drafting +Cv-qualification in deduction of reference to array +
12.9.2.41705CD4 +Unclear specification of “more specialized” +
12.9.2.41825C++17 +Partial ordering between variadic and non-variadic function templates +
12.9.2.42088DRWP +Late tiebreakers in partial ordering +
12.9.2.42235DRWP +Partial ordering and non-dependent types +
12.9.2.42350NAD +Forwarding references and deduction guides +
12.9.2.570CD1 +Is an array bound a nondeduced context? +
12.9.2.5181TC1 +Errors in template template-parameter example +
12.9.2.5300CD1 +References to functions in template argument deduction +
12.9.2.5469NAD +Const template specializations and reference arguments +
12.9.2.5526CD1 +Confusing aspects in the specification of non-deduced contexts +
12.9.2.5586NAD +Default template-arguments and template argument deduction +
12.9.2.5692C++11 +Partial ordering of variadic class template partial specializations +
12.9.2.5873C++11 +Deducing rvalue references in declarative contexts +
12.9.2.51371NAD +Deduction from T&& in return types +
12.9.2.51387CD3 +Missing non-deduced context for decltype +
12.9.2.51395C++17 +Partial ordering of variadic templates reconsidered +
12.9.2.51569C++14 +Deducing a function parameter pack before ellipsis +
12.9.2.51763open +Length mismatch in template type deduction +
12.9.2.51770C++14 +Type matching of non-type template parameters and arguments +
12.9.2.51847CD4 +Clarifying compatibility during partial ordering +
12.9.2.52091CD4 +Deducing reference non-type template arguments +
12.9.2.52318DR +Nondeduced contexts in deduction from a braced-init-list +
12.9.2.52328drafting +Unclear presentation style of template argument deduction rules +
12.9.2.52355extension +Deducing noexcept-specifiers +
12.9.2.61178C++11 +Deduction failure matching placement new +
12.9.3415CD1 +Template deduction does not cause instantiation +
12.9.3947NAD +Deducing type template arguments from default function arguments +
12.9.32092DRWP +Deduction failure and overload resolution +
1398TC1 +Branching into try block +
13211NAD +Constructors should not be allowed to return normally after an exception +
131431CD3 +Exceptions from other than throw-expressions +
13.1104NAD +Destroying the exception temp when no handler is found +
13.1208CD1 +Rethrowing exceptions in nested handlers +
13.1428CD1 +Mention of expression with reference type +
13.1479CD1 +Copy elision in exception handling +
13.1499CD2 +Throwing an array of unknown size +
13.1828CD2 +Destruction of exception objects +
13.11503CD3 +Exceptions during copy to exception object +
13.11667NAD +Function exiting via exception called by destructor during unwinding +
13.11863CD4 +Requirements on thrown object type to support std::current_exception() +
13.2592CD1 +Exceptions during construction of local static objects +
13.21165C++11 +Exceptions when destroying array elements +
13.21424C++14 +When must sub-object destructors be accessible? +
13.21624NAD +Destruction of union members with member initializers +
13.21774CD4 +Discrepancy between subobject destruction and stack unwinding +
13.21807CD4 +Order of destruction of array elements after an exception +
13.21866CD4 +Initializing variant members with non-trivial destructors +
13.22209NAD +Destruction of constructed array elements +
13.22210NAD +Principal/target constructor confusion +
13.3210TC1 +What is the type matched by an exception handler? +
13.3308NAD +Catching exceptions with ambiguous base classes +
13.3388CD3 +Catching base*& from a throw of derived* +
13.3593NAD +Falling off the end of a destructor's function-try-block handler +
13.3729CD3 +Qualification conversions and handlers of reference-to-pointer type +
13.3971C++11 +Incorrect treatment of exception-declarations +
13.31166C++11 +exception-declarations that do not declare objects +
13.31218C++11 +What is the “currently-handled exception” in a multi-threaded program? +
13.31769C++14 +Catching a base class of the exception object +
13.32093CD4 +Qualification conversion for pointer-to-member handler matching +
13.32172drafting +Multiple exceptions with one exception object +
13.32219drafting +Dynamically-unreachable handlers +
13.425TC1 +Exception specifications and pointers to members +
13.487CD1 +Exception specifications on function parameters +
13.492CD4 +Should exception-specifications be part of the type system? +
13.4126TC1 +Exception specifications and const +
13.4133dup +Exception specifications and checking +
13.4346NAD +Typo in 15.4 +
13.4595dup +Exception specifications in templates instantiated from class bodies +
13.4829NAD +At what point is std::unexpected called? +
13.4830CD2 +Deprecating exception specifications +
13.4973CD2 +Function types in exception-specifications +
13.41053NAD +Terminate vs undefined behavior for noexcept violation +
13.41073C++11 +Merging dynamic-exception-specifications and noexcept-specifications +
13.41167C++11 +function-try-blocks for destructors +
13.41216C++11 +Exceptions “allowed” by a noexcept-specification +
13.41267CD3 +Rvalue reference types in exception-specifications +
13.41282CD3 +Underspecified destructor exception-specification +
13.41351CD4 +Problems with implicitly-declared exception-specifications +
13.41356CD4 +Exception specifications of copy assignment operators with virtual bases +
13.41381CD3 +Implicitly-declared special member functions and default nothrow +
13.41639CD4 +exception-specifications and pointer/pointer-to-member expressions +
13.41740C++14 +Disambiguation of noexcept +
13.41777CD4 +Empty pack expansion in dynamic-exception-specification +
13.41798NAD +exception-specifications of template arguments +
13.41934extension +Relaxing exception-specification compatibility requirements +
13.41946CD4 +exception-specifications vs pointer dereference +
13.41975CD4 +Permissible declarations for exception-specifications +
13.41995CD4 +exception-specifications and non-type template parameters +
13.42010CD4 +exception-specifications and conversion operators +
13.42039CD4 +Constant conversions to bool +
13.42047CD4 +Coordinating “throws anything” specifications +
13.42183NAD +Problems in description of potential exceptions +
13.42191C++17 +Incorrect result for noexcept(typeid(v)) +
13.42216NAD +Exception specifications in unevaluated contexts +
13.42336DR +Destructor characteristics vs potentially-constructed subobjects +
13.5.1219NAD +Cannot defend against destructors that throw exceptions +
13.5.1668CD2 +Throwing an exception from the destructor of a local static object +
13.5.11168C++11 +Additional reasons to call std::terminate +
13.5.11171C++11 +Partial stack unwinding with noexcept violation +
13.5.237NAD +When is uncaught_exception() true? +
13.5.2475C++11 +When is std::uncaught_exception() true? (take 2) +
13.5.22034NAD +Deprecating uncaught_exception() +
13.5.22098CD4 +Is uncaught_exceptions() per-thread? +
14394CD1 +identifier-list is never defined +
142001CD4 +non-directive is underspecified +
142002open +White space within preprocessing directives +
14.1601CD2 +Type of literals in preprocessing expressions +
14.1618CD2 +Casts in preprocessor conditional expressions +
14.1925open +Type of character literals in preprocessor expressions +
14.11436drafting +Interaction of constant expression changes with preprocessor expressions +
14.11955CD4 +#elif with invalid controlling expression +
14.12190open +Insufficient specification of __has_include +
14.12390drafting +Is the argument of __has_cpp_attribute macro-expanded? +
14.2370CD1 +Can #include <...> form be used other than for standard C++ headers? +
14.2533NAD +Special treatment for C-style header names +
14.21720NAD +Macro invocation in #include directive +
14.31370CD3 +identifier-list cannot contain ellipsis +
14.31718drafting +Macro invocation spanning end-of-file +
14.32003drafting +Zero-argument macros incorrectly specified +
14.3.2626CD2 +Preprocessor string literals +
14.3.21335drafting +Stringizing, extended characters, and universal-character-names +
14.3.21625open +Adding spaces between tokens in stringizing +
14.3.21709drafting +Stringizing raw string literals containing newline +
14.3.4268open +Macro name suppression in rescanned replacement text +
14.5745open +Effect of ill-formedness resulting from #error +
14.61889drafting +Unclear effect of #pragma on conformance +
14.81169C++11 +Missing feature macro for strict pointer safety +
14.9897open +_Pragma and extended string-literals +
16.3.4.12193NAD +numeric_limits<int>::radix and digits +
16.4.11277NAD +Lax definition of intmax_t and uintmax_t +
16.6.2.22014NAD +Unneeded deallocation signatures +
16.6.2.379dup +Alignment and placement new +
16.12.22361open +Unclear description of longjmp undefined behavior +
Annex A266NAD +No grammar sentence symbol +
Annex B831CD2 +Limit on recursively nested template instantiations +
Annex B1329CD3 +Recursive deduction substitutions +
Annex B1675NAD +Size limit for automatic array object +
Annex B1933NAD +Implementation limit for initializer-list elements +
Annex B2181drafting +Normative requirements in an informative Annex +
Annex C81NAD +Null pointers and C compatibility +
Annex C1944open +New C incompatibilities +
Annex D223CD3 +The meaning of deprecation +
C.11248open +Updating Annex C to C99 +
C.1.32184CD4 +Missing C compatibility entry for decrement of bool +
C.21279drafting +Additional differences between C++ 2003 and C++ 2011 +
C.21377dup +Access declarations not mentioned in Annex C +
C.2.22031CD4 +Missing incompatibility for && +
C.42038CD4 +Document C++14 incompatibility of new braced deduction rule +
D.5145TC1 +Deprecation of prefix ++ +
unknown106CD1 +Creating references to references during template deduction/instantiation +
+ + Index: www/cxx_status.html =================================================================== --- www/cxx_status.html +++ www/cxx_status.html @@ -934,7 +934,7 @@ [[no_unique_address]] attribute P0840R2 - No + SVN [[likely]] and [[unlikely]] attributes