#include <iostream>

using namespace std;

class BST
{
public:
    BST()
    {
        i = 0;
    }
    int i;
};

class BalancedBST: public BST
{
private:
    int j;
};

void printBSTArray(ostream& out, const BST arr[], int numElements)
{
    for (int i = 0; i < numElements; i++)
    {
        out << arr[i].i << endl;
    }
}

int main()
{
    cout << "BST.\n";
    BST BSTArray[10];
    printBSTArray(cout, BSTArray, 10);

    cout << "BalancedBST.\n";
    BalancedBST bBSTArray[10];
    printBSTArray(cout, bBSTArray, 10);

    system("pause");

    return 0;
}

其结果如下：

 

 可以看到程序并不如我们所期望的那样，这说明什么呢？
 arr[i],表示的是*（arr+i）,但是arr+i所指向的地址偏离arr所指向的地址是i*(an object in the array)。
因为参数被声明为BST数组类型，那么数组的每个元素必须是BST，那么它们的间隔也毕定是i*sizeof(BST)。如果传入BalancedBST数组，编译器可能就会犯错误，在这种情况下，编译器就会假定数组里每个对象的大小都和BST的大小一样。而通常派生类要比基类有更多的成员变量，所以派生类一般都比基类对象大。所以我们就看到了如上的结果。

 试图通过一个基类指针删除一个包含派生类对象的数组，也会有同样的问题。

所以不要把多台应用到数组上，还是很有好处的。

去同学那玩，看到这么一本书《C++沉思录》。这本书很早听过，但是没有读过。于是捧起书读了几章，感觉很是不错。其中第四章就是讲“类设计者的核查表”。虽然用c++有几年，但是有一些东西还是需要铭记于心的。

类设计者的核查表

一、        您的类需要一个构造函数么？

有些类太简单，无需构造函数，但有些类太复杂，他们需要构造函数来隐藏它们的内部工作方式。

二、           您的数据成员是私有的么？

通常使用公有的数据成员不是什么好事，因为类设计者无法控制何时访问这些成员。

三、           您的类需要一个无参的构造函数么？

如果一个类已经有了构造函数，想声明该类的对象可以不必显示地初始化它们，则必须显示地写一个无参的构造函数。

四、           是不是每一个构造函数初始化所有的数据成员？

构造函数的用途就是用一种明确定义的状态来设置对象。对象的状态由对象的数据成员进行反映。每个构造函数都要负责为所有的数据成员设置经过明确定义的值。

有时这种说法也未必总是正确的。有时，类会有一些数据成员，它们只在它们的对象存在了一定时间之后才有意义。提这个问题，只是激励你进行思考。

五、           类需要构造函数么？

不是所有有构造函数的类都需要构造函数。如果深入考虑一个类要做些什么，那么该类是否需要析构函数的问题就十分明显了。应该问一问该类是否分配了资源，而这些资源又不会有成员函数自动释放，这就足够了。特别是那些构造函数里包含了new表达式的类，通常要在析构函数中加上相应的delete表达式，所以需要一个虚析构函数。

六、        类需要一个虚析构函数么？

有些类需要虚析构函数只是为了声明他们的析构函数是虚的。当然，决不会用做基类的类是不需要虚析构函数的：任何虚函数只在继承的情况下才有用。

虚析构函数通常是空的。

七、           你的类需要复制构造函数么？

很多时候答案都是“不”，但是有时候答案是“是”。关键在于复制该类对象是否就相当于复制其数据成员和基类对象。如果并不相当，就需要复制构造函数。

如果你的类在构造函数内分配资源，则可能需要一个显示的复制构造函数来管理资源。有析构函数的类通常是析构函数来释放构造函数分配的资源，这通常说明需要一个复制构造函数。（空的虚析构函数除外）

如果不想用户能够复制该类的对象，就声明复制构造函数为私有的。如果其他的成员不会使用这些成员函数，声明就足够了，没有必要定义它们。

八、           你的类需要一个赋值操作么？

如果需要复制构造函数，同理多半也会需要一个赋值操作。

九、           你的赋值操作符能正确地将对象赋给对象本身么？

赋值总是用新值取代目标对象的旧值。如果原对象和目标对象是同一个，而我们又奉行“先释放旧值，再复制”的行事规程，那么就可能在还没有实施复制之前就把原对象销毁了。

十、           你的类需要定义关系操作符么？

如果你的类逻辑上支持相等操作，那么提供operate== 和operate!=可能会有好处。类似的，如果你的类的值有某种排序关系，那就可能会想提供余下的关系操作符。只要它们想创建你的类型的有序集合，你就必须提供关系操作符。

