博客园_小李美刀

[转]PFX证书导入到USBKEY(代码)

2012-01-12T08:32:00Z

5. 完整代码

#include "stdafx.h"
#include <windows.h>
#include <WinCrypt.h>
#include <stdio.h>

// Global Csp Handle
HCRYPTPROV hCryptProv = NULL; // Handle for a cryptographic

void ToSmartCard(HCERTSTORE hSystemStore)
{
PCCERT_CONTEXT pCertContext = NULL;
char pszNameString[256];
DWORD dwKeySpec;
HCRYPTKEY UserKey = 0;

DWORD dwBlobLen;
BYTE *pbKeyBlob;
HCRYPTKEY hPubKey = NULL;
int error;

// CryptAcquireCertificatePrivateKey Exported Handle
HCRYPTPROV hCrypt = NULL;

// Just for Test Provider Name
BYTE pbData[1000]; // 1000 will hold the longest

// key container name.
DWORD cbData;
cbData = 1000;

//-------------------------------------------------------------------
// Find the certificates in the system store.
// In fact, just have one.

while(pCertContext= CertEnumCertificatesInStore(
hSystemStore,
pCertContext)) // on the first call to the function,
// this parameter is NULL
// on all subsequent calls,
// this parameter is the last pointer
// returned by the function
{
//----------------------------------------------------------------
// Do whatever is needed for a current certificate.
// ...
//--------------------------------------------------------------------
// Find and print the name of the subject of the certificate
// just retrieved.

if(CertGetNameString(
pCertContext,
CERT_NAME_SIMPLE_DISPLAY_TYPE,
0,
NULL,
pszNameString,
128))
{
printf("Certificate for %s has been retrieved.\n",pszNameString);

if(!( CryptAcquireCertificatePrivateKey(
pCertContext,
0,
NULL,
&hCrypt, //&hCryptProv, // 注意此处 hCrypt 输出不该是hCryptProv，如果没有猜错是Microsoft Base那个
&dwKeySpec,
NULL)))
{
printf("CryptAcquireCertificatePrivateKey.\n");
}

// Test hCrypt, Try to get its name;
// 猜错了，不是Microsoft Base...,而是下面这个
// Microsoft Enhanced Cryptographic Provider v1.0

if(CryptGetProvParam(
hCrypt,
PP_NAME,
pbData,
&cbData,
0))
{
printf("CryptGetProvParam succeeded.\n");
printf("Provider name: %s\n", pbData);
}

if( ! CryptGetUserKey(
hCrypt, //not hCryptProv,
AT_KEYEXCHANGE, //dwKeySpec,
&UserKey
) )

{
printf("CryptGetUserKey Error.\n");
}

//--------------------------------------------------------------------
// Export the public/private key-pair.

if(CryptExportKey(
UserKey,
NULL,
PRIVATEKEYBLOB,
0,
NULL,
&dwBlobLen))
{
printf("Size of the BLOB for the public/private key pair determined. \n");
}
else
{
printf("Error computing BLOB length.\n");
exit(1);
}

//--------------------------------------------------------------------
// Allocate memory for the pbKeyBlob.

if(pbKeyBlob = (BYTE*)malloc(dwBlobLen))
{
printf("Memory has been allocated for the BLOB. \n");
}
else
{
printf("Out of memory. \n");
exit(1);
}

//--------------------------------------------------------------------
// Do the actual exporting into the key BLOB.

if(CryptExportKey(
UserKey,
NULL,
PRIVATEKEYBLOB,
0,
pbKeyBlob,
&dwBlobLen))
{
printf("Contents have been written to the BLOB. \n");
}
else
{
printf("Error exporting key.\n");
exit(1);
}

if(CryptImportKey(
hCryptProv,
pbKeyBlob,
dwBlobLen,
0,
0,
&hPubKey))
{
printf("The key has been imported.\n");
}
else
{
printf("Public key import failed.\n");
exit(1);
}

// Not this one
//if (!CryptSetKeyParam(UserKey, KP_CERTIFICATE, pCertContext->pbCertEncoded, 0))
if (!CryptSetKeyParam(hPubKey, KP_CERTIFICATE, pCertContext->pbCertEncoded, 0))
{

error = GetLastError();
printf("CryptSetKeyParam 0x%x\n", error);

if (error != NTE_BAD_TYPE) {
// If error is bad_type then we just can't set the property.
// Likely means our provider isn't a smart card.
// If there was another error, we should report it.
printf("CryptSetKeyParam Failed (0x80090020 usually means no room on card) 0x%x\n",error);

}
}

if(hPubKey) {
CryptDestroyKey(hPubKey);
}

//--------------------------------------------------------------------
// Allocate memory for the pbKeyBlob.
if(pbKeyBlob)
free(pbKeyBlob);

}
else
{
printf("CertGetName failed. \n");
}

CertFreeCertificateContext(pCertContext);

} // End of while
}

