C++博客-to myself 的分类学习日志-随笔分类-c++ programming

线程间的通讯——Socket

kongkongzi — Tue, 25 Nov 2014 03:06:00 GMT

Linux：
调用socketpair，create a pair of connected sockets。

1 int g_notificationPipeFDs[2];
2
3 int getNotificationSendFD()
4 {
5     return g_notificationPipeFDs[0];
6 }
7
8 int getNotificationRecvFD()
9 {
10     return g_notificationPipeFDs[1];
11 }
12
13 void* LogicThreadFunc(void* args)
14 {
15     struct timeval timeout;
16     timeout.tv_sec = 3;
17     timeout.tv_usec = 0;
18
19     int value;
20
21     while (1)
22     {
23         int nfds = getNotificationRecvFD() + 1;
24         fd_set readfds;
25         FD_ZERO(&readfds);
26         FD_SET(getNotificationRecvFD(), &readfds);
27
28         int ret = select(nfds, &readfds, NULL, NULL, &timeout);
29         if (ret < 0)
30         {
31             perror("select");
32             break;
33         }
34         else if (0 == ret)
35         {
36                 // timeout and do nothing.
37         }
38         else
39         {
40             while (1)
41             {
42                 int len = recv(getNotificationRecvFD(), &value, sizeof(value), 0);
43                 if (len > 0)
44                 {
45                     printf("Recv: %d\n", value);
46                 }
47                 else
48                 {
49                     break;
50                 }
51             }
52         }
53     }
54
55     return NULL;
56 }
57
58
59
60 int main(int c, char **v)
61 {
62     if (socketpair(AF_LOCAL, SOCK_STREAM, 0, g_notificationPipeFDs) != 0)
63     {
64         perror("socketpair");
65         return -1;
66     }
67
68     pthread_t logicThreadId;
69     int ret = pthread_create(&logicThreadId, NULL, LogicThreadFunc, NULL);
70     if (ret != 0)
71     {
72         perror("fail to create thread 1.\n");
73         return -1;
74     }
75
76     int value;
77     while (1)
78     {
79         std::cin >> value;
80         printf("Input: %d\n", value);
81         int len = send(getNotificationSendFD(), &value, sizeof(value), 0);
82         if (len != sizeof(value))
83         {
84             printf("just send %d bytes.\n", len);
85         }
86     }
87
88     return 0;
89 }

参考 libevent的evutil_socketpair的实现。

/** Create two new sockets that are connected to each other.

    On Unix, this simply calls socketpair().  On Windows, it uses the
    loopback network interface on 127.0.0.1, and only
    AF_INET,SOCK_STREAM are supported.

    (This may fail on some Windows hosts where firewall software has cleverly
    decided to keep 127.0.0.1 from talking to itself.)

    Parameters and return values are as for socketpair()
*/
int evutil_socketpair(int d, int type, int protocol, evutil_socket_t sv[2]);

使用Socket实现进程间的通讯，与使用 “Mutex lock + Condition variable + 共享缓存区” 实现进程间的通讯的区别：

Socket方式：为了实现异步非阻塞地触发处理事件，一般需要把Recv端的socket加入到一个Reactor或Proactor。数据需要被拷贝。
Condition variable方式：在wait端需要死等，没有超时设置（？）。需要加锁。

kongkongzi 2014-11-25 11:06 发表评论

Mutex and Condition variable

kongkongzi — Wed, 12 Nov 2014 09:54:00 GMT

Mutex and Condition variable in Linux:

1 int g_value = 0;
2 pthread_mutex_t g_pthread_mutex;
3 pthread_cond_t g_pthread_cond;
4
5
6 void* ThreadFunc1(void* args)
7 {
8     pthread_mutex_lock(&g_pthread_mutex);
9
10     printf("ThreadFunc1\n");
11
12     pthread_cond_wait(&g_pthread_cond, &g_pthread_mutex);
13
14     g_value = 1;
15     sleep(2);
16     printf("ThreadFunc1: g_value=%d.\n", g_value);
17
18     pthread_mutex_unlock(&g_pthread_mutex);
19     return NULL;
20 }
21
22
23 void* ThreadFunc2(void* args)
24 {
25     pthread_mutex_lock(&g_pthread_mutex);
26
27     printf("ThreadFunc2\n");
28
29     pthread_cond_signal(&g_pthread_cond);
30
31
32     g_value = 2;
33     sleep(2);
34     printf("ThreadFunc2: g_value=%d.\n", g_value);
35
36     pthread_mutex_unlock(&g_pthread_mutex);
37     return NULL;
38 }

