Error

endpoint:描述socket编程体系下的一个端点。一个IP+PORT ?

port还是一样的unsigned short

提供一个data()方法，来返回原生的地址结构体。这是一个好的思路，这样系统就不会封闭了。

 

address: 抽象的一个IP地址，可以是ipv4、ipv6。对外接口一致。具体实现上，是聚合了4和6两个实体。所以提供is_v4 is_v6这样两个函数来确认类型。
  address只提供string到address的转换和构造。具体到address_v6 address_v4以后有提供long到address_v4的转换同时也提供了一系列的帮助函数：
    /// Determine whether the address is a loopback address.
  BOOST_ASIO_DECL bool is_loopback() const;

  /// Determine whether the address is unspecified.
  BOOST_ASIO_DECL bool is_unspecified() const;

  /// Determine whether the address is a class A address.
  BOOST_ASIO_DECL bool is_class_a() const;

  /// Determine whether the address is a class B address.
  BOOST_ASIO_DECL bool is_class_b() const;

  /// Determine whether the address is a class C address.
  BOOST_ASIO_DECL bool is_class_c() const;

  /// Determine whether the address is a multicast address.
  BOOST_ASIO_DECL bool is_multicast() const;
  /// Obtain an address object that represents the loopback address.
  static address_v4 loopback()
  /// Obtain an address object that represents the broadcast address.
  static address_v4 broadcast()

C 宏

前言
第1章并行让程序运行得更快
你可能会想到的一些问题
采用线程化方法的4个步骤
并行算法的背景知识
共享内存编程与分布式内存编程的比较
本书采用的并发编程方法
第2章是否采用并发
并发算法的设计模型
哪些算法不能并行
第3章算法正确性证明与性能衡量
并行算法的验证
示例：临界区问题
性能测试（程序的执行情况如何）
硬件并行性的发展历史

第4章多线程程序设计中的8条简单规则
规则1：找出真正独立的运算
规则2：在尽可能高的层次上实现并发
规则3：尽早考虑通过增加处理器核的数量来获得可伸缩性
规则4：尽可能使用线程安全的库
规则5：使用正确的多线程模型
规则6：永远不要假设程序会按照某种特定的顺序执行
规则7：尽可能使用线程局部存储或者与特定数据相关的锁
规则8：要敢于对代码进行修改以获得更好的并发性
小结

第5章线程化库
隐式线程化
显式线程化
其他主题
特定领域的库

第6章并行求和与前缀求和
并行求和
前缀求和
选择
最后的思考
第7章映射归约
并发映射运算
并发归约运算
映射归约的应用
映射归约作为一般性并发

第8章排序
冒泡排序
奇偶换位排序
希尔排序
快速排序
基数排序

第9章搜索
未排序的数据序列
二分搜索

第10章图算法
深度优先搜索
最短路径问题
最小生成树

第11章线程化工具
调试器
性能工具
其他主题
再接再厉

这个体系中的class职责如下：

*ios_base：定义stream classes的所有“与字符类型以及相应的字符特性（traits）无关”的属性，主要包含状态和格式标志等组件和函数。

*basic_ios<>：定义“与字符类型以及相应的字符特性（traits）相关”的stream classes共同属性，其中包括stream所用的缓冲器。

*basic_istream<>  basic_ostream<>：定义出读写对象，如果不关心国际化问题，一般直接使用char实例化的isteram和ostream。

*basic_iostream<>：读写对象。

*basic_streambuf<>：iostream体系的核心，定义出所有“可改写的stream或，可读取的stream”的接口。其他的stream classes都是利用它进行实际的字符读写操作。

 

    iostream程序严格按照职责分离的原则来设计。basic_ios派生类型只处理数据格式化，实际读写操作由basic_ios派生类所维护的stream buffer完成。streambuf提供读写使用的字符缓冲区，形成对外的一种抽象概念。

 

                                                                                        

#include <iostream>

#include <boost/timer.hpp>

int _tmain(int argc, _TCHAR* argv[])
{
    boost::timer timer;

    const unsigned int TEST_DATA_LEN = 1440*900;
    char* pDataA = new char[TEST_DATA_LEN];
    memset(pDataA, NULL, TEST_DATA_LEN);
    char* pDataB = new char[TEST_DATA_LEN];
    memset(pDataB, NULL, TEST_DATA_LEN);

    double dCopyTime = 0;
    timer.restart();
    for (unsigned int uiLen = 0; uiLen < 1020; uiLen++)
    {
        memcpy(pDataA, pDataB, TEST_DATA_LEN);
    }
    dCopyTime = timer.elapsed();
    std::cout << dCopyTime << std::endl;

    double dMoveTime = 0;
    timer.restart();
    for (unsigned int uiLen = 0; uiLen < 1020; uiLen++)
    {
        memmove(pDataA, pDataA, TEST_DATA_LEN);
    }
    dMoveTime = timer.elapsed();
    std::cout << dMoveTime << std::endl;

    std::cout << "self copy lost:" << (dMoveTime - dCopyTime)*100 << std::endl;

    return 0;
}