void InstallPfx(CHAR *filename, CHAR *password)
{
HANDLE hFile;
BOOL bResult;
BYTE inBuffer[10000];
DWORD nBytesToRead = 0;
DWORD nBytesRead;

WCHAR wszpassword[20];
HCERTSTORE pfxcert = NULL;

hFile = CreateFile(filename, // open MYFILE.TXT
GENERIC_READ, // open for reading
FILE_SHARE_READ, // share for reading
NULL, // no security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no attr. template

if (hFile == INVALID_HANDLE_VALUE)
{
printf("Could not open file.\n"); // process error
return;
}

nBytesToRead = GetFileSize (hFile, NULL);

printf("File Size is %d\n", nBytesToRead);

bResult = ReadFile(hFile, &inBuffer, nBytesToRead, &nBytesRead, NULL) ;

if (bResult) // Reading is OK.
{
CRYPT_DATA_BLOB pfxblob;
pfxblob.cbData = nBytesRead;
pfxblob.pbData = inBuffer;

if( PFXIsPFXBlob( &pfxblob) )
{
printf("It's a Pfx Certificate.\n");

MultiByteToWideChar( CP_ACP, 0, password,
strlen(password)+1, wszpassword,
sizeof(wszpassword)/sizeof(wszpassword[0]) );

if( NULL != PFXImportCertStore(
&pfxblob,
wszpassword,
0x21 //CRYPT_USER_PROTECTED
)
)
{
printf("It's a Pfx imPORT OK.\n");

pfxcert = PFXImportCertStore(
&pfxblob,
wszpassword,
0x21 //CRYPT_USER_PROTECTED
);

ToSmartCard(pfxcert);

// 列出所有My的证书
//ToSmartCard(hSystemStore);

}

}
}

CloseHandle(hFile);
}

void OpenCert(HCRYPTPROV hprov)
{
//--------------------------------------------------------------------
// Declare and initialize variables.

HCERTSTORE hSystemStore; // system store handle

//--------------------------------------------------------------------
// Open the MY system certificate store. The same call can be
// used with the name of a different system store, such as My or Root,
// as the second parameter.

if(hSystemStore = CertOpenSystemStore(
hprov,
"MY"))
{
printf("The MY system store is open. Continue.\n");
}
else
{
printf("The MY system store did not open.\n");
exit(1);
}

// Use the store as needed.
// ...

InstallPfx("d:\\exported.pfx", "123456");

// When done using the store, close it.
if(!CertCloseStore(hSystemStore,CERT_CLOSE_STORE_CHECK_FLAG))
{
printf("Unable to close the MY system store.\n");
exit(1);
}
}

int main(int argc, CHAR* argv[])
{

//--------------------------------------------------------------------
// Declare and initialize variables.

// provider context.
LPCSTR UserName = "MyKeyContainer"; // Name of the key container
LPCSTR ProviderName = "eSafe Cryptographic Service Provider v2.0";

// to be used.
//--------------------------------------------------------------------
// Attempt to acquire a context and a key
// container. The context will use the default CSP
// for the RSA_FULL provider type. DwFlags is set to 0
// to attempt to open an existing key container.

if(CryptAcquireContext(
&hCryptProv, // Handle to the CSP
UserName, // Container name
ProviderName, // Use the default provider
PROV_RSA_FULL, // Provider type
0)) // Flag values
{
printf("A crypto context with the %s key container \n", UserName);
printf("has been acquired.\n\n");

OpenCert(hCryptProv);

}
else
{
//--------------------------------------------------------------------
// An error occurred in acquiring the context. This could mean
// that the key container requested does not exist. In this case,
// the function can be called again to attempt to create a new key
// container. Error codes are defined in winerror.h.
if (GetLastError() == NTE_BAD_KEYSET)
{
if(CryptAcquireContext(
&hCryptProv,
UserName,
ProviderName,
PROV_RSA_FULL,
CRYPT_NEWKEYSET))
{
printf("A new key container has been created.\n");
OpenCert(hCryptProv);
}
else
{
printf("Could not create a new key container.\n");
exit(1);
}
}
else
{
printf("A cryptographic service handle could not be acquired.\n");
exit(1);
}

} // End of else

//--------------------------------------------------------------------
// A cryptographic context and a key container is available. Perform
// any functions that require a Cryptographic provider handle.

//--------------------------------------------------------------------
// When the handle is no longer needed, it must be released.

if (CryptReleaseContext(hCryptProv,0))
{
printf("The handle has been released.\n");
}
else
{
printf("The handle could not be released.\n");
}

return 0;
}

本文链接

[转]通过CSP读取证书

2012-01-12T08:30:00Z

1. 通过Csp读取证书使用的函数

CryptGetUserKey

获取公私钥对的句柄

注意AT_SIGNATURE，AT_KEYEXCHANGE的不同，前者签名，后者加密。

CryptGetKeyParam

读取和公私钥对相关联的证书

注意使用KP_CERTIFICATE

2. 指定Csp容器

通常获取证书时，usbkey已经发证完毕。这是比较难以判断容器的名称。通常会选择默认容器，但有些RA发证时比较特别，可能会使用两个容器。签名证书使用默认容器，而加密证书使用指定的某个容器。

为了验证上面所说的情况，需要枚举Usbkey上的容器进行选择查看。

CryptGetProvParam

注意：第二个参数使用PP_ENUMCONTAINERS

获取第一个容器名称的时候，最后的参数使用CRYPT_FIRST

接下去，调用时使用最后的参数CRYPT_NEXT，当GetLastError的值等于ERROR_NO_MORE_ITEMS则表示没有容器了。

指定好了容器名称后再进行证书的读取工作，下面列出了程序运行结果：

签名证书容器

A crypto context with the MyKeyContainer key container

has been acquired.

0. ContainName is 3d06503f-e4ed-4e89-8d56-2960aa5f0364

1. ContainName is KOAL_CSP_WRAPPER_CONTAINER

2. ContainName is J

The handle has been released.

Please select a container:

A crypto context with the 3d06503f-e4ed-4e89-8d56-2960aa5f0364 key container

has been acquired.

Encrypt Certification:

Invalid parameter

CryptGetKeyParam Failed 0x57

Sign Certification:

CertLen is 791

A new certificate as been created.

测试 310103198301011234

SANCA

The handle has been released.

加密证书容器

A crypto context with the MyKeyContainer key container

has been acquired.

0. ContainName is 3d06503f-e4ed-4e89-8d56-2960aa5f0364

1. ContainName is KOAL_CSP_WRAPPER_CONTAINER

2. ContainName is J

The handle has been released.

Please select a container:

A crypto context with the KOAL_CSP_WRAPPER_CONTAINER key container

has been acquired.

Encrypt Certification:

CertLen is 759

A new certificate as been created.

测试 310103198301011234

SANCA

Sign Certification:

Invalid parameter

CryptGetKeyParam Failed 0x57

The handle has been released.

3. 相关代码

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

#include "stdafx.h"
#include <windows.h>
#include <WinCrypt.h>
#include <stdio.h>

#include <vector>
#include <string>

using namespace std;

vector<string> contain_vector;

//CRYPT_DELETEKEYSET

int TestEnumContainers(HCRYPTPROV hCryptProv)
{
BYTE pbData[1000]; // 1000 will hold the longest
DWORD cbData = 1000;
int count = 0;

if ( CryptGetProvParam(
hCryptProv,
PP_ENUMCONTAINERS,
(BYTE *)&pbData,
&cbData,
CRYPT_FIRST))
{
pbData[cbData] = '\0';
printf("%d. ContainName is %s\n", count++, pbData);
contain_vector.push_back((char *)pbData);

pbData[0] = '\0';
cbData = 1000;

while( CryptGetProvParam(
hCryptProv,
PP_ENUMCONTAINERS,
(BYTE *)&pbData,
&cbData,
CRYPT_NEXT)
)
{
if( ERROR_NO_MORE_ITEMS == GetLastError())
{
break;
}

pbData[cbData] = '\0';
printf("%d. ContainName is %s\n", count++, pbData);
contain_vector.push_back((char *)pbData);
pbData[0] = '\0';
cbData = 1000;
}

}

return count;
}

int EnumContainers()
{
//--------------------------------------------------------------------
// Declare and initialize variables.
HCRYPTPROV hCryptProv = NULL; // Handle for a cryptographic

// provider context.
LPCSTR UserName = "MyKeyContainer"; // Name of the key container
LPCSTR ProviderName = "eSafe Cryptographic Service Provider v2.0";

int count = -1;

if(CryptAcquireContext(
&hCryptProv, // Handle to the CSP
NULL, // Container name
ProviderName, // Use the default provider
PROV_RSA_FULL, // Provider type
0)) // Flag values
{
printf("A crypto context with the %s key container \n", UserName);
printf("has been acquired.\n\n");

count = TestEnumContainers(hCryptProv);

}
else
{
//--------------------------------------------------------------------
// An error occurred in acquiring the context. This could mean
// that the key container requested does not exist. In this case,
// the function can be called again to attempt to create a new key
// container. Error codes are defined in winerror.h.
if (GetLastError() == NTE_BAD_KEYSET)
{
if(CryptAcquireContext(
&hCryptProv,
NULL,
ProviderName,
PROV_RSA_FULL,
CRYPT_NEWKEYSET))
{
printf("A new key container has been created.\n");
count = TestEnumContainers(hCryptProv);
}
else
{
printf("Could not create a new key container.\n");
exit(1);
}
}
else
{
printf("A cryptographic service handle could not be acquired.\n");
exit(1);
}

} // End of else

//--------------------------------------------------------------------
// A cryptographic context and a key container is available. Perform
// any functions that require a Cryptographic provider handle.

//--------------------------------------------------------------------
// When the handle is no longer needed, it must be released.

if (CryptReleaseContext(hCryptProv,0))
{
printf("The handle has been released.\n");
}
else
{
printf("The handle could not be released.\n");
}

return count;
}

void DecodePubKey(HCRYPTPROV hCryptProv, DWORD dwKeySpec)
{
HCRYPTKEY hCurKey= 0;
BOOL ret=TRUE;
//
// Check if a key already exisis,
// If it don't generate a key!
///////////////////////////////////////////
if (!CryptGetUserKey(hCryptProv, dwKeySpec, &hCurKey))
{
int error = GetLastError();
// Make sure error is no key.
if (error != NTE_NO_KEY)
{
printf("First Call to CryptGenKey Failed- with error other than NTE_NO_KEY: [0x%X]\n",error);
ret=FALSE;
goto done;
}
}

unsigned char uchCertInfo[2000];
DWORD CertLen = 2000;
DWORD error = 0;

if (!CryptGetKeyParam(hCurKey, KP_CERTIFICATE, uchCertInfo, &CertLen , 0))
{

//ERROR_MORE_DATA

error = GetLastError();

if( ERROR_INVALID_PARAMETER == error)
{
printf("Invalid parameter\n");
}

if (error != NTE_BAD_TYPE) {
// If error is bad_type then we just can't set the property.
// Likely means our provider isn't a smart card.
// If there was another error, we should report it.
printf("CryptGetKeyParam Failed 0x%x\n",error);
}
ret=FALSE;
goto done;
}

printf("CertLen is %d\n", CertLen );

// MAKING X509 CERTIFICATE

#define MY_ENCODING_TYPE (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
PCCERT_CONTEXT pCertContext = NULL;

//------------------------------------------------------------------
// Create a new certificate from the encoded part of
// an available certificate. pDesiredCert is a previously
// assigned PCCERT_CONTEXT variable.
if(pCertContext = CertCreateCertificateContext(
MY_ENCODING_TYPE, // The encoding type
uchCertInfo, // The encoded data from
// the certificate retrieved
CertLen)) // The length of the encoded data
{
printf("A new certificate as been created.\n");

// Use the certificate context as needed.
// ...

CHAR pszBuff[256];
CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE,
0, NULL, pszBuff, 128);
printf("%s\n", pszBuff); // 显示名
CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE,
CERT_NAME_ISSUER_FLAG, NULL, pszBuff, 128);
printf("%s\n", pszBuff); // 颁发者

// When finished, free the certificate context.
CertFreeCertificateContext(pCertContext);
}
else
{
printf("A new certificate could not be created.\n");
goto done;
}