1 int main(int argc, char **argv)
2 {
3     if (pthread_mutex_init(&g_pthread_mutex, NULL) != 0)
4     {
5         printf("fail to initial thread mutex.\n");
6         return -1;
7     }
8
9     if (pthread_cond_init(&g_pthread_cond, NULL) != 0)
10     {
11         printf("fail to initial thread condition.\n");
12         return -1;
13     }
14
15     pthread_t thread1;
16     int ret = pthread_create(&thread1, NULL, ThreadFunc1, NULL);
17     if (ret != 0)
18     {
19         printf("fail to create thread 1.\n");
20         return -1;
21     }
22
23     pthread_t thread2;
24     ret = pthread_create(&thread2, NULL, ThreadFunc2, NULL);
25     if (ret != 0)
26     {
27         printf("fail to create thread 2.\n");
28         return -1;
29     }
30
31     pthread_join(thread1, NULL);
32     pthread_join(thread2, NULL);
33
34   return 0;
35 }

输出：

ThreadFunc1

ThreadFunc2

ThreadFunc2: g_value=2.

ThreadFunc1: g_value=1.

Mutex and Condition variable in Windows:

HANDLE event
CreateEvent
SetEvent
ResetEvent
WaitForSingleObject

HANDLE mutex
CreateMutex
ReleaseMutex
WaitForSingleObject

注：Windows HANDLE类型可以为Event，Mutex，Process，Thread，Semaphore等。

说明：
1. C++在使用时，一般封装设计class Mutex，提供lock、unlock等函数，和设计class Monitor（boost::condition_variable_any），提供wait、notify等函数。

kongkongzi 2014-11-12 17:54 发表评论

CTime

kongkongzi — Wed, 02 May 2012 10:57:00 GMT

验证time_t值是否正确

1/* ctime example */
2#include <stdio.h>
3#include <time.h>
4#include <stdlib.h>
5
6
7int main (int argc, char* argv[])
8{
9  if (argc != 2)
10  {
11      printf("Usage: %s sec\n", argv[0]);
12      return -1;
13  }
14
15
16  time_t t = (time_t)atoi(argv[1]);
17  printf ( "The input's local time is: %s\n", ctime(&t) );
18
19  // time_t rawtime;
20  //struct tm * ptm;
21
22  //time ( &rawtime );
23  //ptm = gmtime ( &rawtime );
24
25  return 0;
26}

kongkongzi 2012-05-02 18:57 发表评论

c++ programming reference

kongkongzi — Mon, 04 Jul 2011 06:57:00 GMT

《Effective C++中文第三版》【美】 Scott Meyers 著侯捷译

《More Effective C++》

《高质量程序设计指南--C++/C语言（第3版）》林锐韩永泉编著

C++ 是一门难学易用的语言！

C++ 的难学，不仅在其广博的语法、语法背后的语义、语义背后的深层思维、深层思维背后的对象模型；C++ 的难学，还在于它提供了4种不同（相辅相成）的编程思维模型：procedural-based，object-based，object-oriented，generic paradigm。

世上没有白吃的午餐。又要有效率，又要有弹性，又要前瞻望远，又要回溯相容，又要能治大国，又要能烹小鲜，学习起来当然就不可能太简单。

在如此庞大复杂的机制下，万千使用者前赴后继的动力是：一旦学成，妙用无穷。

C++相关书籍车载斗量，如天上繁星，如果过江之鲫。

广博如四库全书者有之（The C++ Programming Language、C++ Primer、Thinking in C++），

深奥如重山复水者有之（The Annotated C++ Reference Manual, Inside the C++ Object Model），

细说历史者有之（The Design and Evolution of C++, Ruminations on C++），

独沽一味者有之（Polymorphism in C++），

