C++ FCD Comment Status

atomic< atomic<int> * > p
f()                    |
{ atomic<int>x;        | W_na x
  p.store(&x,mo_rlx);  | W_rlx p=&x
}                      |

mod       mod
rel1----->rel2----->w

a:Wrlx x=1   b:Wrlx x=2
      \     /
     sb\   /sb
        \ /
        c:Wrel y-----------
                           \sw
                            \
                         d:Racq y
                             |
                             |sb
                             |
                         e:Rrlx x=?

c --sw--> f:Racq y --sb--> g:Rrlx x

            hb
            do
            rf
Wx_release ----> Rx_consume
         ^         |
          \        |sb,hb
        mo \       v
             --- Wx_release

RMW1             +---RMW3_release
|               /
|sb          do/
v             /
R_consume<---+
|
|sb
v
RMW2
|
|sb
v
RMW4

mod       mod               mod
RMW1----->RMW2----->RMW3_release----->RMW4

From sequenced-before:
RMW1      -> R_consume, RMW2, RMW4
R_consume -> RMW2, RMW4
RMW2      -> RMW4
From ithb:
From dependency-ordered-before:
RMW3_release -> R_consume

RMW3_release -> RMW2 or RMW4.

Rx_consume<--+   +-->Ry_consume
|           rf\ /rf  |
|sb            X     |sb
v             / \    v
Wy_release---+   +---Wx_release

• Line splicing occurred in translation phase 2; the backslash is not there on entry to phase 3 when we try to tokenize:
  const char str[] = R"a()\a")a";
• Trigraph replacement occurred in phase 1. The right parenthesis is not there on entry to phase 3:
  const char str[] = R"(??)";
• Trigraph replacement (again). In [lex.string] paragraph 2, there is a footnote 24 in N3092. Note that this provides fuel for anti-trigraph sentiment:
  const char str[] = R"#()??=")#";

• if the next character begins a sequence of characters that could be the prefix and initial double quote of a raw string literal, such as R", the next preprocessing token shall be a raw string literal and any transformations performed in phases 1 and 2 on this input stream (trigraphs, universal-character-names, and line splicing) are reverted for the remainder of the stream until said raw string literal (2.14.5) is matched; [ Footnote: A raw string literal formed through token concatenation (16.3.3) is not parsed from an input stream and is not subject to this reverting. Destringization (16.9) involves an alternate input stream, thus there are no phase 1 or phase 2 transformations to revert. ]
• otherwise, the next preprocessing token is the longest sequence of characters that could constitute a preprocessing token, even if that would cause further lexical analysis to fail.

typedef unsigned long long ULL;
int operator "" X(ULL);
int i = 'c'X; // operator"" X(ULL('c'))

namespace {
namespace N // has no linkage
{
void g(); // has external linkage
} }

int f() {
union U { double d; } u1, u2;
(int&)u1.d = 1;
u2 = u1;
return (int&)u2.d;
}

struct A { int i; };
struct B: A { };
struct C: A, B { };
void f(C* p) {
p->i; // Should be ambiguous
}

constexpr int f(int x){return x + 1; }

constexpr int f2(bool v) { return v ? throw 0 : 0; }
constexpr int f3(bool v) { return v && (throw 0, 0); }

constexpr int f() { return 42 + 84; }
const int sz = f();
int a[sz];

const int sz = 42 + 84;
int a[sz];

typedef char (&One)[1];
typedef char (&Two)[2];
One f(void*); // #1
Two f(...); // #2
constexpr int test(int n) { return sizeof f(n); }
constexpr int test2(int n) { return sizeof f(n*0); }
int q = 0;
#include
int main() {
char a[test(0)];
std::cout << sizeof(a) << std::endl; // #3
std::cout << test(q) << std::endl; // #4
char b[test2(0)];
std::cout << sizeof(b) << std::endl; // #5
std::cout << test2(q) << std::endl; // #6
}