done:
if (hCurKey) CryptDestroyKey(hCurKey);
}

void GetPublicKey(const char *ContainName)
{
//--------------------------------------------------------------------
// Declare and initialize variables.
HCRYPTPROV hCryptProv = NULL; // Handle for a cryptographic

// provider context.
LPCSTR ProviderName = "eSafe Cryptographic Service Provider v2.0";

if(CryptAcquireContext(
&hCryptProv, // Handle to the CSP
ContainName, // Container name
ProviderName, // Use the default provider
PROV_RSA_FULL, // Provider type
0)) // Flag values
{
printf("A crypto context with the %s key container \n", ContainName);
printf("has been acquired.\n\n");

printf("Encrypt Certification:\n");
DecodePubKey(hCryptProv, AT_KEYEXCHANGE);

printf("Sign Certification:\n");
DecodePubKey(hCryptProv, AT_SIGNATURE);

}
else
{
//--------------------------------------------------------------------
// An error occurred in acquiring the context. This could mean
// that the key container requested does not exist. In this case,
// the function can be called again to attempt to create a new key
// container. Error codes are defined in winerror.h.
if (GetLastError() == NTE_BAD_KEYSET)
{
if(CryptAcquireContext(
&hCryptProv,
ContainName,
ProviderName,
PROV_RSA_FULL,
CRYPT_NEWKEYSET))
{
printf("A new key container has been created.\n");
}
else
{
printf("Could not create a new key container.\n");
exit(1);
}
}
else
{
printf("A cryptographic service handle could not be acquired.\n");
exit(1);
}

} // End of else

//--------------------------------------------------------------------
// When the handle is no longer needed, it must be released.

if (CryptReleaseContext(hCryptProv,0))
{
printf("The handle has been released.\n");
}
else
{
printf("The handle could not be released.\n");
}
}

int main(int argc, CHAR* argv[])
{

int count = EnumContainers();
int selectno;

printf("Please select a container:\n");
scanf("%d", &selectno);
if( selectno <= count )
{
GetPublicKey(contain_vector[selectno].c_str());
}

// 0. ContainName is 3d06503f-e4ed-4e89-8d56-2960aa5f0364
// 签名证书

// 1. ContainName is KOAL_CSP_WRAPPER_CONTAINER
// 加密证书

return 0;
}

本文链接

[转]Windows密钥容器和证书的关系

2012-01-12T08:28:00Z

其实CSP主要是对容器里的密钥对操作的，和证书关系不大。

容器里的密钥对有两种类型：一种是AT_KEYEXCHANGE，表示加密的密钥对，一种是AT_SIGNATURE表示签名的密钥对。

由于美国的出口限制，在MS的CSP中加密的密钥对可以取的密钥最大长度通常会比签名的密钥对短。

通常加密的密钥对只会用于加密，签名的密钥对只会用于签名，由于某些原因（例如产生证书请求），加密的密钥对也可以用于签名。

我把AT_KEYEXCHANGE和AT_SIGNATURE看作是容器里的两个位置。在智能卡CSP中可以把证书写入容器中，和加密的密钥对对应的证书写到AT_KEYEXCHANGE位置中，和签名的密钥对对应的证书写到AT_SIGNATURE位置中。这里判断依据是证书的公钥和密钥对的公钥相同，而不是证书中的密钥用法扩展。

使用Crypto API可以根据证书库里的证书的CERT_KEY_PROV_INFO_PROP_ID找到相对应得容器里的密钥对。CRYPT_KEY_PROV_INFO中的dwKeySpec就是指容器里的密钥对类型。如果在CSP实现的层次根据证书的密钥用法扩展来限制是否能够加密和签名，要先读出证书，这个操作比较慢，估计实现者比较少采用。

事实上，明华EKey的CSP的AT_KEYEXCHANGE和AT_SIGNATURE类型的密钥对都是既可以加密也可以签名的(CryptDecrypt和CryptSignHash是没问题的，没怎么测过CryptImportKey，不知道是不是签名的密钥对能不能成功导入会话密钥)。我没有和你的版本一样的xcsp_eclib.dll，我使用了一个稍微旧一点的版本的来测试。我测试了CryptDecryptMessage函数，发现如果是签名密钥对不管我证书的密钥用法扩展如何设置则解密总是会失败（用MS的CSP也一样）。而使用加密密钥对则可以成功。虽然OUTLOOK可能不是使用CryptDecryptMessage来解密CMS的EnvelopedData的，但是我相信最终都会调用CSP的CryptImportKey解出对称密钥，再解密的。CryptDecryptMessage传给CryptImportKey的是一个Simple-Key BLOBs。我的测试发现EKey好像总是使用加密的密钥对来解密。这可能是这个Simple-Key BLOBs的结构有问题导致解密失败或者EKey的CSP的CryptImportKey有BUG导致解密失败。

看来，如果要使得证书既能加密也能签名，必须首先保证使用的是加密密钥对。产生加密密钥对可以在产生证书请求的时候使用Xenroll来设置，至于使用PKCS#12文件导入的方式要取决于使用的软件是根据什么来判断应该创建什么类型的密钥对。

本文链接

[转]boost.bind 如何 bind continue.1

2011-06-02T03:39:00Z

我们先定义目标：

1. simple_bind 提供与 bind 类似的界面，可以只考虑通过对象引用（或者值）调用成员函数的情况，而不考虑 free function 或者通过指针调用等等。具体地说，就是允许