十一  删除数组时你记住了用delete[]么？

这个形式的存在，是C++希望在保持与C的兼容性的同时关注效率。C++要求用户告知要被删除的是不是数组。如果是，该实现就可能会提供另一个地方来存储长度，因为与数组所需的内存量相比，这个常数的开销会小很多。

十二   记得在复制构造函数和赋值操作符的参数类型中加上了const么？

复制构造函数应该是像X::X(const X&)这样，毕竟复制对象不会改变原对象。实际上，由于绑定一个非const引用到一个临时对象是非法的，使用X::X(X&)作为复制构造函数不会允许复制任何特殊表达式的结果。同样道理适用于赋值。

十三   如果函数有引用参数，它们应该是const引用么？

只有当函数想改变参数时，它才应该有不用const声明的引用参数。

        计算阶段由构造函数体内的所有语句构成。在计算阶段中，数据成员的设置被认为是赋值，而不是初始化。

使用初始化列表有两个原因：

1.必须这样做：

        三种情况下需要使用初始化成员列表
        1）对象成员；
        2）const修饰的成员；
        3）引用成员数据；

(1)如果有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，而没有默认构造函数，这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，如果没有初始化列表，那么他将无法完成第一步，就会报错。

using namespace std;
class ABC
{
public:
    ABC(int x,int y,int z):a(x),b(y),c(z){};
private:
  int a;
    int b;
    int c;
};
class MyClass
{
public:
    MyClass(int a,int b,int c):abc(a,b,c){}
private:
    ABC abc;
};

int main()
{
    MyClass o(1,2,3);
    return 0;
}

(2)当类成员中含有一个const成员时

(3)当类成员中含有一个引用时

#include<iostream>
using namespace std;

class ConstRef {
public:
    ConstRef(int i);
    void print();
private:
    int a;
    const int b;//const成员
    int &c;//引用
};

ConstRef::ConstRef(int i):b(i),c(a)//含有一个const对象时，或者是一个引用时使用初始化成员列表
{
    a = i;       // ok
    //b = i;         // 错误
    //c = a;       // 错误
}
void ConstRef::print()
{
    cout<<a<<endl;
    cout<<b<<endl;
    cout<<c<<endl;
}
int main()
{
    ConstRef o(1);
    o.print();
    return 0;
}

2.效率要求这样做：

类对象的构造顺序显示，进入构造函数体后，进行的是计算，是对他们的赋值操作，显然，赋值和初始化是不同的，这样就体现出了效率差异，如果不用成员初始化列表，那么类对自己的类成员分别进行的是一次隐式的默认构造函数的调用，和一次复制操作符的调用，如果是类对象，这样做效率就得不到保障。

注意：构造函数需要初始化的数据成员，不论是否显式的出现在构造函数的成员初始化列表中，都会在该处完成初始化，并且初始化的顺序和其在声明时的顺序是一致的，与列表的先后顺序无关，所以要特别注意，保证两者顺序一致才能真正保证其效率。

现在明白为什么要使用成员初始化列表了。

这里再强调一下类的初始化的顺序，应该是类成员变量的初始化不是按照初始化表的顺序被初始化的，而是按照在类中声明的顺序被初始化的。
这是摘自：Effective C++学习笔记：初始化列表中成员列出的顺序和它们在类中声明的顺序相同 http://www.cppblog.com/xczhang/archive/2008/01/22/41613.html

为什么会这样呢？我们知道，对一个对象的所有成员来说，它们的析构函数被调用的顺序总是和它们在构造函数里被创建的顺序相反。那么，如果允许上面的情况（即，成员按它们在初始化列表上出现的顺序被初始化）发生，编译器就要为每一个对象跟踪其成员初始化的顺序，以保证它们的析构函数以正确的顺序被调用。这会带来昂贵的开销。所以，为了避免这一开销，同一种类型的所有对象在创建（构造）和摧毁（析构）过程中对成员的处理顺序都是相同的,而不管成员在初始化列表中的顺序如何。

注意：上述内容不适用于static变量，static变量应该在类的构造函数前被初始化。

