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  <dr@att.com>

* 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.
  }

}

  • 0
    点赞
  • 4
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
主要讲解C11标准语法内容并且从整个编译、连接到加载过程都会涉及。同时在后会分别介绍GCC编译器与Clang编译器C语言语法扩展。通过阅读本书读者能够完全掌握新标准C语言编程。并且对C语言设计思想、实现方式也能有个大概了解。 前言 第一篇 预备知识篇 第1章 C魔法概览 /2 1.1 例说编程语言 2 1.2 用C语言编程基本注意事项 6 1.3 主流C语言编译器介绍 8 1.4 关于GNU规范语法扩展 10 1.5 用C语言构建一个可执行程序流程 11 1.6 本章小结 12 第2章 学习C语言预备知识 /14 2.1 计算机体系结构简介 14 2.1.1 贮存器 15 2.1.2 存储器 15 2.1.3 寄存器 16 2.1.4 计算单元 16 2.1.5 程序执行流程 16 2.2 整数在计算机中表示 17 2.2.1 原码表示法 18 2.2.2 补码表示法 19 2.2.3 八进制数与十六进制数 20 2.3 浮点数在计算机中表示 22 2.4 地址与字节对齐 24 2.5 字符编码 25 2.6 大端与小端 28 2.7 按位逻辑运算 28 2.8 移位操作 30 2.8.1 算术左移与逻辑左移 30 2.8.2 逻辑右移 30 2.8.3 算术右移 31 2.8.4 循环右移 32 2.9 本章小结 32 第3章 C语言编程环境搭建 /33 3.1 Windows操作系统下搭建C语言编程环境 33 3.1.1 安装Visual Studio Community 2017 34 3.1.2 安装MinGW编译器 40 3.1.3 安装LLVM Clang编译器 43 3.2 macOS系统下搭建C语言编程环境 45 3.3 本章小结 51 第二篇 基础语法篇 第4章 C语言基本元素 /54 4.1 C语言字符集 55 4.2 C语言token 56 4.2.1 C语言标识符 57 4.2.2 C语言关键字 58 4.2.3 C语言常量与字符串字面量 60 4.2.4 C语言标点符号 60 4.3 关于C语言“对象” 62 4.4 C语言“副作用” 63 4.5 C语言标准库中printf函数 63 4.6 本章小结 65 第5章 基本数据类型 /66 5.1 整数类型 66 5.1.1 int类型 67 5.1.2 short类型 68 5.1.3 long类型 69 5.1.4 long long类型 71 5.1.5 布尔类型 72 5.1.6 字符类型 73 5.1.7 宽字符以及Unicode字符类型 77 5.1.8 size_t与ptrdiff_t类型 81 5.1.9 C语言标准整数类型 82 5.2 浮点类型 84 5.3 数据精度与类型转换 86 5.3.1 整数晋升 87 5.3.2 带符号与无符号整数之间转换 87 5.3.3 浮点数与浮点数转换以及浮点数与整数之间转换 90 5.4 C语言基本运算操作符 92 5.4.1 加、减、乘、除与求模运算操作符 92 5.4.2 按位逻辑操作符 93 5.4.3 自增、自减操作符 94 5.4.4 关系操作符、相等性操作符与逻辑操作符 95 5.4.5 移位操作符 96 5.4.6 圆括号操作符 97 5.5 sizeof操作符 98 5.6 投射操作符 99 5.7 本章小结 101 第6章 用户自定义类型 /102 6.1 枚举类型 102 6.2 结构体类型 105 6.2.1 结构体概述 105 6.2.2 用结构体创建对象并访问其成员 107 6.2.3 结构体复合字面量 110 6.3 联合体类型 113 6.4 位域 117 6.4.1 位域一般特性 118 6.4.2 位域成员存放与布局 120 6.4.3 匿名位域 122 6.4.4 位域使用示例 124 6.5 字节对齐与字节填充 125 6.5.1 _Alignof操作符 125 6.5.2 _Alignas对齐说明符 126 6.5.3 结构体成员字节对齐与字节填充 129 6.6 复数类型 133 6.7 本章小结 135 第7章 C语言数组与指针 /136 7.1 一维数组 136 7.2 多维数组 141 7.3 变长数组 145 7.4 一级指针与对象地址 147 7.4.1 地址与指针基本概念 148 7.4.2 访问指针对象所指对象内容 149 7.4.3 指针对象其他操作 150 7.5 多级指针 153 7.6 指向用户自定义类型指针 156 7.7 指针与数组关系 159 7.8 指向数组指针 162 7.9 void类型、指向void类型指针与空指针 165 7.10 字符数组与字符串字面量 167 7.11 完整与不完整类型 170 7.12 灵活数组成员 171 7.13 本章小结 173 第8章 C语言控制流语句 /174 8.1 逗号表达式 174 8.2 条件表达式 176 8.3 if-else语句 176 8.4 switch-case语句 179 8.5 while与do-while迭代语句 182 8.6 for迭代语句 187 8.7 goto语句 189 8.8 本章小结 192 第9章 C语言函数 /193 9.1 函数声明与定义 194 9.2 函数调用与实现 196 9.2.1 函数调用顺序点 197 9.2.2 函数栈空间 200 9.2.3 函数参数传递与返回 201 9.2.4 通过形参修改实参值 204 9.3 数组类型作为函数形参 205 9.4 带有不定参数类型及个数函数声明与调用 209 9.5 函数递归调用 212 9.6 内联函数 218 9.7 函数返回类型与无返回函数 221 9.8 指向函数指针 223 9.9 C语言主函数main 226 9.10 函数与函数调用作为sizeof操作符 228 9.11 本章小结 229 第10章 C语言预处理器 /230 10.1 宏定义 231 10.1.1 宏基本使用 232 10.1.2 宏定义中#操作符 234 10.1.3 宏定义中##操作符 236 10.1.4 宏替换 238 10.1.5 可变参数宏定义 240 10.2 C语言中预定义宏 243 10.2.1 C语言强制要求预定义宏 243 10.2.2 环境宏 244 10.2.3 条件特征宏 245 10.2.4 主流编译器及平台预定义宏 246 10.3 条件预编译 247 10.4 源文件包含预处理指示符 251 10.5 #error 预处理指示符 256 10.6 #line 预处理指示符 256 10.7 #undef 预处理指示符 257 10.8 pragma预编译指示符与操作符 258 10.9 空指示符与C语言程序注释 260 10.10 本章小结 262 第11章 C语言程序编译上下文 /263 11.1 C语言程序中作用域和名字空间 263 11.1.1 文件作用域 264 11.1.2 函数作用域 265 11.1.3 函数原型作用域 266 11.1.4 语句块作用域 267 11.1.5 标识符重定义与作用域叠交 269 11.1.6 标识符名字空间 272 11.2 全局对象与函数 275 11.3 静态对象与函数 277 11.4 局部对象 280 11.5 对象存储与生命周期 282 11.6 _Thread_local对象 285 11.7 本章小结 286 第三篇 高级语法篇 第12章 C语言类型限定符 /290 12.1 const限定符 290 12.1.1 const限定符修饰普通对象 291 12.1.2 const限定符修饰数组元素 293 12.1.3 const限定符修饰指针类型对象 294 12.1.4 const限定符修饰函数形参类型为数组对象 299 12.1.5 类型限定符本质含义 301 12.2 volatile限定符 302 12.3 restrict限定符 304 12.4 _Atomic限定符 307 12.5 本章小结 314 第13章 C语言类型系统 /316 13.1 对象类型与函数类型 316 13.2 对声明符进一步说明 318 13.3 更复杂声明 322 13.3.1 将某一类型转换为指向该类型指针 322 13.3.2 判定当前类型属于哪种对象类型 322 13.3.3 复杂复合类型判断 324 13.4 typedef类型定义 327 13.4.1 typedef一般使用 327 13.4.2 typedef与类型限定符相结合使用 330 13.4.3 用typedef来定义结构体与联合体类型 332 13.5 本章小结 335 第14章 C11标准中表达式、左值与求值顺序 /336 14.1 常量表达式 338 14.2 泛型选择表达式 340 14.3 静态断言 343 14.4 C语言左值 344 14.5 C语言中表达式求值顺序 348 14.6 C语言语句 352 14.7 本章小结 355 第15章 函数调用约定与ABI /356 15.1 Windows操作系统环境下x86处理器函数调用约定 357 15.1.1 Windows操作系统下32位x86执行模式函数调用约定 357 15.1.2 Windows操作系统下64位x86执行模式函数调用约定 363 15.2 Unix/Linux操作系统环境下x86处理器函数调用约定 368 15.3 ARM处理器环境下函数调用约定 370 15.3.1 AArch32架构环境下函数调用约定 370 15.3.2 AArch64架构环境下函数调用约定 373 15.4 本章小结 375 第16章 创建静态库与动态库 /376 16.1 Windows系统下创建静态库与动态库 377 16.1.1 Windows系统下创建并使用静态库 377 16.1.2 Windows系统上创建并使用动态库 379 16.2 macOS系统下创建静态库与动态库 382 16.2.1 macOS系统下创建并使用静态库 383 16.2.2 macOS系统下创建并使用动态库 386 16.3 Linux系统下创建并使用静态库与动态库 390 16.3.1 Linux系统下创建并使用静态库文件 390 16.3.2 Linux系统下创建并使用动态库 391 16.4 本章小结 393 第四篇 语法扩展篇 第17章 GCC对C11标准语法扩展 /396 17.1 在表达式中使用复合语句与声明 397 17.2 声明语句块作用域跳转标签 398 17.3 跳转标签作为值 401 17.4 嵌套函数 402 17.5 使用typeof来获取对象类型 405 17.6 使用__auto_type做类型自动推导 409 17.7 对复数操作扩展 411 17.8 半精度浮点类型 412 17.9 长度为零数组 413 17.10 对可变参数个数语法扩展 415 17.11 case语句中使用范围表达式 417 17.12 投射到一个联合体类型 418 17.13 使用二进制整数字面量 419 17.14 使用__attribute__指定函数、对象与类型属性 420 17.14.1 __attribute__用于修饰函数属性 422 17.14.2 __attribute__用于修饰对象属性 440 17.14.3 __attribute__用于修饰类型属性 443 17.15 本章小结 444 第18章 Clang编译器对C11标准扩展 /445 18.1 特征检查宏 446 18.2 _Nullable与_Nonnull 446 18.3 函数重载 448 18.4 Blocks语法 449 18.5 本章小结 462 第19章 对C语言未来展望 /463 19.1 C语言属性 465 19.2 fallthrough属性 466 19.3 数组片段 467 19.3.1 数组片段赋值操作 468 19.3.2 数组片段算术计算操作 470 19.3.3 数组片段用于函数调用情况 471 19.4 其他语法特性 472 19.5 本章小结 472 第五篇 项目实践篇 第20章 制作UTF-8与UTF-16编码字符串转码器 /474 20.1 UTF-8字符编码格式 474 20.2 UTF-16字符编码格式 476 20.3 代码示例 478 20.4 本章小结 487 第21章 制作控制台计算器 /488 21.1 对数字解析 489 21.2 对操作符优先级处理 489 21.3 代码示例 491 21.4 本章小结 504
这本书很良心啊但是目前都是些PDFepub扫描版什么。这个版本是原版mobi随便用kindle还是电脑都很方便阅读随便复制修改粘贴。 阅读建议:本书从基础到高级全面而深入不同层次读者可选择适合自己章节阅读参见前言“如何阅读本书”模块。 预备知识篇(第1~3章)为初级读者提供计算机理论知识和相关概念如编程模式、主流开源编译器以及搭建C编程环境方法。 基础语法篇(第4~11章)学习C语言基石——基本语法与使用讲解涵盖基本元素、基本数据类型、用户自定义类型、数组和指针(难点)、控制流语句、函数。 高级语法篇(第12~16)讲述了C11编程一些高级特性进阶之用。涵盖: 目前所支持所有预处理器特性; 编译上下文作用域、名字空间、连接属性; C11标准支持类型限定符标准用法与注意事项; 深刻解读C语言语法体系核心——类型系统; C11标准中表达式及其计算优先级以及“左值”; 主流编译器所采用函数调用约定; 主流C语言编译工具构建静态库/动态库方法与实践。 语法扩展篇(第17~19章)讲述了GCC与Clang编译器对C语言扩展以及C语言设计理念、未来C语言新添与排除特性。需要对底层交互与开发深入了解读者大有裨益。 项目实践篇(第20~21章)UTF-8与UTF-16编码程序编写基于控制台计算器程序。精巧而知识点全面。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值