独树一帜者有之（Design Patterns, Large Scale C++ Software Design, C++ FAQs）,
另辟蹊径者有之（Generic Programming and the STL），

程序库大全有之（The C++ Standard Library），

专家经验之累积亦有之（Effective C++, More Effective C++, Exceptional C++）。

这其中，"工程经验之累积"对已具 C++ 相当基础的程序员而言，有着致命的吸引力与立竿见影的帮助，其特色是轻薄短小，高密度地纳入作者浸淫于 C++/OOP 多年而广泛的经验。它们不但开扩读者的视野，也为读者提供各种 C++/OOP 常见问题的解决模型。某些小范围主题诸如"在base classes 中使用 virtual destructor"、"令operator= 传回 *this 的 reference"，可能在百科型 C++ 语言书籍中亦曾概略提过，但此类书籍以深度探索的方式，让我们了解问题背后的成因、最佳的解法，以及其他可能的牵扯。至于大范围主题，例如smart pointers，reference counting，proxy classes，double dispatching，基本上已属design patterns的层级！

c++经典书籍
原文：http://blog.163.com/yujishui2887090@126/blog/static/217925202007101692235256/
　　这几本让读者和我在期待的C/C++巨著就是这期我要推荐的——《Essential C++中文版》、《Effective C++中文版》、《The C++ Programming Language》和《C++ Primer》。

　　Essential C++（Addison Wesley Pub Co.，1999年10月第一版）的作者Stanley B. Lippman更是C++领域一流的大师级人物，他从1984年开始就与C++结下了不解之缘：参与了第一个C++编译器C Front的开发，曾经和C++之父Bjarne Stroustrup（详见下）一起在贝尔实验室的项目组工作、负责研究C++程序开发环境中的对象模型，后来又担任著名的C++Report杂志编辑，此后他到迪斯尼旗下的梦工厂出任软件技术总监（Software Technology Director），主要著述有Essential C++、C++Primer、C++Gems、Inside the C++ Object Model、C＃Primer等，关于作者的更详细信息可以到其个人网站（http://www.objectwrite.com/，该网址笔者已验证无误）查询。

　　Lippman当前在业界的影响力可以从最近发生的一件事情看出：不久前微软已经邀请了C++编程语言的先驱Stanley B. Lippman加盟它的Visual C++.Net开发小组，以打消广大的C++编程人员的疑虑。

　　Essential C++是Lippman在C++ Primer之后的著作，可以说是厚积薄发的精髓之作。不要想当然地觉得这本书只有276页就是烹小鲜的入门向导——其实，我到觉得如果想通过一本书入门，1237页的C++ Primer或1109页的The C++ Programming Language更加适合。

　　Essential C++分为7个章节，分别是C++基础、面向过程的编程风格、泛型编程风格、基于对象的编程风格、面向对象的编程风格、运用模板编程和异常处理。从结构的安排上我们可以看出作者的深意所在：并不是要手把手地教你键入和编译调试一个类似“Hello World”的程序，而是要一步一步地教会读者通过函数、指针、模板、类等构件形成一套完整的编程思想，在不同的需求情况下能够自如地使用面向过程或面向对象的方法进行程序设计，正如Bjarne Stroustrup在The C++ Programming Language一书中引用Kristen Nygaard（Simula语言的两位创造者之一）所说的“Programming is understanding”。

　　如果你是一个新手，在阅读本书的时候不要忘了找一本更详细一些的参考教材——作者只用了30页的篇幅讲C++变成的基础知识，这里面还包括了数组、向量和指针等内容，《Essential C++中文版》（华中科技大学出版社，2001年8月第一版）已经出版，是侯捷的译著——恐怕业内很少有人不知道这位台湾大名鼎鼎电脑教育作家，建立在深刻理解基础上的翻译质量几乎可以说是无可挑剔了，但对于一些词汇的翻译方法和大陆翻译习惯的差异还有待磨合和改进（虽然译者坚持保留其繁体版译法）。

　　Effective C++（Addison Wesley Pub Co.，1997年9月第二版）没有教你C++语法或函数、对象、模板之类的东西，这是一本风格独到的经典技巧集，曾经获得过1992年度Jolt Award and Productivity Awards，作者教给你的是50个“改善程序技术与设计思维”的特别途径。