好文章拿来学习，请作者见谅哈！

    以下为引用：

 // Global variable
 CRITICAL_SECTION CriticalSection;

 void main()
 {
     ...

     // Initialize the critical section one time only.
     if (!InitializeCriticalSectionAndSpinCount(&CriticalSection, 0x80000400) )
         return;
     ...

     // Release resources used by the critical section object.
     DeleteCriticalSection(&CriticalSection)
 }

 DWORD WINAPI ThreadProc( LPVOID lpParameter )
 {
     ...

     // Request ownership of the critical section.
     EnterCriticalSection(&CriticalSection);

     // Access the shared resource.

     // Release ownership of the critical section.
     LeaveCriticalSection(&CriticalSection);

     ...
 }

     首先看看构造和析构临界区结构的函数。
     InitializeCriticalSection 函数(ntosdll esource.c:1210)实际上是调用 InitializeCriticalSectionAndSpinCount 函数(resource.c:1266)完成功能的，只不过传入一个值为0的初始Spin计数器；InitializeCriticalSectionAndSpinCount 函数主要完成两部分工作：初始化 RTL_CRITICAL_SECTION 结构和 RTL_CRITICAL_SECTION_DEBUG 结构。前者是临界区的核心结构，下面将着重讨论；后者是调试用结构，Matt 那篇文章里面分析的很清楚了，我这儿就不罗嗦了 :P
     RTL_CRITICAL_SECTION结构在winnt.h中定义如下：

以下为引用：

 typedef struct _RTL_CRITICAL_SECTION {
     PRTL_CRITICAL_SECTION_DEBUG DebugInfo;

     //
     //  The following three fields control entering and exiting the critical
     //  section for the resource
     //

     LONG LockCount;
     LONG RecursionCount;
     HANDLE OwningThread;        // from the thread''s

ClientId->UniqueThread
     HANDLE LockSemaphore;
     ULONG_PTR SpinCount;        // force size on 64-bit systems when packed
 } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;

     InitializeCriticalSectionAndSpinCount 函数中首先对临界区结构进行了初始化

     DebugInfo 字段指向初始化临界区时分配的RTL_CRITICAL_SECTION_DEBUG结构；
     LockCount 字段是临界区中最重要的字段，初始值为-1，当临界区被获取(Hold)时此字段大于等于0；
     RecursionCount 字段保存当前临界区所有者线程的获取缓冲区嵌套层数，初始值为0；
     OwningThread 字段保存当前临界区所有者线程的句柄，初始值为0；
     LockSemaphore 字段实际上是一个auto-reset的事件句柄，用于唤醒等待获取临界区的阻塞线程，初始值为0；
     SpinCount 字段用于在多处理器环境下完成轻量级的CPU见同步，单处理器时没有使用（初始值为0），多处理器时设置为SpinCount参数值（最大为MAX_SPIN_COUNT=0x00ffffff）。此外 RtlSetCriticalSectionSpinCount 函数(resource.c:1374)的代码与这儿设置SpinCount的代码完全一样。

     初始化临界区结构后，函数会根据SpinCount参数的一个标志位判断是否需要预先初始化 LockSemaphore 字段，如果需要则使用NtCreateEvent创建一个具有访问权限的同步用事件核心对象，初始状态为没有激发。这一初始化本来是在 EnterCriticalSection 函数中完成的，将之显式提前可以进一步优化 EnterCriticalSection 函数的性能。
     值得注意的是，这一特性仅对Win2k有效。MSDN里面说明如下：

以下为引用：

 Windows 2000:  If the high-order bit is set, the function preallocates the event used by the EnterCriticalSection function. Do not set this bit if you are creating a large number of critical section objects, because it will consume a significant amount of nonpaged pool. This flag is not necessary on Windows XP and later, and it is ignored.

     与之对应的 DeleteCriticalSection 函数完成关闭事件句柄和是否调试结构的功能。

     临界区真正的核心代码在win2kprivate tosdlli386critsect.asm里面，包括_RtlEnterCriticalSection、_RtlTryEnterCriticalSection和_RtlLeaveCriticalSection三个函数。

     _RtlEnterCriticalSection 函数 (critsect.asm:85) 首先检查SpinCount是否为0，如果不为0则处理多处理器架构下的问题[分支1]；如为0则使用原子操作给LockCount加一，并判断是否其值为0。如果加一后LockCount大于0，则此临界区已经被获取[分支2]；如为0则获取当前线程TEB中的线程句柄，保存在临界区的OwningThread字段中，并将RecursionCount设置为1。调试版本则调用RtlpCriticalSectionIsOwned函数在调试模式下验证此缓冲区是被当前线程获取的，否则在调试模式下激活调试器。最后还会更新TEB的CountOfOwnedCriticalSections计数器，以及临界区调试结构中的EntryCount字段。
     如果此临界区已经被获取[分支2]，则判断获取临界区的线程句柄是否与当前线程相符。如果是同一线程则直接将RecursionCount和调试结构的EntryCount字段加一；如果不是当前线程，则调用RtlpWaitForCriticalSection函数等待此临界区，并从头开始执行获取临界区的程序。
     多CPU情况的分支处理方式类似，只是多了对SpinCount的双重检查处理。

     接着的_RtlTryEnterCriticalSection(critsect.asm:343)函数是一个轻量级的尝试获取临界区的函数。伪代码如下：