person.SetName("Ralph")      --> simple_bind(&Person::SetName, person, _1)(string("Ralph"))
                                 simple_bind(&Person::SetName, _1, string(“Ralph"))(person)
                                 simple_bind(&Person::SetName, _1, _2)(person, string("Ralph"))
                                 simple_bind(&Person::SetName, _2, _1)(string("Ralph"), person)

2. 一个 simple_bind 表达式会 evaluate 成为一个 simple_binder object ，这是一个 functor ，如：

simple_bind(&Person::SetName, person, _1)(string("Ralph"))     --> simple_binder_obj(string("Ralph"))
simple_bind(&Person::SetName, _1, _2)(person, string("Ralph")) --> simple_binder_obj(person, string(“Ralph”))

在这一头一尾，我们其实没多少选择余地，一方面我们需要提供的用户界面已经定了，另一方面需要提供的函数调用界面也基本上固定了，要玩的 magic 也就是发生在中间。

3. 对于 placeholder ，前面已经说过，就用简单的解决方案：
template <int I>
class placeholder{};
placeholder<1> _1;
placeholder<2> _2;
...

有了这3个出发点，现在从 simple_bind 出发，首先看看 simple_bind 应该有的形式。从前面的实验中可以看出

template <typename R, typename T, typename Arg>

simple_binder<R, T, Arg>

simple_bind( R (T::*pfn)(Arg), const Arg& arg, placeholder&)

{

return simple_binder<R, T, Arg>(pfn, arg);

}

这样的形式虽然方便，但却不具有 scalability 。因为R (T::*pfn)(Arg) 的限制太大了，首先，它只针对接受一个参数的成员函数，如果要支持多个参数，你要对每个参数数量（它有一个术语叫 arity）写一个重载，而这些不同 arity 还要跟 simple_bind 本身的 arity 做组合，结果是爆炸性的 simple_bind 数量。其次，参数 arg 和 placeholder 也太不灵活，前面已经看到，仅仅在两个参数的情况下，就有4种组合：

simple_bind(&Person::SetName, _1, _2)(person, "Joy");

simple_bind(&Person::SetName, _2, _1)("Joy", person);

simple_bind(&Person::SetName, _1, "Joy")(person);

simple_bind(&Person::SetName, person, _1)("Joy");

可想而知参数更多的时候的恐怖情景。于是我们得出结论：

由于前端的调用组合太复杂，simple_bind 的界面必须以最 generic 的方式给出，由此带来的复杂性应该留待 simple_bind 内部处理。

这是经过了实验的教训得出的结论。

何谓“最 generic”？没有比这更加 generic 的了：

template <typename F, typename A1>

simple_binder<unspecified>

simple_bind(F f, A1 a1)

{

//...

}

即便如此，由于 C++ 至今还没有可变数量的模板参数，我们还是不能回避对每一个 arity 都有所定义，但是这已经把复杂度控制在 O(arity) 了：

template <typename F, typename A1, typename A2>

simple_binder<unspecified>

simple_bind(F f, A1 a1, A2 a2)

{

//...

}
......

但是随之而来的就是问题：我现在把第一个参数（函数指针）类型笼统成了一个 F ，我如何知道它的返回类型、参数类型和对象类型？好在这个问题可解，其技法在 boost 里面还很常见，那就是 traits ：

template <typename T>

struct result_of

{};

template <typename R, typename T>

struct result_of<R (T::*)()>

{

typedef R type;

};

template <typename R, typename T, typename A1>

struct result_of<R (T::*)(A1)>

{

typedef R type;

};

template <typename R, typename T, typename A1, typename A2>

struct result_of<R (T::*)(A1, A2)>

{

typedef R type;

};

......

它无非利用 C++ 模板元编程最常用的偏特化来“抽取”函数指针的类型内容，我们甚至无需自己写，boost 已经提供好了相应的工具，但是上面的这个 result_of 也还算清晰好用，在这个例子里面，我们就用它。

在这个方向上，思路已经比较开阔了，现在从另一个方向：simple_binder 入手来想一想。simple_binder 应该长成什么样子呢？由于 function_traits 可以帮我们得到函数返回类型，我们可以肯定 simple_binder 在构造的时候已经知道返回类型了，那么它应该是这样吗？

template <typename R/*返回值的类型*/, typename F, typename A1>

class simple_binder

template <typename R, typename F, typename A1, typename A2>

class simple_binder

如果你的想法是这样，恭喜你，一出门你就撞了南墙：class 不是 function ，除非你偏特化，它是不允许有多个模板参数“重载”的！但是很显然，这些 simple_binder 之间，谁也不是谁的偏特化。那么是不是可以利用类似 TypeList 的技术，用默认模板参数提供变相的可变参数数量模板：

template <typename R, typename F, typename A1, typename A2 = placeholder<0>, typename A3 = placeholder<0> /*...*/ >

class simple_binder
......

好，这下子 simple_bind 的定义算是完整了：

template <typename F, typename A1>

simple_binder<typename result_of<F>::type, F, A1>

simple_bind(F f, const A1& arg1)

{

//...

}

template <typename F, typename A1, typename A2>

simple_binder<typename result_of<F>::type, F, A1, A2>

simple_bind(F f, const A1& arg1, const A2& arg2)

{

//...

}

在这个基础上，提供 simple_binder 的构造函数也是举手之劳，

explicit simple_binder(F f, const A1& a1)

: f_(f)

, a1_(a1)

{}

explicit simple_binder(F f, const A1& a1, const A2& a2)

: f_(f)

, a1_(a1)

, a2_(a2)

{}

其中的 f_, a1_, a2_ 都是 simple_binder 的成员。simple_bind 仍然只是简单的构造一个 simple_binder ：

template <typename F, typename A1>

simple_binder<typename result_of<F>::type, F, A1>

simple_bind(F f, const A1& arg1)

{

return simple_binder

typename result_of<F>::type,

(f, arg1);

}

template <typename F, typename A1, typename A2>

simple_binder<typename result_of<F>::type, F, A1, A2>

simple_bind(F f, const A1& arg1, const A2& arg2)

{

return simple_binder

typename result_of<F>::type,

A1,

(f, arg1, arg2);

}

至于真正的运算，就留给 simple_binder 和它的助手们去做。我们仍然从最简单的情况开始，研究一下调用时没有参数是什么样，例如这样的调用：

simple_bind(&Person::Name, person)()

这个调用的参数在 simple_bind 的时候已经确定，而在 simple_binder 那里只是简单调用一个0参数的 operator()，也就是：

R operator()()

{

//...

}

即便是这个东西，它代表的意义也不单纯，实际上，在有两个 placeholder 的场合，它代表了两种情况：

1. 类似 simple_bind(&Person::Name, person)()，函数实际上没有参数
2. 类似 simple_bind(&Person::SetName, person, “Joy”)(), 函数其实有一个参数

我们有没有足够的信息来确定是那种情况呢？有，答案就在 simple_binder 的模板参数 A1, A2 中。如果 A2 是 placeholder<0> ，那么就是第一种情况，否则就是第二种情况。为了能在这两种情况之间做出决策，必须加上一个助手，我们称之为 eval ：

template <typename R, typename F, typename A1, typename A2>

R eval(F f, A1 a1, A2 a2)

{

return (a1.*f)(a2);

}

template <typename R, typename F, typename A1>

R eval(F f, A1 a1, placeholder<0>)

{

return (a1.*f)();

}

于是乎0参数的 operator() 就成了

R operator()()

{

return eval<R>(f_, a1_, a2_);

}

参数 a2_ 会帮助我们把调用分派到两个 eval 中的一个，从而完成调用决策。

现在来考虑 1 个参数的 operator() ，它就复杂一些了：

1. 类似 bind(&Person::Name, _1)(person) ，函数其实没有参数
2. 类似 bind(&Person::SetName, _1, "Joy")(person)，函数其实有1个参数，_1 代表第一个
3. 类似 bind(&Person::SetName, person, _1)("Joy")，函数其实有1个参数，_1 代表第二个

停！！！看来在这个方向上鸣金收兵的时候到了。回顾一下这个设计：
通过提供 generic 的 simple_bind 界面以及 result_of ，我们简化了 simple_bind ；又通过 eval ，我们让 simple_binder 变得单纯起来，然而现在 eval 的复杂性开始膨胀，大有脱离我们控制的趋势。原因在哪里？

参数的复杂性。

作为一个系统，我们的这个东西其实接受两组参数，一组是由 simple_bind 接受的，混杂了 placeholder 和实际参数；另一组是由 simple_binder 的 operator() 接受的，全部都是实际参数，但是其应用的顺序需要根据 placeholder 的类型来决定。了解了这个复杂性的根源，我们的任务再次变得清晰起来：提供一个方法，以统一的方式来处理参数，降低复杂性。

本文链接

[转]boost.bind 如何 bind

2011-06-02T02:54:00Z

Boost.bind 好用么？当然好用，而且它也确定进入下一代的 C++ 标准了，也早就进了 TR1 了。回顾一下，它允许我们干这个：

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <boost/bind.hpp>

using namespace std;
using namespace boost;

struct Person
{
    Person(const string& name)
        : name_(name)
    {}

    string Name()
    {
        return name_;
    }

    string name_;
};

int main()
{
    typedef vector<Person> PersonList;

    PersonList personList;
    personList.push_back(Person("Ralph"));
    personList.push_back(Person("Joy"));
    personList.push_back(Person("Martin"));

    PersonList::iterator iter =
        find_if(personList.begin(), personList.end(),
            bind(&Person::Name, _1) == "Ralph");

    cout << (iter == personList.end() ? "Not found."
                                      : iter->Name().append(" found."))
         << endl;
}

如果没有它我们怎么办呢？恕我鲁钝，我还没办法用 bind1st, bind2nd 之类办到同样的事，恐怕你也只有写一个完全没营养的 predicate 来达到目的了。

当然，用不了几次，你就会问（或者可能多数人是在第一次看到的时候就会问）：它是怎么办到的？其实还不如问，如果换了你会怎么做？我们降低条件，想象自己是 bind 的作者，在开始的时候舍弃一切细节，只要实现类似 bind1st 或者 mem_fun 的功能，该怎么做？我们把这个 bind 叫做 simple_bind 。

STL 的 bind1st 能给一点启示：它接受两个参数，返回一个 functor ，毫无疑问 simple_bind 也得这样干，我们把它返回的 functor 类型叫做 simple_binder：

template <typename R, typename T>
class simple_binder
{
public:
    explicit simple_binder(R (T::*pfn)())
        : pfn_(pfn)
    {}

    R operator()(T& t)
    {
        return t.*pfn_();
    }
private:
    R (T::*pfn_)();
};

这个东西跟 mem_fun_ref_t 可以相比，因为毕竟，算法是不变的，无论我们在外面玩什么花样，提供给算法的 functor 类型都必须长成这样。中间的 R (T::*pfn)() 是函数指针定义，的确，C++ 里面的函数指针定义从来就不可爱，所以才有了 boost.function ... 扯远了。

我们知道了 simple_bind 的返回类型，那么参数呢，第一个参数简单，跟上面的 pfn 是一样的，第二个是什么呢？我们先空起来：

template <typename R, typename T>
simple_binder<R, T>
simple_bind( R (T::*pfn)(), ??? )
{
    return simple_binder<R, T>(pfn);
}

有没有发现什么？在这里我们压根没用到第二个参数，这就给了我们一个极其简单的定义：

class placeholder{};
placeholder _1;

那么现在程序好像是完整了，我们可以这么用：

#include <iostream>
#include <string>

using namespace std;

struct Person
{
    Person(const string& name)
        : name_(name)
    {}

    string Name()
    {
        return name_;
    }

    string name_;
};

template <typename R, typename T>
class simple_binder
{
public:
    explicit simple_binder(R (T::*pfn)())
        : pfn_(pfn)
    {}

    R operator()(T& t)
    {
        return (t.*pfn_)();
    }
private:
    R (T::*pfn_)();
};

class placeholder{};
placeholder _1;

template <typename R, typename T>
simple_binder<R, T>
simple_bind( R (T::*pfn)(), placeholder&)
{
    return simple_binder<R, T>(pfn);
}

int main()
{
    Person person("Ralph");
    cout << simple_bind(&Person::Name, _1)(person) << endl;
}

输出是 Ralph ，跟直接调用一样！我们的 simple_bind 起作用了！

好了，现在让我们再向前一步，如果 Person 加了一个函数 SetName:

    void SetName(string name)
    {
        name_ = name;
    }

它有一个参数，而我们希望调用的形式类似于 simple_bind(&Person::SetName, string("Joy"), _1) 我们怎么修改 simple_bind 呢？

首先还是从 simple_binder 入手，由于调用方法不变，我们所要做的只是在 simple_binder 里面保存参数，没错，就跟 binder1st 一样：

template <typename R, typename T, typename Arg>
class simple_binder
{
public:
    explicit simple_binder(R (T::*pfn)(Arg), const Arg& arg)
        : pfn_(pfn)
        , arg_(arg)
    {}

    R operator()(T& t)
    {
        return (t.*pfn_)(arg_);
    }
private:
    R (T::*pfn_)(Arg);
    Arg arg_;
};

接下来的就顺理成章了，simple_bind 把 arg 传递给 simple_binder ，而 placeholder 甚至不需要修改，我们甚至可以把这个 simple_bind 直接喂给 STL 算法：

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Person
{
    Person(const string& name)
        : name_(name)
    {}

    string Name()
    {
        return name_;
    }

    void SetName(string name)
    {
        name_ = name;
    }

    string name_;
};

template <typename R, typename T, typename Arg>
class simple_binder
{
public:
    explicit simple_binder(R (T::*pfn)(Arg), const Arg& arg)
        : pfn_(pfn)
        , arg_(arg)
    {}

    R operator()(T& t)
    {
        return (t.*pfn_)(arg_);
    }
private:
    R (T::*pfn_)(Arg);
    Arg arg_;
};

class placeholder{};
placeholder _1;

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const Arg& arg, placeholder&)
{
    return simple_binder<R, T, Arg>(pfn, arg);
}

int main()
{
    typedef vector<Person> PersonList;

    PersonList personList;
    personList.push_back(Person("Ralph"));
    personList.push_back(Person("Joy"));
    personList.push_back(Person("Martin"));

    for_each(personList.begin(), personList.end(),
        simple_bind(&Person::SetName, string("Joy"), _1));

    cout << personList[0].Name() << endl
         << personList[1].Name() << endl
         << personList[2].Name() << endl;
}

输出是三个 Joy 。

现在看起来，我们的 simple_binder 稍微有点样子了，但是 boost.bind 允许 placeholder 被放在任何一个位置，而 simple_binder 不允许，但是这个简单，我们有重载：

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder&, const Arg& arg)
{
return simple_binder<R, T, Arg>(pfn, arg);
}

