End the first line with the line-continuation character, a backslash.

Close the string on the first line with a double quotation mark, and open the string on the next line with another quotation mark.

printf("Hello, // error

world");

printf("Hello,\n // error

world");

printf("Hello,\ // OK

world");

printf("Hello," // OK

" world");

printf("Hello,\n\

world");

printf("Hello,\

\nworld");

printf("Hello,\n"

"world");

printf("Hello,"

"\nworld");

L'mbconst'

struct S;

union S;

struct S

{

int *b : 1; // error

};

struct A* pA;

struct B { int i; };

B* pB;

void main()

{

pA++; // error, size of A not known

pB++; // OK, B has been declared

}

struct S

{

int mem0;

} *pS;

void main()

{

pS->mem1 = 0; // error, mem1 is not a member

pS->mem0 = 0; // OK

}

int i = 081; // error, 8 is not a legal digit

int i = 071; // OK

unsigned signed int i; // error

char array[] = L"Rika";

int array1[] { 1, 2, 3 }; // error, missing =

int array2[] = { 1, 2, 3 }; // OK

int *p // error

main()

{ // error

int i, j;

j = i(); // error, i is not a function

int i, j;

char* p;

void func()

{

j = i(); // error, i is not a function

p(); // error, p doesn't point to a function

}

class A

{

public:

A( int ); // constructor for ints only

};

A a[3] = { A(1), A(2) }; // error, no default constructor

class B

{

public:

B(); // default constructor declared

B( int );

};

B b[3] = { B(1), B(2) }; // OK

struct A

{

int i;

} a, b;

void func()

{

if( a == b ); // error, structure comparison

}

void func1( void )

void main( void )

{

}

int a;

char a;

main()

{

}

main()

{

int a;

int a;

}

int a;

int a;

main()

{

}

int func(a)

char a[10][]; // error

{ }

int func(a)

char a[][5]; // OK

{ }

class A

{

public:

int i;

} a;

int i = 1 + a; // this line causes the error

class B

{

public:

operator int() { return i; }

int i;

} b;

int j = 1 + b; // OK, uses conversion operator

class C

{

public:

int operator+( int j ) { return (j+i); } // solution

int i;

} c;

int k = c + 1; // OK, uses overloaded operator+

int i = 1 + c; // still an error, no conversion

// operator defined for class C

func()

{

int i;

static int *ip=&i; // error

}

Initialization of a variable using a nonconstant value

Initialization of a short address with a long address

Initialization of a local structure, union, or array with a nonconstant expression when compiling with /Za

Initialization with an expression containing a comma operator (,)

Initialization with an expression that is neither constant nor symbolic

int i, j;

int *p;

j = i(); // error, i() is not constant

j = *p; // error, *p is not a constant

typedef int *p_int;

typedef short *p_short;

p_short p_int p; // error

typedef int __near nint;

nint __far a; // error

struct X

{

int a[0]; // error, unsized array

};

struct S

{

int i : 1;

int j;

};

void main()

{

&S::i; // error, address of a bit field

&S::j; // OK

}

int double a;

void func();

void func( int, ... );

class X

{

int member

} x; // error, missing ; on previous line

class + {}; // error, + is invalid tag name

main()

{

#pragma optimize( "l", on )

}

extern static int i; // error

#define mac(a,b) ##a

#define mac(a,b) a##

#define print(a) printf(#b)

char __pascal *p;

int (*fp)();

double d, d1;

fp++; // error

d = ~d1; // error

(__segment) & var

__segment ("_STACK")

(__segment) __self

void

void func1( void );

int func2( void );

int i = 2 + func1(); // error, func1() is type void

int j = 2 + func2(); // OK, both operands are type int

void func( int, float );

void func( int, ); // error, different parameter list

void func( int );

void func( int, float ); // error, different parameter list

void func( float, int );

void func( int, float ); // error, different parameter list

void func( int );

main()

{

func( 1, 2 ); // error, two actual parameters

}

void func( int, int );

main()

{

func( 1 ); // error, only one actual parameter

}

struct S

{

public:

int i;

S( int si ) { i = si; }

};

S(1) s; // error, incorrect syntax

S s(1); // OK

main()

{

static int func1(); // error

}

int func1( int i )

{

if( i ) return 3; // error, nothing returned if i = 0

}

int func2( int i )

{

if( i ) return 3;

else return 0; // OK, always returns a value

}

delete [4] ArrayOfObjects; // error

( struct S {}; ); // error

typedef int functyp();

functyp func1 {}; // error

char __based( void ) *cbvpi;

__saveregs and __interrupt

__fastcall and __saveregs

__fastcall and __interrupt

__fastcall and __export

An interrupt function explicitly declared as near. Interrupt functions must be declared as far.

An interrupt function that is declared with the __fortran, __pascal, or __fastcall attribute. Functions declared with the __interrupt attribute must use C calling conventions.

A function with a variable number of parameters that is declared with the __fortran, __pascal, or __fastcall attribute. These functions must use C calling conventions. Remove the __fortran, __pascal, or __fastcall attribute from the function declaration.

int (const *p);

int func1( int, ... , float ); // error, misplaced ellipsis

int func2( int, float, ... ); // OK

int *pInt;

struct S

{

public:

int member;

} *pS;

void main()

{

pInt->member = 0; // error, pInt points to an int

pS->member = 0; // OK, pS points to a structure S

}

int i;

struct S

{

public:

int member;

} s, *ps;

void main()

{

i.member = 0; // error, i is not a class type

ps.member = 0; // error, ps is a pointer to a structure

s.member = 0; // OK, s is a structure type

ps->member = 0; // OK, ps points to a structure S

}

struct S

{

int a[0]; // error, zero-sized array

int b[1]; // OK

};

struct S

{

public:

int member;

} s, *ps;

void main()

{

ps.member = 0; // error, ps points to structure S

ps->member = 0; // OK, ps points to a structure S

s.member = 0; // OK, s is a structure type

}

struct X

{

int member;

} x, *px;

void main()

{

x->member = 0; // error, x is not a pointer

px->member = 0; // OK, px is a pointer to an X

x.member = 0; // OK

}

void func( int i; float f ); // error, uses semicolon

void func( int i, float f ); // OK, uses comma

class + {}; // error, + is invalid class name

struct bits

{

int field1 : 16;

int 9 : 16; // error, 9 is not a valid name

};

int i 8; // error, missing =

int j = 7; // OK

int func( char );

int func( int );

void main ()

{

+func; // error, can't resolve which func to use

+func( 0 ); // OK

}

class C

{

public:

int i; // i is not a function

void func();

};

class S

{

public:

friend void C::i(); // error

friend void C::func(); // OK

};

void func( void )

{

class A

{

static int i; // error, i is local to func

};

};

class B

{

static int i; // OK

};

class A

{

public:

int i;

};

class B : private A {}; // B inherits a private A

class C : public B {} c; // so even though C's B is public

int j = c.i; // error, i not accessible

class X

{

public:

int pubMemb;

void setPrivMemb( int i ) { privMemb = i; }

protected:

int protMemb;

private:

int privMemb;

} x;

void main()

{

x.privMemb = 0; // error, privMemb is private

x.protMemb = 0; // error, protMemb is protected

x.pubMemb = 0; // OK, pubMemb is public

x.setPrivMemb( 0 ); // OK, uses public access function

}

class A

{

private:

void privFunc( void ) {};

public:

void pubFunc( void ) {};

};

class B : virtual public A {} b;

void main( void )

{

b.privFunc(); // error, private member of A

b.pubFunc(); // OK

}

struct V { virtual void vf(); };

struct A : virtual V { void vf(); };

struct B : virtual V { void vf(); };

struct D : A, B {}; //error

class A

{

virtual int i = 0; // error, i is an int

virtual void func() = 0; // OK, func is a function

};

class A

{

public:

void func1() = 0; // error, not virtual

virtual void func2() = 0; // OK

};

class A

{

public:

friend void func1() = 0; // error, func1 is friend

void virtual func2() = 0; // OK, pure virtual

friend void func3(); // OK, friend not virtual nor

}; // pure

void func1() {};

void func3() {};

class A

{

private:

void func1();

friend void func2();

};

friend void func1() {}; // error

void func2() {}; // OK

class C

{

public:

friend ~C(); // error

~C(); // OK

};

class A

{

public:

void virtual func1() = 1; // error, not = 0

void virtual func2() = 0; // OK

};

class V

{

public:

void virtual func() = 0;

};

class A : public V {};

class B : public V

{

public:

void func();

};

V v; // error, V is an abstract class

A a; // error, A inherits func() as pure virtual

B b; // OK, B defines func()

struct S

{

~S() __near;

};

S __far fs; // error, wrong memory model for destructor

class B

{

~B();

};

class D : public B {};

D d; // error, B's destructor is private

class C

{

public:

operator int( int = 10 ); // incorrect declaration here

};

void main()

{

int i;

C c;

i = c; // error

}

const char *p = "abcde";

int str( char *s );

str( p );

class __far F {};

class __near N {};

class Err : F, N {}; // error

class __far NoErr : F, N {}; // OK

void func1() __near; // error, nonmember function

class C

{

public:

void func2() __near; // OK

};

class C

{

void *operator new( unsigned ) __far; // error

};

class C

{

public:

static void func1() __far; // error, func1 is static

void func2() __far; // OK

};

i = ClassPtr->int( a ); // error

i = ClassPtr->operator int( a ); // OK

i = ClassName.int( a ); // error

i = ClassName.operator int( a ); // OK

class C

{

public:

int i;

static int s;

};

void main()

{

int C::i = 0; // error, nonstatic member

int C::s = 0; // OK, static member

C.c;

c.i = 0; // OK, member of instance of C

}

class B

{

public:

B();

B( int );

};

class D : public B

{

public:

D( int i ) : ( i ) {} // error, B was not named

D( int i ) : B( i ) {} // OK

};

class X

{

public:

static void func1();

void func2();

static void func3()

{

func1(); // error, calls static func1

func2(); // OK, calls nonstatic func2

}

};

class C

{

public:

C() : i( 10 ); // error, missing definition

C() : i( 10 ){}; // OK

private:

int i;

};

char *p = this; // error

void func( void )

{

int x;

switch ( x )

{

case 0 :

int i = 1; // error, skipped by case 1

{ int j = 1; } // OK, initialized in enclosing block

case 1 :

int k = 1; // OK, initialization not skipped

}

}

void func( void )

{

int x;

switch (x)

{

case 0 :

int i = 1; // error, skipped by default

{ int j = 1; } // OK, initialized in enclosing block

default :

int k = 1; // OK, initialization not skipped

}

}

The declaration is enclosed in a block that is not entered.

The jump is from a point where the variable has already been initialized.

void func()

{

goto label1;

int i = 1; // error, initialization skipped

{

int j = 1; // OK, this block is never entered

}

label1:;

}

extern int i;

static int i; // error

int i;

int i(); // error

extern int *fp;

extern int fp[]; // error

void __pascal func( void );

void __cdecl func( void ); // error

int i = 0;

int i = 1; // error

extern void func( void );

static void func( void ); // error

typedef int i;

int i; // error

int i;

typedef int i; //error

class C

{

public:

int C(); // error, specifies an int return

int C; // error, redefinition of i

C(); // OK

};

If the identifier is a function, it should be declared with extern storage.

If the identifier is a formal parameter or local variable, it should be declared with auto storage.

If the identifier is a global variable, it should be declared with no storage class (that is, auto storage).

register int i; //error

void main ()

{

register int j; //OK

}

jz label1

inc AX

label1: inc CX

jnz label2

jmp label1

label2: inc AX

label1: inc CX

_asm mov eax, [ebx*2+ecx*4]

_asm mov ax, [ESI+2*ESP]

_asm mov ax, [esp+esp]

_asm mov eax, DWORD PTR [bx]

class A

{

public:

int i;

} a;

class B

{

public:

operator int() { return i; } // conversion operator

int i;

} b;

void func1( int j = a ) {} // error, can't convert a to int

void func2( int j = b ) {} // OK

class X

{

public:

static const int i;

static int j;

};

const int X::i = 1;

int X::j = 2;

class X

{

public:

int j;

} x;

class Y

{

public:

operator int() { return j; } // conversion operator

int j;

} y;

void main()

{

int i;

i = x; // error, x cannot be converted to an int

i = y; // OK

}

#pragma optimize( "q", off )

short var;

void main()

{

__asm xchg ax,bl // error

__asm mov al,foo // error

__asm mov al,BYTE PTR var // OK

}

class C {};

class D {};

C aC;

D aD;

void main()

{

aC = aD; // error

}

int c;

{} // error

void func(c)

int c;

{} // error

class X

{

public:

int i;

} x;

class Y

{

public:

int i;

operator int() { return i; } // conversion operator

} y;

void main()

{

int j = 1;

switch ( x ) // error, x is not type int

{

default: ;

}

switch ( y ) // OK

{

default: ;

}

}

class C

{

enum i { C }; // error

};

class C

{

union { int C; }; // error

};

class C

{

C aC; // error

};

class C

{

C::C; // error

C::C(); // OK

};

void main()

{

new struct S { int i; }; // error

}

void main()

{

new struct { int x; }; // error

}

void main()

{

new ( int& ir ); // error

}

class A { };

class B : public A, public A { }; // error

class C : public A { };

class D : public A { };

class E : public C, public D { }; // OK, contains two As

class A { };

class B { };

class C : private public A { }; // error

class D : private A { }; // OK

class E : public A, private B { }; // OK

class A; // error, A is undefined

class A {}; // OK, A is defined

class B : public A {}; // the error is detected here

class B { };

class D : public B { }; // OK, D is derived from B

typedef int I;

class E : public I { }; // error, I is not a class

class A

{

public:

int a;

};

class B

{

private:

int a;

};

class C : public A, private B { };

C c;

int j = c.a; // error, could be A::a or B::a

int i = c.A::a; // OK, resolved ambiguity

class A {};

class B : virtual virtual public A {}; // error

class C : virtual public A {}; // OK

int a, b, c;

int &ai[3]; // error, elements not initialized

int &ai[3] = { a, b, c }; // OK

It is declared with the keyword extern.

It is a member of a class, structure, or union and is initialized in the class's constructor function.

It is declared as a parameter in a function declaration or definition.

It is declared as the return type of a function.

class X

{

public:

void X( void ) { ... }; // error, return type declared

X( void ) { ... }; // OK, no return type declared

};

int i;

int A[i]; // error, i is nonconstant

const j = 20;

int A[j]; // OK, j is constant

int B[32]; // OK, 32 is a literal

void main()

{

int i;

delete i; // error, i is not a pointer

int* ip = new int;

delete ip; // OK

}

int func();

int func( int );

( int (*)() )func; // error, func is overloaded

int func2();

( void (*)() )func2; // OK, func2 is not overloaded

void func( int = 1, int, int = 3); // error

void func( int, int, int = 3); // OK

void func( int, int = 2, int = 3); // OK

class X

{

public:

int operator int() { return value; } // error

operator int() { return value; } // OK

private:

int value;

};

An array

A class, structure, or union that does not have constructors, private or protected members, base classes, or virtual functions

void func( int );

void func( int, int );

main()

{

void *fp();

fp = func; // error

fp = func( int, int ); // OK

}

int f( int );

int f( double );

void main()

{

if( f ); // error, which f?

if( f(1) ); // OK

}

void func()

{

int i = int(); // error, no actual parameters

int j = int( 1.0 ) // OK

}

class C

{

* operator int(); // error, indirection on the operator

};

typedef int * pINT_t;

class D

{

operator pINT_t(); // OK

};

int i;

void func();

{

int j;

extern void func2( int k = j ); // error, local variable

extern void func2( int k = i ); // OK

}

~F(); // error

void func()

{

extern "C" int func2(); // error, linkage declared in

. // block with local scope

.

.

}

extern "C" int func( int i ); // OK

void main()

{

class C

{

int f() { return 0; } // error, local function

};

}

An l-value of type type2

A type derived from type2 for which type2 is an accessible base

struct C

{

int mem;

operator int();

};

struct D

{

operator C();

void memfunc();

};

D aD[10];

void D::memfunc()

{

C aC = ( C& )( aD + 1 ); // error

}

class C

{

C::~operator int(); // error

~C(); // OK, destructor declaration

};

class A

{

public:

int i;

A( int ia ) : i( ia ), {}; // error, extra comma

A( int ia ) : i( ia ) {}; // OK

};

class A {};

class B : public A, {}; // error, extra comma

class C : public A {}; // OK

class A

{

public:

int i;

A( int ia ) : B( i ) {}; // error, B is not a member of A

};

class A

{

public:

int i;

};

class B

{

private:

A::i; // error, A::i is not a member of B

};

int i;

func() // no return type prototype

{

if( i ) return; // no return value

else return( 1 ); // error detected on this line

}

int i;

func() // no return type prototype

{

if( i ) return( 1 ); // int return value

else return; // error detected on this line

}

void func()

{

union

{

static int j; // error, j is static

int i; // OK

};

}

class A

{

A(); // A has a default constructor

};

union U

{

A a; // error

};

class A

{

A( const A& ); // A has a copy constructor

};

union U

{

A a; // error

};

class A

{

operator= ( const A& ); // A's assignment operator

};

union U

{

; // error

};

class A

{

~A(); // A has a destructor

};

union U

{

A a; // error

};

static union {}; // error

static union { int i; }; // OK

void main()

{

union

{

public:

int i; // OK, i is public

protected:

int j; // error, j is protected

private:

int k; // error, k is private

};

}

void main()

{

union

{

int i;

void func( void ); // error, union is anonymous

};

union U

{

void func2( void ); // OK

};

}

class C

{

public:

void func( void ) {;}

} // semicolon is missing here

void main() {} // error detected on this line

class B

{

B( &B ); // error, misplaced &

B( B& ); // OK

};

class C

{

int ~C(); // error, returns int

void ~C(); // error, returns void

~C(); // OK

};

int float i; // error

class C

{

extern C(); // error, not inline

};

struct S {};

int &S::*prs; // error

struct S {};

int __pascal S::*pms; // error

class C

{

public:

int i;

int j;

int func();

};

int __near C::* cpi = &C::i; // error, __near modifier

int C::* cpj = &C::j; //OK

int (__near C::* cpf)() = &C::func; // OK, not data member

struct V

{

virtual void func();

};

struct D : virtual V

{

void func();

};

void main()

{

&D::func; // error

}

class A

{

public:

int a;

};

class B

{

public:

int b;

};

class C : virtual public A, public B {};

int C::* cpa = &C::a; // error, C's A is virtual

int C::* cpb = &C::b; // OK

struct V {};

struct A : virtual V {};

int A::*pma;

int V::*pmv = (int V::*)pma;

class B

{

public:

int b:

};

class C {};

int C:: cpb = (int C::*)&B::b; // error

class D : public B

{

public:

int d;

};

int D:: dpb = (int D::*)&B::b; // OK, B is a base class of D

int B:: bpd = (int B::*)&D::d; // OK

class C

{

public:

int i;

operator int*() { return &i; }

};

int C::* cpi = (int*)&C::i; // error

int C::* cpi2 = &C::i; // OK

class C;

int C::* cp; // error, C has not been declared

class D {};

int D::*dp; // OK

class A {};

int ::* cp; // error, class not specifed

int B::* bp // error, B not defined

int A::* ap; // OK

union { int i; }; // error, not static

static union { int j; }; // OK

union U { int i; }; // OK, not anonymous

class C

{

public:

int i;

static int j;

void func1( int i = i ); // error, i is not static

void func2( int i = j ); // OK, uses static j

};

struct S

{

int i;

};

class S::i c; // error

class A

{

virtual void* operator new( unsigned int ); // error

};

class A

{

A( A ); // error, takes an A

};

class B

{

B( B& ); // OK, reference to B

};

int x;

int main()

{

return x::i; // error

}

class A

{

int i;

int j = i; // error, access outside function

void setj( void ) { j = i ; } // OK, access in function

A( int ai )

{

i = ai; // OK, initializes i and j

j = i;

}

} a( 1 );

class A {};

class B

{

public:

static int i;

};

void main()

{

A B::i; // error

}

class C {};

void main() {

C::* pmc1; // error

void C::* pmc2; // OK

}

struct A;

struct B

{

B(A);

B();

};

struct A

{

operator B();

};

A a;

B b = B(a); // error

int func( int );

int func( double );

void main()

{

func = 10; // error

}

void func( int, int );

void main()

{

func( 1 ); // error, func( int ) not declared

func( 1, 0 ); // OK, func( int, int ) was declared

}

void func( int );

void func( int, int );

void main()

{

func( ); // error, func( void ) was not declared

func( 1 ); // OK, func( int ) was declared

}

class __far C

{

public:

void func() __near;

} c;

void main()

{

c.func(); // error

}

class __far C

{

public:

void func() __near;

void func( int ) __near;

} c;

void main()

{

c.func(); // error

}

class A {} a;

func( int, A );

void main()

{

func( 1, 1 ); // error, no conversion from A to int

}

void func( int, float ) {};

void func( float, int ) {};

func( 1, 1 ); // error, same conversion for each func

func( 1, (float)1 ) // OK

struct A {};

struct B : A {};

struct X {};

struct D : B, X {};

void func( X, X );

void func( A, B );

D d;

void main()

{

func( d, d ); // error, D has an A, B, and X

func( (X)d, (X)d ); // OK, uses func( X, X )

}

struct S

{

static S* const func() { return this; } // error

};

class C

{

void* operator new( unsigned int )

{

this = 10; // error

return 0;

}

};

void main()

{

this = 0; // error

}

const int* pci;

const int i = 0;

void main()

{

pci = &i;

delete pci; // error, pci points to a const

}

void (*pf)();

void func();

void main()

{

pf = func;

delete pf; // error, pf points to a function

}

struct S

{

static int i;

};

static S::i; // error

extern void func( void ); // implicit C++ linkage

extern "C" void func( void ); // error

const int j; // error

extern const int i; // OK, declared as extern

void main()

{

int *myint;

myint = new static int; // error

myint = new typedef int; // error

myint = new auto int; // error

myint = new register int; // error

}

int main()

{

return (virtual) 0; // error

}

class C

{

operator:: (); // error :: is overloaded

};

operator[](); // error, not a member

class A

{

static operator->(); // error, static

operator()(); // OK

};

class A

{

static operator+ (); // error, void parameter list

static operator* ( A& ); // OK

};

int operator+( int, int ); // error

class X

{

X operator+ ( X , X ); // error, two parameters

X operator+ ( X ); // OK, one parameter

};

class X

{

public:

X operator< ( void ); // error, must take one parameter

X operator< ( X ); // OK

};

class X

{

public:

X operator++ ( int, int ); // error, more than 1 parameter

X operator++ ( int ); // OK

} ;

class X

{

public:

X operator++ ( X ); // error, nonvoid parameter

X operator++ ( int ); // OK, int parameter

} ;

class X

{

public:

X operator! ( X ); // error, nonvoid parameter list

X operator! ( void ); // OK

};

int operator+ (); // error

void operator delete ( __segment, void __based( void ) * );

void operator delete ( __segment, void __based( void ) *, \

unsigned int );

void operator delete ( __segment, void __based( void ) * );

void operator delete ( __segment, void __based( void ) *, \

unsigned int );

void operator delete ( void __near * );

void operator delete ( void __near *, unsigned int );

void operator delete ( void __far * );

void operator delete ( void __far *, unsigned int );

void operator delete ( void __huge * );

void operator delete ( void __huge *, unsigned int );

void operator delete ( __segment, void __based( void ) * );

void operator delete ( __segment, void __based( void ) *, \

unsigned int);

void operator delete ( __segment, void __based( void ) * );

void operator delete ( __segment, void __based( void ) *, \

unsigned int);

A pointer to a class, structure, or union

A reference to a class, structure, or union where the –> operator is defined

An instance of a class, structure, or union where the –> operator is defined

void __based( void ) * operator new ( __segment, unsigned int );

void __near * operator new ( unsigned int );

void __far * operator new ( unsigned int );

void __huge * operator new ( unsigned long, unsigned int );

void __huge * operator new ( unsigned long, unsigned int );

void __huge * operator new ( unsigned long, unsigned int );

extern int i; // i not exported

int __export i; // error, i exported

#pragma hdrstop( "source\pchfiles\myheader.pch" )