以下为引用：

 if(CriticalSection->LockCount == -1)
 {
   // 临界区可用
   CriticalSection->LockCount = 0;
   CriticalSection->OwningThread = TEB->ClientID;
   CriticalSection->RecursionCount = 1;

   return TRUE;
 }
 else
 {
   if(CriticalSection->OwningThread == TEB->ClientID)
   {
     // 临界区是当前线程获取
     CriticalSection->LockCount++;
     CriticalSection->RecursionCount++;

     return TRUE;
   }
   else
   {
     // 临界区已被其它线程获取
     return FALSE;
   }
 }
 
 

     最后的_RtlLeaveCriticalSection(critsect.asm:271)函数释放已获取的临界区，实现就比较简单了，实际上就是对嵌套计数器和锁定计数器进行操作。伪代码如下：

以下为引用：

 if(--CriticalSection->RecursionCount == 0)
 {
bsp;  // 临界区已不再被使用
   CriticalSection->OwningThread = 0;
 

   if(--CriticalSection->LockCount)
   {
     // 仍有线程锁定在临界区上
     _RtlpUnWaitCriticalSection(CriticalSection)
   }
 }
 else
 {
   --CriticalSection->LockCount
 }

        一般用法：使用“#”把宏参数变为一个字符串，用”##”把两个宏参数结合在一起

       例子：

#include <iostream>
using namespace std;

#define TEST1(x) (cout<<id##x<<endl);
#define TEST2(p) (cout<<#p<<endl);
int main()
{
    int id1 = 1001;
    int id2 = 1002;
    TEST1(1);    // == cout<< id1 << endl;
    TEST2(2);    // == cout<< "2" << endl;
    TEST1(2);    // == cout<< id2 << endl;

    system("pause");
    return 0;
}

1.引言
C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C语言的全局变量和函数所采用的编译和连接方式与C语言完全相同。作为一种欲与C兼容的语言，C++保留了一部分过程式语言的特点（被世人称为“不彻底地面向对象”），因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同。
2.从标准头文件说起

某企业曾经给出如下的一道面试题：
面试题:为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
分析
显然，头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。
那么
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
的作用又是什么呢？我们将在下文一一道来。

3.深层揭密extern "C"

extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。
被extern "C"限定的函数或变量是extern类型的；
extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：
extern int a;
仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数。
与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。
被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；
未加extern “C”声明时的编译方式
首先看看C++中对类似C的函数是怎样编译的。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );
该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。
foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。
未加extern "C"声明时的连接方式
假设在C++中，模块A的头文件如下：
// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在模块B中引用该函数：
// 模块B实现文件　moduleB.cpp
#include "moduleA.h"
foo(2,3);

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！
加extern "C"声明后的编译和连接方式
加extern "C"声明后，模块A的头文件变为：
// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：
（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；
（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。
如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。
所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：
实现C++与C及其它语言的混合编程。

明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。