加上这个，_1 就可以被随便放在第一个或者第二个位置，例如：

int main()
{
    typedef vector<Person> PersonList;

    PersonList personList;
    personList.push_back(Person("Ralph"));
    personList.push_back(Person("Joy"));
    personList.push_back(Person("Martin"));

    for_each(personList.begin(), personList.end(),
        simple_bind(&Person::SetName, string("Joy"), _1));

    for_each(personList.begin(), personList.end(),
        simple_bind(&Person::SetName, _1, string("Ralph")));

    cout << personList[0].Name() << endl
         << personList[1].Name() << endl
         << personList[2].Name() << endl;
}

输出是三个 Ralph 。提醒一下，boost.bind 当然不是用这个办法，要不然还不用等到参数数量到10个，到了3个我们就要累死。simple_bind 的目的只是在于探索，用最容易理解的方式达成目的，如果说 boost 是一座拆除了脚手架、精雕细琢的圣殿，simple_bind 就是尝试把脚手架再搭起来。

回顾一下，现在我们已经能比较好地解决一个参数的成员函数调用了，现在看看两个参数。我们从目的入手，希望达到的效果是这样：

Person person("Ralph");
simple_bind(&Person::SetName, _1, _2)(person, string("Martin"));

首先，这里有了一个新的符号 _2 ，这很简单

placeholder _2;

然后 simple_bind 也顺利成章的又增加了一个重载：

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder&, const placeholder&)
{
return simple_binder<R, T, Arg>(pfn);
}

注意，这个 simple_binder 构造函数只有一个参数，而它还没写出来，我们加上一个：

    // new simple_binder ctor: 1 argument
    explicit simple_binder(R (T::*pfn)(Arg))
        : pfn_(pfn)
    {}

在这种情况下，两个参数都是由调用者直接提供给 simple_binder 的，这就意味着我们还要重载一次 simple_binder::operator() ：

    R operator()(T& t, const Arg& arg)
    {
        return (t.*pfn_)(arg);
    }

好了，这下子都解决了，完整程序如下：

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Person
{
    Person(const string& name)
        : name_(name)
    {}

    string Name()
    {
        return name_;
    }

    void SetName(string name)
    {
        name_ = name;
    }

    string name_;
};

template <typename R, typename T, typename Arg>
class simple_binder
{
public:
    explicit simple_binder(R (T::*pfn)(Arg))
        : pfn_(pfn)
    {}

    explicit simple_binder(R (T::*pfn)(Arg), const Arg& arg)
        : pfn_(pfn)
        , arg_(arg)
    {}

    R operator()(T& t)
    {
        return (t.*pfn_)(arg_);
    }

    R operator()(T& t, const Arg& arg)
    {
        return (t.*pfn_)(arg);
    }
private:
    R (T::*pfn_)(Arg);
    Arg arg_;
};