　　Scott Meyers是C++业界公认的权威，主要从事软件开发咨询工作，活跃在全球各技术研讨会上，同时是C++ Report的重要专栏作家，知名著述出了Effective C++之外还有More Effective C++和Effective STL等，关于作者的更详细信息可以到其个人网站（http://www.aristeia.com/）查询。

　　《Effective C++中文版》（华中科技大学出版社，2001年9月第一版）也已经在国内翻译出版，译者还是侯捷。当你初步了解C++的全貌之后，Effective C++能够在短时间内大幅度地提高你C++编程的水平，此书的独特之处在于每一个你遇到的C++问题，Meyers都好像未卜先知地放在了书里，所有让你困惑的问题你几乎都可以在这本书中找到精辟的论述——如果能加Meyers的另一本巨著More Effective C++（Addison Wesley Pub Co.，1995年12月第一版）将更会锦上添花。

　　本书在结构上分为改变旧有的C习惯、内存管理、构造析构函数与作业运算符、类与函数的设计和声明、类与函数的实现、继承关系与面向对象设计以及杂项讨论7个部分。很多人都认为你越熟悉C语言或其他面向过程的语言，在学习面向对象的语言的时候就会面临更大的困难，的确，如果你已经习惯了面向过程，在面向对象的时候你还是无法忘记过程，为此，Meyers在第一部分就提出了改变旧有的C习惯，通过几个小技巧让你能够尽量不受原有知识对新知识学习的干扰。

　　在接下来的3个部分中，作者又针对让人头疼的内存管理问题（Java就宣称采用自动内存管理减少了编程复杂程度和出错几率是比C++的一大进步），随后，作者针对函数与类的构造析构、设计、实现等问题进行了详实的讨论，没有枯燥的长篇大论，都是结合实例的分析讲解——如果你刚学C++不久但已经可以独立编写一些简单的程序，你会发现所有被批判的问题程序中都可以找到自己的影子，这真是一件奇妙的事情！

　　在“继承关系与面向对象设计”部分里作者没有喋喋不休地去讨论尚有争议的问题，而是把精力放在最基础的理念上，澄清了C++中类的继承体系设计与实现，并结合继承问题阐释了OOP。“杂项讨论”中作者主要讨论了编译、标准库等问题。

　　打一个粗俗些的比方：Effec tiv e C++和M o re Effec tiv e C++就像是C++学习者的手挠，每一下都抓在你的痒处。

　　The C++ Programming Language（Addison Wesley Pub Co.，2000年2月第三版，高等教育出版社，2001年8月影印版）是无论哪一个C++学习者绝对、绝对不能错过的头号经典。

　　Rogue Wave公司（Boland C++ Builder中STL方案的提供商）的Nathan Myers说：“15年之后，此书仍然是唯一一本无可替代的C++书籍。”只要有人推荐C++书籍，此书必在其中。正如侯捷先生1999年C++Primer繁体版前言中评价所说：“C++/OOP的领域极广……，不同的切入角度，都存在不同的经典好书。但如果考量的是语言全貌性（百科型）书籍，从来我只推荐两本，一是Bjarne Stroustrup的The C++ Programming Language，另一是Stanley B.Lippman的C++ Primer。这么说难免遗珠之憾，但是泰山北斗已现，又何必案牍劳形于墨瀚书海之中！这两本书都从C++盘古开天以来，一路改版，斩将搴旗，追奔逐北，成就一身荣光”。

　　作者Bjarne Stroustrup是贝尔实验室大规模程序设计研究部门（Large-Scale Programming Research Department）负责人，AT&T、ACM成员，主要著述有The C++ Programming Language、The Design and Evolution of C++、The Annotated C++ Reference Manual、C++ In-Depth Box Set（与别人合著）等。

　　1979年Stroustrup开始开发一种语言，当时称为“C with Class”，后来演化为C++，并于1995年在贝尔实验室研制成功并投入使用的，Stroustrup也被称为“C++之父”，关于作者的更详细信息可以到其个人网站（http://www.research.att.com/~bs/homepage.html）查询。

　　1998年，ANSI/ISOC++标准建立，同年，Strousturp推出了其经典著作The C++Programming Language的第三版。The C++Programming Language可是说非常全面、权威，充满了技术性极强的材料，很多地方值得反复回味与思索。

