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;
   }
｝