4.extern "C"的惯用法
（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：
extern "C"
{
#include "cExample.h"
}
而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。
笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：
/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
#include "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++实现文件，调用add：cppFile.cpp
extern "C"
{
#include "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。
（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C实现文件 cFile.c
/* 这样会编译出错：#include "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。

作者：José M. Aguilar（西班牙语）
英文译者：Timm Martin
中文译者：numenzq

下面的13个技巧向你展示如何添加代码注释，这些技巧都很容易理解和记忆。

1. 逐层注释
为每个代码块添加注释，并在每一层使用统一的注释方法和风格。例如：
针对每个类：包括摘要信息、作者信息、以及最近修改日期等
针对每个方法：包括用途、功能、参数和返回值等
在团队工作中，采用标准化的注释尤为重要。当然，使用注释规范和工具（例如C#里的XML，Java里的Javadoc）可以更好的推动注释工作完成得更好。
2. 使用分段注释
如果有多个代码块，而每个代码块完成一个单一任务，则在每个代码块前添加一个注释来向读者说明这段代码的功能。例子如下：

// Check that all data records
// are correct
foreach (Record record in records)
{
if (rec.checkStatus()==Status.OK)
{
. . .
}
}
// Now we begin to perform
// transactions
Context ctx = new ApplicationContext();
ctx.BeginTransaction();
. . .

3. 在代码行后添加注释
如果多行代码的每行都要添加注释，则在每行代码后添加该行的注释，这将很容易理解。例如：

const MAX_ITEMS = 10; // maximum number of packets
const MASK = 0x1F;    // mask bit TCP

在分隔代码和注释时，有的开发者使用tab键，而另一些则使用空格键。然而由于tab键在各编辑器和IDE工具之间的表现不一致，因此最好的方法还是使用空格键。

4. 不要侮辱读者的智慧

避免以下显而易见的注释：

if (a == 5)      // if a equals 5
counter = 0; // set the counter to zero

写这些无用的注释会浪费你的时间，并将转移读者对该代码细节的理解。

5. 礼貌点
避免粗鲁的注释，如：“注意，愚蠢的使用者才会输入一个负数”或“刚修复的这个问题出于最初的无能开发者之手”。这样的注释能够反映到它的作者是多么的拙劣，你也永远不知道谁将会阅读这些注释，可能是：你的老板，客户，或者是你刚才侮辱过的无能开发者。

6. 关注要点

不要写过多的需要转意且不易理解的注释。避免ASCII艺术，搞笑，诗情画意，hyperverbosity的注释。简而言之，保持注释简单直接。

7. 使用一致的注释风格
一些人坚信注释应该写到能被非编程者理解的程度。而其他的人则认为注释只要能 被开发人员理解就行了。无论如何，Successful Strategies for Commenting Code已经规定和阐述了注释的一致性和针对的读者。就个人而言，我怀疑大部分非编程人员将会去阅读代码，因此注释应该是针对其他的开发者而言。

8. 使用特有的标签
在一个团队工作中工作时，为了便于与其它程序员沟通，应该采用一致的标签集进行注释。例如，在很多团队中用TODO标签表示该代码段还需要额外的工作。

int Estimate(int x, int y)
{
// TODO: implement the calculations
return 0;
}

注释标签切忌不要用于解释代码，它只是引起注意或传递信息。如果你使用这个技巧，记得追踪并确认这些信息所表示的是什么。

9. 在代码时添加注释
在写代码时就添加注释，这时在你脑海里的是清晰完整的思路。如果在代码最后再添 加同样注释，它将多花费你一倍的时间。而“我没有时间写注释”，“我很忙”和“项目已经延期了”这都是不愿写注释而找的借口。一些开发者觉得应该 write comments before code，用于理清头绪。例如：
public void ProcessOrder()
{
// Make sure the products are available
// Check that the customer is valid
// Send the order to the store
// Generate bill
}

10. 为自己注释代码

当注释代码时，要考虑到不仅将来维护你代码的开发人员要看，而且你自己也可能要看。用Phil Haack大师的话来说就是：“一旦一行代码显示屏幕上，你也就成了这段代码的维护者”。因此，对于我们写得好（差）的注释而言，我们将是第一个受益者（受害者）。

11. 同时更新代码和注释

如果注释没有跟随代码的变化而变化，及时是正确的注释也没有用。代码和注释应该同步变化，否则这样的注释将对维护你代码的开发者带来更大的困难。使用重构工具时应特别注意，它只会自动更新代码而不会修改注释，因此应该立即停止使用重构工具。

12. 注释的黄金规则：易读的代码
对于开发者的一个基本原则就是：让你的代码为己解释。虽然有些人怀疑这会让那些不愿意写注释的开发者钻空子，不过这样的代码真的会使你容易理解，还不需要额外维护注释。例如在Fluid Interfaces文章里向你展示的代码一样：

Calculator calc = new Calculator();
calc.Set(0);
calc.Add(10);
calc.Multiply(2);
calc.Subtract(4);
Console.WriteLine( "Result: {0}", calc.Get() );

在这个例子中，注释是不需要的，否则可能就违反了技巧4。为了使代码更容易理解，你可以考虑使用适当的名字 （Ottinger's Rules里讲解得相当好），确保正确的缩进，并且采用coding style guides，违背这个技巧可能的结果就像是注释在为不好的代码apologize。

13. 与同事分享技巧
虽然技巧10已经向我们表明了我们是如何从好的注释中直接受益，这些技巧将让所有开发者受益，特别是团队中一起工作的同事。因此，为了编写出更容易理解和维护的代码，尝试自由的和你的同事分享这些注释技巧。

下面摘自http://www.cppblog.com/woaidongmao/archive/2008/11/03/65897.html

看到他们的在争论很有意思，我不是很懂。

有利还是有弊呢？

EXT_ASSERT将ASSERT与if结合在一起

posted on 2008-11-03 23:34 肥仔 阅读(333) 评论(7)  编辑 收藏 引用 所属分类: C++存档