class placeholder{};
placeholder _1, _2;

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const Arg& arg, const placeholder&)
{
return simple_binder<R, T, Arg>(pfn, arg);
}

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder&, const Arg& arg)
{
return simple_binder<R, T, Arg>(pfn, arg);
}

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder&, const placeholder&)
{
return simple_binder<R, T, Arg>(pfn);
}

int main()
{
    typedef vector<Person> PersonList;

    PersonList personList;
    personList.push_back(Person("Ralph"));
    personList.push_back(Person("Joy"));
    personList.push_back(Person("Martin"));

    for_each(personList.begin(), personList.end(),
        simple_bind(&Person::SetName, string("Joy"), _1));

    for_each(personList.begin(), personList.end(),
        simple_bind(&Person::SetName, _1, string("Ralph")));

    Person person("Ralph");
    simple_bind(&Person::SetName, _1, _2)(person, string("Martin"));

    cout << personList[0].Name() << endl
         << personList[1].Name() << endl
         << personList[2].Name() << endl;
    cout << person.Name() << endl;
}

输出是：

Ralph
Ralph
Ralph
Martin

虽然实现丑陋了点，但是达到目的了，不是么？好了，现在新的问题来了，我们还希望可以这样：

simple_bind(&Person::SetName, _2, _1)(string("Joy"), person));

其实从这里可以看出来，在前面的实现中，placeholder 没有发挥任何作用，是真正的 placeholder ，然而在这里不同，我们至少希望 placeholder 能够携带某些编译期信息，以便让我们能在调用决策中选择相应的参数，换句话说，我们希望 placeholder _1 和 _2 除了名字不同，还能让编译器看起来有所区别，当然最简单的想法是：

class placeholder1{};
class placeholder2{};
placeholder1 _1;
placeholder2 _2;

然而模仿 MCD 的 IntToType 技术，这样是不是更优雅呢：

template <int I>
class placeholder{};
placeholder<1> _1;
placeholder<2> _2;

boost.bind 里面就是这么干的。有了这个，就可以依照 placeholder 顺序来重载：

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder<1>&, const placeholder<2>&)
{
return simple_binder<R, T, Arg>(pfn);
}

template <typename R, typename T, typename Arg>
simple_binder<R, T, Arg>
simple_bind( R (T::*pfn)(Arg), const placeholder<2>&, const placeholder<1>&)
{
// 返回什么呢？
}

返回什么呢？我们可以定义一个 simple_binder2 ，它在 operator() 里面会交换其参数的位置，也可以修改 simple_binder，让它根据某些标志来干这件事……

我们还是就此打住吧！

不用我说你也看得出来，这种“暴力法”很快就会让代码规模和程序复杂度膨胀到无法收拾的地步，是时候检讨我们的设计了。我们原先的设计其实是从最简单的情况出发，在需求增多的时候，我们用蛮力加以扩展，然而当规模进一步扩大，设计本身的局限就开始显现出来，现在应该从原先的设计中提取抽象，考虑更加灵活的设计了。

（待续...）

本文链接

[转]boost bind使用指南

2011-06-01T08:35:00Z

bind - boost

头文件: boost/bind.hpp

bind 是一组重载的函数模板.
用来向一个函数(或函数对象)绑定某些参数.
bind的返回值是一个函数对象.

它的源文件太长了. 看不下去. 这里只记下它的用法:

9.1 对于普通函数

假如有函数 fun() 如下:
void fun(int x, int y) {
cout << x << ", " << y << endl;
}
现在我们看看怎么用bind 向其绑定参数.
对于像 fun 这样的普通函数. 若fun 有n个参数. 则 bind 需要 n+1 个参数: 原始函数的地址以及 n个要绑定的参数.

第1种用法:
向原始函数 fun 绑定所有的参数
boost::bind(&fun, 3, 4) // bind的实参表依次为: 要绑定的函数的地址, 绑定到fun的第一个参数值, 第二个参数值...
// fun有多少个参数, 这里就要提供多少个.
表示将 3 和 4 作为参数绑定到 fun 函数.
因为绑定了所有的参数. 现在我们调用bind所返回的函数对象:
boost::bind(&fun, 3, 4)( ); //无参数.
就会输出 3, 4

第2种用法:
向原始函数 fun 绑定一部分参数
boost::bind(&fun, 3, _1)    // bind的实参表依次还是: 要绑定的函数的地址, 要绑定到fun的第一个参数值, 然后注意
        // 因为我们不打算向fun绑定第2个参数(即我们希望在调用返回的Functor时再指定这个参数的值)
        // 所以这里使用 _1 来占位. 这里的 _1 代表该新函数对象被调用时. 实参表的第1个参数.
        // 同理下边还会用到 _2 _3 这样的占位符.
这里只为fun绑定了第一个参数3. 所以在调用bind返回的函数对象时. 需要:
boost::bind(&fun, 3, _1)(4); //这个4 会代替 _1 占位符.
输出 3, 4
同理 boost::bind(&fun, _1, 3)(4);
输出 4, 3

第3种用法:
不向 fun 绑定任何参数
boost::bind(&fun, _1, _2)   // _1 _2 都是占位符. 上边已经说过了.
所以它就是将新函数对象在调用时的实参表的第1个参数和第2个参数绑定到fun函数.
boost::bind(&fun, _1, _2)(3, 4);    // 3将代替_1占位符, 4将代替_2占位符.
输出 3, 4
同理 boost::bind(&fun, _2, _1)(3, 4);   // 3将代替_1占位符, 4将代替_2占位符.
会输出 4, 3
同理 boost::bind(&fun, _1, _1)(3);     // 3将代替_1占位符
会输出 3, 3

对于普通函数就这些. 对于函数对象. 如:
struct Func {
  void operator()(int x) {
   cout << x << endl;
  }
} f;
绑定的时候可能要指出返回值的类型:
boost::bind<void>(f, 3)(); //指出返回值的类型 void

9.2 对于非静态成员函数

假如有:
struct A {
  void func(int x, int y) {
   cout << x << "," << y << endl;
  }
};

A a;
A* pa = new A; //指针
boost::shared_ptr<A> ptr_a(pa); //智能指针.

现在要向像 A::func 这样的非静态成员函数绑定.
若A::func有n个参数, 则 bind 要有 n+2 个参数: 指向成员函数fun的指针, 绑定到this的对象, n个参数.
如:
boost::bind(&A::func, a, 3, 4)();    //输出 3, 4
boost::bind(&A::func, pa, 3, 4)();   //输出 3, 4
boost::bind(&A::func, ptr_a, 3, 4)();//输出 3, 4
同样可以用 _1 这样的占位符. 如:
boost::bind(&A::func, _1, 3, 4)(ptr_a);//输出 3, 4

可以看出. 不论传递给bind 的第2个参数是对象. 对象指针. 还是智能指针. bind函数都能够正常工作.

9.3 bind嵌套

有个类如下. 记录人的信息:
class Personal_info {
  string name_;
  int age_;
public:
  int get_age();
  string name();
};

vector<Personal_info> vec;
...
现在要对 vec 排序. 可以用 bind 函数做一个比较谓词
std::sort(
  vec.begin(),
  vec.end(),
  boost::bind(
   std::less<int>(),
   boost::bind(&personal_info::age,_1),     //_1 占位符是 sort 中调用比较函数时的第一个参数.
   boost::bind(&personal_info::age,_2)));   //_2 占位符是 sort 中调用比较函数时的第二个参数.

9.4 函数组合

假如有:
vector<int> ints;
...
想用 std::count_if() 来求ints中有多少是 >5 且 <=10 的. 这在常规代码中通常就要写一个函数来实现这个谓词:
if (i>5 && i<=10) ...
现在用bind则可以:
std::count_if(
  ints.begin(), ints.end(),
  boost::bind(
   std::logical_and<bool>(),
   boost::bind(std::greater<int>(),_1,5),
   boost::bind(std::less_equal<int>(),_1,10)));

9.5 绑定到成员变量