　　Stroustrup说，他所接触和开发的软件无论是在大小、复杂性和难度来说，根本不是外界一般软件所能比拟的。本书虽然是一本计算机编程语言教程，但是处处体现出他对于软件开发和程序设计的看法。所以他在书中的很多观点虽然看上去不觉得有什么了不起的地方，但是当你面临到真正挑战的时候，就会深刻体会到其真知灼见非同一般。即便我们不考虑语言的障碍，这本书仍然比较难懂，作者很多地方点到即止，其中深意不是初学者能够真正领会的。

　　这本书有个绰号——C++专家自学指南，也就是你必须先是专家，然后再来读此书自学提高。

　　C++ Primer是Lippman的成名大作——不要看到这个名字就真认为这是“C++的初级读本”，实际上它是一本标准的“从入门到精通”教材，目前该书的简体中文版还没有上市，我到处寻找其英文版也没能如愿，一个偶然的机会在朋友那里看到了侯捷（见上关于此书的评价）繁体中文版的C++Primer，大体翻看了一下，感觉此书在实例方面非常详尽，内容可谓是全面、权威，通俗易懂。

　　初学者只要能够认真学通这本书，足以能自由使用C++编写程序，成为C++的高手。C++ Primer对标准C++提供了广泛的介绍，提供了一个思考性的C++学习方案，C++中的重要该概念诸如异常处理、容器类型、面向对象的程序设计等等都体现在字里行间，对语言规则也进行了深入地探讨，是一本非常好的入门也是提高的教程和参考。

　　全书共分为20章，从C++最基本的元素、数据类型到面向过程的程序设计到泛型算法到基于对象与面向对象的程序设计等等，洋洋洒洒，蔚为大观。此书将由中国电力出版社近期推出简体中文版，由潘爱民（《COM原理与应用》的作者，《Visual C++技术内幕（第四版）》、《深入理解COM+》、《COM本质论》、《深入解析ATL》的译者）主译。

kongkongzi 2011-07-04 14:57 发表评论

c++ pointer (the second)

kongkongzi — Tue, 14 Dec 2010 10:33:00 GMT

简单例子：

class tt
{
public:
void foo(int x) { printf("%d",x); }
};

typedef void　( tt::* FUNCTYPE)(int );
FUNCTYPE ptr = tt::foo;　//给一个成员函数指针赋值.
tt a;
(a.*ptr)(5);//调用成员函数指针.
tt *b = new tt;
(b->*ptr)(6);　//调用成员函数指针.

men_fun与mem_fun_ref

#include<iostream>
using namespace std;
#include<functional>
#include<algorithm>
#include<bitset>
#include<vector>
class A
{
public:
int Fun()
{
   cout<<"Fun"<<endl;
   return 0;
}
};
void main()
{
vector<A*> vectA;
for(int i=1;i<3;i++)
{
   A * a=new A;
   vectA.push_back(a);
}
for_each(vectA.begin(),vectA.end(),mem_fun(&A::Fun));// mem_fun_ref的作用和用法跟mem_fun一样，唯一的不同就是：当容器中存放的是对象实体的时候用mem_fun_ref，当容器中存放的是对象的指针的时候用mem_fun。

}
我们把men_fun与mem_fun_ref理解为函数绑定器就够了！！

模板成员函数

class Obj
{
public:
    template <class   T>
    void   display(const T& val1 = 10, int val2 = 10) {
        cout << val1 << endl;
        cout << val2 << endl;
    }
};

int main()
{
    Obj obj;

    string str( "hello ");

    obj.display(str, 100);

    system("pause");
    return(0);
}

C++模板实现事件处理器中的“通用成员函数指针”的调用
参考：
http://www.cnblogs.com/Xiao_bird/archive/2009/07/03/1516441.html

class FuncCaller
{
public:
    virtual void func_call(void* obj_ptr, void* param)=0;

};

template <typename T>
class FuncItem : public FuncCaller
{
private:
    typedef void (T::*HandlerPtr)(void* param);
    HandlerPtr handler;

public:
    void func_call(void* obj_ptr, void* param)
    {
        if( !obj_ptr )
            return ;

        (((T*)obj_ptr)->*handler)(param);
    }

