diff options
| author | Dimitry Andric <dim@FreeBSD.org> | 2014-11-24 09:15:30 +0000 |
|---|---|---|
| committer | Dimitry Andric <dim@FreeBSD.org> | 2014-11-24 09:15:30 +0000 |
| commit | 9f4dbff6669c8037f3b036bcf580d14f1a4f12a5 (patch) | |
| tree | 47df2c12b57214af6c31e47404b005675b8b7ffc /www | |
| parent | f73d5f23a889b93d89ddef61ac0995df40286bb8 (diff) | |
| download | src-9f4dbff6669c8037f3b036bcf580d14f1a4f12a5.tar.gz src-9f4dbff6669c8037f3b036bcf580d14f1a4f12a5.zip | |
Vendor import of clang RELEASE_350/final tag r216957 (effectively, 3.5.0 release):vendor/clang/clang-release_350-r216957
Notes
Notes:
svn path=/vendor/clang/dist/; revision=274958
svn path=/vendor/clang/clang-release_350-r216957/; revision=274959; tag=vendor/clang/clang-release_350-r216957
Diffstat (limited to 'www')
32 files changed, 7663 insertions, 4258 deletions
diff --git a/www/analyzer/alpha_checks.html b/www/analyzer/alpha_checks.html new file mode 100644 index 000000000000..6f5e4f170801 --- /dev/null +++ b/www/analyzer/alpha_checks.html @@ -0,0 +1,848 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Alpha Checks</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <script type="text/javascript" src="scripts/expandcollapse.js"></script> + <style type="text/css"> + tr:first-child { width:20%; } + </style> +</head> +<body onload="initExpandCollapse()"> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> +<h1>Alpha Checkers</h1> +Experimental checkers in addition to the <a href = "available_checks.html"> +Default Checkers</a>. These are checkers with known issues or limitations that +keep them from being on by default. They are likely to have false positives. +Bug reports are welcome but will likely not be investigated for some time. +Patches welcome! +<ul> +<li><a href="#core_alpha_checkers">Core Alpha Checkers</a></li> +<li><a href="#cplusplus_alpha_checkers">C++ Alpha Checkers</a></li> +<li><a href="#deadcode_alpha_checkers">Dead Code Alpha Checkers</a></li> +<li><a href="#osx_alpha_checkers">OS X Alpha Checkers</a></li> +<li><a href="#security_alpha_checkers">Security Alpha Checkers</a></li> +<li><a href="#unix_alpha_checkers">Unix Alpha Checkers</a></li> +</ul> + +<!------------------------------ core alpha -----------------------------------> +<h3 id="core_alpha_checkers">Core Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.BoolAssignment</span><span class="lang"> +(ObjC)</span><div class="descr"> +Warn about assigning non-{0,1} values to boolean variables.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + BOOL b = -1; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.CastSize</span><span class="lang"> +(C)</span><div class="descr"> +Check when casting a malloc'ed type T, whether the size is a multiple of the +size of T (Works only with <span class="name">unix.Malloc</span> +or <span class="name">alpha.unix.MallocWithAnnotations</span> +checks enabled).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int *x = (int *)malloc(11); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.CastToStruct</span><span class="lang"> +(C, C++)</span><div class="descr"> +Check for cast from non-struct pointer to struct pointer.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +struct s {}; + +void test(int *p) { + struct s *ps = (struct s *) p; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// C++ +class c {}; + +void test(int *p) { + c *pc = (c *) p; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.FixedAddr</span><span class="lang"> +(C)</span><div class="descr"> +Check for assignment of a fixed address to a pointer.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int *p; + p = (int *) 0x10000; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.IdenticalExpr</span><span class="lang"> +(C, C++)</span><div class="descr"> +Warn about suspicious uses of identical expressions.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +void test() { + int a = 5; + int b = a | 4 | a; // warn: identical expr on both sides +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// C++ +bool f(void); + +void test(bool b) { + int i = 10; + if (f()) { // warn: true and false branches are identical + do { + i--; + } while (f()); + } else { + do { + i--; + } while (f()); + } +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.PointerArithm</span><span class="lang"> +(C)</span><div class="descr"> +Check for pointer arithmetic on locations other than array +elements.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + int *p; + p = &x + 1; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.PointerSub</span><span class="lang"> +(C)</span><div class="descr"> +Check for pointer subtractions on two pointers pointing to different memory +chunks.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x, y; + int d = &y - &x; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.core.SizeofPtr</span><span class="lang"> +(C)</span><div class="descr"> +Warn about unintended use of <code>sizeof()</code> on pointer +expressions.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +struct s {}; + +int test(struct s *p) { + return sizeof(p); + // warn: sizeof(ptr) can produce an unexpected result +} +</pre></div></div></td></tr> + +</tbody></table> + +<!--------------------------- cplusplus alpha ---------------------------------> +<h3 id="cplusplus_alpha_checkers">C++ Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.cplusplus.NewDeleteLeaks</span><span class="lang"> +(C++)</span><div class="descr"> +Check for memory leaks. Traces memory managed by <code>new</code>/<code> +delete</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int *p = new int; +} // warn +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.cplusplus.VirtualCall</span><span class="lang"> +(C++)</span><div class="descr"> +Check virtual member function calls during construction or +destruction.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +class A { +public: + A() { + f(); // warn + } + virtual void f(); +}; +</pre></div><div class="separator"></div> +<div class="example"><pre> +class A { +public: + ~A() { + this->f(); // warn + } + virtual void f(); +}; +</pre></div></div></td></tr> + +</tbody></table> + +<!--------------------------- dead code alpha ---------------------------------> +<h3 id="deadcode_alpha_checkers">Dead Code Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.deadcode.UnreachableCode</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check unreachable code.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +int test() { + int x = 1; + while(x); + return x; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// C++ +void test() { + int a = 2; + + while (a > 1) + a--; + + if (a > 1) + a++; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// Objective-C +void test(id x) { + return; + [x retain]; // warn +} +</pre></div></div></td></tr> +</tbody></table> + +<!---------------------------- OS X alpha --------------------------------------> +<h3 id="osx_alpha_checkers">OS X Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.Dealloc</span><span class="lang"> +(ObjC)</span><div class="descr"> +Warn about Objective-C classes that lack a correct implementation +of <code>-dealloc</code>. +</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyObject : NSObject { + id _myproperty; +} +@end + +@implementation MyObject // warn: lacks 'dealloc' +@end +</pre></div><div class="separator"></div> +<div class="example"><pre> +@interface MyObject : NSObject {} +@property(assign) id myproperty; +@end + +@implementation MyObject // warn: does not send 'dealloc' to super +- (void)dealloc { + self.myproperty = 0; +} +@end +</pre></div><div class="separator"></div> +<div class="example"><pre> +@interface MyObject : NSObject { + id _myproperty; +} +@property(retain) id myproperty; +@end + +@implementation MyObject +@synthesize myproperty = _myproperty; + // warn: var was retained but wasn't released +- (void)dealloc { + [super dealloc]; +} +@end +</pre></div><div class="separator"></div> +<div class="example"><pre> +@interface MyObject : NSObject { + id _myproperty; +} +@property(assign) id myproperty; +@end + +@implementation MyObject +@synthesize myproperty = _myproperty; + // warn: var wasn't retained but was released +- (void)dealloc { + [_myproperty release]; + [super dealloc]; +} +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.DirectIvarAssignment</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check that Objective C properties follow the following rule: the property +should be set with the setter, not though a direct assignment.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyClass : NSObject {} +@property (readonly) id A; +- (void) foo; +@end + +@implementation MyClass +- (void) foo { + _A = 0; // warn +} +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.DirectIvarAssignmentForAnnotatedFunctions</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for direct assignments to instance variables in the methods annotated +with <code>objc_no_direct_instance_variable_assignment</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyClass : NSObject {} +@property (readonly) id A; +- (void) fAnnotated __attribute__(( + annotate("objc_no_direct_instance_variable_assignment"))); +- (void) fNotAnnotated; +@end + +@implementation MyClass +- (void) fAnnotated { + _A = 0; // warn +} +- (void) fNotAnnotated { + _A = 0; // no warn +} +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.InstanceVariableInvalidation</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check that the invalidatable instance variables are invalidated in the methods +annotated with <code>objc_instance_variable_invalidator</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@protocol Invalidation <NSObject> +- (void) invalidate + __attribute__((annotate("objc_instance_variable_invalidator"))); +@end + +@interface InvalidationImpObj : NSObject <Invalidation> +@end + +@interface SubclassInvalidationImpObj : InvalidationImpObj { + InvalidationImpObj *var; +} +- (void)invalidate; +@end + +@implementation SubclassInvalidationImpObj +- (void) invalidate {} +@end +// warn: var needs to be invalidated or set to nil +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.MissingInvalidationMethod</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check that the invalidation methods are present in classes that contain +invalidatable instance variables.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@protocol Invalidation <NSObject> +- (void)invalidate + __attribute__((annotate("objc_instance_variable_invalidator"))); +@end + +@interface NeedInvalidation : NSObject <Invalidation> +@end + +@interface MissingInvalidationMethodDecl : NSObject { + NeedInvalidation *Var; // warn +} +@end + +@implementation MissingInvalidationMethodDecl +@end +</pre></div></div></td></tr> + +</tbody></table> + +<!------------------------- security alpha ------------------------------------> +<h3 id="security_alpha_checkers">Security Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.security.ArrayBound</span><span class="lang"> +(C)</span><div class="descr"> +Warn about buffer overflows (older checker).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char *s = ""; + char c = s[1]; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +struct seven_words { + int c[7]; +}; + +void test() { + struct seven_words a, *p; + p = &a; + p[0] = a; + p[1] = a; + p[2] = a; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// note: requires unix.Malloc or +// alpha.unix.MallocWithAnnotations checks enabled. +void test() { + int *p = malloc(12); + p[3] = 4; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + char a[2]; + int *b = (int*)a; + b[1] = 3; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.security.ArrayBoundV2</span><span class="lang"> +(C)</span><div class="descr"> +Warn about buffer overflows (newer checker).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char *s = ""; + char c = s[1]; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + int buf[100]; + int *p = buf; + p = p + 99; + p[1] = 1; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// note: compiler has internal check for this. +// Use -Wno-array-bounds to suppress compiler warning. +void test() { + int buf[100][100]; + buf[0][-1] = 1; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// note: requires alpha.security.taint check turned on. +void test() { + char s[] = "abc"; + int x = getchar(); + char c = s[x]; // warn: index is tainted +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.security.MallocOverflow</span><span class="lang"> +(C)</span><div class="descr"> +Check for overflows in the arguments to <code>malloc()</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(int n) { + void *p = malloc(n * sizeof(int)); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.security.ReturnPtrRange</span><span class="lang"> +(C)</span><div class="descr"> +Check for an out-of-bound pointer being returned to callers.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +static int A[10]; + +int *test() { + int *p = A + 10; + return p; // warn +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +int test(void) { + int x; + return x; // warn: undefined or garbage returned +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.security.taint.TaintPropagation</span><span class="lang"> +(C)</span><div class="descr"> +Generate taint information used by other checkers.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char x = getchar(); // 'x' marked as tainted + system(&x); // warn: untrusted data is passed to a system call +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// note: compiler internally checks if the second param to +// sprintf is a string literal or not. +// Use -Wno-format-security to suppress compiler warning. +void test() { + char s[10], buf[10]; + fscanf(stdin, "%s", s); // 's' marked as tainted + + sprintf(buf, s); // warn: untrusted data as a format string +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + size_t ts; + scanf("%zd", &ts); // 'ts' marked as tainted + int *p = (int *)malloc(ts * sizeof(int)); + // warn: untrusted data as bufer size +} +</pre></div></div></td></tr> + +</tbody></table> + +<!--------------------------- unix alpha --------------------------------------> +<h3 id="unix_alpha_checkers">Unix Alpha Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.Chroot</span><span class="lang"> +(C)</span><div class="descr"> +Check improper use of <code>chroot</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void f(); + +void test() { + chroot("/usr/local"); + f(); // warn: no call of chdir("/") immediately after chroot +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.MallocWithAnnotations</span><span class="lang"> +(C)</span><div class="descr"> +Check for memory leaks, double free, and use-after-free problems. Assumes that +all user-defined functions which might free a pointer are +annotated.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void __attribute((ownership_returns(malloc))) *my_malloc(size_t); + +void test() { + int *p = my_malloc(1); +} // warn: potential leak +</pre></div><div class="separator"></div> +<div class="example"><pre> +void __attribute((ownership_returns(malloc))) *my_malloc(size_t); +void __attribute((ownership_takes(malloc, 1))) my_free(void *); + +void test() { + int *p = my_malloc(1); + my_free(p); + my_free(p); // warn: attempt to free released +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void __attribute((ownership_returns(malloc))) *my_malloc(size_t); +void __attribute((ownership_holds(malloc, 1))) my_hold(void *); + +void test() { + int *p = my_malloc(1); + my_hold(p); + free(p); // warn: attempt to free non-owned memory +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void __attribute((ownership_takes(malloc, 1))) my_free(void *); + +void test() { + int *p = malloc(1); + my_free(p); + *p = 1; // warn: use after free +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.PthreadLock</span><span class="lang"> +(C)</span><div class="descr"> +Simple lock -> unlock checker; applies to:<div class=functions> +pthread_mutex_lock<br> +pthread_rwlock_rdlock<br> +pthread_rwlock_wrlock<br> +lck_mtx_lock<br> +lck_rw_lock_exclusive<br> +lck_rw_lock_shared<br> +pthread_mutex_trylock<br> +pthread_rwlock_tryrdlock<br> +pthread_rwlock_tryrwlock<br> +lck_mtx_try_lock<br> +lck_rw_try_lock_exclusive<br> +lck_rw_try_lock_shared<br> +pthread_mutex_unlock<br> +pthread_rwlock_unlock<br> +lck_mtx_unlock<br> +lck_rw_done</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +pthread_mutex_t mtx; + +void test() { + pthread_mutex_lock(&mtx); + pthread_mutex_lock(&mtx); + // warn: this lock has already been acquired +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +lck_mtx_t lck1, lck2; + +void test() { + lck_mtx_lock(&lck1); + lck_mtx_lock(&lck2); + lck_mtx_unlock(&lck1); + // warn: this was not the most recently acquired lock +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +lck_mtx_t lck1, lck2; + +void test() { + if (lck_mtx_try_lock(&lck1) == 0) + return; + + lck_mtx_lock(&lck2); + lck_mtx_unlock(&lck1); + // warn: this was not the most recently acquired lock +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.SimpleStream</span><span class="lang"> +(C)</span><div class="descr"> +Check for misuses of stream APIs:<div class=functions> +fopen<br> +fclose</div>(demo checker, the subject of the demo +(<a href="http://llvm.org/devmtg/2012-11/Zaks-Rose-Checker24Hours.pdf">Slides</a> +,<a href="http://llvm.org/devmtg/2012-11/videos/Zaks-Rose-Checker24Hours.mp4">Video</a>) +by Anna Zaks and Jordan Rose presented at the <a href="http://llvm.org/devmtg/2012-11/"> +2012 LLVM Developers' Meeting).</a></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + FILE *F = fopen("myfile.txt", "w"); +} // warn: opened file is never closed +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + FILE *F = fopen("myfile.txt", "w"); + + if (F) + fclose(F); + + fclose(F); // warn: closing a previously closed file stream +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.Stream</span><span class="lang"> +(C)</span><div class="descr"> +Check stream handling functions:<div class=functions>fopen<br> +tmpfile<br> +fclose<br> +fread<br> +fwrite<br> +fseek<br> +ftell<br> +rewind<br> +fgetpos<br> +fsetpos<br> +clearerr<br> +feof<br> +ferror<br> +fileno</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + FILE *p = fopen("foo", "r"); +} // warn: opened file is never closed +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + FILE *p = fopen("foo", "r"); + fseek(p, 1, SEEK_SET); // warn: stream pointer might be NULL + fclose(p); +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + FILE *p = fopen("foo", "r"); + + if (p) + fseek(p, 1, 3); + // warn: third arg should be SEEK_SET, SEEK_END, or SEEK_CUR + + fclose(p); +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + FILE *p = fopen("foo", "r"); + fclose(p); + fclose(p); // warn: already closed +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +void test() { + FILE *p = tmpfile(); + ftell(p); // warn: stream pointer might be NULL + fclose(p); +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.cstring.BufferOverlap</span><span class="lang"> +(C)</span><div class="descr"> +Checks for overlap in two buffer arguments; applies to:<div class=functions> +memcpy<br> +mempcpy</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int a[4] = {0}; + memcpy(a + 2, a + 1, 8); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.cstring.NotNullTerminated</span><span class="lang"> +(C)</span><div class="descr"> +Check for arguments which are not null-terminated strings; applies +to:<div class=functions> +strlen<br> +strnlen<br> +strcpy<br> +strncpy<br> +strcat<br> +strncat</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int y = strlen((char *)&test); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.unix.cstring.OutOfBounds</span><span class="lang"> +(C)</span><div class="descr"> +Check for out-of-bounds access in string functions; applies +to:<div class=functions> +strncopy<br> +strncat</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(char *y) { + char x[4]; + if (strlen(y) == 4) + strncpy(x, y, 5); // warn +} +</pre></div></div></td></tr> + +</tbody></table> + +</div> <!-- page --> +</div> <!-- content --> +</body> +</html> diff --git a/www/analyzer/available_checks.html b/www/analyzer/available_checks.html index 8c7d9e987a51..7707fc0150d5 100644 --- a/www/analyzer/available_checks.html +++ b/www/analyzer/available_checks.html @@ -2,187 +2,30 @@ "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> - <title>Available Checks</title> + <title>Available Checkers</title> <link type="text/css" rel="stylesheet" href="menu.css"> <link type="text/css" rel="stylesheet" href="content.css"> <script type="text/javascript" src="scripts/menu.js"></script> + <script type="text/javascript" src="scripts/expandcollapse.js"></script> <style type="text/css"> tr:first-child { width:20%; } </style> </head> -<body> +<body onload="initExpandCollapse()"> <div id="page"> <!--#include virtual="menu.html.incl"--> <div id="content"> - -<h1>Available Checks</h1> - -<h3>The list of the checks the analyzer performs by default</h3> -<p> -<table border="0" cellpadding="3" cellspacing="3" width="100%"> -<!-- <tr> -<th><h4>Checker Name</h4></th> -<th><h4>Description</h4></th> -</tr>--> -<tr> -<td><b>core.AdjustedReturnValue</b></td><td>Check to see if the return value of a function call is different than the caller expects (e.g., from calls through function pointers).</td> -</tr> -<tr> -<td><b>core.CallAndMessage</b></td><td>Check for logical errors for function calls and Objective-C message expressions (e.g., uninitialized arguments, null function pointers).</td> -</tr> -<tr> -<td><b>core.DivideZero</b></td><td>Check for division by zero.</td> -</tr> -<tr> -<td><b>core.NonNullParamChecker</b></td><td>Check for null pointers passed as arguments to a function whose arguments are known to be non-null.</td> -</tr> -<tr> -<td><b>core.NullDereference</b></td><td>Check for dereferences of null pointers.</td> -</tr> -<tr> -<td><b>core.StackAddressEscape</b></td><td>Check that addresses to stack memory do not escape the function.</td> -</tr> -<tr> -<td><b>core.UndefinedBinaryOperatorResult</b></td><td>Check for undefined results of binary operators.</td> -</tr> -<tr> -<td><b>core.VLASize</b></td><td>Check for declarations of VLA of undefined or zero size.</td> -</tr> -<tr> -<td><b>core.builtin.BuiltinFunctions</b></td><td>Evaluate compiler builtin functions (e.g., alloca()).</td> -</tr> -<tr> -<td><b>core.builtin.NoReturnFunctions</b></td><td>Evaluate "panic" functions that are known to not return to the caller.</td> -</tr> -<tr> -<td><b>core.uninitialized.ArraySubscript</b></td><td>Check for uninitialized values used as array subscripts.</td> -</tr> -<tr> -<td><b>core.uninitialized.Assign</b></td><td>Check for assigning uninitialized values.</td> -</tr> -<tr> -<td><b>core.uninitialized.Branch</b></td><td>Check for uninitialized values used as branch conditions.</td> -</tr> -<tr> -<td><b>core.uninitialized.CapturedBlockVariable</b></td><td>Check for blocks that capture uninitialized values.</td> -</tr> -<tr> -<td><b>core.uninitialized.UndefReturn</b></td><td>Check for uninitialized values being returned to the caller.</td> -</tr> -<tr> -<td><b>cplusplus.NewDelete</b></td><td>Check for double-free and use-after-free problems involving C++ <code>delete</code>.</td> -</tr> -<tr> -<td><b>deadcode.DeadStores</b></td><td>Check for values stored to variables that are never read afterwards.</td> -</tr> -<!-- -<tr> -<td><b>deadcode.IdempotentOperations</b></td><td>Warn about idempotent operations.</td> -</tr> ---> -<tr> -<td><b>osx.API</b></td><td>Check for proper uses of various Apple APIs.</td> -</tr> -<tr> -<td><b>osx.SecKeychainAPI</b></td><td>Check for proper uses of Secure Keychain APIs.</td> -</tr> -<tr> -<td><b>osx.cocoa.AtSync</b></td><td>Check for nil pointers used as mutexes for @synchronized.</td> -</tr> -<tr> -<td><b>osx.cocoa.ClassRelease</b></td><td>Check for sending 'retain', 'release', or 'autorelease' directly to a Class.</td> -</tr> -<tr> -<td><b>osx.cocoa.IncompatibleMethodTypes</b></td><td>Warn about Objective-C method signatures with type incompatibilities.</td> -</tr> -<tr> -<td><b>osx.cocoa.NSAutoreleasePool</b></td><td>Warn for suboptimal uses of NSAutoreleasePool in Objective-C GC mode.</td> -</tr> -<tr> -<td><b>osx.cocoa.NSError</b></td><td>Check usage of NSError** parameters.</td> -</tr> -<tr> -<td><b>osx.cocoa.NilArg</b></td><td>Check for prohibited nil arguments to ObjC method calls.</td> -</tr> -<tr> -<td><b>osx.cocoa.RetainCount</b></td><td>Check for leaks and improper reference count management.</td> -</tr> -<tr> -<td><b>osx.cocoa.SelfInit</b></td><td>Check that 'self' is properly initialized inside an initializer method.</td> -</tr> -<tr> -<td><b>osx.cocoa.UnusedIvars</b></td><td>Warn about private ivars that are never used.</td> -</tr> -<tr> -<td><b>osx.cocoa.VariadicMethodTypes</b></td><td>Check for passing non-Objective-C types to variadic methods that expect only Objective-C types.</td> -</tr> -<tr> -<td><b>osx.coreFoundation.CFError</b></td><td>Check usage of CFErrorRef* parameters.</td> -</tr> -<tr> -<td><b>osx.coreFoundation.CFNumber</b></td><td>Check for proper uses of CFNumberCreate.</td> -</tr> -<tr> -<td><b>osx.coreFoundation.CFRetainRelease</b></td><td>Check for null arguments to CFRetain/CFRelease/CFMakeCollectable.</td> -</tr> -<tr> -<td><b>osx.coreFoundation.containers.OutOfBounds</b></td><td>Checks for index out-of-bounds when using 'CFArray' API.</td> -</tr> -<tr> -<td><b>osx.coreFoundation.containers.PointerSizedValues</b></td><td>Warns if 'CFArray', 'CFDictionary', 'CFSet' are created with non-pointer-size values.</td> -</tr> -<tr> -<td><b>security.FloatLoopCounter</b></td><td>Warn on using a floating point value as a loop counter (CERT: FLP30-C, FLP30-CPP).</td> -</tr> -<tr> -<td><b>security.insecureAPI.UncheckedReturn</b></td><td>Warn on uses of functions whose return values must be always checked.</td> -</tr> -<tr> -<td><b>security.insecureAPI.getpw</b></td><td>Warn on uses of the 'getpw' function.</td> -</tr> -<tr> -<td><b>security.insecureAPI.gets</b></td><td>Warn on uses of the 'gets' function.</td> -</tr> -<tr> -<td><b>security.insecureAPI.mkstemp</b></td><td>Warn when 'mkstemp' is passed fewer than 6 X's in the format string.</td> -</tr> -<tr> -<td><b>security.insecureAPI.mktemp</b></td><td>Warn on uses of the 'mktemp' function.</td> -</tr> -<tr> -<td><b>security.insecureAPI.rand</b></td><td>Warn on uses of the 'rand', 'random', and related functions.</td> -</tr> -<tr> -<td><b>security.insecureAPI.strcpy</b></td><td>Warn on uses of the 'strcpy' and 'strcat' functions.</td> -</tr> -<tr> -<td><b>security.insecureAPI.vfork</b></td><td>Warn on uses of the 'vfork' function.</td> -</tr> -<tr> -<td><b>unix.API</b></td><td>Check calls to various UNIX/Posix functions.</td> -</tr> -<tr> -<td><b>unix.Malloc</b></td><td>Check for memory leaks, double free, and use-after-free problems involving <code>malloc</code>.</td> -</tr> -<tr> -<td><b>unix.MallocSizeof</b></td><td>Check for dubious malloc arguments involving sizeof.</td> -</tr> -<tr> -<td><b>unix.MismatchedDeallocator</b></td><td>Check for mismatched deallocators (e.g. passing a pointer allocating with <code>new</code> to <code>free()</code>).</td> -</tr> -<tr> -<td><b>unix.cstring.BadSizeArg</b></td><td>Check the size argument passed into C string functions for common erroneous patterns.</td> -</tr> -<tr> -<td><b>unix.cstring.NullArg</b></td><td>Check for null pointers being passed as arguments to C string functions.</td> -</table> - -<p>In addition to these the analyzer contains numerous experimental (alpha) checkers.</p> +<h1>Available Checkers</h1> +The analyzer performs checks that are categorized into families or "checkers". The +default set of checkers covers a variety of checks targeted at finding security +and API usage bugs, dead code, and other logic errors. See the +<a href = "#default_checkers">Default Checkers</a> list below. In addition to +these, the analyzer contains a number of <a href = "alpha_checks.html"> +Experimental (Alpha) Checkers</a>. <h3>Writeups with examples of some of the bugs that the analyzer finds</h3> - <ul> <li><a href="http://www.mobileorchard.com/bug-finding-with-clang-5-resources-to-get-you-started/">Bug Finding With Clang: 5 Resources To Get You Started</a></li> <li><a href="http://fruitstandsoftware.com/blog/index.php/2008/08/finding-memory-leaks-with-the-llvmclang-static-analyzer/#comment-2">Finding Memory Leaks With The LLVM/Clang Static Analyzer</a></li> @@ -190,9 +33,1200 @@ <li><a href="http://www.mikeash.com/?page=pyblog/friday-qa-2009-03-06-using-the-clang-static-analyzer.html">Mike Ash - Using the Clang Static Analyzer</a></li> </ul> +<h2 id="default_checkers">Default Checkers</h2> +<ul> +<li><a href="#core_checkers">Core Checkers</a> model core language features and perform general-purpose checks such as division by zero, null pointer dereference, usage of uninitialized values, etc.</li> +<li><a href="#cplusplus_checkers">C++ Checkers</a> perform C++-specific checks</li> +<li><a href="#deadcode_checkers">Dead Code Checkers</a> check for unused code</li> +<li><a href="#osx_checkers">OS X Checkers</a> perform Objective-C-specific checks and check the use of Apple's SDKs (OS X and iOS)</li> +<li><a href="#security_checkers">Security Checkers</a> check for insecure API usage and perform checks based on the CERT Secure Coding Standards</li> +<li><a href="#unix_checkers">Unix Checkers</a> check the use of Unix and POSIX APIs</li> +</ul> + +<!------------------------------------ core -----------------------------------> +<h3 id="core_checkers">Core Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +core.CallAndMessage</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check for logical errors for function calls and Objective-C message expressions +(e.g., uninitialized arguments, null function pointers).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +struct S { + int x; +}; + +void f(struct S s); + +void test() { + struct S s; + f(s); // warn: passed-by-value arg contain uninitialized data +} +</pre></div> +<div class="example"><pre> +// C +void test() { + void (*foo)(void); + foo(); // warn: function pointer is uninitialized +} +</pre></div> +<div class="example"><pre> +// C +void test() { + void (*foo)(void); + foo = 0; + foo(); // warn: function pointer is null +} +</pre></div> +<div class="example"><pre> +// C++ +class C { +public: + void f(); +}; + +void test() { + C *pc; + pc->f(); // warn: object pointer is uninitialized +} +</pre></div> +<div class="example"><pre> +// C++ +class C { +public: + void f(); +}; + +void test() { + C *pc = 0; + pc->f(); // warn: object pointer is null +} +</pre></div> +<div class="example"><pre> +// Objective-C +@interface MyClass : NSObject +@property (readwrite,assign) id x; +- (long double)longDoubleM; +@end + +void test() { + MyClass *obj1; + long double ld1 = [obj1 longDoubleM]; + // warn: receiver is uninitialized +} +</pre></div> +<div class="example"><pre> +// Objective-C +@interface MyClass : NSObject +@property (readwrite,assign) id x; +- (long double)longDoubleM; +@end + +void test() { + MyClass *obj1; + id i = obj1.x; // warn: uninitialized object pointer +} +</pre></div> +<div class="example"><pre> +// Objective-C +@interface Subscriptable : NSObject +- (id)objectAtIndexedSubscript:(unsigned int)index; +@end + +@interface MyClass : Subscriptable +@property (readwrite,assign) id x; +- (long double)longDoubleM; +@end + +void test() { + MyClass *obj1; + id i = obj1[0]; // warn: uninitialized object pointer +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.DivideZero</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check for division by zero.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(int z) { + if (z == 0) + int x = 1 / z; // warn +} +</pre></div> +<div class="example"><pre> +void test() { + int x = 1; + int y = x % 0; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.NonNullParamChecker</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check for null pointers passed as arguments to a function whose arguments are +marked with the <code>nonnull</code> attribute.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int f(int *p) __attribute__((nonnull)); + +void test(int *p) { + if (!p) + f(p); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.NullDereference</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check for dereferences of null pointers.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +void test(int *p) { + if (p) + return; + + int x = p[0]; // warn +} +</pre></div> +<div class="example"><pre> +// C +void test(int *p) { + if (!p) + *p = 0; // warn +} +</pre></div> +<div class="example"><pre> +// C++ +class C { +public: + int x; +}; + +void test() { + C *pc = 0; + int k = pc->x; // warn +} +</pre></div> +<div class="example"><pre> +// Objective-C +@interface MyClass { +@public + int x; +} +@end + +void test() { + MyClass *obj = 0; + obj->x = 1; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.StackAddressEscape</span><span class="lang"> +(C)</span><div class="descr"> +Check that addresses of stack memory do not escape the function.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +char const *p; + +void test() { + char const str[] = "string"; + p = str; // warn +} +</pre></div> +<div class="example"><pre> +void* test() { + return __builtin_alloca(12); // warn +} +</pre></div> +<div class="example"><pre> +void test() { + static int *x; + int y; + x = &y; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.UndefinedBinaryOperatorResult</span><span class="lang"> +(C)</span><div class="descr"> +Check for undefined results of binary operators.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + int y = x + 1; // warn: left operand is garbage +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.VLASize</span><span class="lang"> +(C)</span><div class="descr"> +Check for declarations of VLA of undefined or zero size.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + int vla1[x]; // warn: garbage as size +} +</pre></div> +<div class="example"><pre> +void test() { + int x = 0; + int vla2[x]; // warn: zero size +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.uninitialized.ArraySubscript</span><span class="lang"> +(C)</span><div class="descr"> +Check for uninitialized values used as array subscripts.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int i, a[10]; + int x = a[i]; // warn: array subscript is undefined +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.uninitialized.Assign</span><span class="lang"> +(C)</span><div class="descr"> +Check for assigning uninitialized values.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + x |= 1; // warn: left expression is unitialized +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.uninitialized.Branch</span><span class="lang"> +(C)</span><div class="descr"> +Check for uninitialized values used as branch conditions.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + if (x) // warn + return; +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.uninitialized.CapturedBlockVariable</span><span class="lang"> +(C)</span><div class="descr"> +Check for blocks that capture uninitialized values.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + ^{ int y = x; }(); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.uninitialized.UndefReturn</span><span class="lang"> +(C)</span><div class="descr"> +Check for uninitialized values being returned to the caller.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int test() { + int x; + return x; // warn +} +</pre></div></div></td></tr> + +</tbody></table> + +<!------------------------------------ C++ ------------------------------------> +<h3 id="cplusplus_checkers">C++ Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +cplusplus.NewDelete</span><span class="lang"> +(C++)</span><div class="descr"> +Check for double-free, use-after-free and offset problems involving C++ <code> +delete</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void f(int *p); + +void testUseMiddleArgAfterDelete(int *p) { + delete p; + f(p); // warn: use after free +} +</pre></div> +<div class="example"><pre> +class SomeClass { +public: + void f(); +}; + +void test() { + SomeClass *c = new SomeClass; + delete c; + c->f(); // warn: use after free +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = (int *)__builtin_alloca(sizeof(int)); + delete p; // warn: deleting memory allocated by alloca +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = new int; + delete p; + delete p; // warn: attempt to free released +} +</pre></div> +<div class="example"><pre> +void test() { + int i; + delete &i; // warn: delete address of local +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = new int[1]; + delete[] (++p); + // warn: argument to 'delete[]' is offset by 4 bytes + // from the start of memory allocated by 'new[]' +} +</pre></div></div></td></tr> + +</tbody></table> + +<!--------------------------------- dead code ---------------------------------> +<h3 id="deadcode_checkers">Dead Code Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +deadcode.DeadStores</span><span class="lang"> +(C)</span><div class="descr"> +Check for values stored to variables that are never read afterwards.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x; + x = 1; // warn +} +</pre></div></div></td></tr> + +</tbody></table> + +<!---------------------------------- OS X ------------------------------------> +<h3 id="osx_checkers">OS X Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +osx.API</span><span class="lang"> +(C)</span><div class="descr"> +Check for proper uses of various Apple APIs:<div class=functions> +dispatch_once</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + dispatch_once_t pred = 0; + dispatch_once(&pred, ^(){}); // warn: dispatch_once uses local +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.SecKeychainAPI</span><span class="lang"> +(C)</span><div class="descr"> +Check for improper uses of the Security framework's Keychain APIs:<div class=functions> +SecKeychainItemCopyContent<br> +SecKeychainFindGenericPassword<br> +SecKeychainFindInternetPassword<br> +SecKeychainItemFreeContent<br> +SecKeychainItemCopyAttributesAndData<br> +SecKeychainItemFreeAttributesAndData</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + unsigned int *ptr = 0; + UInt32 length; + + SecKeychainItemFreeContent(ptr, &length); + // warn: trying to free data which has not been allocated +} +</pre></div> +<div class="example"><pre> +void test() { + unsigned int *ptr = 0; + UInt32 *length = 0; + void *outData; + + OSStatus st = + SecKeychainItemCopyContent(2, ptr, ptr, length, outData); + // warn: data is not released +} +</pre></div> +<div class="example"><pre> +void test() { + unsigned int *ptr = 0; + UInt32 *length = 0; + void *outData; + + OSStatus st = + SecKeychainItemCopyContent(2, ptr, ptr, length, &outData); + + SecKeychainItemFreeContent(ptr, outData); + // warn: only call free if a non-NULL buffer was returned +} +</pre></div> +<div class="example"><pre> +void test() { + unsigned int *ptr = 0; + UInt32 *length = 0; + void *outData; + + OSStatus st = + SecKeychainItemCopyContent(2, ptr, ptr, length, &outData); + + st = SecKeychainItemCopyContent(2, ptr, ptr, length, &outData); + // warn: release data before another call to the allocator + + if (st == noErr) + SecKeychainItemFreeContent(ptr, outData); +} +</pre></div> +<div class="example"><pre> +void test() { + SecKeychainItemRef itemRef = 0; + SecKeychainAttributeInfo *info = 0; + SecItemClass *itemClass = 0; + SecKeychainAttributeList *attrList = 0; + UInt32 *length = 0; + void *outData = 0; + + OSStatus st = + SecKeychainItemCopyAttributesAndData(itemRef, info, + itemClass, &attrList, + length, &outData); + + SecKeychainItemFreeContent(attrList, outData); + // warn: deallocator doesn't match the allocator +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.AtSync</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for nil pointers used as mutexes for <code>@synchronized</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(id x) { + if (!x) + @synchronized(x) {} // warn: nil value used as mutex +} +</pre></div> +<div class="example"><pre> +void test() { + id y; + @synchronized(y) {} // warn: uninitialized value used as mutex +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.ClassRelease</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for sending <code>retain</code>, <code>release</code>, or <code> +autorelease</code> directly to a class.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyClass : NSObject +@end + +void test(void) { + [MyClass release]; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.IncompatibleMethodTypes</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for an incompatible type signature when overriding an Objective-C method.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyClass1 : NSObject +- (int)foo; +@end + +@implementation MyClass1 +- (int)foo { return 1; } +@end + +@interface MyClass2 : MyClass1 +- (float)foo; +@end -</div> -</div> +@implementation MyClass2 +- (float)foo { return 1.0; } // warn +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +alpha.osx.cocoa.MissingSuperCall</span><span class="lang"> +(ObjC)</span><div class="descr"> +Warn about Objective-C methods that lack a necessary call to super. (Note: The +compiler now has a warning for methods annotated with <code>objc_requires_super</code> +attribute. The checker exists to check methods in the Cocoa frameworks +that haven't yet adopted this attribute.)</div></div></td> +<td><div class="example"><pre> +@interface Test : UIViewController +@end +@implementation test +- (void)viewDidLoad {} // warn +@end +</pre></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.NSAutoreleasePool</span><span class="lang"> +(ObjC)</span><div class="descr"> +Warn for suboptimal uses of NSAutoreleasePool in Objective-C +GC mode (<code>-fobjc-gc</code> compiler option).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [pool release]; // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.NSError</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check usage of <code>NSError**</code> parameters.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface A : NSObject +- (void)foo:(NSError **)error; +@end + +@implementation A +- (void)foo:(NSError **)error { + // warn: method accepting NSError** should have a non-void + // return value +} +@end +</pre></div> +<div class="example"><pre> +@interface A : NSObject +- (BOOL)foo:(NSError **)error; +@end + +@implementation A +- (BOOL)foo:(NSError **)error { + *error = 0; // warn: potential null dereference + return 0; +} +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.NilArg</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for prohibited nil arguments in specific Objective-C method calls:<div class=functions> +- caseInsensitiveCompare:<br> +- compare:<br> +- compare:options:<br> +- compare:options:range:<br> +- compare:options:range:locale:<br> +- componentsSeparatedByCharactersInSet:<br> +- initWithFormat:</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +NSComparisonResult test(NSString *s) { + NSString *aString = nil; + return [s caseInsensitiveCompare:aString]; + // warn: argument to 'NSString' method + // 'caseInsensitiveCompare:' cannot be nil +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.RetainCount</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for leaks and violations of the Cocoa Memory Management rules.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + NSString *s = [[NSString alloc] init]; // warn +} +</pre></div> +<div class="example"><pre> +CFStringRef test(char *bytes) { + return CFStringCreateWithCStringNoCopy( + 0, bytes, NSNEXTSTEPStringEncoding, 0); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.SelfInit</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check that <code>self</code> is properly initialized inside an initializer +method.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyObj : NSObject { + id x; +} +- (id)init; +@end + +@implementation MyObj +- (id)init { + [super init]; + x = 0; // warn: instance variable used while 'self' is not + // initialized + return 0; +} +@end +</pre></div> +<div class="example"><pre> +@interface MyObj : NSObject +- (id)init; +@end + +@implementation MyObj +- (id)init { + [super init]; + return self; // warn: returning uninitialized 'self' +} +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.UnusedIvars</span><span class="lang"> +(ObjC)</span><div class="descr"> +Warn about private ivars that are never used.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +@interface MyObj : NSObject { +@private + id x; // warn +} +@end + +@implementation MyObj +@end +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.VariadicMethodTypes</span><span class="lang"> +(ObjC)</span><div class="descr"> +Check for passing non-Objective-C types to variadic collection initialization +methods that expect only Objective-C types.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + [NSSet setWithObjects:@"Foo", "Bar", nil]; + // warn: argument should be an ObjC pointer type, not 'char *' +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.coreFoundation.CFError</span><span class="lang"> +(C)</span><div class="descr"> +Check usage of <code>CFErrorRef*</code> parameters.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(CFErrorRef *error) { + // warn: function accepting CFErrorRef* should have a + // non-void return +} +</pre></div> +<div class="example"><pre> +int foo(CFErrorRef *error) { + *error = 0; // warn: potential null dereference + return 0; +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.coreFoundation.CFNumber</span><span class="lang"> +(C)</span><div class="descr"> +Check for improper uses of <code>CFNumberCreate</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +CFNumberRef test(unsigned char x) { + return CFNumberCreate(0, kCFNumberSInt16Type, &x); + // warn: 8 bit integer is used to initialize a 16 bit integer +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.coreFoundation.CFRetainRelease</span><span class="lang"> +(C)</span><div class="descr"> +Check for null arguments to <code>CFRetain</code>, <code>CFRelease</code>, +<code>CFMakeCollectable</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(CFTypeRef p) { + if (!p) + CFRetain(p); // warn +} +</pre></div> +<div class="example"><pre> +void test(int x, CFTypeRef p) { + if (p) + return; + + CFRelease(p); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.coreFoundation.containers.OutOfBounds</span><span class="lang"> +(C)</span><div class="descr"> +Checks for index out-of-bounds when using <code>CFArray</code> API.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + CFArrayRef A = CFArrayCreate(0, 0, 0, &kCFTypeArrayCallBacks); + CFArrayGetValueAtIndex(A, 0); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.coreFoundation.containers.PointerSizedValues</span><span class="lang"> +(C)</span><div class="descr"> +Warns if <code>CFArray</code>, <code>CFDictionary</code>, <code>CFSet</code> are +created with non-pointer-size values.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x[] = { 1 }; + CFArrayRef A = CFArrayCreate(0, (const void **)x, 1, + &kCFTypeArrayCallBacks); // warn +} +</pre></div></div></td></tr> + +</tbody></table> + +<!------------------------------- security ------------------------------------> +<h3 id="security_checkers">Security Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +security.FloatLoopCounter</span><span class="lang"> +(C)</span><div class="descr"> +Warn on using a floating point value as a loop counter (CERT: FLP30-C, +FLP30-CPP).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + for (float x = 0.1f; x <= 1.0f; x += 0.1f) {} // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.UncheckedReturn</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of functions whose return values must be always checked:<div class=functions> +setuid<br> +setgid<br> +seteuid<br> +setegid<br> +setreuid<br> +setregid</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + setuid(1); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.getpw</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of the <code>getpw</code> function.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char buff[1024]; + getpw(2, buff); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.gets</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of the <code>gets</code> function.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char buff[1024]; + gets(buff); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.mkstemp</span><span class="lang"> +(C)</span><div class="descr"> +Warn when <code>mktemp</code>, <code>mkstemp</code>, <code>mkstemps</code> or +<code>mkdtemp</code> is passed fewer than 6 +X's in the format string.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + mkstemp("XX"); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.mktemp</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of the <code>mktemp</code> function.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char *x = mktemp("/tmp/zxcv"); // warn: insecure, use mkstemp +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.rand</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of inferior random number generating functions (only if <code>arc4random</code> +function is available):<div class=functions> +drand48<br> +erand48<br> +jrand48<br> +lcong48<br> +lrand48<br> +mrand48<br> +nrand48<br> +random<br> +rand_r</div></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + random(); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.strcpy</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of the <code>strcpy</code> and <code>strcat</code> functions.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char x[4]; + char *y = "abcd"; + + strcpy(x, y); // warn +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +security.insecureAPI.vfork</span><span class="lang"> +(C)</span><div class="descr"> +Warn on uses of the <code>vfork</code> function.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + vfork(); // warn +} +</pre></div></div></td></tr> + +</tbody></table> + +<!--------------------------------- unix --------------------------------------> +<h3 id="unix_checkers">Unix Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +unix.API</span><span class="lang"> +(C)</span><div class="descr"> +Check calls to various UNIX/POSIX functions:<div class=functions> +open<br> +pthread_once<br> +calloc<br> +malloc<br> +realloc<br> +alloca<br> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// Currently the check is performed for apple targets only. +void test(const char *path) { + int fd = open(path, O_CREAT); + // warn: call to 'open' requires a third argument when the + // 'O_CREAT' flag is set +} +</pre></div> +<div class="example"><pre> +void f(); + +void test() { + pthread_once_t pred = {0x30B1BCBA, {0}}; + pthread_once(&pred, f); + // warn: call to 'pthread_once' uses the local variable +} +</pre></div> +<div class="example"><pre> +void test() { + void *p = malloc(0); // warn: allocation size of 0 bytes +} +</pre></div> +<div class="example"><pre> +void test() { + void *p = calloc(0, 42); // warn: allocation size of 0 bytes +} +</pre></div> +<div class="example"><pre> +void test() { + void *p = malloc(1); + p = realloc(p, 0); // warn: allocation size of 0 bytes +} +</pre></div> +<div class="example"><pre> +void test() { + void *p = alloca(0); // warn: allocation size of 0 bytes +} +</pre></div> +<div class="example"><pre> +void test() { + void *p = valloc(0); // warn: allocation size of 0 bytes +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +unix.Malloc</span><span class="lang"> +(C)</span><div class="descr"> +Check for memory leaks, double free, and use-after-free and offset problems +involving <code>malloc</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int *p = malloc(1); + free(p); + free(p); // warn: attempt to free released memory +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = malloc(sizeof(int)); + free(p); + *p = 1; // warn: use after free +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = malloc(1); + if (p) + return; // warn: memory is never released +} +</pre></div> +<div class="example"><pre> +void test() { + int a[] = { 1 }; + free(a); // warn: argument is not allocated by malloc +} +</pre></div> +<div class="example"><pre> +void test() { + int *p = malloc(sizeof(char)); + p = p - 1; + free(p); // warn: argument to free() is offset by -4 bytes +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +unix.MallocSizeof</span><span class="lang"> +(C)</span><div class="descr"> +Check for dubious <code>malloc</code>, <code>calloc</code> or +<code>realloc</code> arguments involving <code>sizeof</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + long *p = malloc(sizeof(short)); + // warn: result is converted to 'long *', which is + // incompatible with operand type 'short' + free(p); +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +unix.MismatchedDeallocator</span><span class="lang"> +(C, C++, ObjC)</span><div class="descr"> +Check for mismatched deallocators (e.g. passing a pointer allocating +with <code>new</code> to <code>free()</code>).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C, C++ +void test() { + int *p = (int *)malloc(sizeof(int)); + delete p; // warn +} +</pre></div> +<div class="example"><pre> +// C, C++ +void __attribute((ownership_returns(malloc))) *user_malloc(size_t); + +void test() { + int *p = (int *)user_malloc(sizeof(int)); + delete p; // warn +} +</pre></div> +<div class="example"><pre> +// C, C++ +void test() { + int *p = new int; + free(p); // warn +} +</pre></div> +<div class="example"><pre> +// C, C++ +void test() { + int *p = new int[1]; + realloc(p, sizeof(long)); // warn +} +</pre></div> +<div class="example"><pre> +// C, C++ +template <typename T> +struct SimpleSmartPointer { + T *ptr; + + explicit SimpleSmartPointer(T *p = 0) : ptr(p) {} + ~SimpleSmartPointer() { + delete ptr; // warn + } +}; + +void test() { + SimpleSmartPointer<int> a((int *)malloc(4)); +} +</pre></div> +<div class="example"><pre> +// C++ +void test() { + int *p = (int *)operator new(0); + delete[] p; // warn +} +</pre></div> +<div class="example"><pre> +// Objective-C, C++ +void test(NSUInteger dataLength) { + int *p = new int; + NSData *d = [NSData dataWithBytesNoCopy:p + length:sizeof(int) freeWhenDone:1]; + // warn +dataWithBytesNoCopy:length:freeWhenDone: cannot take + // ownership of memory allocated by 'new' +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +unix.cstring.BadSizeArg</span><span class="lang"> +(C)</span><div class="descr"> +Check the size argument passed to <code>strncat</code> for common erroneous +patterns. Use <code>-Wno-strncat-size</code> compiler option to mute other +<code>strncat</code>-related compiler warnings. +</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + char dest[3]; + strncat(dest, "***", sizeof(dest)); + // warn: potential buffer overflow +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +unix.cstring.NullArg</span><span class="lang"> +(C)</span><div class="descr"> +Check for null pointers being passed as arguments to C string functions:<div class=functions> +strlen<br> +strnlen<br> +strcpy<br> +strncpy<br> +strcat<br> +strncat<br> +strcmp<br> +strncmp<br> +strcasecmp<br> +strncasecmp</div></div></div></td> +<td><div class="example"><pre> +int test() { + return strlen(0); // warn +} +</pre></div></td></tr> + +</tbody></table> + +</div> <!-- page --> +</div> <!-- content --> </body> </html> - diff --git a/www/analyzer/checker_dev_manual.html b/www/analyzer/checker_dev_manual.html index 2216176a1308..9c7cd98efa52 100644 --- a/www/analyzer/checker_dev_manual.html +++ b/www/analyzer/checker_dev_manual.html @@ -47,6 +47,7 @@ for developer guidelines and send your questions and proposals to <li><a href="#testing">Testing</a></li> <li><a href="#commands">Useful Commands/Debugging Hints</a></li> <li><a href="#additioninformation">Additional Sources of Information</a></li> + <li><a href="#links">Useful Links</a></li> </ul> <h2 id=start>Getting Started</h2> @@ -605,6 +606,11 @@ href="http://llvm.org/devmtg/2012-11/videos/Zaks-Rose-Checker24Hours.mp4">video< are available. </ul> +<h2 id=links>Useful Links</h2> +<ul> +<li>The list of <a href="implicit_checks.html">Implicit Checkers</a></li> +</ul> + </div> </div> </body> diff --git a/www/analyzer/content.css b/www/analyzer/content.css index 929d5200a3e7..c4d601b4b15a 100644 --- a/www/analyzer/content.css +++ b/www/analyzer/content.css @@ -38,7 +38,7 @@ IMG.img_slide { #content { clear: left; - padding: 1em 2em 0 2em; + padding: 1em 2em 1em 2em; background-color: #ffffff; } @@ -54,9 +54,7 @@ table.options thead { text-align:left; border-top: 2px solid #cccccc; border-bottom: 2px solid #cccccc; - font-weight: bold; font-family: Verdana; - table-layout: fixed; - width: 100% + font-weight: bold; font-family: Verdana } table.options { border: 1px #cccccc solid } table.options { border-collapse: collapse; border-spacing: 0px } @@ -64,7 +62,6 @@ table.options { margin-left:0px; margin-top:20px; margin-bottom:20px } table.options td { border-bottom: 1px #cccccc dotted } table.options td { padding:5px; padding-left:8px; padding-right:8px } table.options td { text-align:left; font-size:9pt } -table.options col.option { width:207px } table.checkers { border: 1px #cccccc solid; @@ -76,41 +73,28 @@ table.checkers { word-wrap :break-word; font-size: 100%; } - table.checkers thead { background-color:#eee; color:#666666; border-top: 2px solid #cccccc; border-bottom: 2px solid #cccccc; font-weight: bold; font-family: Verdana; } - -table.checkers td { - padding:5px; padding-left:8px; padding-right:8px; - border-right: 1px #cccccc dotted; - border-bottom: 1px #cccccc dotted; -} - +table.checkers td { border-right: 1px #cccccc dotted; border-bottom: 1px #cccccc dotted; } table.checkers td.aligned { text-align: center; vertical-align: middle; } table.checkers col.namedescr { width: 45% } table.checkers col.example { width: 55% } table.checkers col.progress { width: 84px } -table.checkers pre { margin:1px; font-size: 100%; word-wrap :break-word; } -table.checkers .name { font-weight:bold; } -table.checkers .checked { background-color:#81F781; } -table.checkers .commented { color:#909090; } - -/* Collapsing Trees: http://dbtree.megalingo.com/web/demo/simple-collapsible-tree.cfm */ -#collapsetree, #collapsetree a:link, #collapsetree li a:link, #collapsetree a:visited, #collapsetree li a:visited{color:#000;text-decoration:none} -#collapsetree,#collapsetree ul{list-style-type:none; width:auto; margin:0; padding:0} -#collapsetree ul{padding-left:20px;display:none;overflow:auto} -#collapsetree li ul{margin:0 auto} -#collapsetree li{display:block;width:100%;line-height:20px;white-space:nowrap} -#collapsetree li a{display:block;padding-left:20px;color:#000;text-decoration:none;background:url(images/tree/bullet.gif) center left no-repeat;white-space:nowrap} -#collapsetree li a:hover{text-decoration:underline;background-color:transparent;color:#000} -#collapsetree li ul.click{display:block} -#collapsetree li.click a{background:url(images/tree/bullet.gif) center left no-repeat} -#collapsetree ul li.click a{background:url(images/tree/bullet.gif) center left no-repeat} -#collapsetree li a.subMenu,#collapsetree ul li a.subMenu{background:url(images/tree/plus.gif) center left no-repeat} -#collapsetree li a.click{background:url(images/tree/minus.gif) center left no-repeat} -#collapsetree ul li a.click{background:url(images/tree/minus.gif) center left no-repeat} +table.checkers thead td, +table.checkers div.namedescr, +table.checkers div.exampleContainer { overflow: hidden; padding: 5px 8px 10px 8px } +/* table.checkers tbody div.example { font-family: monospace; white-space: pre } */ +table.checkers div.example { border-top:1px #cccccc dashed; width:100%; padding-top: 5px; margin-top: 5px } +table.checkers div.example:first-child { border-top:none; padding-top: 0px; margin-top: 0px } +table.checkers span.name { font-weight: bold } +table.checkers span.lang { font-weight: bold; padding-left: 7px; /* display:block; */ } +table.checkers div.descr { margin-top:7px } +table.checkers div.functions { margin-top: 2px; font-style: italic; font-size: 90%; color:#00B } +table.checkers pre { margin: 1px; font-size: 100%; word-wrap: break-word } +table.checkers p { margin: 10px 0px 0px 0px; } +table.checkers ul, li { margin: 0 } diff --git a/www/analyzer/images/expandcollapse/arrows_dark.gif b/www/analyzer/images/expandcollapse/arrows_dark.gif Binary files differnew file mode 100644 index 000000000000..445a3c5533b0 --- /dev/null +++ b/www/analyzer/images/expandcollapse/arrows_dark.gif diff --git a/www/analyzer/images/expandcollapse/arrows_light.gif b/www/analyzer/images/expandcollapse/arrows_light.gif Binary files differnew file mode 100644 index 000000000000..4534d05af96f --- /dev/null +++ b/www/analyzer/images/expandcollapse/arrows_light.gif diff --git a/www/analyzer/images/expandcollapse/ellipses_dark.gif b/www/analyzer/images/expandcollapse/ellipses_dark.gif Binary files differnew file mode 100644 index 000000000000..8ed43b0e7d93 --- /dev/null +++ b/www/analyzer/images/expandcollapse/ellipses_dark.gif diff --git a/www/analyzer/images/expandcollapse/ellipses_light.gif b/www/analyzer/images/expandcollapse/ellipses_light.gif Binary files differnew file mode 100644 index 000000000000..90141ba852ab --- /dev/null +++ b/www/analyzer/images/expandcollapse/ellipses_light.gif diff --git a/www/analyzer/images/tree/bullet.gif b/www/analyzer/images/tree/bullet.gif Binary files differdeleted file mode 100644 index de1534854699..000000000000 --- a/www/analyzer/images/tree/bullet.gif +++ /dev/null diff --git a/www/analyzer/images/tree/minus.gif b/www/analyzer/images/tree/minus.gif Binary files differdeleted file mode 100644 index 225f40daeb0d..000000000000 --- a/www/analyzer/images/tree/minus.gif +++ /dev/null diff --git a/www/analyzer/images/tree/plus.gif b/www/analyzer/images/tree/plus.gif Binary files differdeleted file mode 100644 index 5398c801331c..000000000000 --- a/www/analyzer/images/tree/plus.gif +++ /dev/null diff --git a/www/analyzer/implicit_checks.html b/www/analyzer/implicit_checks.html new file mode 100644 index 000000000000..a476c9bf32bc --- /dev/null +++ b/www/analyzer/implicit_checks.html @@ -0,0 +1,165 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" + "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> + <title>Implicit Checks</title> + <link type="text/css" rel="stylesheet" href="menu.css"> + <link type="text/css" rel="stylesheet" href="content.css"> + <script type="text/javascript" src="scripts/menu.js"></script> + <script type="text/javascript" src="scripts/expandcollapse.js"></script> + <style type="text/css"> + tr:first-child { width:20%; } + </style> +</head> +<body onload="initExpandCollapse()"> + +<div id="page"> +<!--#include virtual="menu.html.incl"--> + +<div id="content"> +<h1>Implicit Checkers</h1> +Even though the implicit checkers do not produce any warnings, they are used to +support the analyzer core and model known APIs. See also +<a href = "available_checks.html">Default Checkers</a> +and <a href = "alpha_checks.html">Experimental (Alpha) Checkers</a>. +<ul> +<li><a href="#core_implicit_checkers">Core Implicit Checkers</a></li> +<li><a href="#osx_implicit_checkers">OS X Implicit Checkers</a></li> +</ul> + +<!------------------------------- core implicit -------------------------------> +<h3 id="core_implicit_checkers">Core Implicit Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +core.DynamicTypePropagation</span><span class="lang"> +(C++, ObjC)</span><div class="descr"> +Generate dynamic type information.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C++ +class A { +public: + A(int x) {} + virtual int foo(); +}; + +class B: public A { +public: + B() + :A(foo()) + // DynamicTypeInfo for 'this' rigion will wrap type 'A' + // unless the base constructor call expression is processed + {} + virtual int foo(); +}; +</pre></div><div class="separator"></div> +<div class="example"><pre> +// Objective-C +@interface MyClass : NSObject {} +@end + +@implementation MyClass ++ (void)foo { + MyClass *x = [[self alloc] init]; + // DynamicTypeInfo from a cast: from 'id' to 'MyClass *' +} +@end + +void test() { + MyClass *x = [MyClass alloc]; + // DynamicTypeInfo from a call to alloc: + // from 'id' to 'MyClass *' +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.builtin.BuiltinFunctions</span><span class="lang"> +(C)</span><div class="descr"> +Evaluate compiler builtin functions (e.g., <code>alloca()</code>)</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(int x) { + int *p = (int *)__builtin_alloca(8); + // evaluates to AllocaRegion + + if(__builtin_expect(x > 10, 0)) // evaluates to 'x > 10' + x = 0; +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +core.builtin.NoReturnFunctions</span><span class="lang"> +(C, ObjC)</span><div class="descr"> +Evaluate "panic" functions that are known to not return to the caller.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +// C +void test() { + panic(); // generate sink +} +</pre></div><div class="separator"></div> +<div class="example"><pre> +// Objective-C +@interface MyObj : NSObject {} +- (void)foo; +@end + +@implementation MyObj +- (void)foo { + [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd + object:self + file:(@"somefile.m") + lineNumber:1 + description:(@"some text")]; + // generate sink +} +@end +</pre></div></div></td></tr> + +</tbody></table> + +<!---------------------------- OS X implicit ----------------------------------> +<h3 id="osx_implicit_checkers">OS X Implicit Checkers</h3> +<table class="checkers"> +<colgroup><col class="namedescr"><col class="example"></colgroup> +<thead><tr><td>Name, Description</td><td>Example</td></tr></thead> + +<tbody> +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.Loops</span><span class="lang"> +(ObjC)</span><div class="descr"> +Improved modeling of loops using Cocoa collection types.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + id x; + for (x in [NSArray testObject]) { + // assume the value of 'x' is non-nil + } +} +</pre></div></div></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +osx.cocoa.NonNilReturnValue</span><span class="lang"> +(ObjC)</span><div class="descr"> +Model the APIs that are guaranteed to return a non-nil value.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(NSArray *A) { + id subscriptObj = A[1]; // assume the value is non-nil +} +</pre></div></div></td></tr> + +</tbody></table> + +</div> <!-- page --> +</div> <!-- content --> +</body> +</html> diff --git a/www/analyzer/latest_checker.html.incl b/www/analyzer/latest_checker.html.incl index 5062622c8c91..99ed3d8898ae 100644 --- a/www/analyzer/latest_checker.html.incl +++ b/www/analyzer/latest_checker.html.incl @@ -1 +1 @@ -<b><a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></b> (built May 23, 2013) +<b><a href="downloads/checker-276.tar.bz2">checker-276.tar.bz2</a></b> (built February 19, 2014) diff --git a/www/analyzer/open_projects.html b/www/analyzer/open_projects.html index 4a888adbb68c..75c069260c7c 100644 --- a/www/analyzer/open_projects.html +++ b/www/analyzer/open_projects.html @@ -56,7 +56,7 @@ mailing list</a> to notify other members of the community.</p> <li>Enhance CFG to model C++ temporaries properly. <p>There is an existing implementation of this, but it's not complete and is disabled in the analyzer. - <i>(Difficulty: Medium)</i></p> + <i>(Difficulty: Medium; current contact: Alex McCarthy)</i></p> <li>Enhance CFG to model exception-handling properly. <p>Currently exceptions are treated as "black holes", and exception-handling @@ -70,7 +70,7 @@ mailing list</a> to notify other members of the community.</p> (<code>operator new</code>), then initialize the result with a constructor call. The problem is discussed at length in <a href="http://llvm.org/bugs/show_bug.cgi?id=12014">PR12014</a>. - <i>(Difficulty: Easy)</i></p> + <i>(Difficulty: Easy; current contact: Karthik Bhat)</i></p> <li>Enhance CFG to model C++ <code>delete</code> more precisely. <p>Similarly, the representation of <code>delete</code> does not include @@ -78,7 +78,14 @@ mailing list</a> to notify other members of the community.</p> function (<code>operator delete</code>). One particular issue (<tt>noreturn</tt> destructors) is discussed in <a href="http://llvm.org/bugs/show_bug.cgi?id=15599">PR15599</a> - <i>(Difficulty: Easy)</i></p> + <i>(Difficulty: Easy; current contact: Karthik Bhat)</i></p> + + <li>Implement a BitwiseConstraintManager to handle <a href="http://llvm.org/bugs/show_bug.cgi?id=3098">PR3098</a>. + <p>Constraints on the bits of an integer are not easily representable as + ranges. A bitwise constraint manager would model constraints such as "bit 32 + is known to be 1". This would help code that made use of bitmasks</code>. + <i>(Difficulty: Medium)</i></p> + </li> <li>Track type info through casts more precisely. <p>The DynamicTypePropagation checker is in charge of inferring a region's @@ -107,14 +114,6 @@ mailing list</a> to notify other members of the community.</p> display such paths in HTML output. <i>(Difficulty: Medium)</i> </p> </li> - <li>Relate bugs to checkers / "bug types" - <p>We need to come up with an API which will relate bug reports - to the checkers that produce them and refactor the existing code to use the - new API. This would allow us to identify the checker from the bug report, - which paves the way for selective control of certain checks. - <i>(Difficulty: Easy-Medium)</i></p> - </li> - <li>Refactor path diagnostic generation in <a href="http://clang.llvm.org/doxygen/BugReporter_8cpp_source.html">BugReporter.cpp</a>. <p>It would be great to have more code reuse between "Minimal" and "Extensive" PathDiagnostic generation algorithms. One idea is to create an @@ -182,7 +181,7 @@ mailing list</a> to notify other members of the community.</p> <p>Take a look at the <a href="http://pages.cs.wisc.edu/~shanlu/paper/TSE-CPMiner.pdf">CP-Miner</a> paper for inspiration. - <i>(Difficulty: Medium-Hard)</i></p> + <i>(Difficulty: Medium-Hard; current contacts: Per Viberg and Daniel Fahlgren)</i></p> </li> </ul> </li> diff --git a/www/analyzer/potential_checkers.html b/www/analyzer/potential_checkers.html index ab8917c7cb46..a06e9426fb5f 100644 --- a/www/analyzer/potential_checkers.html +++ b/www/analyzer/potential_checkers.html @@ -5,10 +5,10 @@ <title>List of potential checkers</title> <link type="text/css" rel="stylesheet" href="content.css"> <link type="text/css" rel="stylesheet" href="menu.css"> + <script type="text/javascript" src="scripts/expandcollapse.js"></script> <script type="text/javascript" src="scripts/menu.js"></script> - <script type="text/javascript" src="scripts/dbtree.js"></script> </head> -<body> +<body onload="initExpandCollapse()"> <div id="page"> @@ -21,120 +21,88 @@ <p>This page contains a list of potential checkers to implement in the static analyzer. If you are interested in contributing to the analyzer's development, this is a good resource to help you get started. The specific names of the checkers are subject to review, and are provided here as suggestions.</p> <!-- ========================= allocation/deallocation ======================= --> -<h3>allocation/deallocation</h3> +<h3>memory</h3> <table class="checkers"> <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">memory.LeakNeverReleased<br> -(C, C++)</span><br><br> -Memory may be never released, potential leak of memory -</td><td> -<pre> -#include <stdlib.h> - -int f() {}; - -void test() { - int *p1 = (int*)malloc(sizeof(int)); // warn - int *p2 = new int; // warn - int x = f(); - if (x==1) - return; - delete p2; -} -</pre></td><td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=15237">PR15237</a> -</td></tr> - -<tr><td><span class="name">memory.MismatchedFree -<br>enhancement to unix.Malloc<br>(C, C++)</span><br><br> -Mismatched deallocation function is used -</td><td><pre> -#include <stdlib.h> +<tr><td><div class="namedescr expandable"><span class="name"> +memory.LeakEvalOrder</span><span class="lang"> +(C, C++)</span><div class="descr"> +Potential memory leaks caused by an undefined argument evaluation order. +<p>Source: <a href="http://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm#BestPractices"> +boost docs: shared_ptr</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void f(int, int); +int g(void *); +int h() __attribute__((noreturn)); void test() { - int *p1 = new int; - int *p2 = new int[1]; - - free(p1); // warn - free(p2); // warn + // It is possible that 'malloc(1)' is called first, + // then 'h()', that is (or calls) noreturn and eventually + // 'g()' is never called. + f(g(malloc(1)), h()); // warn: 'g()' may never be called. } -</pre></td><td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=15238">PR15238</a> -</td></tr> - -<tr><td><span class="name">memory.LeakPtrValChanged -<br>enhancement to unix.Malloc<br>(C, C++)</span><br><br> -Potential memory leak: a pointer to newly allocated data loses its original -value -</td><td><pre> -#include <stdlib.h> - -void f(const int *); -void g(int *); - -void test() { - int *p1 = new int; - p1++; // warn - int *p2 = (int *)malloc(sizeof(int)); - p2 = p1; // warn - int *p3 = new int; - f(p3); - p3++; // warn - int *p4 = new int; - f(p4); - p4++; // ok -} -</pre></td><td class="aligned">done at r174678 (C case) -</td></tr> - -<tr><td><span class="name">memory.LeakEvalOrder<br> -(C, C++)</span><br><br> -Potential memory leak: argument evaluation order is undefined, g() may never be called -</td><td><pre> -#include <stdlib.h> - -void f1(int, int); -void f2(int*, int*); -int g(int *) { throw 1; }; -int h(); +</pre></div> +<div class="example"><pre> +void f(int, int); +int g(int *); +int h() { throw 1; }; void test() { - f1(g(new int), h()); // warn - f1(g((int *)malloc(sizeof(int))), h()); // warn - f2(new int, new int); -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">memory.DstBufferTooSmall -<br>(C, C++)</span><br><br> -Destination buffer too small -</td><td><pre> -#include <string.h> - + // It is possible that 'new int' is called first, + // then 'h()', that throws an exception and eventually + // 'g()' is never called. + f(g(new int), h()); // warn: 'g()' may never be called. +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +memory.DstBufferTooSmall</span><span class="lang"> +(C, C++)</span><div class="descr"> +Destination buffer passed to memory function is too small. +<br>Note: <span class="name">security.insecureAPI.strcpy</span> currently warns +on usage of <code>strcpy</code> and suggests to replace it. +<br>Note: <span class="name">alpha.unix.CStringChecker</span> contains some similar checks. +<p>Source: <a href="https://cwe.mitre.org/data/definitions/120.html">CWE-120</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test() { const char* s1 = "abc"; char *s2 = new char; strcpy(s2, s1); // warn - +} +</pre></div> +<div class="example"><pre> +void test() { int* p1 = new int[3]; int* p2 = new int; memcpy(p2, p1, 3); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">memory.NegativeArraySize -<br>enhancement to experimental.security.MallocOverflow<br>(C, C++) -</span><br><br> -'n' is used to specify the buffer size may be negative -</td><td><pre> -#include <stdlib.h> +<tr><td><div class="namedescr expandable"><span class="name"> +memory.NegativeArraySize</span><span class="lang"> +(C, C++)</span><div class="descr"> +'n' is used to specify the buffer size may be negative. +<br>Note: possibly an enhancement to <span class="name"> +alpha.security.MallocOverflow</span>. +<p>Source: <a href="http://cwe.mitre.org/data/definitions/20.html">CWE-20, +Example 2</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test() { int *p; int n1 = -1; p = new int[n1]; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> </table> @@ -144,42 +112,45 @@ void test() { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">ctordtor.ExptInsideDtorExplicit<br> -(C++)</span><br><br> -It is dangerous to let an exception leave a destructor. Using try..catch will -solve the problem. -</td><td><pre> -void f(); - +<tr><td><div class="namedescr expandable"><span class="name"> +ctordtor.ExptInsideDtor</span><span class="lang"> +(C++)</span><div class="descr"> +It is dangerous to let an exception leave a destructor. +Using <code>try..catch</code> solves the problem. +<p>Source: Scott Meyers "More Effective C++", item 11: Prevent exceptions from +leaving destructors.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { A() {} ~A() { throw 1; } // warn }; -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">ctordtor.ExptInsideDtorImplicit<br> -(C++)</span><br><br> -Calls to functions inside a destructor that are known to throw exceptions is -dangerous. Using try..catch will solve the problem. -</td><td><pre> -void f() { throw 1; }; +</pre></div> +<div class="example"><pre> +void f() throw(int); class A { A() {} ~A() { f(); } // warn }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">ctordtor.PlacementSelfCopy<br> -(C++11)</span><br><br> -For a placement copy or move, it is almost certainly an error if the constructed object is also the object being copied from. -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +ctordtor.PlacementSelfCopy</span><span class="lang"> +(C++11)</span><div class="descr"> +For a placement copy or move, it is almost certainly an error if the +constructed object is also the object being copied from.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A {}; void test(A *dst, A *src) { ::new (dst) A(*dst); // warn (should be 'src') } -</pre></td><td class="aligned"><!--rdar://problem/13688366--></td></tr> +</pre></div></div></td> +<td class="aligned"><!--rdar://problem/13688366--></td></tr> </table> @@ -189,37 +160,55 @@ void test(A *dst, A *src) { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">valist.Uninitialized</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +valist.Uninitialized</span><span class="lang"> +(C)</span><div class="descr"> Calls to the <code>va_arg</code>, <code>va_copy</code>, or <code>va_end</code> macro must happen after calling <code>va_start</code> and -before calling <code>va_end</code>. -</td><td><pre> +before calling <code>va_end</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <stdarg.h> void test(int x, ...) { va_list args; int y = va_arg(args, int); // warn +} +</pre></div> +<div class="example"><pre> +#include <stdarg.h> + +void test(int x, ...) { + va_list args; va_start(args, x); - va_end(args, x); + va_end(args); int z = va_arg(args, int); // warn } -</pre></td><td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16812">PR16811</a></td></tr> +</pre></div></div></td> +<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16812"> +PR16811</a></td></tr> -<tr><td><span class="name">valist.Unterminated</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +valist.Unterminated</span><span class="lang"> +(C)</span><div class="descr"> Every <code>va_start</code> must be matched by a <code>va_end</code>. A va_list can only be ended once. -<i>This should be folded into the generalized "ownership checker" described on the <a href="open_projects.html">Open Projects</a> page.</i> -</td><td><pre> +<i>This should be folded into the generalized "ownership checker" +described on the <a href="open_projects.html"> +Open Projects</a> page.</i></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <stdarg.h> void test(int x, ...) { va_list args; va_start(args, x); int y = x + va_arg(args, int); - // missing va_end -} -</pre></td><td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16812">PR16812</a></td></tr> +} // warn: missing va_end +</pre></div></div></td> +<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16812"> +PR16812</a></td></tr> </table> @@ -229,34 +218,48 @@ void test(int x, ...) { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">exceptions.ThrowSpecButNotThrow -<br>(C++)</span><br><br> -Function prototype has throw(T) specifier but the function do not throw -</td><td><pre> -void f() throw(int) { // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">exceptions.NoThrowSpecButThrows -<br>(C++)</span><br><br> -An exception is throw from a function having the throw() specifier -</td><td><pre> -void f() throw() { +<tr><td><div class="namedescr expandable"><span class="name"> +exceptions.ThrowSpecButNotThrow</span><span class="lang"> +(C++)</span><div class="descr"> +Function declaration has a <code>throw(<i>type</i>)</code> specifier but the +function do not throw exceptions.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() throw(int) { +} // warn +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +exceptions.NoThrowSpecButThrows</span><span class="lang"> +(C++)</span><div class="descr"> +An exception is throw from a function having a <code>throw()</code> +specifier.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() throw() { throw(1); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">exceptions.ThrownTypeDiffersSpec -<br>(C++)</span><br><br> -The type of a thrown exception differs from those specified in the throw(T) -specifier -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +exceptions.ThrownTypeDiffersSpec</span><span class="lang"> +(C++)</span><div class="descr"> +The type of a thrown exception differs from those specified in +a <code>throw(<i>type</i>)</code> specifier.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> struct S{}; -void f() throw(int) { + +void test() throw(int) { S s; throw (s); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> </table> @@ -266,25 +269,36 @@ void f() throw(int) { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">smartptr.SmartPtrInit<br> -(C++)</span><br><br> -C++03: auto_ptr should store a pointer to an object obtained via new as allocated -memory will be cleaned using delete<br> -C++11: one should use unique_ptr<T[]> to keep a pointer to memory -allocated by new[]<br> -C++11: to keep a pointer to memory allocated by new[] in a shared_ptr one -should use a custom deleter that calls delete[] -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +smartptr.SmartPtrInit</span><span class="lang"> +(C++)</span><div class="descr"> +C++03: <code>auto_ptr</code> should store a pointer to an object obtained via +new as allocated memory will be cleaned using <code>delete</code>.<br> +C++11: one should use <code>unique_ptr<<i>type</i>[]></code> to keep a +pointer to memory allocated by <code>new[]</code>.<br> +C++11: to keep a pointer to memory allocated by <code>new[]</code> in +a <code>shared_ptr</code> one should use a custom deleter that calls <code> +delete[].</code>. +<p>Source: C++03 20.4.5p1; C++11 <code>auto_ptr</code> is deprecated (D.10).</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <stdlib.h> #include <memory> void test() { std::auto_ptr<int> p1(new int); // Ok std::auto_ptr<int> p2(new int[3]); // warn - std::auto_ptr<int> - p3((int *)malloc(sizeof(int))); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +#include <stdlib.h> +#include <memory> + +void test() { + std::auto_ptr<int> p((int *)malloc(sizeof(int))); // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> </table> @@ -294,23 +308,90 @@ void test() { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">deadcode.UnmodifiedVariable -<br>(C, C++)</span><br><br> -A variable is never modified but was not declared const and is not a reference. -<br><br> -<i>(opt-in checker)</i> -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +deadcode.UnmodifiedVariable</span><span class="lang"> +(C, C++)</span><div class="descr"> +A variable is never modified but was not declared const and is not a +reference.<br><br><i>(opt-in checker)</i></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> extern int computeDelta(); -int foo(bool cond) { +int test(bool cond) { int i = 0; if (cond) { const int delta = computeDelta(); - // Forgot to modify 'i'. + // warn: forgot to modify 'i' } return i; } -</pre></td><td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16890">PR16890</a></td></tr> +</pre></div></div></td> +<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=16890">PR16890</a></td></tr> + +<tr><td><div class="namedescr expandable"><span class="name"> +deadcode.IdempotentOperations</span><span class="lang"> +(C)</span><div class="descr"> +Warn about idempotent operations.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int x = 7; + x = x; // warn: value is always the same +} +</pre></div> +<div class="example"><pre> +void test() { + int x = 7; + x /= x; // warn: value is always 1 +} +</pre></div> +<div class="example"><pre> +void test() { + int x = 7, one = 1; + x *= one; // warn: right op is always 1 +} +</pre></div> +<div class="example"><pre> +void test() { + int x = 7, zero = 0; + x = x - zero; + // warn: the right operand to '-' is always 0 +} +</pre></div></div></td> +<td class="aligned">removed from alpha.deadcode.* at r198476</td></tr> + +</table> + +<!-- ================================ POSIX ================================ --> +<h3>POSIX</h3> +<table class="checkers"> +<col class="namedescr"><col class="example"><col class="progress"> +<thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> + +<tr><td><div class="namedescr expandable"><span class="name"> +posix.Errno</span><span class="lang"> +(C)</span><div class="descr"> +Record that <code>errno</code> is non-zero when certain functions +fail.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +#include <stdlib.h> + +int readWrapper(int fd, int *count) { + int lcount = read(fd, globalBuf, sizeof(globalBuf)); + if (lcount < 0) + return errno; + *count = lcount; + return 0; +} + +void use(int fd) { + int count; + if (!readWrapper(fd, &count)) + print("%d", count); // should not warn +} +</pre></div></div></td> +<td class="aligned"><a href="http://llvm.org/bugs/show_bug.cgi?id=18701">PR18701</a></td></tr> </table> @@ -320,11 +401,14 @@ int foo(bool cond) { <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">undefbehavior.ExitInDtor -<br>(C++)</span><br><br> -Undefined behavior: std::exit is called to end the program during the -destruction of an object with static storage duration -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ExitInDtor</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: <code>std::exit()</code> is called to end the program during +the destruction of an object with static storage duration. +<p>Source: C++11 3.6.1p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <cstdlib> class A { @@ -333,17 +417,20 @@ public: std::exit(1); // warn } }; +</pre></div></div></td> +<td class="aligned"></td></tr> -A a; -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.LocalStaticDestroyed -<br>(C++)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.LocalStaticDestroyed</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: function containing a definition of static local object is called during the destruction of an object with static storage duration so that flow of control passes through the definition of the previously destroyed -static local object -</td><td><pre> +static local object. +<p>Source: C++11 3.6.3p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void f(); class A { @@ -358,299 +445,383 @@ class B {}; A a; void f() { - static B b; // <- + static B b; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.UseAfterRelease -<br>enhancement to unix.Malloc<br>(C, C++)</span><br><br> -Pointer to deleted object is referenced (The effect of using an invalid pointer -value is undefined) -</td><td><pre> -#include <stdlib.h> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ZeroAllocDereference</span><span class="lang"> +(C, C++)</span><div class="descr"> +The effect of dereferencing a pointer returned as a request for zero size is +undefined.<br> +Note: possibly an enhancement to <span class="name"> +unix.Malloc</span>. +<p>Source: C++03 3.7.3.1p2; C++11 3.7.4.1p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int *p = malloc(0); +*p = 1; // warn +</pre></div> +<div class="example"><pre> +int *p = new int{}; +int i = *p; // warn +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.DeadReferenced</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: the following usage of the pointer to the object whose +lifetime has ended can result in undefined behavior:<br> +The object will be or was of a class type with a non-trivial destructor and +<ul><li>the pointer is used as the operand of a delete-expression</li></ul> +The object will be or was of a non-POD class type (C++11: any class type) and +<ul><li>the pointer is used to access a non-static data member or call a +non-static member function of the object</li> +<li>the pointer is implicitly converted to a pointer to a base class +type</li> +<li>the pointer is used as the operand of a <code>static_cast</code> (except +when the conversion is to <code>void*</code>, or to <code>void*</code> and +subsequently to <code>char*</code>, or <code>unsigned char*</code>)</li> +<li>the pointer is used as the operand of a <code>dynamic_cast</code></li></ul> +<p>Source: C++03 3.8p5, p7; C++11 3.8p5, p7.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +#include <new> + +class A { +public: + ~A(); +}; + +class B : public A {}; void test() { - int *p = new int; - delete p; - int i = *p; // warn + A *a = new A; + new(a) B; + delete a; // warn } +</pre></div> +<div class="example"><pre> +#include <new> -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">undefbehavior.ZeroAllocDereference -<br>enhancement to unix.Malloc<br>(C, C++)</span><br><br> -The effect of dereferencing a pointer returned as a request for zero size is -undefined -</td><td><pre> -#include <stdlib.h> +class A { +public: + ~A(); +}; -int *p = new int[0]; -int i = p[0]; // warn -</pre></td><td class="aligned"></td></tr> +class B {}; -<tr><td><span class="name">undefbehavior.DeadReferenced -<br>(C++)</span><br><br> -Undefined behavior: the following usage of the pointer to the object whose -lifetime has ended can result in undefined behavior -</td><td><pre> -// C++03 +void test() { + A *a = new A; + new(a) B; + a->~A(); +} +</pre></div> +<div class="example"><pre> #include <new> class A { public: - int i; - void f() {}; + ~A(); }; -class B : public A { -}; +class B : public A {}; + +class C {}; + +void f(A*); void test() { B *b = new B; - new(b) A; - b->i; // warn - b->f(); // warn - static_cast<A*>(b); // warn - dynamic_cast<A*>(b); // warn - delete b; // warn + new(b) C; + f(b); // warn } - -// C++11 +</pre></div> +<div class="example"><pre> #include <new> class A { public: - int i; - void f() {}; + ~A(); }; -class B : public A { +class B : public A {}; + +class C {}; + +A* test() { + B *b = new B; + new(b) C; + return static_cast<A*>(b); // warn +} +</pre></div> +<div class="example"><pre> +#include <new> + +class A { public: - ~B() {}; + ~A(); }; -void test() { - A *a = new A; - new(a) B; - a->i; // warn - a->f(); // warn +class B : public A {}; + +class C {}; + +A* test() { B *b = new B; - new(b) A; - b->i; // warn - b->f(); // warn - static_cast<A*>(b); // warn - dynamic_cast<A*>(b); // warn - delete b; // warn + new(b) C; + return dynamic_cast<A*>(b); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.ObjLocChanges -<br>(C++)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ObjLocChanges</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: the program must ensure that an object occupies the same -storage location when the implicit or explicit destructor call takes place -</td><td><pre> +storage location when the implicit or explicit destructor call takes place. +<p>Source: C++11 3.8p8.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <new> -class T { }; -struct B { +class A {}; + +class B { +public: ~B(); }; void test() { - B *b1 = new B; - B b2; - new (b1) T; - new (&b2) T; - delete b1; // warn + B b; + new (&b) A; } // warn -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +#include <new> + +class A {}; -<tr><td><span class="name">undefbehavior.ExprEvalOrderUndef -<br>(C, C++03)</span><br><br> +class B { +public: + ~B(); +}; + +void test() { + B *b = new B; + new (b) A; + delete b; // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ExprEvalOrderUndef</span><span class="lang"> +(C, C++03)</span><div class="descr"> Undefined behavior: a scalar object shall have its stored value modified at -most once by the evaluation of an expression -</td><td><pre> -void test () { +most once by the evaluation of an expression.<br> +Note: most cases are currently handled by the Clang core (search for 'multiple +unsequenced modifications' warning in Clang tests). +<p>Source: C++03 5p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int test () { int i = 0; - int v[1] = {0}; - i = v[i++]; // warn i = ++i + 1; // warn + return i; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.StaticInitReentered -<br>(C)</span><br><br> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.StaticInitReentered</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: static declaration is re-entered while the object is being -initialized -</td><td><pre> +initialized. +<p>Source: C++11 6.7p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> int test(int i) { - static int s = test(2*i); // warn - return i+1; + static int s = test(2 * i); // warn + return i + 1; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.ConstModified -<br>(C, C++)</span><br><br> -Undefined behavior: const object is being modified -</td><td><pre> -#include <stdlib.h> -class X { -public : - mutable int i; - int j; -}; -class Y { +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ConstModified</span><span class="lang"> +(C, C++)</span><div class="descr"> +Undefined behavior: const object is being modified. +<p>Source: C++03 7.1.5.1p4, C++11 7.1.6.1p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + const int *cp = new const int (0); + int *p = const_cast<int *>(cp); + *p = 1; // warn + delete p; +} +</pre></div> +<div class="example"><pre> +class C { public : - X x; - Y(); + int i; + C(); }; void test() { - const int *ciq = - (int *)malloc(sizeof(int)); - int *iq = const_cast<int *>(ciq); - *iq = 1; // warn + const C cb; - const Y y; - Y* p = const_cast<Y*>(&y); - p->x.i = 1; // ok - p->x.j = 1; // warn + C* cp = const_cast<C *>(&cb); + cp->i = 1; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.DeadDestructed -<br>(C++)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.DeadDestructed</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: the destructor is invoked for an object whose lifetime -has ended -</td><td><pre> +has ended. +<p>Source: C++11 12.4p14.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { public: - void f() {}; - A() {}; - ~A() {}; + void f(); + A(); + ~A(); }; void test() { A a; a.~A(); } // warn -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.MethodCallBeforeBaseInit -<br>(C++)</span><br><br> -Undefined behavior: calls member function but base not yet initialized -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.MethodCallBeforeBaseInit</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: calls member function but base not yet initialized. +<p>Source: C++03 12.6.2p8; C++11 12.6.2p13.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { public : - A(int ); + A(int); }; + class B : public A { public : int f(); B() : A(f()) {} // warn }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.MemberOrBaseRefBeforeCtor -<br>(C++)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.MemberOrBaseRefBeforeCtor</span><span class="lang"> +(C++)</span><div class="descr"> C++ Undefined behavior: non-static member or base class of non-POD class type -is referred before constructor begins execution<br> +is referred before constructor begins execution.<br> C++11 Undefined behavior: non-static member or base class of a class with a -non-trivial constructor is referred before constructor begins execution -</td><td><pre> -// C++03 +non-trivial constructor is referred before constructor begins execution. +<p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +struct non_POD { + int i; + non_POD(); +}; + +extern non_POD non_pod; + +int *p = &non_pod.i; // warn +</pre></div> +<div class="example"><pre> struct POD { int i; }; -struct non_POD : public POD { - int j; +struct non_POD : public POD { POD pod; }; -extern POD pod; extern non_POD non_pod; -int *p1 = &non_pod.j; // warn -int *p2 = &non_pod.pod.i; // warn -int *p3 = &pod.i; // ok -POD *p4 = &non_pod; // warn - -POD a; -non_POD b; - -struct S { - int *k; - non_POD non_pod; - S() : k(&non_pod.j) {} // warn -}; - -// C++11 -struct trivial { +int *p = &non_pod.pod.i; // warn +</pre></div> +<div class="example"><pre> +struct POD { int i; }; -struct non_trivial: public trivial { - non_trivial() {}; - int j; - trivial pod; -}; - -extern trivial t; -extern non_trivial nt; +struct non_POD : public POD {}; -int *p1 = &nt.j; // warn -int *p2 = &nt.i; // warn -int *p3 = &t.i; // ok -trivial *p4 = &nt; +extern non_POD non_pod; -trivial t; -non_trivial nt; +POD *p = &non_pod; // warn +</pre></div> +<div class="example"><pre> +struct non_POD { + int i; + non_POD(); +}; struct S { int *k; - non_trivial nt; - S() : k(&nt.j) {} // warn + non_POD non_pod; + S() : k(&non_pod.i) {} // warn }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.MemberRefAfterDtor -<br>(C++)</span><br><br> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.MemberRefAfterDtor</span><span class="lang"> +(C++)</span><div class="descr"> C++03: Undefined behavior: non-static member of non-POD class type is referred -after destructor ends execution<br> +after destructor ends execution.<br> C++11: Undefined behavior: non-static member of a class with a non-trivial -destructor is referred after destructor ends execution -</td><td><pre> -// C++03 -struct non_POD { - virtual void f() {}; +destructor is referred after destructor ends execution. +<p>Source: C++03 12.7p1; C++11 12.7p1.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +class C { +public: + C(); + void f(); }; void test() { - non_POD *non_pod = new non_POD(); - non_pod->~non_POD(); - non_pod->f(); // warn + C *c = new C(); + c->~C(); + c->f(); // warn } +</pre></div></div></td> +<td class="aligned"></td></tr> -// C++11 -struct S { - ~S() {}; - void f() {}; -}; - -void test() { - S *s = new S(); - s->~S(); - s->f(); // warn -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.CtorForeignCall -<br>(C++)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.CtorForeignCall</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: call to virtual function of an object under construction -whose type is neither the constructors own class or one of its bases -</td><td><pre> +whose type is neither the constructors own class or one of its bases. +<p>Source: C++11 12.7p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { public: virtual void f() {}; @@ -665,15 +836,47 @@ class C : public A, B { public: C() : B((A*)this) {} }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.CtorForeignCast -undefbehavior.CtorForeignTypeid -<br>(C++)</span><br><br> -Undefined behavior: the operand of typeid/dynamic_cast is an object under + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.CtorForeignTypeid</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: the operand of <code>typeid</code> is an object under construction whose type is neither the constructors own class or one of its -bases -</td><td><pre> +bases. +<p>Source: C++11 12.7p5.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +#include <typeinfo> + +class A {}; + +class B { +public: + B(A* a) { + (void)typeid(*a); // warn + } +}; + +class C : public A, B { +public: + C() : B((A*)this) {} +}; +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.CtorForeignCast</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: the operand of <code>dynamic_cast</code> is an object under +construction whose type is neither the constructors own class or one of its +bases. +<p>Source: C++11 12.7p6.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <typeinfo> class A { @@ -684,8 +887,7 @@ public: class B { public: B(A* a) { - typeid(*a); // warn - dynamic_cast<B*>(a); //warn + (void)dynamic_cast<B*>(a); //warn } }; @@ -693,45 +895,83 @@ class C : public A, B { public: C() : B((A*)this) {} }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.MemberRefInCatch -undefbehavior.BaseRefInCatch -<br>(C++)</span><br><br> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.MemberOrBaseRefInCatch</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: referring to any non-static member or base class of an object in the handler for a function-try-block of a constructor or destructor -for that object results in undefined behavior -</td><td><pre> +for that object results in undefined behavior. +<p>Source: C++11 15.3p10.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void f() { throw 1; } + class C { int i; public : C() - try - : i(1) {} - catch (...) - { + try { + f(); + } + catch (...) { i=2; // warn } }; -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +void f() { throw 1; } -<tr><td><span class="name">undefbehavior.ReturnAtCatchEnd -<br>(C++)</span><br><br> +class Base { +public: + int i; +}; + +class C: public Base { +public : + ~C() try { + f(); + } + catch (...) { + i=2; // warn + } +}; +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ReturnAtCatchEnd</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: a function returns when control reaches the end of a -handler. This results in undefined behavior in a value-returning -function -</td><td><pre> +handler. This results in undefined behavior in a value-returning function. +<p>Source: C++11 15.3p10.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void f() { throw 1; } + int test() try { + f(); + return 1; } catch(int) { } // warn -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">undefbehavior.AutoptrsOwnSameObj -<br>(C++03)</span><br><br> -Undefined behavior: if more than one auto_ptr owns the same object at the same -time the behavior of the program is undefined. -</td><td><pre> +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.AutoptrsOwnSameObj</span><span class="lang"> +(C++03)</span><div class="descr"> +Undefined behavior: if more than one <code>auto_ptr</code> owns the same object +at the same time the behavior of the program is undefined. +<p>Source: C++03 20.4.5p3; C++11 <code>auto_ptr</code> is deprecated +(D.10).</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <memory> void test() { @@ -739,71 +979,83 @@ void test() { std::auto_ptr<int> p(data); std::auto_ptr<int> q(data); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.BasicStringOutOfBound</span><span class="lang"> +(C++03)</span><div class="descr"> +Undefined behavior: out-of-bound <code>basic_string</code> access/modification. +<br>Note: possibly an enhancement to <span class="name"> +alpha.security.ArrayBoundV2</span>. +<p>Source: C++03 21.3.4p1; C++11 behavior is defined +(21.4.5p2).</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +#include <string> -<tr><td><span class="name">undefbehavior.BasicStringBoundAccess -<br>(C++03)</span><br><br> -Undefined behavior: out-of-bound basic_string access -</td><td><pre> void test() { std::basic_string<char> s; char c = s[10]; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +#include <string> -<tr><td><span class="name">undefbehavior.BasicStringBoundModification -<br>(C++)</span><br><br> -Undefined behavior: out-of-bound basic_string modification -</td><td><pre> void test() { std::basic_string<char> s; s[10] = 0; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.EosDereference -<br>(C++)</span><br><br> -Undefined behavior: the result of operator*() on an end of stream is -undefined -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.EosDereference</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: the result of <code>operator*()</code> on an end of a +stream is undefined. +<p>Source: C++03 24.5.3p2; C++11 24.6.3p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <vector> -void test() { +int test() { std::vector<int> v; - int i = *v.end(); // warn - *v.end() = 0; // warn + return *v.end(); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.QsortNonPOD -undefbehavior.QsortNonTrivial -<br>C++</span><br><br> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.QsortNonPODNonTrivial</span><span class="lang"> +(C++)</span><div class="descr"> C++03: Undefined behavior: the objects in the array passed to qsort are of -non-POD type<br> +non-POD type.<br> C++11: Undefined behavior: the objects in the array passed to qsort are of -non-trivial type -</td><td><pre> +non-trivial type. +<p>Source: C++03 25.4p4; C++11 25.5p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> // C++03 #include <cstdlib> + struct non_POD { - int i; - non_POD(int ii) : i(ii) {} + non_POD(); }; -non_POD values[] = { non_POD(2), non_POD(1) }; +non_POD values[] = { non_POD(), non_POD() }; -int compare(const void *a, - const void *b) { - return ( (*(non_POD*)a).i - - (*(non_POD*)b).i ); -} +int compare(const void *a, const void *b); void test() { - qsort(values, 2, sizeof(non_POD), - compare); // warn + qsort(values, 2, sizeof(non_POD), compare); // warn } - +</pre></div> +<div class="example"><pre> // C++11 #include <cstdlib> @@ -815,57 +1067,64 @@ struct trivial_non_POD : public S { struct non_trivial { int i; - non_trivial() {} + non_trivial(); }; trivial_non_POD tnp[2]; non_trivial nt[2]; -int compare1(const void *a, - const void *b) { - return ( (*(trivial_non_POD *)a).i - - (*(trivial_non_POD *)b).i ); -} +int compare1(const void *a, const void *b); -int compare2(const void *a, - const void *b) { - return ( (*(non_trivial *)a).i - - (*(non_trivial *)b).i ); -} +int compare2(const void *a, const void *b); void test() { - qsort(tnp, 2, sizeof(trivial_non_POD), - compare1); // ok - qsort(nt, 2, sizeof(non_trivial), - compare2); // warn + qsort(tnp, 2, sizeof(trivial_non_POD), compare1); // ok + qsort(nt, 2, sizeof(non_trivial), compare2); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.ThrowWhileCopy -<br>C++</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ThrowWhileCopy</span><span class="lang"> +(C++)</span><div class="descr"> Undefined behavior: copy constructor/assignment operator can throw an exception. -The effects are undefined if an exception is thrown. -</td><td><pre> -struct S { +The effects are undefined if an exception is thrown.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +class C { +public: int i, j; - S (const S &s) { - i = s.i; + C (const C &c) { + i = c.i; throw 1; // warn - j = s.j; + j = c.j; }; - S &operator=(const S &s) { - i = s.i; +}; +</pre></div> +<div class="example"><pre> +class C { +public: + int i, j; + C &operator=(const C &c) { + i = c.i; throw 1; // warn - j = s.j; - } + j = c.j; + }; }; -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">undefbehavior.ValarrayArgBound -<br>(C++)</span><br><br> -Undefined behavior: the value of the second argument is greater than the number -of values pointed to by the first argument -</td><td><pre> +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ValarrayArgBound</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: the value of the <code><i>n</i></code> argument passed +to <code>valarray</code> constructor is greater than the number of values +pointed to by the first argument (source). +<p>Source: C++03 26.3.2.1p4; C++11 26.6.2.2p4.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <valarray> struct S { @@ -877,88 +1136,133 @@ void test(void) { S s[] = { S(1), S(2) }; std::valarray<S> v(s,3); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.ValarrayLengthDiffer -<br>(C++)</span><br><br> -Undefined behavior: valarray operands are of different length -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ValarrayLengthDiffer</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: <code>valarray</code> operands are of different length. +<p>Source: C++03 26.3.2.2p1, 26.3.2.6p3, 26.3.3.1p3, 26.3.3.2p3; +C++11 defined (26.6.2.3p1), 26.6.2.7p3, 26.6.3.1p3, +26.6.3.2p3.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> // C++03 #include <valarray> void test(void) { std::valarray<int> a(0, 1), b(0, 2); - std::valarray<bool> c(false, 1); a = b; // warn - a *= b; // warn - a = a * b; // warn - c = a == b; // warn b.resize(1); - a = b; // OK + a = b; // ok } +</pre></div> +<div class="example"><pre> +// C++03, C++11 +#include <valarray> -// C++11 +void test(void) { + std::valarray<int> a(0, 1), b(0, 2); + a *= b; // warn +} +</pre></div> +<div class="example"><pre> +// C++03, C++11 +#include <valarray> + +void test(void) { + std::valarray<int> a(0, 1), b(0, 2); + a = a + b; // warn +} +</pre></div> +<div class="example"><pre> +// C++03, C++11 #include <valarray> void test(void) { std::valarray<int> a(0, 1), b(0, 2); std::valarray<bool> c(false, 1); - a = b; // ok - a *= b; // ok - a = a * b; // warn c = a == b; // warn - b.resize(1); - a = b; // OK } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.ValarrayZeroLength -<br>(C++)</span><br><br> -Undefined behavior: calling sum()/min()/max() method of an array having zero -length, the behavior is undefined -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ValarrayZeroLength</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: calling <code>sum()</code>/<code>min()</code>/<code> +max()</code> methods of a zero length <code>valarray<code> the behavior is +undefined. +<p>Source: C++03 26.3.2.7p2, p3, p4; C++11 26.6.2.8p5, p6, +p7.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <valarray> void test(void) { std::valarray<int> v(0, 0); v.sum(); // warn - v.min(); // warn - v.max(); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.ValarrayBadIndirection -<br>(C++)</span><br><br> -Undefined behavior: element N is specified more than once in the -indirection -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.ValarrayBadIndirection</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: element is specified more than once in an indirection. +<p>Source: C++03 26.3.9.2p2, 26.3.9.3p2; C++11 26.6.9.2p2, +26.6.9.3p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <valarray> void test() { - size_t addr[] = {0, 1, 1}; // N is 1 + // '1' is specified more then once + size_t addr[] = {0, 1, 1}; std::valarray<size_t>indirect(addr, 3); std::valarray<int> a(0, 5), b(1, 3); a[indirect] = b; //warn +} +</pre></div> +<div class="example"><pre> +#include <valarray> + +void test() { + // '1' is specified more then once + size_t addr[] = {0, 1, 1}; + std::valarray<size_t>indirect(addr, 3); + std::valarray<int> a(0, 5), b(1, 3); a[indirect] *= b; //warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">undefbehavior.IosBaseDestroyedBeforeInit -<br>(C++)</span><br> -<br>Undefined behavior: ios_base object is destroyed before initialization have -taken place. basic_ios::init should be call to initialize ios_base -members -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.IosBaseDestroyedBeforeInit</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: <code>ios_base</code> object is destroyed before +initialization have taken place. <code>basic_ios::init</code> should be call to +initialize <code>ios_base</code> members. +<p>Source: C++03 27.4.2.7p1, 27.4.4.1p2; C++11 27.5.3.7p1, +27.5.5.2p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <ios> using namespace std; -template <class T, class Traits = std::char_traits<T>> +template <class T, class Traits = std::char_traits<T> > class my_stream1 : public std::basic_ios<T, Traits> { }; -template <class T, class Traits = std::char_traits<T>> +template <class T, class Traits = std::char_traits<T> > class my_stream2 : public std::basic_ios<T, Traits> { - class my_streambuf : public std::basic_streambuf<T, Traits> { + class my_streambuf + : public std::basic_streambuf<T, Traits> { }; public: my_stream2() { @@ -967,28 +1271,35 @@ public: }; void test() { - my_stream1<char> *p1 = new my_stream1<char> - my_stream2<char> *p2 = new my_stream2<char> + my_stream1<char> *p1 = new my_stream1<char>; + my_stream2<char> *p2 = new my_stream2<char>; delete p1; // warn delete p2; // ok } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.IosBaseUsedBeforeInit -<br>(C++11)</span><br><br> -Undefined behavior: ios_base object is used before initialization have taken -place. basic_ios::init should be call to initialize ios_base members -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.IosBaseUsedBeforeInit</span><span class="lang"> +(C++11)</span><div class="descr"> +Undefined behavior: <code>ios_base</code> object is used before initialization +have taken place. <code>basic_ios::init</code> should be call to +initialize <code>ios_base</code> members. +<p>Source: C++11 27.5.3.7p1, 27.5.5.2p2.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <ios> using namespace std; -template <class T, class Traits = std::char_traits<T>> +template <class T, class Traits = std::char_traits<T> > class my_stream1 : public std::basic_ios<T, Traits> { }; -template <class T, class Traits = std::char_traits<T>> +template <class T, class Traits = std::char_traits<T> > class my_stream2 : public std::basic_ios<T, Traits> { - class my_streambuf : public std::basic_streambuf<T, Traits> { + class my_streambuf + : public std::basic_streambuf<T, Traits> { }; public: my_stream2() { @@ -997,20 +1308,24 @@ public: }; void test() { - my_stream1<char> *p1 = new my_stream1<char> - my_stream2<char> *p2 = new my_stream2<char> + my_stream1<char> *p1 = new my_stream1<char>; + my_stream2<char> *p2 = new my_stream2<char>; p1->narrow('a', 'b'); // warn p2->narrow('a', 'b'); // ok - delete p1; // warn - delete p2; // ok } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">undefbehavior.MinusOnePosType -<br>(C++)</span><br><br> -Undefined behavior: passing -1 to any streambuf/istream/ostream member that -accepts a value of type traits::pos_type result in undefined behavior -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +undefbehavior.MinusOnePosType</span><span class="lang"> +(C++)</span><div class="descr"> +Undefined behavior: passing -1 to any <code>streambuf</code>/<code> +istream</code>/<code>ostream</code> member that accepts a value of +type <code>traits::pos_type</code> result in undefined behavior. +<p>Source: C++03 27.4.3.2p3; C++11 27.5.4.2p3.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <fstream> class my_streambuf : public std::streambuf { @@ -1018,16 +1333,19 @@ class my_streambuf : public std::streambuf { seekpos(-1); // warn } }; +</pre></div> +<div class="example"><pre> +#include <fstream> void test() { std::filebuf fb; std::istream in(&fb); - std::ostream out(&fb); std::filebuf::off_type pos(-1); in.seekg(pos); // warn - out.seekp(-1); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + </table> <!-- ============================ different ================================ --> @@ -1037,472 +1355,505 @@ void test() { <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr> </thead> -<tr><td><span class="name">different.ArgEvalOrderUndef -<br>(C)</span><br><br> -Errors because of the order of evaluation of function arguments is undefined -</td><td><pre> -void f(int, int); - -void test() { - int i = 0; - int v[1] = {0}; - f(v[i], i++); // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">different.IdenticalExprBinOp -<br>(C)</span><br><br> -There are identical sub-expressions to the left and to the right of the -operator -</td><td><pre> -#define A 1 -#define B 1 - -bool isNan(double d) { - return d != d; // ok -} - -int f(); - -void test() { - int i = 0; - if (i != 0 && i != 0) {} // warn - - if(i == A || i == B) {} // ok - - if (++i != 0 && ++i != 0) {} // ok - - if (f() && f()) {} // ok -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">different.FuncPtrInsteadOfCall -<br>(C)</span><br><br> -Possibly a function call should be used instead of a pointer to function -</td><td><pre> -int f(); - -void test() { - if (f == 0) {} // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">different.IdenticalCondIfElseIf -<br>(C)</span><br><br> -The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a -probability of logical error presence -</td><td><pre> -void test() { - int i = 7; - if (i == 1) {} - else if (i == 1) {} // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">SuccessiveAssign -<br>(C)</span><br><br> -Successive assign to a variable -</td><td><pre> -void test() { - int i=0; +<tr><td><div class="namedescr expandable"><span class="name"> +different.SuccessiveAssign</span><span class="lang"> +(C)</span><div class="descr"> +Successive assign to a variable.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int test() { + int i; i=1; i=2; // warn + return i; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.NullDerefStmtOrder -<br>enhancement to core.NullDereference<br>(C)</span><br><br> +<tr><td><div class="namedescr expandable"><span class="name"> +different.NullDerefStmtOrder</span><span class="lang"> +(C)</span><div class="descr"> Dereferencing of the null pointer might take place. Checking the pointer for -null should be performed first -</td><td><pre> +null should be performed first. +<br>Note: possibly an enhancement to <span class="name"> +core.NullDereference</span>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> struct S { int x; }; -S* f(); +struct S* f(); void test() { - S *p1 = f(); + struct S *p1 = f(); int x1 = p1->x; // warn if (p1) {}; - S *p2 = f(); + struct S *p2 = f(); int x2 = p2->x; // ok } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.NullDerefCondOrder -<br>enhancement to core.NullDereference<br>(C)</span><br><br> + +<tr><td><div class="namedescr expandable"><span class="name"> +different.NullDerefCondOrder</span><span class="lang"> +(C)</span><div class="descr"> Dereferencing of the null pointer might take place. Checking the pointer for -null should be performed first -</td><td><pre> -struct S{bool b;}; +null should be performed first. +<br>Note: possibly an enhancement to <span class="name"> +core.NullDereference</span>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +struct S {int i;}; -S* f(); +struct S* f(); void test() { - S *p = f(); - if (p->b && p) {}; // warn + struct S *p = f(); + if (p->i && p) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.IdenticalStmtThenElse -<br>(C)</span><br><br> -The 'else' statement is equivalent to the 'then' statement -</td><td><pre> -void test() { - int i; - if (i==1) { - i++; - } - else { // warn - i++; - } -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">different.MultipleAccessors -<br>(C++)</span><br><br> -multiple accessors met for 'class::field' -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.MultipleAccessors</span><span class="lang"> +(C++)</span><div class="descr"> +Identical accessor bodies. Possibly a misprint.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { int i; int j; public: int getI() { return i; } int getJ() { return i; } // warn +}; +</pre></div> +<div class="example"><pre> +class A { + int i; + int j; +public: void setI(int& ii) { i = ii; } void setJ(int& jj) { i = jj; } // warn }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.AccessorsForPublic -<br>(C++)</span><br><br> -Accessors exist for 'class::field'. Should this field really be public? -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.AccessorsForPublic</span><span class="lang"> +(C++)</span><div class="descr"> +Accessors exist for a public class field. Should this field really be +public?</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> class A { public: int i; // warn int getI() { return i; } void setI(int& ii) { i = ii; } }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.LibFuncResultUnised -<br>(C, C++)</span><br><br> -Calling 'f' ignoring its return value is of no use (* create the list of known -system/library/API functions falling into this category) -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +different.LibFuncResultUnised</span><span class="lang"> +(C, C++)</span><div class="descr"> +Calling a function ignoring its return value is of no use (create the list of +known system/library/API functions falling into this category).</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <vector> void test() { std::vector<int> v; v.empty(); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.WrongVarForStmt -<br>(C, C++)</span><br><br> -Possibly wrong variable is used in the loop/cond-expression of the 'for' -statement. Did you mean 'proper_variable_name'? -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.WrongVarForStmt</span><span class="lang"> +(C, C++)</span><div class="descr"> +Wrong variable is possibly used in the loop/cond-expression of +the <code>for</code> statement. Did you mean +'proper_variable_name'?</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test() { - int i; - int j; - for (j=0; j<3; ++i); // warn - for (int j=0; i<3; ++j); // warn + int i = 0; + int j = 0; + for (i = 0; i < 3; j += 1); // warn +} +</pre></div> +<div class="example"><pre> +void test() { + int i = 0; + int j = 0; + for (int j = 0; i < 3; ++j); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.FloatingCompare -<br>(C)</span><br><br> -Comparing floating point numbers may be not precise -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.FloatingCompare</span><span class="lang"> +(C)</span><div class="descr"> +Comparing floating point numbers may be not precise.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <math.h> -void test() { +double test() { double b = sin(M_PI / 6.0); if (b == 0.5) // warn b = 0; + return b; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.BoolCompare -<br>maybe merge with experimental.core.BoolAssignment<br>(C, C++)</span><br><br> -Comparing boolean to a value other then 0 or 1 -</td><td><pre> -void test() { - int i; - if (0 < i < 3) {}; // warn - bool b; - if (b == 3) {}; // warn -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">different.BitwiseOpBoolArg -<br>maybe join with experimental.core.BoolAssignment<br>(C, C++)</span><br><br> -bool value is used at the left/right part of the & (|) operator. Did you mean -&& (||) ? -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.BitwiseOpBoolArg</span><span class="lang"> +(C, C++)</span><div class="descr"> +Boolean value met at the left/right part of the bitwise <code>&</code> +or <code>|</code> operator. +Did you mean <code>&&</code> (<code>||</code>) ?</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> int f(); void test() { bool b = true; if (b & f()) {} // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.LabelInsideSwitch -<br>(C)</span><br><br> -Possible misprint: label found inside the switch() statement. (* did you mean -'default'?) -</td><td><pre> -void test() { - int c = 7; + +<tr><td><div class="namedescr expandable"><span class="name"> +different.LabelInsideSwitch</span><span class="lang"> +(C)</span><div class="descr"> +Possibly a misprint: label found inside a <code>switch()</code> +statement.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(int c) { switch(c){ case 1: c += 1; break; - defalt: // warn + defalt: // warn (did you mean 'default'?) c -= 1; break; } } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.IdenticalCondIfIf -<br>(C)</span><br><br> -The conditions of two subsequent 'if' statements are identical -</td><td><pre> -void test() { - int c = 7; - if (c > 5) // <- + +<tr><td><div class="namedescr expandable"><span class="name"> +different.IdenticalCondIfIf</span><span class="lang"> +(C)</span><div class="descr"> +The conditions of two subsequent <code>if</code> statements are +identical.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +int test(int c) { + if (c > 5) c += 1; if (c > 5) // warn c -= 1; + return c; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.CondOpIdenticalReturn -<br>(C)</span><br><br> -The return expressions of the '?:' operator are identical -</td><td><pre> -void test() { - unsigned a; - a = a > 5 ? a : a; // warn -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">different.LogicalOpUselessArg -<br>(C)</span><br><br> -The second operand of the && operator has no impact on expression result -</td><td><pre> -void test() { - unsigned a; +<tr><td><div class="namedescr expandable"><span class="name"> +different.LogicalOpUselessArg</span><span class="lang"> +(C)</span><div class="descr"> +The second operand of a <code>&&</code> operator has no impact on +expression result.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test(unsigned a) { if (a<7 && a<10) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.SameResLogicalExpr -<br>(C)</span><br><br> -The expression always evaluates to true/false -</td><td><pre> -void test() { - int i=0; - if (i!=0) {}; // warn - if (i==0 && i==1) {}; // warn - if (i<0 || i>=0) {}; // warn -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">different.SameResUnsignedCmp -<br>(C)</span><br><br> -Comparison of unsigned expression 'op expr' is always true/false -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.SameResLogicalExpr</span><span class="lang"> +(C)</span><div class="descr"> +An expression is always evaluated to true/false.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test() { - unsigned u; - if (u < -1) {}; // warn - if (u >= 0) {}; // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">different.OpPrecedenceAssignCmp -<br>(C)</span><br><br> -Comparison operation has higher precedence then assignment. Bool value is -assigned to variable of type 'type'. Parenthesis may bee required around an -assignment -</td><td><pre> + int i = 0; + if (i != 0) {}; // warn +} +</pre></div> +<div class="example"><pre> +void test(int i) { + if (i == 0 && i == 1) {}; // warn +} +</pre></div> +<div class="example"><pre> +void test(int i) { + if (i < 0 || i >= 0) {}; // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +different.OpPrecedenceAssignCmp</span><span class="lang"> +(C, C++)</span><div class="descr"> +Comparison operation has higher precedence then assignment. Boolean value is +assigned to a variable of other type. Parenthesis may bee required around an +assignment.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> int f(); -void test() { +void test(int x, int y) { bool b; - int x, y; if((b = x != y)) {} // ok if((x = f() != y)) {} // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.OpPrecedenceIifShift -<br>(C)</span><br><br> -?: has lower precedence then << -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.OpPrecedenceIifShift</span><span class="lang"> +(C, C++)</span><div class="descr"> +<code>?:</code> has lower precedence then <code><<</code>. +<p>Source: Stephen C. Dewhurst "C++ Gotchas: Avoiding Common Problems in Coding +and Design", advise 15.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <iostream> -void test() { - int a; +void test(int a) { std::cout << a ? "a" : "b"; // warn - a << a>7 ? 1 : 2; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +void test(int a) { + a << a > 7 ? 1 : 2; // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.ObjectUnused -<br>(C++)</span><br><br> -The object was created but is not being used<br><br> -The exception object was created but is not being used. Did you mean -'throw std::exception();'? -</td><td><pre> -#include <exception> +<tr><td><div class="namedescr expandable"><span class="name"> +different.ObjectUnused</span><span class="lang"> +(C++)</span><div class="descr"> +The object was created but is not being used.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> struct S { int x, y; - S(int xx, int yy) : x(xx), y(yy) { - } + S(int xx, int yy) : x(xx), y(yy) {} S(int xx) { S(xx, 0); // warn } }; +</pre></div> +<div class="example"><pre> +#include <exception> void test() { - S(0, 0); // warn - std::exception(); // warn + std::exception(); + // warn (did you mean 'throw std::exception()'?) } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.StaticArrayPtrCompare -<br>(C)</span><br><br> -Pointer to static array is being compared to NULL. May the subscripting is -missing -</td><td><pre> -void test() { - int a1[1]; - if (a1 == 0) {}; // warn - int a2[1][1]; - if (a2[0]) {}; // warn +<tr><td><div class="namedescr expandable"><span class="name"> +different.StaticArrayPtrCompare</span><span class="lang"> +(C)</span><div class="descr"> +Pointer to static array is being compared to NULL. May the subscripting is +missing.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +void test() { + int a[1][1]; + if (a[0] == 0) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.ConversionToBool -<br>maybe join with experimental.core.BoolAssignment<br>(C, C++)</span><br><br> -Odd implicit conversion from 'type' to 'bool' -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.ConversionToBool</span><span class="lang"> +(C, C++)</span><div class="descr"> +Odd implicit conversion to boolean. +<br>Note: possibly merge with <span class="name"> +alpha.core.BoolAssignment</span>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> bool test() { return 1.; // warn +} +</pre></div> +<div class="example"><pre> +bool test() { return ""; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.ArrayBound -<br>enhancement to experimental.security.ArrayBound[v2]<br>(C, C++)</span><br><br> -Out-of-bound dynamic array access -</td><td><pre> -#include <stdlib.h> +<tr><td><div class="namedescr expandable"><span class="name"> +different.ArrayBound</span><span class="lang"> +(C++)</span><div class="descr"> +Out-of-bound dynamic array access. +<br>Note: possibly an enhancement to <span class="name"> +alpha.security.ArrayBoundV2</span>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test() { - int *p2 = new int[1]; - if(p2[1]) {}; // warn + int *p = new int[1]; int i = 1; - if(p2[i]) {}; // warn + if(p[i]) {}; // warn + delete[] p; } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">different.StrcpyInputSize -<BR>enhancement to experimental.unix.cstring.OutOfBounds<br>(C)</span><br><br> -Buffer copy without checking size of input -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +different.StrcpyInputSize</span><span class="lang"> +(C)</span><div class="descr"> +Buffer copy without checking the size of input. +<br>Note: possibly an enhancement to <span class="name"> +alpha.unix.cstring.OutOfBounds</span>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> void test(char* string) { char buf[24]; strcpy(buf, string); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.IntegerOverflow -<br>(C)</span><br><br> -Integer overflow -</td><td><pre> + +<tr><td><div class="namedescr expandable"><span class="name"> +different.IntegerOverflow</span><span class="lang"> +(C)</span><div class="descr"> +Integer overflow. +<br>Note: partially handled by Clang core +(search for 'overflow in expression' warning in Clang tests). +<p>Source: <a href="http://cwe.mitre.org/data/definitions/190.html"> +CWE-190</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <limits.h> -int f(int x) { - return INT_MAX+1; // warn -} +int f(int x); void test() { - int x = INT_MAX+1; // warn - f(INT_MAX+1); // warn - - int y = INT_MAX/2+1; // warn - x = y*2; // warn + f(INT_MAX + 1); // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +#include <limits.h> -<tr><td><span class="name">different.SignExtension -<br>(C)</span><br><br> -Unexpected sign extension might take place -</td><td><pre> +int test() { + int x = INT_MAX / 2 + 1; + return x * 2; // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +different.SignExtension</span><span class="lang"> +(C)</span><div class="descr"> +Unexpected sign extension might take place. +<p>Source: <a href="http://cwe.mitre.org/data/definitions/194.html"> +CWE-194</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +unsigned long long test(long long sll) { + unsigned long long ull = sll; // warn + return ull; +} +</pre></div> +<div class="example"><pre> void f(unsigned int i); -int g(); -unsigned int test() { - long long sll; - unsigned long long ull = sll; // warn - long sl; - unsigned long ul = sl; // warn - int si; - unsigned int ui = si; // warn - short ss; - unsigned short us = ss; // warn - signed char sc; - unsigned char uc = sc; // warn +void test(int si) { f(si); // warn - ui = g(); // warn - return si; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div> +<div class="example"><pre> +unsigned int test(int i) { + return i; +} +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">different.NumericTruncation -<br>(C)</span><br><br> -Numeric truncation might take place -</td><td><pre> -void f(int i); -int g(); -int test() { - unsigned long long ull; - long long sll; +<tr><td><div class="namedescr expandable"><span class="name"> +different.NumericTruncation</span><span class="lang"> +(C)</span><div class="descr"> +Numeric truncation might take place. +<p>Source: <a href="http://cwe.mitre.org/data/definitions/197.html"> +CWE-197</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +unsigned long test(unsigned long long ull) { unsigned long ul = ull; // warn - long sl = sll; // warn - unsigned int ui = ul; // warn - int si = sl; // warn - unsigned short us = ui; // warn - short ss = si; // warn - unsigned char uc = us; // warn - signed char sc = uc; // warn + return ul; +} +</pre></div> +<div class="example"><pre> +void f(int i); + +void test(long long sll) { f(sll); // warn - ss = g(); // warn - return sll; // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">different.MissingCopyCtorAssignOp -<br>(C, C++)</span><br><br> -The class has dynamically allocated data members but do not define a copy -constructor/assignment operator -</td><td><pre> -class C { // warn - int *p; // <- +} +</pre></div> +<div class="example"><pre> +int f(); + +short test(long long sll) { + short ss = f(); + return ss; +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +different.MissingCopyCtorAssignOp</span><span class="lang"> +(C++)</span><div class="descr"> +A class has dynamically allocated data members but do not define a copy +constructor/assignment operator. +<p>Source: Scott Meyers "Effective C++", item 11: Prevent exceptions from +leaving destructors.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +class C { + int *p; // warn public: C() { p = new int; } ~C() { delete p; } }; -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> </table> @@ -1512,57 +1863,73 @@ public: <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">WinAPI.CreateProcess -<br>(C)</span><br><br> -After calling CreateProcess(), ensure that process and thread handles get closed -(* for the given example: examine data flow from pi, pi.hProcess and pi.hThread) -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +WinAPI.CreateProcess</span><span class="lang"> +(C)</span><div class="descr"> +<code>CreateProcess()</code>: if the first parameter <code><i> +lpApplicationName</i></code> is NULL then the executable name must be in the +white space-delimited string pointed to by <code><i>lpCommandLine</code></i>. +If the executable or path name has a space in it, there is a risk that a +different executable could be run because of the way the function parses +spaces. +<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms682425%28v=vs.85%29.aspx"> +MSDN: CreateProcess function, Security Remarks</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <windows.h> void test() { STARTUPINFO si; PROCESS_INFORMATION pi; - BOOL fSuccess; - fSuccess = CreateProcess( - NULL, TEXT("MyProgram.exe"), NULL, NULL, - TRUE, 0, NULL, NULL, &si, &pi); -} // warn -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">WinAPI.LoadLibrary -<br>(C)</span><br><br> -Calling LoadLibrary without a fully qualified path may allow to load a DLL from -arbitrary location -</td><td><pre> + CreateProcess(NULL, TEXT("C:\\Program Files\\App -L -S"), + NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi); + // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +WinAPI.LoadLibrary</span><span class="lang"> +(C)</span><div class="descr"> +The <code>SearchPath()</code> function is used to retrieve a path to a DLL for +a subsequent <code>LoadLibrary()</code> call. +<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms684175%28v=vs.85%29.aspx"> +MSDN: LoadLibrary function, Security Remarks</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <windows.h> -void test() { - HINSTANCE h = LoadLibrary("X.dll"); // warn -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">WinAPI.WideCharToMultiByte -<br>(C)</span><br><br> -Buffer overrun while calling WideCharToMultiByte -</td><td><pre> +HINSTANCE test() { + char filePath[100]; + SearchPath(NULL, "file.dll", NULL, 100, filePath, NULL); + return LoadLibrary(filePath); // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +WinAPI.WideCharToMultiByte</span><span class="lang"> +(C)</span><div class="descr"> +Buffer overrun while calling <code>WideCharToMultiByte()</code>. The size of +the input buffer equals the number of characters in the Unicode string, while +the size of the output buffer equals the number of bytes. +<p>Source: <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130%28v=vs.85%29.aspx"> +MSDN: WideCharToMultiByte function</a>.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <windows.h> -void test() -{ +void test() { wchar_t ws[] = L"abc"; char s[3]; - int res1 = WideCharToMultiByte( - CP_UTF8, 0, ws, -1, s, - 3, NULL, NULL); // warn - int res2 = WideCharToMultiByte( - CP_UTF8, 0, ws, -1, s, - 3, NULL, NULL); // ok - if (res2 == sizeof(s)) - s[res2-1] = 0; - else - s[res2] = 0; -} -</pre></td><td class="aligned"></td></tr> + WideCharToMultiByte(CP_UTF8, 0, ws, -1, s, + 3, NULL, NULL); // warn +} +</pre></div></div></td> +<td class="aligned"></td></tr> + </table> @@ -1572,25 +1939,30 @@ void test() <col class="namedescr"><col class="example"><col class="progress"> <thead><tr><td>Name, Description</td><td>Example</td><td>Progress</td></tr></thead> -<tr><td><span class="name">optimization.PassConstObjByValue -<br>(C, C++)</span><br><br> -Optimization: It is more effective to pass const n-th parameter by reference to -avoid unnecessary object copying -</td><td><pre> -struct A { - int a[20]; - int b; -}; - -bool FirstIsZero(const struct A a) { // warn - return a.a[0] == 0; -} -</pre></td><td class="aligned"></td></tr> - -<tr><td><span class="name">optimization.PostfixIncIter -<br>(C++)</span><br><br> -Optimization: It is more effective to use prefix ++ with iterator here -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +optimization.PassConstObjByValue</span><span class="lang"> +(C, C++)</span><div class="descr"> +Optimization: It is more effective to pass constant parameter by reference to +avoid unnecessary object copying.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> +struct A {}; + +void f(const struct A a); // warn +</pre></div></div></td> +<td class="aligned"></td></tr> + + +<tr><td><div class="namedescr expandable"><span class="name"> +optimization.PostfixIncIter</span><span class="lang"> +(C++)</span><div class="descr"> +Optimization: It is more effective to use prefix increment operator with +iterator. +<p>Source: Scott Meyers "More Effective C++", item 6: +Distinguish between prefix and postfix forms of increment and decrement +operators.</p></div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <vector> void test() { @@ -1599,41 +1971,35 @@ void test() { for(it = v.begin(); it != v.end(); it++) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">optimization.MultipleCallsStrlen -<br>(C)</span><br><br> -Optimization: multiple calls to strlen for a given string in the given -expression. It is more effective to hold strlen result in a temporary -variable -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +optimization.MultipleCallsStrlen</span><span class="lang"> +(C)</span><div class="descr"> +Optimization: multiple calls to <code>strlen()</code> for a string in an +expression. It is more effective to hold a value returned +from <code>strlen()</code> in a temporary variable.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <string.h> -void test() { - const char* s = "abc"; +void test(const char* s) { if (strlen(s) > 0 && strlen(s) < 7) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> -<tr><td><span class="name">optimization.EmptyCstrDetect -<br>(C)</span><br><br> -Optimization: it is more efficient to use "str[0] != '\0'" to identify an empty -string -</td><td><pre> -#include <string.h> - -void test() { - const char* s = "abc"; - if (strlen(s) > 0) {}; // warn -} -</pre></td><td class="aligned"></td></tr> -<tr><td><span class="name">optimization.StrLengthCalculation -<br>(C, C++)</span><br><br> -Optimization: it is more efficient to use string::length() method to calculate -string length -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +optimization.StrLengthCalculation</span><span class="lang"> +(C++)</span><div class="descr"> +Optimization: it is more efficient to use <code>string::length()</code> to +calculate the length of an <code>std::string</code>.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <string> #include <string.h> @@ -1641,20 +2007,26 @@ void test() { std::string s; if (strlen(s.c_str()) != 0) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + -<tr><td><span class="name">optimization.EmptyContainerDetect -<br>(C, C++)</span><br><br> -Optimization: It is more efficient to use container.empty() to identify an -empty container -</td><td><pre> +<tr><td><div class="namedescr expandable"><span class="name"> +optimization.EmptyContainerDetect</span><span class="lang"> +(C++)</span><div class="descr"> +Optimization: It is more efficient to use containers <code>empty()</code> +method to identify an empty container.</div></div></td> +<td><div class="exampleContainer expandable"> +<div class="example"><pre> #include <list> void test() { std::list<int> l; if (l.size() != 0) {}; // warn } -</pre></td><td class="aligned"></td></tr> +</pre></div></div></td> +<td class="aligned"></td></tr> + </table> diff --git a/www/analyzer/release_notes.html b/www/analyzer/release_notes.html index bc052bbec0af..81f9c9a52da9 100644 --- a/www/analyzer/release_notes.html +++ b/www/analyzer/release_notes.html @@ -15,6 +15,18 @@ <h1>Release notes for <tt>checker-XXX</tt> builds</h1> +<h4 id="checker_276">checker-276</h4> +<p><b>built:</b> February 19, 2014</br> + <b>download:</b> <a href="downloads/checker-276.tar.bz2">checker-276.tar.bz2</a></p> + <p><b>highlights:</b></p> + <ul> + <li>Includes about 9 months of change to Clang itself (improved C++11/14 support, etc.)</li> + <li>More precise modeling of Objective-C properties, which enables the analyzer to find more bugs.</li> + <li>Includes a new "missing call to <tt>super</tt>" warning, which looks for common pattern in iOS/OSX APIs that require chaining a call to a super class's implementation of a method.</li> + <li>Accepts <tt>-arch arm64</tt> (which may be passed by Xcode 5.0), but for the time being analyzes code in such cases as <tt>-arch armv7s</tt>.</li> + <li>Many sundry fixes, improvements to C++ support, etc.</li> + </ul> + <h4 id="checker_275">checker-275</h4> <p><b>built:</b> May 23, 2013</br> <b>download:</b> <a href="downloads/checker-275.tar.bz2">checker-275.tar.bz2</a></p> diff --git a/www/analyzer/scan-build.html b/www/analyzer/scan-build.html index 9c4070b060d8..abd2bc0dda89 100644 --- a/www/analyzer/scan-build.html +++ b/www/analyzer/scan-build.html @@ -6,7 +6,6 @@ <link type="text/css" rel="stylesheet" href="content.css"> <link type="text/css" rel="stylesheet" href="menu.css"> <script type="text/javascript" src="scripts/menu.js"></script> - <script type="text/javascript" src="scripts/dbtree.js"></script> </head> <body> @@ -53,7 +52,7 @@ aforementioned hack fails to work.</p> <h2>Contents</h2> -<ul id="collapsetree" class="dbtree onclick multiple"> +<ul> <li><a href="#scanbuild">Getting Started</a> <ul> <li><a href="#scanbuild_basicusage">Basic Usage</a></li> diff --git a/www/analyzer/scripts/dbtree.js b/www/analyzer/scripts/dbtree.js deleted file mode 100644 index 5face5db96de..000000000000 --- a/www/analyzer/scripts/dbtree.js +++ /dev/null @@ -1 +0,0 @@ -eval(function(p,a,c,k,e,r){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('7 5,r,Q,u;7 17=[];5=H;1i();9(!1Z.1j.20){1Z.1j.20=k(a){C[C.D]=a}}7 19=\'35+/\';k 36(a){7 b,R=\'\',i=0;I(;i<a.D;i+=4){b=(19.1k(a.1l(i))&1a)<<18|(19.1k(a.1l(i+1))&1a)<<12|(19.1k(a.1l(i+2))&1a)<<6|19.1k(a.1l(i+3))&1a;R+=37.38((b&39)>>16,(b&3a)>>8,b&1a)}9(a.21(i-2)==22)1m=R.23(0,R.D-2);s 9(a.21(i-1)==22)1m=R.23(0,R.D-1);s 1m=R;z 3b(1m)}7 A={24:k(){7 a=l.E(\'X\');I(7 i=0;i<a.D;i++){9(a[i].h.F(/\\1n\\b/)==-1)3c;7 b=a[i];9(b.h.F(/\\1E\\b/)!=-1){7 c=b.E(\'a\');I(7 j=0;j<c.D;j++){m.B(c[j],\'25\',1F,o);m.B(c[j],\'26\',1G,o);m.B(c[j],\'1o\',1b,o);c[j].Y=\'1H:1I(0)\'}}7 d=b.E(\'X\');I(7 j=0;j<d.D;j++){7 e=d[j].p;e.27=J;9(b.h.F(/\\3d\\b/)!=-1){m.B(e,\'w\',A.w,o);9(b.h.F(/\\3e\\b/)==-1){e.E(\'a\')[0].Y=\'1H:1I(0)\'}}s{7 t=b.h.3f(/1J(.*)1J/);t=t?t[1]:H;m.B(e,\'3g\',A.28(e,t),o);m.B(e,\'3h\',A.29(e),o)}e.E(\'a\')[0].h+=\' 2a\'}9(b.h.F(/\\3i\\b/)!=-1)A.2b(b.v)}},2b:k(a){7 b=l.G(a+\'3j\');9(b){A.1p(b);b=b.p;1c(!!b&&(b.v!=a)){9((!b.h)||(b.h==\'\')){b.h=\'w\'}s{b.h+=\' w\'}9(b.1d.K.L()==\'a\')b.1d.h+=\' w\';b=b.p}}},29:k(a){z k(){A.1p(a)}},28:k(a,b){z k(){A.2c(a,b)}},1p:k(a){7 b=a;3k(b.2d);I(7 i=0;i<b.S.D;i++){7 c=b.S[i];9(c.K.L()==\'X\'){b.E(\'a\')[0].h+=\' w\';b.h+=\' w\';c.h+=\' w\'}}},2c:k(a,b){7 c=a;c.2d=3l(k(){A.1q(c)},b)},1q:k(a){I(7 i=0;i<a.S.D;i++){7 b=a.S[i];9(b.K.L()==\'X\'){a.E(\'a\')[0].h=a.E(\'a\')[0].h.1K(/w/g,\'\');b.h=b.h.1K(/w/g,\'\');a.h=a.h.1K(/w/g,\'\')}}},w:k(e){9(M.T){M.T.1L=J}9(e&&e.1r){e.1r()}7 a=(M.T)?M.T.2e:(e)?e.1M:H;9(!a||!(a=A.1N(a,\'2f\')))z;9(a.E(\'a\')[0].h.F(/\\2g\\b/)==-1){7 b=1e(a);9(2h(b)){9(l.G(b).h.F(/\\3m\\b/)==-1){I(n=0;n<a.p.S.D;n++){N=a.p.S[n];9(N.K.L()==\'2f\'){9(N.h.F(/\\2g\\b/)!=-1)A.1q(a.p.S[n])}}}}A.1p(a)}s{A.1q(a)}9(2h(1e(a))){z J}s{z o}},1N:k(a,b){9(a.K.L()!=b&&a.K.L()!=\'U\'){z A.1N(a.p,b)}s 9(a.K.L()==\'U\'){z H}s{z a}}};k 1i(){3n{u=M.2i?O 2i():O 3o(\'3p.3q\')}3r(e){2j(\'2k 2l: 3s 3t 3u 3v 3w-3x!\')}}k 1O(a,x){a.1f.3y=x+\'2m\'}k 1P(a,y){a.1f.3z=y+\'2m\'}k 1e(a){1c(a.h.F(/\\1n\\b/)==-1){a=a.p}9((a.h.F(/\\1n\\b/)!=-1)&&(a.h.F(/\\1E\\b/)!=-1)){I(i=0;i<17.D;i++){9(a.v==17[i].q)z i}}z a.v}k 1G(a){a=O m(a);r=a.P.p.p.v;7 b=r.1s(\'Z\');r=b[1];5=17[1e(a.P)];7 c=l.G(5.q+\'10\').3A(J);7 d=l.G(5.q+\'10\');d.p.2n(d);c.v=5.q+\'10\';l.U.2o(c);1O(c,a.x);1P(c,a.y);c.1f.1Q=\'2p\';a.1t();m.B(l,\'1u\',1R,o);z o}k 1R(c){c=O m(c);7 e;7 a=c.P;7 b=a;1c((b!=H)&&(b.K.L()!=\'U\')){9(b.v==5.q+\'10\')1g;b=b.p}9((b!=H)&&(b.v==5.q+\'10\')){3B(a.p.h){1S\'3C\':a.Y=5.V+\'11=1T&N=\'+5.13;1g;1S\'1T\':a.Y=5.V+\'11=1T&N=\'+r;1g;1S\'2q\':a.Y=5.V+\'11=2q&N=\'+r;1g;3D:e=5.2r+\'?q=\'+5.q;e+=\'&13=\'+5.13;9(a.p.h==\'3E\'){e+=\'&11=2s&N=\'+r+\'&2t=\'+5.13}s{e+=\'&11=\'+a.p.h+\'&N=\'+r}7 d=O 2u();7 f=d.2v();e+=\'&2w=\'+f;e+=\'&1v=\'+5.1v;e+=\'&1w=\'+5.1w;e+=\'&1x=\'+5.1x;e+=\'&1y=\'+5.1y;e+=\'&1z=\'+5.1z;e+=\'&1A=\'+5.1A;e+=\'&v=\'+5.v;e+=\'&1B=\'+5.1B;e+=\'&1C=\'+5.1C;e+=\'&V=\'+5.V;u.2x=1U;u.1V(\'2y\',e,J);u.14(\'2z\',\'2A-2B\');u.14(\'2C-2D\',\'2E-2F\');u.14(\'2G-2H-2I\',l.2J);u.2K(H)}}7 g=l.G(5.q+\'10\');9(g){g.1f.1Q=\'3F\'};m.1h(l,\'1u\',1R,o)}k 1F(a){a=O m(a);r=a.P.p.p.v;7 b=r.1s(\'Z\');r=b[1];5=17[1e(a.P)];9(!l.G(5.q+\'15\')){7 c=(!l.G(5.q+\'15\'))?l.3G(\'3H\'):l.G(5.q+\'15\');c.v=5.q+\'15\';c.2L=a.P.1d.3I;l.U.2o(c)}m.B(l,\'2M\',1W,o);m.B(l,\'1u\',1X,o);m.B(l,\'1o\',1b,o);a.1t();z o}k 1b(a){9(!a&&M.T)a=M.T;9(a!=H){9(3J(a.1Y)==\'k\')a.1Y();s a.2N=o}z o}k 1W(a){a=O m(a);7 b=l.G(5.q+\'15\');1O(b,a.x);1P(b,a.y);b.1f.1Q=\'2p\';a.1t();z o}k 1X(a){a=O m(a);7 b=a.P.p;9(b.K.L()==\'a\'){r=5.q+\'Z\'+r;9(r!=b.p.v){7 c=J;7 d=b.p;1c(!!d&&(d.v!=5.q)){9(d.v==r){c=o;1g}s{d=d.p}}9(c==J){7 e=r.1s(\'Z\');r=e[1];Q=b.p.v;7 f=Q.1s(\'Z\');Q=f[1];2O(a)}}}7 g=l.G(5.q+\'15\');9(g){g.p.2n(g)};m.1h(l,\'2M\',1W,o);m.1h(l,\'1u\',1X,o);m.1h(l,\'1o\',1b,o)}k 2O(a){7 d=O 2u();7 b=d.2v();7 c;c=5.2r+\'?q=\'+5.q+\'&11=2s&13=\'+5.13+\'&N=\'+r+\'&2t=\'+Q+\'&2w=\'+b;c+=\'&1v=\'+5.1v;c+=\'&1w=\'+5.1w;c+=\'&1x=\'+5.1x;c+=\'&1y=\'+5.1y;c+=\'&1z=\'+5.1z;c+=\'&1A=\'+5.1A;c+=\'&v=\'+5.v;c+=\'&1B=\'+5.1B;c+=\'&1C=\'+5.1C;c+=\'&V=\'+5.V;u.2x=1U;u.1V(\'2y\',c,J);u.14(\'2z\',\'2A-2B\');u.14(\'2C-2D\',\'2E-2F\');u.14(\'2G-2H-2I\',l.2J);u.2K(H)}k 2P(){7 a=(!!Q)?Q:r;a=5.q+\'Z\'+a;a=l.G(a);9(a){a=a.E(\'X\')[0];1c(!!a&&(a.h.F(/\\1n\\b/)==-1)&&(a.h.F(/\\1E\\b/)==-1)){9((!a.h)||(a.h==\'\')){a.h=\'w\'}s{a.h+=\' w\'}9(a.1d.K.L()==\'a\')a.1d.h+=\' w\';a=a.p}}}k 3K(a,b){9(a!=\'3L\'){3M(a+".3N=\'"+b.2Q[b.2R].2S+"\'")}s{M.1V(b.2Q[b.2R].2S)}}k 2T(a){7 b=l.G(a);7 c=b.E(\'X\');I(7 j=0;j<c.D;j++){7 d=c[j].p;d.27=J;m.B(d,\'w\',A.w,o);d.E(\'a\')[0].h+=\' 2a\'}7 e=b.E(\'a\');I(7 j=0;j<e.D;j++){m.B(e[j],\'25\',1F,o);m.B(e[j],\'26\',1G,o);m.B(e[j],\'1o\',1b,o);e[j].Y=\'1H:1I(0)\'}}k 1U(){9(u.3O==4){9(u.3P==3Q){l.G(5.q+\'3R\').2L=u.3S;2T(5.q);2P();1i()}s{2j(\'2k 2l: 3T, 3U 3V 1J 3W a 3X 3Y 3Z 40:\\n\'+u.41);1i()}}}k m(a){C.W=a?a:M.T;C.P=a.1M?a.1M:a.2e;C.x=a.2U?(a.2U):(a.42+2V.2W(l.U.2X,l.2Y.2X));C.y=a.2Z?(a.2Z):(a.43+2V.2W(l.U.30,l.2Y.30))}m.1j.44=k(){z\'m [ x = \'+C.x+\', y = \'+C.y+\' ]\'};m.1j.1t=k(){9(C.W.1r){C.W.1r();C.W.1Y()}s 9(C.W.1L){C.W.1L=J;C.W.2N=o}};m.B=k(a,b,c,d){9(l.31){a.31(b,c,d)}s 9(l.32){a.32(\'1D\'+b,c,d)}s{a[\'1D\'+b]=c}};m.1h=k(a,b,c,d){9(l.33){a.33(b,c,d)}s 9(l.34){a.34(\'1D\'+b,c,d)}s{a[\'1D\'+b]=H}};m.B(M,\'45\',A.24,o);',62,254,'|||||instance||var||if||||||||className|||function|document|Evt||false|parentNode|instanceName|nid|else||client|id|click|||return|dbTree|addEvent|this|length|getElementsByTagName|search|getElementById|null|for|true|nodeName|toLowerCase|window|node|new|source|nto|decOut|childNodes|event|body|editpage|evt|ul|href|_|_options|action||rootnode|setRequestHeader|_tip||dbtreeObj||b64s|0xff|PreventDefault|while|firstChild|getObj|style|break|removeEvent|createClient|prototype|indexOf|charAt|undecOut|bdbtree|selectstart|mOver|mOut|stopPropagation|split|consume|mouseup|type|query|datasource|username|password|table|parent|contentfield|on|bedit|dragPress|contextMenu|javascript|void|to|replace|cancelBubble|target|getTarget|setX|setY|display|contextAction|case|add|callback|open|dragMove|dragRelease|preventDefault|Array|push|charCodeAt|61|substring|init|mousedown|contextmenu|hasSubMenu|getMoutFor|getMoverFor|subMenu|mExp|mTimeout|timeout|srcElement|li|bclick|isNaN|XMLHttpRequest|alert|DBTree|Error|px|removeChild|appendChild|block|edit|tagpath|move|nodeto|Date|getTime|time|onreadystatechange|get|Pragma|no|cache|Cache|Control|must|revalidate|If|Modified|Since|lastModified|send|innerHTML|mousemove|returnValue|dragBoxDropped|expandtree|options|selectedIndex|value|reinit|pageX|Math|max|scrollLeft|documentElement|pageY|scrollTop|addEventListener|attachEvent|removeEventListener|detachEvent|ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789|decode|String|fromCharCode|0xff0000|0xff00|unescape|continue|bonclick|blinkparent|match|mouseout|mouseover|bexpand|_active|clearTimeout|setTimeout|bmultiple|try|ActiveXObject|Microsoft|XMLHTTP|catch|Your|browser|is|not|Ajax|enabled|left|top|cloneNode|switch|addroot|default|moveroot|none|createElement|div|nodeValue|typeof|jumpTo|blank|eval|location|readyState|status|200|_edit|responseText|Sorry|there|seems|be|problem|retrieving|the|response|statusText|clientX|clientY|toString|load'.split('|'),0,{})) diff --git a/www/analyzer/scripts/expandcollapse.js b/www/analyzer/scripts/expandcollapse.js new file mode 100644 index 000000000000..593a9831c8b0 --- /dev/null +++ b/www/analyzer/scripts/expandcollapse.js @@ -0,0 +1,191 @@ +// expand/collapse button (expander) is added if height of a cell content +// exceeds CLIP_HEIGHT px. +var CLIP_HEIGHT = 135; + +// Height in pixels of an expander image. +var EXPANDER_HEIGHT = 13; + +// Path to images for an expander. +var imgPath = "./images/expandcollapse/"; + +// array[group][cell] of { 'height', 'expanded' }. +// group: a number; cells of the same group belong to the same table row. +// cell: a number; unique index of a cell in a group. +// height: a number, px; original height of a cell in a table. +// expanded: boolean; is a cell expanded or collapsed? +var CellsInfo = []; + +// Extracts group and cell indices from an id of the form identifier_group_cell. +function getCellIdx(id) { + var idx = id.substr(id.indexOf("_") + 1).split("_"); + return { 'group': idx[0], 'cell': idx[1] }; +} + +// Returns { 'height', 'expanded' } info for a cell with a given id. +function getCellInfo(id) { + var idx = getCellIdx(id); + return CellsInfo[idx.group][idx.cell]; +} + +// Initialization, add nodes, collect info. +function initExpandCollapse() { + if (!document.getElementById) + return; + + var groupCount = 0; + + // Examine all table rows in the document. + var rows = document.body.getElementsByTagName("tr"); + for (var i=0; i<rows.length; i+=1) { + + var cellCount=0, newGroupCreated = false; + + // Examine all divs in a table row. + var divs = rows[i].getElementsByTagName("div"); + for (var j=0; j<divs.length; j+=1) { + + var expandableDiv = divs[j]; + + if (expandableDiv.className.indexOf("expandable") == -1) + continue; + + if (expandableDiv.offsetHeight <= CLIP_HEIGHT) + continue; + + // We found a div wrapping a cell content whose height exceeds + // CLIP_HEIGHT. + var originalHeight = expandableDiv.offsetHeight; + // Unique postfix for ids for generated nodes for a given cell. + var idxStr = "_" + groupCount + "_" + cellCount; + // Create an expander and an additional wrapper for a cell content. + // + // --- expandableDiv ---- + // --- expandableDiv --- | ------ data ------ | + // | cell content | -> | | cell content | | + // --------------------- | ------------------ | + // | ---- expander ---- | + // ---------------------- + var data = document.createElement("div"); + data.className = "data"; + data.id = "data" + idxStr; + data.innerHTML = expandableDiv.innerHTML; + with (data.style) { height = (CLIP_HEIGHT - EXPANDER_HEIGHT) + "px"; + overflow = "hidden" } + + var expander = document.createElement("img"); + with (expander.style) { display = "block"; paddingTop = "5px"; } + expander.src = imgPath + "ellipses_light.gif"; + expander.id = "expander" + idxStr; + + // Add mouse calbacks to expander. + expander.onclick = function() { + expandCollapse(this.id); + // Hack for Opera - onmouseout callback is not invoked when page + // content changes dinamically and mouse pointer goes out of an element. + this.src = imgPath + + (getCellInfo(this.id).expanded ? "arrows_light.gif" + : "ellipses_light.gif"); + } + expander.onmouseover = function() { + this.src = imgPath + + (getCellInfo(this.id).expanded ? "arrows_dark.gif" + : "ellipses_dark.gif"); + } + expander.onmouseout = function() { + this.src = imgPath + + (getCellInfo(this.id).expanded ? "arrows_light.gif" + : "ellipses_light.gif"); + } + + expandableDiv.innerHTML = ""; + expandableDiv.appendChild(data); + expandableDiv.appendChild(expander); + expandableDiv.style.height = CLIP_HEIGHT + "px"; + expandableDiv.id = "cell"+ idxStr; + + // Keep original cell height and its ecpanded/cpllapsed state. + if (!newGroupCreated) { + CellsInfo[groupCount] = []; + newGroupCreated = true; + } + CellsInfo[groupCount][cellCount] = { 'height' : originalHeight, + 'expanded' : false }; + cellCount += 1; + } + groupCount += newGroupCreated ? 1 : 0; + } +} + +function isElemTopVisible(elem) { + var body = document.body, + html = document.documentElement, + // Calculate expandableDiv absolute Y coordinate from the top of body. + bodyRect = body.getBoundingClientRect(), + elemRect = elem.getBoundingClientRect(), + elemOffset = Math.floor(elemRect.top - bodyRect.top), + // Calculate the absoute Y coordinate of visible area. + scrollTop = html.scrollTop || body && body.scrollTop || 0; + scrollTop -= html.clientTop; // IE<8 + + + if (elemOffset < scrollTop) + return false; + + return true; +} + +// Invoked when an expander is pressed; expand/collapse a cell. +function expandCollapse(id) { + var cellInfo = getCellInfo(id); + var idx = getCellIdx(id); + + // New height of a row. + var newHeight; + // Smart page scrolling may be done after collapse. + var mayNeedScroll; + + if (cellInfo.expanded) { + // Cell is expanded - collapse the row height to CLIP_HEIGHT. + newHeight = CLIP_HEIGHT; + mayNeedScroll = true; + } + else { + // Cell is collapsed - expand the row height to the cells original height. + newHeight = cellInfo.height; + mayNeedScroll = false; + } + + // Update all cells (height and expanded/collapsed state) in a row according + // to the new height of the row. + for (var i = 0; i < CellsInfo[idx.group].length; i++) { + var idxStr = "_" + idx.group + "_" + i; + var expandableDiv = document.getElementById("cell" + idxStr); + expandableDiv.style.height = newHeight + "px"; + var data = document.getElementById("data" + idxStr); + var expander = document.getElementById("expander" + idxStr); + var state = CellsInfo[idx.group][i]; + + if (state.height > newHeight) { + // Cell height exceeds row height - collapse a cell. + data.style.height = (newHeight - EXPANDER_HEIGHT) + "px"; + expander.src = imgPath + "ellipses_light.gif"; + CellsInfo[idx.group][i].expanded = false; + } else { + // Cell height is less then or equal to row height - expand a cell. + data.style.height = ""; + expander.src = imgPath + "arrows_light.gif"; + CellsInfo[idx.group][i].expanded = true; + } + } + + if (mayNeedScroll) { + var idxStr = "_" + idx.group + "_" + idx.cell; + var clickedExpandableDiv = document.getElementById("cell" + idxStr); + // Scroll page up if a row is collapsed and the rows top is above the + // viewport. The amount of scroll is the difference between a new and old + // row height. + if (!isElemTopVisible(clickedExpandableDiv)) { + window.scrollBy(0, newHeight - cellInfo.height); + } + } +} diff --git a/www/analyzer/xcode.html b/www/analyzer/xcode.html index 4bae1c15b868..e01f32b55ca8 100644 --- a/www/analyzer/xcode.html +++ b/www/analyzer/xcode.html @@ -6,7 +6,6 @@ <link type="text/css" rel="stylesheet" href="content.css"> <link type="text/css" rel="stylesheet" href="menu.css"> <script type="text/javascript" src="scripts/menu.js"></script> - <script type="text/javascript" src="scripts/dbtree.js"></script> </head> <body> diff --git a/www/comparison.html b/www/comparison.html index afc321e06191..4bca65dc40d3 100644 --- a/www/comparison.html +++ b/www/comparison.html @@ -31,7 +31,7 @@ analysis, you may not care that something lacks codegen support, for example.</p> - <p>Please email cfe-dev if you think we should add another compiler to this + <p>Please email <a href="get_involved.html">cfe-dev</a> if you think we should add another compiler to this list or if you think some characterization is unfair here.</p> <ul> @@ -49,10 +49,16 @@ <ul> <li>GCC supports languages that clang does not aim to, such as Java, Ada, - FORTRAN, etc.</li> + FORTRAN, Go, etc.</li> <li>GCC supports more targets than LLVM.</li> + <li>GCC supports many language extensions, some of which are not implemented + by Clang. For instance, in C mode, GCC supports + <a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html">nested + functions</a> and has an + <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37428">undocumented + extension allowing VLAs in structs</a>. </ul> - + <p>Pro's of clang vs GCC:</p> <ul> @@ -76,12 +82,6 @@ custom garbage collector, uses global variables extensively, is not reentrant or multi-threadable, etc. Clang has none of these problems. </li> - <li>For every token, clang tracks information about where it was written and - where it was ultimately expanded into if it was involved in a macro. - GCC does not track information about macro instantiations when parsing - source code. This makes it very difficult for source rewriting tools - (e.g. for refactoring) to work in the presence of (even simple) - macros.</li> <li>Clang does not implicitly simplify code as it parses it like GCC does. Doing so causes many problems for source analysis tools: as one simple example, if you write "x-x" in your source code, the GCC AST will @@ -108,9 +108,13 @@ including support for a bytecode representation for intermediate code, pluggable optimizers, link-time optimization support, Just-In-Time compilation, ability to link in multiple code generators, etc.</li> - <li><a href="compatibility.html#c++">Clang's support for C++</a> is more - compliant than GCC's in many ways (e.g. conformant two phase name - lookup).</li> + <li><a href="compatibility.html#cxx">Clang's support for C++</a> is more + compliant than GCC's in many ways.</li> + <li>Clang supports + <a href="http://clang.llvm.org/docs/LanguageExtensions.html">many language + extensions</a>, some of which are not implemented by GCC. For instance, + Clang provides attributes for checking thread safety and extended vector + types.</li> </ul> <!--=====================================================================--> diff --git a/www/cxx_dr_status.html b/www/cxx_dr_status.html index b38cc3a71693..2d58415a111e 100644 --- a/www/cxx_dr_status.html +++ b/www/cxx_dr_status.html @@ -1,5 +1,6 @@ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<!-- This file is auto-generated by make_cxx_dr_status. Do not modify. --> <html> <head> <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> @@ -14,7 +15,7 @@ .na { background-color: #DDDDDD } .open * { color: #AAAAAA } //.open { filter: opacity(0.2) } - span:target { background-color: #FFFFBB; outline: #DDDD55 solid thin; } + tr:target { background-color: #FFFFBB } th { background-color: #FFDDAA } </style> </head> @@ -27,7 +28,7 @@ <!--*************************************************************************--> <h1>C++ Defect Report Support in Clang</h1> <!--*************************************************************************--> -<p>Last updated: $Date: 2013-12-03 08:40:27 +0100 (Tue, 03 Dec 2013) $</p> +<p>Last updated: $Date: 2014-06-03 23:58:55 +0200 (Tue, 03 Jun 2014) $</p> <h2 id="cxxdr">C++ defect report implementation status</h2> @@ -40,3231 +41,3231 @@ <th>Issue title</th> <th>Available in Clang?</th> </tr> - <tr> + <tr id="1"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1">1</a></td> <td>TC1</td> <td>What if two using-declarations refer to the same function but the declarations introduce different default-arguments?</td> <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="2"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2">2</a></td> <td>drafting</td> <td>How can dependent names be used in member declarations that appear outside of the class template definition?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="3"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#3">3</a></td> <td>NAD</td> <td>The template compilation model rules render some explicit specialization declarations not visible during instantiation</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="4"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#4">4</a></td> <td>CD1</td> <td>Does extern "C" affect the linkage of function names with internal linkage?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="5"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#5">5</a></td> <td>CD1</td> <td>CV-qualifiers and type conversions</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="6"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#6">6</a></td> <td>open</td> <td>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?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="7"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#7">7</a></td> <td>NAD</td> <td>Can a class with a private virtual base class be derived from?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="8"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#8">8</a></td> <td>CD1</td> <td>Access to template arguments used in a function return type and in the nested name specifier</td> - <td class="full" align="center">Duplicate of 45</td> + <td class="full" align="center">Duplicate of <a href="#45">45</a></td> </tr> - <tr> + <tr id="9"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#9">9</a></td> <td>CD1</td> <td>Clarification of access to base class members</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="10"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#10">10</a></td> <td>CD1</td> <td>Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?</td> - <td class="full" align="center">Duplicate of 45</td> + <td class="full" align="center">Duplicate of <a href="#45">45</a></td> </tr> - <tr> + <tr id="11"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#11">11</a></td> <td>CD1</td> <td>How do the keywords typename/template interact with using-declarations?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="12"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#12">12</a></td> <td>dup</td> <td>Default arguments on different declarations for the same function and the Koenig lookup</td> - <td class="full" align="center">Superseded by 239</td> + <td class="full" align="center">Superseded by <a href="#239">239</a></td> </tr> - <tr class="open"> + <tr id="13"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#13">13</a></td> - <td>extension</td> + <td>NAD</td> <td>extern "C" for Parameters of Function Templates</td> - <td align="center">Not resolved</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="14"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#14">14</a></td> <td>NAD</td> <td>extern "C" functions and declarations in different namespaces</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="15"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#15">15</a></td> <td>dup</td> <td>Default arguments for parameters of function templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="16"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#16">16</a></td> <td>CD1</td> <td>Access to members of indirect private base classes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="17"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#17">17</a></td> <td>NAD</td> <td>Footnote 99 should discuss the naming class when describing members that can be accessed from friends</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="18"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#18">18</a></td> <td>NAD</td> <td>f(TYPE) where TYPE is void should be allowed</td> - <td class="full" align="center">Yes</td> + <td class="none" align="center">Superseded by <a href="#577">577</a></td> </tr> - <tr> + <tr id="19"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#19">19</a></td> <td>NAD</td> <td>Clarify protected member access</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="20"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#20">20</a></td> <td>TC1</td> <td>Some clarifications needed for 12.8 para 15</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="21"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#21">21</a></td> <td>TC1</td> <td>Can a default argument for a template parameter appear in a friend declaration?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="22"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#22">22</a></td> <td>TC1</td> <td>Template parameter with a default argument that refers to itself</td> - <td class="none" align="center">Superseded by 481</td> + <td class="full" align="center">Superseded by <a href="#481">481</a></td> </tr> - <tr> + <tr id="23"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#23">23</a></td> <td>NAD</td> <td>Some questions regarding partial ordering of function templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="24"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#24">24</a></td> <td>TC1</td> <td>Errors in examples in 14.7.3</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="25"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#25">25</a></td> <td>TC1</td> <td>Exception specifications and pointers to members</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="26"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#26">26</a></td> <td>NAD</td> <td>Copy constructors and default arguments</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="27"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#27">27</a></td> <td>NAD</td> <td>Overload ambiguities for builtin ?: prototypes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="28"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#28">28</a></td> <td>CD1</td> <td>'exit', 'signal' and static object destruction</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="29"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#29">29</a></td> <td>CD1</td> <td>Linkage of locally declared functions</td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> - <tr> + <tr id="30"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#30">30</a></td> <td>TC1</td> <td>Valid uses of "<TT>::template</TT>"</td> - <td class="none" align="center">Superseded by 468 (C++11 onwards)</td> + <td class="full" align="center">Superseded by <a href="#468">468</a> (C++11 onwards)</td> </tr> - <tr> + <tr id="31"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#31">31</a></td> <td>NAD</td> <td>Looking up new/delete</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="32"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#32">32</a></td> <td>TC1</td> <td>Clarification of explicit instantiation of non-exported templates</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="33"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#33">33</a></td> <td>TC1</td> <td>Argument dependent lookup and overloaded functions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="34"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#34">34</a></td> <td>NAD</td> <td>Argument dependent lookup and points of instantiation</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="35"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#35">35</a></td> <td>TC1</td> <td>Definition of default-initialization</td> - <td class="full" align="center">Duplicate of 178</td> + <td class="full" align="center">Duplicate of <a href="#178">178</a></td> </tr> - <tr class="open"> + <tr class="open" id="36"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#36">36</a></td> <td>open</td> <td><I>using-declaration</I>s in multiple-declaration contexts</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="37"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#37">37</a></td> <td>NAD</td> <td>When is uncaught_exception() true?</td> - <td class="none" align="center">Superseded by 475</td> + <td class="none" align="center">Superseded by <a href="#475">475</a></td> </tr> - <tr> + <tr id="38"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#38">38</a></td> <td>TC1</td> <td>Explicit template arguments and operator functions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="39"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#39">39</a></td> <td>CD1</td> <td>Conflicting ambiguity rules</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="40"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#40">40</a></td> <td>TC1</td> <td>Syntax of <I>declarator-id</I></td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="41"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#41">41</a></td> <td>TC1</td> <td>Clarification of lookup of names after declarator-id</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="42"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#42">42</a></td> <td>NAD</td> <td>Redefining names from base classes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="43"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#43">43</a></td> <td>TC1</td> <td>Copying base classes (PODs) using memcpy</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="44"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#44">44</a></td> <td>CD1</td> <td>Member specializations</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="45"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#45">45</a></td> <td>CD1</td> <td>Access to nested classes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="46"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#46">46</a></td> <td>NAD</td> <td>Explicit instantiation of member templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="47"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#47">47</a></td> <td>NAD</td> <td>Template friend issues</td> - <td class="none" align="center">No</td> + <td class="svn" align="center">Superseded by <a href="#329">329</a></td> </tr> - <tr> + <tr id="48"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#48">48</a></td> <td>TC1</td> <td>Definitions of unused static members</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="49"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#49">49</a></td> <td>TC1</td> <td>Restriction on non-type, non-value template arguments</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="50"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#50">50</a></td> <td>NAD</td> <td>Converting pointer to incomplete type to same type</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="51"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#51">51</a></td> <td>TC1</td> <td>Overloading and user-defined conversions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="52"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#52">52</a></td> <td>TC1</td> <td>Non-static members, member selection and access checking</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="53"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#53">53</a></td> <td>TC1</td> <td>Lvalue-to-rvalue conversion before certain static_casts</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="54"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#54">54</a></td> <td>CD1</td> <td>Static_cast from private base to derived class</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="55"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#55">55</a></td> <td>NAD</td> <td>Adding/subtracting pointer and enumeration value</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="56"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#56">56</a></td> <td>TC1</td> <td>Redeclaring typedefs within classes</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="57"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#57">57</a></td> <td>open</td> <td>Empty unions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="58"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#58">58</a></td> <td>CD1</td> <td>Signedness of bit fields of enum type</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="59"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#59">59</a></td> <td>TC1</td> <td>Clarification of overloading and UDC to reference type</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="60"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#60">60</a></td> <td>CD1</td> <td>Reference binding and valid conversion sequences</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="61"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#61">61</a></td> <td>NAD</td> <td>Address of static member function "<TT>&p->f</TT>"</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="62"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#62">62</a></td> <td>CD1</td> <td>Unnamed members of classes used as type parameters</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="63"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#63">63</a></td> <td>CD1</td> <td>Class instantiation from pointer conversion to void*, null and self</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="64"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#64">64</a></td> <td>TC1</td> <td>Partial ordering to disambiguate explicit specialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="65"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#65">65</a></td> <td>TC1</td> <td>Typo in default argument example</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="66"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#66">66</a></td> <td>NAD</td> <td>Visibility of default args vs overloads added after using-declaration</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="67"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#67">67</a></td> <td>TC1</td> <td>Evaluation of left side of object-expression</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="68"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#68">68</a></td> <td>TC1</td> <td>Grammar does not allow "friend class A<int>;"</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="69"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#69">69</a></td> <td>TC1</td> <td>Storage class specifiers on template declarations</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="70"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#70">70</a></td> <td>CD1</td> <td>Is an array bound a nondeduced context?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="71"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#71">71</a></td> <td>NAD</td> <td>Incorrect cross reference</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="72"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#72">72</a></td> <td>dup</td> <td>Linkage and storage class specifiers for templates</td> - <td class="full" align="center">Duplicate of 69</td> + <td class="full" align="center">Duplicate of <a href="#69">69</a></td> </tr> - <tr> + <tr id="73"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#73">73</a></td> <td>TC1</td> <td>Pointer equality</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="74"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#74">74</a></td> <td>TC1</td> <td>Enumeration value in direct-new-declarator</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="75"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#75">75</a></td> <td>TC1</td> <td>In-class initialized members must be const</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="76"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#76">76</a></td> <td>TC1</td> <td>Are const volatile variables considered "constant expressions"?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="77"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#77">77</a></td> <td>CD1</td> <td>The definition of friend does not allow nested classes to be friends</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="78"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#78">78</a></td> <td>CD1</td> <td>Section 8.5 paragraph 9 should state it only applies to non-static objects</td> - <td class="none" align="center">Superseded by ????</td> + <td class="none" align="center">Superseded by <a href="#????">????</a></td> </tr> - <tr> + <tr id="79"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#79">79</a></td> <td>dup</td> <td>Alignment and placement new</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="80"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#80">80</a></td> <td>TC1</td> <td>Class members with same name as class</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="81"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#81">81</a></td> <td>NAD</td> <td>Null pointers and C compatibility</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="82"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#82">82</a></td> <td>dup</td> <td>Definition of "using" a constant expression</td> - <td class="full" align="center">Duplicate of 48</td> + <td class="full" align="center">Duplicate of <a href="#48">48</a></td> </tr> - <tr> + <tr id="83"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#83">83</a></td> <td>TC1</td> <td>Overloading and deprecated conversion of string literal</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="84"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#84">84</a></td> <td>TC1</td> <td>Overloading and conversion loophole used by <TT>auto_ptr</TT></td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="85"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#85">85</a></td> <td>TC1</td> <td>Redeclaration of member class</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="86"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#86">86</a></td> <td>CD1</td> <td>Lifetime of temporaries in query expressions</td> - <td class="none" align="center">Duplicate of 446</td> + <td class="full" align="center">Duplicate of <a href="#446">446</a></td> </tr> - <tr> + <tr id="87"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#87">87</a></td> <td>CD1</td> <td>Exception specifications on function parameters</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="88"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#88">88</a></td> <td>NAD</td> <td>Specialization of member constant templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="89"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#89">89</a></td> <td>TC1</td> <td>Object lifetime does not account for reference rebinding</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="90"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#90">90</a></td> <td>TC1</td> <td>Should the enclosing class be an "associated class" too?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="91"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#91">91</a></td> <td>NAD</td> <td>A union's associated types should include the union itself</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr id="92"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#92">92</a></td> - <td>extension</td> + <td>NAD</td> <td>Should <I>exception-specification</I>s be part of the type system?</td> - <td align="center">Not resolved</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="93"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#93">93</a></td> <td>TC1</td> <td>Missing word in 3.8 <U>basic.life</U> paragraph 2</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="94"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#94">94</a></td> <td>TC1</td> <td>Inconsistencies in the descriptions of constant expressions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="95"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#95">95</a></td> <td>NAD</td> <td>Elaborated type specifiers referencing names declared in friend decls</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="96"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#96">96</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Syntactic disambiguation using the <TT>template</TT> keyword</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="97"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#97">97</a></td> <td>NAD</td> <td>Use of bool constants in integral constant expressions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="98"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#98">98</a></td> <td>TC1</td> <td>Branching into try block</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="99"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#99">99</a></td> <td>NAD</td> <td>Partial ordering, references and cv-qualifiers</td> - <td class="full" align="center">Superseded by 214</td> + <td class="full" align="center">Superseded by <a href="#214">214</a></td> </tr> - <tr> + <tr id="100"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#100">100</a></td> <td>TC1</td> <td>Clarify why string literals are not allowed as template arguments</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="101"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#101">101</a></td> <td>TC1</td> <td>Redeclaration of extern "C" names via using-declarations</td> - <td class="full" align="center">Yes</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="102"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#102">102</a></td> <td>NAD</td> <td>Operator lookup rules do not work well with parts of the library</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="103"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#103">103</a></td> <td>TC1</td> <td>Is it <I>extended-namespace-definition</I> or <I>extension-namespace-definition</I> ?</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="104"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#104">104</a></td> <td>NAD</td> <td>Destroying the exception temp when no handler is found</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="105"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#105">105</a></td> <td>TC1</td> <td>Meaning of "template function"</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="106"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#106">106</a></td> <td>CD1</td> <td>Creating references to references during template deduction/instantiation</td> - <td class="none" align="center">Superseded by 540</td> + <td class="none" align="center">Superseded by <a href="#540">540</a></td> </tr> - <tr> + <tr id="107"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#107">107</a></td> <td>NAD</td> <td>Linkage of operator functions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="108"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#108">108</a></td> <td>TC1</td> <td>Are classes nested in templates dependent?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="109"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#109">109</a></td> <td>NAD</td> <td>Allowing <TT>::template</TT> in <I>using-declaration</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="110"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#110">110</a></td> <td>open</td> <td>Can template functions and classes be declared in the same scope?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="111"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#111">111</a></td> <td>NAD</td> <td>Copy constructors and cv-qualifiers</td> - <td class="none" align="center">Duplicate of 535</td> + <td class="none" align="center">Duplicate of <a href="#535">535</a></td> </tr> - <tr> + <tr id="112"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#112">112</a></td> <td>CD1</td> <td>Array types and cv-qualifiers</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="113"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#113">113</a></td> <td>CD1</td> <td>Visibility of called function</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="114"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#114">114</a></td> <td>NAD</td> <td>Virtual overriding by template member function specializations</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="115"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#115">115</a></td> <td>CD1</td> <td>Address of template-id</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="116"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#116">116</a></td> <td>TC1</td> <td>Equivalent and functionally-equivalent function templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="117"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#117">117</a></td> <td>NAD</td> <td>Timing of destruction of temporaries</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="118"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#118">118</a></td> <td>CD1</td> <td>Calls via pointers to virtual member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="119"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#119">119</a></td> <td>CD1</td> <td>Object lifetime and aggregate initialization</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="120"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#120">120</a></td> <td>TC1</td> <td>Nonexistent non-terminal <I>qualified-name</I></td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="121"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#121">121</a></td> <td>TC1</td> <td>Dependent type names with non-dependent <I>nested-name-specifier</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="122"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#122">122</a></td> <td>CD1</td> <td><I>template-id</I>s as <I>unqualified-id</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="123"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#123">123</a></td> <td>TC1</td> <td>Bad cross-reference</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="124"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#124">124</a></td> <td>CD1</td> <td>Lifetime of temporaries in default initialization of class arrays</td> - <td class="none" align="center">Duplicate of 201</td> + <td class="none" align="center">Duplicate of <a href="#201">201</a></td> </tr> - <tr> + <tr id="125"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#125">125</a></td> <td>CD1</td> <td>Ambiguity in <TT>friend</TT> declaration syntax</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="126"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#126">126</a></td> <td>TC1</td> <td>Exception specifications and <TT>const</TT></td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="127"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#127">127</a></td> <td>TC1</td> <td>Ambiguity in description of matching deallocation function</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="128"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#128">128</a></td> <td>TC1</td> <td>Casting between enum types</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="129"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#129">129</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Stability of uninitialized auto variables</td> - <td class="none" align="center">Duplicate of 616</td> + <td class="none" align="center">Duplicate of <a href="#616">616</a></td> </tr> - <tr> + <tr id="130"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#130">130</a></td> <td>NAD</td> <td>Sequence points and <I>new-expression</I>s</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="131"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#131">131</a></td> <td>TC1</td> <td>Typo in Lao characters</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="132"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#132">132</a></td> <td>NAD</td> <td>Local types and linkage</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="133"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#133">133</a></td> <td>dup</td> <td>Exception specifications and checking</td> - <td class="none" align="center">Duplicate of 87</td> + <td class="none" align="center">Duplicate of <a href="#87">87</a></td> </tr> - <tr> + <tr id="134"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#134">134</a></td> <td>TC1</td> <td>Template classes and <I>declarator-id</I>s</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="135"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#135">135</a></td> <td>TC1</td> <td>Class type in in-class member function definitions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="136"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#136">136</a></td> <td>CD1</td> <td>Default arguments and friend declarations</td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> - <tr> + <tr id="137"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#137">137</a></td> <td>TC1</td> <td><TT>static_cast</TT> of <I>cv</I> <TT>void*</TT></td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="138"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#138">138</a></td> <td>drafting</td> <td>Friend declaration name lookup</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="139"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#139">139</a></td> <td>CD1</td> <td>Error in <TT>friend</TT> lookup example</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="140"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#140">140</a></td> <td>CD1</td> <td>Agreement of parameter declarations</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="141"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#141">141</a></td> <td>CD1</td> <td>Non-member function templates in member access expressions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="142"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#142">142</a></td> <td>TC1</td> <td>Injection-related errors in access example</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="143"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#143">143</a></td> <td>CD1</td> <td>Friends and Koenig lookup</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="144"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#144">144</a></td> <td>open</td> <td>Position of <TT>friend</TT> specifier</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="145"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#145">145</a></td> <td>TC1</td> <td>Deprecation of prefix <TT>++</TT></td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="146"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#146">146</a></td> <td>open</td> <td>Floating-point zero</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="147"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#147">147</a></td> <td>TC1</td> <td>Naming the constructor</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="148"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#148">148</a></td> <td>TC1</td> <td>POD classes and pointers to members</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="149"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#149">149</a></td> <td>TC1</td> <td>Accessibility and ambiguity</td> <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="150"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#150">150</a></td> <td>open</td> <td>Template template parameters and default arguments</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="151"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#151">151</a></td> <td>TC1</td> <td>Terminology of zero-initialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="152"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#152">152</a></td> <td>TC1</td> <td><TT>explicit</TT> copy constructors</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="153"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#153">153</a></td> <td>TC1</td> <td>Misleading wording (rank of conversion)</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="154"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#154">154</a></td> <td>NAD</td> <td>Anonymous unions in unnamed namespaces</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="155"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#155">155</a></td> <td>dup</td> <td>Brace initializer for scalar</td> - <td class="none" align="center">Duplicate of 632</td> + <td class="none" align="center">Duplicate of <a href="#632">632</a></td> </tr> - <tr class="open"> + <tr class="open" id="156"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#156">156</a></td> <td>drafting</td> <td>Name lookup for conversion functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="157"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#157">157</a></td> <td>open</td> <td>Omitted typedef declarator</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="158"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#158">158</a></td> <td>CD1</td> <td>Aliasing and qualification conversions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="159"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#159">159</a></td> <td>TC1</td> <td>Namespace qualification in declarators</td> - <td class="none" align="center">No</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="160"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#160">160</a></td> <td>CD1</td> <td>Missing <TT>std::</TT> qualification</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="161"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#161">161</a></td> <td>TC1</td> <td>Access to protected nested type</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="162"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#162">162</a></td> <td>CD1</td> <td>(<TT>&C::f)()</TT> with nonstatic members</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="163"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#163">163</a></td> <td>TC1</td> <td>Description of subaggregate initializer</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="164"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#164">164</a></td> <td>TC1</td> <td>Overlap between Koenig and normal lookup</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="165"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#165">165</a></td> <td>NAD</td> <td>Definitions of friends and block-scope externs</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="166"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#166">166</a></td> <td>TC1</td> <td>Friend declarations of <I>template-id</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="167"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#167">167</a></td> <td>NAD</td> <td>Deprecating static functions</td> - <td class="none" align="center">Superseded by 1012</td> + <td class="none" align="center">Superseded by <a href="#1012">1012</a></td> </tr> - <tr> + <tr id="168"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#168">168</a></td> <td>NAD</td> <td>C linkage for static member functions</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="169"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#169">169</a></td> <td>NAD</td> <td><I>template-id</I>s in <I>using-declaration</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="170"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#170">170</a></td> <td>drafting</td> <td>Pointer-to-member conversions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="171"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#171">171</a></td> <td>TC1</td> <td>Global namespace scope</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="172"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#172">172</a></td> <td>CD1</td> <td>Unsigned int as underlying type of enum</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="173"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#173">173</a></td> <td>TC1</td> <td>Constraints on execution character set</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="174"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#174">174</a></td> <td>NAD</td> <td>Undeprecating global static</td> - <td class="none" align="center">Superseded by 1012</td> + <td class="none" align="center">Superseded by <a href="#1012">1012</a></td> </tr> - <tr> + <tr id="175"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#175">175</a></td> <td>CD1</td> <td>Class name injection and base name access</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="176"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#176">176</a></td> <td>TC1</td> <td>Name injection and templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="177"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#177">177</a></td> <td>CD1</td> <td>Lvalues vs rvalues in copy-initialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="178"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#178">178</a></td> <td>TC1</td> <td>More on value-initialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="179"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#179">179</a></td> <td>TC1</td> <td>Function pointers and subtraction</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="180"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#180">180</a></td> <td>CD1</td> <td><TT>typename</TT> and elaborated types</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="181"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#181">181</a></td> <td>TC1</td> <td>Errors in template <I>template-parameter</I> example</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="182"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#182">182</a></td> <td>NAD</td> <td>Access checking on explicit specializations</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="183"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#183">183</a></td> <td>TC1</td> <td><TT>typename</TT> in explicit specializations</td> - <td class="none" align="center">Superseded by 382</td> + <td class="full" align="center">Superseded by <a href="#382">382</a></td> </tr> - <tr> + <tr id="184"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#184">184</a></td> <td>CD1</td> <td>Default arguments in template <I>template-parameter</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="185"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#185">185</a></td> <td>TC1</td> <td>"Named" temporaries and copy elision</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="186"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#186">186</a></td> <td>open</td> <td>Name hiding and template <I>template-parameter</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="187"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#187">187</a></td> <td>TC1</td> <td>Scope of template parameter names</td> - <td class="none" align="center">Superseded by 481</td> + <td class="full" align="center">Superseded by <a href="#481">481</a></td> </tr> - <tr> + <tr id="188"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#188">188</a></td> <td>TC1</td> <td>Comma operator and rvalue conversion</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="189"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#189">189</a></td> <td>drafting</td> <td>Definition of <I>operator</I> and <I>punctuator</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="190"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#190">190</a></td> <td>TC1</td> <td>Layout-compatible POD-struct types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="191"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#191">191</a></td> <td>open</td> <td>Name lookup does not handle complex nesting</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="192"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#192">192</a></td> <td>drafting</td> <td>Name lookup in parameters</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="193"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#193">193</a></td> <td>TC1</td> <td>Order of destruction of local automatics of destructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="194"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#194">194</a></td> <td>TC1</td> <td>Identifying constructors</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="195"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#195">195</a></td> <td>CD1</td> <td>Converting between function and object pointers</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="196"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#196">196</a></td> <td>open</td> <td>Arguments to deallocation functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="197"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#197">197</a></td> <td>CD1</td> <td>Issues with two-stage lookup of dependent names</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="198"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#198">198</a></td> <td>CD1</td> <td>Definition of "use" in local and nested classes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="199"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#199">199</a></td> <td>CD1</td> <td>Order of destruction of temporaries</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="200"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#200">200</a></td> <td>dup</td> <td>Partial ordering and explicit arguments</td> - <td class="full" align="center">Duplicate of 214</td> + <td class="full" align="center">Duplicate of <a href="#214">214</a></td> </tr> - <tr> + <tr id="201"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#201">201</a></td> <td>CD1</td> <td>Order of destruction of temporaries in initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="202"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#202">202</a></td> <td>TC1</td> <td>Use of overloaded function name</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="203"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#203">203</a></td> <td>extension</td> <td>Type of address-of-member expression</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="204"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#204">204</a></td> <td>CD1</td> <td>Exported class templates</td> <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="205"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#205">205</a></td> <td>drafting</td> <td>Templates and static data members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="206"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#206">206</a></td> <td>TC1</td> <td>Semantic constraints on non-dependent names</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="207"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#207">207</a></td> <td>CD1</td> <td><I>using-declaration</I>s and protected access</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="208"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#208">208</a></td> <td>CD1</td> <td>Rethrowing exceptions in nested handlers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="209"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#209">209</a></td> <td>NAD</td> <td>Must friend declaration names be
accessible?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="210"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#210">210</a></td> <td>TC1</td> <td>What is the type matched by an exception handler?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="211"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#211">211</a></td> <td>NAD</td> <td>Constructors should not be allowed to return normally after an exception</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="212"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#212">212</a></td> <td>drafting</td> <td>Implicit instantiation is not described clearly enough</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="213"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#213">213</a></td> <td>TC1</td> <td>Lookup in dependent base classes</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="214"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#214">214</a></td> <td>CD1</td> <td>Partial ordering of function templates is underspecified</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="215"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#215">215</a></td> <td>CD1</td> <td>Template parameters are not allowed in <I>nested-name-specifier</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="216"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#216">216</a></td> <td>CD1</td> <td>Linkage of nameless class-scope enumeration types</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="217"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#217">217</a></td> <td>TC1</td> <td>Default arguments for non-template member functions of class templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="218"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#218">218</a></td> <td>CD1</td> <td>Specification of Koenig lookup</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="219"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#219">219</a></td> <td>NAD</td> <td>Cannot defend against destructors that throw exceptions</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="220"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#220">220</a></td> <td>CD1</td> <td>All deallocation functions should be required not to throw</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="221"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#221">221</a></td> <td>CD1</td> <td>Must compound assignment operators be member functions?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="222"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#222">222</a></td> <td>CD1</td> <td>Sequence points and lvalue-returning operators</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#637">637</a></td> </tr> - <tr> + <tr id="223"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#223">223</a></td> - <td>DRWP</td> + <td>CD3</td> <td>The meaning of deprecation</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="224"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#224">224</a></td> <td>CD1</td> <td>Definition of dependent names</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="225"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#225">225</a></td> <td>NAD</td> <td>Koenig lookup and fundamental types</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="226"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226">226</a></td> <td>CD1</td> <td>Default template arguments for function templates</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="227"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#227">227</a></td> <td>TC1</td> <td>How many scopes in an <TT>if</TT> statement?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="228"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#228">228</a></td> <td>CD1</td> <td>Use of <TT>template</TT> keyword with non-member templates</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="229"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#229">229</a></td> <td>NAD</td> <td>Partial specialization of function templates</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr id="230"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#230">230</a></td> - <td>extension</td> + <td>NAD</td> <td>Calls to pure virtual functions</td> - <td align="center">Not resolved</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="231"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#231">231</a></td> <td>NAD</td> <td>Visibility of names after <I>using-directive</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="232"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#232">232</a></td> <td>drafting</td> <td>Is indirection through a null pointer undefined behavior?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="233"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#233">233</a></td> <td>open</td> <td>References vs pointers in UDC overload resolution</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="234"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#234">234</a></td> <td>NAD</td> <td>Reuse of base class subobjects</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="235"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#235">235</a></td> <td>TC1</td> <td>Assignment vs initialization</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="236"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#236">236</a></td> <td>NAD</td> <td>Explicit temporaries and integral constant expressions</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="237"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#237">237</a></td> <td>CD1</td> <td>Explicit instantiation and base class members</td> - <td class="none" align="center">Duplicate of 470</td> + <td class="full" align="center">Duplicate of <a href="#470">470</a></td> </tr> - <tr class="open"> + <tr class="open" id="238"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#238">238</a></td> <td>open</td> <td>Precision and accuracy constraints on floating point</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="239"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#239">239</a></td> <td>CD1</td> <td>Footnote 116 and Koenig lookup</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="240"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#240">240</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Uninitialized values and undefined behavior</td> - <td class="none" align="center">Duplicate of 616</td> + <td class="none" align="center">Duplicate of <a href="#616">616</a></td> </tr> - <tr> + <tr id="241"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#241">241</a></td> <td>TC1</td> <td>Error in example in 14.8.1</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="242"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#242">242</a></td> <td>open</td> <td>Interpretation of old-style casts</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="243"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#243">243</a></td> <td>NAD</td> <td>Weighting of conversion functions in direct-initialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="244"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#244">244</a></td> <td>CD1</td> <td>Destructor lookup</td> - <td class="none" align="center">No</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="245"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#245">245</a></td> <td>CD1</td> <td>Name lookup in <I>elaborated-type-specifier</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="246"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#246">246</a></td> <td>CD1</td> <td>Jumps in <I>function-try-block</I> handlers</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="247"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#247">247</a></td> <td>NAD</td> <td>Pointer-to-member casts and function overload resolution</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="248"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#248">248</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Identifier characters</td> <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="249"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#249">249</a></td> <td>TC1</td> <td>What is a member function template?</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="250"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#250">250</a></td> <td>TC1</td> <td>Address of function template specialization with non-deduced template arguments</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="251"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#251">251</a></td> <td>open</td> <td>How many signed integer types are there?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="252"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#252">252</a></td> <td>CD1</td> <td>Looking up deallocation functions in virtual destructors</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="253"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#253">253</a></td> <td>drafting</td> <td>Why must empty or fully-initialized const objects be initialized?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="254"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#254">254</a></td> <td>CD1</td> <td>Definitional problems with <I>elaborated-type-specifier</I>s</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="255"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#255">255</a></td> <td>drafting</td> <td>Placement deallocation functions and lookup ambiguity</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="256"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#256">256</a></td> <td>CD1</td> <td>Overflow in size calculations</td> - <td class="none" align="center">Duplicate of 624</td> + <td class="none" align="center">Duplicate of <a href="#624">624</a></td> </tr> - <tr> + <tr id="257"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#257">257</a></td> <td>CD2</td> <td>Abstract base constructors and virtual base initialization</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="258"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#258">258</a></td> <td>CD1</td> <td><I>using-declaration</I>s and cv-qualifiers</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="259"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#259">259</a></td> <td>CD1</td> <td>Restrictions on explicit specialization and instantiation</td> <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr class="open"> + <tr class="open" id="260"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#260">260</a></td> <td>open</td> <td>User-defined conversions and built-in <TT>operator=</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="261"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#261">261</a></td> <td>CD1</td> <td>When is a deallocation function "used?"</td> <td class="none" align="center">No</td> </tr> - <tr> + <tr id="262"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#262">262</a></td> <td>CD1</td> <td>Default arguments and ellipsis</td> <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="263"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#263">263</a></td> <td>CD1</td> <td>Can a constructor be declared a friend?</td> <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="264"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#264">264</a></td> <td>open</td> <td>Unusable template constructors and conversion functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="265"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#265">265</a></td> <td>dup</td> <td>Destructors, exceptions, and deallocation</td> - <td class="none" align="center">Duplicate of 353</td> + <td class="none" align="center">Duplicate of <a href="#353">353</a></td> </tr> - <tr> + <tr id="266"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#266">266</a></td> <td>NAD</td> <td>No grammar sentence symbol</td> <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="267"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#267">267</a></td> <td>open</td> <td>Alignment requirement for <I>new-expression</I>s</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="268"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#268">268</a></td> <td>open</td> <td>Macro name suppression in rescanned replacement text</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="269"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#269">269</a></td> <td>NAD</td> <td>Order of initialization of multiply-defined static data members
of class templates</td> <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="270"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#270">270</a></td> <td>CD1</td> <td>Order of initialization of static data members of class templates</td> <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="271"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#271">271</a></td> <td>open</td> <td>Explicit instantiation and template argument deduction</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="272"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#272">272</a></td> <td>CD1</td> <td>Explicit destructor invocation and <I>qualified-id</I>s</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="273"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#273">273</a></td> <td>CD1</td> <td>POD classes and <TT>operator&()</TT></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="274"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#274">274</a></td> <td>CD1</td> <td>Cv-qualification and char-alias access to out-of-lifetime objects</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="275"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#275">275</a></td> <td>CD1</td> <td>Explicit instantiation/specialization and <I>using-directive</I>s</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="276"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#276">276</a></td> <td>CD1</td> <td>Order of destruction of parameters and temporaries</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="277"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#277">277</a></td> <td>CD1</td> <td>Zero-initialization of pointers</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="278"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#278">278</a></td> <td>open</td> <td>External linkage and nameless entities</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="279"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#279">279</a></td> <td>open</td> <td>Correspondence of "names for linkage purposes"</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="280"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#280">280</a></td> <td>CD1</td> <td>Access and surrogate call functions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="281"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#281">281</a></td> <td>CD1</td> <td><TT>inline</TT> specifier in <TT>friend</TT> declarations</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="282"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#282">282</a></td> <td>open</td> <td>Namespace for <TT>extended_type_info</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="283"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#283">283</a></td> <td>CD1</td> <td>Template <I>type-parameter</I>s are not syntactically <I>type-name</I>s</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="284"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#284">284</a></td> <td>CD1</td> <td><I>qualified-id</I>s in class declarations</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="285"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#285">285</a></td> <td>NAD</td> <td>Identifying a function template being specialized</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="286"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#286">286</a></td> <td>CD1</td> <td>Incorrect example in partial specialization</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="287"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#287">287</a></td> <td>drafting</td> <td>Order dependencies in template instantiation</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="288"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#288">288</a></td> <td>CD1</td> <td>Misuse of "static type" in describing pointers</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="289"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#289">289</a></td> <td>CD1</td> <td>Incomplete list of contexts requiring a complete type</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="290"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#290">290</a></td> <td>NAD</td> <td>Should memcpy be allowed into a POD with a const member?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="291"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#291">291</a></td> <td>CD1</td> <td>Overload resolution needed when binding reference to class rvalue</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Duplicate of <a href="#391">391</a></td> </tr> - <tr> + <tr id="292"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#292">292</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Deallocation on exception in <TT>new</TT> before arguments evaluated</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="293"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#293">293</a></td> <td>open</td> <td>Syntax of explicit instantiation/specialization too permissive</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="294"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#294">294</a></td> <td>NAD</td> <td>Can <TT>static_cast</TT> drop exception specifications?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="295"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#295">295</a></td> <td>CD1</td> <td>cv-qualifiers on function types</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="296"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#296">296</a></td> <td>CD1</td> <td>Can conversion functions be static?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="297"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#297">297</a></td> <td>open</td> <td>Which template does an explicit specialization specialize?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="298"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#298">298</a></td> <td>CD1</td> <td><TT>T::x</TT> when <TT>T</TT> is cv-qualified</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="299"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#299">299</a></td> <td>CD1</td> <td>Conversion on array bound expression in <TT>new</TT></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="300"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#300">300</a></td> <td>CD1</td> <td>References to functions in template argument deduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="301"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#301">301</a></td> <td>CD1</td> <td>Syntax for <I>template-name</I></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="302"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#302">302</a></td> <td>CD1</td> <td>Value-initialization and generation of default constructor</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="303"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#303">303</a></td> <td>NAD</td> <td>Integral promotions on bit-fields</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="304"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#304">304</a></td> <td>TC1</td> <td>Value-initialization of a reference</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="305"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#305">305</a></td> <td>CD1</td> <td>Name lookup in destructor call</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="306"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#306">306</a></td> <td>CD1</td> <td>Ambiguity by class name injection</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="307"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#307">307</a></td> <td>NAD</td> <td>Initialization of a virtual base class subobject</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="308"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#308">308</a></td> <td>NAD</td> <td>Catching exceptions with ambiguous base classes</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="309"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#309">309</a></td> <td>CD1</td> <td>Linkage of entities whose names are not simply identifiers, in introduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Duplicate of <a href="#485">485</a></td> </tr> - <tr class="open"> + <tr class="open" id="310"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#310">310</a></td> <td>open</td> <td>Can function templates differing only in parameter cv-qualifiers be overloaded?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="311"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#311">311</a></td> <td>NAD</td> <td>Using qualified name to reopen nested namespace</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="312"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#312">312</a></td> - <td>DRWP</td> + <td>CD3</td> <td>“use” of invalid pointer value not defined</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#616">616</a></td> </tr> - <tr> + <tr id="313"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#313">313</a></td> <td>dup</td> <td>Class with single conversion function to integral as array size in <TT>new</TT></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td> </tr> - <tr class="open"> + <tr id="314"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#314">314</a></td> - <td>drafting</td> + <td>ready</td> <td><TT>template</TT> in base class specifier</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Duplicate of <a href="#1710">1710</a></td> </tr> - <tr> + <tr id="315"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#315">315</a></td> <td>NAD</td> <td>Is call of static member function through null pointer undefined?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="316"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#316">316</a></td> <td>NAD</td> <td>Injected-class-name of template used as template template parameter</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Superseded by <a href="#1004">1004</a></td> </tr> - <tr> + <tr id="317"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#317">317</a></td> <td>CD1</td> <td>Can a function be declared inline after it has been called?</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="318"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#318">318</a></td> <td>CD1</td> <td><TT>struct A::A</TT> should not name the constructor of <TT>A</TT></td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Superseded by <a href="#1310">1310</a></td> </tr> - <tr> + <tr id="319"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#319">319</a></td> <td>CD1</td> <td>Use of names without linkage in declaring entities with linkage</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="320"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#320">320</a></td> <td>CD1</td> <td>Question on copy constructor elision example</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="321"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#321">321</a></td> <td>dup</td> <td>Associated classes and namespaces for argument-dependent lookup</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#557">557</a></td> </tr> - <tr> + <tr id="322"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#322">322</a></td> <td>CD1</td> <td>Deduction of reference conversions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="323"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#323">323</a></td> <td>CD1</td> <td>Where must <TT>export</TT> appear?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="324"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#324">324</a></td> <td>CD1</td> <td>Can "<TT>&</TT>" be applied to assignment to bit-field?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="325"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#325">325</a></td> <td>drafting</td> <td>When are default arguments parsed?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="326"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#326">326</a></td> <td>CD1</td> <td>Wording for definition of trivial constructor</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="327"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#327">327</a></td> <td>CD1</td> <td>Use of "structure" without definition</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#538">538</a></td> </tr> - <tr> + <tr id="328"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#328">328</a></td> <td>CD1</td> <td>Missing requirement that class member types be complete</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="329"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#329">329</a></td> <td>CD1</td> <td>Evaluation of friends of templates</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr class="open"> + <tr class="open" id="330"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#330">330</a></td> <td>open</td> <td>Qualification conversions and pointers to arrays of pointers</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="331"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#331">331</a></td> <td>CD1</td> <td>Allowed copy constructor signatures</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="332"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#332">332</a></td> - <td>DRWP</td> + <td>CD3</td> <td>cv-qualified <TT>void</TT> parameter types</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#557">557</a></td> </tr> - <tr> + <tr id="333"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#333">333</a></td> <td>NAD</td> <td>Ambiguous use of "declaration" in disambiguation section</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="334"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#334">334</a></td> <td>NAD</td> <td>Is a comma-expression dependent if its first operand is?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="335"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#335">335</a></td> <td>CD1</td> <td>Allowing <TT>export</TT> on template members of nontemplate classes</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="336"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#336">336</a></td> <td>CD1</td> <td>Explicit specialization examples are still incorrect</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="337"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#337">337</a></td> <td>CD1</td> <td>Attempt to create array of abtract type should cause deduction to fail</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="338"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#338">338</a></td> <td>open</td> <td>Enumerator name with linkage used as class name in other translation unit</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="339"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#339">339</a></td> <td>CD1</td> <td>Overload resolution in operand of <TT>sizeof</TT> in constant expression</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="340"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#340">340</a></td> <td>NAD</td> <td>Unclear wording in disambiguation section</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="341"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#341">341</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>extern "C"</TT> namespace member function versus global variable</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Superseded by <a href="#1708">1708</a></td> </tr> - <tr> + <tr id="342"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#342">342</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Terminology: "indirection" versus "dereference"</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr id="343"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#343">343</a></td> - <td>open</td> + <td>ready</td> <td>Make <TT>template</TT> optional in contexts that require a type</td> - <td align="center">Not resolved</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#344">344</a></td> - <td>open</td> + <tr id="344"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#344">344</a></td> + <td>CD3</td> <td>Naming destructors</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Duplicate of <a href="#1435">1435</a></td> </tr> - <tr> + <tr id="345"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#345">345</a></td> <td>CD1</td> <td>Misleading comment on example in templates chapter</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="346"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#346">346</a></td> <td>NAD</td> <td>Typo in 15.4</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="347"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#347">347</a></td> <td>NAD</td> <td>Use of derived class name in defining base class nested class</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="348"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#348">348</a></td> <td>CD1</td> <td><TT>delete</TT> and user-written deallocation functions</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="349"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#349">349</a></td> <td>CD1</td> <td>Template argument deduction for conversion functions and qualification conversions</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="350"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#350">350</a></td> <td>open</td> <td><TT>signed char</TT> underlying representation for objects</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="351"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#351">351</a></td> <td>CD1</td> <td>Sequence point error: unspecified or undefined?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="352"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#352">352</a></td> <td>CD1</td> <td>Nondeduced contexts</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="353"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#353">353</a></td> <td>CD1</td> <td>Is deallocation routine called if destructor throws exception in delete?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="354"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#354">354</a></td> <td>CD1</td> <td>Null as nontype template argument</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="355"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#355">355</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Global-scope <TT>::</TT> in <I>nested-name-specifier</I></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="356"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#356">356</a></td> <td>NAD</td> <td>Wording of behavior of generated copy constructor for scalar members</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="357"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#357">357</a></td> <td>CD1</td> <td>Definition of signature should include name</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="358"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#358">358</a></td> <td>NAD</td> <td>Namespaces and extern "C"</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="359"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#359">359</a></td> <td>NAD</td> <td>Type definition in anonymous union</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="360"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#360">360</a></td> <td>open</td> <td>Using-declaration that reduces access</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="361"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#361">361</a></td> <td>open</td> <td>Forward reference to default argument</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="362"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#362">362</a></td> <td>CD1</td> <td>Order of initialization in instantiation units</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="363"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#363">363</a></td> <td>NAD</td> <td>Initialization of class from self</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="364"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#364">364</a></td> <td>CD1</td> <td>Calling overloaded function with static in set, with no object</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="365"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#365">365</a></td> <td>open</td> <td>Storage duration and temporaries</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="366"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#366">366</a></td> <td>CD1</td> <td>String literal allowed in integral constant expression?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="367"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#367">367</a></td> <td>CD1</td> <td><TT>throw</TT> operator allowed in constant expression?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="368"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#368">368</a></td> <td>CD1</td> <td>Uses of non-type parameters that should cause deduction to fail</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="369"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#369">369</a></td> <td>drafting</td> <td>Are <TT>new</TT>/<TT>delete</TT> identifiers or <I>preprocessing-op-or-punc</I>?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="370"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#370">370</a></td> <td>CD1</td> <td>Can <TT>#include <...></TT> form be used other than for standard C++ headers?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="371"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#371">371</a></td> <td>open</td> <td>Interleaving of constructor calls</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="372"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#372">372</a></td> <td>CD1</td> <td>Is access granted by base class specifiers available in following base class specifiers?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="373"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#373">373</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Lookup on namespace qualified name in using-directive</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="374"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#374">374</a></td> <td>CD2</td> <td>Can explicit specialization outside namespace use qualified name?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="375"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#375">375</a></td> <td>dup</td> <td>Confusing example on lookup with <TT>typename</TT></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Duplicate of <a href="#345">345</a></td> </tr> - <tr> + <tr id="376"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#376">376</a></td> <td>NAD</td> <td>Class "definition" versus class "declaration"</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="377"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#377">377</a></td> <td>CD1</td> <td>Enum whose enumerators will not fit in any integral type</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="378"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#378">378</a></td> <td>CD1</td> <td>Wording that says temporaries are declared</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">Duplicate of <a href="#276">276</a></td> </tr> - <tr> + <tr id="379"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#379">379</a></td> <td>CD1</td> <td>Change "class declaration" to "class definition"</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="380"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#380">380</a></td> <td>open</td> <td>Definition of "ambiguous base class" missing</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="381"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#381">381</a></td> <td>CD1</td> <td>Incorrect example of base class member lookup</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="382"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#382">382</a></td> <td>CD1</td> <td>Allow <TT>typename</TT> outside of templates</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="383"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#383">383</a></td> <td>CD1</td> <td>Is a class with a declared but not defined destructor a POD?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="384"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#384">384</a></td> <td>NAD</td> <td>Argument-dependent lookup and operator functions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="385"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#385">385</a></td> <td>CD1</td> <td>How does protected member check of 11.5 interact with using-declarations?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="386"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#386">386</a></td> <td>drafting</td> <td>Friend declaration of name brought in by <I>using-declaration</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="387"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#387">387</a></td> <td>CD1</td> <td>Errors in example in 14.6.5</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="388"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#388">388</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Catching base<TT>*&</TT> from a throw of derived<TT>*</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="389"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#389">389</a></td> <td>CD1</td> <td>Unnamed types in entities with linkage</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="390"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#390">390</a></td> <td>CD1</td> <td>Pure virtual must be defined when implicitly called</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="391"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#391">391</a></td> <td>CD1</td> <td>Require direct binding of short-lived references to rvalues</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="392"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#392">392</a></td> <td>CD1</td> <td>Use of full expression lvalue before temporary destruction</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="393"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#393">393</a></td> - <td>open</td> + <td>ready</td> <td>Pointer to array of unknown bound in template argument list in parameter</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="394"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#394">394</a></td> <td>CD1</td> <td><I>identifier-list</I> is never defined</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="395"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#395">395</a></td> <td>NAD</td> <td>Conversion operator template syntax</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="396"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#396">396</a></td> <td>CD1</td> <td>Misleading note regarding use of <TT>auto</TT> for disambiguation</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="397"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#397">397</a></td> <td>CD1</td> <td>Same address for string literals from default arguments in inline functions?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Superseded by <a href="#1823">1823</a></td> </tr> - <tr> + <tr id="398"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#398">398</a></td> <td>CD1</td> <td>Ambiguous wording on naming a type in deduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="399"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#399">399</a></td> <td>drafting</td> <td>Destructor lookup redux</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="400"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#400">400</a></td> <td>CD1</td> <td>Using-declarations and the "struct hack"</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="401"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#401">401</a></td> <td>CD1</td> <td>When is access for template parameter default arguments checked?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="402"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#402">402</a></td> <td>open</td> <td>More on partial ordering of function templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="403"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#403">403</a></td> <td>CD1</td> <td>Reference to a type as a <I>template-id</I></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="404"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#404">404</a></td> <td>CD1</td> <td>Unclear reference to construction with non-trivial constructor</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="405"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#405">405</a></td> <td>open</td> <td>Unqualified function name lookup</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="406"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#406">406</a></td> <td>CD1</td> <td>Static data member in class with name for linkage purposes</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="407"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#407">407</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Named class with associated typedef: two names or one?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="408"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#408">408</a></td> <td>CD2</td> <td>sizeof applied to unknown-bound array static data member of template</td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> - <tr> + <tr id="409"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#409">409</a></td> <td>CD1</td> <td>Obsolete paragraph missed by changes for issue 224</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="410"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#410">410</a></td> <td>CD1</td> <td>Paragraph missed in changes for issue 166</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="411"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#411">411</a></td> <td>open</td> <td>Use of universal-character-name in character versus string literals</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="412"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#412">412</a></td> <td>NAD</td> <td>Can a replacement allocation function be inline?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="413"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#413">413</a></td> <td>CD1</td> <td>Definition of "empty class"</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="414"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#414">414</a></td> <td>CD1</td> <td>Multiple types found on destructor lookup</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#305">305</a></td> </tr> - <tr> + <tr id="415"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#415">415</a></td> <td>CD1</td> <td>Template deduction does not cause instantiation</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="416"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#416">416</a></td> <td>CD1</td> <td>Class must be complete to allow operator lookup?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="417"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#417">417</a></td> <td>CD1</td> <td>Using derived-class qualified name in out-of-class nested class definition</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="418"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#418">418</a></td> <td>open</td> <td>Imperfect wording on error on multiple default arguments on a called function</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="419"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#419">419</a></td> <td>open</td> <td>Can cast to virtual base class be done on partially-constructed object?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="420"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#420">420</a></td> <td>CD1</td> <td>postfixexpression->scalar_type_dtor() inconsistent</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="421"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#421">421</a></td> <td>CD1</td> <td>Is rvalue.field an rvalue?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="422"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#422">422</a></td> <td>NAD</td> <td>Is a typedef redeclaration allowed with a template type that might be the same?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="423"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#423">423</a></td> <td>NAD</td> <td>Can a conversion be done on the left operand of a compound assignment?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="424"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#424">424</a></td> <td>CD1</td> <td>Wording problem with issue 56 resolution on redeclaring typedefs in class scope</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="425"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#425">425</a></td> <td>CD1</td> <td>Set of candidates for overloaded built-in operator with float operand</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="426"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#426">426</a></td> <td>drafting</td> <td>Identically-named variables, one internally and one externally linked, allowed?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="427"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#427">427</a></td> <td>CD1</td> <td><TT>static_cast</TT> ambiguity: conversion versus cast to derived</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="428"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#428">428</a></td> <td>CD1</td> <td>Mention of expression with reference type</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="429"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#429">429</a></td> <td>CD1</td> <td>Matching deallocation function chosen based on syntax or signature?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="430"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#430">430</a></td> <td>CD1</td> <td>Ordering of expression evaluation in initializer list</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="431"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#431">431</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defect in wording in 14.2</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="432"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#432">432</a></td> <td>CD1</td> <td>Is injected class name visible in base class specifier list?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="433"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#433">433</a></td> <td>CD1</td> <td>Do elaborated type specifiers in templates inject into enclosing namespace scope?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="434"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#434">434</a></td> <td>NAD</td> <td>Unclear suppression of standard conversions while binding reference to lvalue</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="435"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#435">435</a></td> <td>NAD</td> <td>Change "declararation or definition" to "declaration"</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="436"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#436">436</a></td> <td>CD1</td> <td>Problem in example in 9.6 paragraph 4</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="437"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#437">437</a></td> <td>CD1</td> <td>Is type of class allowed in member function exception specification?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="438"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#438">438</a></td> <td>CD2</td> <td>Possible flaw in wording for multiple accesses to object between sequence points</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="439"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#439">439</a></td> <td>CD1</td> <td>Guarantees on casting pointer back to cv-qualified version of original type</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="440"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#440">440</a></td> <td>open</td> <td>Allow implicit pointer-to-member conversion on nontype template argument</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="441"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#441">441</a></td> <td>CD1</td> <td>Ordering of static reference initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="442"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#442">442</a></td> <td>CD1</td> <td>Incorrect use of null pointer constant in description of delete operator</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">Superseded by <a href="#348">348</a></td> </tr> - <tr> + <tr id="443"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#443">443</a></td> <td>CD1</td> <td>Wording nit in description of lifetime of temporaries</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="444"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#444">444</a></td> <td>NAD</td> <td>Overriding and the generated copy assignment operator</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="445"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#445">445</a></td> <td>NAD</td> <td>Wording issue on friend declarations</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="446"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#446">446</a></td> <td>CD1</td> <td>Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="447"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#447">447</a></td> <td>CD1</td> <td>Is offsetof type-dependent?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="448"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#448">448</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Set of template functions in call with dependent explicit argument</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="449"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#449">449</a></td> <td>NAD</td> <td>Consistency in use of hyphen with names of "non" entities</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="450"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#450">450</a></td> <td>CD1</td> <td>Binding a reference to const to a cv-qualified array rvalue</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="451"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#451">451</a></td> <td>CD1</td> <td>Expressions with invalid results and ill-formedness</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="452"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#452">452</a></td> <td>CD1</td> <td>Wording nit on description of <TT>this</TT></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="453"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#453">453</a></td> <td>drafting</td> <td>References may only bind to “valid” objects</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="454"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#454">454</a></td> <td>CD1</td> <td>When is a definition of a static data member required?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="455"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#455">455</a></td> <td>drafting</td> <td>Partial ordering and non-deduced arguments</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="456"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#456">456</a></td> <td>NAD</td> <td>Is initialized const int or const bool variable a null pointer constant?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="457"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#457">457</a></td> <td>CD1</td> <td>Wording nit on use of const variables in constant expressions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="458"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#458">458</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Hiding of member template parameters by other members</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr class="open"> + <tr class="open" id="459"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#459">459</a></td> <td>open</td> <td>Hiding of template parameters by base class members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="460"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#460">460</a></td> <td>CD1</td> <td>Can a <I>using-declaration</I> name a namespace?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="461"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#461">461</a></td> <td>NAD</td> <td>Make <TT>asm</TT> conditionally-supported</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="462"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#462">462</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Lifetime of temporaries bound to comma expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="463"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#463">463</a></td> <td>CD1</td> <td><TT>reinterpret_cast<T*>(0)</TT></td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="464"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#464">464</a></td> <td>CD1</td> <td>Wording nit on lifetime of temporaries to which references are bound</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="465"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#465">465</a></td> <td>NAD</td> <td>May constructors of global objects call <TT>exit()</TT>?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="466"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#466">466</a></td> <td>CD1</td> <td>cv-qualifiers on pseudo-destructor type</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="467"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#467">467</a></td> <td>NAD</td> <td>Jump past initialization of local static variable</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="468"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#468">468</a></td> <td>CD1</td> <td>Allow <TT>::template</TT> outside of templates</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="469"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#469">469</a></td> <td>NAD</td> <td>Const template specializations and reference arguments</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="470"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#470">470</a></td> <td>CD1</td> <td>Instantiation of members of an explicitly-instantiated class template</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="471"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#471">471</a></td> <td>NAD</td> <td>Conflicting inherited access specifications</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="472"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#472">472</a></td> <td>drafting</td> <td>Casting across protected inheritance</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="473"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#473">473</a></td> <td>open</td> <td>Block-scope declarations of allocator functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="474"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#474">474</a></td> <td>CD1</td> <td>Block-scope <TT>extern</TT> declarations in namespace members</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="475"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#475">475</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is <TT>std::uncaught_exception()</TT> true? (take 2)</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="476"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#476">476</a></td> <td>extension</td> <td>Determining the buffer size for placement new</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="477"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#477">477</a></td> <td>CD1</td> <td>Can <TT>virtual</TT> appear in a <TT>friend</TT> declaration?</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="478"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#478">478</a></td> <td>NAD</td> <td>May a function parameter be an array of an abstract class type?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="479"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#479">479</a></td> <td>CD1</td> <td>Copy elision in exception handling</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="480"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#480">480</a></td> <td>CD1</td> <td>Is a base of a virtual base also virtual?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="481"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#481">481</a></td> <td>CD2</td> <td>Scope of template parameters</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="482"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#482">482</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Qualified declarators in redeclarations</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="483"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#483">483</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Normative requirements on integral ranges</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="484"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#484">484</a></td> <td>CD1</td> <td>Can a <I>base-specifier</I> name a cv-qualified class type?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="485"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#485">485</a></td> <td>CD1</td> <td>What is a “name”?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="486"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#486">486</a></td> <td>CD1</td> <td>Invalid return types and template argument deduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="487"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#487">487</a></td> <td>NAD</td> <td>Operator overloading in constant expressions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="488"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#488">488</a></td> <td>CD1</td> <td>Local types, overload resolution, and template argument deduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="489"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#489">489</a></td> <td>NAD</td> <td>Must member function templates be instantiated during overload resolution?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="490"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#490">490</a></td> <td>CD2</td> <td>Name lookup in friend declarations</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="491"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#491">491</a></td> <td>CD1</td> <td>Initializers for empty-class aggregrate members</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Duplicate of <a href="#413">413</a></td> </tr> - <tr> + <tr id="492"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#492">492</a></td> <td>CD1</td> <td><TT>typeid</TT> constness inconsistent with example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="493"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#493">493</a></td> <td>CD2</td> <td>Type deduction from a <TT>bool</TT> context</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#976">976</a></td> </tr> - <tr> + <tr id="494"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#494">494</a></td> <td>CD1</td> <td>Problems with the resolution of issue 45</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#372">372</a></td> </tr> - <tr> + <tr id="495"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#495">495</a></td> <td>CD2</td> <td>Overload resolution with template and non-template conversion functions</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="496"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#496">496</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Is a volatile-qualified type really a POD?</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="497"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#497">497</a></td> <td>CD1</td> <td>Missing required initialization in example</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="498"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#498">498</a></td> <td>open</td> <td>Storage class specifiers in definitions of class members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="499"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#499">499</a></td> <td>CD2</td> <td>Throwing an array of unknown size</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="500"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#500">500</a></td> <td>CD1</td> <td>Access in <I>base-specifier</I>s of friend and nested classes</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#372">372</a></td> </tr> - <tr> + <tr id="501"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#501">501</a></td> <td>NAD</td> <td>Visibility of friend declarations within the befriending class</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="502"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#502">502</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Dependency of nested enumerations and enumerators</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="503"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#503">503</a></td> <td>open</td> <td>Cv-qualified function types in template argument deduction</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="504"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#504">504</a></td> <td>open</td> <td>Should use of a variable in its own initializer require a diagnostic?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="505"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#505">505</a></td> <td>CD1</td> <td>Conditionally-supported behavior for unknown character escapes</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="506"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#506">506</a></td> <td>CD1</td> <td>Conditionally-supported behavior for non-POD objects passed to ellipsis</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="507"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#507">507</a></td> <td>dup</td> <td>Ambiguity assigning class object to built-in type</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Duplicate of <a href="#260">260</a></td> </tr> - <tr> + <tr id="508"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#508">508</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-constructed value-initialized objects</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="509"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#509">509</a></td> <td>CD1</td> <td>Dead code in the specification of default initialization</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="510"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#510">510</a></td> <td>CD1</td> <td>Default initialization of POD classes?</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr class="open"> + <tr class="open" id="511"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#511">511</a></td> <td>open</td> <td>POD-structs with template assignment operators</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="512"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#512">512</a></td> <td>NAD</td> <td>Union members with user-declared non-default constructors</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="513"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#513">513</a></td> <td>CD1</td> <td>Non-class “most-derived” objects</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="514"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#514">514</a></td> <td>CD1</td> <td>Is the initializer for a namespace member in the scope of the namespace?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="515"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#515">515</a></td> <td>CD1</td> <td>Non-dependent references to base class members</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">Superseded by <a href="#1017">1017</a></td> </tr> - <tr> + <tr id="516"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#516">516</a></td> <td>CD1</td> <td>Use of <TT>signed</TT> in bit-field declarations</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="517"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#517">517</a></td> <td>CD1</td> <td>Partial specialization following explicit instantiation</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="518"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#518">518</a></td> <td>CD1</td> <td>Trailing comma following <I>enumerator-list</I></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes (C++11 onwards)</td> </tr> - <tr> + <tr id="519"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#519">519</a></td> <td>CD1</td> <td>Null pointer preservation in <TT>void*</TT> conversions</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="520"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#520">520</a></td> <td>CD1</td> <td>Old-style casts between incomplete class types</td> - <td class="none" align="center">Unknown</td> + <td class="na" align="center">N/A</td> </tr> - <tr> + <tr id="521"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#521">521</a></td> <td>CD1</td> <td>Requirements for exceptions thrown by allocation functions</td> - <td class="none" align="center">Unknown</td> + <td class="none" align="center">No</td> </tr> - <tr> + <tr id="522"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#522">522</a></td> <td>CD1</td> <td>Array-to-pointer decay in template argument deduction</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr class="open"> + <tr class="open" id="523"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#523">523</a></td> <td>open</td> <td>Can a one-past-the-end pointer be invalidated by deleting an adjacent object?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="524"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#524">524</a></td> <td>CD1</td> <td>Can function-notation calls to operator functions be dependent?</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="525"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#525">525</a></td> <td>CD1</td> <td>Missing <TT>*</TT> in example</td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="526"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#526">526</a></td> <td>CD1</td> <td>Confusing aspects in the specification of non-deduced contexts</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="527"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#527">527</a></td> <td>CD2</td> <td>Problems with linkage of types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="528"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#528">528</a></td> <td>open</td> <td>Why are incomplete class types not allowed with <TT>typeid</TT>?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="529"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#529">529</a></td> <td>drafting</td> <td>Use of <TT>template<></TT> with “explicitly-specialized” class templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="530"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#530">530</a></td> <td>CD1</td> <td>Nontype template arguments in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="531"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#531">531</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defining members of explicit specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="532"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#532">532</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Member/nonmember operator template partial ordering</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="533"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#533">533</a></td> <td>NAD</td> <td>Special treatment for C-style header names</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="534"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#534">534</a></td> <td>CD1</td> <td><I>template-name</I>s and <I>operator-function-id</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="535"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#535">535</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Copy construction without a copy constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="536"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#536">536</a></td> <td>drafting</td> <td>Problems in the description of <I>id-expression</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="537"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#537">537</a></td> <td>CD1</td> <td>Definition of “signature”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="538"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#538">538</a></td> <td>CD1</td> <td>Definition and usage
@@ -3272,7318 +3273,8134 @@ of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>, and <I>POD class</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="539"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#539">539</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Constraints on <I>type-specifier-seq</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="540"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#540">540</a></td> <td>CD1</td> <td>Propagation of cv-qualifiers in reference-to-reference collapse</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="541"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#541">541</a></td> <td>CD2</td> <td>Dependent function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="542"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#542">542</a></td> <td>CD2</td> <td>Value initialization of arrays of POD-structs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="543"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#543">543</a></td> <td>CD1</td> <td>Value initialization and default constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="544"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#544">544</a></td> <td>NAD</td> <td>Base class lookup in explicit specialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="545"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#545">545</a></td> <td>open</td> <td>User-defined conversions and built-in operator overload resolution</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="546"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#546">546</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicit instantiation of class template members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="547"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#547">547</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Partial specialization on member function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="548"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#548">548</a></td> <td>dup</td> <td><I>qualified-id</I>s in declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="549"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#549">549</a></td> <td>drafting</td> <td>Non-deducible parameters in partial specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="550"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#550">550</a></td> <td>open</td> <td>Pointer to array of unknown bound in parameter declarations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="551"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#551">551</a></td> <td>CD1</td> <td>When is <TT>inline</TT> permitted in an explicit instantiation?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="552"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#552">552</a></td> <td>NAD</td> <td>Use of <TT>typename</TT> in the type in a non-type <I>parameter-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="553"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#553">553</a></td> <td>NAD</td> <td>Problems with friend allocation and deallocation functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="554"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#554">554</a></td> <td>drafting</td> <td>Definition of “declarative region” and “scope”</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="555"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#555">555</a></td> <td>drafting</td> <td>Pseudo-destructor name lookup</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="556"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#556">556</a></td> <td>CD2</td> <td>Conflicting requirements for acceptable aliasing</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="557"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#557">557</a></td> <td>CD1</td> <td>Does argument-dependent lookup cause template instantiation?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="558"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#558">558</a></td> <td>CD1</td> <td>Excluded characters in universal character names</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="559"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#559">559</a></td> <td>CD1</td> <td>Editing error in issue 382 resolution</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="560"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#560">560</a></td> <td>drafting</td> <td>Use of the <TT>typename</TT> keyword in return types</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="561"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#561">561</a></td> <td>CD2</td> <td>Internal linkage functions in dependent name lookup</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="562"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#562">562</a></td> <td>open</td> <td><I>qualified-id</I>s in non-expression contexts</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="563"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#563">563</a></td> <td>open</td> <td>Linkage specification for objects</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="564"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#564">564</a></td> <td>CD2</td> <td>Agreement of language linkage or <I>linkage-specification</I>s?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="565"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#565">565</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Conflict rules for <I>using-declaration</I>s naming function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="566"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#566">566</a></td> <td>NAD</td> <td>Conversion of negative floating point values to integer type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="567"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#567">567</a></td> <td>NAD</td> <td>Can <TT>size_t</TT> and <TT>ptrdiff_t</TT> be larger than <TT>long</TT>?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="568"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#568">568</a></td> <td>CD1</td> <td>Definition of POD is too strict</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="569"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#569">569</a></td> <td>CD2</td> <td>Spurious semicolons at namespace scope should be allowed</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="570"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#570">570</a></td> <td>CD2</td> <td>Are references subject to the ODR?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="571"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#571">571</a></td> <td>CD2</td> <td>References declared <TT>const</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="572"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#572">572</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Standard conversions for non-built-in types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="573"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#573">573</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Conversions between function pointers and <TT>void*</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="574"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#574">574</a></td> <td>NAD</td> <td>Definition of “copy assignment operator”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="575"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#575">575</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Criteria for deduction failure</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="576"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#576">576</a></td> <td>CD2</td> <td>Typedefs in function definitions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="577"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#577">577</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>void</TT> in an empty parameter list</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="578"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#578">578</a></td> <td>open</td> <td>Phase 1 replacement of characters with <I>universal-character-name</I>s</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="579"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#579">579</a></td> <td>open</td> <td>What is a “nested” <TT>></TT> or <TT>>></TT>?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="580"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#580">580</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Access in <I>template-parameter</I>s of member and friend definitions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="581"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#581">581</a></td> <td>open</td> <td>Can a templated constructor be explicitly instantiated or specialized?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="582"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#582">582</a></td> <td>CD1</td> <td>Template conversion functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="583"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#583">583</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Relational pointer comparisons against the null pointer constant</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="584"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#584">584</a></td> <td>NAD</td> <td>Unions and aliasing</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="585"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#585">585</a></td> <td>NAD</td> <td>Friend template template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="586"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#586">586</a></td> <td>NAD</td> <td>Default <I>template-argument</I>s and template argument deduction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="587"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#587">587</a></td> <td>CD2</td> <td>Lvalue operands of a conditional expression differing only in cv-qualification</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="588"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#588">588</a></td> <td>CD2</td> <td>Searching dependent bases of classes local to function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="589"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#589">589</a></td> <td>CD2</td> <td>Direct binding of class and array rvalues in reference initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="590"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#590">590</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Nested classes and the “current instantiation”</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="591"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#591">591</a></td> - <td>drafting</td> + <td>ready</td> <td>When a dependent base class is the current instantiation</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="592"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#592">592</a></td> <td>CD1</td> <td>Exceptions during construction of local static objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="593"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#593">593</a></td> <td>NAD</td> <td>Falling off the end of a destructor's <I>function-try-block</I> handler</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="594"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#594">594</a></td> <td>CD1</td> <td>Coordinating issues 119 and 404 with delegating constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="595"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#595">595</a></td> <td>dup</td> <td>Exception specifications in templates instantiated from class bodies</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="596"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#596">596</a></td> <td>open</td> <td>Replacing an exception object</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="597"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#597">597</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Conversions applied to out-of-lifetime non-POD lvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="598"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#598">598</a></td> <td>CD2</td> <td>Associated namespaces of overloaded functions and function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="599"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#599">599</a></td> <td>CD2</td> <td>Deleting a null function pointer</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="600"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#600">600</a></td> <td>open</td> <td>Does access control apply to members or to names?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="601"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#601">601</a></td> <td>CD2</td> <td>Type of literals in preprocessing expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="602"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#602">602</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is the injected-class-name of a class template a template?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="603"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#603">603</a></td> <td>CD1</td> <td>Type equivalence and unsigned overflow</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="604"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#604">604</a></td> <td>CD2</td> <td>Argument list for overload resolution in copy-initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="605"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#605">605</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Linkage of explicit specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="606"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#606">606</a></td> <td>CD1</td> <td>Template argument deduction for rvalue references</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="607"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#607">607</a></td> <td>open</td> <td>Lookup of <I>mem-initializer-id</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="608"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#608">608</a></td> <td>CD2</td> <td>Determining the final overrider of a virtual function</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="609"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#609">609</a></td> - <td>open</td> + <td>ready</td> <td>What is a “top-level” cv-qualifier?</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="610"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#610">610</a></td> <td>NAD</td> <td>Computing the negative of <TT>0U</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="611"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#611">611</a></td> <td>CD2</td> <td>Zero-initializing references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="612"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#612">612</a></td> <td>CD2</td> <td>Requirements on a conforming implementation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="613"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#613">613</a></td> <td>CD1</td> <td>Unevaluated uses of non-static class members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="614"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#614">614</a></td> <td>CD1</td> <td>Results of integer <TT>/</TT> and <TT>%</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="615"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#615">615</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect description of variables that can be initialized</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="616"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#616">616</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of “indeterminate value”</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="617"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#617">617</a></td> <td>drafting</td> <td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="618"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#618">618</a></td> <td>CD2</td> <td>Casts in preprocessor conditional expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="619"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#619">619</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Completeness of array types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="620"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#620">620</a></td> <td>CD1</td> <td>Declaration order in layout-compatible POD structs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="621"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#621">621</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template argument deduction from function return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="622"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#622">622</a></td> <td>extension</td> <td>Relational comparisons of arbitrary pointers</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#623">623</a></td> - <td>extension</td> + <tr id="623"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#623">623</a></td> + <td>CD3</td> <td>Use of pointers to deallocated storage</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="624"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#624">624</a></td> <td>CD1</td> <td>Overflow in calculating size of allocation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="625"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#625">625</a></td> <td>CD2</td> <td>Use of <TT>auto</TT> as a <I>template-argument</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="626"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#626">626</a></td> <td>CD2</td> <td>Preprocessor string literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="627"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#627">627</a></td> <td>NAD</td> <td>Values behaving as types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="628"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#628">628</a></td> <td>CD2</td> <td>The values of an enumeration with no enumerator</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="629"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#629">629</a></td> <td>CD1</td> <td><TT>auto</TT> parsing ambiguity</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="630"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#630">630</a></td> <td>CD2</td> <td>Equality of narrow and wide character values in the basic character set</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="631"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#631">631</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Jumping into a “then” clause</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="632"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#632">632</a></td> <td>CD1</td> <td>Brace-enclosed initializer for scalar member of aggregate</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="633"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#633">633</a></td> <td>CD2</td> <td>Specifications for variables that should also apply to references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="634"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#634">634</a></td> <td>CD1</td> <td>Conditionally-supported behavior for non-POD objects passed to ellipsis redux</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="635"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#635">635</a></td> <td>NAD</td> <td>Names of constructors and destructors of templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="636"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#636">636</a></td> <td>drafting</td> <td>Dynamic type of objects and aliasing</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="637"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#637">637</a></td> <td>CD1</td> <td>Sequencing rules and example disagree</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="638"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#638">638</a></td> <td>CD2</td> <td>Explicit specialization and friendship</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="639"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#639">639</a></td> <td>CD1</td> <td>What makes side effects “different” from one another?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="640"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#640">640</a></td> <td>open</td> <td>Accessing destroyed local objects of static storage duration</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="641"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#641">641</a></td> <td>CD2</td> <td>Overload resolution and conversion-to-same-type operators</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="642"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#642">642</a></td> <td>CD2</td> <td>Definition and use of “block scope” and “local scope”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="643"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#643">643</a></td> <td>NAD</td> <td>Use of <TT>decltype</TT> in a class <I>member-specification</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="644"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#644">644</a></td> <td>CD1</td> <td>Should a trivial class type be a literal type?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="645"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#645">645</a></td> <td>CD2</td> <td>Are bit-field and non-bit-field members layout compatible?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="646"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#646">646</a></td> <td>NAD</td> <td>Can a class with a constexpr copy constructor be a literal type?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="647"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#647">647</a></td> <td>CD1</td> <td>Non-constexpr instances of constexpr constructor templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="648"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#648">648</a></td> <td>CD1</td> <td>Constant expressions in constexpr initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="649"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#649">649</a></td> <td>CD1</td> <td>Optionally ill-formed extended alignment requests</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="650"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#650">650</a></td> <td>CD2</td> <td>Order of destruction for temporaries bound to the returned value of a function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="651"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#651">651</a></td> <td>CD1</td> <td>Problems in <TT>decltype</TT> specification and examples</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="652"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#652">652</a></td> <td>CD2</td> <td>Compile-time evaluation of floating-point expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="653"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#653">653</a></td> <td>CD2</td> <td>Copy assignment of unions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="654"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#654">654</a></td> <td>CD1</td> <td>Conversions to and from <TT>nullptr_t</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="655"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#655">655</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Initialization not specified for forwarding constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="656"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#656">656</a></td> <td>CD2</td> <td>Direct binding to the result of a conversion operator</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="657"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#657">657</a></td> <td>CD2</td> <td>Abstract class parameter in synthesized declaration</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="658"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#658">658</a></td> <td>CD2</td> <td>Defining <TT>reinterpret_cast</TT> for pointer types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="659"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#659">659</a></td> <td>CD1</td> <td>Alignment of function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="660"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#660">660</a></td> <td>CD1</td> <td>Unnamed scoped enumerations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="661"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#661">661</a></td> <td>CD1</td> <td>Semantics of arithmetic comparisons</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="662"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#662">662</a></td> <td>NAD</td> <td>Forming a pointer to a reference type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="663"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#663">663</a></td> <td>CD1</td> <td>Valid Cyrillic identifier characters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="664"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#664">664</a></td> <td>CD2</td> <td>Direct binding of references to non-class rvalue references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="665"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#665">665</a></td> <td>CD2</td> <td>Problems in the specification of <TT>dynamic_cast</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="666"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#666">666</a></td> <td>CD1</td> <td>Dependent <I>qualified-id</I>s without the <TT>typename</TT> keyword</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="667"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#667">667</a></td> <td>CD2</td> <td>Trivial special member functions that cannot be implicitly defined</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="668"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#668">668</a></td> <td>CD2</td> <td>Throwing an exception from the destructor of a local static object</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="669"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#669">669</a></td> <td>NAD</td> <td>Confusing specification of the meaning of <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="670"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#670">670</a></td> <td>open</td> <td>Copy initialization via derived-to-base conversion in the second step</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="671"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#671">671</a></td> <td>CD1</td> <td>Explicit conversion from a scoped enumeration type to integral type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="672"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#672">672</a></td> <td>CD2</td> <td>Sequencing of initialization in <I>new-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="673"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#673">673</a></td> <td>NAD</td> <td>Injection of names from <I>elaborated-type-specifier</I>s in <TT>friend</TT> declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="674"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#674">674</a></td> - <td>FDIS</td> + <td>C++11</td> <td>“matching specialization” for a friend declaration</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="675"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#675">675</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Signedness of bit-field with typedef or template parameter type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="676"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#676">676</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>static_assert-declaration</I>s and general requirements for declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="677"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#677">677</a></td> <td>CD1</td> <td>Deleted <TT>operator delete</TT> and virtual destructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="678"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#678">678</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Language linkage of member function parameter types and the ODR</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="679"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#679">679</a></td> <td>CD1</td> <td>Equivalence of <I>template-id</I>s and operator function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="680"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#680">680</a></td> <td>CD2</td> <td>What is a move constructor?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="681"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#681">681</a></td> <td>CD1</td> <td>Restrictions on declarators with late-specified return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="682"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#682">682</a></td> <td>drafting</td> <td>Missing description of lookup of template aliases</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="683"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#683">683</a></td> <td>CD1</td> <td>Requirements for trivial subobject special functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="684"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#684">684</a></td> <td>CD1</td> <td>Constant expressions involving the address of an automatic variable</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="685"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#685">685</a></td> <td>CD2</td> <td>Integral promotion of enumeration ignores fixed underlying type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="686"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#686">686</a></td> <td>CD1</td> <td>Type declarations/definitions in <I>type-specifier-seq</I>s and <I>type-id</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="687"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#687">687</a></td> <td>extension</td> <td><TT>template</TT> keyword with <I>unqualified-id</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="688"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#688">688</a></td> <td>CD1</td> <td>Constexpr constructors and static initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="689"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#689">689</a></td> <td>open</td> <td>Maximum values of signed and unsigned integers</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="690"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#690">690</a></td> <td>CD2</td> <td>The dynamic type of an rvalue reference</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="691"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#691">691</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template parameter packs in class template partial specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="692"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#692">692</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Partial ordering of variadic class template partial specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="693"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#693">693</a></td> <td>CD2</td> <td>New string types and deprecated conversion</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="694"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#694">694</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Zero- and value-initialization of union objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="695"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#695">695</a></td> <td>CD2</td> <td>Compile-time calculation errors in constexpr functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="696"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#696">696</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Use of block-scope constants in local classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="697"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#697">697</a></td> <td>open</td> <td>Deduction rules apply to more than functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="698"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#698">698</a></td> <td>open</td> <td>The definition of “sequenced before” is too narrow</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="699"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#699">699</a></td> <td>CD2</td> <td>Must constexpr member functions be defined in the class <I>member-specification</I>?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="700"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#700">700</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Constexpr member functions of class templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="701"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#701">701</a></td> <td>CD2</td> <td>When is the array-to-pointer conversion applied?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="702"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#702">702</a></td> <td>CD2</td> <td>Preferring conversion to <TT>std::initializer_list</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="703"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#703">703</a></td> <td>CD2</td> <td>Narrowing for literals that cannot be exactly represented</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="704"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#704">704</a></td> <td>CD2</td> <td>To which <I>postfix-expression</I>s does overload resolution apply?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="705"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#705">705</a></td> <td>CD2</td> <td>Suppressing argument-dependent lookup via parentheses</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="706"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#706">706</a></td> <td>NAD</td> <td>Use of <TT>auto</TT> with rvalue references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="707"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#707">707</a></td> <td>CD2</td> <td>Undefined behavior in integral-to-floating conversions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="708"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#708">708</a></td> <td>open</td> <td>Partial specialization of member templates of class templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="709"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#709">709</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Enumeration names as <I>nested-name-specifier</I>s in deduction failure</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="710"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#710">710</a></td> <td>CD2</td> <td>Data races during construction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="711"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#711">711</a></td> <td>CD2</td> <td><TT>auto</TT> with <I>braced-init-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="712"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#712">712</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Are integer constant operands of a <I>conditional-expression</I> “used?”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="713"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#713">713</a></td> <td>CD2</td> <td>Unclear note about cv-qualified function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="714"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#714">714</a></td> <td>CD2</td> <td>Static const data members and <I>braced-init-list</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="715"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#715">715</a></td> <td>CD2</td> <td>Class member access constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="716"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#716">716</a></td> <td>CD2</td> <td>Specifications that should apply only to non-static union data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="717"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#717">717</a></td> <td>CD2</td> <td>Unintentional restrictions on the use of <TT>thread_local</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="718"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#718">718</a></td> <td>open</td> <td>Non-class, non-function friend declarations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="719"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#719">719</a></td> <td>CD2</td> <td>Specifications for <I>operator-function-id</I> that should also apply to <I>literal-operator-id</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="720"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#720">720</a></td> <td>CD2</td> <td>Need examples of <I>lambda-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="721"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#721">721</a></td> <td>CD2</td> <td>Where must a variable be initialized to be used in a constant expression?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="722"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#722">722</a></td> <td>CD2</td> <td>Can <TT>nullptr</TT> be passed to an ellipsis?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="726"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#726">726</a></td> <td>CD2</td> <td>Atomic and non-atomic objects in the memory model</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="727"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#727">727</a></td> - <td>open</td> + <td>drafting</td> <td>In-class explicit specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="728"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#728">728</a></td> <td>extension</td> <td>Restrictions on local classes</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="729"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#729">729</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Qualification conversions and handlers of reference-to-pointer type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="730"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#730">730</a></td> <td>CD2</td> <td>Explicit specializations of members of non-template classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="731"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#731">731</a></td> <td>CD2</td> <td>Omitted reference qualification of member function type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="732"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#732">732</a></td> <td>CD2</td> <td>Late-specified return types in function definitions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="733"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#733">733</a></td> <td>NAD</td> <td>Reference qualification of copy assignment operators</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="734"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#734">734</a></td> <td>CD2</td> <td>Are unique addresses required for namespace-scope variables?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="735"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#735">735</a></td> <td>CD2</td> <td>Missing case in specification of safely-derived pointers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="736"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#736">736</a></td> <td>NAD</td> <td>Is the <TT>&</TT> <I>ref-qualifier</I> needed?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="737"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#737">737</a></td> <td>CD2</td> <td>Uninitialized trailing characters in string initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="738"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#738">738</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> not permitted by the syntax of constructor declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="739"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#739">739</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Signedness of plain bit-fields</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="740"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#740">740</a></td> <td>CD2</td> <td>Incorrect note on data races</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="741"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#741">741</a></td> - <td>FDIS</td> + <td>C++11</td> <td>“plain” <TT>long long</TT> bit-fields</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="742"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#742">742</a></td> <td>open</td> <td>Postfix increment/decrement with long bit-field operands</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="743"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#743">743</a></td> <td>CD2</td> <td>Use of <TT>decltype</TT> in a <I>nested-name-specifier</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="744"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#744">744</a></td> <td>CD2</td> <td>Matching template arguments with template template parameters with parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="745"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#745">745</a></td> <td>open</td> <td>Effect of ill-formedness resulting from <TT>#error</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="746"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#746">746</a></td> <td>CD2</td> <td>Use of <TT>auto</TT> in <I>new-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="747"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#747">747</a></td> <td>dup</td> <td>Access of protected base classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="749"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#749">749</a></td> <td>CD2</td> <td>References to function types with a <I>cv-qualifier</I> or <I>ref-qualifier</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="750"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#750">750</a></td> <td>CD2</td> <td>Implementation constraints on reference-only closure objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="751"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#751">751</a></td> <td>CD2</td> <td>Deriving from closure classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="752"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#752">752</a></td> <td>CD2</td> <td>Name lookup in nested <I>lambda-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="753"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#753">753</a></td> <td>CD2</td> <td>Array names in lambda capture sets</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="754"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#754">754</a></td> <td>CD2</td> <td>Lambda expressions in default arguments of block-scope function declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#755">755</a></td> - <td>extension</td> + <tr id="755"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#755">755</a></td> + <td>CD3</td> <td>Generalized <I>lambda-capture</I>s</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="756"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#756">756</a></td> <td>CD2</td> <td>Dropping cv-qualification on members of closure objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="757"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#757">757</a></td> <td>CD2</td> <td>Types without linkage in declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="758"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#758">758</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing cases of declarations that are not definitions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="759"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#759">759</a></td> <td>CD2</td> <td>Destruction of closure objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="760"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#760">760</a></td> <td>CD2</td> <td><TT>this</TT> inside a nested class of a non-static member function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="761"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#761">761</a></td> <td>CD2</td> <td>Inferred return type of closure object call operator</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="762"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#762">762</a></td> <td>CD2</td> <td>Name lookup in the <I>compound-statement</I> of a lambda expression</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="763"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#763">763</a></td> <td>CD2</td> <td>Is a closure object's <TT>operator()</TT> inline?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="764"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#764">764</a></td> <td>CD2</td> <td>Capturing unused variables in a lambda expression</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="765"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#765">765</a></td> <td>CD2</td> <td>Local types in inline functions with external linkage</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="766"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#766">766</a></td> <td>CD2</td> <td>Where may lambda expressions appear?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="767"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#767">767</a></td> <td>CD2</td> <td><TT>void</TT> and other unnamed <I>lambda-parameter</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="768"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#768">768</a></td> <td>CD2</td> <td>Ellipsis in a lambda parameter list</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="769"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#769">769</a></td> <td>CD2</td> <td>Initialization of closure objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="770"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#770">770</a></td> <td>CD2</td> <td>Ambiguity in late-specified return type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="771"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#771">771</a></td> <td>CD2</td> <td>Move-construction of reference members of closure objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="772"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#772">772</a></td> <td>CD2</td> <td><I>capture-default</I> in lambdas in local default arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="773"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773">773</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Parentheses in address non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="774"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#774">774</a></td> <td>CD2</td> <td>Can a closure class be a POD?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="775"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#775">775</a></td> <td>CD2</td> <td>Capturing references to functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="776"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#776">776</a></td> <td>CD2</td> <td>Delegating constructors, destructors, and <TT>std::exit</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="777"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#777">777</a></td> <td>CD2</td> <td>Default arguments and parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="778"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#778">778</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template parameter packs in non-type template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="779"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#779">779</a></td> <td>CD2</td> <td>Rvalue reference members of closure objects?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="782"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#782">782</a></td> <td>CD2</td> <td>Lambda expressions and argument-dependent lookup</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="783"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#783">783</a></td> <td>open</td> <td>Definition of “argument”</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="784"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#784">784</a></td> - <td>FDIS</td> + <td>C++11</td> <td>List of incompatibilities with the previous Standard</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="785"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#785">785</a></td> <td>CD2</td> <td>“Execution sequence” is inappropriate phraseology</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="786"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#786">786</a></td> <td>CD2</td> <td>Definition of “thread”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="787"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#787">787</a></td> <td>CD2</td> <td>Unnecessary lexical undefined behavior</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="788"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#788">788</a></td> <td>CD2</td> <td>Relationship between locale and values of the execution character set</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="789"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#789">789</a></td> <td>CD2</td> <td>Deprecating trigraphs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="790"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#790">790</a></td> <td>CD2</td> <td>Concatenation of raw and non-raw string literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="792"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#792">792</a></td> <td>CD2</td> <td>Effects of <TT>std::quick_exit</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="793"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#793">793</a></td> <td>CD2</td> <td>Use of class members during destruction</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="794"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#794">794</a></td> <td>extension</td> <td>Base-derived conversion in member type of pointer-to-member conversion</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="795"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#795">795</a></td> <td>NAD</td> <td>Dependency of lambdas on <TT><functional></TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="796"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#796">796</a></td> <td>CD2</td> <td>Lifetime of a closure object with members captured by reference</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="797"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#797">797</a></td> <td>CD2</td> <td>Converting a no-capture lambda to a function type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="798"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#798">798</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overloaded subscript operator described in clause 5</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="799"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#799">799</a></td> <td>CD2</td> <td>Can <TT>reinterpret_cast</TT> be used to cast an operand to its own type?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="800"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#800">800</a></td> <td>NAD</td> <td>Safely-derived pointers and object pointers converted from function pointers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="801"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#801">801</a></td> <td>CD2</td> <td>Casting away constness in a cast to rvalue reference type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="803"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#803">803</a></td> <td>CD2</td> <td><TT>sizeof</TT> an enumeration type with a fixed underlying type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="804"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#804">804</a></td> <td>CD2</td> <td>Deducing the type in <TT>new auto(x)</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="805"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#805">805</a></td> <td>CD2</td> <td>Which exception to throw for overflow in array size calculation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="806"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#806">806</a></td> <td>CD2</td> <td>Enumeration types in integral constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="807"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#807">807</a></td> <td>NAD</td> <td><TT>typeid</TT> expressions in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="808"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#808">808</a></td> <td>CD2</td> <td>Non-type <I>decl-specifier</I>s versus max-munch</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="809"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#809">809</a></td> <td>CD2</td> <td>Deprecation of the <TT>register</TT> keyword</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="810"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#810">810</a></td> <td>CD2</td> <td>Block-scope <TT>thread_local</TT> variables should be implicitly <TT>static</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="811"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#811">811</a></td> <td>CD2</td> <td>Unclear implications of const-qualification</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="812"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#812">812</a></td> <td>CD2</td> <td>Duplicate names in inline namespaces</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="813"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#813">813</a></td> <td>open</td> <td><TT>typename</TT> in a <I>using-declaration</I> with a non-dependent name</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="814"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#814">814</a></td> <td>CD2</td> <td>Attribute to indicate that a function throws nothing</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="815"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#815">815</a></td> <td>CD2</td> <td>Parameter pack expansion inside attributes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="816"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#816">816</a></td> <td>CD2</td> <td>Diagnosing violations of <TT>[[final]]</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="817"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#817">817</a></td> <td>CD2</td> <td>Meaning of <TT>[[final]]</TT> applied to a class definition</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="818"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#818">818</a></td> <td>CD2</td> <td>Function parameter packs in non-final positions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="819"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#819">819</a></td> <td>NAD</td> <td>Access control and deleted implicitly-declared special member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="820"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#820">820</a></td> <td>CD2</td> <td>Deprecation of <TT>export</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="822"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#822">822</a></td> <td>extension</td> <td>Additional contexts for template aliases</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="823"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#823">823</a></td> <td>CD2</td> <td>Literal types with constexpr conversions as non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="828"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#828">828</a></td> <td>CD2</td> <td>Destruction of exception objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="829"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#829">829</a></td> <td>NAD</td> <td>At what point is <TT>std::unexpected</TT> called?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="830"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#830">830</a></td> <td>CD2</td> <td>Deprecating exception specifications</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="831"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#831">831</a></td> <td>CD2</td> <td>Limit on recursively nested template instantiations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="832"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#832">832</a></td> <td>CD2</td> <td>Value of preprocessing numbers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="833"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#833">833</a></td> <td>CD2</td> <td>Explicit conversion of a scoped enumeration value to a floating type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="834"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#834">834</a></td> <td>CD2</td> <td>What is an “ordinary string literal”?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="835"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#835">835</a></td> <td>CD2</td> <td>Scoped enumerations and the “usual arithmetic conversions”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="836"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#836">836</a></td> <td>NAD</td> <td><TT>[[noreturn]]</TT> applied to function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="837"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#837">837</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Constexpr functions and <TT>return</TT> <I>braced-init-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="838"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#838">838</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Use of <TT>this</TT> in a <I>brace-or-equal-initializer</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="839"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#839">839</a></td> <td>dup</td> <td><TT>sizeof</TT> with opaque enumerations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="840"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#840">840</a></td> <td>CD2</td> <td>Rvalue references as nontype template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="842"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#842">842</a></td> <td>CD2</td> <td>Casting to rvalue reference type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="845"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#845">845</a></td> <td>CD2</td> <td>What is the “first declaration” of an explicit specialization?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="846"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#846">846</a></td> <td>CD2</td> <td>Rvalue references to functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="847"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#847">847</a></td> <td>CD2</td> <td>Error in rvalue reference deduction example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="850"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#850">850</a></td> <td>CD2</td> <td>Restrictions on use of non-static data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="852"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#852">852</a></td> <td>open</td> <td><I>using-declaration</I>s and dependent base classes</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="853"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#853">853</a></td> <td>CD2</td> <td>Support for relaxed pointer safety</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="854"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#854">854</a></td> <td>CD2</td> <td>Left shift and unsigned extended types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="855"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#855">855</a></td> <td>CD2</td> <td>Incorrect comments in <I>braced-init-list</I> assignment example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="858"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#858">858</a></td> <td>CD2</td> <td>Example binding an rvalue reference to an lvalue</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="860"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#860">860</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicit qualification of constexpr member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="861"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#861">861</a></td> <td>CD2</td> <td>Unintended ambiguity in inline namespace lookup</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="862"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#862">862</a></td> <td>CD2</td> <td>Undefined behavior with enumerator value overflow</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="863"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#863">863</a></td> <td>CD2</td> <td>Rvalue reference cast to incomplete type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="864"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#864">864</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>braced-init-list</I> in the range-based <TT>for</TT> statement</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="865"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#865">865</a></td> <td>CD2</td> <td>Initializing a <TT>std::initializer_list</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="869"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#869">869</a></td> <td>CD2</td> <td>Uninitialized <TT>thread_local</TT> objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="872"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#872">872</a></td> <td>CD2</td> <td>Lexical issues with raw strings</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="873"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#873">873</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Deducing rvalue references in declarative contexts</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="874"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#874">874</a></td> <td>CD2</td> <td>Class-scope definitions of enumeration types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="876"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#876">876</a></td> <td>CD2</td> <td>Type references in rvalue reference deduction specification</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="877"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#877">877</a></td> <td>CD2</td> <td>Viable functions and binding references to rvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="879"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#879">879</a></td> <td>CD2</td> <td>Missing built-in comparison operators for pointer types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="880"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#880">880</a></td> <td>CD2</td> <td>Built-in conditional operator for scoped enumerations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="882"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#882">882</a></td> <td>CD2</td> <td>Defining <TT>main</TT> as deleted</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="883"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#883">883</a></td> <td>CD2</td> <td><TT>std::memcpy</TT> vs <TT>std::memmove</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="884"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#884">884</a></td> <td>CD2</td> <td>Defining an explicitly-specialized static data member</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="885"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#885">885</a></td> <td>NAD</td> <td>Partial ordering of function templates with unordered parameter pairs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="886"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#886">886</a></td> <td>CD2</td> <td>Member initializers and aggregates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="887"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#887">887</a></td> <td>CD2</td> <td>Move construction of thrown object</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="888"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#888">888</a></td> <td>CD2</td> <td>Union member initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="891"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#891">891</a></td> <td>CD2</td> <td><TT>const_cast</TT> to rvalue reference from objectless rvalue</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="892"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#892">892</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing requirements for constexpr constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="893"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#893">893</a></td> <td>NAD</td> <td>Brace syntax for <I>enumerator-definition</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="896"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#896">896</a></td> <td>CD2</td> <td>Rvalue references and rvalue-reference conversion functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="897"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#897">897</a></td> <td>open</td> <td><TT>_Pragma</TT> and extended <I>string-literal</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="898"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#898">898</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Declarations in constexpr functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="899"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#899">899</a></td> <td>CD2</td> <td>Explicit conversion functions in direct class initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="900"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#900">900</a></td> <td>NAD</td> <td>Lifetime of temporaries in range-based <TT>for</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="901"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#901">901</a></td> <td>drafting</td> <td>Deleted <TT>operator delete</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="902"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#902">902</a></td> <td>NAD</td> <td>In-class initialization of non-constant static data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="903"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#903">903</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value-dependent integral null pointer constants</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="904"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#904">904</a></td> <td>CD2</td> <td>Parameter packs in <I>lambda-capture</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="905"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#905">905</a></td> <td>CD2</td> <td>Explicit defaulted copy constructors and trivial copyability</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="906"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#906">906</a></td> <td>CD2</td> <td>Which special member functions can be defaulted?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="908"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#908">908</a></td> <td>CD2</td> <td>Deleted global allocation and deallocation functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="909"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#909">909</a></td> <td>NAD</td> <td>Old-style casts with conversion functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="910"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#910">910</a></td> <td>CD2</td> <td>Move constructors and implicitly-declared copy constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="912"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#912">912</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Character literals and <I>universal-character-name</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="913"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#913">913</a></td> <td>CD2</td> <td>Deduction rules for array- and function-type conversion functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="914"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#914">914</a></td> <td>extension</td> <td>Value-initialization of array types</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="915"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#915">915</a></td> <td>CD2</td> <td>Deleted specializations of member function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="916"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#916">916</a></td> <td>open</td> <td>Does a reference type have a destructor?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="919"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#919">919</a></td> <td>CD2</td> <td>Contradictions regarding inline namespaces</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="920"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#920">920</a></td> <td>CD2</td> <td>Interaction of inline namespaces and <I>using-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="921"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#921">921</a></td> <td>CD2</td> <td>Unclear specification of inline namespaces</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="922"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#922">922</a></td> <td>CD2</td> <td>Implicit default constructor definitions and <TT>const</TT> variant members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="923"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#923">923</a></td> <td>CD2</td> <td>Inline explicit specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="924"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#924">924</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>alias-declaration</I> as a class member</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="925"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#925">925</a></td> <td>open</td> <td>Type of character literals in preprocessor expressions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="926"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#926">926</a></td> <td>CD2</td> <td>Inline unnamed namespaces</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="927"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#927">927</a></td> <td>CD2</td> <td>Implicitly-deleted default constructors and member initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="928"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#928">928</a></td> <td>CD2</td> <td>Defaulting a function that would be implicitly defined as deleted</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="929"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#929">929</a></td> <td>CD2</td> <td>What is a template alias?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="930"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#930">930</a></td> <td>CD2</td> <td><TT>alignof</TT> with incomplete array type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="931"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#931">931</a></td> <td>CD2</td> <td>Confusing reference to the length of a user-defined string literal</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="932"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#932">932</a></td> <td>CD2</td> <td>UCNs in closing delimiters of raw string literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="933"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#933">933</a></td> <td>CD2</td> <td>32-bit UCNs with 16-bit <TT>wchar_t</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="934"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#934">934</a></td> <td>CD2</td> <td>List-initialization of references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="935"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#935">935</a></td> <td>CD2</td> <td>Missing overloads for character types for user-defined literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="936"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#936">936</a></td> <td>CD2</td> <td>Array initialization with new string literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="937"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#937">937</a></td> <td>NAD</td> <td>Restrictions on values of template arguments in user-defined literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="938"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#938">938</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Initializer lists and array new</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="939"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#939">939</a></td> <td>CD2</td> <td>Explicitly checking virtual function overriding</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="940"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#940">940</a></td> <td>CD2</td> <td>Global anonymous unions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="941"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#941">941</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicit specialization of deleted function template</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="942"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#942">942</a></td> <td>CD2</td> <td>Is <TT>this</TT> an entity?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="943"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#943">943</a></td> <td>open</td> <td>Is <TT>T()</TT> a temporary?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="944"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#944">944</a></td> <td>open</td> <td><TT>reinterpret_cast</TT> for all types with the same size and alignment</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="945"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#945">945</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Use of <TT>this</TT> in a late-specified return type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="946"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#946">946</a></td> <td>CD2</td> <td>Order of destruction of local static objects and calls to <TT>std::atexit</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="947"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#947">947</a></td> - <td>extension</td> + <td>NAD</td> <td>Deducing type template arguments from default function arguments</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="948"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#948">948</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> in <I>condition</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="949"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#949">949</a></td> <td>open</td> <td>Requirements for freestanding implementations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="950"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#950">950</a></td> <td>CD2</td> <td>Use of <TT>decltype</TT> as a <I>class-name</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="951"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#951">951</a></td> <td>CD2</td> <td>Problems with <I>attribute-specifier</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="952"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#952">952</a></td> <td>drafting</td> <td>Insufficient description of “naming class”</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="953"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#953">953</a></td> <td>CD2</td> <td>Rvalue references and function viability</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="954"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#954">954</a></td> <td>open</td> <td>Overload resolution of conversion operator templates with built-in types</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="955"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#955">955</a></td> <td>CD2</td> <td>Can a closure type's <TT>operator()</TT> be virtual?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="956"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#956">956</a></td> <td>CD2</td> <td>Function prototype scope with late-specified return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="957"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#957">957</a></td> <td>CD2</td> <td>Alternative tokens and <I>attribute-token</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="958"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#958">958</a></td> <td>NAD</td> <td>Lambdas and <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="959"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#959">959</a></td> <td>CD2</td> <td>Alignment attribute for class and enumeration types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="960"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#960">960</a></td> <td>CD2</td> <td>Covariant functions and lvalue/rvalue references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="961"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#961">961</a></td> <td>CD2</td> <td>Overload resolution and conversion of <TT>std::nullptr_t</TT> to <TT>bool</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="962"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#962">962</a></td> <td>CD2</td> <td>Attributes appertaining to class and enum types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="963"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#963">963</a></td> <td>CD2</td> <td>Comparing <TT>nullptr</TT> with 0</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="964"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#964">964</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect description of when the lvalue-to-rvalue conversion applies</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="965"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#965">965</a></td> <td>CD2</td> <td>Limiting the applicability of the <TT>carries_dependency</TT> attribute</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="966"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#966">966</a></td> <td>CD2</td> <td>Nested types without linkage</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="967"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#967">967</a></td> <td>open</td> <td>Exception specification of replacement allocation function</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="968"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#968">968</a></td> <td>CD2</td> <td>Syntactic ambiguity of the attribute notation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="969"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#969">969</a></td> <td>CD2</td> <td>Explicit instantiation declarations of class template specializations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="970"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#970">970</a></td> <td>CD2</td> <td>Consistent use of “appertain” and “apply”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="971"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#971">971</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect treatment of <I>exception-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="972"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#972">972</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Allowing multiple <I>attribute-specifier</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="973"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#973">973</a></td> <td>CD2</td> <td>Function types in <I>exception-specification</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="974"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#974">974</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Default arguments for lambdas</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="975"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#975">975</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Restrictions on return type deduction for lambdas</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="976"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#976">976</a></td> <td>CD2</td> <td>Deduction for <TT>const T&</TT> conversion operators</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="977"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#977">977</a></td> - <td>DRWP</td> + <td>CD3</td> <td>When is an enumeration type complete?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="978"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#978">978</a></td> <td>CD2</td> <td>Incorrect specification for copy initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="979"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#979">979</a></td> <td>CD2</td> <td>Position of <I>attribute-specifier</I> in declarator syntax</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="980"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#980">980</a></td> <td>CD2</td> <td>Explicit instantiation of a member of a class template</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="981"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#981">981</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Constexpr constructor templates and literal types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="982"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#982">982</a></td> <td>NAD</td> <td>Initialization with an empty initializer list</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="983"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#983">983</a></td> <td>CD2</td> <td>Ambiguous pointer-to-member constant</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="984"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#984">984</a></td> <td>CD2</td> <td>“Deduced type” is unclear in <TT>auto</TT> type deduction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="985"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#985">985</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Alternative tokens and user-defined literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="986"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#986">986</a></td> <td>CD2</td> <td>Transitivity of <I>using-directive</I>s versus qualified lookup</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="987"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#987">987</a></td> <td>open</td> <td>Which declarations introduce namespace members?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="988"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#988">988</a></td> <td>CD2</td> <td>Reference-to-reference collapsing with <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="989"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#989">989</a></td> <td>CD2</td> <td>Misplaced list-initialization example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="990"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#990">990</a></td> <td>CD2</td> <td>Value initialization with multiple initializer-list constructors</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="991"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#991">991</a></td> <td>CD2</td> <td>Reference parameters of constexpr functions and constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="992"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#992">992</a></td> <td>NAD</td> <td>Inheriting explicitness</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="993"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#993">993</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Freedom to perform instantiation at the end of the translation unit</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="994"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#994">994</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>braced-init-list</I> as a default argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="995"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#995">995</a></td> <td>CD2</td> <td>Incorrect example for <I>using-declaration</I> and explicit instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="996"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#996">996</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Ambiguous partial specializations of member class templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="997"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#997">997</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Argument-dependent lookup and dependent function template parameter types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="998"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#998">998</a></td> <td>dup</td> <td>Function parameter transformations and template functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="999"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#999">999</a></td> <td>CD2</td> <td>“Implicit” or “implied” object argument/parameter?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1000"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1000">1000</a></td> <td>CD2</td> <td>Mistaking member typedefs for constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1001"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1001">1001</a></td> <td>drafting</td> <td>Parameter type adjustment in dependent parameter types</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1002"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1002">1002</a></td> <td>NAD</td> <td>Pack expansion for function arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1003"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1003">1003</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Acceptable definitions of <TT>main</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1004"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1004">1004</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Injected-class-names as arguments for template template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1005"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1005">1005</a></td> <td>NAD</td> <td>Qualified name resolution in member functions of class templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1006"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1006">1006</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>std::nullptr_t</TT> as a non-type template parameter</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1007"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1007">1007</a></td> <td>NAD</td> <td>Protected access and pointers to members</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1008"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1008">1008</a></td> <td>extension</td> <td>Querying the alignment of an object</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1009"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1009">1009</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing cases in the <I>declarator-id</I> of a function template declaration</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1010"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1010">1010</a></td> <td>CD2</td> <td>Address of object with dynamic storage duration in constant expression</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1011"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1011">1011</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Standard conversions that cannot be inverted</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1012"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1012">1012</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Undeprecating <TT>static</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1013"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1013">1013</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Uninitialized <TT>std::nullptr_t</TT> objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1014"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1014">1014</a></td> <td>NAD</td> <td>Overload resolution between <TT>const T&</TT> and <TT>T&&</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1015"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1015">1015</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template arguments and argument-dependent lookup</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1016"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1016">1016</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overloadable declarations, function templates, and references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1017"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1017">1017</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Member access transformation in unevaluated operands</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1018"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1018">1018</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Ambiguity between <I>simple-declaration</I> and <I>attribute-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1019"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1019">1019</a></td> <td>dup</td> <td>Dependent <I>simple-template-id</I>s in <I>base-specifier</I>s and <I>mem-initializer</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1020"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1020">1020</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Implicitly-defined copy constructors and explicit base class constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1021"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1021">1021</a></td> - <td>open</td> + <td>drafting</td> <td>Definitions of namespace members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1022"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1022">1022</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Can an enumeration variable have values outside the values of the enumeration?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1023"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1023">1023</a></td> <td>dup</td> <td><TT>thread_local</TT> objects as non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1024"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1024">1024</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Limits on multicharacter literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1025"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1025">1025</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Use of a reference as a non-type template argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1026"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1026">1026</a></td> <td>NAD</td> <td>Cv-qualified non-class rvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1027"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1027">1027</a></td> <td>drafting</td> <td>Type consistency and reallocation of scalar types</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1028"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1028">1028</a></td> <td>open</td> <td>Dependent names in non-defining declarations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1029"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1029">1029</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Type of a destructor call</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1030"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1030">1030</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Evaluation order in <I>initializer-list</I>s used in aggregate initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1031"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1031">1031</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Optional elements in attributes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1032"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1032">1032</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Empty pack expansions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1033"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1033">1033</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Restrictions on alignment attributes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1034"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1034">1034</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Attributes for <TT>return</TT> statements in lambdas</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1035"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1035">1035</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Omitted and required <I>decl-specifier</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1036"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1036">1036</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Alignment attribute in an <I>exception-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1037"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1037">1037</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Requirements for operands of <I>delete-expression</I>s and deallocation functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1038"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1038">1038</a></td> <td>open</td> <td>Overload resolution of <TT>&x.static_func</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1039"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1039">1039</a></td> <td>dup</td> <td>Coordinating C and C++ alignment specifications</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1040"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1040">1040</a></td> <td>NAD</td> <td>Memory model issues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1041"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1041">1041</a></td> <td>dup</td> <td><I>alias-declaration</I>s as class members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1042"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1042">1042</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Attributes in <I>alias-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1043"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1043">1043</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Qualified name lookup in the current instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1044"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1044">1044</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Point of declaration for an <I>alias-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1045"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1045">1045</a></td> <td>NAD</td> <td>Requiring explicit instantiation declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1046"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1046">1046</a></td> <td>open</td> <td>What is a “use” of a class specialization?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1047"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1047">1047</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is <TT>typeid</TT> value-dependent?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1048">1048</a></td> - <td>extension</td> + <tr class="open" id="1048"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1048">1048</a></td> + <td>open</td> <td><TT>auto</TT> deduction and lambda return type deduction.</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1049"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1049">1049</a></td> <td>open</td> <td>Copy elision through reference parameters of inline functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1050"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1050">1050</a></td> <td>NAD</td> <td>Effects of thread support on object lifetime</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1051"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1051">1051</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Reference members and generated copy constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1052"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1052">1052</a></td> <td>dup</td> <td><TT>const</TT> non-static data member and PODness</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1053"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1053">1053</a></td> <td>NAD</td> <td>Terminate vs undefined behavior for noexcept violation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1054"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1054">1054</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Lvalue-to-rvalue conversions in expression statements</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1055"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1055">1055</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Permissible uses of <TT>void</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1056"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1056">1056</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template aliases, member definitions, and the current instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1057"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1057">1057</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>decltype</TT> and the current instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1058"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1058">1058</a></td> <td>NAD</td> <td>Reference binding of incompatible array types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1059"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1059">1059</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Cv-qualified array types (with rvalues)</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1060"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1060">1060</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Scoped enumerators in integral constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1061"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1061">1061</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Negative array bounds in a <I>new-expression</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1062"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1062">1062</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Syntax of <I>attribute-specifier</I>s in lambdas</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1063"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1063">1063</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>[[hiding]]</TT> with non-attribute declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1064"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1064">1064</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defaulted move constructor for a union</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1065"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1065">1065</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>[[hiding]]</TT> with <TT>[[override]]</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1066"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1066">1066</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is a copy/move assignment operator implicitly defined?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1067"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1067">1067</a></td> <td>NAD</td> <td><TT>[[hiding]]</TT>, <I>using-declaration</I>s, and multiple inheritance</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1068"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1068">1068</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template aliases with default arguments and template parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1069"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1069">1069</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect function type with <I>trailing-return-type</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1070"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1070">1070</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing initializer clauses in aggregate initialization</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="1071"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1071">1071</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Literal class types and trivial default constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1072"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1072">1072</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Scoped enumerator with the same name as its containing class</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1073"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1073">1073</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Merging <I>dynamic-exception-specification</I>s and <I>noexcept-specification</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1074"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1074">1074</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Value-dependent <I>noexcept-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1075"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1075">1075</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Grammar does not allow template alias in <I>type-name</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1076"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1076">1076</a></td> <td>open</td> <td>Value categories and lvalue temporaries</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1077"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1077">1077</a></td> <td>extension</td> <td>Explicit specializations in non-containing namespaces</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1078"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1078">1078</a></td> <td>NAD</td> <td>Narrowing and the usual arithmetic conversions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1079"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1079">1079</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overload resolution involving aggregate initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1080"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1080">1080</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Confusing relationship between templates and copy constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1081"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1081">1081</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defaulted destructor and unusable operator delete</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1082"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1082">1082</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Implicit copy function if subobject has none?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1083"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1083">1083</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Passing an object to ellipsis with non-trivial move constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1084"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1084">1084</a></td> <td>NAD</td> <td>Conditions for a deleted move function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1085"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1085">1085</a></td> <td>NAD</td> <td>Move assignment operators and virtual bases</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1086"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1086">1086</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>const_cast</TT> to rvalue reference to function type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1087"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1087">1087</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Additional applications of issue 899</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1088"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1088">1088</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Dependent non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1089"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1089">1089</a></td> <td>drafting</td> <td>Template parameters in member selections</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1090"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1090">1090</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Alignment of subobjects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1091"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1091">1091</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Inconsistent use of the term “object expression”</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1092"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1092">1092</a></td> <td>drafting</td> <td>Cycles in overload resolution during instantiation</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1093"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1093">1093</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value-initializing non-objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1094"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1094">1094</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Converting floating-point values to scoped enumeration types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1095"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1095">1095</a></td> - <td>FDIS</td> + <td>C++11</td> <td>List-initialization of references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1096"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1096">1096</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing requirement for template definitions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1097"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1097">1097</a></td> <td>NAD</td> <td>Aggregate initialization of function parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1098"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1098">1098</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Pointer conversions in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1099"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1099">1099</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Infinite recursion in <TT>constexpr</TT> functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1100"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1100">1100</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> conversion functions and non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1101"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1101">1101</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-integral initialized static data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1102"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1102">1102</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Better example of undefined behavior</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1103"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1103">1103</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Reversion of phase 1 and 2 transformations in raw string literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1104"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1104">1104</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Global-scope template arguments vs the <TT><:</TT> digraph</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1105"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1105">1105</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Issues relating to TR 10176:2003</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1106"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1106">1106</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Need more detail in <TT>nullptr</TT> keyword description</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1107"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1107">1107</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overload resolution for user-defined integer literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1108"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1108">1108</a></td> <td>NAD</td> <td>User-defined literals have not been implemented</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1109"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1109">1109</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is “use” a reference to the ODR meaning?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1110"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1110">1110</a></td> <td>NAD</td> <td>Incomplete return type should be allowed in <TT>decltype</TT> operand</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1111"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1111">1111</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Remove dual-scope lookup of member template names</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1112"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1112">1112</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> variables should have internal linkage like <TT>const</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1113"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1113">1113</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Linkage of namespace member of unnamed namespace</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1114"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1114">1114</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect use of placement <TT>new</TT> in example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1115"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1115">1115</a></td> - <td>FDIS</td> + <td>C++11</td> <td>C-compatible alignment specification</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1116"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1116">1116</a></td> <td>drafting</td> <td>Aliasing of union members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1117"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1117">1117</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect note about xvalue member access expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1118"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1118">1118</a></td> <td>NAD</td> <td>Implicit lambda capture via explicit copy constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1119"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1119">1119</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing case in description of member access ambiguity</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1120"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1120">1120</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>reinterpret_cast</TT> and <TT>void*</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1121"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1121">1121</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Unnecessary ambiguity error in formation of pointer to member</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1122"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1122">1122</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Circular definition of <TT>std::size_t</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1123"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1123">1123</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Destructors should be <TT>noexcept</TT> by default</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1124"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1124">1124</a></td> <td>NAD</td> <td>Error in description of value category of pointer-to-member expression</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1125"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1125">1125</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Unclear definition of “potential constant expression”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1126"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1126">1126</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> functions in <TT>const</TT> initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1127"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1127">1127</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overload resolution in <TT>constexpr</TT> functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1128"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1128">1128</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>attribute-specifier</I>s in <I>decl-specifier-seq</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1129"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1129">1129</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Default <TT>nothrow</TT> for <TT>constexpr</TT> functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1130"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1130">1130</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Function parameter type adjustments and <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1131"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1131">1131</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Template aliases in <I>elaborated-type-specifier</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1132"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1132">1132</a></td> <td>NAD</td> <td>Keyword vs attribute for <TT>noreturn</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1133"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1133">1133</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Keywords vs attributes for control of hiding and overriding</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1134"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1134">1134</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is an explicitly-defaulted function defined?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1135"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1135">1135</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicitly-defaulted non-public special member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1136"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1136">1136</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicitly-defaulted explicit constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1137"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1137">1137</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicitly-defaulted virtual special member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1138"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1138">1138</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Rvalue-ness check for rvalue reference binding is wrong</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1139"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1139">1139</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Rvalue reference binding to scalar xvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1140"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1140">1140</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect redefinition of POD class</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1141"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1141">1141</a></td> <td>NAD</td> <td>Non-static data member initializers have not been implemented</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1142"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1142">1142</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>friend</TT> declaration of member function of containing class</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1143"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1143">1143</a></td> <td>NAD</td> <td>Move semantics for <TT>*this</TT> have not been implemented</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1144"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1144">1144</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Remove access declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1145"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1145">1145</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defaulting and triviality</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1146"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1146">1146</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>exception-specification</I>s of defaulted functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1147"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1147">1147</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Destructors should be default <TT>nothrow</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1148"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1148">1148</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Copy elision and move construction of function parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1149"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1149">1149</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Trivial non-public copy operators in subobjects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1150"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1150">1150</a></td> <td>NAD</td> <td>Inheriting constructors have not been implemented</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1151"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1151">1151</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overload resolution with initializer-list and non-list constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1152"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1152">1152</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Rules for determining existence of implicit conversion sequence</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1153"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1153">1153</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Type matching in address of overloaded function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1154"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1154">1154</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Address of <TT>thread_local</TT> variable as non-type template argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1155"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1155">1155</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Internal-linkage non-type template arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1156"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1156">1156</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Partial ordering in a non-call context</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1157"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1157">1157</a></td> <td>open</td> <td>Partial ordering of function templates is still underspecified</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1158"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1158">1158</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Recursive instantiation via alias template</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1159"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1159">1159</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Class and enumeration definitions in template aliases</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1160"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1160">1160</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Definitions of template members and the current instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1161"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1161">1161</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Dependent <I>nested-name-specifier</I> in a pointer-to-member declarator</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1162"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1162">1162</a></td> <td>NAD</td> <td>Dependent <I>elaborated-type-specifier</I>s in non-deduced contexts</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1163"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1163">1163</a></td> <td>NAD</td> <td><TT>extern template</TT> prevents inlining functions not marked <TT>inline</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1164"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1164">1164</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Partial ordering of <TT>f(T&)</TT> and <TT>f(T&&)</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1165"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1165">1165</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Exceptions when destroying array elements</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1166"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1166">1166</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>exception-declaration</I>s that do not declare objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1167"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1167">1167</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>function-try-block</I>s for destructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1168"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1168">1168</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Additional reasons to call <TT>std::terminate</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1169"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1169">1169</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Missing feature macro for strict pointer safety</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1170"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1170">1170</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Access checking during template argument deduction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1171"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1171">1171</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Partial stack unwinding with <TT>noexcept</TT> violation</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1172"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1172">1172</a></td> <td>drafting</td> <td>“instantiation-dependent” constructs</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1173"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1173">1173</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Unclear specification of effects of signal handling</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1174"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1174">1174</a></td> - <td>FDIS</td> + <td>C++11</td> <td>When is a pure virtual function “used?”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1175"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1175">1175</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Disambiguating user-defined literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1176"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1176">1176</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Definition of release sequence</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1177"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1177">1177</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Intra-thread dependency-ordered-before</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1178"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1178">1178</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Deduction failure matching placement new</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1179"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1179">1179</a></td> <td>NAD</td> <td>Cv-qualification of non-type template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1180"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1180">1180</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Over-aligned class types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1181"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1181">1181</a></td> - <td>FDIS</td> + <td>C++11</td> <td>What is a “built-in type?”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1182"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1182">1182</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Incorrect description of pack expansion syntax</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1183"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1183">1183</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Expansion of parameter packs in declarators</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1184"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1184">1184</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Argument conversions to nondeduced parameter types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1185"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1185">1185</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Misleading description of language linkage and member function types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1186"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1186">1186</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-dependent <TT>constexpr</TT> violations in function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1187"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1187">1187</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Problems in initialization example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1188"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1188">1188</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Type punning in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1189"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1189">1189</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Address of distinct base class subobjects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1190"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1190">1190</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Operations on non-safely-derived pointers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1191"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1191">1191</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Deleted subobject destructors and implicitly-defined constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1192"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1192">1192</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Inadvertent change to ODR and templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1193"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1193">1193</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Use of address-constant pointers in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1194"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1194">1194</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Constexpr references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1195"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1195">1195</a></td> - <td>FDIS</td> + <td>C++11</td> <td>References to non-literal types in constexpr functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1196"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1196">1196</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Definition required for explicit instantiation after explicit specialization?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1197"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1197">1197</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Constexpr arrays</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1198"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1198">1198</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Literal types and copy constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1199"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1199">1199</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Deleted constexpr functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1200"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1200">1200</a></td> <td>open</td> <td>Lookup rules for template parameters</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1201"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1201">1201</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Are deleted and defaulted functions definitions?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1202"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1202">1202</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Calling virtual functions during destruction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1203"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1203">1203</a></td> <td>dup</td> <td>Misleading note regarding initialized static data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1204"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1204">1204</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Specifiers in a <I>for-range-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1205"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1205">1205</a></td> <td>dup</td> <td>Lvalue reference binding and function viability</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1206"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1206">1206</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Defining opaque enumeration members of class templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1207"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1207">1207</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Type of class member in <I>trailing-return-type</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1208"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1208">1208</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Explicit <TT>noexcept</TT> in defaulted definition</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1209"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1209">1209</a></td> <td>open</td> <td>Is a potentially-evaluated expression in a template definition a “use?”</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1210"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1210">1210</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Injection of <I>elaborated-type-specifier</I> in enumeration scope</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1211"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1211">1211</a></td> <td>drafting</td> <td>Misaligned lvalues</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1212"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1212">1212</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-function-call xvalues and <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1213"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1213">1213</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Array subscripting and xvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1214"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1214">1214</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Kinds of initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1215"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1215">1215</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Definition of POD struct</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1216"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1216">1216</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Exceptions “allowed” by a <I>noexcept-specification</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1217"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1217">1217</a></td> <td>NAD</td> <td>Are deleted functions implicitly <TT>noexcept</TT>?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1218"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1218">1218</a></td> - <td>FDIS</td> + <td>C++11</td> <td>What is the “currently-handled exception” in a multi-threaded program?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1219"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1219">1219</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-static data member initializers in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1220"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1220">1220</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Looking up <I>conversion-type-id</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1221"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1221">1221</a></td> <td>open</td> <td>Partial ordering and reference collapsing</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1222"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1222">1222</a></td> <td>NAD</td> <td>Unnecessary restriction on <TT>auto</TT> array types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1223"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1223">1223</a></td> <td>drafting</td> <td>Syntactic disambiguation and <I>trailing-return-type</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1224"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1224">1224</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> defaulted copy constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1225"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1225">1225</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> constructors and virtual bases</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1226"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1226">1226</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Converting a <I>braced-init-list</I> default argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1227"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1227">1227</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Mixing immediate and non-immediate contexts in deduction failure</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1228"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1228">1228</a></td> <td>NAD</td> <td>Copy-list-initialization and <TT>explicit</TT> constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1229"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1229">1229</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overload resolution with empty <I>braced-init-list</I> argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1230"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1230">1230</a></td> <td>open</td> <td>Confusing description of ambiguity of destructor name</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1231"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1231">1231</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Variadic templates requiring an empty pack expansion</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1232"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1232">1232</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Creation of array temporaries using a <I>braced-init-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1233"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1233">1233</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Pack expansions and dependent calls</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1234"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1234">1234</a></td> - <td>FDIS</td> + <td>C++11</td> <td><I>abstract-declarator</I> does not permit <TT>...</TT> after <I>ptr-operator</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1235"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1235">1235</a></td> - <td>FDIS</td> + <td>C++11</td> <td>“Unused” ellipsis and default arguments in partial ordering</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1236"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1236">1236</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Inconsistently-interrelated examples</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1237"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1237">1237</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Deprecated implicit copy assignment in example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1238"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1238">1238</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Overloading ambiguity binding reference to function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1239"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1239">1239</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Hexadecimal floating-point literals vs user-defined literals</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1240"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1240">1240</a></td> - <td>FDIS</td> + <td>C++11</td> <td><TT>constexpr</TT> defaulted constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1241"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1241">1241</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Which members does a destructor destroy?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1242"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1242">1242</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Initializing variant class members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1243"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1243">1243</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Misleading footnote regarding multiple-declarator declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1244"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1244">1244</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Equivalence of alias templates and class templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1245"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1245">1245</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Matching declarations involving <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1246"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1246">1246</a></td> - <td>FDIS</td> + <td>C++11</td> <td>Non-deduced non-final parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1247"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1247">1247</a></td> <td>drafting</td> <td>Restriction on alias name appearing in <I>type-id</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1248"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1248">1248</a></td> <td>open</td> <td>Updating Annex C to C99</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1249"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1249">1249</a></td> <td>drafting</td> <td>Cv-qualification of nested lambda capture</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1250"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1250">1250</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Cv-qualification of incomplete virtual function return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1251"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1251">1251</a></td> - <td>DRWP</td> + <td>CD3</td> <td>C compatibility: casting to unqualified <TT>void*</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1252"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1252">1252</a></td> <td>drafting</td> <td>Overloading member function templates based on dependent return type</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1253"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1253">1253</a></td> <td>drafting</td> <td>Generic non-template members</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1254"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1254">1254</a></td> <td>NAD</td> <td>odr-use vs template arguments and constexpr functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1255"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1255">1255</a></td> <td>drafting</td> <td>Definition problems with <TT>constexpr</TT> functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1256"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1256">1256</a></td> <td>open</td> <td>Unevaluated operands are not necessarily constant expressions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1257"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1257">1257</a></td> <td>open</td> <td>Instantiation via non-dependent references in uninstantiated templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1258"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1258">1258</a></td> <td>drafting</td> <td>“Instantiation context” differs from dependent lookup rules</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1259"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1259">1259</a></td> <td>extension</td> <td>Deleting a POD via a pointer to base</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1260"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1260">1260</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Incorrect use of term “overloaded” in description of odr-use</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1261"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1261">1261</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Explicit handling of cv-qualification with non-class prvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1262"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1262">1262</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Default template arguments and deduction failure</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1263"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1263">1263</a></td> <td>NAD</td> <td>Mismatch between rvalue reference binding and overload resolution</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1264"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1264">1264</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Use of <TT>this</TT> in <TT>constexpr</TT> constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1265"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1265">1265</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Mixed use of the <TT>auto</TT> specifier</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1266"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1266">1266</a></td> <td>open</td> <td><I>user-defined-integer-literal</I> overflow</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1267"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1267">1267</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Rvalue reference types in <I>exception-specification</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1268"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1268">1268</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>reinterpret_cast</TT> of an xvalue operand</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1269"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1269">1269</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>dynamic_cast</TT> of an xvalue operand</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1270"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1270">1270</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Brace elision in array temporary initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1271"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1271">1271</a></td> <td>drafting</td> <td>Imprecise wording regarding dependent types</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1272"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1272">1272</a></td> <td>extension</td> <td>Implicit definition of static data member of const literal type</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1273"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1273">1273</a></td> <td>NAD</td> <td>Accessibility and function signatures</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1274"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1274">1274</a></td> <td>drafting</td> <td>Common nonterminal for <I>expression</I> and <I>braced-init-list</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1275"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1275">1275</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Incorrect comment in example of template parameter pack restriction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1276"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1276">1276</a></td> <td>NAD</td> <td>Reference to <TT>stdint.h</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1277"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1277">1277</a></td> <td>NAD</td> <td>Lax definition of <TT>intmax_t</TT> and <TT>uintmax_t</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1278"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1278">1278</a></td> <td>drafting</td> <td>Incorrect treatment of contrived object</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1279"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1279">1279</a></td> <td>drafting</td> <td>Additional differences between C++ 2003 and C++ 2011</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1280"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1280">1280</a></td> <td>NAD</td> <td>Object reallocation and reference members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1281"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1281">1281</a></td> <td>NAD</td> <td>Virtual and dependent base classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1282"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1282">1282</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Underspecified destructor <I>exception-specification</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1283"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1283">1283</a></td> <td>drafting</td> <td>Static data members of classes with typedef name for linkage purposes</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1284"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1284">1284</a></td> <td>drafting</td> <td>Should the lifetime of an array be independent of that of its elements?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1285"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1285">1285</a></td> <td>open</td> <td>Trivial destructors and object lifetime</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1286"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1286">1286</a></td> <td>drafting</td> <td>Equivalence of alias templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1287"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1287">1287</a></td> - <td>DR</td> + <td>DRWP</td> <td>Direct initialization vs “implicit” conversion in reference binding</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1288"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1288">1288</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Reference list initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1289"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1289">1289</a></td> <td>NAD</td> <td>Can an alias template name the current instantiation?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1290"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1290">1290</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Lifetime of the underlying array of an <TT>initializer_list</TT> member</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1291"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1291">1291</a></td> <td>drafting</td> <td>Looking up a <I>conversion-type-id</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1292"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1292">1292</a></td> - <td>drafting</td> + <td>ready</td> <td>Dependent calls with <I>braced-init-list</I>s containing a pack expansion</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1293"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1293">1293</a></td> - <td>DRWP</td> + <td>CD3</td> <td>String literals in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1294"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1294">1294</a></td> <td>drafting</td> <td>Side effects in dynamic/static initialization</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1295"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1295">1295</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Binding a reference to an rvalue bit-field</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1296"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1296">1296</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Ill-formed template declarations (not just definitions)</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1297"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1297">1297</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Misplaced function <I>attribute-specifier</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1298"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1298">1298</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Incorrect example in overload resolution</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1299"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1299">1299</a></td> - <td>drafting</td> + <td>ready</td> <td>“Temporary objects” vs “temporary expressions”</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1300"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1300">1300</a></td> - <td>extension</td> + <td>dup</td> <td><TT>T()</TT> for array types</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1301"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1301">1301</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value initialization of union</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1302"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1302">1302</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>noexcept</TT> applied to expression of type <TT>void</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1303"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1303">1303</a></td> <td>NAD</td> <td>C language linkage for template with internal linkage</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1304"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1304">1304</a></td> <td>drafting</td> <td>Omitted array bound with string initialization</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1305"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1305">1305</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>alignof</TT> applied to array of unknown size</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1306"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1306">1306</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Modifying an object within a <TT>const</TT> member function</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1307"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1307">1307</a></td> - <td>DR</td> + <td>DRWP</td> <td>Overload resolution based on size of array <I>initializer-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1308"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1308">1308</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Completeness of class type within an <I>exception-specification</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1309"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1309">1309</a></td> <td>drafting</td> <td>Incorrect note regarding lookup of a member of the current instantiation</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1310"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1310">1310</a></td> - <td>DRWP</td> + <td>CD3</td> <td>What is an “acceptable lookup result?”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1311"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1311">1311</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Volatile lvalues in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1312"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1312">1312</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Simulated <TT>reinterpret_cast</TT> in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1313"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1313">1313</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Undefined pointer arithmetic in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1314"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1314">1314</a></td> <td>NAD</td> <td>Pointer arithmetic within standard-layout objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1315"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1315">1315</a></td> <td>drafting</td> <td>Restrictions on non-type template arguments in partial specializations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1316"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1316">1316</a></td> <td>NAD</td> <td><TT>constexpr</TT> function requirements and class scope</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1317"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1317">1317</a></td> <td>NAD</td> <td>Unnamed scoped enumerations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1318"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1318">1318</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Syntactic ambiguities with <TT>final</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1319"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1319">1319</a></td> <td>NAD</td> <td>Error in pack expansion example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1320"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1320">1320</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Converting scoped enumerations to <TT>bool</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1321"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1321">1321</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Equivalency of dependent calls</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1322"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1322">1322</a></td> <td>drafting</td> <td>Function parameter type decay in templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1323"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1323">1323</a></td> <td>NAD</td> <td>Nonexistent nonterminal in <I>alignment-specifier</I> grammar</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1324"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1324">1324</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value initialization and defaulted constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1325">1325</a></td> - <td>drafting</td> + <tr id="1325"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1325">1325</a></td> + <td>NAD</td> <td>Omitted declarator in <TT>friend</TT> declarations</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1326"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1326">1326</a></td> <td>extension</td> <td>Deducing an array bound from an <I>initializer-list</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1327"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1327">1327</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>virt-specifier</I> in a defaulted definition</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1328"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1328">1328</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Conflict in reference binding vs overload resolution</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1329"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1329">1329</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Recursive deduction substitutions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1330"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1330">1330</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Delayed instantiation of <TT>noexcept</TT> specifiers</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1331"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1331">1331</a></td> <td>extension</td> <td><TT>const</TT> mismatch with defaulted copy constructor</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1332"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1332">1332</a></td> <td>drafting</td> <td>Handling of invalid universal-character-names</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1333"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1333">1333</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Omission of <TT>const</TT> in a defaulted copy constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1334"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1334">1334</a></td> <td>NAD</td> <td>Layout compatibility and cv-qualification</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1335"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1335">1335</a></td> <td>drafting</td> <td>Stringizing, extended characters, and universal-character-names</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1336"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1336">1336</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of “converting constructor”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1337"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1337">1337</a></td> <td>dup</td> <td>Partial ordering and non-deduced parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1338"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1338">1338</a></td> - <td>drafting</td> + <td>ready</td> <td>Aliasing and allocation functions</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1339"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1339">1339</a></td> <td>NAD</td> <td>Parenthesized <I>braced-init-list</I> and arrays</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1340"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1340">1340</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Complete type in member pointer expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1341"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1341">1341</a></td> <td>drafting</td> <td>Bit-field initializers</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1342"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1342">1342</a></td> <td>drafting</td> <td>Order of initialization with multiple declarators</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1343"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1343">1343</a></td> <td>drafting</td> <td>Sequencing of non-class initialization</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1344">1344</a></td> - <td>ready</td> + <tr id="1344"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1344">1344</a></td> + <td>DR</td> <td>Adding new special member functions to a class via default arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1345"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1345">1345</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Initialization of anonymous union class members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1346"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1346">1346</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>expression-list</I> initializers and the <TT>auto</TT> specifier</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr> + <tr id="1347"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1347">1347</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Consistency of <TT>auto</TT> in multiple-declarator declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1348"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1348">1348</a></td> <td>drafting</td> <td>Use of <TT>auto</TT> in a <I>trailing-return-type</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1349"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1349">1349</a></td> <td>drafting</td> <td>Consistency of alias template redeclarations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1350"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1350">1350</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Incorrect exception specification for inherited constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1351"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1351">1351</a></td> <td>review</td> <td>Problems with implicitly-declared <I>exception-specification</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1352"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1352">1352</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Inconsistent class scope and completeness rules</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1353"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1353">1353</a></td> <td>drafting</td> <td>Array and variant members and deleted special member functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1354"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1354">1354</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Destructor exceptions for temporaries in noexcept expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1355"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1355">1355</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Aggregates and “user-provided” constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1356"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1356">1356</a></td> <td>review</td> <td>Exception specifications of copy assignment operators with virtual bases</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1357"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1357">1357</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>brace-or-equal-initializer</I>s for function and typedef members</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1358"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1358">1358</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Unintentionally ill-formed <TT>constexpr</TT> function template instances</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1359"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1359">1359</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>constexpr</TT> union constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1360"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1360">1360</a></td> <td>drafting</td> <td><TT>constexpr</TT> defaulted default constructors</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1361"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1361">1361</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Requirement on <I>brace-or-equal-initializer</I>s of literal types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1362"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1362">1362</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Complete type required for implicit conversion to <TT>T&</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1363"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1363">1363</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Triviality vs multiple default constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1364"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1364">1364</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>constexpr</TT> function parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1365"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1365">1365</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Calling undefined <TT>constexpr</TT> functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1366"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1366">1366</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Deleted <TT>constexpr</TT> constructors and virtual base classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1367"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1367">1367</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Use of <TT>this</TT> in a constant expression</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1368"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1368">1368</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value initialization and defaulted constructors (part 2)</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1369"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1369">1369</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Function invocation substitution of <TT>this</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1370"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1370">1370</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>identifier-list</I> cannot contain ellipsis</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1371"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1371">1371</a></td> <td>NAD</td> <td>Deduction from <TT>T&&</TT> in return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1372"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1372">1372</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Cross-references incorrect in conversion function template argument deduction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1373"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1373">1373</a></td> <td>dup</td> <td>Overload resolution changes matching reference-binding changes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1374"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1374">1374</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Qualification conversion vs difference in reference binding</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1375"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1375">1375</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Reference to anonymous union?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1376">1376</a></td> - <td>ready</td> + <tr id="1376"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1376">1376</a></td> + <td>DR</td> <td><TT>static_cast</TT> of temporary to rvalue reference</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1377"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1377">1377</a></td> <td>dup</td> <td>Access declarations not mentioned in Annex C</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1378"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1378">1378</a></td> <td>open</td> <td>When is an instantiation required?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1379"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1379">1379</a></td> <td>NAD</td> <td>Is <TT>std::initializer_list</TT> an aggregate?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1380"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1380">1380</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Type definitions in <I>template-parameter</I> <I>parameter-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1381"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1381">1381</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Implicitly-declared special member functions and default <TT>nothrow</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1382"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1382">1382</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Dead code for constructor names</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1383"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1383">1383</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Clarifying discarded-value expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1384"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1384">1384</a></td> <td>NAD</td> <td><TT>reinterpret_cast</TT> in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1385"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1385">1385</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Syntactic forms of conversion functions for surrogate call functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1386"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1386">1386</a></td> <td>NAD</td> <td>Explicitly-specified partial argument list with multiple parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1387"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1387">1387</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Missing non-deduced context for <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1388"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1388">1388</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Missing non-deduced context following a function parameter pack</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1389"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1389">1389</a></td> <td>NAD</td> <td>Recursive reference in <I>trailing-return-type</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1390"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390">1390</a></td> <td>drafting</td> <td>Dependency of alias template specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1391"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1391">1391</a></td> <td>drafting</td> - <td>Conversions to parameter types with non deduced template arguments</td> + <td>Conversions to parameter types with non-deduced template arguments</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1392"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1392">1392</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Explicit conversion functions for references and non-references</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1393"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1393">1393</a></td> <td>extension</td> <td>Pack expansions in <I>using-declaration</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1394"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1394">1394</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Incomplete types as parameters of deleted functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1395"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1395">1395</a></td> <td>drafting</td> <td>Partial ordering of variadic templates reconsidered</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1396"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1396">1396</a></td> <td>drafting</td> <td>Deferred instantiation and checking of non-static data member initializers</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1397"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1397">1397</a></td> - <td>drafting</td> + <td>ready</td> <td>Class completeness in non-static data member initializers</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1398"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1398">1398</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Non-type template parameters of type <TT>std::nullptr_t</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1399"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1399">1399</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Deduction with multiple function parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1400"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1400">1400</a></td> <td>NAD</td> <td>Function pointer equality</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1401"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1401">1401</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Similar types and reference compatibility</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1402"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1402">1402</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Move functions too often deleted</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1403"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1403">1403</a></td> <td>open</td> <td>Universal-character-names in comments</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1404"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1404">1404</a></td> <td>drafting</td> <td>Object reallocation in unions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1405"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1405">1405</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>constexpr</TT> and mutable members of literal types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1406"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1406">1406</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>ref-qualifier</I>s and added parameters of non-static member function templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1407"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1407">1407</a></td> <td>NAD</td> <td>Integral to <TT>bool</TT> conversion in converted constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1408"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1408">1408</a></td> - <td>DRWP</td> + <td>CD3</td> <td>What is “the same aggregate initialization?”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1409"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1409">1409</a></td> - <td>DRWP</td> + <td>CD3</td> <td>What is the second standard conversion sequence of a list-initialization sequence?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1410"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1410">1410</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Reference overload tiebreakers should apply to rvalue references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1411"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1411">1411</a></td> - <td>DRWP</td> + <td>CD3</td> <td>More on global scope <TT>::</TT> in <I>nested-name-specifier</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1412"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1412">1412</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Problems in specifying pointer conversions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1413"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1413">1413</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Missing cases of value-dependency</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1414"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1414">1414</a></td> <td>drafting</td> <td>Binding an rvalue reference to a reference-unrelated lvalue</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1415"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1415">1415</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Missing prohibition of block-scope definition of <TT>extern</TT> object</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1416"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1416">1416</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Function cv-qualifiers and <TT>typeid</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1417"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1417">1417</a></td> - <td>DR</td> + <td>DRWP</td> <td>Pointers/references to functions with cv-qualifiers or <I>ref-qualifier</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1418"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1418">1418</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Type of <TT>initializer_list</TT> backing array</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1419"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1419">1419</a></td> <td>NAD</td> <td>Evaluation order in aggregate initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1420"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1420">1420</a></td> <td>NAD</td> <td>Abstract final classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1421"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1421">1421</a></td> <td>NAD</td> <td>Full expressions and aggregate initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1422"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1422">1422</a></td> <td>dup</td> <td>Type of character literals containing universal-character-names</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1423"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1423">1423</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Convertibility of <TT>nullptr</TT> to <TT>bool</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1424"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1424">1424</a></td> - <td>DR</td> + <td>DRWP</td> <td>When must sub-object destructors be accessible?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1425"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1425">1425</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Base-class subobjects of standard-layout structs</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1426"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1426">1426</a></td> <td>extension</td> <td>Allowing additional parameter types in defaulted functions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1427"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1427">1427</a></td> <td>NAD</td> <td>Default constructor and deleted or inaccessible destructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1428"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1428">1428</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Dynamic const objects</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1429"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1429">1429</a></td> <td>NAD</td> <td>Scope of a member template's template parameter</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1430"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1430">1430</a></td> <td>drafting</td> <td>Pack expansion into fixed alias template parameter list</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1431"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1431">1431</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Exceptions from other than <I>throw-expression</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1432"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1432">1432</a></td> <td>drafting</td> <td>Newly-ambiguous variadic template expansions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1433"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1433">1433</a></td> <td>extension</td> <td><I>trailing-return-type</I> and point of declaration</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1434"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1434">1434</a></td> <td>NAD</td> <td>Parenthesized <I>braced-init-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1435"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1435">1435</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>template-id</I> as the declarator for a class template constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1436"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1436">1436</a></td> <td>drafting</td> <td>Interaction of constant expression changes with preprocessor expressions</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1437"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1437">1437</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>alignas</TT> in <I>alias-declaration</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1438"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1438">1438</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Non-dereference use of invalid pointers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1439"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1439">1439</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Lookup and friend template declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1440"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1440">1440</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Acceptable <I>decltype-specifier</I>s used as <I>nested-name-specifier</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1441">1441</a></td> - <td>concurrency</td> + <tr id="1441"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1441">1441</a></td> + <td>DR</td> <td>Unclear wording for signal handler restrictions</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1442"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1442">1442</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Argument-dependent lookup in the range-based <TT>for</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1443"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1443">1443</a></td> <td>NAD</td> <td>Default arguments and non-static data members</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1444"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1444">1444</a></td> <td>drafting</td> <td>Type adjustments of non-type template parameters</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1445"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1445">1445</a></td> <td>dup</td> <td>Argument-dependent lookup of <TT>begin</TT> and <TT>end</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1446"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1446">1446</a></td> - <td>drafting</td> + <td>ready</td> <td>Member function with no <I>ref-qualifier</I> and non-member function with rvalue reference</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1447"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1447">1447</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>static_cast</TT> of bit-field lvalue to rvalue reference</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1448"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1448">1448</a></td> <td>NAD</td> <td>Integral values of type <TT>bool</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1449"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1449">1449</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Narrowing conversion of negative value to unsigned type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1450"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1450">1450</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>INT_MIN % -1</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1451"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1451">1451</a></td> <td>extension</td> <td>Objects with no linkage in non-type template arguments</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1452"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1452">1452</a></td> <td>drafting</td> <td>Value-initialized objects may be constants</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1453"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1453">1453</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Volatile members in literal classes?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1454"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1454">1454</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Passing constants through <TT>constexpr</TT> functions via references</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1455"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1455">1455</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Lvalue converted constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1456"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1456">1456</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Address constant expression designating the one-past-the-end address</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1457"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1457">1457</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Undefined behavior in left-shift</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1458"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1458">1458</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Address of incomplete type vs <TT>operator&()</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1459"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1459">1459</a></td> <td>open</td> <td>Reference-binding tiebreakers in overload resolution</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1460"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1460">1460</a></td> - <td>DR</td> + <td>DRWP</td> <td>What is an empty union?</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr class="open"> + <tr id="1461"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1461">1461</a></td> - <td>extension</td> + <td>NAD</td> <td>Narrowing conversions to bit-fields</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1462"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1462">1462</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Deduction failure vs “ill-formed, no diagnostic required”</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1463"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1463">1463</a></td> <td>extension</td> <td><TT>extern "C"</TT> alias templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1464"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1464">1464</a></td> - <td>WP</td> + <td>CD3</td> <td>Negative array bound in a <I>new-expression</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1465"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1465">1465</a></td> <td>review</td> <td><TT>noexcept</TT> and <TT>std::bad_array_new_length</TT></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1466">1466</a></td> - <td>concurrency</td> + <tr id="1466"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1466">1466</a></td> + <td>DR</td> <td>Visible sequences of side effects are redundant</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1467"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1467">1467</a></td> <td>drafting</td> <td>List-initialization of aggregate from same-type object</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1468"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1468">1468</a></td> <td>drafting</td> <td><TT>typeid</TT>, overload resolution, and implicit lambda capture</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1469">1469</a></td> - <td>drafting</td> + <tr class="open" id="1469"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1469">1469</a></td> + <td>extension</td> <td>Omitted bound in array <I>new-expression</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1470"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1470">1470</a></td> <td>NAD</td> <td>Thread migration</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1471"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1471">1471</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Nested type of non-dependent base</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1472"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1472">1472</a></td> - <td>DRWP</td> + <td>CD3</td> <td>odr-use of reference variables</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1473"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1473">1473</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Syntax of <I>literal-operator-id</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1474"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1474">1474</a></td> - <td>extension</td> + <td>NAD</td> <td>User-defined literals and <TT><inttypes.h></TT> format macros</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1475"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1475">1475</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Errors in <TT>[[carries_dependency]]</TT> example</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1476"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1476">1476</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of user-defined type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1477"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1477">1477</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of a <TT>friend</TT> outside its namespace</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1478"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1478">1478</a></td> <td>drafting</td> <td><TT>template</TT> keyword for dependent template template arguments</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1479"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1479">1479</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Literal operators and default arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1480">1480</a></td> - <td>drafting</td> + <tr id="1480"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1480">1480</a></td> + <td>CD3</td> <td>Constant initialization via non-constant temporary</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1481"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1481">1481</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Increment/decrement operators with reference parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1482"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1482">1482</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Point of declaration of enumeration</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1483"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1483">1483</a></td> <td>NAD</td> <td>Non-dependent <I>static_assert-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1484"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1484">1484</a></td> - <td>review</td> + <td>ready</td> <td>Unused local classes of function templates</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1485"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1485">1485</a></td> <td>drafting</td> <td>Out-of-class definition of member unscoped opaque enumeration</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1486"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1486">1486</a></td> <td>drafting</td> <td>Base-derived conversion in member pointer deduction</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1487"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1487">1487</a></td> - <td>DRWP</td> + <td>CD3</td> <td>When are inheriting constructors declared?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1488"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1488">1488</a></td> <td>drafting</td> <td><I>abstract-pack-declarator</I>s in <I>type-id</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1489"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1489">1489</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Is value-initialization of an array constant initialization?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1490"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1490">1490</a></td> <td>drafting</td> <td>List-initialization from a string literal</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1491">1491</a></td> - <td>drafting</td> + <tr id="1491"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1491">1491</a></td> + <td>CD3</td> <td>Move construction and rvalue reference members</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1492"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1492">1492</a></td> - <td>drafting</td> + <td>ready</td> <td>Exception specifications on template destructors</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1493">1493</a></td> - <td>ready</td> + <tr id="1493"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1493">1493</a></td> + <td>DR</td> <td>Criteria for move-construction</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1494"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1494">1494</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Temporary initialization for reference binding in list-initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1495"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1495">1495</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Partial specialization of variadic class template</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1496"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1496">1496</a></td> <td>drafting</td> <td>Triviality with deleted and missing default constructors</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1497"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1497">1497</a></td> <td>NAD</td> <td>Aggregate initialization with parenthesized string literal</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1498"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1498">1498</a></td> <td>dup</td> <td>Lifetime of temporaries in range-based <TT>for</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1499"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1499">1499</a></td> <td>drafting</td> <td>Missing case for deleted move assignment operator</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1500"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1500">1500</a></td> <td>open</td> <td>Name lookup of dependent conversion function</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1501"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1501">1501</a></td> <td>NAD</td> <td>Nested braces in list-initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1502"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1502">1502</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value initialization of unions with member initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1503"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1503">1503</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Exceptions during copy to exception object</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1504"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1504">1504</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Pointer arithmetic after derived-base conversion</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1505"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1505">1505</a></td> <td>dup</td> <td>Direct binding of reference to temporary in list-initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1506"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1506">1506</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value category of <TT>initializer_list</TT> object</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1507"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1507">1507</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Value initialization with trivial inaccessible default constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1508"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1508">1508</a></td> - <td>DR</td> + <td>DRWP</td> <td>Template initializer-list constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1509"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1509">1509</a></td> - <td>DR</td> + <td>DRWP</td> <td>Definition of “non-template function”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1510"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1510">1510</a></td> - <td>DRWP</td> + <td>CD3</td> <td>cv-qualified references via <TT>decltype</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1511"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1511">1511</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>const volatile</TT> variables and the one-definition rule</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1512"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1512">1512</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Pointer comparison vs qualification conversions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1513"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1513">1513</a></td> <td>drafting</td> <td><TT>initializer_list</TT> deduction failure</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1514"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1514">1514</a></td> - <td>DR</td> + <td>DRWP</td> <td>Ambiguity between enumeration definition and zero-length bit-field</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1515"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1515">1515</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Modulo 2<SUP><I>n</I></SUP> arithmetic for implicitly-unsigned types</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1516"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1516">1516</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of “virtual function call”</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1517"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1517">1517</a></td> - <td>review</td> + <td>drafting</td> <td>Unclear/missing description of behavior during construction/destruction</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1518"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1518">1518</a></td> <td>drafting</td> <td>Explicit default constructors and copy-list-initialization</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1519"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1519">1519</a></td> - <td>extension</td> + <td>NAD</td> <td>Conflicting default and variadic constructors</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1520"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1520">1520</a></td> <td>NAD</td> <td>Alias template specialization vs pack expansion</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1521"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1521">1521</a></td> <td>drafting</td> <td><TT>T{</TT><I>expr</I><TT>}</TT> with reference types</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1522"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1522">1522</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Access checking for <TT>initializer_list</TT> array initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1523"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1523">1523</a></td> <td>drafting</td> <td>Point of declaration in range-based <TT>for</TT></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1524"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1524">1524</a></td> <td>drafting</td> <td>Incompletely-defined class template base</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1525"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1525">1525</a></td> <td>NAD</td> <td>Array bound inference in temporary array</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1526"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1526">1526</a></td> <td>dup</td> <td>Dependent-class lookup in the current instantiation</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1527"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1527">1527</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Assignment from <I>braced-init-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1528"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1528">1528</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Repeated <I>cv-qualifier</I>s in declarators</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1529"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1529">1529</a></td> <td>drafting</td> <td>Nomenclature for variable vs reference non-static data member</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1530"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1530">1530</a></td> <td>drafting</td> <td>Member access in out-of-lifetime objects</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1531"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1531">1531</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of “access” (verb)</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1532"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1532">1532</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Explicit instantiation and member templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1533"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1533">1533</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Function pack expansion for member initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1534"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1534">1534</a></td> <td>dup</td> <td>cv-qualification of prvalue of type “array of class”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1535"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1535">1535</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>typeid</TT> in core constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1536"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1536">1536</a></td> <td>drafting</td> <td>Overload resolution with temporary from initializer list</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1537"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1537">1537</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Optional compile-time evaluation of constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1538"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1538">1538</a></td> - <td>DRWP</td> + <td>CD3</td> <td>C-style cast in <I>braced-init-list</I> assignment</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1539"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1539">1539</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Definition of “character type”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1540"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1540">1540</a></td> <td>NAD</td> <td>Use of address constants in constant expressions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1541"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1541">1541</a></td> - <td>DRWP</td> + <td>CD3</td> <td><I>cv</I> <TT>void</TT> return types</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1542"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1542">1542</a></td> <td>drafting</td> <td>Compound assignment of <I>braced-init-list</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1543"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1543">1543</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Implicit conversion sequence for empty initializer list</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1544"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1544">1544</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Linkage of member of unnamed namespace</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1545"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1545">1545</a></td> <td>drafting</td> <td><TT>friend</TT> function templates defined in class templates</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1546"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1546">1546</a></td> <td>NAD</td> <td>Errors in function template default arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1547"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1547">1547</a></td> <td>NAD</td> <td><TT>typename</TT> keyword in <I>alias-declaration</I>s</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1548"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1548">1548</a></td> <td>drafting</td> <td>Copy/move construction and conversion functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1549"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1549">1549</a></td> <td>open</td> <td>Overloaded comma operator with <TT>void</TT> operand</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1550"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1550">1550</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Parenthesized <I>throw-expression</I> operand of <I>conditional-expression</I></td> - <td class="none" align="center">Unknown</td> + <td class="full" align="center">Yes</td> </tr> - <tr> + <tr id="1551"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1551">1551</a></td> - <td>DR</td> + <td>DRWP</td> <td>Wording problems in <I>using-declaration</I> specification</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1552"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1552">1552</a></td> - <td>drafting</td> + <td>ready</td> <td><I>exception-specification</I>s and defaulted special member functions</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1553"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1553">1553</a></td> - <td>DRWP</td> + <td>CD3</td> <td><TT>sizeof</TT> and xvalue bit-fields</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1554"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1554">1554</a></td> <td>drafting</td> <td>Access and alias templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1555"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1555">1555</a></td> <td>extension</td> <td>Language linkage and function type compatibility</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1556"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1556">1556</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Constructors and explicit conversion functions in direct initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1557"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1557">1557</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Language linkage of converted lambda function pointer</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1558"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1558">1558</a></td> - <td>drafting</td> + <td>ready</td> <td>Unused arguments in alias template specializations</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1559"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1559">1559</a></td> - <td>DRWP</td> + <td>CD3</td> <td>String too long in initializer list of <I>new-expression</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1560"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1560">1560</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Gratuitous lvalue-to-rvalue conversion in <I>conditional-expression</I> with <I>throw-expression</I> operand</td> - <td class="none" align="center">Unknown</td> + <td class="svn" align="center">SVN</td> </tr> - <tr class="open"> + <tr class="open" id="1561"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1561">1561</a></td> <td>extension</td> <td>Aggregates with empty base classes</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1562"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1562">1562</a></td> - <td>DR</td> + <td>DRWP</td> <td>Non-static data member initializers and union <I>ctor-initializer</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1563"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1563">1563</a></td> - <td>DRWP</td> + <td>CD3</td> <td>List-initialization and overloaded function disambiguation</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1564"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1564">1564</a></td> <td>extension</td> <td>Template argument deduction from an initializer list</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1565"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1565">1565</a></td> <td>drafting</td> <td>Copy elision and lifetime of <TT>initializer_list</TT> underlying array</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1566"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1566">1566</a></td> <td>NAD</td> <td>Should <TT>new std::initializer_list<T></TT> be ill-formed?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1567"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1567">1567</a></td> - <td>DR</td> + <td>DRWP</td> <td>Inheriting constructors and copy/move constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1568"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1568">1568</a></td> <td>dup</td> <td>Temporary lifetime extension with intervening cast</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1569"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1569">1569</a></td> - <td>DR</td> + <td>DRWP</td> <td>Deducing a function parameter pack before ellipsis</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1570"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1570">1570</a></td> - <td>DR</td> + <td>DRWP</td> <td>Address of subobject as non-type template argument</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1571"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1571">1571</a></td> - <td>drafting</td> + <td>ready</td> <td>cv-qualification for indirect reference binding via conversion function</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1572"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1572">1572</a></td> - <td>drafting</td> + <td>ready</td> <td>Incorrect example for rvalue reference binding via conversion function</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1573"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1573">1573</a></td> - <td>drafting</td> + <td>ready</td> <td>Inherited constructor characteristics</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1574"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1574">1574</a></td> <td>NAD</td> <td>Explicitly-defaulted <TT>constexpr</TT> functions in wrapper templates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1575"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1575">1575</a></td> - <td>DR</td> + <td>DRWP</td> <td>Incorrect definition of “strict pointer safety”</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1576"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1576">1576</a></td> - <td>DR</td> + <td>DRWP</td> <td>Discarded-value volatile xvalues</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1577"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1577">1577</a></td> <td>extension</td> <td>Unnecessary restrictions on partial specializations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1578"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1578">1578</a></td> <td>NAD</td> <td>Value-initialization of aggregates</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1579">1579</a></td> - <td>ready</td> + <tr id="1579"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1579">1579</a></td> + <td>DR</td> <td>Return by converting move constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1580"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1580">1580</a></td> <td>drafting</td> <td>Default arguments in explicit instantiations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1581"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1581">1581</a></td> <td>drafting</td> <td>When are <TT>constexpr</TT> member functions defined?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1582">1582</a></td> - <td>drafting</td> + <tr class="open" id="1582"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1582">1582</a></td> + <td>extension</td> <td>Template default arguments and deduction failure</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1583"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1583">1583</a></td> - <td>DR</td> + <td>DRWP</td> <td>Incorrect example of unspecified behavior</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1584"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584">1584</a></td> - <td>review</td> + <td>ready</td> <td>Deducing function types from cv-qualified types</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1585"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1585">1585</a></td> <td>NAD</td> <td>Value category of member access of rvalue reference member</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1586">1586</a></td> - <td>drafting</td> + <tr class="open" id="1586"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1586">1586</a></td> + <td>extension</td> <td>Naming a destructor via <TT>decltype</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1587"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1587">1587</a></td> - <td>DR</td> + <td>DRWP</td> <td><TT>constexpr</TT> initialization and nested anonymous unions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1588"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1588">1588</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Deducing cv-qualified <TT>auto</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1589"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1589">1589</a></td> <td>drafting</td> <td>Ambiguous ranking of list-initialization sequences</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1590"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1590">1590</a></td> <td>review</td> <td>Bypassing non-copy/move constructor copying</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1591"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1591">1591</a></td> - <td>drafting</td> + <td>ready</td> <td>Deducing array bound and element type from initializer list</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1592"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1592">1592</a></td> - <td>DR</td> + <td>DRWP</td> <td>When do template parameters match?</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1593"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1593">1593</a></td> - <td>DR</td> + <td>DRWP</td> <td>“Parameter type” of special member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1594"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1594">1594</a></td> <td>drafting</td> <td>Lazy declaration of special members vs overload errors</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1595"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1595">1595</a></td> - <td>DR</td> + <td>DRWP</td> <td>Constructors “involved in” subobject initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1596"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1596">1596</a></td> - <td>review</td> + <td>ready</td> <td>Non-array objects as <TT>array[1]</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1597"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1597">1597</a></td> - <td>WP</td> + <td>CD3</td> <td>Misleading <TT>constexpr</TT> example</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1598">1598</a></td> - <td>drafting</td> + <tr id="1598"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1598">1598</a></td> + <td>DR</td> <td>Criterion for equality of pointers to members</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1599"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1599">1599</a></td> <td>open</td> <td>Lifetime of <TT>initializer_list</TT> underlying array</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1600"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1600">1600</a></td> - <td>review</td> + <td>ready</td> <td>Erroneous reference initialization in example</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1601"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1601">1601</a></td> - <td>DR</td> + <td>DRWP</td> <td>Promotion of enumeration with fixed underlying type</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1602"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1602">1602</a></td> <td>open</td> <td>Linkage of specialization vs linkage of template arguments</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1603"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1603">1603</a></td> <td>review</td> <td>Errors resulting from giving unnamed namespaces internal linkage</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1604">1604</a></td> - <td>ready</td> + <tr id="1604"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1604">1604</a></td> + <td>DR</td> <td>Double temporaries in reference initialization</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1605"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1605">1605</a></td> - <td>DRWP</td> + <td>CD3</td> <td>Misleading parenthetical comment for explicit destructor call</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1606"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1606">1606</a></td> <td>NAD</td> <td><TT>sizeof</TT> closure class</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1607">1607</a></td> - <td>ready</td> + <tr id="1607"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1607">1607</a></td> + <td>DR</td> <td>Lambdas in template parameters</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1608"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1608">1608</a></td> - <td>DR</td> + <td>DRWP</td> <td>Operator lookup in trailing return type</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1609"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1609">1609</a></td> <td>open</td> <td>Default arguments and function parameter packs</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1610"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1610">1610</a></td> <td>drafting</td> <td>Cv-qualification in deduction of reference to array</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1611">1611</a></td> - <td>tentatively ready</td> + <tr id="1611"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1611">1611</a></td> + <td>DR</td> <td>Deleted default constructor for abstract class</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1612">1612</a></td> - <td>ready</td> + <tr id="1612"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1612">1612</a></td> + <td>DR</td> <td>Implicit lambda capture and anonymous unions</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1613">1613</a></td> - <td>ready</td> + <tr id="1613"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1613">1613</a></td> + <td>DR</td> <td>Constant expressions and lambda capture</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1614"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1614">1614</a></td> - <td>review</td> + <td>ready</td> <td>Address of pure virtual function vs odr-use</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1615"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1615">1615</a></td> - <td>review</td> + <td>ready</td> <td>Alignment of types, variables, and members</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1616"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1616">1616</a></td> <td>drafting</td> <td>Disambiguation parsing and template parameters</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1617"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1617">1617</a></td> <td>open</td> <td><TT>alignas</TT> and non-defining declarations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1618"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1618">1618</a></td> - <td>DR</td> + <td>DRWP</td> <td>Gratuitously-unsigned underlying enum type</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1619"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1619">1619</a></td> <td>open</td> <td>Definition of current instantiation</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1620"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1620">1620</a></td> <td>open</td> <td>User-defined literals and extended integer types</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1621"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1621">1621</a></td> <td>drafting</td> <td>Member initializers in anonymous unions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1622"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1622">1622</a></td> <td>drafting</td> <td>Empty aggregate initializer for union</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1623"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1623">1623</a></td> <td>drafting</td> <td>Deleted default union constructor and member initializers</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1624"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1624">1624</a></td> <td>NAD</td> <td>Destruction of union members with member initializers</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1625"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1625">1625</a></td> <td>open</td> <td>Adding spaces between tokens in stringizing</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1626"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1626">1626</a></td> <td>drafting</td> <td><TT>constexpr</TT> member functions in <I>brace-or-equal-initializer</I>s</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1627"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1627">1627</a></td> <td>NAD</td> <td>Agreement of dependent <TT>alignas</TT> specifiers</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1628"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1628">1628</a></td> <td>open</td> <td>Deallocation function templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1629">1629</a></td> - <td>drafting</td> + <tr id="1629"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1629">1629</a></td> + <td>DR</td> <td>Can a closure class be a literal type?</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1630"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1630">1630</a></td> <td>drafting</td> <td>Multiple default constructor templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1631"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1631">1631</a></td> <td>drafting</td> <td>Incorrect overload resolution for single-element <I>initializer-list</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1632"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1632">1632</a></td> <td>open</td> <td>Lambda capture in member initializers</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1633"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1633">1633</a></td> <td>review</td> <td>Copy-initialization in member initialization</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1634"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1634">1634</a></td> <td>drafting</td> <td>Temporary storage duration</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1635"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1635">1635</a></td> <td>drafting</td> <td>How similar are template default arguments to function default arguments?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1636"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1636">1636</a></td> <td>drafting</td> <td>Bits required for negative enumerator values</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1637"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1637">1637</a></td> <td>NAD</td> <td>Recursion in <TT>constexpr</TT> template default constructor</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1638"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1638">1638</a></td> <td>drafting</td> <td>Declaring an explicit specialization of a scoped enumeration</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1639"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1639">1639</a></td> <td>review</td> <td><I>exception-specification</I>s and pointer/pointer-to-member expressions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1640"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1640">1640</a></td> <td>drafting</td> <td>Array of abstract instance of class template</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1641"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1641">1641</a></td> <td>NAD</td> <td>Assignment in member initializer</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1642"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1642">1642</a></td> <td>open</td> <td>Missing requirements for prvalue operands</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1643"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1643">1643</a></td> <td>extension</td> <td>Default arguments for template parameter packs</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1644"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1644">1644</a></td> <td>open</td> <td>Equivalent <I>exception-specification</I>s in function template declarations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1645"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1645">1645</a></td> <td>drafting</td> <td>Identical inheriting constructors via default arguments</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1646"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1646">1646</a></td> <td>drafting</td> <td><I>decltype-specifier</I>s, abstract classes, and deduction failure</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1647"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1647">1647</a></td> <td>drafting</td> <td>Type agreement of non-type template arguments in partial specializations</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1648"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1648">1648</a></td> - <td>DR</td> + <td>DRWP</td> <td><TT>thread_local</TT> vs block extern declarations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1649"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1649">1649</a></td> - <td>DR</td> + <td>DRWP</td> <td>Error in the syntax of <I>mem-initializer-list</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1650">1650</a></td> - <td>open</td> + <tr id="1650"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1650">1650</a></td> + <td>NAD</td> <td>Class prvalues in reference initialization</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1651"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1651">1651</a></td> - <td>drafting</td> + <td>ready</td> <td>Lifetime extension of temporary via reference to subobject</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1652"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1652">1652</a></td> <td>drafting</td> <td>Object addresses in <TT>constexpr</TT> expressions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1653"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1653">1653</a></td> <td>drafting</td> <td>Removing deprecated increment of <TT>bool</TT></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1654"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1654">1654</a></td> <td>dup</td> <td>Literal types and <TT>constexpr</TT> defaulted constructors</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1655"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1655">1655</a></td> <td>drafting</td> <td>Line endings in raw string literals</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1656"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1656">1656</a></td> <td>drafting</td> <td>Encoding of numerically-escaped characters</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1657"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1657">1657</a></td> <td>extension</td> <td>Attributes for namespaces and enumerators</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1658">1658</a></td> - <td>drafting</td> + <tr id="1658"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1658">1658</a></td> + <td>DR</td> <td>Deleted default constructor for abstract class via destructor</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1659"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1659">1659</a></td> <td>open</td> <td>Initialization order of thread_local template static data members</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1660">1660</a></td> - <td>open</td> + <tr id="1660"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1660">1660</a></td> + <td>DR</td> <td><I>member-declaration</I> requirements and unnamed bit-fields</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1661"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1661">1661</a></td> <td>concurrency</td> <td>Preservation of infinite loops</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1662">1662</a></td> - <td>ready</td> + <tr id="1662"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1662">1662</a></td> + <td>DR</td> <td>Capturing function parameter packs</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1663"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1663">1663</a></td> <td>NAD</td> <td>Capturing an empty pack expansion</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1664">1664</a></td> - <td>ready</td> + <tr id="1664"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1664">1664</a></td> + <td>DR</td> <td>Argument-dependent lookup of lambdas used in default arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1665"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1665">1665</a></td> <td>drafting</td> <td>Declaration matching in explicit instantiations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1666">1666</a></td> - <td>drafting</td> + <tr id="1666"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1666">1666</a></td> + <td>DR</td> <td>Address constant expressions</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1667"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1667">1667</a></td> <td>NAD</td> <td>Function exiting via exception called by destructor during unwinding</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1668"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1668">1668</a></td> <td>drafting</td> <td>Parameter type determination still not clear enough</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1669">1669</a></td> - <td>drafting</td> + <tr id="1669"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1669">1669</a></td> + <td>accepted</td> <td><TT>auto</TT> return type for <TT>main</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1670"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1670">1670</a></td> - <td>open</td> + <td>drafting</td> <td><TT>auto</TT> as <I>conversion-type-id</I></td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1671"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1671">1671</a></td> <td>NAD</td> <td>Unclear rules for deduction with cv-qualification</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1672"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1672">1672</a></td> <td>drafting</td> <td>Layout compatibility with multiple empty bases</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1673">1673</a></td> - <td>review</td> + <tr id="1673"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1673">1673</a></td> + <td>DR</td> <td>Clarifying overload resolution for the second step of copy-initialization</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1674">1674</a></td> - <td>drafting</td> + <tr id="1674"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1674">1674</a></td> + <td>accepted</td> <td>Return type deduction for address of function</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1675">1675</a></td> - <td>ready</td> + <tr id="1675"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1675">1675</a></td> + <td>NAD</td> <td>Size limit for automatic array object</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1676"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1676">1676</a></td> <td>drafting</td> <td><TT>auto</TT> return type for allocation and deallocation functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1677"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677">1677</a></td> <td>drafting</td> <td>Constant initialization via aggregate initialization</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1678"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1678">1678</a></td> <td>NAD</td> <td>Naming the type of an array of runtime bound</td> <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1679"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1679">1679</a></td> <td>NAD</td> <td>Range-based <TT>for</TT> and array of runtime bound</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1680"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1680">1680</a></td> <td>drafting</td> <td>Including <TT><initializer_list></TT> for range-based <TT>for</TT></td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1681">1681</a></td> - <td>ready</td> + <tr id="1681"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1681">1681</a></td> + <td>accepted</td> <td><I>init-capture</I>s and nested lambdas</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1682"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1682">1682</a></td> <td>open</td> <td>Overly-restrictive rules on function templates as allocation functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1683"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1683">1683</a></td> <td>review</td> <td>Incorrect example after <TT>constexpr</TT> changes</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1684">1684</a></td> - <td>drafting</td> + <tr id="1684"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1684">1684</a></td> + <td>accepted</td> <td>Static <TT>constexpr</TT> member functions for non-literal classes</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1685">1685</a></td> - <td>review</td> + <tr id="1685"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1685">1685</a></td> + <td>NAD</td> <td>Value category of <TT>noexcept</TT> expression</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1686"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1686">1686</a></td> - <td>review</td> + <td>ready</td> <td>Which variables are “explicitly declared <TT>const</TT>?”</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1687">1687</a></td> - <td>drafting</td> + <tr id="1687"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1687">1687</a></td> + <td>DR</td> <td>Conversions of operands of built-in operators</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> + <tr id="1688"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1688">1688</a></td> <td>NAD</td> <td>Volatile <TT>constexpr</TT> variables</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1689">1689</a></td> - <td>drafting</td> + <tr id="1689"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1689">1689</a></td> + <td>DR</td> <td>Syntactic nonterminal for operand of <TT>alignas</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1690">1690</a></td> - <td>ready</td> + <tr id="1690"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1690">1690</a></td> + <td>DR</td> <td>Associated namespace for local type</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1691">1691</a></td> - <td>ready</td> + <tr id="1691"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1691">1691</a></td> + <td>DR</td> <td>Argument-dependent lookup and opaque enumerations</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1692">1692</a></td> - <td>ready</td> + <tr id="1692"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1692">1692</a></td> + <td>DR</td> <td>Associated namespaces of doubly-nested classes</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1693">1693</a></td> - <td>drafting</td> + <tr id="1693"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1693">1693</a></td> + <td>DR</td> <td>Superfluous semicolons in class definitions</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1694"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1694">1694</a></td> - <td>review</td> + <td>ready</td> <td>Restriction on reference to temporary as a constant expression</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1695"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1695">1695</a></td> <td>drafting</td> <td>Lifetime extension via <I>init-capture</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1696"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1696">1696</a></td> - <td>open</td> + <td>drafting</td> <td>Temporary lifetime and non-static data member initializers</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1697"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1697">1697</a></td> <td>drafting</td> <td>Lifetime extension and copy elision</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1698"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1698">1698</a></td> <td>open</td> <td>Files ending in <TT>\</TT></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1699"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1699">1699</a></td> <td>drafting</td> <td>Does befriending a class befriend its friends?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1700"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1700">1700</a></td> <td>NAD</td> <td>Does the special rvalue-reference deduction apply to alias templates?</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1701"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1701">1701</a></td> <td>drafting</td> <td>Array vs sequence in object representation</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1702"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1702">1702</a></td> <td>drafting</td> <td>Rephrasing the definition of “anonymous union”</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1703"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1703">1703</a></td> <td>NAD</td> <td>Language linkage of names of functions with internal linkage</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1704"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1704">1704</a></td> <td>drafting</td> <td>Type checking in explicit instantiation of variable templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1705"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1705">1705</a></td> - <td>review</td> + <td>ready</td> <td>Unclear specification of “more specialized”</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1706"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1706">1706</a></td> - <td>open</td> + <td>drafting</td> <td><TT>alignas</TT> pack expansion syntax</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1707">1707</a></td> - <td>drafting</td> + <tr id="1707"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1707">1707</a></td> + <td>DR</td> <td><TT>template</TT> in <I>elaborated-type-specifier</I> without <I>nested-name-specifier</I></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1708"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1708">1708</a></td> - <td>drafting</td> + <td>review</td> <td>overly-strict requirements for names with C language linkage</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1709"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1709">1709</a></td> <td>drafting</td> <td>Stringizing raw string literals containing newline</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1710"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1710">1710</a></td> - <td>drafting</td> + <td>ready</td> <td>Missing <TT>template</TT> keyword in <I>class-or-decltype</I></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1711"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1711">1711</a></td> - <td>open</td> + <td>drafting</td> <td>Missing specification of variable template partial specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1712"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1712">1712</a></td> - <td>drafting</td> + <td>ready</td> <td><TT>constexpr</TT> variable template declarations</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1713"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1713">1713</a></td> - <td>open</td> + <td>drafting</td> <td>Linkage of variable template specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1714">1714</a></td> - <td>drafting</td> + <tr id="1714"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1714">1714</a></td> + <td>NAD</td> <td>odr-use of <TT>this</TT> from a local class</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1715"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1715">1715</a></td> - <td>drafting</td> + <td>ready</td> <td>Access and inherited constructor templates</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1716">1716</a></td> - <td>drafting</td> + <tr id="1716"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1716">1716</a></td> + <td>DR</td> <td>When are default arguments evaluated?</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1717">1717</a></td> - <td>ready</td> + <tr id="1717"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1717">1717</a></td> + <td>accepted</td> <td>Missing specification of type of binary literal</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1718"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1718">1718</a></td> - <td>open</td> + <td>drafting</td> <td>Macro invocation spanning end-of-file</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1719"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1719">1719</a></td> - <td>open</td> + <td>drafting</td> <td>Layout compatibility and cv-qualification revisited</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1720"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1720">1720</a></td> <td>NAD</td> <td>Macro invocation in <TT>#include</TT> directive</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1721"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1721">1721</a></td> <td>drafting</td> <td>Diagnosing ODR violations for static data members</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1722"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1722">1722</a></td> <td>drafting</td> <td>Should lambda to function pointer conversion function be <TT>noexcept</TT>?</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1723"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1723">1723</a></td> <td>drafting</td> <td>Multicharacter user-defined character literals</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1724"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1724">1724</a></td> <td>drafting</td> <td>Unclear rules for deduction failure</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1725"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1725">1725</a></td> <td>NAD</td> <td>Trailing return type with nested function declarator</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1726"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1726">1726</a></td> <td>drafting</td> <td>Declarator operators and conversion function</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1727"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1727">1727</a></td> <td>NAD</td> <td>Type of a specialization of a variable template</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1728"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1728">1728</a></td> <td>drafting</td> <td>Type of an explicit instantiation of a variable template</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1729"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1729">1729</a></td> <td>drafting</td> <td>Matching declarations and definitions of variable templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1730"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1730">1730</a></td> <td>drafting</td> <td>Can a variable template have an unnamed type?</td> <td align="center">Not resolved</td> </tr> - <tr> + <tr id="1731"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1731">1731</a></td> <td>NAD</td> <td><TT>is_trivially_</TT><I>X</I> and definitions of special member functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1732">1732</a></td> - <td>drafting</td> + <tr id="1732"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1732">1732</a></td> + <td>DR</td> <td>Defining types in <I>condition</I>s and range-based <TT>for</TT> statements</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1733"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1733">1733</a></td> <td>drafting</td> <td>Return type and value for <TT>operator=</TT> with <I>ref-qualifier</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1734"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1734">1734</a></td> <td>drafting</td> <td>Nontrivial deleted copy functions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1735"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1735">1735</a></td> <td>drafting</td> <td>Out-of-range literals in <I>user-defined-literal</I>s</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1736"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1736">1736</a></td> <td>drafting</td> <td>Inheriting constructor templates in a local class</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1737">1737</a></td> - <td>drafting</td> + <tr id="1737"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1737">1737</a></td> + <td>DR</td> <td>Type dependence of call to a member of the current instantiation</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1738">1738</a></td> - <td>drafting</td> + <tr id="1738"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1738">1738</a></td> + <td>DR</td> <td>Explicit instantiation/specialization of inheriting constructor templates</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1739">1739</a></td> - <td>drafting</td> + <tr id="1739"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1739">1739</a></td> + <td>DR</td> <td>Conversion of floating point to enumeration</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1740">1740</a></td> - <td>ready</td> + <tr id="1740"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1740">1740</a></td> + <td>DR</td> <td>Disambiguation of <TT>noexcept</TT></td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1741">1741</a></td> - <td>ready</td> + <tr id="1741"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1741">1741</a></td> + <td>DR</td> <td>odr-use of class object in lvalue-to-rvalue conversion</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1742"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1742">1742</a></td> <td>open</td> <td><I>using-declaration</I>s and scoped enumerators</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1743"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1743">1743</a></td> <td>open</td> <td><I>init-capture</I>s in nested lambdas</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1744"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1744">1744</a></td> - <td>open</td> + <td>review</td> <td>Unordered initialization for variable template specializations</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1745">1745</a></td> - <td>open</td> + <tr id="1745"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1745">1745</a></td> + <td>NAD</td> <td><TT>thread_local constexpr</TT> variable</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1746">1746</a></td> - <td>open</td> + <tr id="1746"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1746">1746</a></td> + <td>DR</td> <td>Are volatile scalar types trivially copyable?</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1747">1747</a></td> - <td>open</td> + <tr id="1747"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1747">1747</a></td> + <td>DR</td> <td>Constant initialization of reference to function</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1748"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1748">1748</a></td> - <td>open</td> + <td>ready</td> <td>Placement new with a null pointer</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1749">1749</a></td> - <td>open</td> + <tr id="1749"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1749">1749</a></td> + <td>NAD</td> <td>Confusing definition for constant initializer</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1750"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1750">1750</a></td> - <td>open</td> + <td>ready</td> <td>“Argument” vs “parameter”</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1751"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1751">1751</a></td> - <td>open</td> + <td>ready</td> <td>Non-trivial operations vs non-trivial initialization</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1752"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1752">1752</a></td> - <td>open</td> + <td>ready</td> <td>Right-recursion in <I>mem-initializer-list</I></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1753"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1753">1753</a></td> - <td>open</td> + <td>ready</td> <td><I>decltype-specifier</I> in <I>nested-name-specifier</I> of destructor</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1754">1754</a></td> - <td>open</td> + <tr class="open" id="1754"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1754">1754</a></td> + <td>extension</td> <td>Declaration of partial specialization of static data member template</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1755"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1755">1755</a></td> - <td>open</td> + <td>drafting</td> <td>Out-of-class partial specializations of member templates</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1756"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1756">1756</a></td> - <td>open</td> + <td>review</td> <td>Direct-list-initialization of a non-class object</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1757"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1757">1757</a></td> - <td>open</td> + <td>ready</td> <td>Const integral subobjects</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1758"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1758">1758</a></td> <td>open</td> <td>Explicit conversion in copy/move list initialization</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1759">1759</a></td> - <td>drafting</td> + <tr id="1759"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1759">1759</a></td> + <td>DR</td> <td>UTF-8 code units in plain <TT>char</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1760">1760</a></td> - <td>ready</td> + <tr id="1760"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1760">1760</a></td> + <td>accepted</td> <td>Access of member corresponding to <I>init-capture</I></td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1761">1761</a></td> - <td>ready</td> + <tr id="1761"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1761">1761</a></td> + <td>NAD</td> <td>Runtime check on size of automatic array</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1762">1762</a></td> - <td>ready</td> + <tr id="1762"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1762">1762</a></td> + <td>DR</td> <td>Reserved identifier used in <I>literal-operator-id</I> example</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1763"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1763">1763</a></td> <td>open</td> <td>Length mismatch in template type deduction</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1764">1764</a></td> - <td>ready</td> + <tr id="1764"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1764">1764</a></td> + <td>DR</td> <td>Hiding of function from using-declaration by signature</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1765">1765</a></td> - <td>ready</td> + <tr id="1765"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1765">1765</a></td> + <td>DR</td> <td>Overflow of enumeration used as enumerator value</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1766"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1766">1766</a></td> - <td>open</td> + <td>ready</td> <td>Values outside the range of the values of an enumeration</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1767">1767</a></td> - <td>ready</td> + <tr id="1767"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1767">1767</a></td> + <td>DR</td> <td>Scoped enumeration in a <TT>switch</TT> statement</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1768">1768</a></td> - <td>ready</td> + <tr id="1768"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1768">1768</a></td> + <td>NAD</td> <td>Zero-element array of runtime bound</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1769">1769</a></td> - <td>review</td> + <tr id="1769"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1769">1769</a></td> + <td>DR</td> <td>Catching a base class of the exception object</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1770">1770</a></td> - <td>ready</td> + <tr id="1770"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1770">1770</a></td> + <td>DR</td> <td>Type matching of non-type template parameters and arguments</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1771"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1771">1771</a></td> <td>open</td> <td>Restricted lookup in <I>nested-name-specifier</I></td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1772">1772</a></td> - <td>ready</td> + <tr id="1772"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1772">1772</a></td> + <td>DR</td> <td><TT>__func__</TT> in a lambda body</td> <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1773">1773</a></td> - <td>ready</td> + <tr id="1773"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1773">1773</a></td> + <td>DR</td> <td>Out-of-lifetime lvalue-to-rvalue conversion</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1774"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1774">1774</a></td> - <td>open</td> + <td>drafting</td> <td>Discrepancy between subobject destruction and stack unwinding</td> <td align="center">Not resolved</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1775">1775</a></td> - <td>ready</td> + <tr id="1775"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1775">1775</a></td> + <td>DR</td> <td>Undefined behavior of line splice in raw string literal</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1776"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1776">1776</a></td> - <td>open</td> + <td>drafting</td> <td>Replacement of class objects containing reference members</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1777"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1777">1777</a></td> - <td>open</td> + <td>ready</td> <td>Empty pack expansion in <I>dynamic-exception-specification</I></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1778">1778</a></td> - <td>ready</td> + <tr id="1778"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1778">1778</a></td> + <td>DR</td> <td><I>exception-specification</I> in explicitly-defaulted functions</td> <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1779"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1779">1779</a></td> - <td>open</td> + <td>ready</td> <td>Type dependency of <TT>__func__</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr id="1780"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1780">1780</a></td> - <td>open</td> + <td>ready</td> <td>Explicit instantiation/specialization of generic lambda <TT>operator()</TT></td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1781"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1781">1781</a></td> <td>open</td> <td>Converting from <TT>nullptr_t</TT> to <TT>bool</TT> in overload resolution</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1782"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1782">1782</a></td> - <td>open</td> + <td>ready</td> <td>Form of initialization for <TT>nullptr_t</TT> to <TT>bool</TT> conversion</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1783">1783</a></td> - <td>open</td> + <tr id="1783"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1783">1783</a></td> + <td>NAD</td> <td>Why are virtual destructors non-trivial?</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1784"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1784">1784</a></td> <td>concurrency</td> <td>Concurrent execution during static local initialization</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1785"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1785">1785</a></td> - <td>open</td> + <td>drafting</td> <td>Conflicting diagnostic requirements for template definitions</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1786">1786</a></td> - <td>drafting</td> + <tr id="1786"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1786">1786</a></td> + <td>DR</td> <td>Effect of merging allocations on memory leakage</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1787">1787</a></td> - <td>drafting</td> + <tr id="1787"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1787">1787</a></td> + <td>DR</td> <td>Uninitialized <TT>unsigned char</TT> values</td> - <td align="center">Not resolved</td> + <td class="none" align="center">Unknown</td> </tr> - <tr class="open"> + <tr class="open" id="1788"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1788">1788</a></td> - <td>open</td> + <td>review</td> <td>Sized deallocation of array of non-class type</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1789"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1789">1789</a></td> - <td>open</td> + <td>drafting</td> <td>Array reference vs array decay in overload resolution</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr class="open" id="1790"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1790">1790</a></td> <td>open</td> <td>Ellipsis following function parameter pack</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> + <tr id="1791"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1791">1791</a></td> - <td>open</td> + <td>ready</td> <td>Incorrect restrictions on <I>cv-qualifier-seq</I> and <I>ref-qualifier</I></td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1792"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1792">1792</a></td> + <td>NAD</td> + <td>Incorrect example of explicit specialization of member enumeration</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1793"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1793">1793</a></td> + <td>ready</td> + <td><TT>thread_local</TT> in explicit specializations</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1794"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1794">1794</a></td> + <td>ready</td> + <td><TT>template</TT> keyword and alias templates</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1795"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1795">1795</a></td> + <td>drafting</td> + <td>Disambiguating <I>original-namespace-definition</I> and <I>extension-namespace-definition</I></td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1792">1792</a></td> + <tr id="1796"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1796">1796</a></td> + <td>ready</td> + <td>Is all-bits-zero for null characters a meaningful requirement?</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1797"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1797">1797</a></td> + <td>ready</td> + <td>Are all bit patterns of <TT>unsigned char</TT> distinct numbers?</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1798"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1798">1798</a></td> + <td>extension</td> + <td><I>exception-specification</I>s of template arguments</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1799"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1799">1799</a></td> + <td>ready</td> + <td><TT>mutable</TT> and non-explicit const qualification</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1800"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1800">1800</a></td> + <td>ready</td> + <td>Pointer to member of nested anonymous union</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1801"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1801">1801</a></td> + <td>drafting</td> + <td>Kind of expression referring to member of anonymous union</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1802"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1802">1802</a></td> + <td>ready</td> + <td><TT>char16_t</TT> string literals and surrogate pairs</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1803"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1803">1803</a></td> + <td>drafting</td> + <td><I>opaque-enum-declaration</I> as <I>member-declaration</I></td> + <td align="center">Not resolved</td> + </tr> + <tr id="1804"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1804">1804</a></td> + <td>ready</td> + <td>Partial specialization and friendship</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1805"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1805">1805</a></td> + <td>ready</td> + <td>Conversions of array operands in <I>conditional-expression</I>s</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1806"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1806">1806</a></td> + <td>review</td> + <td>Virtual bases and move-assignment</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1807"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1807">1807</a></td> + <td>ready</td> + <td>Order of destruction of array elements after an exception</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1808"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1808">1808</a></td> <td>open</td> - <td>Incorrect example of explicit specialization of member enumeration</td> + <td>Constructor templates vs default constructors</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1793">1793</a></td> + <tr id="1809"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1809">1809</a></td> + <td>ready</td> + <td>Narrowing and template argument deduction</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1810"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1810">1810</a></td> + <td>review</td> + <td>Invalid <I>ud-suffix</I>es</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1811"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1811">1811</a></td> + <td>tentatively ready</td> + <td>Lookup of deallocation function in a virtual destructor definition</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1812"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1812">1812</a></td> + <td>ready</td> + <td>Omission of <TT>template</TT> in a <I>typename-specifier</I></td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1813"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1813">1813</a></td> + <td>drafting</td> + <td>Direct vs indirect bases in standard-layout classes</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1814"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1814">1814</a></td> + <td>ready</td> + <td>Default arguments in <I>lambda-expression</I>s</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1815"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1815">1815</a></td> + <td>drafting</td> + <td>Lifetime extension in aggregate initialization</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1816"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1816">1816</a></td> + <td>ready</td> + <td>Unclear specification of bit-field values</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1817"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1817">1817</a></td> + <td>ready</td> + <td>Linkage specifications and nested scopes</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1818"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1818">1818</a></td> <td>open</td> - <td><TT>thread_local</TT> in explicit specializations</td> + <td>Visibility and inherited language linkage</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1794">1794</a></td> + <tr class="open" id="1819"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1819">1819</a></td> + <td>review</td> + <td>Acceptable scopes for definition of partial specialization</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1820"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1820">1820</a></td> <td>open</td> - <td><TT>template</TT> keyword and alias templates</td> + <td>Qualified typedef names</td> <td align="center">Not resolved</td> </tr> - <tr class="open"> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1795">1795</a></td> + <tr class="open" id="1821"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1821">1821</a></td> <td>open</td> - <td>Disambiguating <I>original-namespace-definition</I> and <I>extension-namespace-definition</I></td> + <td>Qualified redeclarations in a class <I>member-specification</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1822"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1822">1822</a></td> + <td>open</td> + <td>Lookup of parameter names in <I>lambda-expression</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1823"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1823">1823</a></td> + <td>review</td> + <td>String literal uniqueness in inline functions</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1824"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1824">1824</a></td> + <td>ready</td> + <td>Completeness of return type vs point of instantiation</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1825"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1825">1825</a></td> + <td>drafting</td> + <td>Partial ordering between variadic and non-variadic function templates</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1826"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1826">1826</a></td> + <td>extension</td> + <td><TT>const</TT> floating-point in constant expressions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1827"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1827">1827</a></td> + <td>drafting</td> + <td>Reference binding with ambiguous conversions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1828"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1828">1828</a></td> + <td>drafting</td> + <td><I>nested-name-specifier</I> ambiguity</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1829"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1829">1829</a></td> + <td>open</td> + <td>Dependent unnamed types</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1830"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1830">1830</a></td> + <td>ready</td> + <td>Repeated specifiers</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1831"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1831">1831</a></td> + <td>NAD</td> + <td>Explicitly vs implicitly deleted move constructors</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1832"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1832">1832</a></td> + <td>ready</td> + <td>Casting to incomplete enumeration</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1833"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1833">1833</a></td> + <td>extension</td> + <td><TT>friend</TT> declarations naming implicitly-declared member functions</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1834"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1834">1834</a></td> + <td>ready</td> + <td>Constant initialization binding a reference to an xvalue</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1835"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1835">1835</a></td> + <td>drafting</td> + <td>Dependent member lookup before <TT><</TT></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1836"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1836">1836</a></td> + <td>drafting</td> + <td>Use of class type being defined in <I>trailing-return-type</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1837"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1837">1837</a></td> + <td>drafting</td> + <td>Use of <TT>this</TT> in <TT>friend</TT> and local class declarations</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1838"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1838">1838</a></td> + <td>drafting</td> + <td>Definition via <I>unqualified-id</I> and <I>using-declaration</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1839"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1839">1839</a></td> + <td>drafting</td> + <td>Lookup of block-scope <TT>extern</TT> declarations</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1840"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1840">1840</a></td> + <td>drafting</td> + <td>Non-deleted explicit specialization of deleted function template</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1841"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1841">1841</a></td> + <td>drafting</td> + <td><TT><</TT> following template injected-class-name</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1842"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1842">1842</a></td> + <td>concurrency</td> + <td>Unevaluated operands and “carries a dependency”</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1843"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1843">1843</a></td> + <td>ready</td> + <td>Bit-field in conditional operator with <TT>throw</TT> operand</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1844"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1844">1844</a></td> + <td>drafting</td> + <td>Defining “immediate context”</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1845"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1845">1845</a></td> + <td>drafting</td> + <td>Point of instantiation of a variable template specialization</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1846"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1846">1846</a></td> + <td>review</td> + <td>Declaring explicitly-defaulted implicitly-deleted functions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1847"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1847">1847</a></td> + <td>drafting</td> + <td>Clarifying compatibility during partial ordering</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1848"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1848">1848</a></td> + <td>open</td> + <td>Parenthesized constructor and destructor declarators</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1849"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1849">1849</a></td> + <td>drafting</td> + <td>Variable templates and the ODR</td> + <td align="center">Not resolved</td> + </tr> + <tr id="1850"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1850">1850</a></td> + <td>ready</td> + <td>Differences between definition context and point of instantiation</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1851"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1851">1851</a></td> + <td>ready</td> + <td><TT>decltype(auto)</TT> in <I>new-expression</I>s</td> + <td class="none" align="center">Unknown</td> + </tr> + <tr id="1852"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1852">1852</a></td> + <td>ready</td> + <td>Wording issues regarding <TT>decltype(auto)</TT></td> + <td class="none" align="center">Unknown</td> + </tr> + <tr class="open" id="1853"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1853">1853</a></td> + <td>drafting</td> + <td>Defining “allocated storage”</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1854"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1854">1854</a></td> + <td>open</td> + <td>Disallowing use of implicitly-deleted functions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1855"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1855">1855</a></td> + <td>open</td> + <td>Out-of-lifetime access to nonstatic data members</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1856"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1856">1856</a></td> + <td>open</td> + <td>Indirect nested classes of class templates</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1857"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1857">1857</a></td> + <td>open</td> + <td>Additional questions about bits</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1858"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1858">1858</a></td> + <td>open</td> + <td>Comparing pointers to union members</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1859"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1859">1859</a></td> + <td>open</td> + <td>UTF-16 in <TT>char16_t</TT> string literals</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1860"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1860">1860</a></td> + <td>open</td> + <td>What is a “direct member?”</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1861"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1861">1861</a></td> + <td>open</td> + <td>Values of a bit-field</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1862"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1862">1862</a></td> + <td>open</td> + <td>Determining “corresponding members” for friendship</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1863"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1863">1863</a></td> + <td>open</td> + <td>Requirements on thrown object type to support <TT>std::current_exception()</TT></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1864"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1864">1864</a></td> + <td>open</td> + <td>List-initialization of array objects</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1865"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1865">1865</a></td> + <td>open</td> + <td>Pointer arithmetic and multi-level qualification conversions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1866"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1866">1866</a></td> + <td>open</td> + <td>Initializing variant members with non-trivial destructors</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1867"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1867">1867</a></td> + <td>open</td> + <td>Function/expression ambiguity with qualified parameter name</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1868"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1868">1868</a></td> + <td>open</td> + <td>Meaning of “placeholder type”</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1869"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1869">1869</a></td> + <td>open</td> + <td><TT>thread_local</TT> vs <I>linkage-specification</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1870"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1870">1870</a></td> + <td>open</td> + <td>Contradictory wording about definitions vs explicit specialization/instantiation</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1871"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1871">1871</a></td> + <td>open</td> + <td>Non-identifier characters in <I>ud-suffix</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1872"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1872">1872</a></td> + <td>open</td> + <td>Instantiations of <TT>constexpr</TT> templates that cannot appear in constant expressions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1873"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1873">1873</a></td> + <td>open</td> + <td>Protected member access from derived class friends</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1874"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1874">1874</a></td> + <td>open</td> + <td>Type vs non-type template parameters with <TT>class</TT> keyword</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1875"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1875">1875</a></td> + <td>open</td> + <td>Reordering declarations in class scope</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1876"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1876">1876</a></td> + <td>open</td> + <td>Preventing explicit specialization</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1877"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1877">1877</a></td> + <td>open</td> + <td>Return type deduction from <TT>return</TT> with no operand</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1878"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1878">1878</a></td> + <td>open</td> + <td><TT>operator auto</TT> template</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1879"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1879">1879</a></td> + <td>open</td> + <td>Inadequate definition of alignment requirement</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1880"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1880">1880</a></td> + <td>open</td> + <td>When are parameter objects destroyed?</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1881"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1881">1881</a></td> + <td>open</td> + <td>Standard-layout classes and unnamed bit-fields</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1882"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1882">1882</a></td> + <td>open</td> + <td>Reserved names without library use</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1883"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1883">1883</a></td> + <td>open</td> + <td>Protected access to constructors in <I>mem-initializer</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1884"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1884">1884</a></td> + <td>open</td> + <td>Unclear requirements for same-named external-linkage entities</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1885"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1885">1885</a></td> + <td>open</td> + <td>Return value of a function is underspecified</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1886"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1886">1886</a></td> + <td>open</td> + <td>Language linkage for <TT>main()</TT></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1887"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1887">1887</a></td> + <td>open</td> + <td>Problems with <TT>::</TT> as <I>nested-name-specifier</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1888"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1888">1888</a></td> + <td>open</td> + <td>Implicitly-declared default constructors and <TT>explicit</TT></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1889"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1889">1889</a></td> + <td>open</td> + <td>Unclear effect of <TT>#pragma</TT> on conformance</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1890"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1890">1890</a></td> + <td>open</td> + <td>Member type depending on definition of member function</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1891"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1891">1891</a></td> + <td>open</td> + <td>Move constructor/assignment for closure class</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1892"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1892">1892</a></td> + <td>open</td> + <td>Use of <TT>auto</TT> in function type</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1893"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1893">1893</a></td> + <td>open</td> + <td>Function-syle cast with <I>braced-init-list</I>s and empty pack expansions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1894"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1894">1894</a></td> + <td>open</td> + <td><I>typedef-name</I>s and <I>using-declaration</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1895"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1895">1895</a></td> + <td>open</td> + <td>Deleted conversions in conditional operator operands</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1896"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1896">1896</a></td> + <td>open</td> + <td>Repeated alias templates</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1897"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1897">1897</a></td> + <td>open</td> + <td>ODR vs alternative tokens</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1898"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1898">1898</a></td> + <td>open</td> + <td>Use of “equivalent” in overload resolution</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1899"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1899">1899</a></td> + <td>open</td> + <td>Value-dependent constant expressions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1900"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1900">1900</a></td> + <td>open</td> + <td>Do <TT>friend</TT> declarations count as “previous declarations”?</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1901"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1901">1901</a></td> + <td>open</td> + <td><I>punctuator</I> referenced but not defined</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1902"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1902">1902</a></td> + <td>open</td> + <td>What makes a conversion “otherwise ill-formed”?</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1903"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1903">1903</a></td> + <td>open</td> + <td>What declarations are introduced by a non-member <I>using-declaration</I>?</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1904"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1904">1904</a></td> + <td>open</td> + <td>Default template arguments for members of class templates</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1905"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1905">1905</a></td> + <td>open</td> + <td>Dependent types and injected-class-names</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1906"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1906">1906</a></td> + <td>open</td> + <td>Name lookup in member <TT>friend</TT> declaration</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1907"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1907">1907</a></td> + <td>open</td> + <td><I>using-declaration</I>s and default arguments</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1908"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1908">1908</a></td> + <td>open</td> + <td>Dual destructor lookup and <I>template-id</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1909"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1909">1909</a></td> + <td>open</td> + <td>Member class template with the same name as the class</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1910"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1910">1910</a></td> + <td>open</td> + <td>“Shall” requirement applied to runtime behavior</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1911"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1911">1911</a></td> + <td>open</td> + <td><TT>constexpr</TT> constructor with non-literal base class</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1912"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1912">1912</a></td> + <td>open</td> + <td><I>exception-specification</I> of defaulted function</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1913"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1913">1913</a></td> + <td>open</td> + <td><TT>decltype((x))</TT> in <I>lambda-expression</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1914"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1914">1914</a></td> + <td>open</td> + <td>Duplicate standard attributes</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1915"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1915">1915</a></td> + <td>open</td> + <td>Potentially-invoked destructors in non-throwing constructors</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1916"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1916">1916</a></td> + <td>open</td> + <td>“Same cv-unqualified type”</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1917"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1917">1917</a></td> + <td>open</td> + <td>decltype-qualified enumeration names</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1918"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1918">1918</a></td> + <td>open</td> + <td><TT>friend</TT> templates with dependent scopes</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1919"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1919">1919</a></td> + <td>open</td> + <td>Overload resolution for <TT>!</TT> with explicit conversion operator</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1920"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1920">1920</a></td> + <td>open</td> + <td>Qualification mismatch in <I>pseudo-destructor-name</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1921"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1921">1921</a></td> + <td>open</td> + <td><TT>constexpr</TT> constructors and point of initialization of <TT>const</TT> variables</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1922"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1922">1922</a></td> + <td>open</td> + <td>Injected class template names and default arguments</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1923"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1923">1923</a></td> + <td>open</td> + <td>Lvalues of type <TT>void</TT></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1924"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1924">1924</a></td> + <td>open</td> + <td>Definition of “literal” and kinds of literals</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1925"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1925">1925</a></td> + <td>open</td> + <td>Bit-field prvalues</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1926"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1926">1926</a></td> + <td>open</td> + <td>Potential results of subscript operator</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1927"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1927">1927</a></td> + <td>open</td> + <td>Lifetime of temporaries in <I>init-capture</I>s</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1928"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1928">1928</a></td> + <td>open</td> + <td>Triviality of deleted special member functions</td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1929"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1929">1929</a></td> + <td>open</td> + <td><TT>template</TT> keyword following namespace <I>nested-name-specifier</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1930"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1930">1930</a></td> + <td>open</td> + <td><I>init-declarator-list</I> vs <I>member-declarator-list</I></td> + <td align="center">Not resolved</td> + </tr> + <tr class="open" id="1931"> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1931">1931</a></td> + <td>open</td> + <td>Default-constructible and copy-assignable closure types</td> <td align="center">Not resolved</td> </tr> </table> diff --git a/www/cxx_status.html b/www/cxx_status.html index d4c8878b6238..9d1d29c7e6b7 100644 --- a/www/cxx_status.html +++ b/www/cxx_status.html @@ -3,7 +3,7 @@ <html> <head> <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> - <title>Clang - C++98, C++11, and C++14 Status</title> + <title>Clang - C++1z, C++14, C++11 and C++98 Status</title> <link type="text/css" rel="stylesheet" href="menu.css"> <link type="text/css" rel="stylesheet" href="content.css"> <style type="text/css"> @@ -23,22 +23,38 @@ <div id="content"> <!--*************************************************************************--> -<h1>C++98, C++11, and C++14 Support in Clang</h1> +<h1>C++ Support in Clang</h1> <!--*************************************************************************--> -<p>Last updated: $Date: 2013-11-28 01:33:42 +0100 (Thu, 28 Nov 2013) $</p> +<p>Last updated: $Date: 2014-06-22 18:00:05 +0200 (Sun, 22 Jun 2014) $</p> + +<p>Clang fully implements all published ISO C++ standards including <a +href="#cxx11">C++11</a>, as well as the upcoming standard provisionally named <a +href="#cxx14">C++14</a>, and some parts of the fledgling <a +href="#cxx17">C++1z</a> standard, +and is considered a production-quality C++ compiler. + +<p>The Clang community is continually striving to improve C++ standards +compliance between releases by submitting and tracking <a +href="cxx_dr_status.html">C++ Defect Reports</a> and implementing resolutions +as they become available.</p> + +<p>Experimental work is also under way to implement <a href="#ts">C++ Technical +Specifications</a> that will help drive the future of the C++ programming +language.</p> + +<p>The <a href="http://llvm.org/bugs/">LLVM bug tracker</a> contains Clang +C++ components that track known bugs with Clang's language conformance in +each language mode.</p> <h2 id="cxx98">C++98 implementation status</h2> -<p>Clang currently implements all of the ISO C++ 1998 standard +<p>Clang implements all of the ISO C++ 1998 standard (including the defects addressed in the ISO C++ 2003 standard) - except for <tt>export</tt> (which has been removed in C++11) - and is considered a production-quality C++ compiler. The <a - href="http://llvm.org/bugs/">LLVM bug tracker</a> contains a Clang - C++ component that tracks known Clang C++ bugs.</p> + except for <tt>export</tt> (which was removed in C++11). <h2 id="cxx11">C++11 implementation status</h2> - <p>Clang implements all of the <a + <p>Clang 3.3 and later implement all of the <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372">ISO C++ 2011 standard</a>. The following table describes the Clang version in which each feature became available.</p> @@ -52,7 +68,7 @@ work with Clang in C++11 mode. Patches are also needed to make <a href="libstdc++4.6-clang11.patch">libstdc++-4.6</a> and <a href="libstdc++4.7-clang11.patch">libstdc++-4.7</a> work with Clang releases prior to version 3.2 in C++11 mode. <tt>thread_local</tt> support -currently requires g++-4.8's C++ runtime library.</p> +currently requires the C++ runtime library from g++-4.8 or later.</p> <table width="689" border="1" cellspacing="0"> <tr> @@ -177,7 +193,7 @@ currently requires g++-4.8's C++ runtime library.</p> <td class="full" align="center">Clang 3.1</td> </tr> <tr> - <td>Generalized attributes</td> + <td>Standardized attribute syntax</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf">N2761</a></td> <td class="full" align="center">Clang 3.3 <a href="#n2761">(1)</a></td> </tr> @@ -191,8 +207,16 @@ currently requires g++-4.8's C++ runtime library.</p> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf">N2341</a></td> <td class="full" align="center">Clang 3.3</td> </tr> - <!-- Skipped N1627: Conditionally-support behavior --> - <!-- Skipped N1727: Changing Undefined Behavior into Diagnosable Errors --> + <tr> + <td>Conditionally-support behavior</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1627.pdf">N1627</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> + <tr> + <td>Changing undefined behavior into diagnosable errors</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1727.pdf">N1727</a></td> + <td class="full" align="center">Clang 2.9</td> + </tr> <tr> <td>Delegating constructors</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf">N1986</a></td> @@ -289,7 +313,7 @@ currently requires g++-4.8's C++ runtime library.</p> <tr> <td>Minimal support for garbage collection and reachability-based leak detection</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm">N2670</a></td> - <td class="na" align="center">N/A</td> + <td class="na" align="center">N/A <a href="#n2670">(2)</a></td> </tr> <tr> <td>Allowing move constructors to throw [noexcept]</td> @@ -318,7 +342,7 @@ currently requires g++-4.8's C++ runtime library.</p> <tr> <td>Strong Compare and Exchange</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2748.html">N2748</a></td> - <td class="full" align="center">Clang 3.1 <a href="#n2748">(2)</a></td> + <td class="full" align="center">Clang 3.1 <a href="#n2748">(3)</a></td> </tr> <tr> <td>Bidirectional Fences</td> @@ -334,7 +358,7 @@ currently requires g++-4.8's C++ runtime library.</p> <tr> <td>Data-dependency ordering: atomics and memory model</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm">N2664</a></td> - <td class="full" align="center">Clang 3.2 <a href="#n2664">(3)</a></td> + <td class="full" align="center">Clang 3.2 <a href="#n2664">(4)</a></td> </tr> <tr> <td>Propagating exceptions</td> @@ -342,11 +366,6 @@ currently requires g++-4.8's C++ runtime library.</p> <td class="full" align="center">Clang 2.9</td> </tr> <tr> - <td>Abandoning a process and at_quick_exit</td> - <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm">N2440</a></td> - <td class="na" align="center">N/A</td> - </tr> - <tr> <td>Allow atomics use in signal handlers</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm">N2547</a></td> <td class="full" align="center">Clang 3.1</td> @@ -383,26 +402,31 @@ currently requires g++-4.8's C++ runtime library.</p> <tr> <td>Extended integral types</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf">N1988</a></td> - <td class="na" align="center">N/A <a href="#n1988">(4)</a></td> + <td class="na" align="center">N/A <a href="#n1988">(5)</a></td> </tr> </table> <p> <span id="n2761">(1): The <code>[[carries_dependency]]</code> attribute has no effect.</span><br> -<span id="n2748">(2): All compare-exchange operations are emitted as +<span id="n2670">(2): No compiler changes are required for an implementation +such as Clang that does not provide garbage collection.</span><br> +<span id="n2748">(3): All compare-exchange operations are emitted as strong compare-exchanges.</span><br> -<span id="n2664">(3): <code>memory_order_consume</code> is lowered to +<span id="n2664">(4): <code>memory_order_consume</code> is lowered to <code>memory_order_acquire</code>.</span><br> -<span id="n1988">(4): <code>__int128</code> is not treated as an extended -integer type, because changing <code>intmax_t</code> would be an -ABI-incompatible change.</span> +<span id="n1988">(5): No compiler changes are required for an implementation +such as Clang that does not provide any extended integer types. +<code>__int128</code> is not treated as an extended integer type, +because changing <code>intmax_t</code> would be an ABI-incompatible +change.</span> </p> <h2 id="cxx14">C++1y implementation status</h2> -<p>Clang implements all of the -<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf">current draft</a> +<p>Clang 3.4 and later implement all of the Draft International Standard (see <a +href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf">most +recent publicly available draft</a>) of the upcoming C++ language standard, provisionally named C++1y. The following table describes the Clang version in which each feature became available.</p> @@ -417,7 +441,7 @@ table describes the Clang version in which each feature became available.</p> <tr> <td>Tweak to certain C++ contextual conversions</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3323.pdf">N3323</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Binary literals</td> @@ -431,27 +455,27 @@ table describes the Clang version in which each feature became available.</p> </tr> <tr> <td>Return type deduction for normal functions</td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Initialized lambda captures</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3648.html">N3648</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Generic lambdas</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3649.html">N3649</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Variable templates</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3651.pdf">N3651</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Relaxing requirements on constexpr functions</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html">N3652</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Member initializers and aggregates</td> @@ -461,35 +485,65 @@ table describes the Clang version in which each feature became available.</p> <tr> <td>Clarifying memory allocation</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3664.html">N3664</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td><tt>[[deprecated]]</tt> attribute</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3760.html">N3760</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>Single quotation mark as digit separator</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3781.pdf">N3781</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> <tr> <td>C++ Sized Deallocation</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3778.html">N3778</a></td> - <td class="svn" align="center">SVN</td> + <td class="full" align="center">Clang 3.4</td> </tr> </table> -<!-- <h2 id="cxx17">C++1z implementation status</h2> -<p>Clang implements none of the upcoming C++ language standard, +<p>Clang has <b>highly experimental</b> support for some proposed features of +the C++ standard following C++1y, provisionally named C++1z. The following table describes which C++1z features have been implemented in Clang and in which Clang version they became available.</p> +<p>Note that support for these features may change or be removed without notice, +as the draft C++1z standard evolves.</p> + <p>You can use Clang in C++1z mode with the <code>-std=c++1z</code> option.</p> ---> + +<table width="689" border="1" cellspacing="0"> + <tr> + <th>Language Feature</th> + <th>C++1z Proposal</th> + <th>Available in Clang?</th> + </tr> + <tr> + <td><tt>static_assert</tt> with no message</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3928.pdf">N3928</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Disabling trigraph expansion by default</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3981.html">N3981</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td>Terse range-based for loops</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3994.htm">N3994</a></td> + <td class="svn" align="center">SVN</td> + </tr> + <tr> + <td><tt>typename</tt> in a template template parameter</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4051.html">N4051</a></td> + <td class="svn" align="center">SVN</td> + </tr> +</table> <h2 id="ts">Technical specifications and standing documents</h2> @@ -507,13 +561,23 @@ Clang version they became available:</p> <tr> <td>SD-6: SG10 feature test recommendations</td> <td><a href="http://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations">SD-6</a></td> - <td class="svn" align="center">SVN (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3745">N3745</a>)</td> + <td class="full" align="center">Clang 3.4 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3745">N3745</a>)</td> </tr> <tr> <td>[DRAFT TS] Array extensions (arrays of runtime bound)</td> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3820.html">N3820</a></td> <td class="none" align="center">No</td> </tr> + <tr> + <td>[DRAFT TS] Library fundamentals (invocation type traits)</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html">N3908</a></td> + <td class="none" align="center">No</td> + </tr> + <tr> + <td>[DRAFT TS] Concepts</td> + <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3929.pdf">N3929</a></td> + <td class="none" align="center">No</td> + </tr> </table> </div> diff --git a/www/diagnostics.html b/www/diagnostics.html index bd9a89d62979..00a3f9a9f689 100644 --- a/www/diagnostics.html +++ b/www/diagnostics.html @@ -7,10 +7,14 @@ <link type="text/css" rel="stylesheet" href="menu.css"> <link type="text/css" rel="stylesheet" href="content.css"> <style type="text/css"> - .warn { color:magenta; } - .err { color:red; } - .snip { color:darkgreen; } - .point { color:blue; } + .loc { font-weight: bold; } + .err { color:red; font-weight: bold; } + .warn { color:magenta; font-weight: bold; } + .note { color:gray; font-weight: bold; } + .msg { font-weight: bold; } + .cmd { font-style: italic; } + .snip { } + .point { color:green; font-weight: bold; } </style> </head> <body> @@ -29,10 +33,7 @@ friendly. As far as a command-line compiler goes, this basically boils down to making the diagnostics (error and warning messages) generated by the compiler be as useful as possible. There are several ways that we do this. This section talks about the experience provided by the command line compiler, contrasting -Clang output to GCC 4.2's output in several examples. -<!-- -Other clients -that embed Clang and extract equivalent information through internal APIs.--> +Clang output to GCC 4.9's output in some cases. </p> <h2>Column Numbers and Caret Diagnostics</h2> @@ -41,25 +42,35 @@ that embed Clang and extract equivalent information through internal APIs.--> information. The clang command-line compiler driver uses this information to print "point diagnostics". (IDEs can use the information to display in-line error markup.) -Precise error location in the source is a feature provided by many commercial -compilers, but is generally missing from open source -compilers. This is nice because it makes it very easy to understand exactly -what is wrong in a particular piece of code</p> +This is nice because it makes it very easy to understand exactly +what is wrong in a particular piece of code.</p> -<p>The point (the blue "^" character) exactly shows where the problem is, even +<p>The point (the green "^" character) exactly shows where the problem is, even inside of a string. This makes it really easy to jump to the problem and -helps when multiple instances of the same character occur on a line. (We'll +helps when multiple instances of the same character occur on a line. (We'll revisit this more in following examples.)</p> <pre> - $ <b>gcc-4.2 -fsyntax-only -Wformat format-strings.c</b> - format-strings.c:91: warning: too few arguments for format - $ <b>clang -fsyntax-only format-strings.c</b> - format-strings.c:91:13: <span class="warn">warning:</span> '.*' specified field precision is missing a matching 'int' argument - <span class="snip"> printf("%.*d");</span> + $ <span class="cmd">gcc-4.9 -fsyntax-only -Wformat format-strings.c</span> + format-strings.c: In function 'void f()': + format-strings.c:91:16: warning: field precision specifier '.*' expects a matching 'int' argument [-Wformat=] + printf("%.*d"); + ^ + format-strings.c:91:16: warning: format '%d' expects a matching 'int' argument [-Wformat=] + $ <span class="cmd">clang -fsyntax-only format-strings.c</span> + <span class="loc">format-strings.c:91:13:</span> <span class="warn">warning:</span> <span class="msg">'.*' specified field precision is missing a matching 'int' argument</span> + <span class="snip" > printf("%.*d");</span> <span class="point"> ^</span> </pre> +<p>Note that modern versions of GCC have followed Clang's lead, and are +now able to give a column for a diagnostic, and include a snippet of source +text in the result. However, Clang's column number is much more accurate, +pointing at the problematic format specifier, rather than the <tt>)</tt> +character the parser had reached when the problem was detected. +Also, Clang's diagnostic is colored by default, making it easier to +distinguish from nearby text.</p> + <h2>Range Highlighting for Related Text</h2> <p>Clang captures and accurately tracks range information for expressions, @@ -74,11 +85,14 @@ Range information is very useful for cases involving precedence issues and many other cases.</p> <pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - t.c:7: error: invalid operands to binary + (have 'int' and 'struct A') - $ <b>clang -fsyntax-only t.c</b> - t.c:7:39: <span class="err">error:</span> invalid operands to binary expression ('int' and 'struct A') - <span class="snip"> return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</span> + $ <span class="cmd">gcc-4.9 -fsyntax-only t.c</span> + t.c: In function 'int f(int, int)': + t.c:7:39: error: invalid operands to binary + (have 'int' and 'struct A') + return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X); + ^ + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:7:39:</span> <span class="err">error:</span> <span class="msg">invalid operands to binary expression ('int' and 'struct A')</span> + <span class="snip" > return y + func(y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);</span> <span class="point"> ~~~~~~~~~~~~~~ ^ ~~~~~</span> </pre> @@ -90,62 +104,24 @@ why. In the example above, we tell you what the inferred types are for the left and right hand sides, and we don't repeat what is obvious from the point (e.g., that this is a "binary +").</p> -<p>Many other examples abound. In the following example, not only do we tell you that there is a problem with the * +<p>Many other examples abound. In the following example, not only do we tell you +that there is a problem with the <tt>*</tt> and point to it, we say exactly why and tell you what the type is (in case it is a complicated subexpression, such as a call to an overloaded function). This sort of attention to detail makes it much easier to understand and fix problems quickly.</p> <pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - t.c:5: error: invalid type argument of 'unary *' - $ <b>clang -fsyntax-only t.c</b> - t.c:5:11: <span class="err">error:</span> indirection requires pointer operand ('int' invalid) - <span class="snip"> int y = *SomeA.X;</span> + $ <span class="cmd">gcc-4.9 -fsyntax-only t.c</span> + t.c:5:11: error: invalid type argument of unary '*' (have 'int') + return *SomeA.X; + ^ + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:5:11:</span> <span class="err">error:</span> <span class="msg">indirection requires pointer operand ('int' invalid)</span> + <span class="snip" > int y = *SomeA.X;</span> <span class="point"> ^~~~~~~~</span> </pre> -<h2>No Pretty Printing of Expressions in Diagnostics</h2> - -<p>Since Clang has range highlighting, it never needs to pretty print your code -back out to you. GCC can produce inscrutible error messages in some cases when -it tries to do this. In this example P and Q have type "int*":</p> - -<pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - #'exact_div_expr' not supported by pp_c_expression#'t.c:12: error: called object is not a function - $ <b>clang -fsyntax-only t.c</b> - t.c:12:8: <span class="err">error:</span> called object type 'int' is not a function or function pointer - <span class="snip"> (P-Q)();</span> - <span class="point"> ~~~~~^</span> -</pre> - -<p>This can be particularly bad in G++, which often emits errors - containing lowered vtable references. For example:</p> - -<pre> - $ <b>cat t.cc</b> - struct a { - virtual int bar(); - }; - - struct foo : public virtual a { - }; - - void test(foo *P) { - return P->bar() + *P; - } - $ <b>gcc-4.2 t.cc</b> - t.cc: In function 'void test(foo*)': - t.cc:9: error: no match for 'operator+' in '(((a*)P) + (*(long int*)(P->foo::<anonymous>.a::_vptr$a + -0x00000000000000020)))->a::bar() + * P' - t.cc:9: error: return-statement with a value, in function returning 'void' - $ <b>clang t.cc</b> - t.cc:9:18: <span class="err">error:</span> invalid operands to binary expression ('int' and 'foo') - <span class="snip"> return P->bar() + *P;</span> - <span class="point"> ~~~~~~~~ ^ ~~</span> -</pre> - - <h2>Typedef Preservation and Selective Unwrapping</h2> <p>Many programmers use high-level user defined types, typedefs, and other @@ -156,15 +132,11 @@ trivial types and it is important to strip off the typedef to understand what is going on. Clang aims to handle both cases well.<p> <p>The following example shows where it is important to preserve -a typedef in C. Here the type printed by GCC isn't even valid, but if the error -were about a very long and complicated type (as often happens in C++) the error -message would be ugly just because it was long and hard to read.</p> +a typedef in C.</p> <pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - t.c:15: error: invalid operands to binary / (have 'float __vector__' and 'const int *') - $ <b>clang -fsyntax-only t.c</b> - t.c:15:11: <span class="err">error:</span> can't convert between vector values of different size ('__m128' and 'int const *') + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:15:11:</span> <span class="err">error:</span> <span class="msg">can't convert between vector values of different size ('__m128' and 'int const *')</span> <span class="snip"> myvec[1]/P;</span> <span class="point"> ~~~~~~~~^~</span> </pre> @@ -174,10 +146,8 @@ underlying details of a typedef. If the user was somehow confused about how the system "pid_t" typedef is defined, Clang helpfully displays it with "aka".</p> <pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - t.c:13: error: request for member 'x' in something not a structure or union - $ <b>clang -fsyntax-only t.c</b> - t.c:13:9: <span class="err">error:</span> member reference base type 'pid_t' (aka 'int') is not a structure or union + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:13:9:</span> <span class="err">error:</span> <span class="msg">member reference base type 'pid_t' (aka 'int') is not a structure or union</span> <span class="snip"> myvar = myvar.x;</span> <span class="point"> ~~~~~ ^</span> </pre> @@ -202,13 +172,11 @@ void addHTTPService(servers::Server const &server, ::services::WebService co </pre> </blockquote> -<p>and then compile it, we see that Clang is both providing more accurate information and is retaining the types as written by the user (e.g., "servers::Server", "::services::WebService"): +<p>and then compile it, we see that Clang is both providing accurate information and is retaining the types as written by the user (e.g., "servers::Server", "::services::WebService"): <pre> - $ <b>g++-4.2 -fsyntax-only t.cpp</b> - t.cpp:9: error: no match for 'operator+=' in 'server += http' - $ <b>clang -fsyntax-only t.cpp</b> - t.cpp:9:10: <span class="err">error:</span> invalid operands to binary expression ('servers::Server const' and '::services::WebService const *') + $ <span class="cmd">clang -fsyntax-only t.cpp</span> + <span class="loc">t.cpp:9:10:</span> <span class="err">error:</span> <span class="msg">invalid operands to binary expression ('servers::Server const' and '::services::WebService const *')</span> <span class="snip">server += http;</span> <span class="point">~~~~~~ ^ ~~~~</span> </pre> @@ -216,10 +184,8 @@ void addHTTPService(servers::Server const &server, ::services::WebService co <p>Naturally, type preservation extends to uses of templates, and Clang retains information about how a particular template specialization (like <code>std::vector<Real></code>) was spelled within the source code. For example:</p> <pre> - $ <b>g++-4.2 -fsyntax-only t.cpp</b> - t.cpp:12: error: no match for 'operator=' in 'str = vec' - $ <b>clang -fsyntax-only t.cpp</b> - t.cpp:12:7: <span class="err">error:</span> incompatible type assigning 'vector<Real>', expected 'std::string' (aka 'class std::basic_string<char>') + $ <span class="cmd">clang -fsyntax-only t.cpp</span> + <span class="loc">t.cpp:12:7:</span> <span class="err">error:</span> <span class="msg">incompatible type assigning 'vector<Real>', expected 'std::string' (aka 'class std::basic_string<char>')</span> <span class="snip">str = vec</span>; <span class="point">^ ~~~</span> </pre> @@ -237,14 +203,14 @@ code should be removed, then replaced with the code below the point line (".x =" or ".y =", respectively).</p> <pre> - $ <b>clang t.c</b> - t.c:5:28: <span class="warn">warning:</span> use of GNU old-style field designator extension + $ <span class="cmd">clang t.c</span> + <span class="loc">t.c:5:28:</span> <span class="warn">warning:</span> <span class="msg">use of GNU old-style field designator extension</span> <span class="snip">struct point origin = { x: 0.0, y: 0.0 };</span> - <span class="err">~~</span> <span class="point">^</span> + <span class="err">~~</span> <span class="msg"><span class="point">^</span></span> <span class="snip">.x = </span> - t.c:5:36: <span class="warn">warning:</span> use of GNU old-style field designator extension + <span class="loc">t.c:5:36:</span> <span class="warn">warning:</span> <span class="msg">use of GNU old-style field designator extension</span> <span class="snip">struct point origin = { x: 0.0, y: 0.0 };</span> - <span class="err">~~</span> <span class="point">^</span> + <span class="err">~~</span> <span class="msg"><span class="point">^</span></span> <span class="snip">.y = </span> </pre> @@ -256,8 +222,8 @@ Clang provides the fix--add <code>template<></code>--as part of the diagnostic.<p> <pre> - $ <b>clang t.cpp</b> - t.cpp:9:3: <span class="err">error:</span> template specialization requires 'template<>' + $ <span class="cmd">clang t.cpp</span> + <span class="loc">t.cpp:9:3:</span> <span class="err">error:</span> <span class="msg">template specialization requires 'template<>'</span> struct iterator_traits<file_iterator> { <span class="point">^</span> <span class="snip">template<> </span> @@ -273,15 +239,15 @@ printed as an indented text tree.</p> Default: template diff with type elision <pre> -t.cc:4:5: <span class="note">note:</span> candidate function not viable: no known conversion from 'vector<map<[...], <span class="template-highlight">float</span>>>' to 'vector<map<[...], <span class="template-highlight">double</span>>>' for 1st argument; +<span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion from 'vector<map<[...], <span class="template-highlight">float</span>>>' to 'vector<map<[...], <span class="template-highlight">double</span>>>' for 1st argument; </pre> -fno-elide-type: template diff without elision <pre> -t.cc:4:5: <span class="note">note:</span> candidate function not viable: no known conversion from 'vector<map<int, <span class="template-highlight">float</span>>>' to 'vector<map<int, <span class="template-highlight">double</span>>>' for 1st argument; +<span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion from 'vector<map<int, <span class="template-highlight">float</span>>>' to 'vector<map<int, <span class="template-highlight">double</span>>>' for 1st argument; </pre> -fdiagnostics-show-template-tree: template tree printing with elision <pre> -t.cc:4:5: <span class="note">note:</span> candidate function not viable: no known conversion for 1st argument; +<span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion for 1st argument; vector< map< [...], @@ -289,7 +255,7 @@ t.cc:4:5: <span class="note">note:</span> candidate function not viable: no know </pre> -fdiagnostics-show-template-tree -fno-elide-type: template tree printing with no elision <pre> -t.cc:4:5: <span class="note">note:M</span> candidate function not viable: no known conversion for 1st argument; +<span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion for 1st argument; vector< map< int, @@ -306,14 +272,11 @@ nested range information for diagnostics as they are instantiated through macros and also shows how some of the other pieces work in a bigger example.</p> <pre> - $ <b>gcc-4.2 -fsyntax-only t.c</b> - t.c: In function 'test': - t.c:80: error: invalid operands to binary < (have 'struct mystruct' and 'float') - $ <b>clang -fsyntax-only t.c</b> - t.c:80:3: <span class="err">error:</span> invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float')) + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:80:3:</span> <span class="err">error:</span> <span class="msg">invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float'))</span> <span class="snip"> X = MYMAX(P, F);</span> <span class="point"> ^~~~~~~~~~~</span> - t.c:76:94: note: expanded from: + <span class="loc">t.c:76:94:</span> <span class="note">note:</span> expanded from: <span class="snip">#define MYMAX(A,B) __extension__ ({ __typeof__(A) __a = (A); __typeof__(B) __b = (B); __a < __b ? __b : __a; })</span> <span class="point"> ~~~ ^ ~~~</span> </pre> @@ -322,14 +285,14 @@ and also shows how some of the other pieces work in a bigger example.</p> implements the "wwopen" class of APIs):</p> <pre> - $ <b>clang -fsyntax-only t.c</b> - t.c:22:2: <span class="warn">warning:</span> type specifier missing, defaults to 'int' + $ <span class="cmd">clang -fsyntax-only t.c</span> + <span class="loc">t.c:22:2:</span> <span class="warn">warning:</span> <span class="msg">type specifier missing, defaults to 'int'</span> <span class="snip"> ILPAD();</span> <span class="point"> ^</span> - t.c:17:17: note: expanded from: + <span class="loc">t.c:17:17:</span> <span class="note">note:</span> expanded from: <span class="snip">#define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */</span> <span class="point"> ^</span> - t.c:14:2: note: expanded from: + <span class="loc">t.c:14:2:</span> <span class="note">note:</span> expanded from: <span class="snip"> register i; \</span> <span class="point"> ^</span> </pre> @@ -342,62 +305,64 @@ macros that in simple ones.</p> <p>Finally, we have put a lot of work polishing the little things, because little things add up over time and contribute to a great user experience.</p> -<p>The following example shows a trivial little tweak, where we tell you to put the semicolon at -the end of the line that is missing it (line 4) instead of at the beginning of -the following line (line 5). This is particularly important with fixit hints -and point diagnostics, because otherwise you don't get the important context. -</p> +<p>The following example shows that we recover from the simple case of +forgetting a ; after a struct definition much better than GCC.</p> <pre> - $ <b>gcc-4.2 t.c</b> - t.c: In function 'foo': - t.c:5: error: expected ';' before '}' token - $ <b>clang t.c</b> - t.c:4:8: <span class="err">error:</span> expected ';' after expression - <span class="snip"> bar()</span> - <span class="point"> ^</span> - <span class="point"> ;</span> + $ <span class="cmd">cat t.cc</span> + template<class T> + class a {}; + struct b {} + a<int> c; + $ <span class="cmd">gcc-4.9 t.cc</span> + t.cc:4:8: error: invalid declarator before 'c' + a<int> c; + ^ + $ <span class="cmd">clang t.cc</span> + <span class="loc">t.cc:3:12:</span> <span class="err">error:</span> <span class="msg">expected ';' after struct</span> + <span class="snip" >struct b {}</span> + <span class="point"> ^</span> + <span class="point"> ;</span> </pre> -<p>The following example shows much better error recovery than GCC. The message coming out -of GCC is completely useless for diagnosing the problem. Clang tries much harder -and produces a much more useful diagnosis of the problem.</p> +<p>The following example shows that we diagnose and recover from a missing +<tt>typename</tt> keyword well, even in complex circumstances where GCC +cannot cope.</p> <pre> - $ <b>gcc-4.2 t.c</b> - t.c:3: error: expected '=', ',', ';', 'asm' or '__attribute__' before '*' token - $ <b>clang t.c</b> - t.c:3:1: <span class="err">error:</span> unknown type name 'foo_t' - <span class="snip">foo_t *P = 0;</span> - <span class="point">^</span> + $ <span class="cmd">cat t.cc</span> + template<class T> void f(T::type) { } + struct A { }; + void g() + { + A a; + f<A>(a); + } + $ <span class="cmd">gcc-4.9 t.cc</span> + t.cc:1:33: error: variable or field 'f' declared void + template<class T> void f(T::type) { } + ^ + t.cc: In function 'void g()': + t.cc:6:5: error: 'f' was not declared in this scope + f<A>(a); + ^ + t.cc:6:8: error: expected primary-expression before '>' token + f<A>(a); + ^ + $ <span class="cmd">clang t.cc</span> + <span class="loc">t.cc:1:26:</span> <span class="err">error:</span> <span class="msg">missing 'typename' prior to dependent type name 'T::type'</span> + <span class="snip" >template<class T> void f(T::type) { }</span> + <span class="point"> ^~~~~~~</span> + <span class="point"> typename </span> + <span class="loc">t.cc:6:5:</span> <span class="err">error:</span> <span class="msg">no matching function for call to 'f'</span> + <span class="snip" > f<A>(a);</span> + <span class="point"> ^~~~</span> + <span class="loc">t.cc:1:24:</span> <span class="note">note:</span> <span class="msg">candidate template ignored: substitution failure [with T = A]: no type named 'type' in 'A'</span> + <span class="snip" >template<class T> void f(T::type) { }</span> + <span class="point"> ^ ~~~~</span> </pre> -<p>The following example shows that we recover from the simple case of -forgetting a ; after a struct definition much better than GCC.</p> -<pre> - $ <b>cat t.cc</b> - template<class T> - class a {} - class temp {}; - a<temp> b; - struct b { - } - $ <b>gcc-4.2 t.cc</b> - t.cc:3: error: multiple types in one declaration - t.cc:4: error: non-template type 'a' used as a template - t.cc:4: error: invalid type in declaration before ';' token - t.cc:6: error: expected unqualified-id at end of input - $ <b>clang t.cc</b> - t.cc:2:11: <span class="err">error:</span> expected ';' after class - <span class="snip">class a {}</span> - <span class="point"> ^</span> - <span class="point"> ;</span> - t.cc:6:2: <span class="err">error:</span> expected ';' after struct - <span class="snip">}</span> - <span class="point"> ^</span> - <span class="point"> ;</span> -</pre> <p>While each of these details is minor, we feel that they all add up to provide a much more polished experience.</p> diff --git a/www/features.html b/www/features.html index 2d3191e685c4..8a1c856cd1c0 100644 --- a/www/features.html +++ b/www/features.html @@ -65,71 +65,18 @@ These features are: <p>A major focus of our work on clang is to make it fast, light and scalable. The library-based architecture of clang makes it straight-forward to time and profile the cost of each layer of the stack, and the driver has a number of -options for performance analysis.</p> - -<p>While there is still much that can be done, we find that the clang front-end -is significantly quicker than gcc and uses less memory For example, when -compiling "Carbon.h" on Mac OS/X, we see that clang is 2.5x faster than GCC:</p> - -<img class="img_slide" src="feature-compile1.png" width="400" height="300" - alt="Time to parse carbon.h: -fsyntax-only"> - -<p>Carbon.h is a monster: it transitively includes 558 files, 12.3M of code, -declares 10000 functions, has 2000 struct definitions, 8000 fields, 20000 enum -constants, etc (see slide 25+ of the <a href="clang_video-07-25-2007.html">clang -talk</a> for more information). It is also #include'd into almost every C file -in a GUI app on the Mac, so its compile time is very important.</p> - -<p>From the slide above, you can see that we can measure the time to preprocess -the file independently from the time to parse it, and independently from the -time to build the ASTs for the code. GCC doesn't provide a way to measure the -parser without AST building (it only provides -fsyntax-only). In our -measurements, we find that clang's preprocessor is consistently 40% faster than -GCCs, and the parser + AST builder is ~4x faster than GCC's. If you have -sources that do not depend as heavily on the preprocessor (or if you -use Precompiled Headers) you may see a much bigger speedup from clang. -</p> +options for performance analysis. Many detailed benchmarks can be found online.</p> <p>Compile time performance is important, but when using clang as an API, often memory use is even moreso: the less memory the code takes the more code you can fit into memory at a time (useful for whole program analysis tools, for example).</p> -<img class="img_slide" src="feature-memory1.png" width="400" height="300" - alt="Space"> - -<p>Here we see a huge advantage of clang: its ASTs take <b>5x less memory</b> -than GCC's syntax trees, despite the fact that clang's ASTs capture far more -source-level information than GCC's trees do. This feat is accomplished through -the use of carefully designed APIs and efficient representations.</p> - <p>In addition to being efficient when pitted head-to-head against GCC in batch -mode, clang is built with a <a href="#libraryarch">library based +mode, clang is built with a <a href="#libraryarch">library based architecture</a> that makes it relatively easy to adapt it and build new tools with it. This means that it is often possible to apply out-of-the-box thinking -and novel techniques to improve compilation in various ways.</p> - -<img class="img_slide" src="feature-compile2.png" width="400" height="300" - alt="Preprocessor Speeds: GCC 4.2 vs clang-all"> - -<p>This slide shows how the clang preprocessor can be used to make "distcc" -parallelization <b>3x</b> more scalable than when using the GCC preprocessor. -"distcc" quickly bottlenecks on the preprocessor running on the central driver -machine, so a fast preprocessor is very useful. Comparing the first two bars -of each group shows how a ~40% faster preprocessor can reduce preprocessing time -of these large C++ apps by about 40% (shocking!).</p> - -<p>The third bar on the slide is the interesting part: it shows how trivial -caching of file system accesses across invocations of the preprocessor allows -clang to reduce time spent in the kernel by 10x, making distcc over 3x more -scalable. This is obviously just one simple hack, doing more interesting things -(like caching tokens across preprocessed files) would yield another substantial -speedup.</p> - -<p>The clean framework-based design of clang means that many things are possible -that would be very difficult in other systems, for example incremental -compilation, multithreading, intelligent caching, etc. We are only starting -to tap the full potential of the clang design.</p> +and novel techniques to improve compilation in various ways.</p> <!--=======================================================================--> @@ -157,7 +104,7 @@ GCC and Clang diagnostic:</p> </pre> <p>Here you can see that you don't even need to see the original source code to -understand what is wrong based on the Clang error: Because clang prints a +understand what is wrong based on the Clang error: Because Clang prints a caret, you know exactly <em>which</em> plus it is complaining about. The range information highlights the left and right side of the plus which makes it immediately obvious what the compiler is talking about, which is very useful for diff --git a/www/get_involved.html b/www/get_involved.html index 9ed2d470c1bd..06fee594200a 100644 --- a/www/get_involved.html +++ b/www/get_involved.html @@ -21,6 +21,11 @@ and contribute to its development. Alternatively, maybe you just want to follow the development of the project to see it progress. </p> +<h2>Contribute</h2> + +See the <a href="hacking.html">hacking</a> document for information on how +to author patches. + <h2>Follow what's going on</h2> <p>Clang is a subproject of the <a href="http://llvm.org">LLVM Project</a>, but @@ -54,7 +59,13 @@ href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits mailing list</a>. All of these lists have archives, so you can browse through previous discussions or follow the list development on the web if you prefer.</p> -<p>If you're looking for something to work on, check out our <a href="OpenProjects.html">Open Projects</a> page or go look through the <a href="http://llvm.org/bugs/">Bugzilla bug database</a>.</p> +<p>You can also follow the <a href="http://planet.clang.org/">Planet Clang</a> +community news feed which offers a window into the world, work and lives of +Clang developers, contributors and the standards they implement.</p> + +<p>If you're looking for something to work on, check out our <a +href="OpenProjects.html">Open Projects</a> page or look through the <a +href="http://llvm.org/bugs/">Bugzilla bug database</a>.</p> <h2 id="criteria">Contributing Extensions to Clang</h2> diff --git a/www/get_started.html b/www/get_started.html index 512833143b33..6f08f5e6f0fc 100644 --- a/www/get_started.html +++ b/www/get_started.html @@ -23,9 +23,8 @@ bugs in <a href="http://llvm.org/bugs/">LLVM Bugzilla</a>.</p> <h2 id="download">Release Clang Versions</h2> -<p>Clang has been released as part of regular LLVM releases since LLVM 2.6. You -can download the release versions -from <a href="http://llvm.org/releases/">http://llvm.org/releases/</a>.</p> +<p>Clang is released as part of regular LLVM releases. You can download the release versions from <a href="http://llvm.org/releases/">http://llvm.org/releases/</a>.</p> +<p>Clang is also provided in all major BSD or GNU/Linux distributions as part of their respective packaging systems. From Xcode 4.2, Clang is the default compiler for Mac OS X.</p> <h2 id="build">Building Clang and Working with the Code</h2> @@ -142,7 +141,7 @@ Visual Studio:</p> project files. Get it from: <a href="http://www.cmake.org/cmake/resources/software.html"> http://www.cmake.org/cmake/resources/software.html</a></li> - <li><b>Visual Studio 2008 or 2010</b></li> + <li><b>Visual Studio 2012 or later</b></li> <li><b>Python</b>. This is needed only if you will be running the tests (which is essential, if you will be developing for clang). Get it from: @@ -174,8 +173,7 @@ Visual Studio:</p> <li><tt>cd ..\..</tt> (back to where you started)</li> <li><tt>mkdir build</tt> (for building without polluting the source dir)</li> <li><tt>cd build</tt></li> - <li>If you are using Visual Studio 2008: <tt>cmake -G "Visual Studio 9 2008" ..\llvm</tt></li> - <li>Or if you are using Visual Studio 2010: <tt>cmake -G "Visual Studio 10" ..\llvm</tt></li> + <li>If you are using Visual Studio 2012: <tt>cmake -G "Visual Studio 11" ..\llvm</tt></li> <li>See the <a href="http://www.llvm.org/docs/CMake.html">LLVM CMake guide</a> for more information on other configuration options for CMake.</li> <li>The above, if successful, will have created an LLVM.sln file in the diff --git a/www/hacking.html b/www/hacking.html index a1ff8d4efd43..4535ef4a137e 100644 --- a/www/hacking.html +++ b/www/hacking.html @@ -97,31 +97,20 @@ <h3 id="debuggingVisualStudio">Debugging using Visual Studio</h3> <!--=====================================================================--> - <p>The file <tt>utils/clangVisualizers.txt</tt> provides debugger visualizers that make debugging - of more complex data types much easier.</p> - <p>There are two ways to install them:</p> - - <ul> - <li>Put the path to <tt>clangVisualizers.txt</tt> in the environment variable called - <tt>_vcee_autoexp</tt>. This method should work for Visual Studio 2008 and above. - </li> - <li>Edit your local <tt>autoexp.dat</tt> (make sure you make a backup first!), - located in <tt>Visual Studio Directory\Common7\Packages\Debugger</tt> and append - the contents of <tt>clangVisuailzers.txt</tt> to it. This method should work for - Visual Studio 2008 and above. - </li> - </ul> - - <p><i>[Note: To disable the visualizer for any specific variable, type - <tt>variable_name,!</tt> inside the watch window.]</i></p> + <p>The files + <a href="http://llvm.org/svn/llvm-project/llvm/trunk/utils/llvm.natvis"> + <tt>utils/llvm.natvis</tt></a> and + <a href="http://llvm.org/svn/llvm-project/cfe/trunk/utils/clang.natvis"> + <tt>utils/clang.natvis</tt></a> provide debugger visualizers + that make debugging of more complex data types much easier.</p> + <p>Put the files into + <tt>%USERPROFILE%\Documents\Visual Studio 2012\Visualizers</tt> or + create a symbolic link so they update automatically.</p> <!--=====================================================================--> <h2 id="testing">Testing</h2> <!--=====================================================================--> - <p><i>[Note: The test running mechanism is currently under revision, so the - following might change shortly.]</i></p> - <!--=====================================================================--> <h3 id="testingNonWindows">Testing on Unix-like Systems</h3> <!--=====================================================================--> @@ -287,9 +276,10 @@ Testing Time: 81.52s <p>To return changes to the Clang team, unless you have checkin privileges, the preferred way is to send patch files to the cfe-commits mailing list, with an explanation of what the patch is - for. If your patch requires a wider discussion (for example, - because it is an architectural change), you can use the cfe-dev - mailing list. </p> + for. clang follows <a + href="http://llvm.org/docs/DeveloperPolicy.html">LLVM's developer policy</a>. + If your patch requires a wider discussion (for example, because it is an + architectural change), you can use the cfe-dev mailing list.</p> <p>To create these patch files, change directory to the llvm/tools/clang root and run:</p> diff --git a/www/index.html b/www/index.html index 23d82e3ce078..2d3ca8f5aacb 100644 --- a/www/index.html +++ b/www/index.html @@ -40,7 +40,7 @@ <ul> <li>Modular library based architecture</li> <li>Support diverse clients (refactoring, static analysis, code generation, - etc)</li> + etc.)</li> <li>Allow tight integration with IDEs</li> <li>Use the LLVM 'BSD' License</li> </ul> @@ -65,7 +65,7 @@ <h2>Why?</h2> <!--=====================================================================--> - <p>The development of a new front-end was started out of a need -- a need + <p>Development of the new front-end was started out of a need for a compiler that allows better diagnostics, better integration with IDEs, a license that is compatible with commercial products, and a nimble compiler that is easy to develop and maintain. All of these were @@ -89,7 +89,7 @@ <h2>Current Status</h2> <!--=====================================================================--> - <p>Clang is still under heavy development. Clang is considered to + <p>Clang is considered to be a production quality C, Objective-C, C++ and Objective-C++ compiler when targeting X86-32, X86-64, and ARM (other targets may have caveats, but are usually easy to fix). If you are looking for source analysis or diff --git a/www/make_cxx_dr_status b/www/make_cxx_dr_status index 4750e1b2cbb0..82e8abd31733 100755 --- a/www/make_cxx_dr_status +++ b/www/make_cxx_dr_status @@ -51,6 +51,7 @@ out_file = file(output, 'w') print >> out_file, '''\ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<!-- This file is auto-generated by make_cxx_dr_status. Do not modify. --> <html> <head> <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> @@ -65,7 +66,7 @@ print >> out_file, '''\ .na { background-color: #DDDDDD } .open * { color: #AAAAAA } //.open { filter: opacity(0.2) } - span:target { background-color: #FFFFBB; outline: #DDDD55 solid thin; } + tr:target { background-color: #FFFFBB } th { background-color: #FFDDAA } </style> </head> @@ -101,10 +102,10 @@ def availability(issue): if status == 'unknown': avail = 'Unknown' avail_style = ' class="none"' - elif status == '3.4': + elif status == '3.5': avail = 'SVN' avail_style = ' class="svn"' - elif status in ('3.1', '3.2', '3.3'): + elif status in ('3.1', '3.2', '3.3', '3.4'): avail = 'Clang %s' % status avail_style = ' class="full"' elif status == 'yes': @@ -121,7 +122,7 @@ def availability(issue): avail_style = ' class="na"' elif status.startswith('sup '): dup = status.split(' ', 1)[1] - avail = 'Superseded by %s' % dup + avail = 'Superseded by <a href="#%s">%s</a>' % (dup, dup) try: _, avail_style = availability(int(dup)) except: @@ -129,7 +130,7 @@ def availability(issue): avail_style = ' class="none"' elif status.startswith('dup '): dup = int(status.split(' ', 1)[1]) - avail = 'Duplicate of %s' % dup + avail = 'Duplicate of <a href="#%s">%s</a>' % (dup, dup) _, avail_style = availability(dup) else: assert False, 'unknown status %s for issue %s' % (status, dr.issue) @@ -153,13 +154,12 @@ for dr in drs: count[avail] = count.get(avail, 0) + 1 print >> out_file, '''\ - <tr%s> + <tr%s id="%s"> <td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/%s">%s</a></td> <td>%s</td> <td>%s</td> <td%s align="center">%s</td> - </tr>''' % (row_style, dr.url, dr.issue, dr.status, dr.title, avail_style, - avail) + </tr>''' % (row_style, dr.issue, dr.url, dr.issue, dr.status, dr.title, avail_style, avail) for status, num in count.items(): print "%s: %s" % (status, num) diff --git a/www/menu.html.incl b/www/menu.html.incl index 438299146856..b8689d1fb4ae 100644 --- a/www/menu.html.incl +++ b/www/menu.html.incl @@ -35,8 +35,9 @@ <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-users">cfe-users List</a> <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-dev">cfe-dev List</a> <a href="http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits">cfe-commits List</a> - <a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a> <a href="http://llvm.org/bugs/">Bug Reports</a> + <a href="http://planet.clang.org/">Planet Clang</a> + <a href="irc://irc.oftc.net/llvm">IRC: irc.oftc.net#llvm</a> </div> <div class="submenu"> diff --git a/www/related.html b/www/related.html index 8191daabb17d..62dd2632cd54 100644 --- a/www/related.html +++ b/www/related.html @@ -19,7 +19,7 @@ custom analysis tools using Clang. This page tracks some of those Clang related projects.</p> - <p>Please email cfe-dev if you have a Clang related project you would like + <p>Please email <a href="get_involved.html">cfe-dev</a> if you have a Clang related project you would like added to this list.</p> <dl> |
