国产精品系列在线,91久久午夜,欧美www在线

Fox — Tue, 22 Dec 2009 18:18:00 GMT

摘要: 从接触和使用make以来�Q�前前后后写了不��Makefile�Q�添��d��减、修修补补，累计上千行是有的�Q�，今天在重新整理代码的�l�织�l�构之后�Q�突然就惻I��我�ؓ什么不使用Autotools呢？

在开始体验功能强大的Autotools之前�Q�简单（详细�Q�回忆�ȝ��一下我使用make的经历和思考的�q�程�Q�反省一下看看自己在接触�q�些新鲜事物的时候到底走了多��弯路�?nbsp; 阅读全文

Fox 2009-12-23 02:18 发表评论

Fox — Mon, 21 Sep 2009 16:38:00 GMT

本文同步�?a target="_blank">游戏人生

以前曄��讨论�q?a target="_blank">Singleton的实�?/a>�Q�这�ơ在对照ACE和Boost代码的时候，又重新审视了一下二者对Singleton不同的实现。其间的差别也体��C��不同的编�E�哲学：ACE的实现更加偏重多�U�程中的安全和效率问题；Boost的实现则偏重于��用语�a�自��n的特性满��Singleton模式的基本需求�?

o ACE的实�?/strong>

Douglas C. Schmidt�?a target="_blank">Double-Checked Locking: An Optimization Pattern for Efficiently Initializing and Accessing Thread-safe Objects一文中对double-check lock�Q�一般译为双��锁）�q�行了详�l�的阐述�?

ACE的Singleton使用Adapter模式实现对其他类的适配�Q��之具有全局唯一的实例。由于C++标准�q��明确指定全局静态对象的初始化顺序，ACE使用double-check lock保证�U�程安全�Q��ƈ使之不受全局静态对象初始化��序的媄响，同时也避免了全局静态实现方式的初始化后不��用的开销�?

如果你能够准��的区分以下三种实现的弊端和隐患�Q�对double-check lock也就有了��_��的了解�?

// ------------------------------------------- class Singleton { public: static Singleton *instance (void) { // Constructor of guard acquires // lock_ automatically. Guard guard (lock_); // Only one thread in the // critical section at a time. if (instance_ == 0) instance_ = new Singleton; return instance_; // Destructor of guard releases // lock_ automatically. } private: static Mutex lock_; static Singleton *instance_; }; // --------------------------------------------- static Singleton *instance (void) { if (instance_ == 0) { Guard guard (lock_); // Only come here if instance_ // hasn’t been initialized yet. instance_ = new Singleton; } return instance_; } // --------------------------------------------- class Singleton { public: static Singleton *instance (void) { // First check if (instance_ == 0) { // Ensure serialization (guard // constructor acquires lock_). Guard guard (lock_); // Double check. if (instance_ == 0) instance_ = new Singleton; } return instance_; // guard destructor releases lock_. } private: static Mutex lock_; static Singleton *instance_; };

更多详情�Q�见Schmidt老师的原文和ACE_Singleton实现�?
o Boost的实�?/strong>
Boost的Singleton也是�U�程安全的，而且没有使用锁机制。当�Ӟ��Boost的Singleton有以下限�Ӟ��遵从�q�些限制�Q�可以提高效率）�Q?
o The classes below support usage of singletons, including use in program startup/shutdown code, AS LONG AS there is only one thread running before main() begins, and only one thread running after main() exits.
o This class is also limited in that it can only provide singleton usage for classes with default constructors.
// T must be: no-throw default constructible and no-throw destructible template struct singleton_default { private: struct object_creator { // This constructor does nothing more than ensure that instance() // is called before main() begins, thus creating the static // T object before multithreading race issues can come up. object_creator() { singleton_default::instance(); } inline void do_nothing() const { } }; static object_creator create_object; singleton_default(); public: typedef T object_type; // If, at any point (in user code), singleton_default::instance() // is called, then the following function is instantiated. static object_type & instance() { // This is the object that we return a reference to. // It is guaranteed to be created before main() begins because of // the next line. static object_type obj; // The following line does nothing else than force the instantiation // of singleton_default::create_object, whose constructor is // called before main() begins. create_object.do_nothing(); return obj; } }; template typename singleton_default::object_creator singleton_default::create_object;

对于多数Singleton使用�Q�Boost提供的版本完全能够满��需求。�ؓ了效率，我们有必要对其��用作��Z��定的限制�?/p>
而在多线�E�编�E�中�Q�则有必要��用double-check lock降低频繁加锁带来的开销�?/p>
-------------------------------------------------------------------------------

PS: �ƣ赏Soft的一句话�Q?strong>�l�得赯��惑，耐得住寂�?/strong>�?/p>

Fox 2009-09-22 00:38 发表评论

IOCP使用时常见的几个错误

Fox — Fri, 11 Sep 2009 16:20:00 GMT

本文同步�?a target="_blank">游戏人生

在��用IOCP�Ӟ��最重要的几个API��是GetQueueCompeltionStatus、WSARecv、WSASend�Q�数据的I/O及其完成状态通过�q�几个接口获取�ƈ�q�行后箋处理�?/p>
GetQueueCompeltionStatus attempts to dequeue an I/O completion packet from the specified I/O completion port. If there is no completion packet queued, the function waits for a pending I/O operation associated with the completion port to complete.
BOOL WINAPI GetQueuedCompletionStatus( __in HANDLE CompletionPort, __out LPDWORD lpNumberOfBytes, __out PULONG_PTR lpCompletionKey, __out LPOVERLAPPED *lpOverlapped, __in DWORD dwMilliseconds );

If the function dequeues a completion packet for a successful I/O operation from the completion port, the return value is nonzero. The function stores information in the variables pointed to by the lpNumberOfBytes, lpCompletionKey, and lpOverlapped parameters.

除了兛_��q�个API的in & out�Q�这是MSDN开头的几行��可以告诉我们的�Q�之外，我们更加兛_��不同的return & out意味着什么，因�ؓ�׃��各种已知或未知的原因�Q�我们的�E�序�q�不��L��有正��的return & out�?/p>
If *lpOverlapped is NULL and the function does not dequeue a completion packet from the completion port, the return value is zero. The function does not store information in the variables pointed to by the lpNumberOfBytes and lpCompletionKey parameters. To get extended error information, call GetLastError. If the function did not dequeue a completion packet because the wait timed out, GetLastError returns WAIT_TIMEOUT.

假设我们指定dwMilliseconds为INFINITE�?/p>
�q�里常见的几个错误有�Q?/p>
WSA_OPERATION_ABORTED (995): Overlapped operation aborted.

�׃��U�程退出或应用�E�序��h��Q�已攑ּ�I/O 操作�?/p>
MSDN: An overlapped operation was canceled due to the closure of the socket, or the execution of the SIO_FLUSH command in WSAIoctl. Note that this error is returned by the operating system, so the error number may change in future releases of Windows.

成因分析�Q�这个错误一般是�׃��peer socket�?strong>closesocket或�?strong>WSACleanup关闭后，针对�q�些socket的pending overlapped I/O operation被中止�?/p>

解决�Ҏ���Q�针对socket�Q�一般应该先调用shutdown��止I/O操作后再调用closesocket关闭�?/p>

严重�E�度�Q?strong>��d��易处�?/strong>�?/p>

WSAENOTSOCK (10038): Socket operation on nonsocket.

MSDN: An operation was attempted on something that is not a socket. Either the socket handle parameter did not reference a valid socket, or for select, a member of an fd_set was not valid.

成因分析�Q�在一个非套接字上��试了一个操作�?/p>

使用closesocket关闭socket之后�Q�针对该invalid socket的�Q何操作都会获得该错误�?/p>

解决�Ҏ���Q�如果是多线�E�存在对同一socket的操作，要保证对socket的I/O操作逻辑上的��序�Q�做好socket的graceful disconnect�?/p>

严重�E�度�Q?strong>��d��易处�?/strong>�?/p>

WSAECONNRESET (10054): Connection reset by peer.

�q�程��L��关闭了一个现有的�q�接�?/p>

MSDN: An existing connection was forcibly closed by the remote host. This normally results if the peer application on the remote host is suddenly stopped, the host is rebooted, the host or remote network interface is disabled, or the remote host uses a hard close (see setsockopt for more information on the SO_LINGER option on the remote socket). This error may also result if a connection was broken due to keep-alive activity detecting a failure while one or more operations are in progress. Operations that were in progress fail with WSAENETRESET. Subsequent operations fail with WSAECONNRESET.