    FuncItem(const HandlerPtr ptr):handler(ptr) {}  // 此处为新添加代码
};

typedef struct _EventRegister
{
    EventType event;
    FuncCaller* func_caller;
} EventRegister;

class ClassA
{
public:
    void show_me(void* param)
    { printf("I'm ClassA, show_me is called! param is 0x%x\n", param); }
};

class ClassB
{
public:
    void come_on(void* param)
    { printf("I'm ClassB, come_on is called! param is 0x%x", param); }
};

EventRegister event_center[] = {
    { EVENT_TEST_1  , new FuncItem<ClassA>(&ClassA::show_me) },
    { EVENT_TEST_2  , new FuncItem<ClassB>(&ClassB::come_on) },
    { EVENT_INVALID , NULL }
};

/**
* Function:send_event
* params:
*        event -> event type
*        target -> who will process the event
*/
void send_event(EventType event, void* target, void* param)
{
    if( !target )
        return ;

    int loop_event = 0;
    EventType et = event_center[loop_event].event;
    while( et!=EVENT_INVALID )
    {
        if( et==event )
    {
        event_center[loop_event].func_caller->func_call(target, param);
        break;
    }

    et = event_center[++loop_event].event;
    }
}

void main()
{
    ClassA ca;
    ClassB cb;

    send_event(EVENT_TEST_1, (void*)&ca, (void*)0xff00);
    send_event(EVENT_TEST_2, (void*)&cb, NULL);
}

boost::bind
参考：
1，http://blog.csdn.net/Solstice/archive/2008/10/13/3066268.aspx

class Foo
{
public:
  void methodA();
  void methodInt(int a);
};
class Bar
{
public:
  void methodB();
};

boost::function<void()> f1; // 无参数，无返回值

Foo foo;
f1 = boost::bind(&Foo::methodA, &foo);
f1(); // 调用 foo.methodA();
Bar bar;
f1 = boost::bind(&Bar::methodB, &bar);
f1(); // 调用 bar.methodB();

f1 = boost::bind(&Foo::methodInt, &foo, 42);
f1(); // 调用 foo.methodInt(42);

boost::function<void(int)> f2; // int 参数，无返回值
f2 = boost::bind(&Foo::methodInt, &foo, _1);
f2(53); // 调用 foo.methodInt(53);

kongkongzi 2010-12-14 18:33 发表评论

class base and derived

kongkongzi — Fri, 12 Nov 2010 12:07:00 GMT

// base.h
#include <iostream>

class Base
{
public:
    Base() { std::cout << "Base::Base" << std::endl; }
    ~Base() { std::cout << "Base::~Base" << std::endl; }
    virtual void Init() { std::cout << "Base::Init" << std::endl; }
    virtual void Final() { std::cout << "Base::Final" << std::endl; }
    virtual void Print() { std::cout << "Base::Print" << std::endl; }
    void Call() { Print(); }
};

// derived.h
#include "base.h"

class Derived : public Base
{
public:
    Derived() { std::cout << "Derived::Derived" << std::endl; }
    ~Derived() { std::cout << "Derived::~Derived" << std::endl; }
    virtual void Init() { std::cout << "Derived::Init" << std::endl; }
    virtual void Final() { std::cout << "Derived::Final" << std::endl; }
    virtual void Print() { std::cout << "Derived::Print" << std::endl; }
};

// main.cpp
#include <derived.h>

int main(void)
{
    Base *pD = new Derived();
    pD->Init();

    pD->Call();

    pD->Final();
    delete pD;
    pD = NULL;

    return 0;
}

Results:

Base::Base
Derived::Derived
Derived::Init
Derived::Print
Derived::Final
Base::~Base

若在Base的构造函数里调用Call()，那么将打印：“Base::Print “，这是因为Base在构造的时候，Derived本身还没有构造好。

kongkongzi 2010-11-12 20:07 发表评论

c++ pointer

kongkongzi — Fri, 17 Sep 2010 03:56:00 GMT

摘要: 一、数据指针 #include struct MyStruct{ int key; int value;};int sum(My... 阅读全文

