GNU的C++代码书写规范，C语言之父Dennis Ritchie亲自修订

C++ Standard Library Style Guidelines    DRAFT 1999-02-26
-------------------------------------

This library is written to appropriate C++ coding standards.     As such,
it is intended to precede the recommendations of the GNU Coding
Standard, which can be referenced here:

http://www.gnu.ai.mit.edu/prep/standards_toc.html

ChangeLog entries for member functions should use the
classname::member function name syntax as follows:

1999-04-15     Dennis Ritchie     <[e-mail]>

* src/basic_file.cc (__basic_file::open): Fix thinko in
_G_HAVE_IO_FILE_OPEN bits.

Notable areas of divergence from what may be previous local practice
(particularly for GNU C) include:

01. Pointers and references
     char* p = "flop";
     char& c = *p;
        -NOT-
     char *p = "flop";     // wrong
     char &c = *p;         // wrong
    
       Reason: In C++, definitions are mixed with executable code.     Here,         
        p             is being initialized, not *p.     This is near-universal
               practice among C++ programmers; it is normal for C hackers
               to switch spontaneously as they gain experience.

02. Operator names and parentheses
     operator==(type)
        -NOT-
     operator == (type)     // wrong
       
       Reason: The == is part of the function name.     Separating
               it makes the declaration look like an expression.

03. Function names and parentheses
     void mangle()
        -NOT-
     void mangle ()     // wrong

        Reason: no space before parentheses (except after a control-flow
        keyword) is near-universal practice for C++.     It identifies the
        parentheses as the function-call operator or declarator, as
        opposed to an expression or other overloaded use of parentheses.

04. Template function indentation
     template<typename T>
       void
       template_function(args)
       { }
         -NOT-
     template<class T>
     void template_function(args) {};
    
        Reason: In class definitions, without indentation whitespace is
                needed both above and below the declaration to distinguish
         it visually from other members.     (Also, re: "typename"
         rather than "class".)     T often could be int, which is
         not a class.     ("class", here, is an anachronism.)

05. Template class indentation
     template<typename _CharT, typename _Traits>
       class basic_ios : public ios_base
       {
       public:
         // Types:
       };
     -NOT-
     template<class _CharT, class _Traits>
     class basic_ios : public ios_base
       {
       public:
         // Types:
       };
     -NOT-
     template<class _CharT, class _Traits>
       class basic_ios : public ios_base
     {
       public:
         // Types:
     };

06. Enumerators
     enum
     {
       space = _ISspace,
       print = _ISprint,
       cntrl = _IScntrl,
     };
     -NOT-
     enum { space = _ISspace, print = _ISprint, cntrl = _IScntrl };

07. Member initialization lists
      All one line, separate from class name.

     gribble::gribble()
     : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
     { }
     -NOT-
     gribble::gribble() : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
     { }

08. Try/Catch blocks
     try {
       //
     }     
     catch(...) {
       //
     }     
     -NOT-
     try { // } catch(...) { // }

09. Member functions declarations and defintions
      Keywords such as extern, static, export, explicit, inline, etc
      go on the line above the function name. Thus

     virtual int     
     foo()
     -NOT-
     virtual int foo()

Reason: GNU coding conventions dictate return types for functions
         are on a separate line than the function name and parameter list
         for definitions. For C++, where we have member functions that can
.        be either inline definitions or declarations, keeping to this
         standard allows all member function names for a given class to be
aligned to the same margin, increasing readibility.

10. Invocation of member functions with "this->"
      For non-uglified names, use this->name to call the function.

     this->sync()
     -NOT-
     sync()

The library currently has a mixture of GNU-C and modern C++ coding
styles.     The GNU C usages will be combed out gradually.

Name patterns:

For nonstandard names appearing in Standard headers, we are constrained
to use names that begin with underscores.     This is called "uglification".
The convention is:

     Local and argument names:     __[a-z].*

       Examples:     __count     __ix     __s1    

     Type names and template formal-argument names: _[A-Z][^_].*

       Examples:     _Helper     _CharT     _N

     Member data and function names: _M_.*

       Examples:     _M_num_elements     _M_initialize ()

     Static data members, constants, and enumerations: _S_.*

       Examples: _S_max_elements     _S_default_value

Don't use names in the same scope that differ only in the prefix,
e.g. _S_top and _M_top.     See BADNAMES for a list of forbidden names.
(The most tempting of these seem to be and "_T" and "__sz".)

Names must never have "__" internally; it would confuse name
unmanglers on some targets.     Also, never use "__[0-9]", same reason.

--------------------------

[BY EXAMPLE]
      
#ifndef     _HEADER_
#define     _HEADER_ 1

namespace std
{
     class gribble
     {
     public:
       // ctor, op=, dtor
       gribble() throw();

       gribble(const gribble&);

       explicit
       gribble(int __howmany);

       gribble&
       operator=(const gribble&);

       virtual
       ~gribble() throw ();

       // argument
       inline void    
       public_member(const char* __arg) const;

       // in-class function definitions should be restricted to one-liners.
       int
       one_line() { return 0 }

       int
       two_lines(const char* arg)
         { return strchr(arg, 'a'); }

       inline int
       three_lines();     // inline, but defined below.

       // note indentation
       template<typename _Formal_argument>
         void
         public_template() const throw();

       template<typename _Iterator>
         void
         other_template();

     private:
       class _Helper;

       int _M_private_data;
       int _M_more_stuff;
       _Helper* _M_helper;
       int _M_private_function();

       enum _Enum
         {
_S_one,
_S_two
         };

       static void
       _S_initialize_library();
     };

// More-or-less-standard language features described by lack, not presence:
# ifndef _G_NO_LONGLONG
     extern long long _G_global_with_a_good_long_name;     // avoid globals!
# endif

     // avoid in-class inline definitions, define separately;
     //      likewise for member class definitions:
     inline int
     gribble::public_member() const
     { int __local = 0; return __local; }

     class gribble::_Helper
     {
       int _M_stuff;

       friend class gribble;
     };
}

// Names beginning with "__": only for arguments and
//      local variables; never use "__" in a type name, or
//      within any name; never use "__[0-9]".

#endif /* _HEADER_ */

namespace std {

     template<typename T>     // notice: "typename", not "class", no space
       long_return_value_type<with_many, args>    
       function_name(char* pointer,                  // "char *pointer" is wrong.
       char* argument,
       const Reference& ref)
       {
         // int a_local;     /* wrong; see below. */
         if (test)
         {
      nested code
         }
      
         int a_local = 0;     // declare variable at first use.

         //     char a, b, *p;      /* wrong */
         char a = 'a';
         char b = a + 1;
         char* c = "abc";     // each variable goes on its own line, always.

         // except maybe here...
         for (unsigned i = 0, mask = 1; mask; ++i, mask <<= 1) {
      // ...
         }
       }
    
     gribble::gribble()
     : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
     { }

     inline int
     gribble::three_lines()
     {
       // doesn't fit in one line.
     }

}