成因分析�Q�在使用WSAAccpet、WSARecv、WSASend�{�接口时�Q�如果peer application�H�然中止�Q�原因如上所�q�ͼ��Q�往其对应的socket上投递的operations��会��p�|�?/p>

解决�Ҏ���Q�如果是�Ҏ��L��或程序意外中止，那就只有各安天命了。但如果�q�程序是你写的，而你只是hard close�Q�那��q��不得别�h了。至��，你要知道�q�样的错误已�l�出��C��Q�就不要再费劲的�l�箋投递或�{�待了�?/p>

严重�E�度�Q?strong>��d��易处�?/strong>�?/p>

WSAECONNREFUSED (10061): Connection refused.

�׃��目标机器�U�极拒绝�Q�无法连接�?/p>

MSDN: No connection could be made because the target computer actively refused it. This usually results from trying to connect to a service that is inactive on the foreign host—that is, one with no server application running.

成因分析�Q�在使用connect或WSAConnect�Ӟ��服务器没有运行或者服务器的监听队列已满；在��用WSAAccept�Ӟ��客户端的�q�接��h��被condition function拒绝�?/p>

解决�Ҏ���Q�Call connect or WSAConnect again for the same socket. �{�待服务器开启、监听空闲或查看被拒�l�的原因�?strong>是不是长的丑或者钱没给够，要不��是服务器拒�l�接受天仯��酬自��d��业去了？

严重�E�度�Q?strong>��d��易处�?/strong>�?/p>

WSAENOBUFS (10055): No buffer space available.

�׃��pȝ��~�冲区空间不��x��列队已满�Q�不能执行套接字上的操作�?/p>

MSDN: An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full.

成因分析�Q�这个错误是我查看错误日志后�Q�最在意的一个错误。因为服务器对于消息收发有明��限�Ӟ��如果�~�冲��Z��_��该早��处理了�Q�不可能待到send/recv��p�|啊。而且�q�个错误在之前的版本中几乎没有出现过。这也是�q�篇文章的主要内宏V��像connect和accept因�ؓ�~�冲区空间不��都可以理解�Q�而且危险不高�Q�但如果send/recv造成拥堵�q�恶性��@环下去，�ȝ��大了，臛_��说明之前的验证逻辑有疏漏�?/p>

WSASend��p�|的原因是�Q�The Windows Sockets provider reports a buffer deadlock. �q�里提到的是buffer deadlock�Q�显然是�׃��多线�E�I/O投递不当引��L��?/p>

解决�Ҏ���Q�在消息收发前，�Ҏ��大挂��L��消息�ȝ��数量和容量进行检验和控制�?/p>

严重�E�度�Q?strong>严重�?/p>

本文主要参�?a target="_blank">MSDN�?/p>

************* 说明 *************

Fox只是对自己关心的几个错误和API参照MSDN�q�行分析�Q�不提供额外帮助�?/p>

Fox 2009-09-12 00:20 发表评论

Amdahl 定律 = Gustafson定律

Fox — Thu, 10 Sep 2009 04:04:00 GMT

本文同步�?a target="_blank">游戏人生

周伟明老师应该是多核计��领域的老�h了�?/p>

�q�几日因为想找找无锁�Q�lock-free�Q�方面的信息�Q�就打开�?a target="_blank">周老师的blog。看�?a target="_blank">多核�pȝ��中三�U�典型锁竞争的加速比分析�q�篇文章�Ӟ��觉得老师��多核计算效率是有必要的，但拿Amdahl 定律和Gustafson定律作对比有点不恰当�?/p>

按照我的理解�Q�这两个定律所�ȝ��的内�Ҏ��完全一致的�Q�只是对加速比的定义不一��LŞ了。这里，我们都以S(n)表示n核系�l�对具体�E�序的加速比�Q�K表示串行部分计算旉��比例�?/p>

Amdahl 定律的加速比�Q�S(n) �Q?使用1个处理器的串行计��时�?/ 使用n个处理器的�ƈ行计��时�?/p>

S(n) = 1/(K+(1-K)/n) = n/(1+(n-1)K)

Gustafson定律的加速比�Q�S(n) �Q?使用n个处理器的�ƈ行计��量 / 使用1个处理器的串行计��量

S(n) = K+(1-K)n

通俗的讲�Q�Amdahl 定律��工作量看作1�Q�有n�怹�只能分担1-K的工作量�Q�而Gustafson定律则将单核工作量看�?�Q�有n核，��可以增加n(1-K)的工作量�?/p>

�q�两个计��公式都没有��锁开销考虑在内�Q�是理想化的。周老师提到设计不当造成�q�行变串行的问题与这两个公式计算无关。因��Z�Q何多核计��都存在对串行和�q�行的设计考量�Q�这正是�E�序员在使用多核�q�行时最兛_��的事情�?/p>

��M��Q�二者的区别只在于态度的不同：一个消极悲观，一个积极乐观，充其量是一个冷�W�话�Q�而于多核计算没有��M��兌��?/p>

我说�q�些也与多核计算没有兌��Q�丝毫没有质疑多核效率的意思。相反，我期待能够通过技术层面提高多核的有效负蝲�?/p>最后一句题外话�Q�周老师使用Word的水�q�一般：所有来自Word的截��N��是在��面视图直接截，换行�W�和光标随处可见�?img src ="http://www.shnenglu.com/Fox/aggbug/95782.html" width = "1" height = "1" />

Fox 2009-09-10 12:04 发表评论

Fox — Tue, 01 Sep 2009 06:22:00 GMT

本文同步�?a target="_blank">游戏人生

o *__ �?__* o

在阅读ACE代码和C++NPv1, v2, APG的时候，我意识到一个问题：虽然�E�有C++和网�l�基��的同学都可以��L��ACE�Q�但如果你对OS�Q�五大管理模块都包含在内�Q�、TCP/IP、C++、Design Patterns了解��多�Q�你��p��能体会ACE��Z��么需要这么庞杂，虽然它不够完��（但至��我�q�没有资格来批评�q�一点，我现在最常想做的一个动作就是五体投圎ͼ��?/p>

而且我隐�U�感觉到�Q�我现在所写的很多东西在以后（对于有些人或许就是现在）看来会相当不深刻、相当不严�}�Q�但对于一�D�学习历�E�，�q�个�q�程是必然的、必需的�?/p>

在C++NPv1中，Douglas C. Schmidt把原始socket及其API的缺��h��些妖��化了，比如一�D�加上注释、空行在内的35行的代码�Q�被指出�?0处错误之多。这��像很多其他语言的倡导者或反传�l�C/C++指针者在批评指针时的说法一栗��长期��用原始socket和指针的同学�Ҏ��感觉很不舒服�Q�何况socket API提供了大量错误检��的接口�Q�至多是不够友好�|�了。你好就好了�Q�没必要抓住别�h一��痛批吧�Q�『本是同根生�Q�相煎何太急』�?/p>

虽然Solaris、Linux的很多版本及Windows对�v源于Berkeley的socket API�q�行了重写，但不可否认，�׃��历史原因和POSIX标准的存在，对于使用者而言�Q�我们可以无视这些API的实现差异。只是一旦我们从socket通信扩展到其他IPC通信的话�Q�就需要正视各�U�I/O�l�节的差异了�?/p>

�׃��UNIX中，对于socket, file, pipe, device的大多数操作�Q�描�q�符都是通用的（�q�一点，OS上面讲的更清楚些�Q�。而Windows中，句柄大多不能互换�Q�socket对于MS来说是舶来品�Q�。系�l�和标准的不一致导致地址、协议和API的�؜杂甚��x؜乱�?/p>

UNIX下的描述�W�和Windows的句柄可以看作是同一个概念，只是应用环境不一��P��所描述的内容也时常不一��P��再简单了��_��它们都是一个整型的ID�?/p>

ACE的源码中使用了大量预处理指��o�Q�尤其在跨��^�?�~�译环境的部分更加明显。鉴于C/C++标准的博大胸怀�Q�有些指令需要阅�ȝ��关编译器提供的帮助文档：

o #pragma: GCC, MSVC

o #define (#, #@, ##) : GCC, MSVC

其中有若�q�代码文件以.inl为后�~��Q�里面是寚w��分函数的内联实现�Q�以使代码结构看上去更加��z�。如果确定��用内联函数的话，*.inl��被包含�?.h的最后，如果不��用，则像*.h一��P��包含�?.cpp的头部�?/p>

ACE采用doxygen输出文档�Q�在阅读代码注释时能够感受到差异�Q�但基本不会影响阅读�?/p>

o * __ 关于�W?章（C++NPv1�Q�__ * o

ACE抽象的地址�c�ACE_Addr拥有ACE_DEV_Addr, ACE_FILE_Addr, ACE_INET_Addr, ACE_SPIPE_Addr, ACE_UNIX_Addr五个子类。对于狭义上的网�l�通信�Q�TCP/IP�Q�而言�Q�ACE_INET_Addr对应于我们熟悉的sockaddr_in�?/p>

ACE_IPC_SAP是IPC�Q�interprocess communication�Q�I/O操作�cȝ��root�c�R�?/p>

从编码的角度看，�q�个�c�L��亮的地方在于�C�Z��了抽象类的另一�U�实现方式�?/p>

一提到抽象�c�，大多��C�h的第一反应是pure virtual function。当一个基�cȝ��定需要��用virtual function�Ӟ��q�是一个不错的选择。但我们都知道虚拟函数有开销。而且对于一个结构简单的抽象基类和其�l�承子类�Q�尤其是大量使用�Ӟ��Q�一个虚函数表带来的开销会让整个设计昑־�十分�y�脚�?/p>

我们都知道如何强制让一个类无法使用default constructor�Q�protected�Q�。如果对基类使用该方法，仅��子类��h��public的default constructor�Q�这��p��C��定义抽象基类的效果�?/p>

virtual destructor的意义在于防止delete父类指针�Q�指向子�c�d��象）时未调用子类destructor。在此例中，为避免这�U�情况，同样��destructor声明为protected卛_��?/p>

从设计实现的角度看，相较于socket API�Q�ACE_IPC_SAP的子�c�ACE_SOCK提供了编译时对句柄合法性的��?/p>

从逻辑功能层面划分�Q�socket有三�U�角�Ԍ��

o active connection role (connector)�Q�主动连�?/p>

o passive connection role (acceptor)�Q�被动连�?/p>

o communication role (stream)�Q�数据通信

但socket API毕竟不是OOD出来的，对于一个socket描述�W�，也完全没有必要去限制其担负的功能�Q�更不可能搞成三�U�不同的socket。而OOD的ACE则可以轻易实现对socket对象及其操作的封装�?/p>

工厂�c�ACE_SOCK_Connector是一个主动创建通信端的工厂�c�R��socket API中的connect接口只是��Z��个socket建立与其它peer的网�l�连接，而不产生新的socket实例�Q�也不依赖于��M��其它socket。同��P��ACE_SOCK_Connector只是��Z��个ACE_SOCK_Stream对象�Q�对用于数据通信的socket的封装）�q�接到ACE_Addr�Q�对struct sockaddr的封装）提供接口�Q�也不含对ACE_SOCK_Stream对象的其它操作�?/p>

工厂�c�ACE_SOCK_Acceptor是一个被动创建通信端的工厂�c�R��当监听到新的网�l�连接后�Q��ؓ该连接初始化一个ACE_SOCK_Stream对象。和connector不同的是�Q�acceptor依赖于一个已�l�存在的充当监听功能的socket句柄�Q�ACE_SOCK�Q�，因此�Q�ACE_SOCK_Acceptor是ACE_SOCK的一个子�c�R�?/p>

ACE_SOCK_Stream是只负有通信传输功能的socket�Q�对应connection-oriented的TCP通信格式stream�Q�和UDP的CE_SOCK_CODgram相呼应。ACE_SOCK_Stream只是socket的通信载体�Q�在两个工厂ACE_SOCK_Connector和ACE_SOCK_Acceptor中初始化。这样一个类除支持最基本的数据发送（send�Q�和接收�Q�recv�Q�和��d��Q�blocking�Q�、非��d��Q�nonblocking�Q�及定时�Q�timed�Q�的I/O模式外，�q�支持分散读取（scatter-read�Q�和集中写入�Q�gather-write�Q��?/p>

对于一个简单的『网�l�课�E�作业：写一个有�q�接的IM��程序』，上面�q�些内容已经��_��了。当然即使��用对应的几个socket API也已�l��够了。但我们昄��更加兛_��如此庞大的一个库�Q�是如何解决复杂的网�l�应用的�Q�我��其兛_��的是多线�E��ƈ发如何更好的处理�?/p>

所以，我准备跑到第8�?章了�?/p>

Fox 2009-09-01 14:22 发表评论

Doxygen在Cygwin下的使用

Fox — Fri, 28 Aug 2009 09:14:00 GMT

本文同步�?a target="_blank">游戏人生

我发现我最�q�成了Cygwin下的��白鼠，写完Cygwin下安装ACE�Q�写ACE在cygwin下的使用。现在又�?a target="_blank">doxygen�?/p>

之前提到在Cygwin下读代码的不习惯�Q�后来回到VS下看。没�q�几天，觉得VS下还是不够直观，于是��q��接看ACE的doxygen�?#8230;…

doxygen好是好，用�v来还是要慢慢习惯才行�Q�需要在写注释和代码的时候注意一些，掌握的细节和技巧越多，出来的文档越丰富�Q�当�Ӟ��q�和代码质量是两码事�Q��?/p>

我自然是把doxygen安装在Cygwin下了�Q�由于doxygen没有提供info�Q�Info doxygen时就自动打开了doxygen的man�Q�和man doxygen、doxygen --help一个效果�?/p>

如果希望阅读更详��的使用�Ҏ��Q�只有自�?a target="_blank">down一个manual�?/a>�?/p>

在Cygwin下，doxygen采用GNU的libiconv�q�行文字�~�码的�{换，�?a target="_blank">UTF-8作�ؓ默认�~�码�?/p>

使用doxygen生成config-file模板后，可以在config-file中进行一些项目设�|�（有注释的�Q�看的懂�Q��?/p>

��Z��支持中文�Q�我DOXYFILE_ENCODING用的�?a target="_blank">EUC-CN�Q�但输出文档的语�a�OUTPUT_LANGUAGE却选了English。两点原因：

o EUC-CN�Q�各�U�汉字编码知识就不在此普及了�Q�你可以认�ؓ��体字�~�码都是EUC-CN�Q�和UTF-8不同�Q�但OUTPUT_LANGUAGE的各�U�语�a�都是使用的UTF-8�Q?span style="text-decoration: line-through;">所以两�U�编码不可能同时昄��Q�当�Ӟ��你可以把EUC-CN全�{成UTF-8。编码不是高�U�的技术，但对于非��p��用户�l�对是一个噩�?/span>�Q?span style="color: rgb(34, 34, 34); font-family: Georgia, Arial; font-size: 14px; ">后来发现是我自己学艺不精�Q�DOXYFILE_ENCODING只是配置文�g的编码格式而已�Q�而识别中文文档只需要修改INPUT_ENCODING成EUC-CN卛_��Q�OUTPUT_LANGUAGE自然讄��成Chinese也不会有问题�Q�因为doxygen采用UTF-8输出�Q��用中文输��Z��会有��q��问题�?/span>

o 虽然我的英文很蹩脚，虽然我的文档中多有中文注释。但像doxygen中文输出的文档中把class、public都给你翻译成中文�Q�你也受不了�Q�这也英文水�q�x��兟�?/p>

config-file中的其他内容我现在也用不刎ͼ��没有仔�l�看�?/p>

因�ؓKevin会在公司里讲一下doxygen�Q�doxygen的manual也讲的很详细�Q�我��q��Ҏ��_��不翻译文档了�?/p>

��单的一�?a target="_blank">Doxygen的测�?/a>在这里�?/p>

Fox 2009-08-28 17:14 发表评论

ACE之Cygwin vs Win

Fox — Mon, 24 Aug 2009 03:59:00 GMT

本文同步�?a target="_blank">游戏人生

我屈服了�Q�还是VS用的方便�?/p>

之前在Cygwin下已�l�可以��用的ACE�Q�因为阅��M��码太不方便（对于一个WinEr来说�Q�，上午在VS下面�׃��几分钟就把ACE配好了，而且使用$(ACE_ROOT)\examples\C++NPv1的代码跟�t�调试，太习惯了�?/p>

按照$(ACE_ROOT)\ACE-INSTALL.html的安装说明：

o 选择�q�打开$(ACE_ROOT)\ace\ace_vc9.sln

o ��d��config.h�q�加入以下内容：

#define ACE_HAS_STANDARD_CPP_LIBRARY 1
#include "ace/config-win32.h"

o F7

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

OK�Q�现�?(ACE_ROOT)\lib下面已经生成了ACEd.dll、ACEd.lib�Q�再讄��一下系�l�环境变量（�q�行�E�序必需�Q�和VC++目录�Q�调试程序必需�Q�。可以��用了�Q?

o 选择�q�打开$(ACE_ROOT)\examples\C++NPv1

o F7

Fox 2009-08-24 11:59 发表评论

ACE在cygwin下的使用

Fox — Wed, 19 Aug 2009 02:05:00 GMT

本文同步�?a target="_blank">游戏人生

int ACE_TMAIN(int, ACE_TCHAR *[])
{
ACE_TRACE(ACE_TEXT("main"));

ACE_DEBUG((LM_INFO, ACE_TEXT("%IStart\n")));
ACE_DEBUG((LM_INFO, ACE_TEXT("%IEnd\n")));

return 0;
}

/*--------- makefile ---------*/

BIN     = hello                       # src & exe file name
SRC     = $(addsuffix .cc, $(BIN))    # src file suffix
LIBS    = -lACE                       # libACE.dll under cygwin

include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
include $(ACE_ROOT)/include/makeinclude/macros.GNU
include $(ACE_ROOT)/include/makeinclude/rules.common.GNU
include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU
include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU
include $(ACE_ROOT)/include/makeinclude/rules.local.GNU

/*--------- Compilation ---------*/

GNUmakefile: /home/fox/ace/GNUmakefile MAKEFLAGS=k

g++ -Wpointer-arith -mthreads -mtune=pentiumpro -O3 -g -pipe -pipe -I/usr/\
share/ace -DACE_HAS_EXCEPTIONS -DACE_NO_INLINE -c -o .obj/hello.o hello.cc
g++ -Wpointer-arith -mthreads -mtune=pentiumpro -O3 -g -pipe -pipe -I/usr/\
share/ace -DACE_HAS_EXCEPTIONS -DACE_NO_INLINE -Wl,--enable-auto-import -Wl,-E\
-L/usr/share/ace/lib -o hello .obj/hello.o -lACE

Compilation finished at Wed Aug 19 00:35:42

/*--------- Result ---------*/

$ ./hello.exe
(14417928) calling main in file `hello.cc' on line 13
Start
End
(14417928) leaving main

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

更多内容请参�?a target="_blank">C++NP(C++ Network Programming) vol.1 & vol.2和APG(The ACE Progrmmer's Guide)�?/p>

忙活了一晚上�Q�终于知道怎么包含头文件了�Q�在gcc的编译选项中用 -I�?I$(ACE_ROOT)�Q?/p>

本例中是�Q?I/usr/share/ace

�l�果后面库又链接不上�Q�联想以前��用OpenGL库的LIBS�Q�终于靠一�?lACE搞定�?/p>

因�ؓ不愿意用MPC�Q��L��觉再多花些时间去弄又只是��题更远了，有兴��的同学自然是可以通过ACE的官�|�找到所有问题的�{�案�?/p>

�q�样一来，ACE在cygwin下从安装��C��用也��告一�D�落了，后面的问题就比较easy了，无非是你用ACE做什么。而我也不会再��ACE && cygwin写什么心得了�Q��ȝ��见证了这两天的捣腾�?/p>

Fox 2009-08-19 10:05 发表评论

与君共勉

Fox — Mon, 17 Aug 2009 08:31:00 GMT

本文同步�?a target="_blank">游戏人生

现在有些�q�轻人的心态比较��Q�w�，大致�ȝ��以下『四点表现』：

1. 眼高�q�顶�Q?/p>

2. 垂手�q�膝�Q?/p>

3. 期望值高�Q?/p>

4. �U�极性低�?/p>

深层�ơ的客观原因大致是『四个没有』：

1. 没有吃过苦；

2. 没有�q�过�z�；

3. 没有说过话；

4. 没有当过家�?/p>

一般都��h��『四个特征』：

1. 独生子女�Q?/p>

2. 毕业��C�h�Q?/p>

3. 沉默寡言�Q?/p>

4. 半瓶开水�?/p>

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

1. 你想要什么？

参考：一个有影响力的人。（@李开�?/a>�Q?/p>

2. 那是否是你想要的�Q?/p>

参考：你的眼光有多�q�，军_��了你能走多远。（@Fox�Q?/p>

3. 你需要做什么？

参考：高筑墙，�q�积�_�，�~�称王。（朱元璋）

4. 你还需要做什么？

参考：�q�_��的心态，�q�取的态度�Q�坚定的目标�Q�不懈的努力。（@Fox�Q?/p>

5. 你是否做��C��Q?/p>

参考：没有�Q�但我一直在努力。（@Fox�Q?/p>

Fox 2009-08-17 16:31 发表评论

Cygwin下安装ACE

Fox — Mon, 17 Aug 2009 01:52:00 GMT

本文同步�?a >游戏人生

-----------------------��M��-----------------------

惌��《UNIX Network Programming�?/a>很久了，只是�q�种愿望一直没有特别强烈。用的笔记本换了之后��自己只是装了cygwin�Q�没有安装VS�Q��^时写些代码就只能在cygwin下用gcc了。最�q�对UNIX环境�~�程和网�l�基��比较感兴��，于是读这本书�l�于提上了议事日�E�，可是大多��C��店都没有�q�本书了�?

工作之后�Q�对于自己喜�Ƣ的书，��很��会�ȝ��电子版，觉得�q�是捧卷在手的感觉舒服一些，��x��么看怎么看，享受拿笔在上面写写画�ȝ��感觉。因此对于想��M��C��到的书，�W�一反应是等待。在��ȝ��脑上面一些资料的时候才反应�q�来我已�l�很久没有down�q�电子书了，�l�果��׃��|�上down�?a target="_blank">很多惌��(豆瓣)的书�Q�forgive me, Richard Stevens and anybody.

-----------------------动手-----------------------

之前只是在Windows下用�q�ACE�Q�因为ACE提供了VS各种版本的解��x��案，�~�译�q�程比较��单。这�ơ放在cygwin下编译的时候，因�ؓ环境变量讄��问题�Q��ƈ不是非常��利�Q�参照了源码目录下的ACE-INSTALL.html的描�q�才��问题解冟뀂现在将�q�程�l�出来，仅供google到这里的同学参考：

友情提示�Q�我目前对于cygwin和UNIX�cȝ��l�的了解停留在知其然�Q�还是在google之后�Q�的水��^�?

1. 增加环境变量

o 修改/etc/profile文�g��d��属性：

$ chmod 777 /etc/profile

cygwin下的环境变量可以在该文�g中配�|�，�׃��该文仉��认具有写保护属性，因此需要修改��之可写，修改完成之后应该记得对其�q�行写保护：

$ chmod 555 /etc/profile

o 打开profile文�g�Q�本��Z��用emacs�q�行�~�辑�Q�读者也可以使用vi、vim�{�，在此不再赘述�Q�：

$ emacs /etc/profile

o 往profile中修改和��d��环境变量�Q?

��以下五行添加到文�g中，ACE_ROOT为ACE源码目录�Q�本文用到的目录�?usr/share/ace�Q?

ACE_ROOT=/usr/share/ace
export ACE_ROOT

LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH

# export PATH=$ACE_ROOT/ace:$PATH

�q�个操作�{�同于在VS下修改库文�g目录�Q�我是直接修改了PATH变量的：

PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:$ACE_ROOT/ace:$PATH

o 执行/etc/profile

$ /etc/profile

执行修改后有可能需要重启cygwin�Q�可使用下面的命令查看ACE_ROOT讄��是否正确�Q?

$ echo $ACE_ROOT

2. 创徏若干文�g�Q?

o �?ACE_ROOT/ace 文�g夹中创徏名�ؓ config.h 的文�Ӟ��q�加入以下内容后保存关闭�Q?

#include "ace/config-cygwin32.h"

o �?ACE_ROOT/include/makeinclude 文�g夹中创徏名�ؓ platform_macros.GNU 的文�Ӟ��q�加入以下内容保存关闭：

include $(ACE_ROOT)/include/makeinclude/platform_cygwin32.GNU

3. �~�译ACE�Q?

$ cd $ACE_ROOT/ace
$ make

大概会花掉十几分钟时间吧�?

4. ��试ACE�Q?

$ cd $ACE_ROOT/tests
$ make

大概又会花掉十几分钟旉��吧�?

接下来就可以使用perl脚本完成所有测试，我没有��用过perl�Q��时安装了一下�?

$ perl run_test.pl

�q�个脚本在我一位同事的机器上跑了很久（十几分钟 or 几十分钟�Q�）�Q�不�q�的是，Windows竟然抛出了一个内存读写错误，更加不幸的是�Q�我现在没有能力�ȝ��定�?

�l�果周末后面的时间又花在熟悉EMacs上了�Q�还没有看ACE的代码，只有下周才能看了�?

-----------------------�l�束-----------------------

�q�种��学生的东西拿出来讲��实是很难�ؓ情的�Q�然而，于我现在却又��是极大的一个收莗��真�{�我熟悉了其中的很多内容�Q�又未必会再有耐心说了。所以还是记录一下，既是鼓励�Q�也是督促�?/p>

晚上睡觉之前��M��一�?a target="_blank">《ACE�E�序员指南：�|�络与系�l�编�E�的实用设计模式�?/a>�Q�发现里�?.3节也讲到了怎么安装�?/p>

Fox 2009-08-17 09:52 发表评论

设计模式�Q�四�Q?amp;mdash;—Template Method

Fox — Tue, 10 Feb 2009 17:46:00 GMT

在一个稍微上规模�Q�怎么也有几十个类吧）的C++�E�序中，�l�承和组合的使用比比皆是。虽然GoF提出了OOD的两个原则，�W�二个谓之�?strong>优先使用对象�l�合�Q�而不是��?/strong>』，但这�l�不意味着不��用��承，正因如此�Q�第一个原则才是�?strong>针对接口�~�程�Q�而不是针对实现编�E?/strong>』，�q�两个原则清楚的表达了��Y件工�E�中�?strong>低耦合』的思想�?/p>

模板�Ҏ��Q�Template Method�Q�的意图正是�?strong>定义一个操作中的算法的框架�Q�而将一些步骤�g�q�到子类�?/strong>』�?/p>

注意�Q�这里有个关键词『一些』，既然是『一些』，��意味着父类的的接口中已�l�实��C��『一些』步骤，否则�Q�父�c�M��只提供了抽象接口�?/p>

�q�一情况是我们在�~�码时时帔R��到的�Q�父�c�d��C��部分��法中的通用行�ؓ�Q�子�c�L��据自��q��需求可对其�q�行必要扩充�?/p>

class CBase { public: // Default done virtual void Operation(void) { ... } };

class CDerive : public CBase { public: virtual void Operation(void) { switch( ... ) { case A: ... case B: ... case c: ... default: CBase::Operation(); } } };

因�ؓ对父�cȝ��不了解或是对子类的太了解�Q�你以�ؓCDerive::Operation()做了��_��多，不需�?code>CBase::Operation()�Q�但实际上仍焉��要的情况��d��发生�?/p>

换一�U�方式，�?code>Operation()作�ؓ模板�Ҏ��Q�把DoOperation()作�ؓ可扩展的接口提供�l�子�c�d��玎ͼ�

class CBase { public: void SetFocus(void) { ... } void ResetFocus(void) { ... } // Call by user void Operation(void) { SetFocus(); DoOperation(); ResetFocus(); } // Default done virtual void DoOperation(void) = 0; };

class CDerive : public CBase { public: virtual void DoOperation(void) { ... } };

模板�Ҏ��只是提供了一个简单的��装技巧，当然不是所有的虚接口都�q�么�?)�?/p>

更多内容��L��?a target="_blank">我的个�h主页�?/p>

Fox 2009-02-11 01:46 发表评论

Fox — Sun, 04 Jan 2009 03:04:00 GMT

VS2005下��用VC�Q�部分断�Ҏ��效，昄��『当前不会命中断炏V��还没有��文档加蝲��M��W�号』�?/p>

试过以下一些方法：

1、无效断�Ҏ��在的��目和启动项目的讄��Q�项�?>属�?>配置属�?>C/C++->常规->调试信息格式�Q�这里不能�ؓ『禁用』；

2、项�?>属�?>配置属�?>链接�?>调试->生成调试信息�Q�这里设为『是』；

3、C/C++->优化->优化选择『禁用』；

4、删除解��x��案下�?ncb文�g�Q?/p>

5、工�?>选项->调试->『要求源文�g与原始版本完成匹配』去掉勾�Q?/p>

6、最后在上述讄��的情况下�Q�重新编译整个解��x��案；

7、回�q�头来，发现原来是一�D�不会被执行到的代码…�?/p>看来�Q�除了VS本��n会有bug�Q�自��q��代码�q�是要多��查一下�?img src ="http://www.shnenglu.com/Fox/aggbug/71110.html" width = "1" height = "1" />

Fox 2009-01-04 11:04 发表评论

Fox — Sat, 27 Dec 2008 18:44:00 GMT

本文最早发布于我的个�h主页

一般的RPG游戏中，玩家角色、NPC、物品、场景等一般都��h��为数众多的各�U�属性，使用C++�~�码�Ӟ��很容易考虑设计成�ؓ大量的成员变量和相应的存取函敎ͼ�

 class CObject
{
public:
    long GetAttrA(void) const { return m_lAttrA; }
    void SetAttrA(long lVal) { m_lAttrA = lVal; }
    long GetAttrB(void) const { return m_lAttrB; }
    void SetAttrB(long lVal) { m_lAttrB = lVal; }
    ...
    long GetAttrN(void) const { return m_lAttrN; }
    void SetAttrN(long lVal) { m_lAttrN = lVal; }  
private:
    long m_lAttrA;
    long m_lAttrB;
    ...
    long m_lAttrN;
};

乍一看，非常清晰明了。在一个稍昑֤�杂的��目中，惌��住、甚��x��到每一个属性是非常隄��Q�况且除了属性，�q�有大量的逻辑处理�Q�甚��x��不同��目间的数据交互�Q�比如将属性的数据库存取。这么做的缺点大致有�q�么几点�Q?/p>

1. 属性没有明��分门别�c�，��其在多人协作、多模块�~�写�Ӟ��往往上面一扏V��下面一批，甚至有重复属性、废弃属性，难于��理和把握；

2. 对于数据库存取，需要写单独的存取接口，而且一旦属性有增减、修改，存取接口要随之修改；

3. 通过接口函数�q�行��单的属性存取面临大量的堆栈保存�Q�即使��用内联或宏定义，也是��L��不治本�?/p>

针对上述问题�Q�我的思�\也比较简单：�?strong>基本�c�d��数据�q�行二次��装�?/p>

struct tagDBAttrs { long lA; long lB; ... long lN; };

class CObject { public: const tagDBAttrs& GetDBAttrs(void) const { return m_DBAttrs; } void SetDBAttrs(const tagDBAttrs& rDBAttrs) { memcpy(&m_DBAttrs, rDBAttrs, sizeof(m_DBAttrs)); }

private: tagDBAttrs m_DBAttrs; string m_strA; CObject* m_pObjB; CShape* m_pShapeC; ... };

之所以提到基本类型数据，主要�~�于基本�c�d��构成的结构可以通过sizeof�q�算�W�直接确定，而像�c�d��象等�l�合�c�d��Q�其深拷贝、赋倹{��操作及赋值等逻辑则较为复杂，一般无法统一处理�?/p>

以上面的tagDBAttrs��Z��Q�对于基本类型数据处理具有非常大的优势，��其在数据整体存取时�Q�此外，增减基本�c�d��属性也比较��单，而且不需要重�?code>Get/Set接口�Q�同时方便了对属性的分门别类处理�?/p>

此处��Z��谈谈关于开发中的一些杂的体会�?/p>

对于工作不久的同学而言�Q�拿��C��个�Q务有可能出现以下两种情况�Q?/p>

1. 以快速开发�ؓ重，前期�q�展较快�Q�在��型模块开发中��风��水�Q�但在面对复杂�Q务时�Q�因为对前期设计重视不��Q�后期会不断调整代码�Q�甚臛_��基本功能开发结束后�Q�因为逻辑架构问题�Q�导致bug隐患较多较深�Q�容易陷入惔��|��痛苦挣扎�Q?/p>

2. 随时随处�q�求代码�l�构的优��和执行效率的优化，�_��求精�Q�往往在前期设计上��p��q�多的心思，以达到较合理的逻辑�l�构�Q�甚��x��延整个项目的开发进度，�q�种同学一般说来，代码质量较高�Q�后期bug较少�?/p>

其实�Q�上面说的就是我自己�Q�我刚开始工作的时候，上面�l�我一个编写独立工��L��d��Q�当时急于表现�Q�缺乏项目实战经验，为编码而编码，逻辑�l�构不注重扩展性，设计不合理，在进行到后期�Ӟ��面对出现的新需求无法应对，��D��最后推到重来�?/p>

后来�Q�慢慢接受了注重前期设计的观念，更因��q��完美情结和代码洁癖，不仅�l�常调整自己�~�码中不优美的片�D�，甚至��俎代庖��M��改其他同事的代码�Q�追求处处的高效�Q�耗费大量旉��_�֊��Q�难以自拔�?/p>

在�Q何一个项目中�Q�都有轻重主�ơ之分，也就是所谓的�?strong>8020原则』，关于�?strong>8020原则』怎么理解都行�Q�我的理解就是，每个��目中的效率瓉��?0%的核心代码，80%的时间和工作重心应该攑ֈ��q?0%的核心代码上。放��C��个小的模块中也是�q�样�Q�应该确定工作重心，在开发进度的限制下，�Ҏ��心代码精益求�_�，寚w��效率瓉��可以适当减少侧重�?/p>

对于��C�h�Q�最隄��是从整体的高度��定20%的工作重心，�q�主要依赖于自��n素质的提高和开发经验的�U�篏。而对需求深入细致的分析和对逻辑�_��求精的设计本�w�可以训�l�一个�h分析问题、解决问题的能力�?/p>

�ȝ��一下的话，也正是我们项目组历来所倡导和坚持的�Q?/p>

1. �_��求精�Q?/p>2. �l�节军_��成��|�Q�态度制约能力�?img src ="http://www.shnenglu.com/Fox/aggbug/70542.html" width = "1" height = "1" />

Fox 2008-12-28 02:44 发表评论

设计模式�Q�三�Q?amp;mdash;—Singleton

Fox — Wed, 19 Nov 2008 15:37:00 GMT

不知道Singleton��不��用的最多的�Q��^时用的时候，往往都是直接敲下面一�D�：

 ……
 不是不想改，���是懒，敲多了已�l�不觉得�q�么写多���费旉���了，按大家的说法�Q�这样写臛_��有这么几个缺点：
 1. 必须在程序结束前手动释放�Q�这不仅是RP问题�Q�如果你借了内存不主动还�Q�说明你RP差，但被别�h搞丢了（宕机�Q�导致你�q�不上，说明别�hRP差？所以，�q�还是个问题�Q?/p> 
2. �U�程同步问题�Q�如果Singleton实例跨线�E���用，上例不安全，在Initial和Release时加锁可以解冻I��
 3. 最大的问题�Q�不能重用�?/p> 
阅读全文

Fox 2008-11-19 23:37 发表评论

设计模式�Q�二�Q?amp;mdash;—State

Fox — Tue, 18 Nov 2008 16:57:00 GMT

State模式对应到C++�?strong>多�?/strong>�Ҏ��?/p>

State模式适用较广�Q�这儿给出比较常见易懂的三种情况�Q?/p>

1. 当怪物在面对不同职业和�Ҏ��的玩家时对应不同的AI处理和技能释放：

 CSkill* pAttackSkill;
 if( pPlayer->MagicImmune() ) pAttackSkill = SomePhysicalAttackSkill;
 else if( pPlayer->PhysicalImmune() ) pAttackSkill = SomeMagicAttackSkill;
 ...
 pAttackSkill->Begin();
 ...

或者��用分支结构：

 CSkill* pAttackSkill;
 switch( pPlayer->GetOccupation() ) 
 {
   case WARRIOR: pAttackSkill = SomeLongRangeSkill; break;
   case MAGICIAN: pAttackSkill = SomeForceSkill; break;
   case NIMROD: pAttackSkill = SomeMagicSkill; break;
 ...
 }
 pAttackSkill->Begin();
 ...

阅读全文

Fox 2008-11-19 00:57 发表评论

WSAEventSelect剖析

Fox — Mon, 27 Oct 2008 15:25:00 GMT

本文同时发布�?a title="http://www.yulefox.com" target="_blank" rel="tag">http://www.yulefox.com�?a title="http://www.shnenglu.com/fox" href="http://www.shnenglu.com/fox" target="_blank" rel="tag">http://www.shnenglu.com/fox�?

�q�来在Windows下用WSAEventSelect�Ӟ��到一个棘手的问题�Q�当然现在已�l�解决了�?

问题描述�Q?/strong>

一个Server�Q�一个ClientA�Q�一个ClientB�Q�Server用WSAEventSelect模型监听�Q�只有监听，没有��d��Q�，ClientA在连接Server后，ClientA对应的EventA被触发，Server的WSAWaitForMultipleEvents�{�待到EventA�Q�ClientB�q�接Server�Ӟ��TCP三次握手成功�Q�ClientB与Server的TCP状态被�|��ؓESTABLISHED�Q�然而Server的WSAWaitForMultipleEvents没有�{�待到EventB被触发�?

用netstat看了一下，ClientB与Server的状态是ESTABLISHED�Q�此时如果ClientB退出，�׃��Server无法正常Close该连接，因此Server的状态不是TIME_WAIT而是CLOSE_WAIT�Q�持�l?��时�Q�，Client的状态是FIN_WAIT_2�Q�持�l?0分钟�Q��?

我尝试将ClientA��d��关闭后再�ơ连接Server�Q�Server的WSAWaitForMultipleEvents在wait到EventA之后�Q�EventB此时也被触发�?

开始一直以为问题的�Ҏ��在于WSAEventSelect的��用上�Q�毕竟，之前没有�pȝ��写过�c�M��的代码，隑օ�怀疑到事�g模型的��用上。多�Ҏ��阅资料，最后还是没有发现类似问题的解决�Ҏ��?

又跟了一上午之后�Q�Kevin开始怀疑是多线�E��用的问题�Q�我看了一下，的确没有对event的多�U�程操作�q�行处理�Q�但因�ؓ在另一个应用中�Q��用了同样的模块，却没有该问题。最后考虑必要性时�q�是攑ּ�了加临界资源�Q�无视多�U�程同步问题。Kevin本来劝我换个模型�Q�但我固执的认�ؓ要做��把�q�事儿做好。因��Z��午还要回学校一��，��想��快搞定�Q�毕竟因��一块已�l�把Kevin的进度拖了一周了�Q�心下还是过意不去，而且隐约感觉到离问题的解册��来越�q�了�?

问题分析�Q?/strong>

在对着WSAWaitForMultipleEvents思考了半天之后�Q�忽然开�H�了�Q�如果ThreadA在WSAWaitForMultipleEvents�Ӟ��只有一个EventA被WSAEventSelect�q�set到signaled状态，则该EventA会被wait成功�Q�ThreadA处理EventA之后�l�箋��d��在WSAWaitForMultipleEvents。此�Ӟ��ThreadB通过WSAEventSelect��EventB初始化�ؓnonsignaled状态，之后即��EventB被set为signaled状态，但ThreadA的WSAWaitForMultipleEvents因�ؓ处于��d��状态，不可能刷��C��仉��Q�也��׃��可能wait到EventB�Q�最�l�导致了ClientB的请求无法被响应。如果EventA被触发则会被ThreadA�{�待刎ͼ�WSAWaitForMultipleEvents�q�回后再�ơ进入时事�g集已�l�被��h��Q�EventB被wait��C��׃��隄��解了�?

问题解决�Q?/strong>

说到底是因�ؓ当ThreadA��d��在WSAWaitForMultipleEvents处之�Ӟ��事�g集的变更无法立即得到体现。如果允�怸�层应用随时create或close一些event�Q�则WSAWaitForMultipleEvents��׃��应该无限��d��下去�?

因此最后的一个解��x��法就是让WSAWaitForMultipleEvents��时�q�回�q�Sleep一�D�|��_��当WSAWaitForMultipleEvents再次�q�入时事仉��得以更新�?

想了一下，另一个应用中之所以没出现该问题也只是个��y合，因�ؓ该应用中ThreadB的两�ơWSAEventSelect间隔很短�Q�在ThreadA获得旉��片之前已�l�确定了事�g集�?

说白了这也不是一个什么大问题�Q�甚臌��不上��M��隑ֺ��Q�但是因��Z��前对WSAEventSelect没有一个清晰的概念�Q�因此在发现和分析问题上��p��了大量时��_��加上在VS2005调试�q�程中，有个别文件更新时没有被重新编译，也耗费了很多无谓的旉��Q�以至于我们都在考虑是不是要攑ּ�IDE�Q�因为我们确实太依赖IDE了，有些TX��Z��E�_��Q�每�ơ都是“重新生成整个解��x��案”，如果一个解��x��案有几千个文件、几十万行的代码�Q�估计重�~�一�ơ也要花个几分钟吧�?

�ȝ��Q?/strong>

netstat观察的网�l�连接处于ESTABLISHED状态�ƈ不意味着逻辑�q�接被accept�Q�只是表明客��L��connect的TCP物理�q�接�Q�三�ơ握手）被服务器端ack�Q�如果服务器没有accept到该�q�接�Q�证明网�l�模块代码有问题�Q?
多线�E�怎么都是个问题，�U�程同步��量避免�Q�毕竟，用Kevin的话来说�Q�加锁是丑陋的。但在涉及到同步问题�Ӟ��q�是权衡一下，我这儿之所以最后没有加临界区，是因��Z��件主要是在ThreadA中处理，ThreadB中只有create操作�Q�而且ThreadA对事仉��的刷新要求不是那么严��|��也就不考虑加��界区了；
如果能力和条件允许的话，攑ּ�IDE吧，IDE的确不是个好东西�Q�我主要是指在编译链接的时候，如果作�ؓ�~�辑器说不定�q�会好用:)�?

个�h�|�站http://www.yulefox.com用的��L��最�q�从据说要黑屏的Windows换成了Debian�Q�还在调��_��估计明天能弄好，内容肯定比Cppblog杂的多，谈点技术的�q�是会同步更新到http://www.shnenglu.com/fox�?/p>

Fox 2008-10-27 23:25 发表评论

Fox — Fri, 10 Oct 2008 02:20:00 GMT

作者：Fox

本文同时发布�?a >http://www.yulefox.com�?a href="http://www.shnenglu.com/fox">http://www.shnenglu.com/fox�?/p>
十天之前�Q�在CPPBLOG上写了一��?a title="消息映射机制的简单实�? href="http://www.shnenglu.com/Fox/archive/2008/09/29/63056.html" target="_blank" rel="tag">消息映射机制的简单实�?/a>�Q�有同学提到该实��C��支持成员函数。这个问题我也考虑��C��Q�既然被提出来，不妨把实现提供出来�?/p>
需要说明的是，我本�w�对template比较不感冒，不过Kevin Lynx对template感冒�Q�而且写过关于成员函数指针的问题，想了很久�Q�如果支持成员函数指针，不用模板是不行了�?/p>
此处�Ҏ��员函数的支持�q�不涉及对函数参数的泛化�Q�因为我�q�个消息映射暂时不需要参数泛化，下面的代码应该不需要过多的解释了�?/p>
#define REG_MSG_FUNC(nMsgType, MsgFunc) \     CMsgRegister::RegisterCallFunc(nMsgType, MsgFunc);
#define REG_MSG_MEM_FUNC(nMsgType, Obj, MsgFunc) \     CMsgRegister::RegisterCallFunc(nMsgType, Obj, MsgFunc); class CBaseMessage; class CHandler { public:     virtual int operator()(CBaseMessage* pMsg) = 0; }; template class CDefHandler : public CHandler { public:     CDefHandler(){}     CDefHandler(FuncType &Func)         : m_Func(Func)     {     }     virtual int operator()(CBaseMessage* pMsg)     {         return m_Func(pMsg);     } protected:     FuncType    m_Func; }; template class CMemHandler : public CHandler { public:     CMemHandler(){}     CMemHandler(ObjType* pObj, FuncType Func)         : m_pObj(pObj)         , m_Func(Func)     {     }     virtual int operator()(CBaseMessage* pMsg)     {         return (m_pObj->*m_Func)(pMsg);     } protected:     FuncType    m_Func;     ObjType*    m_pObj; }; class CFunction { public:     CFunction()         : m_pHandler(NULL)     {     }     // ��装(C函数或静态成员函�?     template     CFunction( FuncType &Func )         : m_pHandler(new CDefHandler(Func))     {     }     // ��装(非静态成员函�?     template     CFunction( ObjType* pObj, FuncType Func )         : m_pHandler(new CMemHandler(pObj, Func))     {     }     virtual ~CFunction()     {         DELETE_SAFE(m_pHandler);     }         // 函数调用     int operator()(CBaseMessage* pMsg)     {         return (*m_pHandler)(pMsg);     } private:     CHandler    *m_pHandler; }; typedef std::map MSG_MAP; typedef MSG_MAP::iterator MSG_ITR; class CMsgRegister { public:     // 注册消息函数(C函数或静态成员函�?     template     inline static void RegisterCallFunc(int nMsgType, FuncType &Func)     {         CFunction *func = new CFunction(Func);         s_MsgMap[nMsgType] = func;     }     // 注册消息函数(非静态成员函�?     template     inline static void RegisterCallFunc(int nMsgType, ObjType* pObj, FuncType Func)     {         CFunction *func = new CFunction(pObj, Func);         s_MsgMap[nMsgType] = func;     }     // 执行消息     inline static void RunCallFunc(int nMsgType, CBaseMessage* pMsg)     {         MSG_ITR itr = s_MsgMap.find(nMsgType);         if( s_MsgMap.end() != itr )         {             (*itr->second)(pMsg);         }     }     static void ReleaseMsgMap()                // 释放消息映射�?     {         MSG_ITR itr = s_MsgMap.begin();         while( itr != s_MsgMap.end() )         {             DELETE_SAFE(itr->second);             itr = s_MsgMap.erase(itr);         }     } protected:     static MSG_MAP            s_MsgMap;        // 消息映射�? };
不可否认�Q�模板给了你更大的想象空��_��很多东西�Q�还是不要一��x��斥的�?)�?/p>

Fox 2008-10-10 10:20 发表评论

Fox — Mon, 29 Sep 2008 10:34:00 GMT

��目中��用了消息通信机制�Q�因为消息类型非常多�Q�相应的�Q�处理消息的地方代码也非常多�?
自然而然惛_��MFC中的消息映射�Q?
创徏一个缺省MFC框架�E�序的解��x��案Test�Q�在Test.h中看��C��下内容：
class Ctest_mfcApp : public CWinApp { public:     Ctest_mfcApp();
// 重写 public:     virtual BOOL InitInstance();
// 实现     afx_msg void OnAppAbout();     DECLARE_MESSAGE_MAP() };

其中�Q�最紧要的就�?code>DECLARE_MESSAGE_MAP()�q�个宏，相关内容展开如下�Q?
struct AFX_MSGMAP_ENTRY {     UINT nMessage;   // windows message     UINT nCode;      // control code or WM_NOTIFY code     UINT nID;        // control ID (or 0 for windows messages)     UINT nLastID;    // used for entries specifying a range of control id's     UINT_PTR nSig;   // signature type (action) or pointer to message #     AFX_PMSG pfn;    // routine to call (or special value) };
struct AFX_MSGMAP {     const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();     const AFX_MSGMAP_ENTRY* lpEntries; };
#define DECLARE_MESSAGE_MAP() \ protected: \     static const AFX_MSGMAP* PASCAL GetThisMessageMap(); \     virtual const AFX_MSGMAP* GetMessageMap() const; \
其中AFX_PMSG不再解析下去�Q�我们认��是一个指向特定消息对应的实现函数的函数指针，�q�几个宏的作用可��单理解成为Test�q�个��目定义了一个静态的消息映射表。当消息到来�Ӟ��从消息队列中弹出消息�q�分发到��h��入口实现的上层CWnd�z��H�口。用户只需要注册消息，实现消息入口函数��够了，�q�在MFC中一般放�?cpp文�g头部。Test.cpp中头部有以下内容�Q?
BEGIN_MESSAGE_MAP(CTest, CWinApp)     ON_COMMAND(ID_APP_ABOUT, &CTest::OnAppAbout)     // ��Z��文�g的标准文档命�?br>    ON_COMMAND(ID_FILE_NEW, &CWinApp::OnFileNew)     ON_COMMAND(ID_FILE_OPEN, &CWinApp::OnFileOpen)     // 标准打印讄��命��o     ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinApp::OnFilePrintSetup) END_MESSAGE_MAP()
�q�里是�ؓ消息枚�D��g��消息实现函数建立映射�Q�其中涉及到的宏的展开如下�Q?/p>
#define ON_COMMAND(id, memberFxn) \     { WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSigCmd_v, \         static_cast (memberFxn) },
#define BEGIN_MESSAGE_MAP(theClass, baseClass) \     PTM_WARNING_DISABLE \     const AFX_MSGMAP* theClass::GetMessageMap() const \         { return GetThisMessageMap(); } \     const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \     { \         typedef theClass ThisClass;                           \         typedef baseClass TheBaseClass;                       \         static const AFX_MSGMAP_ENTRY _messageEntries[] = \         {
#define END_MESSAGE_MAP() \         {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \     }; \         static const AFX_MSGMAP messageMap = \         { &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; \         return &messageMap; \     }                                  \     PTM_WARNING_RESTORE
按照上述思�\得到的相��g��码如下：
// Test.h typedef void (* funCall)(void*);        // 消息执行函数�c�d�� struct tagMsgEntry                      // 消息入口�l�构 {     int            nMsgType;            // 消息�c�d��     funCall        MsgRun;              // 消息执行函数 }; struct tagMsgMap                        // 消息映射表结�?br>{     const tagMsgMap* (__stdcall* funGetBaseMsgMap)();     const tagMsgEntry* pMsgEntries;     // 消息入口�?br>}; class CMessage {     // ... protected:     static const tagMsgMap* __stdcall GetThisMsgMap();     virtual const tagMsgMap* GetMsgMap() const; }; // Test.cpp const tagMsgMap* CMessage::GetMsgMap() const {     return GetThisMsgMap(); } const tagMsgMap* __stdcall CMessage::GetThisMsgMap() {     static const tagMsgEntry MsgEntries[] =     {         { MSG_SOME_ONE, SomeOneFunc },         { MSG_SOME_TWO, SomeTwoFunc },         { MSG_NULL, NULL }     };     static const tagMsgMap msgMap =     {         &CBaseMessage::GetThisMsgMap,    // 父类消息映射�?br>        &MsgEntries[0]     };     return &msgMap; } int CMessage::MsgProc(int nMsgType) {     switch( nMsgType )     {     case MSG_SOME_ONE:         {
        }         break;     }     return CBaseMessage::MsgProc(nMsgType); }
�q�种处理的优点在于，子类没有定义的消息实现接口，可以使用父类接口实现。不�q�在现在的消息处理中�Q�我们一般不需要由基类来完成，因此可以不依赖基�c�L��口，使用宏可以��代码看上��L��加简�z��?
___________________________________________________________
��化版本的消息映射采用以下方式�Q�简单清晎ͼ�
// Test.h #define REG_MSG_FUNC(nMsgType, MsgFunc) \     CMessge::RegisterCallFunc(nMsgType, MsgFunc); \
typedef void (* function)(void*);
typedef std::map MSG_MAP; typedef MSG_MAP::const_iterator MSG_CITR;
class CMessage {     // ... public:     static const MSG_MAP& GetMsgMap();     static void RegisterCallFunc(int nMsgType, void(* Func)(void *))     {         s_MsgMap[nMsgType] = Func;     }
    int CMessage::Run(int nMsgType)                // 消息公用执行函数     {         MSG_ITR itr = s_MsgMap.find(nMsgType);         if( s_MsgMap.end() != itr )         {             itr->second(this);         }     }
protected:     static MSG_MAP            s_MsgMap;            // 消息映射�?br>};
// UserTest.cpp -- 用户在��用时对自己关心的消息予以注册, 入口函数予以实现卛_�� REG_MSG_FUNC(MSG_SOME_ONE, SomeOneFunc)
void SomeOneFunc(CBaseMessage *pMsg) {     return; }
___________________________________________________________
最�q�忙的焦头烂额，正好写到消息�Q�稍微整理一下，提供些许借鉴�?/p>

Fox 2008-09-29 18:34 发表评论

Fox — Wed, 10 Sep 2008 17:11:00 GMT

�|�络�~�程学习和实�늚��q�程中，同步�Q�synchronous�Q?异步�Q�asynchronous�Q?/strong>�?strong>��d��Q�blocking�Q?非阻塞（non-blocking�Q?/strong>��L��会迷惑很多�h。依然记得我半年之前�?a title="MMORPG�|�络模型剖析——IOCP��? href="http://www.shnenglu.com/Fox/archive/2008/03/06/mmorpg_net_iocp.html" target="_blank">记述IOCP�Ӟ��一句不�l�意的�?strong>非阻塞I/O则是致力于提供高效的异步I/O”便引来一番口水论争�?/p>
今天在查一些资料的时候，看到关于�q�几个词的论辩竟不是一般的多，�l�细��x��Q�这个问题似乎也��实有解释的必要�Q�不在于争论寚w��Q�而在于��L明是非�?/p>
讨论之前�Q�先限定讨论的范��_��此处之同�?异步仅限于I/O操作�Q�与OS所讨论的进�E?�U�程中的其他同步/异步没有直接关系�Q�讨论的内容是：两对�怼�的术语之间的区别到底有多�?/strong>�?/p>

非常大：

Douglas C. Schmidt在《C++�|�络�~�程》中�q�样说到�Q?/p>
They are very different, as follows:

AIO is "asynchronous I/O", i.e., the operation is invoked asynchronously and control returns to the client while the OS kernel processes the I/O request. When the operation completes there is some mechanism for the client to retrieve the results.

Non-blocking I/O tries an operation (such as a read() or write()) and if it the operation would block (e.g., due to flow control on a TCP connection or due to lack of data in a socket), the call returns -1 and sets errno to EWOULDBLOCK.

��译如下�Q?/p>
异步I/O�Q�例如，操作被异步调用时�Q�控制权交给客户端，I/O操作��h��则交由操作系�l�内核处理，当操作完成后�Q�通过某种机制��结果通知客户端�?/p>
非阻塞I/O�Q�尝试调用某操作�Q�如果操作被��d��Q�则调用�q�回-1�q�置错误��gؓEWOULDBLOCK�?/p>
从这两段“very different”的解释来看�Q�我的感觉是�q�没有指��Z��者的区别�Q�因为我们无法确定所谓AIO是如何处理的�Q�如果AIO直接“调用返�?1�q�置错误��gؓEWOULDBLOCK”，实现“控制权交给客户端”，��g��q�无��M��不妥。况且，对于非阻塞I/O�Q�我们也需要“当操作完成后，通过某种机制��结果通知客户端”这��L��处理�?/p>

无差别：

而在Wikipedia上则直接�{�同二者：Asynchronous I/O, or non-blocking I/O, is a form of input/output processing that permits other processing to continue before the transmission has finished.

当然�Q�对于recv和send�Q�我们一般会说他们是��d����L��Q�而不会说他们�?strong>同步��L��Q�但�q�显然不是二者的区别�Q�因为我们都知道�Q?strong>��d��的原因正是等待同步结果的�q�回�?/p>
因此�Q�二者的区别在于�Q?strong>��d��/非阻塞是表现�Q�同�?异步是原�?/strong>�Q�我们说某某操作是阻塞�v的，或者某某线�E�是��d��L��Q�是因�ؓ在等待操作结果的同步�q�回�Q�我们说某某操作是非��d��的，是因为操作结果会通过异步方式�q�回�?/p>
讨论到这儿，再咬文嚼字的争辩下去��g��已经没有��M��实际意义�?/p>
------------------------------------------------------------

PS�Q�纠�l�一些必要的概念是�ؓ了加��q��解，太过�U�结了反倒会滞塞理解。我之前对于其概念也�q��特别清楚�Q�所以才会再�l�一��特意言明，也算弥补一下自��q��q�失�?/p>

Fox 2008-09-11 01:11 发表评论

Fox — Wed, 06 Aug 2008 07:43:00 GMT

0. Introduction

接触设计模式有两�q�时间了�Q�但一直没有系�l�整理过�Q��ؓ了不至于让自��q��思维被繁琐的工作一点点��锢�Q�还是决定�ȝ��一下，��Z��能够真正做到有所收获�Q�整个系列会按照GoF的Design Patterns: Elements of Reusable Object-Oriented Software的行文思�\�Q�但不会照本宣科��是了，Wikipedia上关�?3�U�设计模式的介绍非常全面�Q�CSDN上也可以下蝲�?英文电子档，因此很多套话、类图一概省厅R�?/p>
最早接触设计模式的时候，隑օ�被各�U�模式的联系和区别所困扰�Q�从教科书的分析可以得到模式之间形式上的不同。但�q�样对于领会设计模式意义不大�Q�因为我们掌握模式的目的是�ؓ了融会诏通，灉|��q�用�Q�以对开发有所帮助�?/p>
�E�微成规模的OO�E�序�Q�会有大量对象，其中很多实体对象之间存在着父子、兄�?/strong>关系�Q�对象的创徏提升��Z��U�模式。其好处在于设计模式本��n所宣称�?strong>reusable�Q�这��像堆积木盖房子一��P��堆的好的情况下，换一换门�H�便是另一番风景�?/p>
关于实现�Q�我不会��Z��厘清模式间的区别而刻意��用相��g��码实玎ͼ�相反�Q�我会根据模式本�w�的适用情况举例�Q�而且大量代码��Z��SourceMaking�?/p>
_______________________________

1. Creational Design Patterns(DP)

创徏型DP抽象了类和对象的创徏�q�程�Q?a title="Gang of Four" target=_blank>GoF�l�出�?�U?strong>创徏型DP�Q?strong>Abstract Factory�?strong>Builder�?strong>Factory Method�?strong>Builder�?strong>Prototype�?strong>Singleton�?/p>
2. Abstract Factory

意图�Q�提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无需指定它们具体的类�?/strong>

1) 只提供了一个创建接口，其返回��gؓ具体产品�Q�如AbstractProduct *Client::CreateProduct(AbstractFactory &factory);

2) 接口的参数是一�?strong>工厂对象�Q?code>AbstractFactory &factory�Q�的引用�Q�参数类型（AbstractFactory�Q��ؓ抽象基类�Q�调用时�Ҏ��需要传入具体工厂对象即可；

3) 接口内部实现�?strong>一�p�d��相关或相互依赖对�?/strong>�Q�抽象��品）的创建：当传入具体工厂时�Q�接口实现的��是一�p�d��具体产品的创建；

4) 创徏的��?strong>立即�q�回�Q?code>CreateProduct�Q��?/p>
参与者：

• AbstractFactory
�?声明一个创建抽象��品对象的操作接口�?/p>
• ConcreteFactory
�?实现创徏具体产品对象的操作�?/p>
• AbstractProduct
�?��Z��c�M�品对象声明一个接口�?/p>
• ConcreteProduct
�?定义一个将被相应的具体工厂创徏的��品对象�?br>�?实现AbstractProduct接口�?/p>
• Client
�?仅��用由AbstractFactory和AbstractProduct�c�d��明的接口�?/p>
代码�Q?/strong>
class AbstractFactory { public:     virtual AbstractProduct *MakePartA() = 0;     virtual AbstractProduct *MakePartB() = 0;     virtual AbstractProduct *MakePartC() = 0;     virtual AbstractProduct *AddPart(const AbstractProduct *pPart) = 0; }; AbstractProduct *Client::CreateProduct(AbstractFactory &factory) {     AbstractProduct *pProduct = factory.CreateProduct();     AbstractProduct *pPartA = factory.MakePartA();     AbstractProduct *pPartB = factory.MakePartB();     AbstractProduct *pPartC = factory.MakePartC();     factory.AddPart(pPartA);     factory.AddPart(pPartB);     factory.AddPart(pPartC);     return pProduct; }
int main(void) {     Client client;                ConcreteFactory factory;     client.CreateProduct(factory);     return 0; }
3. Builder

意图�Q�将一个复杂对象的构徏与它的表�C�分��，使得同样的构��E�可以创��Z��同的表示�?/strong>

1) director提供抽象产品创徏接口�Q�如void Director::Construct();

2) 不同产品使用同一创徏�q�程�Q�由director指定特定builder以生产不同��品；

3) 接口内部实现�?strong>一个复杂对�?/strong>�Q�抽象��品）的创建：当传入具体工厂时�Q�接口实现的�?strong>一个复杂的具体产品的创建；

4) 创徏的��?strong>�q�不立即�q�回�Q?strong>创徏完毕后返回，�?strong>使用接口�Q?code>GetProduct�Q�提取结果�?/p>
参与者：

• Builder
�?为创��Z��个Product对象的各个部件指定抽象接口�?/p>
• ConcreteBuilder
�?实现Builder的接口以构造和装配该��品的各个部�g�?br>�?定义�q�明��它所创徏的表�C��?br>�?提供一个检索��品的接口�?/p>
• Director
�?构造一个��用Builder接口的对象�?/p>
• Product
�?表示被构造的复杂对象。ConcreteBuilder创徏该��品的内部表示�q�定义它的装配过�E��?br>�?包含定义�l�成部�g的类�Q�包括将�q�些部�g装配成最�l��品的接口�?/p>
代码�Q?/strong>
class Builder { public:     virtual void MakePartA() = 0;     virtual void MakePartB() = 0;     virtual void MakePartC() = 0;     Product *GetProduct()    { return _product; } protected:     Product *_product; }; class Director { public:     void setBuilder(Builder *b)    { _builder = b; }     void Construct(); private:     Builder *_builder; }; void Director::Construct() {     _builder.MakePartA();     _builder.MakePartB();     _builder.MakePartC(); } int main(void) {     ConcreteBuilderA concreteBuilderA;     ConcreteBuilderB concreteBuilderB;     Director director;     Product *pProduct;     director.SetBuilder(&concreteBuilderA);     director.Construct();     pProduct = concreteBuilderA.GetProduct();     pProduct->Show();     director.SetBuilder(&concreteBuilderB);     director.Construct();     pProduct = concreteBuilderB.GetProduct();     pProduct->Show();
    return 0;}

4. Factory Method

意图�Q�定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类。Factory Method使一个类的实例化延迟到其子类�?/strong>

1) 看得��模式其实��是C++的多态特�?/strong>�Q��?strong>�l�承实现。因此，其别名�ؓ虚构造器�Q?Virtual Constructor�Q?/strong>�Q?/p>
2) 作�ؓ模式与C++多态特性不同的是，Creator可以定义工厂�Ҏ��的缺省实�?/strong>�Q�完成缺省操作，MFC大量使用了这一思想�?/p>
参与者：

• Product
�?定义工厂�Ҏ��所创徏的对象的接口�?/p>
• ConcreteProduct
�?实现Product接口�?/p>
• Creator
�?声明工厂�Ҏ��Q�该�Ҏ��q�回一个Product�c�d��的对象。Creator也可以定义一个工厂方法的�~�省实现�Q�它�q�回一个缺省的ConcreteProduct对象�?br>�?可以调用工厂�Ҏ��以创��Z��个Product对象�?/p>
• ConcreteCreator
�?重定义工厂方法以�q�回一个ConcreteProduct实例�?/p>
代码�Q?/strong>

ConcreteProduct *ConcreteCreator::FactoryMethod() {     ConcreteProduct *pProduct = new ConcreteProduct;     return pProduct; }

Product *Creator::FactoryMethod() {     Product *pProduct = new Product;     return pProduct; }
int main(void) {     Creator creator;     ConcreteProduct *pProduct;     pProduct = creator.FactoryMethod();     pProduct->Show();
    return 0; }
5. Prototype

意图�Q�用原型实例指定创徏对象的种�c�，�q�且通过拯��q�些原型创徏新的对象�?/strong>

1) 创徏不再通过工厂新类�l�承�Q�inheritance�Q?/strong>�Q�而是通过委托�Q�delegation�Q?/strong>�Q?/p>
2) 栚w�?strong>拯��原型实例创徏新对象�?/p>
参与者：

• ProtoType
�?声明一个克隆自�w�的接口�?/p>
• ConcreteProtoType
�?实现一个克隆自�w�的操作�?/p>
• Client
�?让一个原型克隆自�w�从而创��Z��个新的对象�?/p>
代码�Q?/strong>
class ProtoType { public:     virtual void Draw();     virtual ProtoType *Clone() = 0;     virtual void Initialize(); }; class ProtoTypeA: public ProtoType { public:     virtual ProtoType *Clone()     {         return new ProtoTypeA;     } }; class ProtoTypeB: public ProtoType { public:     virtual ProtoType *Clone()     {         return new ProtoTypeB;     } }; class Client { public:     static ProtoType *Clone( int choice ); private:     static ProtoType *s_prototypes[3]; }; ProtoType* Client::s_prototypes[] = { 0, new ProtoTypeA, new ProtoTypeB };
ProtoType *Client::Clone(int choice) {     return s_prototypes[choice]->Clone(); }

6. Singleton

意图�Q�保证一个类仅有一个实例，�q�提供一个访问它的全局讉K��炏V�?/strong>

1) �?strong>静态成员函�?/strong>保证上述意图�?/p>
参与者：

• Singleton
�?定义一个Instance操作�Q�允许客戯��问它的唯一实例。Instance是一个类操作�Q�即C++中的一个静态成员函敎ͼ��?br>�?可能负责创徏它自��q��唯一实例�?/p>

代码�Q?/strong>
class Singleton { public:     static Singleton *GetInstance()     {         if (!s_instance)             s_instance = new Singleton;         return s_instance;     }     void Run()    {} private:     static Singleton *s_instance;     Singleton()    {}                // Singleton cannot be created outside. }; Singleton *GetSingleton(void) {     return Singleton::GetInstance(); } int main(void) {     GetSingleton()->Run();     return 0; }
______________________________________________

代码写的都比较简单，基本可以��各�U�模式之间的不同体现出来了�?/p>

Fox 2008-08-06 15:43 发表评论

Fox — Wed, 30 Jul 2008 06:48:00 GMT

一、Big-endian & Little-endian

�q�是Wikipedia好啊�Q�可惜中文的国内看不了，愚昧啊！实在觉得中文有点难懂�Q�看�?a title="Wikipedia 日本语版�? target="_blank">日本语版�?/a>�?D�Q?/p>
关于端（endianness�Q?/strong>的介�l�，Wikipedia上比较全了：http://en.wikipedia.org/wiki/Endianness

关于�|�络字节序（network byte order�Q?/strong>�?strong>��L��字节序（host byte order�Q?/strong>�Q�说来挺无关紧要的一点东西，因�ؓ每次��L��忘掉�Q�所以每�ơ都要好奇的看看大端�Q�big-endian�Q?/strong>�?strong>��端�Q�little-endian�Q?/strong>�?/p>
�l�定unsigned long型整数十六进制�Ş式：0x0A0B0C0D�Q�其big-endian和little-endian形式分别为：

1) Big-endian

Memory |... | 8-bit atomic element size       | ...    | 16-bit atomic element size
| 0x0A | a                               | 0x0A0B | a| 0x0B | a+1                             | 0x0C0D | a+1
| 0x0C | a+2| 0x0D | a+3| ... |

2) Little-endian�Q�X86�Q?/strong>

Memory |... | 8-bit atomic element size       | ...    | 16-bit atomic element size
| 0x0D | a                               | 0x0C0D | a| 0x0C | a+1                             | 0x0A0B | a+1
| 0x0B | a+2| 0x0A | a+3| ... |

Mapping registers to memory locations (from Wikipedia)

��Z��么X86存储会��用little-endian�Q��v初我惛_��于位�q�算�Q�尤其是位移�q�算�Q�little-endian很方便，但�{念一惻I��big-endian也方便啊�Q�无非是左移和右�Uȝ��区别而已�Q�但little-endian的优势在于unsigned char/short/int/long�c�d��转换�Ӟ��存储位置无需改变�?/p>
在网�l�传输中�Q�采用big-endian序，对于0x0A0B0C0D�Q�传输顺序就�?tt>0A 0B 0C 0D�Q�因此big-endian作�ؓnetwork byte order�Q�little-endian作�ؓhost byte order�?/p>
________________________________________________

PS�Q�做鸡有什么不好？

上午跟某同事�Q��ؓ��重虑，下文以Y�U�C��Q�躲在犄角旮旯抽烟。以下�ؓ场景再现�Q?/p>
�Q�忽然整出来一句）Y�Q�听�q�鹰的故事没有？

�Q�满脸疑惑）Fox�Q�没有�?/p>
Y�Q�一只小鹰掉到鸡�H�里�Q?$@%…�?/p>
F�Q�我不是鹎ͼ�我就是一只鸡�Q�做~~技�?/strike>鸡有什么不好？~~

Y�Q�做技术没有不好啊…�?/p>
F�Q�我不是说做技术，我说做鸡�Q�我��是在地上走的，我�ؓ什么��L��要抬头看天？

Y�Q�你要往上看�Q�没有�h注定不能飞，XX以前也没有想�q�有一天会飞�v来�?/p>
F�Q�我不是掉到鸡窝里，我本来就在鸡�H�里�Q�我也喜�Ƣ呆在鸡�H�里�Q�别人都在地上走�Q�我��Z��么要飞�v来？

Y�Q�你总要飞�v来�?/p>
F�Q�我说了我喜�Ƣ呆在鸡�H�里�Q�你见过有那只鸡飞�v来了�Q?/p>
Y�Q�…�?/p>
F�Q�我��是一只鸡�Q�插了鸡��还是飞不�v来，况且�Q�我寚w��h��也没有�Q何兴��?/p>
Y�Q�…�?/p>
F�Q�做鸡有什么不好？

Y�Q�你看老毛�Q�与人斗其乐无穷�Q�他境界多高�Q�与天斗其乐无穷�Q�知道吧�Q�他已经不屑与�h斗了�?/p>
F�Q�我不喜�Ƣ与人斗�Q�我也斗不过�Q�做鸡有什么不好？

Y�Q�…�?/p>

Fox 2008-07-30 14:48 发表评论

[译]Google C++�~�程风格指南�Q�八�Q�[完]

Fox — Wed, 23 Jul 2008 06:28:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

规则之例�?/font>

前面说明的编码习惯基本是强制性的�Q�但所有优�U�的规则都允许例外�?/p>
1. 现有不统一代码�Q�Existing Non-conformant Code�Q?/font>

对于现有不符合既定编�E�风格的代码可以�|�开一面�?/p>
当你修改使用其他风格的代码时�Q��ؓ了与代码原有风格保持一致可以不使用本指南约定。如果不攑ֿ�可以与代码原作者或现在的负责�h员商讨，��C��Q�一致性包括原有的一致性�?/p>
1. Windows代码�Q�Windows Code�Q?/font>

Windows�E�序员有自己的编码习惯，主要源于Windows的一些头文�g和其他Microsoft代码。我们希望�Q何�h都可以顺利读懂你的代码，所以针�Ҏ��有��^台的C++�~�码�l�出一个单独的指导�Ҏ��?/p>
如果你一直��用Windows�~�码风格的，�q�儿有必要重申一下某些你可能会忘记的指南�Q�译者注�Q�我怎么感觉像在被洗�?D�Q?/font>�Q?/p>
1) 不要使用匈牙利命名法�Q�Hungarian notation�Q�如定义整型变量�?code>iNum�Q?/font>�Q��用Google命名�U�定�Q�包括对源文件��?code>.cc扩展名；

2) Windows定义了很多原有内建类型的同义�?font color="#800000">�Q�译者注�Q�这一点，我也很反感）�Q�如DWORD�?code>HANDLE�{�等�Q�在调用Windows API时这是完全可以接受甚至鼓��q��Q�但�q�是��量使用原来的C++�c�d��Q�例如，使用const TCHAR *而不�?code>LPCTSTR�Q?/p>
3) 使用Microsoft Visual C++�q�行�~�译�Ӟ��?strong>警告�U�别讄��?或更�?/strong>�Q��ƈ��所有warnings当作errors处理�Q?/p>
4) 不要使用#pragma once;作�ؓ包含保护�Q��用C++标准包含保护�Q?strong>包含保护的文件�\径包含到��目树顶�?font color="#800000">�Q�译者注�Q?code>#include�Q?/font>�Q?/p>
5) 除非万不得已�Q�否则不使用��M��不标准的扩展�Q�如#pragma�?code>__declspec�Q�允�怋��?code>__declspec(dllimport)�?code>__declspec(dllexport)�Q�但必须通过DLLIMPORT�?code>DLLEXPORT�{�宏�Q�以便其他�h在共享��用这些代码时�Ҏ��攑ּ��q�些扩展�?/p>
在Windows上，只有很少一些偶��可以不遵守的规则：

1) 通常我们��止使用多重�l�承�Q�但在��?a title="Component Object Model (COM)" target="_blank">COM�?a title="Active Template Library (ATL)" target="_blank">ATL/WTL�c�L��可以使用多重�l�承�Q��ؓ了执�?a title="Component Object Model (COM)" target="_blank">COM�?a title="Active Template Library (ATL)" target="_blank">ATL/WTL�c�d��其接口时可以使用多重实现�l�承�Q?/p>
2) 虽然代码中不应��用异�?/strong>�Q�但�?a title="Active Template Library (ATL)" target="_blank">ATL和部�?a title="Standard Template Library (STL)" target="_blank">STL�Q�包括Visual C++的STL�Q�中异常被广泛��用，使用ATL�Ӟ��应定�?code>_ATL_NO_EXCEPTIONS以屏蔽异常，你要研究一下是否也屏蔽掉STL的异常，如果不屏蔽，开启编译器异常也可以，注意�q�只是�ؓ了编译STL�Q�自�׃��然不要写含异常处理的代码�Q?/p>
3) 通常每个��目的每个源文�g中都包含一个名�?code>StdAfx.h�?code>precompile.h的头文�g方便头文仉��~�译�Q��ؓ了��代码方便与其他项目共享，避免昑ּ�包含此文�Ӟ��precompile.cc除外�Q�，使用�~�译器选项/FI以自动包含；

4) 通常名�ؓresource.h、且只包含宏的资源头文�g�Q�不必拘泥于此风格指南�?/p>

团队合作

参考常识，保持一�?/strong>�?/p>
�~�辑代码�Ӟ��q��旉��看看��目中的其他代码�q�确定其风格�Q�如果其他代�?code>if语句中��用空��|��那么你也要��用。如果其中的注释用星��P��*�Q�围成一个盒子状�Q�你也这样做�Q?/p>
/********************************** * Some comments are here. * There may be many lines. **********************************/

�~�程风格指南的��用要点在于提供一个公��q��~�码规范�Q�所有�h可以把精力集中在实现内容而不是表现�Ş式上。我们给��Z��全局的风��D��范，但局部的风格也很重要�Q�如果你在一个文件中新加的代码和原有代码风格相去甚远的话�Q�这��q��坏了文�g本��n的整体美观也影响阅读�Q�所以要��量避免�?/p>
好了�Q�关于编码风格写的差不多了，代码本��n才是更有��的�Q�尽情��n受吧�Q?/p>
Benjy Weinberger
Craig Silverstein
Gregory Eitzmann
Mark Mentovai
Tashana Landray

______________________________________

译者：�l�于��d��了，前后历时两周�Q�整个过�E�中�Q�虽因工作关�p�d��有懈怠，但�ȝ��不是虎头蛇尾�Q��v码我的态度是非常认真的:D�Q�，无论是否能对你有所裨益�Q�对我而言�Q�至��是温习了一些以前知道的知识�Q�也学到了一些之前不知道的知�?/strong>�?/strong>
刚好�q�两天还不是特紧张，赶紧��d��了，要开始干�z�M��…�?/strong>

Fox 2008-07-23 14:28 发表评论

Fox — Wed, 23 Jul 2008 03:43:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

格式

代码风格和格式确实比较随意，但一个项目中所有�h遵��@同一风格是非常容易的�Q�作��Z��人未必同意下�q�格式规则的每一处，但整个项目服从统一的编�E�风格是很重要的�Q�这样做才能让所有�h在阅��d��理解代码时更加容易�?/p>
1. 行长度（Line Length�Q?/font>

每一行代码字�W�数不超�q?0�?/p>
我们也认识到�q�条规则是存有争议的�Q�但如此多的代码都遵照这一规则�Q�我们感觉一致性更重要�?/p>
优点�Q�提倡该原则的�h认�ؓ��他们调整�~�辑器窗口大��很野蛮。很多�h同时�q�排开几个�H�口�Q�根本没有多余空间拓宽某个窗口，��Z��窗口最大尺寸加以限定，一致��?0列宽�Q��ؓ什么要改变呢？

�~�点�Q�反对该原则的�h则认为更宽的代码行更易阅读，80列的限制是上个世�U?0�q�代的大型机的古板缺��P��C��讑֤��h��更宽的显�C�屏�Q�很��L��的可以显�C�更多代码�?/p>
�l�论�Q?0个字�W�是最大倹{��例外：

1) 如果一行注释包含了��过80字符的命令或URL�Q�出于复制粘贴的方便可以��过80字符�Q?/p>
2) 包含长�\径的可以��出80列，��量避免�Q?/p>
3) 头文件保护（防止重复包含�W�一��?/a>�Q�可以无视该原则�?/p>
2. 非ASCII字符�Q�Non-ASCII Characters�Q?/font>

��量不��用非ASCII字符�Q��用时必须使用 UTF-8格式�?/p>
哪怕是英文�Q�也不应��用��L��面的文本��编码到源代码中�Q�因此非ASCII字符要少用。特�D�情况下可以适当包含此类字符�Q�如�Q�代码分析外部数据文件时�Q�可以适当��编码数据文件中作�ؓ分隔�W�的非ASCII字符�Ԍ��更常用的是（不需要本地化的）单元��试代码可能包含非ASCII字符丌Ӏ�此�c�L��况下�Q�应使用UTF-8格式�Q�因为很多工具都可以理解和处理其�~�码�Q�十六进制编码也可以�Q�尤其是在增强可��L��的情况下——如"\xEF\xBB\xBF"是Unicode�?a title="zero-width no-break space" target="_blank">zero-width no-break space字符�Q�以UTF-8格式包含在源文�g中是不可见的�?/p>
3. �I�格�q�是制表位（Spaces vs. Tabs�Q?/font>

只��用空��|��每次�~�进2个空根{�?/p>
使用�I�格�q�行�~�进�Q�不要在代码中��用tabs�Q�设定编辑器��tab转�ؓ�I�格�?/p>
译者注�Q�在前段旉��?/strong>关于Debian开发学习日�?/strong>一文中�Q�曾�l�出针对C/C++�~�码使用的vim配置�?/strong>

4. 函数声明与定义（Function Declarations and Definitions�Q?/font>

�q�回�c�d��和函数名在同一行，合适的话，参数也放在同一行�?/p>
函数看上��d��q�样�Q?/p>
ReturnType ClassName::FunctionName(Type par_name1, Type par_name2) { DoSomething(); ... }

如果同一行文本较多，容不下所有参敎ͼ�
ReturnType ClassName::ReallyLongFunctionName(Type par_name1, Type par_name2, Type par_name3) { DoSomething(); ... }

甚至�q�第一个参数都放不下：
ReturnType LongClassName::ReallyReallyReallyLongFunctionName( Type par_name1, // 4 space indent Type par_name2, Type par_name3) { DoSomething(); // 2 space indent ... }

注意以下几点�Q?/p>
1) �q�回值��L��和函数名在同一行；

2) 左圆括号�Q�open parenthesis�Q?/font>��L��和函数名在同一行；

3) 函数名和左圆括号间没有空��|��

4) 圆括号与参数间没有空��|��

5) 左大括号�Q�open curly brace�Q?/font>��d��最后一个参数同一行的末尾处；

6) 叛_��括号�Q�close curly brace�Q?/font>��L��单独位于函数最后一行；

7) 叛_��括号�Q�close parenthesis�Q?/font>和左大括号间��L��有一个空��|��

8) 函数声明和实现处的所有�Ş参名�U�必��M��持一��_��

9) 所有�Ş参应��可能对齐；

10) �~�省�~�进�?个空��|��

11) 独立��装的参��C��?个空格的�~�进�?/p>
如果函数�?code>const的，关键�?code>const应与最后一个参��C��于同一行�?/p>
// Everything in this function signature fits on a single line ReturnType FunctionName(Type par) const { ... } // This function signature requires multiple lines, but // the const keyword is on the line with the last parameter. ReturnType ReallyLongFunctionName(Type par1, Type par2) const { ... }

如果有些参数没有用到�Q�在函数定义处将参数名注释�v来：
// Always have named parameters in interfaces. class Shape { public: virtual void Rotate(double radians) = 0; } // Always have named parameters in the declaration. class Circle : public Shape { public: virtual void Rotate(double radians); } // Comment out unused named parameters in definitions. void Circle::Rotate(double /*radians*/) {}
// Bad - if someone wants to implement later, it's not clear what the // variable means. void Circle::Rotate(double) {}

译者注�Q�关于UNIX/Linux风格��Z��么要把左大括��L��于行��（.cc文�g的函数实现处�Q�左大括号位于行首）�Q�我的理解是代码看上��L��较简�U�，��x��行首除了函数体被一对大括号��在一起之外，只有叛_��括号的代码看上去��实也舒服；Windows风格��左大括��L��于行首的优点是匹配情况一目了然�?/strong>

5. 函数调用�Q�Function Calls�Q?/font>

��量攑֜�同一行，否则�Q�将实参��装在圆括号中�?/p>
函数调用遵��@如下形式�Q?/p>
bool retval = DoSomething(argument1, argument2, argument3);

如果同一行放不下�Q�可断�ؓ多行�Q�后面每一行都和第一个实参对齐，左圆括号后和叛_��括号前不要留�I�格�Q?/p>
bool retval = DoSomething(averyveryveryverylongargument1, argument2, argument3);

如果函数参数比较多，可以��Z��可读性的考虑每行只放一个参敎ͼ�
bool retval = DoSomething(argument1, argument2, argument3, argument4);

如果函数名太长，以至于超�q�行最大长度，可以��所有参数独立成行：
if (...) { ... ... if (...) { DoSomethingThatRequiresALongFunctionName( very_long_argument1, // 4 space indent argument2, argument3, argument4); }

6. 条�g语句�Q�Conditionals�Q?/font>

更提倡不在圆括号中添加空��|��关键�?code>else另�v一行�?/p>
对基本条件语句有两种可以接受的格式，一�U�在圆括号和条�g之间有空��|��一�U�没有�?/p>
最常见的是没有�I�格的格式，那种都可以，�q�是一致�?/strong>��Z��。如果你是在修改一个文�Ӟ��参考当前已有格式；如果是写新的代码�Q�参考目录下或项目中其他文�g的格式，�q�在徘徊的话�Q�就不要加空��g��?/p>
if (condition) { // no spaces inside parentheses ... // 2 space indent. } else { // The else goes on the same line as the closing brace. ... }

如果你們֐�于在圆括号内部加�I�格�Q?/p>
if ( condition ) { // spaces inside parentheses - rare ... // 2 space indent. } else { // The else goes on the same line as the closing brace. ... }

注意所有情况下if和左圆括号间有个�I�格�Q�右圆括号和左大括号�Q�如果��用的话）间也要有个空��|��
if(condition) // Bad - space missing after IF. if (condition){ // Bad - space missing before {. if(condition){ // Doubly bad.
if (condition) { // Good - proper space after IF and before {.

有些条�g语句写在同一行以增强可读性，只有当语句简单�ƈ且没有��?code>else子句时��用：
if (x == kFoo) return new Foo(); if (x == kBar) return new Bar();

如果语句�?code>else分支是不允许的：
// Not allowed - IF statement on one line when there is an ELSE clause if (x) DoThis(); else DoThat();

通常�Q�单行语句不需要��用大括号�Q�如果你喜欢也无可厚非，也有��?code>if必须使用大括��P��
if (condition) DoSomething(); // 2 space indent. if (condition) { DoSomething(); // 2 space indent. }

但如果语句中哪一分支使用了大括号的话�Q�其他部分也必须使用�Q?/p>
// Not allowed - curly on IF but not ELSE if (condition) { foo; } else bar; // Not allowed - curly on ELSE but not IF if (condition) foo; else { bar; }

// Curly braces around both IF and ELSE required because // one of the clauses used braces. if (condition) { foo; } else { bar; }

7. 循环和开关选择语句�Q�Loops and Switch Statements�Q?/font>

switch语句可以使用大括号分块；�I��@环体应��?code>{}�?code>continue�?/p>
switch语句中的case块可以��用大括号也可以不用，取决于你的喜好，使用时要依下文所�q��?/p>
如果有不满��case枚�D条�g的��|��要��L��包含一�?code>default�Q�如果有输入值没�?code>case��d��理，�~�译器将报警�Q�。如�?code>default�怸�会执行，可以��单的使用assert�Q?/p>
switch (var) { case 0: { // 2 space indent ... // 4 space indent break; } case 1: { ... break; } default: { assert(false); } }

�I��@环体应��?code>{}�?code>continue�Q�而不是一个简单的分号�Q?/p>
while (condition) { // Repeat test until it returns false. } for (int i = 0; i < kSomeNumber; ++i) {} // Good - empty body. while (condition) continue; // Good - continue indicates no logic.
while (condition); // Bad - looks like part of do/while loop.

8. 指针和引用表辑ּ��Q�Pointers and Reference Expressions�Q?/font>

句点�Q?code>.�Q�或��头�Q?code>->�Q�前后不要有�I�格�Q�指�?地址操作�W�（*�?amp;�Q�后不要有空根{�?/p>
下面是指针和引用表达式的正确范例�Q?/p>
x = *p; p = &x; x = r.y; x = r->y;

注意�Q?/p>
1) 在访问成员时�Q�句�Ҏ��头前后没有�I�格�Q?/p>
2) 指针操作�W?code>*�?code>&后没有空根{�?/p>
在声明指针变量或参数�Ӟ��星号与类型或变量名紧挨都可以�Q?/p>
// These are fine, space preceding. char *c; const string &str; // These are fine, space following. char* c; // but remember to do "char* c, *d, *e, ...;"! const string& str;
char * c; // Bad - spaces on both sides of * const string & str; // Bad - spaces on both sides of &

同一个文�Ӟ��新徏或现有）中�v码要保持一致�?/p>
译者注�Q�个人比较习惯与变量紧挨的方�?/strong>�?/strong>

9. 布尔表达式（Boolean Expressions�Q?/font>

如果一个布��表辑ּ��过标准行宽�Q?0字符�Q�，如果断行要统一一下�?/p>
下例中，逻辑与（&&�Q�操作符��M��于行��：
if (this_one_thing > this_other_thing && a_third_thing == a_fourth_thing && yet_another & last_one) { ... }

两个逻辑与（&&�Q�操作符都位于行��，可以考虑额外插入圆括��P��合理使用的话对增强可��L��是很有帮助的�?/p>
译者注�Q�个人比较习惯逻辑�q�算�W�位于行首，逻辑关系一目了�Ӟ��各�h喜好而已�Q�至于加不加圆括��L��问题�Q�如果你对优先��了然于胸的话可以不加�Q�但可读性��L��差了�?/strong>�?/strong>

10. 函数�q�回��|��Return Values�Q?/font>

return表达式中不要使用圆括受��?/p>
函数�q�回时不要��用圆括号�Q?/p>
return x; // not return(x);

11. 变量及数�l�初始化�Q�Variable and Array Initialization�Q?/font>

选择=�q�是()�?/p>
需要做二者之间做出选择�Q�下面的形式都是正确的：
int x = 3; int x(3); string name("Some Name"); string name = "Some Name";

12. 预处理指令（Preprocessor Directives�Q?/font>

预处理指令不要羃�q�，从行首开始�?/p>
即��预处理指令位于羃�q�代码块中，指��o也应从行首开始�?/p>
// Good - directives at beginning of line if (lopsided_score) { #if DISASTER_PENDING // Correct -- Starts at beginning of line DropEverything(); #endif BackToNormal(); }
// Bad - indented directives if (lopsided_score) { #if DISASTER_PENDING // Wrong! The "#if" should be at beginning of line DropEverything(); #endif // Wrong! Do not indent "#endif" BackToNormal(); }

13. �c�L��式（Class Format�Q?/font>

声明属性依�ơ序�?code>public:�?code>protected:�?code>private:�Q�每�ơ羃�q?个空�?font color="#800000">�Q�译者注�Q��ؓ什么不是两个呢�Q�也有�h提�?code>private在前�Q�对于声明了哪些数据成员一目了�Ӟ��q�有人提倡依逻辑关系��变量与操作攑֜�一��P��都有道理:-)�Q?/font>�?/p>
�c�d��明（对类注释不了解的话，参�?a title="[译]Google C++�~�程风格指南�Q�六�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/22/56873.html" target="_blank">�W�六��?/a>中的�c�L��?/strong>一节）的基本格式如下：
class MyClass : public OtherClass { public: // Note the 1 space indent! MyClass(); // Regular 2 space indent. explicit MyClass(int var); ~MyClass() {} void SomeFunction(); void SomeFunctionThatDoesNothing() { } void set_some_var(int var) { some_var_ = var; } int some_var() const { return some_var_; } private: bool SomeInternalFunction(); int some_var_; int some_other_var_; DISALLOW_COPY_AND_ASSIGN(MyClass); };

注意�Q?/p>
1) 所以基�c�d��应在80列限制下��量与子�c�d��攑֜�同一行；

2) 关键�?code>public:�?/code>protected:�?code>private:要羃�q?个空�?font color="#800000">�Q�译者注�Q�MSVC多��用tab�~�进�Q�且�q�三个关键词没有�~�进�Q?/font>�Q?/p>
3) 除第一个关键词�Q�一般是public�Q�外�Q�其他关键词前空一行，如果�c�L��较小的话也可以不�I�；

4) �q�些关键词后不要�I��Q?/p>
5) public攑֜�最前面�Q�然后是protected�?code>private�Q?/p>
6) 关于声明�ơ序参�?a title="[译]Google C++�~�程风格指南�Q�三�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/16/56324.html" target="_blank">�W�三��?/a>声明�ơ序一节�?/p>
14. 初始化列表（Initializer Lists�Q?/font>

构造函数初始化列表攑֜�同一行或按四格羃�q��ƈ排几行�?/p>
两种可以接受的初始化列表格式�Q?/p>
// When it all fits on one line: MyClass::MyClass(int var) : some_var_(var), some_other_var_(var + 1) {

�?/p>
// When it requires multiple lines, indent 4 spaces, putting the colon on // the first initializer line: MyClass::MyClass(int var) : some_var_(var), // 4 space indent some_other_var_(var + 1) { // lined up ... DoSomething(); ... }

15. 命名�I�间格式化（Namespace Formatting�Q?/font>

命名�I�间内容不羃�q��?/p>
命名�I�间不添加额外羃�q�层�ơ，例如�Q?/p>
namespace { void foo() { // Correct. No extra indentation within namespace. ... } } // namespace

不要�~�进�Q?/p>
namespace { // Wrong. Indented when it should not be. void foo() { ... } } // namespace

16. 水��^留白�Q�Horizontal Whitespace�Q?/font>

水��^留白的��用因地制宜。不要在行尾��d��无谓的留白�?/p>
普�?/strong>�Q?/p>
void f(bool b) { // Open braces should always have a space before them. ... int i = 0; // Semicolons usually have no space before them. int x[] = { 0 }; // Spaces inside braces for array initialization are int x[] = {0}; // optional. If you use them, put them on both sides! // Spaces around the colon in inheritance and initializer lists. class Foo : public Bar { public: // For inline function implementations, put spaces between the braces // and the implementation itself. Foo(int b) : Bar(), baz_(b) {} // No spaces inside empty braces. void Reset() { baz_ = 0; } // Spaces separating braces from implementation. ...

��d��冗余的留白会�l�其他�h�~�辑旉��成额外负担�Q�因此，不要加入多余的空根{��如果确定一行代码已�l�修改完毕，��多余的�I�格��L��Q�或者在专门清理�I�格时去掉（��信没有其他人在使用�Q��?/p>
循环和条件语�?/strong>�Q?/p>
if (b) { // Space after the keyword in conditions and loops. } else { // Spaces around else. } while (test) {} // There is usually no space inside parentheses. switch (i) { for (int i = 0; i < 5; ++i) { switch ( i ) { // Loops and conditions may have spaces inside if ( test ) { // parentheses, but this is rare. Be consistent. for ( int i = 0; i < 5; ++i ) { for ( ; i < 5 ; ++i) { // For loops always have a space after the ... // semicolon, and may have a space before the // semicolon. switch (i) { case 1: // No space before colon in a switch case. ... case 2: break; // Use a space after a colon if there's code after it.

操作�W?/strong>�Q?/p>
x = 0; // Assignment operators always have spaces around // them. x = -5; // No spaces separating unary operators and their ++x; // arguments. if (x && !y) ... v = w * x + y / z; // Binary operators usually have spaces around them, v = w*x + y/z; // but it's okay to remove spaces around factors. v = w * (x + z); // Parentheses should have no spaces inside them.

模板和�{�?/strong>�Q?/p>
vector x; // No spaces inside the angle y = static_cast(x); // brackets (< and >), before // <, or between >( in a cast. vector x; // Spaces between type and pointer are // okay, but be consistent. set > x; // C++ requires a space in > >. set< list > x; // You may optionally make use // symmetric spacing in < <.

17. 垂直留白�Q�Vertical Whitespace�Q?/font>

垂直留白��少��好�?/p>
�q�不仅仅是规则而是原则问题了：不是非常有必要的话就不要使用�I��。尤其是�Q�不要在两个函数定义之间�I��q?行，函数体头、尾不要有空行，函数体中也不要随意添加空行�?/p>
基本原则是：同一屏可以显�C��多的代码�Q�程序的控制��就��容易理解。当�Ӟ��q�于密集的代码块和过于疏杄��代码块同样难看，取决于你的判断，但通常是越��越好�?/p>
函数头、尾不要有空行：
void Function() { // Unnecessary blank lines before and after }

代码块头、尾不要有空行：
while (condition) { // Unnecessary blank line after } if (condition) { // Unnecessary blank line before }

if-else块之间空一行还可以接受�Q?/p>
if (condition) { // Some lines of code too small to move to another function, // followed by a blank line. } else { // Another block of code }

______________________________________

译者：首先说明�Q�对于代码格式，因�h、因�pȝ��各有优缺点，但同一个项目中遵��@同一标准�q�是有必要的�Q?
1. 行宽原则上不��过80列，�?2寸的昄��屏都占完�Q�怎么也说不过去；

2. ��量不��用非ASCII字符�Q�如果��用的话，参考UTF-8格式�Q�尤其是UNIX/Linux下，Windows下可以考虑宽字�W�）�Q�尽量不��字�W�串帔R��耦合��C��码中�Q�比如独立出资源文�g�Q�这不仅仅是风格问题了；

3. UNIX/Linux下无条�g使用�I�格�Q�MSVC的话使用Tab也无可厚非；

4. 函数参数、逻辑条�g、初始化列表�Q�要么所有参数和函数名放在同一行，要么所有参数�ƈ排分行；

5. 除函数定义的左大括号可以�|�于行首外，包括函数/�c?�l�构�?枚�D声明、各�U�语句的左大括号�|�于行尾�Q�所有右大括��L��立成行；

6. ./->操作�W�前后不留空��|��*/&不要前后都留�Q�一个就可，靠左靠右依各人喜好；

7. 预处理指�?命名�I�间不��用额外羃�q�，�c?�l�构�?枚�D/函数/语句使用�~�进�Q?/strong>

8. 初始化用=�q�是()依个人喜好，�l�一��好�Q?/strong>

9. return不要�?)�Q?/strong>

10. 水��^/垂直留白不要滥用�Q�怎么易读怎么来�?/strong>

Fox 2008-07-23 11:43 发表评论

Fox — Tue, 22 Jul 2008 09:02:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

注释

注释虽然写�v来很痛苦�Q�但对保证代码可��L��至为重要，下面的规则描�q�C��应该注释什么、注释在哪儿。当然也要记住，注释的确很重要，但最好的代码本��n��是文档�Q�self-documenting�Q?/font>�Q�类型和变量命名意义明确要比通过注释解释模糊的命名好得多�?/p>
注释是�ؓ别�h�Q�下一个需要理解你的代码的人）而写的，认真点吧�Q�那下一个�h可能��是你！

1. 注释风格�Q�Comment Style�Q?/font>

使用//�?code>/* */�Q�统一��好�?/p>
//�?code>/* */都可以，//只是用的更加�q�泛�Q�在如何注释和注释风��g��保�l�一�?/p>

2. 文�g注释�Q�File Comments�Q?/font>
在每一个文件开头加入版权公告，然后是文件内�Ҏ��q��?/p>
法律公告和作者信�?/strong>�Q?/p>
每一文�g包含以下��，依次是：

1) 版权�Q�copyright statement�Q?/font>�Q�如Copyright 2008 Google Inc.�Q?/p>
2) 许可版本�Q�license boilerplate�Q?/font>�Q��ؓ��目选择合适的许可证版本，�?a title="Apache License" target="_blank">Apache 2.0�?a title="BSD licenses" target="_blank">BSD�?a title="GNU Lesser General Public License" target="_blank">LGPL�?a title="GNU General Public License" target="_blank">GPL�Q?/p>
3) 作者（author line�Q?/font>�Q�标识文件的原始作者�?/p>
如果你对其他人创建的文�g做了重大修改�Q�将你的信息��d��C��者信息里�Q�这样当其他人对该文件有疑问时可以知道该联系谁�?/p>
文�g内容�Q?/p>
每一个文件版权许可及作者信息后�Q�都要对文�g内容�q�行注释说明�?/p>
通常�Q?code>.h文�g要对所声明的类的功能和用法作简单说明，.cc文�g包含了更多的实现�l�节或算法讨论，如果你感觉这些实现细节或��法讨论对于阅读有帮助，可以�?code>.cc中的注释攑ֈ�.h中，�q�在.cc中指出文档在.h中�?/p>
不要单纯�?code>.h�?code>.cc间复制注释，复制的注释偏��M��实际意义�?/p>
3. �c�L��释（Class Comments�Q?/font>

每个�cȝ��定义要附着描述�cȝ��功能和用法的注释�?/p>
// Iterates over the contents of a GargantuanTable. Sample usage: // GargantuanTable_Iterator* iter = table->NewIterator(); // for (iter->Seek("foo"); !iter->done(); iter->Next()) { // process(iter->key(), iter->value()); // } // delete iter; class GargantuanTable_Iterator { ... };

如果你觉得已�l�在文�g�剙��详细描述了该�c�，想直接简单的来上一句“完整描�q�见文�g�剙��”的话，�q�是多少在类中加�Ҏ��释吧�?/p>
如果�c�L��M��同步前提�Q�synchronization assumptions�Q?/font>�Q�文档说明之。如果该�cȝ��实例可被多线�E�访问，使用时务必注意文档说明�?/p>
4. 函数注释�Q�Function Comments�Q?/font>

函数声明处注释描�q�函数功能，定义处描�q�函数实现�?/p>
函数声明�Q?/p>
注释于声明之前，描述函数功能及用法，注释使用描述式（"Opens the file"�Q�而非指��o式（"Open the file"�Q�；注释只是��Z��描述函数而不是告诉函数做什么。通常�Q�注释不会描�q�函数如何实玎ͼ�那是定义部分的事情�?/p>
函数声明处注释的内容�Q?/p>
1) inputs�Q�输入）�?font color="#800000">outputs�Q�输出）�Q?/p>
2) 对类成员函数而言�Q�函数调用期间对象是否需要保持引用参敎ͼ�是否会释放这些参敎ͼ�

3) 如果函数分配了空��_��需要由调用者释放；

4) 参数是否可以�?code>NULL�Q?/p>
5) 是否存在函数使用�?font color="#800000">性能隐忧�Q�performance implications�Q?/font>�Q?/p>
6) 如果函数�?font color="#800000">可重入的�Q�re-entrant�Q?/font>�Q�其同步前提�Q�synchronization assumptions�Q?/font>是什么？

举例如下�Q?/p>
// Returns an iterator for this table. It is the client's // responsibility to delete the iterator when it is done with it, // and it must not use the iterator once the GargantuanTable object // on which the iterator was created has been deleted. // // The iterator is initially positioned at the beginning of the table. // // This method is equivalent to: // Iterator* iter = table->NewIterator(); // iter->Seek(""); // return iter; // If you are going to immediately seek to another place in the // returned iterator, it will be faster to use NewIterator() // and avoid the extra seek. Iterator* GetIterator() const;

但不要有无谓冗余或显而易见的注释�Q�下面的注释��没有必要加上“returns false otherwise”，因�ؓ已经暗含其中了：
// Returns true if the table cannot hold any more entries. bool IsTableFull();

注释构�?析构函数�Ӟ��C��Q�读代码的�h知道构�?析构函数是什么，所以“destroys this object”这��L��注释是没有意义的。说明构造函数对参数做了什么（例如�Q�是否是指针的所有者）以及析构函数清理了什么，如果都是无关紧要的内容，直接省掉注释�Q�析构函数前没有注释是很正常的�?/p>
函数定义�Q?/p>
每个函数定义时要以注释说明函数功能和实现要点�Q�如使用的漂亮代码、实现的��要步骤、如此实现的理由、�ؓ什么前半部分要加锁而后半部分不需要�?/p>
不要�?code>.h文�g或其他地方的函数声明处直接复制注释，��要说明函数功能是可以的，但重点要攑֜�如何实现上�?/p>
5. 变量注释�Q�Variable Comments�Q?/font>

通常变量名本�w��以很好说明变量用途，特定情况下，需要额外注释说明�?/p>
�c�L��据成�?/strong>�Q?/p>
每个�c�L��据成员（也叫实例变量或成员变量）应注释说明用途，如果变量可以接受NULL�?1�{?font color="#800000">警戒��|��sentinel values�Q?/font>�Q�须说明之，如：
private: // Keeps track of the total number of entries in the table. // Used to ensure we do not go over the limit. -1 means // that we don't yet know how many entries the table has. int num_total_entries_;

全局变量�Q�常量）�Q?/p>
和数据成员相��|��所有全局变量�Q�常量）也应注释说明含义及用途，如：
// The total number of tests cases that we run through in this regression test. const int kNumTestCases = 6;

6. 实现注释�Q�Implementation Comments�Q?/font>

对于实现代码中��y妙的、晦涩的、有��的、重要的地方加以注释�?/p>
代码前注�?/strong>�Q?/p>
出彩的或复杂的代码块前要加注释，如：
// Divide result by two, taking into account that x // contains the carry from the add. for (int i = 0; i < result->size(); i++) { x = (x << 8) + (*result)[i]; (*result)[i] = x >> 1; x &= 1; }

行注�?/strong>�Q?/p>
比较隐晦的地方要在行��֊�入注释，可以在代码之后空两格加行��注释，如：
// If we have enough memory, mmap the data portion too. mmap_budget = max(0, mmap_budget - index_->length()); if (mmap_budget >= data_size_ && !MmapData(mmap_chunk_bytes, mlock)) return; // Error already logged.

注意�Q�有两块注释描述�q�段代码�Q�当函数�q�回时注释提及错误已�l�被记入日志�?/p>
前后盔R��几行都有注释�Q�可以适当调整使之可读性更好：
... DoSomething(); // Comment here so the comments line up. DoSomethingElseThatIsLonger(); // Comment here so there are two spaces between // the code and the comment. ...

NULL、true/false�?�?�?…�?/strong>�Q?/p>
向函��C��入、布��值或整数�Ӟ��要注释说明含义，或��用常量让代码望文知意�Q�比较一下：
bool success = CalculateSomething(interesting_value, 10, false, NULL); // What are these arguments??

和：
bool success = CalculateSomething(interesting_value, 10, // Default base value. false, // Not the first time we're calling this. NULL); // No callback.

使用帔R��或描�q�性变量：
const int kDefaultBaseValue = 10; const bool kFirstTimeCalling = false; Callback *null_callback = NULL; bool success = CalculateSomething(interesting_value, kDefaultBaseValue, kFirstTimeCalling, null_callback);

不要�Q?/p>
注意永远不要用自然语�a��译代码作�ؓ注释�Q�要假设��M��代码的�hC++比你�?D�Q?/p>
// Now go through the b array and make sure that if i occurs, // the next element is i+1. ... // Geez. What a useless comment.

7. 标点、拼写和语法�Q�Punctuation, Spelling and Grammar�Q?/font>

留意标点、拼写和语法�Q�写的好的注释比差的要易�ȝ��多�?/p>
注释一般是包含适当大写和句点（.�Q�的完整的句子，短一点的注释�Q�如代码行尾的注释）可以随意点，依然要注意风格的一致性。完整的句子可读性更好，也可以说明该注释是完整的而不是一点不成熟的想法�?/p>
虽然被别人指��?font color="#800000">分号�Q�semicolon�Q?/font>的时候用�?font color="#800000">逗号�Q�comma�Q?/font>有点��尬。清晰易�ȝ��代码�q�是很重要的�Q�适当的标炏V��拼写和语法�Ҏ��会有所帮助�?/p>
8. TODO注释�Q�TODO Comments�Q?/font>

寚w��些��时的、短期的解决�Ҏ��Q�或已经够好但�ƈ不完��的代码使用TODO注释�?/p>
�q�样的注释要使用全大写的字符�?code>TODO�Q�后�?font color="#800000">括号�Q�parentheses�Q?/font>里加上你的大名、邮件地址�{�，�q�可以加�?font color="#800000">冒号�Q�colon�Q?/font>�Q�目的是可以�Ҏ��l�一�?code>TODO格式�q�行查找�Q?/p>
// TODO(kl@gmail.com): Use a "*" here for concatenation operator. // TODO(Zeke) change this to use relations.

如果加上是�ؓ了在“将来某一天做某事”，可以加上一个特定的旉��Q?Fix by November 2005"�Q�或事�g�Q?Remove this code when all clients can handle XML responses."�Q��?/p>
______________________________________

译者：注释也是比较人性化的约定了�Q?
1. 关于注释风格�Q�很多C++的coders更喜�Ƣ行注释�Q�C coders或许对块注释依然情有独钟�Q�或者在文�g头大�D�大�D늚�注释时��用块注释�Q?/strong>

2. 文�g注释可以炫耀你的成就�Q�也是�ؓ了捅了篓子别人可以找你；

3. 注释要言��意赅�Q�不要拖沓冗余，复杂的东西简单化和简单的东西复杂化都是要被鄙视的�Q?/strong>

4. 对于Chinese coders来说�Q�用英文注释�q�是用中文注释，it is a problem�Q�但不管怎样�Q�注释是��Z��让别人看懂，��N��是�ؓ了炫耀�~�程语言之外的你的母语或外语水��^吗；

5. 注释不要太�ؕ�Q�适当的羃�q�才会让��Z��意看�Q�但也没有必要规定注释从�W�几列开始（我自己写代码的时候��d��Ƣ这��P��Q�UNIX/LINUX下还可以�U�定是��用tab�q�是space�Q�个人們֐�于space�Q?/strong>

6. TODO很不错，有时候，注释��实是�ؓ了标��C��些未完成的或完成的不��如人意的地方，�q�样一搜烦�Q�就知道�q�有哪些�z�要�qԌ��日志都省了�?/strong>

Fox 2008-07-22 17:02 发表评论

Fox — Tue, 22 Jul 2008 03:59:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

命名�U�定

最重要的一致性规则是命名��理�Q�命名风格直接可以直接确定命名实体是�Q�类型、变量、函数、常量、宏�{�等�Q�无需查找实体声明�Q�我们大脑中的模式匹配引擎依赖于�q�些命名规则�?/p>
命名规则��h��一定随意性，但相比按个�h喜好命名�Q�一致性更重要�Q�所以不��你怎么惻I��规则��d��是规则�?/p>
1. 通用命名规则�Q�General Naming Rules�Q?/font>

函数命名、变量命名、文件命名应��h��描述性，不要�q�度�~�写�Q�类型和变量应该是名词，函数名可以用“命令性”动词�?/p>
如何命名�Q?
��可能给出描�q�性名�U�ͼ�不要节约�I�间�Q�让别�h很快理解你的代码更重要，好的命名选择�Q?pre>int num_errors; // Good. int num_completed_connections; // Good.

丑陋的命名��用模�p�的�~�写或随意的字符�Q?pre>int n; // Bad - meaningless. int nerr; // Bad - ambiguous abbreviation. int n_comp_conns; // Bad - ambiguous abbreviation.

�c�d��和变量名一般�ؓ名词�Q�如FileOpener�?code>num_errors�?
函数名通常是指令性的�Q�如OpenFile()�?code>set_num_errors()�Q�访问函数需要描�q�的更细��_��要与其访问的变量相吻合�?
�~�写�Q?
除非攑ֈ��目外也非常明了�Q�否则不要��用羃写，例如�Q?pre>// Good // These show proper names with no abbreviations. int num_dns_connections; // Most people know what "DNS" stands for. int price_count_reader; // OK, price count. Makes sense.

// Bad! // Abbreviations can be confusing or ambiguous outside a small group. int wgc_connections; // Only your group knows what this stands for. int pc_reader; // Lots of things can be abbreviated "pc".

不要用省略字母的�~�写�Q?pre>int error_count; // Good.
int error_cnt; // Bad.

2. 文�g命名�Q�File Names�Q?/font>
文�g名要全部��写�Q�可以包含下划线�Q�_�Q�或短线�Q?�Q�，按项目约定来�?/p>
可接受的文�g命名�Q?/p>
my_useful_class.cc my-useful-class.cc myusefulclass.cc

C++文�g�?code>.cc�l�尾�Q�头文�g�?code>.h�l�尾�?/p>
不要使用已经存在�?code>/usr/include下的文�g�?font color="#800000">�Q�译者注�Q�对UNIX、Linux�{�系�l�而言�Q?/font>�Q�如db.h�?/p>
通常�Q�尽量让文�g名更加明��，http_server_logs.h��比logs.h要好�Q�定义类时文件名一般成对出玎ͼ��?code>foo_bar.h�?code>foo_bar.cc�Q�对应类FooBar�?/p>
内联函数必须攑֜�.h文�g中，如果内联函数比较短，��q��接放�?code>.h中。如果代码比较长�Q�可以放��C��-inl.h�l�尾的文件中。对于包含大量内联代码的�c�，可以有三个文�Ӟ��
url_table.h // The class declaration. url_table.cc // The class definition. url_table-inl.h // Inline functions that include lots of code.

参�?a title="[译]Google C++�~�程风格指南�Q�一�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/10/55818.html" target="_blank">�W�一��?/a>-inl.h文�g一节�?/p>
3. �c�d��命名�Q�Type Names�Q?/font>

�c�d��命名每个单词以大写字母开��_��不包含下划线�Q?code>MyExcitingClass�?code>MyExcitingEnum�?/p>
所有类型命名——类、结构体、类型定义（typedef�Q�、枚�䏀�—��用相同约定，例如�Q?/p>
// classes and structs class UrlTable { ... class UrlTableTester { ... struct UrlTableProperties { ... // typedefs typedef hash_map PropertiesMap; // enums enum UrlTableErrors { ...

4. 变量命名�Q�Variable Names�Q?/font>

变量名一律小写，单词间以下划�U�相�q�，�cȝ��成员变量以下划线�l�尾�Q�如my_exciting_local_variable�?code>my_exciting_member_variable_�?/p>
普通变量命�?/strong>�Q?/p>
举例�Q?/p>
string table_name; // OK - uses underscore. string tablename; // OK - all lowercase.
string tableName; // Bad - mixed case.

�c�L��据成�?/strong>�Q?/p>
�l�构体的数据成员可以和普通变量一��P��不用像类那样接下划线�Q?/p>
struct UrlTableProperties { string name; int num_entries; }

�l�构体与�cȝ��讨论参�?a title="[译]Google C++�~�程风格指南�Q�三�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/16/56324.html" target="_blank">�W�三��?/a>�l�构体vs.�c?/strong>一节�?/p>
全局变量�Q?/p>
对全局变量没有特别要求�Q�少用就好，可以�?code>g_或其他易与局部变量区分的标志为前�~��?/p>
5. 帔R��命名�Q�Constant Names�Q?/font>

在名�U�前�?code>k�Q?code>kDaysInAWeek�?/p>
所有编译时帔R��Q�无论是局部的、全局的还是类中的�Q�和其他变量保持些许区别�Q?code>k后接大写字母开头的单词�Q?/p>
const int kDaysInAWeek = 7;

6. 函数命名�Q�Function Names�Q?/font>

普通函敎ͼ�regular functions�Q�译者注�Q�这里与讉K��函数�{�特�D�函数相对）大小写�؜合，存取函数�Q�accessors and mutators�Q?/font>则要求与变量名匹配：MyExcitingFunction()�?code>MyExcitingMethod()�?code>my_exciting_member_variable()�?code>set_my_exciting_member_variable()�?/p>
普通函�?/strong>�Q?/p>
函数名以大写字母开��_��每个单词首字母大写，没有下划�U�：
AddTableEntry() DeleteUrl()

存取函数�Q?/p>
存取函数要与存取的变量名匚w��Q�这儿摘录一个拥有实例变�?code>num_entries_的类�Q?/p>
class MyClass { public: ... int num_entries() const { return num_entries_; } void set_num_entries(int num_entries) { num_entries_ = num_entries; } private: int num_entries_; };

其他短小的内联函数名也可以��用小写字母，例如�Q�在循环中调用这��L��函数甚至都不需要缓存其��|��写命名��可以接受�?/p>
译者注�Q�从�q�一点上可以看出�Q�小写的函数名意味着可以直接内联使用�?/strong>

7. 命名�I�间�Q�Namespace Names�Q?/font>

命名�I�间的名�U�是全小写的�Q�其命名��Z��目名称和目录结构：google_awesome_project�?/p>
关于命名�I�间的讨论和如何命名�Q�参�?a title="[译]Google C++�~�程风格指南�Q�二�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/14/56109.html" target="_blank">�W�二��?/a>命名�I�间�?/p>
8. 枚�D命名�Q�Enumerator Names�Q?/font>

枚�D值应全部大写�Q�单词间以下划线相连�Q?code>MY_EXCITING_ENUM_VALUE�?/p>
枚�D名称属于�c�d��Q�因此大��写混合�Q?code>UrlTableErrors�?/p>
enum UrlTableErrors { OK = 0, ERROR_OUT_OF_MEMORY, ERROR_MALFORMED_INPUT, };

9. 宏命名（Macro Names�Q?/font>

你�ƈ不打��用宏�Q�对吧？如果使用�Q�像�q�样�Q?code>MY_MACRO_THAT_SCARES_SMALL_CHILDREN�?/p>
参�?a title="[译]Google C++�~�程风格指南�Q�四�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/21/56760.html" target="_blank">�W�四��?/a>预处理宏�Q�通常是不使用宏的�Q�如果绝对要用，其命名像枚�D命名一样全部大写、��用下划线�Q?/p>
#define ROUND(x) ... #define PI_ROUNDED 3.0 MY_EXCITING_ENUM_VALUE

10. 命名规则例外�Q�Exceptions to Naming Rules�Q?/font>

当命名与现有C/C++实体�怼�的对象时�Q�可参考现有命名约定：

bigopen()
函数名，参�?code>open()
uint
typedef�c�d��定义
bigpos
struct�?code>class�Q�参�?/code>pos
sparse_hash_map
STL�怼�实体�Q�参考STL命名�U�定
LONGLONG_MAX
帔R��Q�类�?code>INT_MAX

______________________________________

译者：命名�U�定��q��对轻松许多，在遵从代码一致性、可��L��的前提下，略显随意�Q?
1. ��M��规则�Q�不要随意羃写，如果说ChangeLocalValue写作ChgLocVal�q�有情可原的话，把ModifyPlayerName写作MdfPlyNm��太�q�分了，除函数名可适当为动词外�Q�其他命名尽量��用清晰易懂的名词�Q?/strong>

2. 宏、枚丄��使用全部大写+下划�U�；

3. 变量�Q�含�c�R��结构体成员变量�Q�、文件、命名空间、存取函数等使用全部��写+下划�U�，�c�L��员变量以下划�U�结��，全局变量以g_开��_��

4. 普通函数、类型（含类与结构体、枚丄��型）、常量等使用大小写�؜合，不含下划�U�；

5. 参考现有或相近命名�U�定�?/strong>

Fox 2008-07-22 11:59 发表评论

Fox — Mon, 21 Jul 2008 06:55:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

Google�Ҏ��的风�?/font>

Google有很多自己实现的使C++代码更加健壮的技巧、功能，以及有异于别处的C++的��用方式�?/p>
1. ��指针�Q�Smart Pointers�Q?/font>

如果��实需要��用智能指针的话，scoped_ptr完全可以胜�Q。在非常�Ҏ��的情况下�Q�例如对STL容器中对象，你应该只使用std::tr1::shared_ptr�Q��Q何情况下都不要��用auto_ptr�?/p>
“智能”指针看上去是指针，其实是附加了语义的对象。以scoped_ptr��Z��Q�scoped_ptr被销毁时�Q�删除了它所指向的对象。shared_ptr也是如此�Q�而且�Q�shared_ptr实现�?font color="#800000">引用计数�Q�reference-counting�Q?/font>�Q�从而只有当它所指向的最后一个对象被销毁时�Q�指针才会被删除�?/p>
一般来��_��我们們֐�于设计对象隶属明��的代码�Q�最明确的对象隶属是�Ҏ��不��用指针，直接��对象作��Z��?font color="#800000">域（field�Q?/font>或局部变量��用。另一�U�极端是引用计数指针不属于�Q何对象，�q�样设计的问题是�Ҏ��D��循环引用或其他导致对象无法删除的诡异条�g�Q�而且在每一�ơ拷贝或赋值时�q�原子操作都会很慢�?/p>
虽然不推荐这么做�Q�但有些时候，引用计数指针是最��单有效的解决�Ҏ��?
译者注�Q�看来，Google所谓的不同之处�Q�在于尽量避免��用智能指�?D�Q��用时也尽量局部化�Q��ƈ且，安全�W�一�?/strong>

其他C++�Ҏ�?/font>

1. 引用参数�Q�Reference Arguments�Q?/font>

所以按引用传递的参数必须加上const�?/p>
定义�Q?/strong>在C语言中，如果函数需要修改变量的��|��形参�Q�parameter�Q?/font>必须为指针，如int foo(int *pval)。在C++中，函数�q�可以声明引用�Ş参：int foo(int &val)�?/p>
优点�Q?/strong>定义形参为引用避免了�?*pval)++�q�样丑陋的代码，像拷贝构造函数这��L��应用也是必需的，而且不像指针那样不接受空指针NULL�?/p>
�~�点�Q?/strong>�Ҏ��引�v误解�Q�因为引用在语法上是值却拥有指针的语义�?/p>
�l�论�Q?/strong>

函数形参表中�Q�所有引用必��L��const�Q?/p>
void Foo(const string &in, string *out);

事实上这是一个硬性约定：输入参数为值或常数引用�Q�输出参��Cؓ指针�Q�输入参数可以是常数指针�Q�但不能使用非常数引用�Ş参�?/p>
在强调参��C��是拷贝而来�Q�在对象生命期内必须一直存在时可以使用常数指针�Q�最好将�q�些在注释中详细说明。bind2nd和mem_fun�{�STL适配器不接受引用形参�Q�这�U�情况下也必��M��指针形参声明函数�?/p>
2. 函数重蝲�Q�Function Overloading�Q?/font>

仅在输入参数�c�d��不同、功能相同时使用重蝲函数�Q�含构造函敎ͼ��Q�不要��用函数重载模仿缺省函数参数�?/p>
定义�Q?/strong>可以定义一个函数参数类型�ؓconst string&�Q��ƈ定义光��载函数类型�ؓconst char*�?/p>
class MyClass { public: void Analyze(const string &text); void Analyze(const char *text, size_t textlen); };

优点�Q?/strong>通过重蝲不同参数的同名函敎ͼ�令代码更加直观，模板化代码需要重载，同时��问者带来便利�?/p>
�~�点�Q?/strong>限制使用重蝲的一个原因是在特定调用处很难��定到底调用的是哪个函数�Q�另一个原因是当派生类只重载函数的部分变量会��o很多人对�l�承语义产生困惑。此外在阅读库的客户端代码时�Q�因�~�省函数参数造成不必要的费解�?/p>
�l�论�Q?/strong>如果你想重蝲一个函敎ͼ�考虑让函数名包含参数信息�Q�例如，使用AppendString()、AppendInt()而不是Append()�?/p>
3. �~�省参数�Q�Default Arguments�Q?/font>

��止使用�~�省函数参数�?/p>
优点�Q?/strong>�l�常用到一个函数带有大量缺省��|��偶尔会重写一下这些��|��~�省参数为很��涉及的例外情况提供了少定义一些函数的方便�?
�~�点�Q?/strong>大家�l�常会通过查看现有代码��定如何使用API�Q�缺省参��C��得复制粘贴以前的代码难以呈现所有参敎ͼ�当缺省参��C��适用于新代码时可能导致重大问题�?
�l�论�Q?/strong>所有参数必��L��指定，强制�E�序员考虑API和传入的各参数��|��避免使用可能不�ؓ�E�序员所知的�~�省参数�?
4. 变长数组和alloca�Q�Variable-Length Arrays and alloca()�Q?/font>

��止使用变长数组和alloca()�?/p>
优点�Q?/strong>变长数组��h��然天成的语法，变长数组和alloca()也都很高效�?/p>
�~�点�Q?/strong>变长数组和alloca()不是标准C++的组成部分，更重要的是，它们�?font color="#800000">堆栈�Q�stack�Q?/font>上根据数据分配大��可能导致难以发现的内存泄漏�Q�“在我的机器上运行的好好的，��C��产品中却莫名其妙的挂掉了”�?/p>
�l�论�Q?/strong>

使用安全�?font color="#800000">分配器（allocator�Q?/font>�Q�如scoped_ptr/scoped_array�?
5. 友元�Q�Friends�Q?/font>

允许合理使用友元�c�d��友元函数�?/p>
通常��友元定义在同一文�g下，避免读者跑到其他文件中查找其对某个�cȝ��有成员的使用。经常用到友元的一个地�Ҏ��FooBuilder声明为Foo的友元，FooBuilder以便可以正确构造Foo的内部状态，而无需��该状态暴露出来。某些情况下�Q�将一个单元测试用�c�d��明�ؓ待测�cȝ��友元会很方便�?/p>
友元延��了（但没有打��_��cȝ��装界线�Q�当你希望只允许另一个类讉K��某个成员�Ӟ��使用友元通常比将其声明�ؓpublic要好得多。当�Ӟ��大多数类应该只提供公共成员与其交互�?
6. 异常�Q�Exceptions�Q?/font>

不要使用C++异常�?/p>
优点�Q?/strong>

1) 异常允许上层应用军_��如何处理在底层嵌套函��C��发生的“不可能发生”的��p�|�Q�不像出错代码的记录那么模糊费解�Q?/p>
2) 应用于其他很多现代语�a�中，引入异常使得C++与Python、Java及其他与C++相近的语�a�更加兼容�Q?/p>
3) 许多C++�W�三方库使用异常�Q�关闭异常将��D��难以与之�l�合�Q?/p>
4) 异常是解��x��造函数失败的唯一�Ҏ��Q�虽然可以通过工厂函数�Q�factory function�Q?/font>或Init()�Ҏ��模拟异常�Q�但他们分别需要堆分配或新的“非法”状态；

5) �?font color="#800000">��试框架�Q�testing framework�Q?/font>中，异常��实很好用�?/p>
�~�点�Q?/strong>

1) 在现有函��C��d��throw语句�Ӟ��必须��查所有调用处�Q�即使它们至��具有基本的异常安全保护�Q�或者程序正常结束，永远不可能捕莯��异常。例如：if f() calls g() calls h()�Q?code>h抛出�?code>f捕获的异常，g��p��当心了，避免没有完全清理�Q?/p>
2) 通俗一点说�Q�异�怼��D��E�序控制��（control flow�Q?/font>通过查看代码无法��定�Q�函数有可能在不��定的地方返回，从而导致代码管理和调试困难�Q�当�Ӟ��你可以通过规定何时何地如何使用异常来最��化的降低开销�Q�却�l�开发�h员带来掌握这些规定的负担�Q?/p>
3) 异常安全需要RAII和不同编码实��c��轻松、正��编写异常安全代码需要大量支撑。允�怋�用异常；

4) 加入异常使二�q�制执行代码体积变大�Q�增加了�~�译旉��Q�或许媄响不大）�Q�还可能增加地址�I�间压力�Q?/p>
5) 异常的实用性可能会刺激开发�h员在不恰当的时候抛出异常，或者在不安全的地方从异�怸�恢复�Q�例如，非法用户输入可能��D��抛出异常。如果允�怋�用异�怼�使得�q�样一��编�E�风格指南长出很多（译者注�Q�这个理由有点牵�?-(�Q�！

�l�论�Q?/strong>

从表面上看，使用异常利大于弊�Q�尤其是在新��目中，然而，对于现有代码�Q�引入异�怼�牵连到所有依赖代码。如果允许异常在新项目中使用�Q�在跟以前没有��用异常的代码整合时也是一个麻烦。因为Google现有的大多数C++代码都没有异常处理，引入带有异常处理的新代码相当困难�?
鉴于Google现有代码不接受异常，在现有代码中使用异常比在新项目中使用的代价多��要大一点，�q�移�q�程会比较慢�Q�也�Ҏ��出错。我们也不相信异常的有效替代�Ҏ��Q�如错误代码、断�a��{�，都是严重负担�?
我们�q�不是基于哲学或道�d层面反对使用异常�Q�而是在实�늚�基础上。因为我们希望��用Google上的开源项目，但项目中使用异常会�ؓ此带来不便，因�ؓ我们也徏议不要在Google上的开源项目中使用异常�Q�如果我们需要把�q�些��目推倒重来显然不太现实�?
对于Windows代码来说�Q�这一�Ҏ��个例外（�{�到最后一��吧:D�Q��?
译者注�Q�对于异常处理，昄��不是短短几句话能够说清楚的，以构造函��Cؓ例，很多C++书籍上都提到当构造失败时只有异常可以处理�Q�Google��止使用异常�q�一点，仅仅是�ؓ了自�w�的方便�Q�说大了�Q�无非是��Z��软�g��理成本上，实际使用中还是自己决定�?/strong>
7. �q�行时类型识别（Run-Time Type Information, RTTI�Q?/font>

我们��止使用RTTI�?/p>
定义�Q?/strong>RTTI允许�E�序员在�q�行时识别C++�c�d��象的�c�d��?/p>
优点�Q?/strong>

RTTI在某些单元测试中非常有用�Q�如在进行工厂类��试时用于检验一个新建对象是否�ؓ期望的动态类型�?/p>
除测试外�Q�极��用到�?/p>
�~�点�Q?/strong>�q�行时识别类型意呌��设计本��n有问题，如果你需要在�q�行期间��定一个对象的�c�d��Q�这通常说明你需要重新考虑你的�cȝ��设计�?/p>
�l�论�Q?/strong>

除单元测试外�Q�不要��用RTTI�Q�如果你发现需要所写代码因对象�c�d��不同而动作各异的话，考虑换一�U�方式识别对象类型�?/p>
虚函数可以实现随子类�c�d��不同而执行不同代码，工作都是交给对象本��n��d��成�?/p>
如果工作在对象之外的代码中完成，考虑双重分发�Ҏ��Q�如Visitor模式�Q�可以方便的在对象本�w�之外确定类的类型�?/p>
如果你认��Z��面的�Ҏ��你掌握不了，可以使用RTTI�Q�但务必请三思，不要��L��工实��C��?font color="#800000">貌似RTTI的方案（RTTI-like workaround�Q?/font>�Q�我们反对��用RTTI�Q�同样反对脓上类型标�{��貌似�cȝ��承的替代�Ҏ��Q?font color="#800000">译者注�Q��用就使用吧，不��用也不要造轮�?D�Q��?/p>
8. �c�d��转换�Q�Casting�Q?/strong>

使用static_cast<>()�{�C++的类型�{换，不要使用int y = (int)x�?code>int y = int(x);�?/p>
定义�Q?/strong>C++引入了有别于C的不同类型的�c�d��转换操作�?/p>
优点�Q?/strong>C语言的类型�{换问题在于操作比较含�p�：有时是在做强制�{换（�?code>(int)3.5�Q�，有时是在做类型�{换（�?code>(int)"hello"�Q�。另外，C++的类型�{换查找更�Ҏ��、更醒目�?/p>
�~�点�Q?/strong>语法比较恶心�Q�nasty�Q?/font>�?/p>
�l�论�Q?/strong>使用C++风格而不要��用C风格�c�d��转换�?/p>
1) static_cast�Q�和C风格转换�怼�可做值的强制转换�Q�或指针的父�c�d��子类的明��的向上转换�Q?/p>
2) const_cast�Q�移除const属性；

3) reinterpret_cast�Q�指针类型和整型或其他指针间不安全的�怺�转换�Q�仅在你�Ҏ��做一切了然于心时使用�Q?/p>
4) dynamic_cast�Q�除��试外不要��用，除单元测试外�Q�如果你需要在�q�行时确定类型信息，说明设计有缺��P��参�?strong>RTTI�Q��?/p>
9. ��（Streams�Q?/font>

只在记录日志时��用流�?/p>
定义�Q?/strong>��是printf()�?code>scanf()的替代�?/p>
优点�Q?/strong>有了��，在输出时不需要关心对象的�c�d��Q�不用担心格式化字符串与参数列表不匹配（虽然在gcc中��用printf也不存在�q�个问题�Q�，打开、关闭对应文件时�Q�流可以自动构造、析构�?/p>
�~�点�Q?/strong>��?code>pread()�{�功能函数很难执行，如果不��?code>printf之类的函数而是使用��很隑֯�格式�q�行操作�Q�尤其是常用的格式字�W�串%.*s�Q�，��不支持字符串操作符重新定序�Q?code>%1s�Q�，而这一点对国际化很有用�?/p>
�l�论�Q?/strong>

不要使用��，除非是日志接口需要，使用printf之类的代�ѝ�?/p>
使用��还有很多利弊，代码一致性胜�q�一切，不要在代码中使用��?/p>
拓展讨论�Q?/strong>

对这一条规则存在一些争论，�q�儿�l�出深层�ơ原因。回�?font color="#800000">唯一性原则（Only One Way�Q?/font>�Q�我们希望在��M��时候都只��用一�U�确定的I/O�c�d��Q��代码在所有I/O处保持一致。因此，我们不希望用��h��军_��是��用流�q�是printf + read/write�Q�我们应该决定到底用哪一�U�方式。把日志作�ؓ例外是因为流非常适合�q�么做，也有一定的历史原因�?/p>
��的支持者们��d��是不二之选，但观点�ƈ不是那么清晰有力�Q�他们所指出��的所有优势也正是其劣势所在。流最大的优势是在输出时不需要关心输出对象的�c�d��Q�这是一个亮点，也是一个不��I��很容易用错类型，而编译器不会报警。��用流时容易造成的一�c�错误是�Q?/p>
cout << this; // Prints the address cout << *this; // Prints the contents

�~�译器不会报错，因�ؓ<<被重载，��因��一�Ҏ��们反对��用操作符重蝲�?/p>
有�h�?code>printf的格式化丑陋不堪、易��L��差�Q�但��也好不到哪儿去。看看下面两�D�代码吧�Q�哪个更加易读？
cerr << "Error connecting to '" << foo->bar()->hostname.first << ":" << foo->bar()->hostname.second << ": " << strerror(errno); fprintf(stderr, "Error connecting to '%s:%u: %s", foo->bar()->hostname.first, foo->bar()->hostname.second, strerror(errno));

你可能会��_��“把��封装一下就会比较好了”，�q�儿可以�Q�其他地方呢�Q�而且不要忘了�Q�我们的目标是��语言��可能小�Q�而不是添加一些别人需要学习的新的内容�?/p>
每一�U�方式都是各有利弊，“没有最好，只有更好”，��单化的教条告诫我们必��M��中选择其一�Q�最后的多数军_��?code>printf + read/write�?/p>
10. 前置自增和自减（Preincrement and Predecrement�Q?/strong>

对于�q�代器和其他模板对象使用前缀形式�Q?code>++i�Q�的自增、自减运��符�?/p>
定义�Q�对于变量在自增�Q?code>++i�?code>i++�Q�或自减�Q?code>--i�?code>i--�Q�后表达式的值又没有没用到的情况下，需要确定到底是使用前置�q�是后置的自增自减�?/p>
优点�Q�不考虑�q�回值的话，前置自增�Q?code>++i�Q�通常要比后置自增�Q?code>i++�Q�效率更高，因�ؓ后置的自增自减需要对表达式的�?code>i�q�行一�ơ拷贝，如果i是�P代器或其他非数值类型，拯��的代��h��比较大的。既然两�U�自增方式动作一��P��译者注�Q�不考虑表达式的��|��怿�你知道我在说什�?/font>�Q�，��Z��么不直接使用前置自增呢？

�~�点�Q�C语言中，当表辑ּ�的值没有��用时�Q�传�l�的做法是��用后�|�自增，特别是在for循环中，有些��得后�|�自增更加易懂，因�ؓ�q�很像自然语�a��Q�主语（i�Q�在谓语动词�Q?code>++�Q�前�?/p>
�l�论�Q�对��单数��|��非对象）来说�Q�两�U�都无所谓，对�P代器和模板类型来��_��要��用前�|�自增（自减�Q��?/p>
11. const的��用（Use of const�Q?/font>

我们强烈��你在��M��可以使用的情况下都要使用const�?/p>
定义�Q�在声明的变量或参数前加上关键字const用于指明变量��g��可修改（�?code>const int foo�Q�，为类中的函数加上const限定表明该函��C��会修改类成员变量的状态（�?code>class Foo { int Bar(char c) const; };�Q��?/p>
优点�Q��h们更�Ҏ��理解变量是如何��用的�Q�编辑器可以更好地进行类型检��、更好地生成代码。�h们对�~�写正确的代码更加自信，因�ؓ他们知道所调用的函数被限定了能或不能修改变量倹{��即使是在无锁的多线�E�编�E�中�Q��h们也知道什么样的函数是安全的�?/p>
�~�点�Q�如果你向一个函��C��?code>const变量�Q�函数原型中也必��L��const的（否则变量需�?code>const_cast�c�d��转换�Q�，在调用库函数时这��其是个�ȝ��?/p>
�l�论�Q?code>const变量、数据成员、函数和参数为编译时�c�d��增加了一层保障，更好的尽早发现错误。因此，我们强烈��在�Q何可以��用的情况下��?code>const�Q?/p>
1) 如果函数不会修改传入的引用或指针�c�d��的参敎ͼ��q�样的参数应该�ؓconst�Q?/p>
2) ��可能将函数声明�?code>const�Q�访问函数应该��L��const�Q�其他函数如果不会修改�Q何数据成员也应该�?code>const�Q�不要调用非const函数�Q�不要返回对数据成员的非const指针或引用；

3) 如果数据成员在对象构造之后不再改变，可将其定义�ؓconst�?/p>
然而，�?strong>不要�?code>const�q�度使用�Q�像const int * const * const x;��有些过了，即便�q�样写精��描�q�C��x�Q�其实写�?code>const int** x��可以了�?/p>
关键�?code>mutable可以使用�Q�但是在多线�E�中是不安全的，使用旉��先要考虑�U�程安全�?/p>
const位置�Q?/p>
有�h喜欢int const *foo形式不喜��?code>const int* foo�Q�他们认为前者更加一致因此可��L��更好：遵��@�?code>const��M��于其描述的对象（int�Q�之后的原则。但是，一致性原则不适用于此�Q�“不要过度��用”的权威抉|��了一致性��用。将const攑֜�前面才更易读�Q�因为在自然语言中�Ş容词�Q?code>const�Q�是在名词（int�Q�之前的�?/p>
�q�是��_��我们提�?code>const在前�Q��ƈ不是要求�Q�但要兼��代码的一致性！

12. 整型�Q�Integer Types�Q?/strong>

C++内徏整型中，唯一用到的是int�Q�如果程序中需要不同大��的变量�Q�可以��?code>中的�_��宽度�Q�precise-width�Q?/font>的整型，�?code>int16_t�?/p>
定义�Q�C++没有指定整型的大��，通常��Z��认�ؓshort�?6位，int�?2位，long�?2位，long long�?4位�?/p>
优点�Q�保持声明统一�?/p>
�~�点�Q�C++中整型大��因�~�译器和体系�l�构的不同而不同�?/p>
�l�论�Q?/p>
定义�?code>int16_t�?code>uint32_t�?code>int64_t�{�整型，在需要确定大��的整型时可以��用它们代�?code>short�?code>unsigned long long�{�，在C整型中，只��?code>int。适当情况下，推荐使用标准�c�d��?code>size_t�?code>ptrdiff_t�?/p>
最�怋�用的是，�Ҏ��数来��_��通常不会用到太大�Q�如循环计数�{�，可以使用普通的int。你可以认�ؓint臛_��?2位，但不要认为它会多�?2位，需�?4位整型的话，可以使用int64_t�?code>uint64_t�?/p>
对于大整敎ͼ�使用int64_t�?/p>
不要使用uint32_t�{�无�W�号整型�Q�除非你是在表示一�?font color="#800000">位组�Q�bit pattern�Q?/font>而不是一个数倹{��即使数��g��会�ؓ负��g��不要使用无符��L��型，使用断言�Q�assertion�Q�译者注�Q�这一点很有道理，计算机只会根据变量、返回值等有无�W�号��定数值正负，仍然无法��定寚w��Q?/font>来保护数据�?/p>
无符��h��?/strong>�Q?/p>
有些人，包括一些教�U�书作者，推荐使用无符��L��型表�C�非负数�Q�类型表明了数值取值�Ş式。但是，在C语言中，�q�一优点被由其导致的bugs所�Ҏ��。看看：
for (unsigned int i = foo.Length()-1; i >= 0; --i) ...

上述代码永远不会�l�止�Q�有时gcc会发现该bug�q�报警，但通常不会。类似的bug�q�会出现在比较有�W�合变量和无�W�号变量�Ӟ��主要是C�?font color="#800000">�c�d��提升机制�Q�type-promotion scheme�Q�C语言中各�U�内建类型之间的提升转换关系�Q?/font>会致使无�W�号�c�d��的行为出乎你的意料�?/p>
因此�Q��用断�a�声明变量为非负数�Q�不要��用无�W�号型�?/p>
13. 64位下的可�U�L��性（64-bit Portability�Q?/strong>

代码�?4位和32位的�pȝ��中，原则上应该都比较友好�Q�尤其对于输出、比较�?font color="#800000">�l�构寚w��Q�structure alignment�Q?/font>来说�Q?/p>
1) printf()指定的一些类型在32位和64位系�l�上可移植性不是很好，C99标准定义了一些可�U�L��的格式。不�q�的是，MSVC 7.1�q��全部支持�Q�而且标准中也有所遗漏。所以有时我们就不得不自己定义丑陋的版本�Q��用标准风��D��包含文�ginttypes.h�Q�：
// printf macros for size_t, in the style of inttypes.h #ifdef _LP64 #define __PRIS_PREFIX "z" #else #define __PRIS_PREFIX #endif // Use these macros after a % in a printf format string // to get correct 32/64 bit behavior, like this: // size_t size = records.size(); // printf("%"PRIuS"\n", size); #define PRIdS __PRIS_PREFIX "d" #define PRIxS __PRIS_PREFIX "x" #define PRIuS __PRIS_PREFIX "u" #define PRIXS __PRIS_PREFIX "X" #define PRIoS __PRIS_PREFIX "o"

�c�d�� 不要使用使用备注

void *�Q�或其他指针�c�d��Q?/td> %lx %p

int64_t %qd, %lld %"PRId64"

uint64_t %qu, %llu, %llx %"PRIu64", %"PRIx64"

size_t %u %"PRIuS", %"PRIxS" C99指定%zu

ptrdiff_t %d %"PRIdS" C99指定%zd

注意�?code>PRI*会被�~�译器扩展�ؓ独立字符�Ԍ��因此如果使用非常量的格式化字�W�串�Q�需要将宏的��D��不是宏名插入格式中�Q�在使用�?code>PRI*时同样可以在%后指定长度等信息。例如，printf("x = %30"PRIuS"\n", x)�?2位Linux上将被扩展�ؓprintf("x = %30" "u" "\n", x)�Q�编译器会处理�ؓprintf("x = %30u\n", x)�?/p>
2) ��C��sizeof(void *) != sizeof(int)�Q�如果需要一个指针大��的整数要��?code>intptr_t�?/p>
3) 需要对�l�构寚w��加以留心�Q�尤其是对于存储在磁盘上的结构体。在64位系�l�中�Q��Q何拥�?code>int64_t/uint64_t成员的类/�l�构体将默认被处理�ؓ8字节寚w��。如�?2位和64位代码共用磁盘上的结构体�Q�需要确保两�U�体�pȝ��构下的结构体的对齐一致。大多数�~�译器提供了调整�l�构体对齐的�Ҏ��。gcc中可使用__attribute__((packed))�Q�MSVC提供�?code>#pragma pack()�?code>__declspec(align())�Q�译者注�Q�解��x��案的��目属性里也可以直接设�|�）�?/p>
4) 创徏64位常量时使用LL�?code>ULL作�ؓ后缀�Q�如�Q?/p>
int64_t my_value = 0x123456789LL; uint64_t my_mask = 3ULL << 48;

5) 如果你确实需�?2位和64位系�l�具有不同代码，可以在代码变量前使用。（��量不要�q�么做，使用时尽量��修改局部化�Q��?/p>
14. 预处理宏�Q�Preprocessor Macros�Q?/strong>

使用宏时要�}慎，��量以内联函数、枚丑֒�帔R��代替之�?/p>
宏意味着你和�~�译器看到的代码是不同的�Q�因此可能导致异常行为，��其是当宏存在于全局作用域中�?/p>
值得庆幸的是�Q�C++中，宏不像C中那么必要。宏内联效率关键代码�Q�performance-critical code�Q?/font>可以内联函数替代�Q�宏存储帔R��可以const变量替代�Q�宏“羃写”长变量名可以引用替代；使用宏进行条件编译，�q�个……，最好不要这么做�Q�会令测试更加痛苦（#define防止头文仉��包含当然是个例外�Q��?/p>
宏可以做一些其他技术无法实现的事情�Q�在一些代码库�Q�尤其是底层库中�Q�可以看到宏的某些特性（�?font color="#800000">字符串化�Q�stringifying�Q�译者注�Q��?code>#�Q?/font>�?font color="#800000">�q�接�Q�concatenation�Q�译者注�Q��?code>##�Q?/font>�{�等�Q�。但在��用前�Q�仔�l�考虑一下能不能不��用宏实现同样效果�?/p>
译者注�Q�关于宏的高�U�应用，可以参�?/strong>C语言宏的高��应用�?/strong>

下面�l�出的用法模式可以避免一些��用宏的问题，供��用宏时参考：

1) 不要�?code>.h文�g中定义宏�Q?/p>
2) 使用前正��?code>#define�Q��用后正确#undef�Q?/p>
3) 不要只是对已�l�存在的宏��?code>#undef�Q�选择一个不会冲�H�的名称�Q?/p>
4) 不��用会��D��不稳定的C++构造（unbalanced C++ constructs�Q�译者注�Q?/font>的宏�Q�至��文档说明其行�ؓ�?/p>
15. 0和NULL�Q? and NULL�Q?/strong>

整数�?code>0�Q�实数用0.0�Q�指针用NULL�Q�字�W�（�Ԍ��?code>'\0'�?/p>
整数�?code>0�Q�实数用0.0�Q�这一�Ҏ��毫无争议的�?/p>
对于指针�Q�地址��|��Q�到底是�?code>0�q�是NULL�Q�Bjarne Stroustrup��使用最原始�?code>0�Q�我们徏议��用看上去像是指针�?code>NULL�Q�事实上一些C++�~�译器（如gcc 4.1.0�Q�专门提供了NULL的定义，可以�l�出有用的警告，��其�?code>sizeof(NULL)�?code>sizeof(0)不相�{?/code>的情��c�?/p>
字符�Q�串�Q�用'\0'�Q�不仅类型正��而且可读性好�?/p>
16. sizeof�Q�sizeof�Q?/strong>

��可能用sizeof(varname)代替sizeof(type)�?/p>
使用sizeof(varname)是因为当变量�c�d��改变时代码自动同步，有些情况�?code>sizeof(type)或许有意义，�q�是要尽量避免，如果变量�c�d��改变的话不能同步�?/p>
Struct data; memset(&data, 0, sizeof(data));
memset(&data, 0, sizeof(Struct));

17. Boost库（Boost�Q?/strong>

只��用Boost中被认可的库�?/p>
定义�Q�Boost库集是一个非常受�Ƣ迎的�?font color="#800000">同��评议的（peer-reviewed�Q?/font>、免费的、开源的C++库�?/p>
优点�Q�Boost代码质量普遍较高、可�U�L��性好�Q�填补了C++标准库很多空白，�?font color="#800000">型别�Ҏ��（type traits�Q?/font>、更完善�?font color="#800000">�l�定�Q�binders�Q?/font>、更好的��指针�Q�同时还提供了TR1�Q�标准库的扩展）的实现�?/p>
�~�点�Q�某些Boost库提倡的�~�程实践可读性差�Q�像元程序（metaprogramming�Q?/font>和其他高�U�模板技术，以及�q�度“函数化”（"functional"�Q?/font>的编�E�风根{�?/p>
�l�论�Q��ؓ了向阅读和维护代码的人员提供更好的可��L��，我们只允�怋�用Boost�Ҏ��的一个成熟子集，当前�Q�这些库包括�Q?/p>
1) Compressed Pair�Q?code>boost/compressed_pair.hpp�Q?/p>
2) Pointer Container�Q?code>boost/ptr_container不包�?code>ptr_array.hpp和序列化�Q�serialization�Q��?/p>
我们会积极考虑��d��可以的Boost�Ҏ��，所以不必拘泥于该规则�?/p>
______________________________________

译者：关于C++�Ҏ��的注意事项�Q��ȝ��一下：
1. 对于��指针�Q�安全第一、方便第二，��可能局部化�Q�scoped_ptr�Q?/strong>�Q?/strong>
2. 引用形参加上const�Q�否则��用指针�Ş参；
3. 函数重蝲的��用要清晰、易读；
4. 鉴于�Ҏ��误用�Q�禁止��用缺省函数参敎ͼ�值得商榷�Q�；
5. ��止使用变长数组�Q?/strong>
6. 合理使用友元�Q?/strong>
7. ��Z��方便代码��理�Q�禁止��用异常（值得商榷�Q�；
8. ��止使用RTTI�Q�否则重新设计代码吧�Q?/strong>
9. 使用C++风格的类型�{换，除单元测试外不要使用dynamic_cast�Q?/strong>
10. 使用��还printf + read/write�Q�it is a problem�Q?/strong>
11. 能用前置自增/减不用后�|�自�?减；
12. const能用则用�Q�提倡const在前�Q?/strong>

13. 使用��定大小的整型，除位�l�外不要使用无符号型�Q?/strong>

14. 格式化输出及�l�构寚w��Ӟ��注意32位和64位的�pȝ��差异�Q?/strong>

15. 除字�W�串化、连接外��量避免使用宏；

16. 整数�?�Q�实数用0.0�Q�指针用NULL�Q�字�W�（�Ԍ��?\0'�Q?/strong>

17. 用sizeof(varname)代替sizeof(type)�Q?/strong>

18. 只��用Boost中被认可的库�?/strong>

Fox 2008-07-21 14:55 发表评论

Fox — Fri, 18 Jul 2008 02:03:00 GMT

一个好的日志系�l�，除了可以记录��可能多的必要信息，方便trace bugs、提供data analysis source�q�些基本功能之外�Q�其他的貌似不必太在意。但真正当bugs冒出来的时候，要命的是既没有dump�Q�也没有有�h值的日志�Q�更要命的是日志居然已经记录了那么多�Q�居然让你查了半天，居然都是没有价值的�Q?/p>
悲剧啊！

日志需要记录的信息大概分�ؓ两类�Q?/p>
1) �pȝ��q�行情况�Q�启动、加载、读写、关闭�?strong>异常�Q?/p>
2) 用户使用情况�Q�进入、操作、离开�?strong>异常�?/p>
我可以想到的关于日志�pȝ��的要求大致以下几点：

1) 日志�pȝ��使用目录树结�?/strong>�Q�系�l�日志和用户日志分别记录�Q�正常日志和异常日志分别记录�Q�不�|�于同一文�g夹下�Q�日志文件命名做��C�o观者一目了�Ӟ��

2) 记录详尽但不冗余�Q�正��记录日志时间、位�|�、事件、因果，有可能的话，记录上下�?/strong>�Q�这要求有点高了�Q�；

3) 格式�l�一但严��千��一�?/strong>�Q�格式统一是指记录内容遵��@一定格式，方便查看�Q�严��千��一律是指记录要有层�ơ、轻重，不同事�g��D��的“同一”异常日志不应不加区别，同样是�ؓ了方便查看；

4) 与异常处理相辅相�?/strong>�Q�有dump�Ӟ��以日志辅助快速定位，没有dump�Ӟ��日志应尽可能提供有效信息�Q?strong>��ȝ��l�崩溃的地方��近��好�Q�这一点似乎也有难度）�?/p>
________________________________________________

�H�然惛_��的，也还没有动手��d��Q�先��C��了，�Ƣ迎补充�?/p>
_____Added on Jul.25th, 2008_______________________

�q�看��C��位兄弟在为我说话�Q�谢谢！

今天在考虑实现�Ӟ��惛_��一个很现实的问题，日志几乎是无处不在的�Q�随旉��C��有日志记录。不知道有谁对I/O�Q�当然主要是Output�Q�消耗和对系�l�的影响做过专门��试�Q�猜��就��了:-)�Q�我很想知道有没有必要放��C��门的�U�程中，如果攑ֈ�独立�U�程中的话，问题��出来了�Q�多长时间写一�ơ？毕竟�Q�记录日志的主要目的��是��Z��全面记录�pȝ��q�行和用户��用情况，如果在服务器crash的时候，�q�有日志�Q�尤其是crash上下文日志）没有被顺利写入，日志的意义也��大打折扣�?/p>
谁给点徏议？

Fox 2008-07-18 10:03 发表评论

Fox — Wed, 16 Jul 2008 09:43:00 GMT

�q�一��主要提到的是类�Q�Lippman在�?a title="Inside The C++ Object Model" href="www.amazon.com/Inside-Object-Model-Stanley-Lippman/dp/0201834545" target="_blank">Inside The C++ Object Model》第二章中对构造函��C��了详��说明，本文中提到的几个单词基本仿该书中译本侯捷先生的翻译：

explicit�Q�明��的

implicit�Q�隐含的

trivial�Q�没有意义的

non-trivial�Q�有意义�?/p>

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

�c?/font>

�c�L��C++中基本的代码单元�Q�自然被�q�泛使用。本节列举了在写一个类时要做什么、不要做什么�?/p>
1. 构造函敎ͼ�Constructor�Q�的职责

构造函��C��只进行那�?font color="#800000">没有实际意义的（trivial�Q�译者注�Q�简单初始化对于�E�序执行没有实际的逻辑意义�Q�因为成员变量的“有意义”的值大多不在构造函��C��定�Q?/font>初始化，可能的话�Q��用Init()�Ҏ��集中初始化�ؓ有意义的�Q�non-trivial�Q?/font>数据�?/p>
定义�Q?/strong>在构造函��C��执行初始化操作�?/p>
优点�Q?/strong>排版方便�Q�无需担心�c�L��否初始化�?/p>
�~�点�Q?/strong>在构造函��C��执行操作引�v的问题有�Q?/p>
1) 构造函��C��不易报告错误�Q�不能��用异常�?/p>
2) 操作��p�|会造成对象初始化失败，引�v不确定状态�?/p>
3) 构造函数内调用虚函敎ͼ�调用不会�z�֏�到子�c�d��C��Q�即使当前没有子�c�d��实现�Q�将来仍是隐患�?/p>
4) 如果有�h创徏该类型的全局变量�Q�虽然违背了上节提到的规则）�Q�构造函数将在main()之前被调用，有可能破坏构造函��C��暗含的假设条件。例如，gflags��未初始化�?/p>
�l�论�Q?/strong>如果对象需�?font color="#800000">有意义的�Q�non-trivial�Q?/font>初始化，考虑使用另外的Init()�Ҏ��qӞ��或）增加一个成员标记用于指�C�对象是否已�l�初始化成功�?/p>
2. 默认构造函敎ͼ�Default Constructors�Q?/font>

如果一个类定义了若�q�成员变量又没有其他构造函敎ͼ�需要定义一个默认构造函敎ͼ�否则�~�译器将自动生��默认构造函数�?/p>
定义�Q?/strong>新徏一个没有参数的对象�Ӟ��默认构造函数被调用�Q�当调用new[]�Q��ؓ数组�Q�时�Q�默认构造函数��L��被调用�?/p>
优点�Q?/strong>默认��结构体初始化�ؓ“不可能的”��|��使调试更加容易�?/p>
�~�点�Q?/strong>对代码编写者来��_��q�是多余的工作�?/p>
�l�论�Q?/strong>

如果�c�M��定义了成员变量，没有提供其他构造函敎ͼ�你需要定义一个默认构造函敎ͼ�没有参数�Q�。默认构造函数更适合于初始化对象�Q��对象内部状态（internal state�Q?/font>一致、有效�?/p>
提供默认构造函数的原因是：如果你没有提供其他构造函敎ͼ�又没有定义默认构造函敎ͼ��~�译器将��Z��自动生成一个，�~�译器生成的构造函数�ƈ不会对对象进行初始化�?
如果你定义的�cȝ��承现有类�Q�而你又没有增加新的成员变量，则不需要�ؓ新类定义默认构造函数�?
3. 明确的构造函敎ͼ�Explicit Constructors�Q?/font>

对单参数构造函��C��用C++关键字explicit�?/p>
定义�Q?/strong>通常�Q�只有一个参数的构造函数可被用�?font color="#800000">转换�Q�conversion�Q�译者注�Q�主要指隐式转换�Q�下文可见）�Q�例如，定义了Foo::Foo(string name)�Q�当向需要传入一个Foo对象的函��C��入一个字�W�串�Ӟ��构造函数Foo::Foo(string name)被调用�ƈ��该字符串�{换�ؓ一个Foo临时对象传给调用函数。看上去很方便，但如果你�q�不希望如此通过转换生成一个新对象的话�Q�麻烦也随之而来。�ؓ避免构造函数被调用造成隐式转换�Q�可以将其声明�ؓexplicit�?/p>
优点�Q?/strong>避免不合时宜的变换�?
�~�点�Q?/strong>无�?
�l�论�Q?/strong>
所有单参数构造函数必��L��明确的。在�c�d��义中�Q�将关键字explicit加到单参数构造函数前�Q�explicit Foo(string name);
例外�Q�在��数情况下，拯��构造函数可以不声明为explicit�Q�特意作为其他类的透明包装器的�c�R��类��g��外情况应在注释中明确说明�?
4. 拯��构造函敎ͼ�Copy Constructors�Q?/font>

仅在代码中需要拷贝一个类对象的时候��用拷贝构造函敎ͼ�不需要拷贝时应��?code>DISALLOW_COPY_AND_ASSIGN�?/p>
定义�Q?/strong>通过拯��新徏对象时可使用拯��构造函敎ͼ�特别是对象的传值时�Q��?/p>
优点�Q?/strong>拯��构造函��C��得拷贝对象更加容易，STL容器要求所有内容可拯��、可赋倹{�?/p>
�~�点�Q?/strong>C++中对象的隐式拯��是导致很多性能问题和bugs的根源。拷贝构造函数降低了代码可读性，相比按引用传递，跟踪按��g��递的对象更加困难�Q�对象修改的地方变得难以捉摸�?/p>
�l�论�Q?/strong>

大量的类�q�不需要可拯��Q�也不需要一个拷贝构造函数或赋值操作（assignment operator�Q?/font>。不�q�的是，如果你不��d��声明它们�Q�编译器会�ؓ你自动生成，而且是public的�?/p>
可以考虑在类的private中添�?font color="#800000">�I�的�Q�dummy�Q?/font>拯��构造函数和赋值操作，只有声明�Q�没有定义。由于这些空�E�序声明为private�Q�当其他代码试图使用它们的时候，�~�译器将报错。�ؓ了方便，可以使用宏DISALLOW_COPY_AND_ASSIGN�Q?/p>
// ��止使用拯��构造函数和赋值操作的�?br>// 应在�cȝ��private:中��?br>#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ TypeName(const TypeName&);               \ void operator=(const TypeName&)
class Foo { public: Foo(int f); ~Foo(); private: DISALLOW_COPY_AND_ASSIGN(Foo); };
如上所�q�ͼ��l�大多数情况下都应��用DISALLOW_COPY_AND_ASSIGN�Q�如果类��实需要可拯��Q�应在该�cȝ��头文件中说明原由�Q��ƈ适当定义拯��构造函数和赋值操作，注意在operator=中检��?font color="#800000">自赋��|��self-assignment�Q?/font>情况�?/p>
在将�c�M��为STL容器值得时候，你可能有使类可拷贝的冲动。类似情况下�Q�真正该做的是��用指针指向STL容器中的对象�Q�可以考虑使用std::tr1::shared_ptr�?/p>
5. �l�构体和�c�（Structs vs. Classes�Q?/font>

仅当只有数据时��用struct�Q�其它一概��用class�?/p>
在C++中，关键字struct和class几乎含义�{�同�Q�我们�ؓ其�h为添加语义，以便为定义的数据�c�d��合理选择使用哪个关键字�?/p>
struct被用在仅包含数据的消极对象（passive objects�Q�上�Q�可能包括有兌��的常量，但没有存取数据成员之外的函数功能�Q�而存取功能通过直接讉K��实现而无需�Ҏ��调用�Q�这儿提到的�Ҏ��是指只用于处理数据成员的�Q�如构造函数、析构函数、Initialize()、Reset()、Validate()�?/p>
如果需要更多的函数功能�Q�class更适合�Q�如果不��定的话�Q�直接��用class�?/p>
如果与STL�l�合�Q�对�?font color="#800000">仿函敎ͼ�functors�Q�和�Ҏ��（traits�Q?/font>可以不用class而是使用struct�?/p>
注意�Q�类和结构体的成员变量��用不同的命名规则�?/p>
6. �l�承�Q�Inheritance�Q?/font>

使用�l�合�Q�composition�Q�译者注�Q�这一点也是GoF在《Design Patterns》里反复��的）通常比��用��承更适宜�Q�如果��用��承的话，只��用公��q��ѝ�?/p>
定义�Q?/strong>当子�cȝ��承基�c�L��Q�子�c�d��含了父基�c�L��有数据及操作的定义。C++实践中，�l�承主要用于两种场合�Q?font color="#800000">实现�l�承�Q�implementation inheritance�Q?/font>�Q�子�cȝ��承父�cȝ��实现代码�Q?font color="#800000">接口�l�承�Q�interface inheritance�Q?/font>�Q�子�c�M��l�承父类的方法名�U��?/p>
优点�Q?/strong>实现�l�承通过原封不动的重用基�c�M��码减��了代码量。由于��承是�~�译时声明（compile-time declaration�Q?/font>�Q�编码者和�~�译器都可以理解相应操作�q�发现错误。接口��承可用于�E�序上增强类的特定API的功能，在类没有定义API的必要实现时�Q�编译器同样可以侦错�?/p>
�~�点�Q?/strong>对于实现�l�承�Q�由于实现子�cȝ��代码在父�c�d��子类间�g展，要理解其实现变得更加困难。子�c�M��能重写父�cȝ��非虚函数�Q�当然也��׃��能修改其实现。基�c�M��可能定义了一些数据成员，�q�要区分基类�?font color="#800000">物理轮廓�Q�physical layout�Q?/font>�?/p>
�l�论�Q?/strong>

所有��承必��L��public的，如果想私有��承的话，应该采取包含基类实例作�ؓ成员的方式作为替代�?

不要�q�多使用实现�l�承�Q�组合通常更合适一些。努力做到只�?font color="#800000">“是一个”（"is-a"�Q�译者注�Q�其�?has-a"情况下请使用�l�合�Q?/font>的情况下使用�l�承�Q�如果Bar的确“是一�U�”Foo�Q�才令Bar是Foo的子�c�R�?
必要的话�Q��o析构函数为virtual�Q�必要是指，如果该类��h��虚函敎ͼ�其析构函数应该�ؓ虚函数�?
译者注�Q�至于子�c�L��有额外数据成员，甚至父类也没有�Q何数据成员的�Ҏ��情况下，析构函数的调用是否必要是语义争论�Q�从�~�程设计规范的角度看�Q�在含有虚函数的父类中，定义虚析构函数绝对必要�?/strong>
限定仅在子类讉K��的成员函��Cؓprotected�Q�需要注意的是数据成员应始终为私有�?
当重定义�z��的虚函数�Ӟ��在派生类中明��声明其为virtual。根本原因：如果遗漏virtual�Q�阅读者需要检索类的所有祖先以��定该函数是否�ؓ虚函�?font color="#800000">�Q�译者注�Q�虽然不影响其�ؓ虚函数的本质�Q?/font>�?
7. 多重�l�承�Q�Multiple Inheritance�Q?/font>

真正需要用�?font color="#800000">多重实现�l�承�Q�multiple implementation inheritance�Q?/font>的时候非常少�Q�只有当最多一个基�c�M��含有实现�Q�其他基�c�都是以Interface为后�~�的纯接口�c�L��才会使用多重�l�承�?/p>
定义�Q?/strong>多重�l�承允许子类拥有多个基类�Q�要��作为纯接口的基�c�d��h��实现的基�c�d��别开来�?/p>
优点�Q?/strong>相比单��承，多重实现�l�承可��o你重用更多代码�?/p>
�~�点�Q?/strong>真正需要用到多重实现��承的时候非常少�Q�多重实现��承看上去是不错的解决�Ҏ��Q�通常可以扑ֈ�更加明确、清晰的、不同的解决�Ҏ��?/p>
�l�论�Q?/strong>只有当所�?font color="#800000">��类�Q�superclass�Q?/font>除第一个外都是�U�接口时才能使用多重�l�承。�ؓ��保它们是纯接口�Q�这些类必须�?code>Interface为后�~��?/p>
注意�Q�关于此规则�Q�Windows下有�U�例外情况（译者注�Q�将在本译文最后一��的规则例外中阐�q�ͼ��?/p>
8. 接口�Q�Interface�Q?/font>

接口是指满��特定条�g的类�Q�这些类以Interface为后�~��Q�非必需�Q��?/p>
定义�Q?/strong>当一个类满��以下要求�Ӟ��U�C��为纯接口�Q?/p>
1) 只有�U�虚函数�Q?=0"�Q�和静态函敎ͼ�下文提到的析构函数除外）�Q?/p>
2) 没有非静态数据成员；

3) 没有定义��M��构造函数。如果有�Q�也不含参数�Q��ƈ且�ؓprotected�Q?/p>
4) 如果是子�c�，也只能��承满��上�q�条件�ƈ以Interface为后�~�的类�?/p>
接口�c�M��能被直接实例化，因�ؓ它声明了�U�虚函数。�ؓ��保接口�cȝ��所有实现可被正��销毁，必须��Z��声明虚析构函敎ͼ�作�ؓ�W?条规则的例外�Q�析构函��C��能是�U�虚函数�Q�。具体细节可参考Stroustrup的�?a title="The C++ Programming Language, 3rd edition" href="www.amazon.com/Programming-Language-3rd-Bjarne-Stroustrup/dp/0201889544" target="_blank">The C++ Programming Language, 3rd edition》第12.4节�?/p>
优点�Q?/strong>以Interface为后�~�可��o他�h知道不能��接口�c�d��加实现函数或非静态数据成员，�q�一点对于多重��承尤光��要。另外，对于Java�E�序员来��_��接口的概念已�l�深入�h心�?/p>
�~�点�Q?/strong>Interface后缀增加了类名长度，为阅��d��理解带来不便�Q�同�Ӟ��接口�Ҏ��作为实现细节不应暴露给客户�?/p>
�l�论�Q?/strong>。只有在满��上述需要时�Q�类才以Interface�l�尾�Q�但反过来，满��上述需要的�c�L��必一定以Interface�l�尾�?/p>
9. 操作�W�重载（Operator Overloading�Q?/font>

除少数特定环境外�Q�不要重载操作符�?/p>
定义�Q?/strong>一个类可以定义诸如+�?�{�操作符�Q��其可以像内徏�c�d��一��L��接��用�?/p>
优点�Q?/strong>使代码看上去更加直观�Q�就像内建类型（如int�Q�那��P��重蝲操作�W��那些Equals()、Add()�{�黯淡无光的函数名好玩多了。�ؓ了��一些模板函数正��工作，你可能需要定义操作符�?/p>
�~�点�Q?/strong>虽然操作�W�重载��o代码更加直观�Q�但也有一些不��?/p>
1) ��h��直觉�Q�让你误以�ؓ一些耗时的操作像内徏操作那样��d�y�Q?/p>
2) 查找重蝲操作�W�的调用处更加困难，查找Equals()昄��比同�{�调�?=�Ҏ��的多�Q?/p>
3) 有的操作�W�可以对指针�q�行操作�Q�容易导致bugs�Q�Foo + 4做的是一件事�Q��?amp;Foo + 4可能做的是完全不同的另一件事�Q�对于二者，�~�译器都不会报错�Q��其很难调试；

4) 重蝲�q�有令你吃惊的副作用�Q�比如，重蝲操作�W?amp;的类不能被前�|�声明�?

�l�论�Q?/strong>

一般不要重载操作符�Q�尤其是赋值操作（operator=�Q�比较阴险，应避免重载。如果需要的话，可以定义�c�M��Equals()、CopyFrom()�{�函数�?/p>
然而，极少数情况下需要重载操作符以便与模板或“标准”C++�c�衔接（如operator<<(ostream&, const T&)�Q�，如果被证明是正当的尚可接受，但你要尽可能避免�q�样做。尤其是不要仅仅��Z��在STL容器中作为key使用��重载operator==或operator<�Q�取而代之，你应该在声明容器的时候，创徏相等判断和大��比较的仿函数类型�?/p>
有些STL��法��实需要重载operator==时可以这么做�Q�不要忘了提供文档说明原因�?/p>
参�?strong>拯��构造函�?/strong>�?strong>函数重蝲�?

10. 存取控制�Q�Access Control�Q?/font>

��数据成员私有化�Q��ƈ提供相关存取函数�Q�如定义变量foo_及取值函数foo()、赋值函数set_foo()�?/p>
存取函数的定义一般内联在头文件中�?/p>
参�?strong>�l�承�?strong>函数命名�?/p>
11. 声明�ơ序�Q�Declaration Order�Q?/font>

在类中��用特定的声明�ơ序�Q�public:在private:之前�Q�成员函数在数据成员�Q�变量）前�?/p>
定义�ơ序如下�Q�public:、protected:、private:�Q�如果那一块没有，直接忽略卛_��?/p>
每一块中�Q�声明次序一般如下：

1) typedefs和enums�Q?/p>
2) 帔R��Q?/p>
3) 构造函敎ͼ�

4) 析构函数�Q?/p>
5) 成员函数�Q�含静态成员函敎ͼ�

6) 数据成员�Q�含静态数据成员�?/p>
宏DISALLOW_COPY_AND_ASSIGN�|�于private:块之后，作�ؓ�cȝ��最后部分。参�?strong>拯��构造函�?/strong>�?/p>
.cc文�g中函数的定义应尽可能和声明次序一致�?/p>
不要��大型函数内联到�cȝ��定义中，通常�Q�只有那些没有特别意义的或者性能要求高的�Q��ƈ且是比较短小的函数才被定义�ؓ内联函数。更多细节参�?a title="[译]Google C++�~�程风格指南�Q�一�Q? href="http://www.shnenglu.com/Fox/archive/2008/07/10/55818.html" target="_blank">译文�W�一��的内联函数�?/p>
12. �~�写短小函数�Q�Write Short Functions�Q?/font>

們֐�于选择短小、凝�l�的函数�?/p>
长函数有时是恰当的，因此对于函数长度�q�没有严格限制。如果函数超�q?0行，可以考虑在不影响�E�序�l�构的情况下��其分割一下�?/p>
即��一个长函数现在工作的非常好�Q�一旦有人对其修改，有可能出现新的问题，甚至��D��难以发现的bugs。��函数��量短小、简单，便于他�h阅读和修改代码�?/p>
在处理代码时�Q�你可能会发现复杂的长函敎ͼ�不要��x��修改现有代码：如果证实�q�些代码使用、调试困难，或者你需要��用其中的一��块�Q�考虑��其分割为更加短��、易于管理的若干函数�?/p>
______________________________________

译者：关于�cȝ��注意事项�Q��ȝ��一下：
1. 不在构造函��C��做太多逻辑相关的初始化�Q?/strong>
2. �~�译器提供的默认构造函��C��会对变量�q�行初始化，如果定义了其他构造函敎ͼ��~�译器不再提供，需要编码者自行提供默认构造函敎ͼ�
3. 为避免隐式�{换，需��单参数构造函数声明�ؓexplicit�Q?/strong>
4. 为避免拷贝构造函数、赋值操作的滥用和编译器自动生成�Q�可目前声明其�ؓprivate且无需实现�Q?/strong>
5. 仅在作�ؓ数据集合时��用struct�Q?/strong>
6. �l�合>实现�l�承>接口�l�承>�U�有�l�承�Q�子�c�重载的虚函��C��要声明virtual关键字，虽然�~�译器允�怸��q�样做；
7. 避免使用多重�l�承�Q��用时�Q�除一个基�c�d��有实现外�Q�其他基�c�d��为纯接口�Q?/strong>
8. 接口�cȝ��名以Interface为后�~��Q�除提供带实现的虚析构函数、静态成员函数外�Q�其他均为纯虚函敎ͼ�不定义非静态数据成员，不提供构造函敎ͼ�提供的话�Q�声明�ؓprotected�Q?/strong>
9. 为降低复杂性，��量不重载操作符�Q�模�ѝ��标准类中��用时提供文档说明�Q?/strong>
10. 存取函数一般内联在头文件中�Q?/strong>
11. 声明�ơ序�Q�public->protected->private�Q?/strong>
12. 函数体尽量短��、紧凑，功能单一�?/strong>

Fox 2008-07-16 17:43 发表评论

Fox — Mon, 14 Jul 2008 07:49:00 GMT

原文地址�Q?a title="Google C++ Style Guide" target="_blank" rel="tag">Google C++ Style Guide

作用�?/font>

1. 命名�I�间�Q�Namespaces�Q?/font>

�?cc文�g中，提倡��?font color="#800000">不具名的命名�I�间�Q�unnamed namespaces�Q�译者注�Q�不具名的命名空间就像不具名的类一��P��g��被介�l�的很少:-(�Q?/font>。��用具名命名空间时�Q�其名称可基于项目或路径名称�Q�不要��用using指示�W��?/p>
定义�Q?/strong>命名�I�间��全局作用域细分�ؓ不同的、具名的作用域，可有效防止全局作用域的命名冲突�?/p>
优点�Q?/strong>命名�I�间提供了（可嵌套）命名轴线�Q�name axis�Q�译者注�Q�将命名分割在不同命名空间内�Q?/font>�Q�当�Ӟ��c�M��提供了（可嵌套）的命名��u�U�（译者注�Q�将命名分割在不同类的作用域�?/font>�Q��?/p>
举例来说�Q�两个不同项目的全局作用域都有一个类Foo�Q�这样在�~�译或运行时造成冲突。如果每个项目将代码�|�于不同命名�I�间中，project1::Foo和project2::Foo作�ؓ不同�W�号自然不会冲突�?/p>
�~�点�Q?/strong>命名�I�间��h��q�h��性，因�ؓ它们和类一��h��供了额外的（可嵌套的�Q�命名��u�Uѝ��在头文件中使用不具名的�I�间�Ҏ��q�背C++�?font color="#800000">唯一定义原则�Q�One Definition Rule (ODR)�Q?/font>�?/p>
�l�论�Q?/strong>�Ҏ��下文��要提到的策略合理��用命名空间�?/p>
1) 不具名命名空��_��Unnamed Namespaces�Q?/font>

�?cc文�g中，允许甚至提倡��用不具名命名�I�间�Q�以避免�q�行时的命名冲突�Q?/p>
namespace {                                   // .cc 文�g�?
// 命名�I�间的内�Ҏ��需�~�进
enum { UNUSED, EOF, ERROR };          // �l�常使用的符�?br>bool AtEof() { return pos_ == EOF; }   // 使用本命名空间内的符号EOF
} // namespace
然而，与特定类兌��的文件作用域声明在该�c�M��被声明�ؓ�c�d��、静态数据成员或静态成员函敎ͼ�而不是不具名命名�I�间的成员。像上文展示的那��P��不具名命名空间结束时用注�?/ namespace标识�?
不能�?h文�g中��用不具名命名�I�间�?
2) 具名命名�I�间�Q�Named Namespaces�Q?/strong>
具名命名�I�间使用方式如下�Q?/p>
命名�I�间��?font color="#800000">除文件包含、全局标识的声�?定义以及�cȝ��前置声明�?/font>的整个源文�g��装��h��Q�以同其他命名空间相区分�?/p>
// .h文�g
namespace mynamespace {

// 所有声明都�|�于命名�I�间�?br>// 注意不要使用�~�进
class MyClass {
public:
...
void Foo();
};
} // namespace mynamespace

// .cc文�g
namespace mynamespace {

// 函数定义都置于命名空间中
void MyClass::Foo() {
...
}
} // namespace mynamespace
通常�?cc文�g会包含更多、更复杂的细节，包括对其他命名空间中�cȝ��引用�{��?
#include "a.h"
DEFINE_bool(someflag, false, "dummy flag");
class C; // 全局命名�I�间中类C的前�|�声�?br>namespace a { class A; } // 命名�I�间a中的�c�a::A的前�|�声�?
namespace b {
...code for b...                // b中的代码
} // namespace b

不要声明命名�I�间std下的��M��内容�Q�包括标准库�cȝ��前置声明。声明std下的实体会导致不明确的行为，如，不可�U�L��。声明标准库下的实体�Q�需要包含对应的头文件�?/p>
最好不要��用using指示�W�，以保证命名空间下的所有名�U�都可以正常使用�?/p>
// ��止——污染命名空�?br>using namespace foo;

�?cc文�g�?h文�g的函数、方法或�c�M��Q�可以��用using�?/p>
// 允许�Q?cc文�g�?br>// .h文�g中，必须在函数、方法或�cȝ��内部使用
using ::foo::bar;

�?cc文�g�?h文�g的函数、方法或�c�M��Q�还可以使用命名�I�间别名�?/p>// 允许�Q?cc文�g�?br>// .h文�g中，必须在函数、方法或�cȝ��内部使用

namespace fbz = ::foo::bar::baz;

2. 嵌套�c�（Nested Class�Q?/font>

当公开嵌套�c�M��为接口的一部分�Ӟ��虽然可以直接��他们保持在全局作用域中�Q�但��嵌套类的声明置于命名空间中是更好的选择�?/p>
定义�Q?/strong>可以在一个类中定义另一个类�Q�嵌套类也称成员�c�（member class�Q?/font>�?
class Foo {
private:
// Bar是嵌套在Foo中的成员�c?br> class Bar {
    ...
};
};
优点�Q?/strong>当嵌套（成员�Q�类只在被嵌套类�Q�enclosing class�Q?/font>中��用时很有用，��其�|�于被嵌套类作用域作��嵌套�cȝ��成员不会污染其他作用域同名类。可在被嵌套�c�M��前置声明嵌套�c�，�?cc文�g中定义嵌套类�Q�避免在被嵌套类中包含嵌套类的定义，因�ؓ嵌套�cȝ��定义通常只与实现相关�?
�~�点�Q?/strong>只能在被嵌套�cȝ��定义中才能前�|�声明嵌套类。因此，��M��使用Foo::Bar*指针的头文�g必须包含整个Foo的声明�?
�l�论�Q?/strong>不要��嵌套类定义为public�Q�除非它们是接口的一部分�Q�比如，某个�Ҏ��使用了这个类的一�p�d��选项�?
3. 非成员函敎ͼ�Nonmember�Q�、静态成员函敎ͼ�Static Member�Q�和全局函数�Q�Global Functions�Q?/strong>
使用命名�I�间中的非成员函数或静态成员函敎ͼ��量不要使用全局函数�?
优点�Q?/strong>某些情况下，非成员函数和静态成员函数是非常有用的，��非成员函数�|�于命名�I�间中可避免对全局作用域的污染�?
�~�点�Q?/strong>��非成员函数和静态成员函��C��为新�cȝ��成员或许更有意义�Q�当它们需要访问外部资源或��h��重要依赖时更是如此�?
�l�论�Q?/strong>
有时�Q�不把函数限定在�cȝ��实体中是有益的，甚至需要这么做�Q�要么作为静态成员，要么作�ؓ非成员函数。非成员函数不应依赖于外部变量，�q�尽量置于某个命名空间中。相比单�U��ؓ了封装若�q�不�׃�n��M��静态数据的静态成员函数而创建类�Q�不如��用命名空间�?
定义于同一�~�译单元的函敎ͼ�被其他编译单元直接调用可能会引入不必要的耦合和连接依赖；静态成员函数对此尤其敏感。可以考虑提取到新�c�M��Q�或者将函数�|�于独立库的命名�I�间中�?
如果你确实需要定义非成员函数�Q�又只是�?cc文�g中��用它�Q�可使用不具名命名空间或static兌��Q�如static int Foo() {...}�Q�限定其作用域�?
4. 局部变量（Local Variables�Q?/font>
��函数变量尽可能�|�于最��作用域内，在声明变量时��其初始化�?/p>
C++允许在函数的��M��位置声明变量。我们提倡在��可能小的作用域中声明变量，��ȝ��一�ơ��用越�q�越好。这使得代码易于阅读�Q�易于定位变量的声明位置、变量类型和初始倹{��特别是�Q�应使用初始化代替声�?赋值的方式�?/p>
int i;
i = f();        // 坏——初始化和声明分��?br>nt j = g();   // 好——初始化时声�?/p>
注意�Q�gcc可正��执行for (int i = 0; i < 10; ++i)�Q�i的作用域仅限for循环�Q�，因此其他for循环中可重用i。if和while�{�语句中�Q?font color="#800000">作用域声明（scope declaration�Q?/font>同样是正��的�?/p>
while (const char* p = strchr(str, '/')) str = p + 1;

注意�Q�如果变量是一个对象，每次�q�入作用域都要调用其构造函敎ͼ�每次退��Z��用域都要调用其析构函数�?/p>
// 低效的实�?br>for (int i = 0; i < 1000000; ++i) {
Foo f; // 构造函数和析构函数分别调用1000000�ơ！
f.DoSomething(i);
}

�c�M��变量攑ֈ�循环作用域外面声明要高效的多�Q?/p>
Foo f; // 构造函数和析构函数只调�?��?br>for (int i = 0; i < 1000000; ++i) {
f.DoSomething(i);
}

5. 全局变量�Q�Global Variables�Q?/font>

class�c�d��的全局变量是被��止的，内徏�c�d��的全局变量是允许的�Q�当然多�U�程代码中非常数全局变量也是被禁止的。永�q�不要��用函数返回值初始化全局变量�?/p>
不幸的是�Q�全局变量的构造函数、析构函��C��及初始化操作的调用顺序只是被部分规定�Q�每�ơ生成有可能会有变化�Q�从而导致难以发现的bugs�?/p>
因此�Q�禁止��用class�c�d��的全局变量�Q�包括STL的string, vector�{�等�Q�，因�ؓ它们的初始化��序有可能导致构造出现问题。内建类型和由内建类型构成的没有构造函数的�l�构体可以��用，如果你一定要使用class�c�d��的全局变量�Q�请使用单�g模式�Q�singleton pattern�Q?/font>�?/p>
对于全局的字�W�串帔R��Q��用C风格的字�W�串�Q�而不要��用STL的字�W�串�Q?/p>
const char kFrogSays[] = "ribbet";

虽然允许在全局作用域中使用全局变量�Q��用时务必三思。大多数全局变量应该是类的静态数据成员，或者当其只�?cc文�g中��用时�Q�将其定义到不具名命名空间中�Q�或者��用静态关联以限制变量的作用域�?/p>
��C��Q�静态成员变量视作全局变量�Q�所以，也不能是class�c�d��Q?/p>
______________________________________

译者：�q�一��主要提到的是作用域的一些规则，�ȝ��一下：
1. .cc中的不具名命名空间可避免命名冲突、限定作用域�Q�避免直接��用using提示�W�污染命名空��_��
2. 嵌套�cȝ��合局部��用原则，只是不能在其他头文�g中前�|�声明，��量不要public�Q?/strong>
3. ��量不用全局函数和全局变量�Q�考虑作用域和命名�I�间限制�Q�尽量单独�Ş成编译单元；
4. 多线�E�中的全局变量�Q�含静态成员变量）不要使用class�c�d��Q�含STL容器�Q�，避免不明��行为导致的bugs�?/strong>
作用域的使用�Q�除了考虑名称污染、可��L��之外，主要是�ؓ降低耦合度，提高�~�译、执行效率�?/strong>

Fox 2008-07-14 15:49 发表评论

�c�d��	不要使用	使用	备注
`void *`�Q�或其他指针�c�d��Q?/td>	`%lx`	`%p`
`int64_t`	`%qd`, `%lld`	`%"PRId64"`
`uint64_t`	`%qu`, `%llu`, `%llx`	`%"PRIu64"`, `%"PRIx64"`
`size_t`	`%u`	`%"PRIuS"`, `%"PRIxS"`	C99指定`%zu`
`ptrdiff_t`	`%d`	`%"PRIdS"`	C99指定`%zd`