kongkongzi 2010-09-17 11:56 发表评论

编码风格

kongkongzi — Sat, 28 Aug 2010 12:59:00 GMT

文件包含的名字和顺序

请使用以下标准顺序以保证可读性，并且避免隐藏的依赖：C库，C++库，其他库的.h，你的项目的.h。

所有项目的头文件应作为项目源文件目录的后代列出，不要使用UNIX中的目录快捷方式 . (当前目录）和 .. (父目录）。

举个例子，google-awesome-project/src/base/logging.h应该以#include "base/logging.h"的格式包含。

在 dir/foo.cc中，该文件的主要目的是实现或者测试在dir2/foo2.h中的东西，文件包含应按照如下排序：

1. dir2/foo2.h (首选位置(preferred location) — 请见下面的详细说明).

2. C system files.

3. C++ system files.

4. Other libraries' .h files.

5. Your project's .h files.

首选的排序（preferred ordering，译者注：在以上例子中为dir2/foo2.h ）降低了隐藏的依赖。我们希望每个头文件能够自我编译。最简单的方式就是确保它们中的每一个都在某个.cc文件中是第一个被#include的。

dir/foo.cc and dir2/foo2.h通常在同一目录下（比如base/basictypes_unittest.cc and base/basictypes.h），但也可能在不同的目录下。

在每个部分(section)中，根据字母顺序排列是不错的方式。

举个例子，google-awesome-project/src/foo/internal/fooserver.cc中的文件包含顺序可能是这样：

1
2
3
4
5
6
7
8
9
10

#include "foo/public/fooserver.h" // 首选位置
#include
#include

#include
#include

#include "base/basictypes.h"
#include "base/commandlineflags.h"
#include "foo/public/bar.h"

参考：
1， Google C++ Style Guide：http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
2， Google C++ 风格指南 - 中文版：http://yangyubo.com/google-cpp-styleguide/

kongkongzi 2010-08-28 20:59 发表评论

异常处理

kongkongzi — Fri, 23 Apr 2010 02:54:00 GMT

1 #include <iostream>
2 #include <string>
3 #include <exception>
4 using namespace std;
5
6
7 class SystemException : public std::exception
8 {
9 public:
10 /// Construct with a specific context and error code.
11 SystemException(const std::string& context, int code)
12     : mContext(context),
13     mCode(code)
14 {
15 }
16 /// Copy constructor.
17 SystemException(const SystemException& e)
18     : std::exception(e),
19     mContext(e.mContext),
20     mCode(e.mCode)
21 {
22 }
23 /// Destructor.
24 virtual ~SystemException() throw ()
25 {
26 }
27 /// Assignment operator.
28 SystemException& operator=(const SystemException& e)
29 {
30     mContext = e.mContext;
31     mCode = e.mCode;
32     return *this;
33 }
34 /// Get a string representation of the exception.
35 virtual const char* what() const throw ()
36 {
37     return mContext.c_str();
38 }
39 /// Get the implementation-defined context associated with the exception.
40 const std::string& Context() const
41 {
42     return mContext;
43 }
44 /// Get the implementation-defined code associated with the exception.
45 int Code() const
46 {
47     return mCode;
48 }
49 private:
50 // The context associated with the error.
51 std::string mContext;
52 // The code associated with the error.
53 int mCode;
54 };
55
56 /// Output the string associated with a system exception.
57 /**
58 * Used to output a human-readable string that is associated with a system
59 * exception.
60 *
61 * @param os The output stream to which the string will be written.
62 *
63 * @param e The exception to be written.
64 *
65 * @return The output stream.
66 *
67 * @relates boost::asio::SystemException
68 */
69 template <typename Ostream>
70 Ostream& operator<<(Ostream& os, const SystemException& e)
71 {
72 os << e.what();
73 return os;
74 }
75
76
77 int main(void)
78 {
79     try
80     {
81         throw SystemException("A system error!", 0);
82     }
83     catch (std::exception& e)
84     {
85         std::cout << "Exception1:" << e.what() << std::endl;
86     }
87     catch (std::string& e)
88     {
89         std::cout << "Exception2:" << e.c_str() << std::endl;
90     }
91     catch ()
92     {
93         std::cout << "catch a exception " << std::endl;
94     }
95
96     std::cout << "end main" << std::endl;
97     return 0;
98 }
99

kongkongzi 2010-04-23 10:54 发表评论

VC++设置

kongkongzi — Tue, 15 Sep 2009 09:35:00 GMT

修改工程的Working Directory 为：$(OutDir)

kongkongzi 2009-09-15 17:35 发表评论

静态库与动态库

kongkongzi — Fri, 06 Mar 2009 05:57:00 GMT

静态编译的lib；动态dll的lib，只是一些符号导入库。
LIB有两种,一种是静态库,比如C-Runtime库,这种LIB中有函数的实现代码,一般用在静态连编上,它是将LIB中的代码加入EXE文件中,所以编译好了之后,LIB文件就没有了.一种LIB是和DLL配合使用的,里面没有代码,代码在DLL中,这种LIB是用在静态调用DLL上的,所以起的作用也是编译中用,编译完成了,LIB也没用了.至于动态调用DLL的话,根本用不上LIB文件.

kongkongzi 2009-03-06 13:57 发表评论

加锁

kongkongzi — Thu, 05 Mar 2009 07:31:00 GMT

关键区域
和其他同步对象不同，除非有需要以外，关键区域工作在用户模式下。若一个线程想运行一个封装在关键区域中的代
码，它首先做一个旋转封锁，然后等待特定的时间，它进入内核模式去等待关键区域。实际上，关键区域持有一个旋转计数器和一个信号量，前者用于用户模式的等待，后者用于内核模式的等待（休眠态）。
在Win32API中，有一个L_SECTION结构体表示关键区域对象。在MFC中，有一个类CCriticalSection。关键区域是这样一段代码，当它被一个线程执行时，必须确保不会被另一个线程中断。

Linux设备驱动之并发控制: 自旋锁与信号量（绝大多数时候作为互斥锁使用）。
原子操作
锁的作用域：在哪定义一把锁？

kongkongzi 2009-03-05 15:31 发表评论

c++点滴

kongkongzi — Thu, 05 Mar 2009 07:25:00 GMT

类成员指针的讲解详见c++primer高级主题
typedef void (T::* HANDLER)(ObjectMessage* pMessage);

delete this;

string内存布局不透明，只能用new类，不能用malloc类。用memset会把类里的一些必要数据也清零。比如如果类有虚函数，则就有虚表指针，你用memset会把虚函数表指针置为0，这样你的类还有多态吗，你的程序还是健壮的吗? 有构造函数为什么还要如此呢!!!!!!

uint32数据总是大于0.

_DEBUG;

mutable
explicit
std::cout.write(buf.data(), len);

一个线程只能在一个CPU core上运行。

错误处理(Error-Handling)
异常规格申明
ip地址映射 NAT（网络地址转换）
刚刚断开的socket被新加入的连接socket重用，导致处理复杂逻辑的线程里把应该发给原来断开的SOCKET的数据发给新上来SOCKET了，呵呵，所以错误就出现了。

原型：extern char *strlwr(char *s);
功能：将字符串s转换为小写形式
说明：只转换s中出现的大写字母，不改变其它字符。返回指向s的指针

原型：extern char *strupr(char *s);
功能：将字符串s转换为大写形式
说明：只转换s中出现的小写字母，不改变其它字符。返回指向s的指针。

kongkongzi 2009-03-05 15:25 发表评论

char*与std::string

kongkongzi — Wed, 04 Mar 2009 02:52:00 GMT

1，从数据流中取出指定长度的字节，不能保证该段字节是以'\0'结尾，故取的时候要主动在其后面加上'\0'，保证它一定是字符串（特别是使用char*接收的时候）。使用std::string(s)亦可将字符流转换成字符串？？？？？No!!! 转换的字节流也是以在找到'\0'时才结束。
2，向Data Stream中压入string类型的数据时，Data Stream使用strlen()来计算它的长度。
3，为了保险起见，发送指定长度的字节时，最好后面跟上一个'\0'。
4，一般化：当要将一段字节流当作字符串使用时，应该主动地、显示地在字节流的末尾加上'\0'。

kongkongzi 2009-03-04 10:52 发表评论