// test_demo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>

class L1Provider
{
public:
    virtual void L1Service() = 0;
};

class L2Provider
{
public:
    virtual void L2Service() = 0;
    void SetLowerLayer(L1Provider* lv1)
    {
        m_pLv1 = lv1;
    }

protected:
    L1Provider* m_pLv1;
};

class L3Provider
{
public:
    virtual void L3Service() = 0;
    void SetLowerLayer(L2Provider* lv2)
    {
        m_pLv2 = lv2;
    }

protected:
    L2Provider* m_pLv2;
};

class DataLink : public L1Provider
{
public:
    virtual void L1Service()
    {
        std::cout << "lv1 doing its job" << std::endl;
    }
};

class Transport : public L2Provider
{
public:
    virtual void L2Service()
    {
        std::cout << "lv2 start its job" << std::endl;
        m_pLv1->L1Service();
        std::cout << "lv2 end its job" << std::endl;
    }
};

class Session : public L3Provider
{
public:
    virtual void L3Service()
    {
        std::cout << "lv3 start its job" << std::endl;
        m_pLv2->L2Service();
        std::cout << "lv3 end its job" << std::endl;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    // 实例化个层对象
    DataLink dataLink;
    Transport transport;
    Session session;

    // 安装好层
    transport.SetLowerLayer(&dataLink);
    session.SetLowerLayer(&transport);

    // 工作
    session.L3Service();

    return 0;
}

     摘要: 简化后的CNetClient类图：   本次是分享下整体设计思想，不研究细节网络实现。     CNetClient用户客户端的网络处理。主要功能需求如下： *能接收远端数据 *能把接收到的数据送到上层处理 *能向远端发送数据 **发送和接收都是异步 **CNetClient本身是一个底层服务，对上层是异步的   针对上述需求GodofMon...  阅读全文

 

///////////////////////////////////////////////////////////////////////////////////////////

实在是没看出来这样有什么优势，为了记录是否走过某个path？

Query::execute(const SQLString& str)这里看到了递归操作，难道是为了辅助递归？

总感觉这里越搞越复杂，，，

///////////////////////////////////////////////////////////////////////////////////////////

/// \brief A template for setting a flag on a variable as long as the
/// object that set it is in scope.  Flag resets when object goes
/// out of scope.  Works on anything that looks like bool.

template <class T = bool>
class AutoFlag
{
public:
    /// \brief Constructor: sets ref to true.
    AutoFlag(T& ref) :
    referent_(ref)
    {
        referent_ = true;
    }

    /// \brief Destructor: sets referent passed to ctor to false.
    ~AutoFlag()
    {
        referent_ = false;
    }

private:
    T& referent_;
};

 

///////////////////////////////////////////////////////////////////////////////////////////

ResNSel
Query::execute(const SQLString& str)
{
    if ((def.size() == 1) && !def.processing_) {
        // .  The
        // auto-reset flag is required because we'll end up back in this
        // function once the query string is built, but we need to take
        // the 'else' path to avoid an infinite loop.
        AutoFlag<> af(def.processing_);
        return execute(SQLQueryParms() << str);
    }
    else {
        // Take str to be the entire query string
        return execute(str.c_str(), str.length());
    }
}

ResNSel
Query::execute(const char* str)
{
    return execute(SQLString(str));
}

ResNSel
Query::execute(const char* str, size_t len)
{
    if (lock()) {
        success_ = false;
        if (throw_exceptions()) {
            throw LockFailed();
        }
        else {
            return ResNSel();
        }
    }

    success_ = !mysql_real_query(&conn_->mysql_, str, len);

    unlock();
    if (success_) {
        return ResNSel(conn_);
    }
    else if (throw_exceptions()) {
        throw BadQuery(error());
    }
    else {
        return ResNSel();
    }
}

////////////////////////////////////////////////////////////////

简介：内存DC，又名“双缓冲”，是解决windows窗口自绘中出现“闪屏”的常规手段。

1)、为屏幕 DC 创建兼容的内存 DC
2)、创建位图
3)、把位图选入设备环境
4)、把绘制好的图形“拷贝“到屏幕上

 