有:
map<int, string> my_map;
my_map[0]="Boost";my_map[1]="Bind";
现在要输出所有元素的 second 成员. 也就是输出这些字符串. 其中的打印函数如下:
void print_string(const string& s) {
  std::cout << s << '\n';
}
则可以:
for_each(
  my_map.begin(),
  my_map.end(),
  boost::bind(
   &print_string,
   boost::bind(&std::map<int,std::string>::value_type::second,_1)
   )
  );

汗... 看不懂bind的源码. 也不知是如何实现这些功能的. 只能等<<boost源码剖析>>出来了.

注意:
(以下补于08年6月3日)

boost::bind() 返回的函数对象会保存要绑定的实参. 而且总是拷贝一份以值的方式保存..
这主要是考虑到被绑定的实参的生命期.
但这并不总是我们期望的. 例如有时我们希望它保存指针或引用:

有函数:
void f(int & x) { ++x; }
然后:
int n = 0;
bind(&f, n)();    //我们希望 n==1 . 但实际上没有这样...

要避免这种对象复制. 而要bind得到的函数对象保存实参的引用语义. 可以:
使用 boost::ref() 或 boost::cref() 如
bind(&f, ref(n))();        //OK, 执行后 n==1

如果是绑定一个对象到它的成员函数上. 如:
A a;
bind(&A::fun, a);       //则保存的是 a对象的拷贝.
要避免这种拷贝. 除了上面提到的 ref() 外, 也可以:
bind(&A::fun, &a);      //用指针. 反正用对象和用指针都可以. 而用指针可以避免对象拷贝的问题.

注意: (以下补于6月10日)
bind () 的第一个参数——被绑定函数——是不被求值的. 如下例:

typedef void (*pf)(int);
std::vector<pf> v; //v中有一些函数指针.
std::for_each(v.begin(), v.end(), bind(_1, 5));   //想实现 _1(5); 这样的调用. 但这样不行!

正确的做法是借助 boost::apply 模板(来自boost/bind/apply.hpp).
apply也是一个函数对象. 它的作用如下:
apply<void> a;   //模板参数为函数对象的返回值类型.
a(x);       //相当于调用 x();
a(x, y);    //相当于调用 x(y);
a(x, y, z); //相当于调用 x(y, z);
所以错误的bind应该写为:
std::for_each(v.begin(), v.end(), bind(apply<void>(), _1, 5));

本文链接

[转]boost.asio 编译

2011-05-31T07:26:00Z

环境： VS2010,

boost_1_46_1,解压缩后放在，D:\boost_1_46_1。

1，编译。

boost库大部分源文件是只有投文件，所以有很多库不用编译就可以使用。但是有些库是需要编译源码的。asio就需要编译。

怎么去编译呢？在boost官方网站下载bjam.exe，放入boost源文件的根目录下面。因为asio依赖于其它的一些库，所以编译参数还有点复杂。然后在cmd下输入
D:\boost_1_46_1>bjam
--with-system --with-thread --with-date_time --with-regex
-
-with-serialization stage

编译完成后就可以在boost_1_46_1\stage里面找到编译好的库文件。如果在编译的时候出现编译器方面的错误，可以尝试运行C:\Program
Files\Microsoft Visual Studio 9.0\VC\vcvarsall.bat,自动设置编译环境。

有时候你的系统上面可能装了几个版本的VS，那么怎么指定版本呢？

D:\boost_1_46_1>bjam --without-python --toolset=msvc-10.0 --with-thread
--with-date_time --with-regex -
-with-serialization stage

--without-python 表示不使用 python
--toolset : 所使用compiler，Visual Studio
2010為msvc-10.0
--prefix：指定編譯後library的安裝目錄

接下来就是导入include目录boost根目录到vs中，导入编译后的lib文件目录stage\lib到lib路径中去。

vs2010:右击project->properties->VC++ Directories.
将D:\boost_1_46_1加入到include directories中去，将D:\boost_1_46_1\stage\lib加入到Library
Directories路径中去。

2、测试。

//
// timer.cpp
// ~~~~~~~~~
//
// Copyright (c)
2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
//
Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

#include <iostream>
#include <boost/asio.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

int main()
{
boost::asio::io_service io;

boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));

t.wait();

std::cout << "Hello, world!\n";

return 0;
}

编译时提示建议添加一下编译参数来制定编译目标平台：

1> Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For
example:
1> - add -D_WIN32_WINNT=0x0501 to the compiler command line;
or
1> - add _WIN32_WINNT=0x0501 to your project's Preprocessor
Definitions.
1> Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP
target).

编译pass~~

补充一下：

执行以上操作之前请执行：

bootstrap.bat

参考：

http://blog.csdn.net/TADICAN/archive/2009/06/17/4273004.aspx

本文链接

IT人员简历样本（英文）

2011-05-25T05:43:00Z

http://www.51ielts.com 2005-1-22 来源：【无忧雅思网】

Michael Needjobs
3221 Need Job Street
North York, ON
V5R
5B7
Tel.(416)
123-4567

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

OBJECTIVE:
Seeking a challenging position as System Analyst with a growth-oriented
organisation where my skills, experience will be utilised to their full
potential.

WORK EXPERIENCE:

May 1994-Present Employer: BEST SYSTEM
INC., Markham, Ontario

Position: System Analyst

designed and
implemented complex GUI and RDBMS applications under WINDOWS NT environment
using Visual C++, MFC, C, Visual Basic 4, SQL Server 6, Access 2.0
member of
a development team for a large client server (three tier) relational database
application using Visual Basic, remote automation, remote databases and SQL
server under WINDOWS NT environment.
redeveloped and reengineered several
applications of serial communication and databases

1993 - Apr.1994
Employer: SINUS INTERNATIONAL INC., Toronto, Ontario

Position: Programmer
Analyst

designed, developed and tested communication software written in
C for DOS and UNIX, based on custom communication protocol
designed
relational database applications on UNIX environment
supported and managed
the activity of a Novell network
1991-1993 Employer: ALEGRA Ltd, Oradea,
Romania

Position: R&D Engineer

designed and developed
structured software applications in C (DOS/WINDOWS), C++, Pascal
designed
database applications dBase and Fox-Pro
co-ordinated and supervised the whole
activity in a NOVELL computer network
taught public courses 10 hours/week
about computer programming
July-Sept. Environment: University of Coimbra
(Portugal)

1990 Position: R&D Engineer

summer courses on data
transmission, remote connections to servers,
Internet

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

PERSONAL
STRENGTHS:

six years of extensive work experience in various aspects of
computer programming, analysis, developing and testing
able to optimise
programs, to use difficult algorithms and protocol specifications, to work in a
team environment or unsupervised
able to co-ordinate the analysis and
production a development team
excellent programming abilities in C (DOS &
UNIX), Visual C++, Visual Basic, SQL server, Access
very good working
knowledges with computer networks (Novell and TCP/IP)
well-organised,
efficient, quick learner, self-motivated and excellent mathematics
background
excellent ability to plan, organise, prioritise my work and to
meet on time the deadlines
EDUCATION AND TRAINING:

1986-1991 Computer
and Control Engineering Faculty
University of Timisoara/Romania
Master of
Science Degree in Computer Engineering

1991-1994 International Business
Relations Faculty
University of Timisoara/Romania

1995 Seneca College
- Advanced C++ Course
Microsoft - Advanced C++ Course

PAPERS,
DISSERTATIONS AND AWARDS:

1986-1989 prizes at the Graduate Student
National Mathematics Contest
June 1994 Member in Romanian Engineers
Association
SPECIAL INTERESTS:

Object Oriented Programming,
Numerical Models, Data Communication
HOBBIES:

Hiking, tennis, music
and reading
LANGUAGES:

English, French, German and
Romanian
REFERENCES:

Available upon request

本文链接

[转]VC和c++ builder DLL互调用

2011-02-22T09:48:00Z

