The effects of using this option on C++ programs are:

• classes declared or defined within classes or declared within argument lists are given the scope of the closest nonclass.
• typedefs declared within classes are given the scope of the closest nonclass.
• The overload statement is recognized and ignored.
• An expression showing the dimension in a delete expression is parsed and ignored. For example:

  delete [20] p; // 20 is ignored.

• Where a conversion to a reference type uses a compiler temporary type, the reference need not be to a const type.
• Initializations can be bypassed as long as they are not constructor initializations.
• Returning a void expression from a function that returns void is allowed.
• operator++ and operator-- without the second zero argument are matched with both prefix and postfix ++ and --.
• $ sign is allowed in identifiers.
• friend X; is allowed when X has not yet been introduced as a class name. For example:

  friend X; // is equivalanet to : friend class X;

• Extra tokens following preprocessor directives are allowed. For example:

  #endif Comment

• A class declaration with no declarator can have the same name as its container. For example:

  class A {
  class A;
  }

• A trailing comma is allowed in an enumeration constant list. For example:

  enum E { e, }; // allowed

• A cast expression can contain a storage class specifier. For example:

  (static int *) pi; //allowed

• Overloaded operators

  class B {
  int operator==(unsigned int);
  operator int();
     };
     B bobj;
      int i;
      ... bobj == i // exact match

• Not returning avalue from a function that has a return value generates a warning instead of an error.

For similar reasons, tokens separated only by a comment may also be combined to form a single token. Here is a summary of how tokenization of a program compiled in classic mode is performed:

1. At a given point in the source file, the next token is the longest sequence of characters that can possibly form a token. For example, i+++++j is tokenized as i ++ ++ + j even though i ++ + ++ j may have resulted in a correct program.
2. If the token formed is an identifier and a macro name, the macro is replaced by the text of the tokens specified on its #define directive. Each parameter is replaced by the text of the corresponding argument. Comments are removed from both the arguments and the macro text.
3. Scanning is resumed at the first step from the point at which the macro was replaced, as if it were part of the original program.
4. When the entire program has been preprocessed, the result is scanned again by the compiler as in the first step. The second and third steps do not apply here since there will be no macros to replace. Constructs generated by the first three steps that resemble preprocessing directives are not processed as such.

It is in the third and fourth steps that the text of adjacent but previously separate tokens may be combined to form new tokens.

The \ character for line continuation is accepted only in string and character literals and on preprocessing directives.

Constructs such as:

   #if 0
      "unterminated
   #endif
   #define US "Unterminating string
   char *s = US terminated now"

will not generate diagnostic messages, since the first is an unterminated literal in a FALSE block, and the second is completed after macro expansion. However:

   char *s = US;

will generate a diagnostic message since the string literal in US is not completed before the end of the line.

Empty character literals are allowed. The value of the literal is sero.

   #define f(a,b) a+b
   f\
   (1,2)      /* accepted */

   #define f(a,b) a+b
   f(\
   1,2)       /* not accepted */

The rules concerning \ apply whether or not the directive is valid. For example,

   #\
   define M 1   /* not allowed */

   #def\
   ine M 1      /* not allowed */

   #define\
   M 1          /* allowed */

   #dfine\
   M 1          /* equivalent to #dfine M 1, even
                   though #dfine is not valid  */

Following are the preprocessor directive differences between classic mode and ansi mode. Directives not listed here behave similarly in both modes.

• When the number of arguments on a macro invocation does not match the number of parameters, a warning is issued.
• If the ( token is present after the macro name of a function-like macro, it is treated as too few arguments (as above) and a warning is issued.
• Parameters are replaced in string literals and character literals.
• Examples:

     #define M()    1
     #define N(a)   (a)
     #define O(a,b) ((a) + (b))

     M();  /* no error */
     N();  /* empty argument */
     O();  /* empty first argument 
              and too few arguments */