{ auto&& __range = (expression);
auto __begin = begin_expr; auto __end =
end_expr;
for (; ...

auto f(int a[])->decltype(a);
// ill-formed or int*?
auto g(const int i)->decltype(i);
// int or const int?

struct A { };
template<typename T> using X = A;
struct X<int>* p2; // ill-formed

class D [[base_check]] : public B {
void sone_func [[override]] ();
virtual void h [[ hiding]] (char*);
};

class D : public B {
void sone_func() override; // same meaning as
[[override]] - explicit override
virtual void h (char*) new; // same meaning as
[[hiding]] - a new function, not an override
};
int override = 42; // ok, override is not a
reserved keyword

class D [[base_check]] : public B {

class [[base_check]] D : public B {

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

struct S { int a; const char* b; int c; };
S ss = { 1, "asdf" };

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

union u { int a; const char* b; };
u a = { 1 };
u b = a;
u c = 1; // error
u d = { 0, "asdf" }; // error
u e = { "asdf" }; // error

struct A { };
struct B {
operator A&();
};
A&& aref = B(); // binds to lvalue

int i;
int main()
{
int&& ir = static_cast<int&&>(i);
ir = 42;
return (i != 42);
}

void push_back(const T &);
//Copies the const T & into the vector's storage
void push_back(T &&);
//Moves the T && into the vector's storage

const char * cchar = "Hello, world"; std::vector<std::string>
v;
v.push_back(cchar);
//makes a temporary string, copies the string
into vector storage using push_back(const T&)
v.push_back(std::string(cchar));
//makes a temporary string, moves the string into vector
storage using push_back(T&&)
v.push_back(std::move(cchar));
//makes a temporary string, moves the string into the
vector using push_back(T&&)

string && s = string_lvalue;
string && s = string_rvalue_ref_variable;
//mistake, std::move(string_rvalue_ref_variable) was
intended

void f(std::string&&);
void g() {
f(std::string("hello")); // #1, ok
f("hello"); // #2, error,
// but should be the same as #1
}

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

struct tnode {
char tword[20];
int count;
tnode *left;
tnode *right;
void set(const char*, tnode* l, tnode* r);
};
void tnode::set(const char* w, tnode* l, tnode* r) {
count = strlen(w)+1;
if (sizeof(tword)<=count)
perror("tnode string too long");
strcpy(tword,w);
left = l;
right = r;
}
void f(tnode n1, tnode n2) {
n1.set("abc",&n2,0);
n2.set("def",0,0);
}

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

void f() {
union { int a; const char* p; };
a = 1;
p = "Jennifer";
}

class B {
public:
virtual B *f() = 0;
};
class D1 : public B {
public:
virtual D2 *f();
};
class D2 : public B {
public:
virtual D1 *f();
};

struct Base {
virtual B* vf5();
};
class A;
struct Derived : public Base {
A* vf5(); // error: returns pointer to incomplete
class
};

int f (int) { /* ... */ } // definition of f(int)
int f (cInt) { /* ... */ } // error: redefinition of f(int)

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

struct B {
int f(int);
};
struct D : B {
int f(const char*);
};

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

void f(const char*);
void g() {
extern void f(int);
f("asdf"); // error: f(int) hides f(const char*)
// so there is no f(const char*) in this scope
}

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

struct String {
String (const String&);
String (const char*);
operator char* ();
};
String operator + (const String&, const String&);
void f(void) {
char* p= "one" + "two"; // ill-formed because
neither
// operand has user-defined type
int I = 1 + 1; // Always evaluates to 2 even if
// user-defined types exist which
// would perform the operation.
}

template<class T, char* p> class X {
X();
X(const char* q) { / ... / }
};
X<int, "Studebaker"> x1; // error: string literal as templateargument
char p[] = "Vivisectionist";
X<int,p> x2; // OK

template<class T, char* p> class X {
X();
X(const char* q) { /* ... */ }
};
X<int, "Studebaker"> x1; // error: string literal as templateargument
char p[] = "Vivisectionist";
X<int,p> x2; // OK

template<class T, const char* p> class X {
/* ... */
};
X<int, "Studebaker"> x1; // error: string literal as
template-argument
char p[] = "Vivisectionist";
X<int,p> x2; // OK

template<typename T> struct A;
template<typename T> using B=typename A<T>::U;
template<typename T> struct A {
typedef B<T> U;
};
B<short> b;

template<typename T> using A =
struct { void f(T) { } };

template<typename T> struct id { typedef T type; };
template<typename T> void f() { int id<T>::type::*p = 0; }
struct A { };
int main() { f<A>(); }

template <typename T>
bool *foo(T *, enum T::u_type * = 0) { return 0; }
template <typename T> char *foo(T *, struct T::u_type * =
0) { return 0; }
struct A { enum u_type { I }; }; int main(void) { foo((A*)0); }

template <typename T> struct MY_is_enum :
std::false_type { };
template <typename T> struct MY_is_enum<enum T> :
std::true_type { }; // ill-formed,

char * p1 = "..." ; // ill-formed.(removing constness)
char const *p2 = "..." ;// well-formed.

namespace N {
template<class T> class List {
public:
T* get();
};
}
template<class K, class V> class Map {
public:
N::List<V> lt;
V get(K);
};
void g(Map<const char*,int>& m) {
int i = m.get("Nicholas");
}

char * p1 = "..." ; // ill-formed.(removing const'ness)
char const *p2 = "..." ;// well-formed.

template<class X, class Y, class Z> X f(Y,Z);
template<class ... Args> void f2();
void g() {
f<int,const char*,double>("aa",3.0);
f<int,const char*>("aa",3.0); // Z is deduced to be
double
f<int>("aa",3.0); // Y is deduced to be const char*,
and
// Z is deduced to be double
f("aa",3.0); // error: X cannot be deduced
f2<char, short, int, long>(); // OK
}

struct S { ~S(); } s[10];