常在江湖飘，少不了要和DLL打交道。有时我们需要使用C++Builder编写一个DLL，然后拿到VC中用（比如用C++Builder写一个窗体封装到DLL）；有时又要拿VC编写的DLL在C++Builder使用（比如拿到一个产品的开发包，这个包是一堆用VC写的DLL）。
很遗憾，由于MS和Borland（CodeGear）两家的编辑器实现细节不同，造成了它们生成的DLL不能相互通用，因此给实际带来了很多的麻烦。下面来说一说如何解决这个问题。
一、VC生成DLL，C++Builder调用。
1、用extern "C"修饰VC导出的DLL函数。如：extern "C" __declspec(dllexport) int aFunc(int a);
2、用C++Builder的implib工具生成DLL对应的lib文件。如：implib -a xxx.lib xxx.dll（注意，implib一定要带-a开关）。生成lib文件之后，C++Builder便可以使用这个lib文件了。

二、C++Builder生成DLL，VC调用。
1、用extern "C"修饰C++Builder导出的DLL函数。如：extern "C" __declspec(dllexport) int aFunc(int a);
2、用C++Builder的impdef工具生成DLL对应的def文件。如：impdef xxx.def xxx.dll。
3、用记事本打开xxx.def文件，删去每个函数名前的"_"。如原来的def文件为：

C/C++ code: LIBRARY XXX.DLL

EXPORTS
___CPPdebugHook @2 ; ___CPPdebugHook
_aFunc @1 ; _aFunc

那么删除后就变成了：

C/C++ code: LIBRARY XXX.DLL

EXPORTS
__CPPdebugHook @2 ; ___CPPdebugHook
aFunc @1 ; _aFunc

4、用VC的LIB工具，根据上面的def文件生成lib文件。如：LIB /DEF:XXX.def。生成lib文件之后，VC便可以使用这个lib文件了。

综上说来，两种工具开发的DLL在相互使用的时候，主要的问题便是lib库的问题，能把这一问题解决好行了。

本文链接

[转]c++builder调用VC的dll以及VC调用c++builder的dll

2010-12-02T03:47:00Z

解析__cdecl，__fastcall， __stdcall 的不同:
在函数调用过程中，会使用堆栈，这三个表示不同的堆栈调用方式和释放方式。
比如说__cdecl，它是标准的c方法的堆栈调用方式，就是在函数调用时的参数压入堆栈是与函数的声明顺序相反的，其它两个可以看MSDN，不过这个对我们编程没有太大的作用
---------------------------------------------------------------
调用约定
调用约定(Calling convention)决定以下内容：函数参数的压栈顺序，由调用者还是被调用者把参数弹出栈，以及产生函数修饰名的方法。MFC支持以下调用约定：
_cdecl
按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于"C"函数或者变量，修饰名是在函数名前加下划线。对于"C++"函数，有所不同。
如函数void test(void)的修饰名是_test；对于不属于一个类的"C++"全局函数，修饰名是_test@@ZAXXZ（怎么感觉像乱码？？）。
这是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。
_stdcall
按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于"C"函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号"@"及参数的字节数，如函数int func(int a, double b)的修饰名是_func@12。对于"C++"函数，则有所不同。所有的Win32 API函数都遵循该约定。
_fastcall
头两个DWORD类型或者占更少字节的参数被放入ECX和EDX寄存器，其他剩下的参数按从右到左的顺序压入栈。由被调用者把参数弹出栈，对于"C"函数或者变量，修饰名以"@"为前缀，然后是函数名，接着是符号"@"及参数的字节数，如函数int func(int a, double b)的修饰名是@func@12。对于"C++"函数，有所不同。
未来的编译器可能使用不同的寄存器来存放参数。

Dll中用 __declspec(dllexport)声明的函数:
__declspec(dllexport)只是表示这个函数是一个DLL导出函数,而__stdcall是一种函数调用约定,两者应该是没有冲突的.
如:__declspec(dllexport) void __stdcall aTry();

c++builder和vc描述符定义的区别
在c++builder中
        __cdecl的函数输出前会带："_"
        __stdcall无特征,只输出函数名
        __fastcall函数输出前带："@"
        都无"@nn"后缀格式！
在vc中
        __cdecl无特征,只输出函数名
        __stdcall的函数输出前会带："_" 后缀带："@nn"
        __fastcall函数输出前带："@"后缀带："@nn

c++builder调用VC的dll:
在VC中编写DLL时，使用了.def文件，在出口函数声明时也在前面加上了__declspec(dllexport)说明。把VC生成的DLL文件放在了当前目录下，使用BCB的命令行工具implib生成的.lib文件，具体格式为implib bcb.lib vc.dll，再把implib根据dll生成的LIB文件加入到工程中，再在工程中加入DLL出口函数的声明（函数名前加上了WINAPI,即__stdcall；每个函数定义的最前面也加上了__declspec(dllimport)）。
而且由于BCB和VC++成立函数名转换的做法不同。所以在VC中最好是输出函数为C函数的DLL，如果输出函数是C++类，则可能无法调用。
我的解决办法（经过本人实验证明的，共2种）
方法1：VC编译c文件生成dll时导出函数头文件加上extern "C"{}关键字，函数声明和定义处再加调用约定描述符__cdecl，然后将函数声明和定义处都加上一个下划线就没有问题了。
EXAMPLE:
假设我VC的dll中包含int myFunction(void)，.c文件中函数实现处的正确写法是：
__declspec(dllexport) int __cdecl _myFunction(void)
{
// add your code here
}
.h文件中函数声明处的正确写法如下
__declspec(dllexport) int __cdecl _myFunction(void);
BCB调用时只要包含lib文件，具体操作步骤：
运行implib bcb.lib vc.dll
project->add to...下拉框中选择.lib类型，打开刚才通过implib和vc的dll生成的lib文件
在工程中用到dll的.c源文件中包含该dll的头文件
调用时直接写 int i = myFunction(); 即可。

方法2：仅对VC编译C文件生成dll时有效，导出函数头文件加上extern "C"{}关键字。BCB的Project->option->advanced compiler下的Calling convention中选择Stdcall就可以直接调用VC的.c文件编译生成的动态链接库了。

VC调用c++builder的dll: (参考：MSDN2000)
VC中无LIB时的DLL隐式链接,制作与VC++相符合的LIB函数符号输入库（转）请大家注意!这种方法只能应用于输出为C格式的__stdcall调用方式！
1.使用VC++的工具DUMPBIN将DLL中的导出函数表导出到一定义(.DEF)文件
EXAMPLE：
DUMPBIN VideoDeCoder.dll /EXPORTS /OUT:VideoDeCoder.def
2.将导出的.DEF文件整理为一符合.DEF个数的函数导出文件(整理过程巨乱巨复杂，懒得举例了，后面有简便方法^_^)
3.使用VC++的LIB工具,带/DEF:(.def文件名) /MACHINE:IX86(80X86机器),就输出符合VC++格式的的LIB文件了.
EXAMPLE:
LIB/DEF:VideoDeCoder.def /MACHINE:IX86
4.连接时带上LIB文件链接;注意的是当有些动态库DUMPBIN的只有函数名,无"@nn"的参数格式,如C++Builder写的DLL,输出就只有函数名符号,链接时就会报错:
error LNK2002:unresolved external symbol "functionname@nn"
提示程序中引入的函数符号无法识别,这时只要将DEF文件中相应的函数名称改为functionname@nn方式,重新建立LIB,重新链接即可.
这样就制作成功了符合VC调用方式的LIB了！

要值得一说的是！BORLAND C++BUILDER有一个很好的工具IMPDEF可以直接将DLL中的函数输出到.DEF文件中，这种方法只能应用于输出为C格式的__stdcall调用方式，只要做一点点修改就可以成为符合VC的DEF文件！
IMPDEF xxx.def xxx.dll
只要将BCB的DEF文件中函数申明格式转换为vc识别的格式就可以利用LIB工具生成LIB；要使用C分格输出(extern "C")才是必须的！而且别忘了在DEF文件中的函数申明不要带“_”啊！：）不然会出现error LNK2001的链接错误！
vc调用bcb的我没试过，不过可以参照上面的格式自己改改好了：）

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/helenhf/archive/2007/03/16/1531002.aspx

本文链接