看这个代码：

首先看构造，从一个CDC构造。然后看了一下成员函数，好像没几个，估计这是一个可以完全替换的CDC的省心的东东。

然后看析构：析构是一个BitBit，联想自己做内存DC的时候，最后一步也是内存到DC的贴图动作。

公开接口就两个，重载的CDC* 和 ->操作，直接能当作CDC使用。

这几个细节需要注意：

1.m_bMemDC = !pDC->IsPrinting();  // 以前关注不多，这是用于判断这个DC是不是用于print，如果是就不使用“内存DC”，至于为什么还不了解。我理解是没有需要。

2.FillSolidRect(m_rect, pDC->GetBkColor());  // WM_ERASEBKGND，针对这个消息的细节处理。

 

这个类持有了一个“前台”DC，它本身是一个“后台”DC，每次后台克隆前台执行绘画然后把结果贴回去。

这里还有一个细节，就是SelectObject。为了保证不泄漏，最好的办法是，每次工作完成将所有的GDI对象复位。

///////////////////////////////////////////////////////////////

class CMemDC : public CDC
{
public:

    // constructor sets up the memory DC
    CMemDC(CDC* pDC) : CDC()
    {
        ASSERT(pDC != NULL);

        m_pDC = pDC;
        m_pOldBitmap = NULL;
#ifndef _WIN32_WCE_NO_PRINTING
        m_bMemDC = !pDC->IsPrinting();
#else
        m_bMemDC = FALSE;
#endif

        if (m_bMemDC)    // Create a Memory DC
        {
            pDC->GetClipBox(&m_rect);
            CreateCompatibleDC(pDC);
            m_bitmap.CreateCompatibleBitmap(pDC, m_rect.Width(), m_rect.Height());
            m_pOldBitmap = SelectObject(&m_bitmap);
#ifndef _WIN32_WCE
            SetWindowOrg(m_rect.left, m_rect.top);
#endif
            // EFW - Bug fix - Fill background in case the user has overridden
            // WM_ERASEBKGND.  We end up with garbage otherwise.
            // CJM - moved to fix a bug in the fix.
            FillSolidRect(m_rect, pDC->GetBkColor());
        }
        else        // Make a copy of the relevent parts of the current DC for printing
        {
#if !defined(_WIN32_WCE) || ((_WIN32_WCE > 201) && !defined(_WIN32_WCE_NO_PRINTING))
            m_bPrinting = pDC->m_bPrinting;
#endif
            m_hDC       = pDC->m_hDC;
            m_hAttribDC = pDC->m_hAttribDC;
        }

    }

    // Destructor copies the contents of the mem DC to the original DC
    ~CMemDC()
    {
        if (m_bMemDC)
        {
            // Copy the offscreen bitmap onto the screen.
            m_pDC->BitBlt(m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(),
                          this, m_rect.left, m_rect.top, SRCCOPY);

            //Swap back the original bitmap.
            SelectObject(m_pOldBitmap);
        } else {
            // All we need to do is replace the DC with an illegal value,
            // this keeps us from accidently deleting the handles associated with
            // the CDC that was passed to the constructor.
            m_hDC = m_hAttribDC = NULL;
        }
    }

    // Allow usage as a pointer
    CMemDC* operator->() {return this;}
    // Allow usage as a pointer
    operator CMemDC*() {return this;}

private:
    CBitmap  m_bitmap;      // Offscreen bitmap
    CBitmap* m_pOldBitmap;  // bitmap originally found in CMemDC
    CDC*     m_pDC;         // Saves CDC passed in constructor
    CRect    m_rect;        // Rectangle of drawing area.
    BOOL     m_bMemDC;      // TRUE if CDC really is a Memory DC.
};

#include <iostream>
#include <string>
#include <locale>
#include <codecvt>
#include <fstream>
int main(int argc, char *argv[])
{
   std::wstring str = L"123,我是谁？我爱钓鱼岛！";
   std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
   std::string narrowStr = conv.to_bytes(str);
   {
      std::ofstream ofs ("c:\\test.txt");
      ofs << narrowStr;
   }
   std::wstring wideStr = conv.from_bytes(narrowStr);
   {
      std::locale::global(std::locale("Chinese-simplified"));
      std::wofstream ofs (L"c:\\testW.txt");
      ofs << wideStr;
   }
｝