麻豆精品久久精品色综合,久久亚洲高清观看,四虎国产精品免费久久5151

volnet — Fri, 18 Mar 2011 18:01:00 GMT

以下是来自Google Protobuf Documents里的一句话�Q?

As you can see, each field in the message definition has a unique numbered tag. These tags are used to identify your fields in the message binary format, and should not be changed once your message type is in use. Note that tags with values in the range 1 through 15 take one byte to encode. Tags in the range 16 through 2047 take two bytes. So you should reserve the tags 1 through 15 for very frequently occurring message elements. Remember to leave some room for frequently occurring elements that might be added in the future.

�q�里要做一个解释，��是��Z��么是1�?5�Q�以�?6�?047呢？

1�?5�Q�仅使用1bytes。每个byte包含两个部分�Q�一个是field_number一个是tag�Q�其中field-number��是protobuf中每个值后�{�号后的数字�Q�在C++和Java中，如果不设�|�这个��|��则它是随机的�Q�如果在Python中，不设�|�，它则不被处理�Q�这个在message binary format中的Field Order一节中有提刎ͼ�。那么我们可以认��个field_number是必��ȝ��。那么一个byte用来表达�q�个值就�?span style="color: red">000000000�Q�其中红色表�C�是否有后箋字节�Q�如果�ؓ0表示没有也就是这是一个字节，蓝色部分表示field-number�Q�绿色部分则是wire_type部分�Q�表�C�数据类型。也��是(field_number << 3) | wire_type。其中wire_type只有3位，表示数据�c�d��。那么能够表�C�field_number的就�?位蓝色的数字�Q?位数字能够表辄��最大范围就�?-15�Q�其�?是无效的�Q��?
16�?047�Q�与上面的规则其实类��|��下面�?bytes��Z��子，那么��有10000000 00000000�Q�其中红色部分依然是�W�号位，因�ؓ每个byte的第一位都用来表示下一byte是否和自己有养I��那么对于>1byte的数据，�W�一位一定是1�Q�因��里假设是2byte�Q�那么第二个byte的第一位也是红�Ԍ��刨除�q�两位，再扣�?个wire_type位，剩下11位（2*8-2-3�Q�，能够表达的数字范围就�?047�Q?¹¹�Q��?/li>

参考资料：

http://code.google.com/intl/zh-CN/apis/protocolbuffers/docs/proto.html
http://code.google.com/apis/protocolbuffers/docs/encoding.html

volnet 2011-03-19 02:01 发表评论

zig-zag�~�码方式

volnet — Fri, 18 Mar 2011 16:36:00 GMT

zig-zag�Q�就是把�Q?1�Q?000 0001变成0000 0011�Q�注意最后一�?是符号位�Q�也��是2�Q�那么如果是个int32的话�Q?000 0000 0000 0000 0000 0000 0000 0001 ��变成了000 0000 0000 0000 0000 0000 0000 00011�Q�那么也��是11了，那么可以节约很多�W�号位�?a >http://goo.gl/2wRKb
用位�q�算来表�C�把一个负数�{换成zig-zag�~�码�Q�就�?span class="pun">

int32是：(n << 1) ^ (n >> 31)
int64是：(n << 1) ^ (n >> 63)

也就是说�Q�如果是负数�Q�对�?2位最多能省去30��|��其中1格是�W�号位，另一个代表最����?�Q�此处假�?#8220;正负0”不合法）。同理，64位最多能省去62位。当然比较极端的是所有的位数都被用上了�?br>

volnet 2011-03-19 00:36 发表评论

IsWow64�q�不能用来检��是否是Windows 32bit�pȝ��q�是64bit�pȝ��

volnet — Sun, 05 Sep 2010 18:06:00 GMT

如何当前操作�pȝ��是不�?4位？如何判断当前应用�E�序是否在Wow64下运行？

首先什么是Wow64�Q�很多朋友一看到64��p��个方法是判断当前�pȝ��是否�?4bit的，其实不然。Wow64是Windows-On-Windows64的意思，它是指在64位的操作�pȝ��上（不是�?4位的CPU�Q�运�?2位应用程序的兼容�q�_��?/p>

下面是MSDN中一�D�IsWow64的应用程序：

BOOL IsWow64() 
{ 
    typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL); 
    LPFN_ISWOW64PROCESS fnIsWow64Process; 
    BOOL bIsWow64 = FALSE; 
    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle(_T("kernel32")), "IsWow64Process"); 
    if (NULL != fnIsWow64Process) 
    {
        fnIsWow64Process(GetCurrentProcess(),&bIsWow64); 
    } 
    return bIsWow64; 
}

下面的代码用来检��这个程序的�l�果�Q?/p>

if( IsWow64() == TRUE )
{
    _tprintf(_T("IsWow64() == TRUE\n"));
}
else
{
    _tprintf(_T("IsWow64() == FALSE\n"));
}

让我们编译一下这个程序�?/p>

我们需要的�?4位的操作�pȝ��Q�比如XP64bit�Q�Windows 2008 R2�{�都�?4bit操作�pȝ��?/p>

�?4位的操作�pȝ��上运行的kernel32.dll中，��会实现IsWow64Process�Ҏ��Q�而在32位系�l�中提供的kernel32.dll中则没有提供相关函数的实现�?/p>

比较�q�h��人的则是bIsWow64�Q�其实仔�l�看MSDN中的Remark�Q�会发现�Q?/p>

If the application is a 64-bit application running under 64-bit Windows, the Wow64Process parameter is set to FALSE.也就是说64位应用程序跑�?4位的操作�pȝ��上，bIsWow64的值将是FALSE而不是TRUE�?

因此我们需要分别将我们的程序编译成Win32�q�_��和x64�q�_��的，如果你用Visual Studio�q�行�~�译�Q�默认安装则只包�?2位的�~�译�?链接器，即便你是�?4位操作系�l�上安装�Q�也是一��L��。你需要在VC++节点下勾选x64选项才可以，Itanium则需要在Server�q�_��下安装才可勾选。然后在�~�译的时候，分别选择Win32和x64�q�行�~�译�?

�~�译后，�q�行�Q�结果如我们分析的一��P��

�?4位系�l�上�q�行Win32�~�译配置的结果是IsWow64() == TRUE�Q�而x64�~�译配置的结果是IsWow64() == FALSE�?

如果惌��知道当前�pȝ��是否�?4位的�Q�则可以通过下面的方法：

BOOL Is64bitSystem()
{
    SYSTEM_INFO si;
    GetNativeSystemInfo(&si);

    if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||    
        si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 )
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    } 
}

注意�Q�需要注意是GetNativeSystemInfo 函数从Windows XP 开始才有， �?IsWow64Process 函数�?Windows XP with SP2 以及 Windows Server 2003 with SP1 开始才有�?

volnet 2010-09-06 02:06 发表评论

volnet — Sat, 04 Sep 2010 18:20:00 GMT

摘要: http://software.intel.com/zh-cn/articles/intel-guide-for-developing-multithreaded-applications/ ��q��?多线�E�应用开发指�?提交新文�? Published On : 2010�q?2�?5�?20:00 评�� L��录后评��Q�当前分敎ͼ� 0 �?0 用户 ��L��录后评��Q�当前分敎ͼ� 0 ... 阅读全文

volnet 2010-09-05 02:20 发表评论

[转]C/C++中动态链接库的创建和调用

volnet — Fri, 27 Aug 2010 16:30:00 GMT

转蝲自：http://developer.51cto.com/art/200702/39608.htm

动态连接库的创建步骤：

一、创建Non-MFC DLL动态链接库

1、打开File �?gt; New �?gt; Project选项�Q�选择Win32 Dynamic-Link Library �?gt;sample project �?gt;工程名：DllDemo

2、新��Z��?h文�gDllDemo.h

#ifdef DllDemo_EXPORTS 
#define DllAPI __declspec(dllexport) 
#else 
#define DllAPI __declspec(dllimport) 
extern "C" //原样�~�译 
{ 
DllAPI int __stdcall Max(int a,int b); //__stdcall佉K��C/C++语言内能够调用API 
} 
#endif

3、在DllDemo.cpp文�g中导入DllDemo.h文�g�Q��ƈ实现Max(int,int)函数

#include "DllDemo.h" 
DllAPI int __stdcall Max(int a,int b) 
{ 
if(a==b) 
return NULL; 
else if(a>b) 
return a; 
else 
return b; 
}

4、编译程序生成动态连接库

二、用.def文�g创徏动态连接库DllDemo.dll

1、删除DllDemo工程中的DllDemo.h文�g�?

2、在DllDemo.cpp文�g��_��删除 #include DllDemo.h语句�?

3、向该工�E�中加入一个文本文�Ӟ��命名为DllDemo.def�q�写入如下语句：

LIBRARY MyDll

EXPORTS

Max@1

4、编译程序生成动态连接库�?

动态链接的调用步骤�Q?/strong>

一、隐式调�?/strong>

1、徏立DllCnslTest工程

2、将文�gDllDemo.dll、DllDemo.lib拯��到DllCnslTest工程所在的目录

3、在DllCnslTest.h中添加如下语句：

#define DllAPI __declspec(dllimport) 
#pragma comment(lib�Q?DllDemo.lib") //在编辑器link�Ӟ��链接到DllDemo.lib文�g 
extern "C" 
{ 
DllAPI int __stdcall Max(int a,int b); 
}

4、在DllCnslTest.cpp文�g中添加如下语句：
#include "DllCnslTest.h"http://或�?#include "DllDemo.h"
void main()
{
int value;
value = Max(2,9);
printf("The Max value is %d\n",value);
}

5、编译�ƈ生成应用�E�序DllCnslTest.exe
二、显式调�?/strong>
1、徏立DllWinTest工程�?
2、将文�gDllDemo.dll拯��到DllWinTest工程所在的目录或Windows�pȝ��目录下�?
3、用vc/bin下的Dumpbin.exe的小�E�序�Q�查看DLL文�g(DllDemo.dll)中的函数�l�构�?
4、��用类型定义关键字typedef�Q�定义指向和DLL中相同的函数原型指针�?
例：
typedef int(*lpMax)(int a,int b); //此语句可以放�?h文�g�?/p>

5、通过LoadLibray()��DLL加蝲到当前的应用�E�序中�ƈ�q�回当前DLL文�g的句柄�?
例：
HINSTANCE hDll; //声明一个Dll实例文�g句柄
hDll = LoadLibrary("DllDemo.dll");//导入DllDemo.dll动态连接库

6、通过GetProcAddress()函数获取导入到应用程序中的函数指针�?
例：
lpMax Max;
Max = (lpMax)GetProcAddress(hDLL,"Max");
int value;
value = Max(2,9);
printf("The Max value is %d",value);

7、函数调用完毕后�Q��用FreeLibrary()卸蝲DLL文�g�?pre>
FreeLibrary(hDll);

8、编译�ƈ生成应用�E�序DllWinTest.exe
注：昑ּ�链接应用�E�序�~�译时不需要��用相应的Lib文�g�?/p>
下蝲�Q?font style="background-color: #cccccc">Visual Studio 2008验证通过�Q�：http://www.shnenglu.com/Files/mymsdn/DllCnsTest.7z

volnet 2010-08-28 00:30 发表评论

两个有用的宏�Q?amp;ldquo;��止�c�L��员复�?amp;rdquo;以及“��止隐式构�?amp;rdquo;

volnet — Tue, 10 Aug 2010 16:34:00 GMT

��止�c�L��员复�Ӟ��其核心就在于不允许类外部看见复制函数�Q�包�?#8220;拯��构造函�?#8221;�?#8220;operator =重蝲”�?/p>
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
private:                     \
TypeName(const TypeName&);               \
TypeName& operator=(const TypeName&)
��止隐式构造，则可以将默认构造函数隐藏�v来，在大多数�~�译器中也可以对构造函数增加explicit关键字来避免隐式构造�?
#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
private:                     \
TypeName();                                    \
DISALLOW_COPY_AND_ASSIGN(TypeName)
更多解释详见《More Effective C++�?

volnet 2010-08-11 00:34 发表评论

volnet — Thu, 22 Jul 2010 12:46:00 GMT

__declspec关键�?/p>
// keyword__declspec.cpp : 定义控制台应用程序的入口炏V�? // // ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/kernel_d/hh/Kernel_d/64bitAMD_6db3322a-fe6d-4287-9eda-a9c1378e715d.xml.htm // The sizeof value for any structure is the offset of the final member, // plus that member's size, rounded up to the nearest multiple of the largest // member alignment value or the whole structure alignment value, // whichever is greater. #include "stdafx.h" __declspec( align( 32) ) struct Struct__declspec_1 { int a; int b; }; __declspec( align( 32) ) struct Struct__declspec_2 { __declspec( align( 64) ) int a; int b; }; __declspec( align( 8 ) ) struct Struct__declspec_3 { int a; //4 bytes int b; //4 bytes int c; //4 bytes }; __declspec( align( 8 ) ) struct Struct__declspec_4 { int a; //4 bytes int b; //4 bytes }; struct StructNormal { int a; //4 bytes int b; //4 bytes int c; //4 bytes }; int _tmain(int argc, _TCHAR* argv[]) { printf( "sizeof Struct__declspec_1 is %d.\n", sizeof( Struct__declspec_1 )); //32 printf( "sizeof Struct__declspec_2 is %d.\n", sizeof( Struct__declspec_2 )); //64 printf( "sizeof Struct__declspec_3 is %d.\n", sizeof( Struct__declspec_3 )); //16 printf( "sizeof Struct__declspec_4 is %d.\n", sizeof( Struct__declspec_4 )); //8 printf( "sizeof StructNormal is %d.\n", sizeof( StructNormal )); //12 return 0; }

volnet 2010-07-22 20:46 发表评论

volnet — Tue, 06 Jul 2010 14:45:00 GMT
     摘要: 和大多数内存��理的初衷一��_��希望能够控制内存分配和回�Ӟ��减少内存��片�Q�且通常�q�样的内存都会预开一�D�连�l�内存空��_��然后我们自己来管理这�D�内存。当焉��常�q�样的需求都很合理，但是实现��h��则通常不能完美�Q�比如：效率、算法的选择、如何减��内存碎片、跟�t�管理内存分配、性能��、对�pȝ��内存使用的统计、垃圑֛�收等。下面是我近期实现的一个非常简陋的�E�序�Q�甚臛_��能连基本的要求都无法辑ֈ��Q�大家帮忙看看，它究竟有多少�~�点...  阅读全文

volnet 2010-07-06 22:45 发表评论

volnet — Thu, 01 Jul 2010 17:14:00 GMT

今天在VS2008下编译VS自带Sample中的一个例子，TstCon�Q�因��Z��前的机器装的是XP�pȝ��Q�该�E�序曾成功编译过�Q�不�q�今天在Windows Server 2008 R2下打开��p�|�Q�在朋友的Windows 7 Ultimate下打开也失败，试用以管理员�w�䆾�q�行�Q�失败，试用修改兼容性选项为Windows XP SP3/SP2方式�Q�均��p�|�?/p>
其实�q�个时候可能是一些Vista以上版本的OS所提供的新功能引�v的限制。就当前的这个例子而言�Q�是因�ؓ�~�译的时候，启用用户帐户控制(UAC)默认为“是”所��_��解��x��案内所有工�E�选中�Q�右键属性，修改“配�|�属性�?>“链接器�?>“清单文件�?>“启用用户帐��h��?UAC)”�ؓ“否”，重新生成解决�Ҏ��Q�即可�?/p>

volnet 2010-07-02 01:14 发表评论

size_t的倒序遍历问题

volnet — Wed, 30 Jun 2010 15:51:00 GMT

准确地说�q�是�l�验不��Q�这么简单的事居然想了好几分钟，当然也要怪VS在没有重新生成前的诡异现象�?/p>
今晚在类中加入两个数�l�用来做计数�Q�因��Z��前代码有所改动�Q�VS�~�译�Q�增量）的结果居然出��C��无数�ơ的�E�序崩溃�Q�害我一度怀疑是不是我的数组写的有问题。囧。最后无奈之下，点了重新生成�Q�居焉��利通过了，很生气，愤怒中�?/p>
但是另外却发��C��一个问题，也就是当size_t用作循环的时候。因��Z��前都是用int做��@环的�Q�现在换成unsigned int�Q�也��是size_t�Q�后�Q�一下子没反应过来，��顺手这么写了：

for( size_t i = MAX - 1; i >= 0; --i)

{

//…�?/p>

}

乍一看似乎没啥问题，因�ؓ我��@环内的代码是删除资源的，因此�E�序也频频崩溃�?/p>
step over的结果才让�h惊讶�Q�因为当size_t i = 0的时候，--i的结果是无穷大，而无�I�大则肯定满��i>=0的条�Ӟ��所以当我们期待�E�序停住的时候，�E�序是不会停住的�?/p>
修正的方式：

1、��用正向遍历�?/p>
2、增加判断条�Ӟ��i>=0 && i < MAX�Q�，但这里也可能存在问题�Q�因为size_t可能被定义�ؓunsigned int�Q�但是MAX可能是个更大的数�Q�比如unsigned long long�Q�当然这��L��比较不是很有意义�Q�或者会实现一些�{换，但是如果�q�种情况发生的话�Q�程序可能还是会通过一个随机的i�q�入��C��个未知的�I�间中，从而造成崩溃。而且增加判断条�g也��得程序的�q�行成本提高�?/p>

volnet 2010-06-30 23:51 发表评论

C++ Traits

volnet — Mon, 26 Apr 2010 07:31:00 GMT

本来惛_��好写写C++ Traits的，刚刚接到interview的通知�Q�先贴代码，改天再议�?/p>
/* * cpp_traits.cpp * * Created on: 2010-4-26 * Author: volnet@tom.com */ #include // kinds of types for overloading. struct undefined_type {}; struct int32_type {}; struct int64_type {}; // typedef some has_trivial_* for difference types. template <class T> struct type_traits { typedef undefined_type has_trivial_type; }; // define the partial specialization functions. template <> struct type_traits<int> { typedef int32_type has_trivial_type; }; template <> struct type_traits<long> { typedef int64_type has_trivial_type; }; // the dispatcher method for all kinds of types. template <class T> void type_detect(T& p){ typedef typename type_traits<T>::has_trivial_type trivial_type; type_detect(p, trivial_type()); } // define the functions for dispatching. template <class T> void type_detect(T& p, undefined_type) { std::cout << p; std::cout << " // It's a undefined type, we have NOT found the dispatcher function." << std::endl; } template <class T> void type_detect(T& p, int32_type) { std::cout << p; std::cout << " // It's a int32" << std::endl; } template <class T> void type_detect(T& p, int64_type) { std::cout << p; std::cout << " // It's a int64" << std::endl; } int main(void) { int int32num = 2010; type_detect(int32num); long int64num = 2010L; type_detect(int64num); std::string str = "2010"; type_detect(str); std::cout << "-------end of program." << std::endl; return EXIT_SUCCESS; }

volnet 2010-04-26 15:31 发表评论

[��译]高效使用auto_ptr

volnet — Wed, 07 Apr 2010 11:08:00 GMT

本文来自C/C++用户日志�Q?7�Q?0�Q�，1999�q?0�?/i> 原文链接

大部分�h都听说过auto_ptr指针�Q�但是�ƈ非所有�h都每天��用它。不使用它是不明智的�Q�可�ȝ��Q�，因�ؓauto_ptr的设计初��h��Z��解决C++设计和编码的普遍问题�Q�将它用好可以写出更健壮的代码。本文指出如何正��用auto_ptr以�ɽE�序变得安全�Q�以及如何避开危险�Q�而不是一般��用auto_ptr的恶习所致的创徏间歇性和难以诊断的问题�?

��Z��么它是一个“自动”指�?

auto_ptr只是许许多多��指针中的一�U�。许多商业库提供许多更强大的��指针�Q�可以完成更多的事情。从可以��理引用计数到提供更先进的代理服务等。应该把auto_ptr认�ؓ是智能指针中的福特Escort[注释]�Q�一个基于简单且通用目的的智能指针，既没有小发明也没有丰富的�Ҏ��目的更不需要高性能�Q�但是能��许多普通的事情做好�Q��ƈ且能够适合日常使用的智能指针�?

auto_ptr做这样一件事�Q�拥有一个动态分配内存对象，�q�且在它不再需要的时候��行自动清理的职责。这里有个没有��用auto_ptr指针的不安全的例子：

// Example 1(a): Original code // void f() { T* pt( new T ); /*...more code...*/ delete pt; }

我们每天都像�q�样写代码，如果f()只是一个三行程序，也没做什么多余的事情�Q�这样做当然可以很好工作。但是如果f()没有执行delete语句�Q�比如程序提前返回（return�Q�了�Q�或者在执行的时候抛出异�怺��Q�然后就��D��已经分配的对象没有被删除�Q�因此我们就有了一个经典的内存泄漏�?

一个��Example�Q?�Q�安全的办法是用一个“智能”的指针拥有�q�个指针�Q�当销毁的时候，删除那个被指的自动分配的对象。因��个智能指针被��单地用�ؓ自动对象�Q�这��是�Q�当它离开它的作用域的时候自动销毁对象）�Q�所以它被称作“自动”指针�?

// Example 1(b): Safe code, with auto_ptr // void f() { auto_ptr pt( new T ); /*...more code...*/ } // cool: pt's destructor is called as it goes out // of scope, and the object is deleted automatically

现在�q�段代码��不会再T对象上发生泄漏了�Q�不必在意这个方法是正常退��是异帔R��出，因�ؓpt的析构函数将��L��在堆栈弹出的时候被调用。清理工作将自动�q�行�?/p>
最后，使用auto_ptr和��用内建指针一样地�Ҏ��Q�如果要“收回”资源�ƈ且再�ơ手动管理的话，我们可以调用release()�Q?/p>
// Example 2: Using an auto_ptr // void g() { T* pt1 = new T; // right now, we own the allocated object // pass ownership to an auto_ptr auto_ptr pt2( pt1 ); // use the auto_ptr the same way // we'd use a simple pointer *pt2 = 12; // same as "*pt1 = 12;" pt2->SomeFunc(); // same as "pt1->SomeFunc();" // use get() to see the pointer value assert( pt1 == pt2.get() ); // use release() to take back ownership T* pt3 = pt2.release(); // delete the object ourselves, since now // no auto_ptr owns it any more delete pt3; } // pt2 doesn't own any pointer, and so won't // try to delete it... OK, no double delete

最后，我们可以使用auto_ptr的reset()�Ҏ��auto_ptr重置向另一个对象。如果auto_ptr已经获得一个对象，�q�个�q�程��像是它先删除已�l�拥有的对象�Q�因此调用reset()�Q�就像是先销毁了auto_ptr�Q�然后重��Z��一个新的�ƈ拥有该新对象�Q?

// Example 3: Using reset() // void h() { auto_ptr pt( new T(1) ); pt.reset( new T(2) ); // deletes the first T that was // allocated with "new T(1)" } // finally, pt goes out of scope and // the second T is also deleted

包装指针数据成员

同样�Q�auto_ptr也可以被用于安全地包装指针数据成员。考虑下面使用Pimpl idiom�Q�或者，�~�译器防火墙�Q�的例子�Q?sup>[1]

// Example 4(a): A typical Pimpl // // file c.h // class C { public: C(); ~C(); /*...*/ private: class CImpl; // forward declaration CImpl* pimpl_; }; // file c.cpp // class C::CImpl { /*...*/ }; C::C() : pimpl_( new CImpl ) { } C::~C() { delete pimpl_; }

��单地��_��是C的私有细节被实现��Z��个单独的对象�Q�藏匿于一个指针之中。该思�\要求C的构造函数负责�ؓ隐藏在类内部的辅助“Pimpl”对象分配内存，�q�且C的析构函数负责销毁它。��用auto_ptr�Q�我们会发现�q�非常容易：

// Example 4(b): A safer Pimpl, using auto_ptr // // file c.h // class C { public: C(); /*...*/ private: class CImpl; // forward declaration auto_ptr pimpl_; }; // file c.cpp // class C::CImpl { /*...*/ }; C::C() : pimpl_( new CImpl ) { }

现在�Q�析构函��C��需要担心删除pimpl_指针了，因�ؓauto_ptr��自动处理它。事实上�Q�如果没有其它需要显式写析构函数的原因，我们完全不需要自定义析构函数。显�Ӟ��q�比手动��理指针要容易得多，�q�且��对象所有权包含�q�对象是一个不错的习惯�Q�这正是auto_ptr所擅长的。我们将在最后再�ơ回��这个例子�?

所有权�Q�源�Q�以及调用�?Sinks)

它本�w�很漂亮�Q��ƈ且做得非常好�Q�从函数传入或传�?span style="font-family: 'Courier New'" class="Code">auto_ptrs�Q�是非常有用的，比如函数的参数或者返回倹{�?/p>
让我们看看�ؓ什么，首先我们考虑当拷贝auto_ptr的时候会发生什么：一个auto_ptr获得一个拥有指针的对象�Q��ƈ且在同一旉��只允许有一个auto_ptr可以拥有�q�个对象。当你拷贝一个auto_ptr的时候，你自动将源auto_ptr的所有权�Q�传递给目标auto_ptr�Q�如果目标auto_ptr已经拥有了一个对象，�q�个对象��先被释放。在拯��完之后，只有目标auto_ptr拥有指针�Q��ƈ且负责在合适的旉��销毁它�Q�而源��被讄��为空�Q�null�Q�，�q�且不能再被当作原有指针的代表来使用�?

例如�Q?/p>
// Example 5: Transferring ownership from // one auto_ptr to another // void f() { auto_ptr pt1( new T ); auto_ptr pt2; pt1->DoSomething(); // OK pt2 = pt1; // now pt2 owns the pointer, // and pt1 does not pt2->DoSomething(); // OK } // as we go out of scope, pt2's destructor // deletes the pointer, but pt1's does nothing

但是要避免陷阱再�ơ��用已�l�失��L��有权的auto_ptr�Q?

// Example 6: Never try to do work through // a non-owning auto_ptr // void f() { auto_ptr pt1( new T ); auto_ptr pt2; pt2 = pt1; // now pt2 owns the pointer, and // pt1 does not pt1->DoSomething(); // error! following a null pointer }

谨记于心�Q�我们现在看看auto_ptr如何在源和调用者之间工作。“源”这里是指一个函敎ͼ�或者其它创��Z��个新资源的操作，�q�且通常��移交出资源的所有权。一个“调用者”函数反转这个关�p�，也就是获得已�l�存在对象的所有权�Q��ƈ且通常�q�负责释攑֮��Q�。而不是有一个源和调用者，�q�回�q�且利用一个秃头指针（译者注�Q�而不是��用一个局部变量来传递这个指针）�Q�虽�Ӟ��通过一个秃头指针来获得一个资源通常很好�Q?

// Example 7: Sources and sinks // // A creator function that builds a new // resource and then hands off ownership. // auto_ptr Source() { return auto_ptr( new T ); } // A disposal function that takes ownership // of an existing resource and frees it. // void Sink( auto_ptr pt ) { } // Sample code to exercise the above: auto_ptr pt( Source() ); // takes ownership

注意下面的微妙的变化�Q?

Source()分配了一个新对象�q�且以一个完整安全的方式��它�q�回�l�调用者，�q�让调用者成为指针的拥有着。即使调用者忽略了�q�回��|��昄��Q�如果调用者忽略了�q�回��|��你应该从来没有写�q�代码来删除�q�个对象�Q�对吧？�Q�，分配的对象也��被自动安全地删除�?/p>
在本文的最后，我将演示�q�回一个auto_ptr是一个好习惯。让�q�回值包裹进一些东西比如auto_ptr通常是��得函数变得强健的有效方式�?

Sink()通过传值的方式获得对象所有权。当执行完Sink()的时候，当离开作用域的时候，删除操作��被执行�Q�只要Sink()没有��所有权转移�Q�。上面所写的Sink()函数实际上�ƈ没有对参数做��M��事情�Q�因此调用“Sink(pt);”就�{�于写了“pt.reset(0);”，但是大部分的Sink函数都将在释攑֮�之前做一些工作�?

不可以做的事情，以及��Z��么不能做

谨记�Q�千万不要以我之前没有提到的方式使用auto_ptrs。我已经看见�q�很多程序员试着用其他方式写auto_ptrs��像他们在��用其它对象一栗��但问题是auto_ptr�q�不像其他对象。这里有些基本原则，我将把它们提出来以引起你的注意：

For auto_ptr, copies are NOT equivalent. �Q�复制auto_ptr��与原来的不相等�Q?

当你试着在一般的代码中��?span style="font-family: 'Courier New'" class="Code">auto_ptrs的时候，它将执行拯��Q��ƈ且没有�Q何提�C�，拯��是不相等的（�l�果�Q�它��实��是拯��Q�。看下面�q�段代码�Q�这是我在C++新闻�l�经常看见的�Q?

// Example 8: Danger, Will Robinson! // vector< auto_ptr > v; /* ... */ sort( v.begin(), v.end() );

在标准容器中使用auto_ptrs��L��不安全的。一些�h可能要告诉你�Q�他们的�~�译器或者类库能够很好地�~�译它们�Q�而另一些�h则告诉你在某一个流行的�~�译器的文档中看到这个例子，不要听他们的�?

问题�?span style="font-family: 'Courier New'" class="Code">auto_ptr�q�不完全�W�合一个可以放�q�容器类型的前提�Q�因为拷�?span style="font-family: 'Courier New'" class="Code">auto_ptrs是不�{��h的。首先，没有��M��东西说明�Q�vector不能军_��增加�q�制造出“扩展”的内部拯��。再�ơ，当你调用一个一般函数的时候，它可能会拯��元素�Q�就像sort()那样�Q�函数必��L��能力假设拯��是等��L��。至��一个流行的排序拯��“核心”的元素�Q�如果你试着让它�?span style="font-family: 'Courier New'" class="Code">auto_ptrs一起工作的话，它将拯��一份“核心”的auto_ptr对象�Q�因此�{�U�L��有权�q�且��所有权转移�l�一个��时对象）�Q�然后对其余的元素也采取相同的方式（从现有成员创建更多的拥有所有权的auto_ptr�Q�，当排序完成后�Q�核心元素将被销毁，�q�且你将遇到一个问题：�q�组序列里至��一个auto_ptr�Q�也��是刚才被掉包的那个核心元素�Q�不再拥有对象所有权�Q�而那个真实的指针已经随着临时对象的销毁而被删除了！

于是标准委员会回退�q�希望做一些能够帮助你避免�q�些行�ؓ的事情：标准的auto_ptr被故意设计成当你希望在��用标准容器的时候��用它时打断你�Q�或者，臛_��Q�在大部分的标准库实��C��打断你）。�ؓ了达到这个目的，标准委员会利用这样一个技巧：�?span style="font-family: 'Courier New'" class="Code">auto_ptr's的拷贝构造函数和赋值操作符的右��|��rhs�Q�指向非帔R��。因为标准容器的单元素insert()函数�Q�需要一个常量作为参敎ͼ�因此auto_ptrs在这里就不工作了。（译者注�Q�右��g��能赋值给非常量）

使用const auto_ptr是一个好习惯

��一个auto_ptr设计�?span style="font-family: 'Courier New'" class="Code">const auto_ptrs��不再丢失所有权�Q�拷贝一个const auto_ptr是违法的�Q�译者注�Q�没有这��L��构造函敎ͼ��Q�实际上你可以针对它做的唯一事情��是通过operator*()或者operator->()解引用它或者调用get()来获得所包含的指针的倹{��这意味着我们有一个简单明了的风格来表达一个绝不丢失所有权的auto_ptr�Q?

// Example 9: The const auto_ptr idiom // const auto_ptr pt1( new T ); // making pt1 const guarantees that pt1 can // never be copied to another auto_ptr, and // so is guaranteed to never lose ownership auto_ptr pt2( pt1 ); // illegal auto_ptr pt3; pt3 = pt1; // illegal pt1.release(); // illegal pt1.reset( new T ); // illegal

�q�就是我要说的cosnt�Q�因此如果现在你要向世界证明你的auto_ptr是不会被改变�q�且��L��删除其所有权�Q�加上const��是你要做的。const auto_ptr风格是有用的�Q�你必须��它谨记于心�?

auto_ptr以及异常安全

最后，auto_ptr对写出异常安全的代码有时候非常必要，思考下面的代码�Q?/p>
// Example 10(a): Exception-safe? // String f() { String result; result = "some value"; cout << "some output"; return result; }

该函数有两个可见的作用：它输��Z��些内容，�q�且�q�回一个String。关于异常安全的详细说明��出了本文的范围^[2]�Q�但是我们想要取得的目标��是强异常安全的保障�Q�归�l��ؓ��保函数的原子性——如果有异常�Q�所有的作用一起发生或者都不发生�?

虽然在例10(a)中的代码非常�_��y�Q�看��h��相当接近于异常安全的代码�Q�但仍然有一些小的瑕疵，��像下面的客户代码所�C�：

String theName; theName = f();

因�ؓ�l�果通过��D��回，因此String的拷贝构造函数将被调用，而拷贝赋值操作符被调用来��结果拷贝到theName中。如果�Q何一个拷贝失败了�Q�f()��完成了所有它的工作以及所有它的�Q务（�q�很好）�Q�但是结果是无法挽回的（哎哟我的妈呀�Q?

我们可以做的更好吗，是否可以通过避免拯��来避免这个问题？例如�Q�我们可�?让函数有一个非帔R��引用参数�q�向下面�q�样�q�回��|��

// Example 10(b): Better? // void f( String& result ) { cout << "some output"; result = "some value"; }

�q�看��h��很棒�Q�但实际不是�q�样的，�q�回result的赋值的函数只完成了一个功能，而将其它事情留给了我们。它仍然会出错。因此这个做法不可取�?

解决�q�个问题的一个方法是�q�回一个指向动态分配指针的String对象�Q�但是最好的解决�Ҏ��是让我们做的更多�Q�返回一个指针包含在auto_ptr�Q?

// Example 10(c): Correct (finally!) // auto_ptr f() { auto_ptr result = new String; *result = "some value"; cout << "some output"; return result; // rely on transfer of ownership; // this can't throw }

�q�里是一个技巧，当我们有效隐藏所有的工作来构造第二个功能�Q�返回��|��当确保它可以被安全返回给调用者�ƈ且在�W�一个功能（打印消息�Q�完成的时候没有抛出操作。我们知道一旦cout完成�Q�返回值将成功交到调用者手中，�q�且无论如何都会正确清理�Q�如果调用者接受返回��|��调用者将得到�q�个拯��的auto_ptr临时对象的所有权�Q�如果调用者没有接受返回��|��也就是忽略返回��|��分配的String��在临时auto_ptr被销毁的时候自动清理。这�U�安全扩展的代�h呢？��像我们�l�常实现的强异常安全一��P��强安全通常消耗一些效率（通常比较��）——这里指额外的动态内存分配。但是当我们在效率和正确性之间做出选择的话�Q�我们通常会选择后者！

让我们养成在日常工作中��用auto_ptr的习惯。auto_ptr解决了常见的问题�Q��ƈ且能够��你的代码变得更安全和健壮�Q�特别是它可以防止内存泄漏以及确保强安全。因为它是标准的�Q�因此它在不同类库和�q�_��之间是可�U�L��的，因此无论你在哪里使用它，它都��是对的�?

致谢

This article is drawn from material in the new book Exceptional C++: 47 engineering puzzles, programming problems, and exception-safety solutions by Herb Sutter, © 2000 Addison Wesley Longman Inc., which contains further detailed treatments of points touched on briefly in this article, including exception safety, the Pimpl (compiler-firewall) Idiom, optimization, const-correctness, namespaces, and other C++ design and programming topics.

注释

Pimpl风格可以有效减少��目构徏旉��Q�因为它在C�U�有部分改变的时候，��L��客户代码引�v�q�泛的重新编译。更多关于Pimpl风格以及如何部��v�~�译器墙�Q�参考这�?a href="xc++.htm">Exceptional C++的条��?6�?0。（Addison-Wesley, 2000�Q?

See the article originally published in C++ Report and available on the Effective C++ CD (Scott Meyers, Addison-Wesley, 1999) and Items 8 to 19 in Exceptional C++ (Herb Sutter, Addison-Wesley, 2000).

volnet 2010-04-07 19:08 发表评论

[转]从C++的Return Value Optimization (RVO)到C#的value type

volnet — Tue, 06 Apr 2010 11:42:00 GMT

先看一�D늮�单的C++代码�Q?
Type get(int I){ return Type(i); } Type t = get(1);

�q�里�Q?我们从C++的基本语义看上去�Q?应该是Type(i) 调用一�ơ拷贝构造函敎ͼ� 在堆栈中生成一个��时对象；然后�Q�用该对象构造返回对象；然后对这个��时对象调用析构函敎ͼ�在调用者方�Q?用返回的临时对象调用拯��构造函��C��初始化对象t, �q�回对象的析构函数在�q�之后，函数�q�回之前调用�?
所以， Type t = get(i); 应该有三个拷贝构造函数和两个析构函数的调�?
可是�Q?�q�有一�U�说法是�Q?�~�译器可能会对这两个临时对象�q�行优化�Q�最�l�的优化�l�果会是只有一�ơ的构造函数。因为很明显地可以看刎ͼ� �q�里我们其实只是要用一个整数构造一个Type对象�?
�? ��g��很有道理�Q?
那么�Q?哪一�U�说法对呢？没有调查��没有发�a�权，于是本�h用VC++6.0做了实验�?放了些cout<<�?.在拷贝构造函数里�Q�观察打印的�l�果�Q?�l�果却是跟我的simple, naïve的预��一致。三个拷贝构造函敎ͼ� 两个析构函数�?
“你个弱智编译器�Q�脑袋进水了吧？�?忘了�~�译器没脑袋�?“很明显在这个例子里我的两个临时对象都没有用的啊�Q��?
于是�Q�上�|�，查资料， google一下吧�Q?
下面是我查到的一些结果：
其实�Q?�q�种对��g��递的优化的研�IӞ�� q�不只局限于�q�回倹{��对下面�q�个例子�Q?
void f(T t) { } void main(void){ T t1; f(t1); }

也有�q�种考虑�?
f(T)是按��g��递的。语义上应该做一个复�Ӟ�� 使得函数内部对T的改变不会媄响到原来的t1.
但是�Q�因为在调用f(t1)之后�Q?我们没有再��用t1(除了一个隐含的destructor调用)�Q�是否可能把复制优化掉，直接使用t1呢？�q�样可以节省掉一个拷贝构造函数和一个析构函数�?
可是�Q?不论是对�q�回值的优化�Q?�q�是对上面这�U�局部对象的优化�Q�在1995�q�的C++新标准草案出台前都是为标准所严格限制�?(虽然有些�~�译器�ƈ没有遵行�q�个标准�Q?�q�是支持了这�U�“优化�?
那么�Q?�q�又是�ؓ什么呢�Q?
�q�里面涉及到一个普遍的对side-effect的担忧�?
什么又是side-effect呢？
所谓side-effect��是一个函数的调用与否能够对系�l�的状态造成区别�?
int add(int i, int j){ return i+j; }��是没有side-effect的，�?
void set(int* p, int I, int v){ p[I]=v; }��是有side-effect的。因为它改变了一个数�l�元素的��|�� 而这个数�l�元素在函数外是可见的�?
通常意义上来��_�� 所有的优化应该在不影响�E�序的可观察行�ؓ的基��上进行的。否则，快则快了�Q?�l�果却和所惌��的完全不同！
而C++的拷贝构造函数和析构函数又很多都是有side-effect的。如果我们的“优化”去掉了一个有side-effect的拷贝构造函数和一个析构函敎ͼ� �q�个“优化”就有可能改变程序的可观察行为。（注意�Q?我这里说的是“可能”，因�ؓ“负负得正”，两个有side-effect的函数的调用�Q?在不考虑�q�行�q�行的情况下�Q?也许反而不会媄响程序的可观察行为。不�q�， �q�种塞翁失马的事儿， �~�译器就很难判断了）
��Z��q�种忧虑, 1995�q�以前的标准�Q?明确��止对含有side-effect的拷贝构造函数和析构函数的优化。同�Ӟ�� q�有一些对C++扩充的提议，考虑让程序员自己对类�q�行允许优化的声明�?�E�序员可以明��地告诉�~�译器：不错�Q?我这个拷贝构造函敎ͼ� 析构函数是有side-effect, 但你别管�Q?��管优化�Q?��Z��事有我呢�Q?
哎， side-effect真是一个让人又恨又��q��东西�Q�它使编译器的优化变得困难；加大了程序维护和调试的难度。因�?functional language 把side-effect当作�z�水猛兽一��P��q�脆��止。但同时�Q�我们又很难��d��side-effect. 不说�E�序员们更习惯于imperative 的编�E�方�? 象数据库操作�Q�IO操作都天然就是side-effect.
不过�Q�个��是认为C++标准对“优化”的保守态度是有道理的。无论如何，让“优化”可以潜在地偷偷地改变程序的行�ؓ��L��让�h惌��v来就不舒服的�?
但是�Q?矛盾是对立统一的。（惛_��q�俺马列可得了八十多分呢�Q��?对这�U�aggressive的“优化”的呼声是一��高�q�一��?以Stan Lippeman为首的一��撮��固分子�Ҏ��准的颠覆和和�q�x��变的阴谋从来��没有停止过�?�q�不�Q�在1996�q�的一个风雨交加的夜晚�Q?一个阴险的C++新标准草案出炉了。在�q�个草案里，加入了一个名为RVO (Return Value Optimization) 的放宽对优化的限�Ӟ�� 妄图走资本主义道路， �l�资本家张目的提案。其具体内容��是��_��允许�~�译器对命名�q�的局部对象的�q�回�q�行优化�Q?即��拯��构造函�?析构函数有side-effect也在所不惜。这个提议背后所隐藏的思想��是�Q��ؓ了提高效率，宁可冒改变程序行为的风险。宁要资本主义的苗，不要�C�会��M��的草了！
我想�Q?�q�样的一个罪大恶极的提案竟会被提交，应该是因为C++的值拷贝的语义的效率实在太“妈妈的”了�?当你写一�?Complex operator+(const Complex& c1, const Complex& c2);的时候，竟需要调用好几次拯��构造函数和析构函数�Q�同志们�Q�（沉痛圎ͼ� 语重心长圎ͼ��C�会��M��的生产关�pȝ��优越性怎么体现啊？
接下来，当我想Google C++最新的标准�Q?看RVO是否被最�l�采�U�x��Q?却什么也找不��C��?到ANSI的网站上去，居然要付钱才能DOWNLOAD文档�?“老子在城里下馆子都不付钱�Q?down你几个烂文档�q�要�l�钱�Q�！�?
故事没有�l�局�Q?实在是不爽�?也不知是不是因�ؓ标准�q�没有敲定，所以VC++6 ��没有优化， �q�是VC�Ҏ��没完全遵守标准�?
不过�Q�有一�Ҏ��肯定的�?当写�E�序的时候，最好不要依赖于RVO (有�h�Q?象Stan Lippeman, 又叫它NRV优化)�?因�ؓ�Q?不论�Ҏ��准的争论是否已经有了�l�果�Q?实际上各个编译器的实��C��q�是各自为政�Q?没有�l�一�?一个叫SCOtt Meyers的家�?忘了是卖什么的�?��p��Q?如果你的�E�序依赖于RVO, 最好去掉这�U�依赖。也��是��_�� 不管RVO到底标准不标准，你还是不能用�?不仅不能用， �q�得时刻警惕着RVO可能带来的程序行��Z��的变化�?�Q�也不知�q�帮家伙瞎忙了半天到底�ؓ啥！�Q?
说到�q�里�Q?倒想起了C#里一个困惑了我很久的问题。记得读C#的specification的时候，非常不解��Z��么C#不允许给value type 定义析构函数�?
�q�里�Q?先简略介�l�一下C#里的value type (原始数据�c�d��Q?struct �c�d��)�?
在C#里的value_type��p��是��|�� 永远只能copy, 取倹{��因此，它永�q�是in-place的。如果你把一个value type的数据放在一个对象里�Q�它的生命期��和那个对象相同�Q�如果你声明一个value type 的变量在函数中，它的生命期就在lexical scope里�?
{
The_ValueType value;
}//value 到这里就死菜�?
啊呀呀�Q?�q�不正是我们怀�늚�C++的stack object吗？
在C++里，Auto_ptr, shared_ptr, 容器们，不都是利用析构函数来��理资源的吗�Q?
C#�Q�Java 虽然利用garbage collection技术来攉��无用对象�Q?使我们不用再担心内存的回收�?但garbage collection�q�不保证无用对象一定被攉��Q?�q�不保证Dispose()函数一定被调用�Q?更不保证一个对象什么时候被回收�?所以对一些非内存的资源，象数据库�q�接�Q?�|�络�q�接�Q?我们�q�是希望能有一个类��g��smart pointer的东西来帮我们管理啊。（try-finally 虽然可以用，但因为它影响到lexical scope, 有时用�v来不那么方便�Q?
于是�Q?我对C#的取消value type的析构函数充满了深厚的阶�U�仇恨�?
不过�Q?现在��x��Q?C#的这�U�设计一定是惩于C++��p�|的教训：
   1. value type 没有拯��构造函数。C#只做�~�省copy, 没有side-effect
   2. value type 不准有析构函数。C#有garbage collection, 析构函数的唯一用途只会是做一些side-effect象关闭数据库�q�接�?所以取消了析构函数�Q?��取消了value type的side-effect.
   3. 没有了side-effect, �pȝ��可以��L��地做优化�?
对以下程序：
The_Valuetype get(int I){return The_Valuetype(i);}
The_Valuetype t = get(1);
在C#里我们可以快乐地��_��只调用了一�ơ构造函数�?再没有side-effect的沙漠，再没有难以优化的荒原�Q?smart pointer望而却步，效率之花处处开遍�?I have a dream, …�?/p>
转蝲自：http://gugu99.itpub.net/post/34143/466008

volnet 2010-04-06 19:42 发表评论

模板�c�d��推断的一个小问题

volnet — Sun, 04 Apr 2010 16:28:00 GMT

/* * type_infer_in_const_char_array.cpp * * Created on: 2010-4-4 * Author: volnet * Ref: http://topic.csdn.net/u/20100403/16/aebc3e87-ae49-4a18-ba0b-263348b512e3.html * ShortRef: http://is.gd/be914 */ #include #include #ifdef _MSC_VER #include #else #include #endif template <typename T> int compare(const T &v1, const T &v2) { std::cout << "invoking compare ..." << std::endl; if(v1return -1; if(v2return 1; return 0; } int main() { //error: // no matching function for call to `compare(const char[3], const char[6])' // compare("hi","world"); compare<const char*>("hi","world"); //what's the real type about "abcd"? // const char * or const char [n] ? std::cout << typeid("hi").name() << std::endl; // char const [3] std::cout << typeid("world").name() << std::endl; // char const [6] std::cout << typeid("dlrow").name() << std::endl; // char const [6] // the compiler infer the typename T is char const [6] compare("world", "dlrow"); }

volnet 2010-04-05 00:28 发表评论

volnet — Sun, 04 Apr 2010 15:08:00 GMT

首先我们面��的挑战是�Q�声明堆中的数据需要我们用new关键字，直到我们昄��调用了delete之后�Q�它们才会被�U�除�Q�但问题是，我们什么时候应该移除？如果调用语句在上下行中，我们自然知道如何�U�除。我们知道如果对象声明在堆中�Q�那么在它离开它的作用域中的时候，可以自动释放�Q�如果我们能够用栈对象来��理堆对象，在栈对象自动释放的时候，释放堆对象，��׃��需要显式调用delete语句了：
于是��有了下面的做法�Q�应该不隄��解：
template<class T> class smart_ptr { public: smart_ptr(T* t = 0) { real_ptr = t; } ~smart_ptr() { delete real_ptr; } T* operator ->() const { return real_ptr; } T& operator *() const { return *real_ptr; } private: T* real_ptr; };

我们希望我们的智能指针能够像指针一样地工作�Q�但下面的工作方式似乎存在问题：
在普通的dumb指针中，以下行�ؓ是正��的�Q?pre class="gc-code">void letUsGo(BaseClass* objPtr); DerivedClass* derivedObjPtr2 = new DerivedClass(); letUsGo(derivedObjPtr2); delete derivedObjPtr2;
但是�Q�以下代码呢�Q?pre class="gc-code">void letUsSmartGo(const smart_ptr& objPtr); smart_ptr smartDerivedObjPtr2(new DerivedClass()); // the smart_ptr is not inherited from the smart_ptr // the compiler can't find the class to cast it, so it must cause the error. letUsSmartGo(smartDerivedObjPtr2);
下面的过�E�描�q�C��q�个变化所需要的一些支持：
1、error C2664: “letUsSmartGo�? 不能��参�?1 从“smart_ptr”�{换�ؓ“const smart_ptr &�?br>2、smartDerivedObjPtr2的类型：
    smart_ptr smartDerivedObjPtr2(new DerivedClass());
3、letUsSmartGo的声明：
    void letUsSmartGo(const smart_ptr&);
4、问题�{化�ؓ�Q�如何从smart_ptr到const smart_ptr&的�{变�?br>5、针对letUsSmartGo的声明，可以有的实参�c�d��包括�Q?br>    const smart_ptr
    smart_ptr
    假设存在以下�c�d�� smart_derived_ptr : smart_ptr�Q�那么smart_derived_ptr也是可以被传递的�?br>6、这里存在这样一个问题：
    new DerivedClass() 被传递给smartDerivedObjPtr2之后�Q�smartDerivedObjPtr2��拥有了它的指针。如果从smartDerivedObjPtr2隐式转换成另一个smart_ptr后，我们需要解决的��是��smartDerivedObjPtr2所拥有的指针传递给smart_ptr�q�将smartDerivedObjPtr2的内部指针清�Ӟ��q�样��׃��会在smartDerivedObjPtr2被销毁的时候，因�ؓ调用delete real_ptr�Q�而它的新拯��在离开作用域的时候，一样会再次调用delete real_ptr�Q�而此时real_ptr指向的对象已�l�被释放�Q�因此这��L��行�ؓ是未定义的。）
7、因此，定义如下�Ҏ��卛_��Q?pre class="gc-code">template<class T> class smart_ptr { public: smart_ptr(T* t = 0) { std::cout << "creating smart_ptr ...smart_ptr(T* t = 0)" << std::endl; real_ptr = t; } template<class U> smart_ptr(smart_ptr& rhs) : real_ptr(rhs.real_ptr){ std::cout << "creating smart_ptr ...smart_ptr(smart_ptr& rhs)" << std::endl; rhs.real_ptr = 0; } ~smart_ptr() { std::cout << "destoring smart_ptr ..." << std::endl; delete real_ptr; } T* operator ->() const { return real_ptr; } T& operator *() const { return *real_ptr; } T* real_ptr; };
8、但是这里real_ptr按照习惯应该是一个私有成员，而且我们在完成该�Ҏ��时候，希望能够实现一�U�所谓的所有权转移�Q�也��是��内部的指针传递给另一个智能指针，而这应该是一个原子过�E�。因此，我们实现以下�Ҏ��Q?/p>
template<class T> class smart_ptr { public: smart_ptr(T* t = 0) { std::cout << "creating smart_ptr ...smart_ptr(T* t = 0)" << std::endl; real_ptr = t; } template<class U> smart_ptr(smart_ptr& rhs) : real_ptr(rhs.release()){ std::cout << "creating smart_ptr ...smart_ptr(smart_ptr& rhs)" << std::endl; } ~smart_ptr() { std::cout << "destoring smart_ptr ..." << std::endl; delete real_ptr; } T* operator ->() const { return real_ptr; } T& operator *() const { return *real_ptr; } // helper T* release() { T* tmp = real_ptr; real_ptr = 0; return tmp; } private: T* real_ptr; };

volnet 2010-04-04 23:08 发表评论

volnet — Thu, 01 Apr 2010 10:02:00 GMT

1、设�|�“生成时启用C/C++代码分析”�ؓ“是”，如果不设�|�此��，�E�序速度��出乎你的意料…�?/p>

2、点几Z��分析�?>“启动性能向导�?/p>

3、在“性能资源��理器”中右键新徏的性能报告节点�Q�右键“启动�ƈ启用分析功能”�?/p>

虽然此处有“启用分析功能”，但如果在配置里面没有�q�行讄��Q�第一�ơ的��试报告�l�果��是不准��的�?/p>
4、选择两个性能报告�Q�ctrl+鼠标�Q�，右键“比较性能报告”�?/p>

用性能报告��有助于提高�E�序的性能�Q��ƈ且快速定位问题所在，剩下的结果就是你自己需要多观察�Q�分析性能报告所反映的问题了�?br>

更多

VC++ 6.0详见�q�里>> http://neural.cs.nthu.edu.tw/jang/mir/technicalDocument/vc6_profile/index.htm

�W�三方工�?gt;> http://www.semdesigns.com/Products/Profilers/CppProfiler.html

volnet 2010-04-01 18:02 发表评论

volnet — Tue, 30 Mar 2010 09:17:00 GMT
�q�不是一��向��|��全面的向��D��?a href="http://www.boost.org/doc/libs/1_42_0/more/getting_started/unix- variants.html">�q�里�Q�http://goo.gl/XcAf�Q��?br>�q�仅是一��笔记。这里用bjam方式�q�行�~�译�?br>
下蝲boost。（http://cdnetworks-kr-1.dl.sourceforge.net/project/boost/boost/1.42.0/boost_1_42_0.tar.bz2�Q?/li>
解压到指定文件夹�Q�我是将它解压到根目录下的一个sourcecode文�g夹下�?div class="console">   /home/volnet/sourcecode/boost_1_42_0
启动�l�端�Q�ctrl+f2,输入“gnome-terminal”�Q�。生成bjam脚本�?div class="console">   ./bootstrap.sh --prefix=/home/volnet/sourcecode/boost_install如果不带--prefix参数的话�Q?b>推荐�Q�，默认的�\径是/usr/local/include�?usr/local/lib
   ./bootstrap.sh
使用--help参数可以查看帮助�Q�用-h可以查看��要帮助�?div class="console">   ./bootstrap.sh --help生成脚本bjam�Q�已�l�存在的脚本��被自动备䆾�?pre class="console">volnet@Ubuntu:~/sourcecode/boost_1_42_0$ ./bootstrap.sh --prefix=/home/volnet/sourcecode/boost_install/
Building Boost.Jam with toolset gcc... tools/jam/src/bin.linuxx86/bjam
Detecting Python version... 2.6
Detecting Python root... /usr
Unicode/ICU support for Boost.Regex?... /usr
Backing up existing Boost.Build configuration in project-config.jam.4
Generating Boost.Build configuration in project-config.jam...

Bootstrapping is done. To build, run:

    ./bjam

To adjust configuration, edit 'project-config.jam'.
Further information:

   - Command line help:
     ./bjam --help

   - Getting started guide:
     http://www.boost.org/more/getting_started/unix-variants.html

   - Boost.Build documentation:
     http://www.boost.org/boost-build2/doc/html/index.html

然后��是利用生成的bjam脚本�~�译源码了�?br>
volnet@Ubuntu:~/sourcecode/boost_1_42_0$ sudo ./bjam -a -sHAVE_ICU=1 installNote: Building Boost.Regex with Unicode/ICU support enabled    Using ICU in /usr/include
./是unix-like�pȝ��执行文�g的前�~��Q�这里就是指要执行bjam文�g�?/li>
-a是参敎ͼ�代表重新�~�译�Q�Rebuild�Q�。输�?/bjam -h获得更多帮助�?/li>
-sHAVE_ICU=1�Q�代表支持Unicode/ICU�?a >点击�q�里�Q�http://goo.gl/ySEe�Q?/a>
前提�Q�系�l�内需要安装有libicu-dev�Q�可以在�l�端输入�Q?br>
sudo apt-get install libicu-dev
install�Q�表�C�安�?/li>
--clean�Q�表�C�清理。当前语句中包含-a�Q�则不需要先手动清理�Q�否则需要先�q�行
./bjam --clean
如果你执行上一步，会出现诸如：mpi的问题，多半是本机没有安装mpi。根据系�l�提�C�，你可以找到有/home/volnet/sourcecode/boost_1_42_0/tools/build/v2/user-config.jam。在文�g最后跟�?div class="console">using mpi ;卛_��。然后如果还是有mpi问题�Q�说明本机没有安装mpi�?div class="console">sudo apt-get install mpi-default-dev

界此应该��利通过�~�译了。�ƈ�?usr/local/lib下有了boost的库了�?br>下面讨论一下链接静态链接库在Eclipse里的问题�?br>�?a >Unix variants向导里，官方提供了一个��用正则表辑ּ�的程序�?br>在Eclipse里，新增c++ project�Q��ƈ使用Linux C++�~�译器。将代码拯��到文件中�Q?br>因�ؓ要静态链接到正则表达式的库，所以如下图所�C�，讄��对应�?.a文�g路径到eclipse�Q�以佉K��接器能够扑ֈ�它�?br>

�~�译通过�Q?br>��Z��我们的程序能够正��蝲入，我们需要让我们的程序在我们的系�l�范围内也能够找到我们的库。这时候我们需要在讄��一下。详�?a >�q�部�?/a>的相关介�l��?br>��试�E�序�Q?br>
volnet@Ubuntu:~/workspace/boost_get_started/Debug$ ./boost_get_started < test
Will Success Spoil Rock Hunter?
�q�里test是一个文件�?br>

volnet 2010-03-30 17:17 发表评论

单参数构造函数的问题�Q�single-argument construct

volnet — Mon, 29 Mar 2010 07:37:00 GMT

关于单一参数构造函数的问题�Q�主要是因�ؓ单一参数被编译器用作隐式�c�d��转换�Q�从而导致一些不可预期的事�g的发生，请参见代码详�l�注释：
/* * single_argument_ctor.cpp * * Created on: 2010-3-29 * Author: Volnet * Compiler: GNU C++(version 3.4.5) * MSVC CL(version 15.00.30729.01) */ #include #include #include // single-argument class class SingleArgumentClass { private: int _inner; public: SingleArgumentClass() :_inner(-1) { } SingleArgumentClass(int actual) :_inner(actual) { } bool operator==(const SingleArgumentClass& rhs); std::string str(){ // we'd better to use boost::lexical_cast to cast. // #region cast std::stringstream strStream; strStream << _inner; std::string str; strStream >> str; // #endregion return str; } }; bool SingleArgumentClass::operator ==(const SingleArgumentClass& rhs){ if(_inner == rhs._inner) return true; return false; } // single-argument class fixed bug by explicit keyword. class SingleArgumentClassFixedBugByExplicitKeyword { private: int _inner; public: SingleArgumentClassFixedBugByExplicitKeyword() :_inner(-1) { } explicit SingleArgumentClassFixedBugByExplicitKeyword(int actual) :_inner(actual) { } bool operator==(const SingleArgumentClassFixedBugByExplicitKeyword& rhs); std::string str(){ // we'd better to use boost::lexical_cast to cast. // #region cast std::stringstream strStream; strStream << _inner; std::string str; strStream >> str; // #endregion return str; } }; bool SingleArgumentClassFixedBugByExplicitKeyword::operator ==(const SingleArgumentClassFixedBugByExplicitKeyword& rhs){ if(_inner == rhs._inner) return true; return false; } // single-argument class fixed bug by helper class. class ActualType { public: ActualType(int value):_value(value){}; int get_value(){ return _value; } private: int _value; }; class SingleArgumentClassFixedBugByHelperClass { private: int _inner; public: SingleArgumentClassFixedBugByHelperClass() :_inner(-1) { } SingleArgumentClassFixedBugByHelperClass(ActualType actual) :_inner(actual.get_value()) { } bool operator==(const SingleArgumentClassFixedBugByHelperClass& rhs); std::string str(){ // we'd better to use boost::lexical_cast to cast. // #region cast std::stringstream strStream; strStream << _inner; std::string str; strStream >> str; // #endregion return str; } }; bool SingleArgumentClassFixedBugByHelperClass::operator ==(const SingleArgumentClassFixedBugByHelperClass& rhs){ if(_inner == rhs._inner) return true; return false; } void Assert(bool status, std::string strTrue = std::string("assert result is true;"), std::string strFalse = std::string("assert result is false;")); int main(void){ SingleArgumentClass obj(3); std::cout << obj.str() << std::endl; // our purpose. SingleArgumentClass obj1(1); SingleArgumentClass obj2(1); Assert(obj1 == obj2, "obj1 == obj2", "obj1 != obj2"); int i = 3; // warning!!! // obj is a SingleArgumentClass object. // i is a integer. // operator== only define the equal between two SingleArgumentClass object. // In fact: // obj == i: // 1.compiler found the operator== require two SingleArgumentClass object. // 2.compiler try to find a cast method for casting int to SingleArgumentClass. // 3.compiler found it can use the SingleArguementClass.Ctor(int) // to create a new SingleArgumentClass. // 4.compiler try to create a new SingleArgumentClass object from i. // 5.so it without any warning and error, but it's logical not we need. Assert(obj == i, "obj == i //right?", "obj != i"); // Assert(i == obj); // Compile ERROR: no match for 'operator==' in 'i == obj' // it's may encounter a compile-time error. // GNU G++: no match for 'operator==' in 'objFixed == i' single_argument_ctor.cpp single_argument_ctor/src 106 C/C++ Problem // MSVC: 错误 1 error C2679: 二进制�?=�? 没有扑ֈ�接受“int”类型的��x��作数的运��符(或没有可接受的�{�? {projectpath}\single_argument_ctor\src\single_argument_ctor.cpp 107 single_argument_ctor SingleArgumentClassFixedBugByExplicitKeyword objFixed(3); // Assert(objFixed == i, "objFixed == i", "objFixed != i"); SingleArgumentClassFixedBugByHelperClass objFixedByHelper1(3); SingleArgumentClassFixedBugByHelperClass objFixedByHelper2(3); // it's may encounter a compile-time error. // GNU G++: no match for 'operator==' in 'objFixedAuto1 == i' single_argument_ctor.cpp single_argument_ctor/src 158 C/C++ Problem // MSVC: 错误 1 error C2679: 二进制�?=�? 没有扑ֈ�接受“int”类型的��x��作数的运��符(或没有可接受的�{�? {projectpath}\single_argument_ctor\src\single_argument_ctor.cpp 163 single_argument_ctor // Assert(objFixedByHelper1 == i); } void Assert(bool status, std::string strTrue, std::string strFalse) { std::cout << (status strTrue : strFalse) << std::endl; }

解决�Ҏ��Q?/p>
1、explicit关键字，在单参数构造函数前使用explicit参数�Q�可以避免单参数构造函数被用于隐式转换�?/p>
2、利用中间类的方式，详见代码“SingleArgumentClassFixedBugByHelperClass相关部分”。如果编译器不支持解��x��?�Q�则��使用此方法。上面代码所提及的两�ƾ主��编译器均支持explicit关键字�?/p>

volnet 2010-03-29 15:37 发表评论

[C++]namespace&using keyword

volnet — Mon, 29 Mar 2010 05:28:00 GMT

有时候我们可以用namespace来组�l�命名空间�?/p>
有时候我们又希望��一些较深层�ơ的�c�d��成我们比较容易访问的对象�?/p>
下面的代码提供了一�U�简单的�C�Z��来满��L��需求�?/p>
1、用namespace来组�l�各个类的层�U�关�p�R�?/p>
2、用using关键字，��深层次�l�构暴露到较外层�?/p>
//============================================================================ // Name : namespace.cpp // Author : Volnet // Version : // Copyright : reserve by volnet@tom.com // Description : namespace in C++, Ansi-style //============================================================================ #include namespace volnet { namespace extensions { class _Console { public: void WriteLine(std::string); }; } using extensions::_Console; } using namespace volnet; _Console Console; void _Console::WriteLine(std::string s) { std::cout << s << std::endl; } using namespace std; int main() { Console.WriteLine(std::string("I'm volnet!")); return 0; }

volnet 2010-03-29 13:28 发表评论

boost::tuple

volnet — Thu, 25 Mar 2010 09:46:00 GMT

boost::tuple<derived> tup4; boost::tuple<base> tup5; tup5 = tup4; tup4.get<0>().test(); tup5.get<0>().test(); // 丢失多态�?br> derived d; boost::tuple<derived*> tup6(&d); boost::tuple<base*> tup7; tup7 = tup6; tup6.get<0>()->test(); tup7.get<0>()->test(); // 恢复多态性（�Ҏ��1�Q? boost::tuple<derived&> tup8(d); boost::tuple<base&> tup9(tup8);
// tup9 = tup8; 不能使用该方法，因�ؓ无法对引用赋倹{�? tup8.get<0>().test(); tup9.get<0>().test(); // 恢复多态性（�Ҏ��2�Q?/span>
/* * tuple.cpp * * Created on: 2010-3-25 * Author: GoCool */ #include #include #include #include #include "../header/baseClass.h" using namespace std; class X { X(); public: X(std::string){} }; class Y { Y(const Y&); public: Y(){} }; class A { }; bool operator==(A, A) { std::cout << "All the same to me..."; return true; } void f(int i); void cut_off_rule(void); int main(void){ // add a new tuple boost::tuple<int,double,std::string> triple(42, 3.14, "My first tuple!"); int a = triple.get<0>(); ++a; cout << a << endl; cout << triple << endl; cut_off_rule(); boost::tuple<int, double> pair = boost::make_tuple(21, 22.5); cout << pair << endl; cut_off_rule(); int pair_element_1 = -1; double pair_element_2 = -1; boost::tie(pair_element_1, pair_element_2) = pair; cout << pair_element_1 << "," << pair_element_2 << endl; cut_off_rule(); boost::tuple<int,std::string,derived> tup1(-5,"Tuples"); boost::tuple<unsigned int,std::string,base> tup2; tup2=tup1; tup2.get<2>().test(); std::cout << "Interesting value: " << tup2.get<0>() << '\n'; const boost::tuple<double,std::string,base> tup3(tup2); // Description Resource Path Location Type // assignment of read-only location tuple.cpp boost_tuple/src 45 C/C++ Problem // tup3.get<0>()=3.14; cut_off_rule(); boost::tuple<X,X,X> obj = boost::tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")); // ok cut_off_rule(); double dNum = 5; boost::tuple<double&> numTuple(dNum); // ok // boost::tuple(dNum+3.14); // error: cannot initialize // non-const reference with a temporary boost::tuple<const double&>(dNum+3.14); // ok, but dangerous: // the element becomes a dangling reference cut_off_rule(); // char arr[2] = {'a', 'b'}; // boost::tuple(arr); // error, arrays can not be copied // boost::tuple(arr, Y()); // error, neither arrays nor Y can be copied boost::tuple<char[2], Y>(); // ok cut_off_rule(); boost::tuple<void (*)(int)> pFTuple1 = boost::make_tuple(&f); pFTuple1.get<0>()(10); boost::tuple<void (*)(int)> pFTuple2 = boost::make_tuple(boost::ref(f)); pFTuple2.get<0>()(20); boost::tuple<void (&)(int)> pFTuple3(f); pFTuple3.get<0>()(30); boost::tupletuple<void (&)(int)> > pFTuple4(f); pFTuple4.get<0>().get<0>()(40); cut_off_rule(); // boost::tuple stdPairToTuple = std::make_pair(1, 'a'); cut_off_rule(); boost::tuplestring, int, A> t1(std::string("same?"), 2, A()); boost::tuplestring, long> t2(std::string("same?"), 2); boost::tuplestring, long> t3(std::string("different"), 3); // t1 == t2; // true cut_off_rule(); int i; char c; boost::tie(i, c) = std::make_pair(1, 'a'); cout << i << " " << c << endl; cut_off_rule(); boost::tie(boost::tuples::ignore, c) = std::make_pair(1, 'a'); cout << c << endl; cut_off_rule(); int myX = -1; double myY = -2; boost::tuple<int, double> f2(2); boost::tie(myX, myY) = f2; // #2 cout << "myX = " << myX << ", myY = " <void cut_off_rule(void) { cout << "-----------------------------------" << endl; } void f(int i) { cout << "f(" << i << ")" << endl; }

tuple是boost库中一个类似标准std::pair库库�Q�但pair只能支持两种元素�Q�而tuple则可以支持大于两�U�的�?/p>
更多详解�Q?a title="http://www.boost.org/doc/libs/1_42_0/libs/tuple/doc/tuple_users_guide.html" >http://www.boost.org/doc/libs/1_42_0/libs/tuple/doc/tuple_users_guide.html

以下内容直接引自原文�Q?/p>

Boost C++ Libraries

�?..one of the most highly regarded and expertly designed C++ library projects in the world.�?�?Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Welcome
Introduction
Community
Development
Support
Documentation
Index

The Boost Tuple Library

A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples, quadruples etc. are tuples. In a programming language, a tuple is a data object containing other objects as elements. These element objects may be of different types.
Tuples are convenient in many circumstances. For instance, tuples make it easy to define functions that return more than one value.
Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. Unfortunately C++ does not. To compensate for this "deficiency", the Boost Tuple Library implements a tuple construct using templates.
Table of Contents

Using the library
Tuple types
Constructing tuples
Accessing tuple elements
Copy construction and tuple assignment
Relational operators
Tiers
Streaming
Performance
Portability
Acknowledgements
References

More details

Advanced features (describes some metafunctions etc.).
Rationale behind some design/implementation decisions.
Using the library

To use the library, just include:
#include "boost/tuple/tuple.hpp"

Comparison operators can be included with:
#include "boost/tuple/tuple_comparison.hpp"

To use tuple input and output operators,
#include "boost/tuple/tuple_io.hpp"

Both tuple_io.hpp and tuple_comparison.hpp include tuple.hpp.
All definitions are in namespace ::boost::tuples, but the most common names are lifted to namespace ::boost with using declarations. These names are: tuple, make_tuple, tie and get. Further, ref and cref are defined directly under the ::boost namespace.
Tuple types

A tuple type is an instantiation of the tuple template. The template parameters specify the types of the tuple elements. The current version supports tuples with 0-10 elements. If necessary, the upper limit can be increased up to, say, a few dozen elements. The data element can be any C++ type. Note that void and plain function types are valid C++ types, but objects of such types cannot exist. Hence, if a tuple type contains such types as elements, the tuple type can exist, but not an object of that type. There are natural limitations for element types that cannot be copied, or that are not default constructible (see 'Constructing tuples' below).
For example, the following definitions are valid tuple instantiations (A, B and C are some user defined classes):
tuple tuple tuple tuple > tuple, bool, void*>

Constructing tuples

The tuple constructor takes the tuple elements as arguments. For an n-element tuple, the constructor can be invoked with k arguments, where 0 <= k <= n. For example:
tuple() tuple(1) tuple(1, 3.14)

If no initial value for an element is provided, it is default initialized (and hence must be default initializable). For example.
class X { X(); public: X(std::string); }; tuple() // error: no default constructor for X tuple(string("Jaba"), string("Daba"), string("Duu")) // ok

In particular, reference types do not have a default initialization:
tuple() // error: reference must be // initialized explicitly double d = 5; tuple(d) // ok tuple(d+3.14) // error: cannot initialize // non-const reference with a temporary tuple(d+3.14) // ok, but dangerous: // the element becomes a dangling reference

Using an initial value for an element that cannot be copied, is a compile time error:
class Y { Y(const Y&); public: Y(); }; char a[10]; tuple(a, Y()); // error, neither arrays nor Y can be copied tuple(); // ok

Note particularly that the following is perfectly ok:
Y y; tuple(a, y);

It is possible to come up with a tuple type that cannot be constructed. This occurs if an element that cannot be initialized has a lower index than an element that requires initialization. For example: tuple.
In sum, the tuple construction is semantically just a group of individual elementary constructions.
The make_tuple function

Tuples can also be constructed using the make_tuple (cf. std::make_pair) helper functions. This makes the construction more convenient, saving the programmer from explicitly specifying the element types:
tuple add_multiply_divide(int a, int b) { return make_tuple(a+b, a*b, double(a)/double(b)); }

By default, the element types are deduced to the plain non-reference types. E.g.:
void foo(const A& a, B& b) { ... make_tuple(a, b);

The make_tuple invocation results in a tuple of type tuple.
Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. Therefore, the programmer can control the type deduction and state that a reference to const or reference to non-const type should be used as the element type instead. This is accomplished with two helper template functions: ref and cref. Any argument can be wrapped with these functions to get the desired type. The mechanism does not compromise const correctness since a const object wrapped with ref results in a tuple element with const reference type (see the fifth example below). For example:
A a; B b; const A ca = a; make_tuple(cref(a), b); // creates tuple make_tuple(ref(a), b); // creates tuple make_tuple(ref(a), cref(b)); // creates tuple make_tuple(cref(ca)); // creates tuple make_tuple(ref(ca)); // creates tuple

Array arguments to make_tuple functions are deduced to reference to const types by default; there is no need to wrap them with cref. For example:
make_tuple("Donald", "Daisy");

This creates an object of type tuple (note that the type of a string literal is an array of const characters, not const char*). However, to get make_tuple to create a tuple with an element of a non-const array type one must use the ref wrapper.
Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. A tuple can also hold a reference to a function, but such a tuple cannot be constructed with make_tuple (a const qualified function type would result, which is illegal):
void f(int i); ... make_tuple(&f); // tuple ... volnet: boost::tuple pFTuple3(f); pFTuple3.get<0>()(30); tuple > a(f) // ok make_tuple(f); // not ok

Accessing tuple elements

Tuple elements are accessed with the expression:
t.get()

or
get(t)

where t is a tuple object and N is a constant integral expression specifying the index of the element to be accessed. Depending on whether t is const or not, get returns the Nth element as a reference to const or non-const type. The index of the first element is 0 and thus N must be between 0 and k-1, where k is the number of elements in the tuple. Violations of these constraints are detected at compile time. Examples:
double d = 2.7; A a; tuple t(1, d, a); const tuple ct = t; ... int i = get<0>(t); i = t.get<0>(); // ok int j = get<0>(ct); // ok get<0>(t) = 5; // ok get<0>(ct) = 5; // error, can't assign to const ... double e = get<1>(t); // ok get<1>(t) = 3.14; // ok get<2>(t) = A(); // error, can't assign to const A aa = get<3>(t); // error: index out of bounds ... ++get<0>(t); // ok, can be used as any variable

Note! The member get functions are not supported with MS Visual C++ compiler. Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier. Hence, all get calls should be qualified as: tuples::get(a_tuple) when writing code that should compile with MSVC++ 6.0.
Copy construction and tuple assignment

A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible. Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable. For example:
class A {}; class B : public A {}; struct C { C(); C(const B&); }; struct D { operator C() const; }; tuple t; ... tuple a(t); // ok a = t; // ok

In both cases, the conversions performed are: char -> int, B* -> A* (derived class pointer to base class pointer), B -> C (a user defined conversion) and D -> C (a user defined conversion).
Note that assignment is also defined from std::pair types:
tuple a = std::make_pair(1, 'a'); volnet:(Eclipse with MinGW g++ conversion from `std::pair' to non-scalar type `boost::tuples::tuple' requested

Relational operators

Tuples reduce the operators ==, !=, <, >, <= and >= to the corresponding elementary operators. This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well. The equality operators for two tuples a and b are defined as:

a == b iff for each i: a_i == b_i
a != b iff exists i: a_i != b_i

The operators <, >, <= and >= implement a lexicographical ordering.
Note that an attempt to compare two tuples of different lengths results in a compile time error. Also, the comparison operators are "short-circuited": elementary comparisons start from the first elements and are performed only until the result is clear.
Examples:
tuple t1(std::string("same?"), 2, A()); tuple t2(std::string("same?"), 2, A()); tuple t3(std::string("different"), 3, A()); bool operator==(A, A) { std::cout << "All the same to me..."; return true; } t1 == t2; // true t1 == t3; // false, does not print "All the..."

Tiers

Tiers are tuples, where all elements are of non-const reference types. They are constructed with a call to the tie function template (cf. make_tuple):
int i; char c; double d; ... tie(i, c, a);

The above tie function creates a tuple of type tuple. The same result could be achieved with the call make_tuple(ref(i), ref(c), ref(a)).
A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
int i; char c; double d; tie(i, c, d) = make_tuple(1,'a', 5.5); std::cout << i << " " << c << " " << d;

This code prints 1 a 5.5 to the standard output stream. A tuple unpacking operation like this is found for example in ML and Python. It is convenient when calling functions which return tuples.
The tying mechanism works with std::pair templates as well:
int i; char c; tie(i, c) = std::make_pair(1, 'a');

Ignore

There is also an object called ignore which allows you to ignore an element assigned by a tuple. The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that ignore is under the tuples subnamespace):
char c; tie(tuples::ignore, c) = std::make_pair(1, 'a');

Streaming

The global operator<< has been overloaded for std::ostream such that tuples are output by recursively calling operator<< for each element.
Analogously, the global operator>> has been overloaded to extract tuples from std::istream by recursively calling operator>> for each element.
The default delimiter between the elements is space, and the tuple is enclosed in parenthesis. For Example:
tuple a(1.0f, 2, std::string("Howdy folks!"); cout << a;

outputs the tuple as: (1.0 2 Howdy folks!)
The library defines three manipulators for changing the default behavior:

set_open(char) defines the character that is output before the first element.
set_close(char) defines the character that is output after the last element.
set_delimiter(char) defines the delimiter character between elements.

Note, that these manipulators are defined in the tuples subnamespace. For example:
cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;

outputs the same tuple a as: [1.0,2,Howdy folks!]
The same manipulators work with operator>> and istream as well. Suppose the cin stream contains the following data:
(1 2 3) [4:5]

The code:
tuple i; tuple j; cin >> i; cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':'); cin >> j;

reads the data into the tuples i and j.
Note that extracting tuples with std::string or C-style string elements does not generally work, since the streamed tuple representation may not be unambiguously parseable.
Performance

All tuple access and construction functions are small inlined one-liners. Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand-written tuple like classes. Particularly, with a decent compiler there is no performance difference between this code:
class hand_made_tuple { A a; B b; C c; public: hand_made_tuple(const A& aa, const B& bb, const C& cc) : a(aa), b(bb), c(cc) {}; A& getA() { return a; }; B& getB() { return b; }; C& getC() { return c; }; }; hand_made_tuple hmt(A(), B(), C()); hmt.getA(); hmt.getB(); hmt.getC();

and this code:
tuple t(A(), B(), C()); t.get<0>(); t.get<1>(); t.get<2>();

Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.
Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using non-const reference parameters as a mechanism for returning multiple values from a function. For example, suppose that the following functions f1 and f2 have equivalent functionalities:
void f1(int&, double&); tuple f2();

Then, the call #1 may be slightly faster than #2 in the code below:
int i; double d; ... f1(i,d); // #1 tie(i,d) = f2(); // #2 volnet: int myX = -1; double myY = -2; boost::tuple f2(2); boost::tie(myX, myY) = f2; // #2 cout << "myX = " << myX << ", myY = " <

See [1, 2] for more in-depth discussions about efficiency.
Effect on Compile Time

Compiling tuples can be slow due to the excessive amount of template instantiations. Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the hand_made_tuple class above. However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable. Compile time increases between 5 and 10 percent were measured for programs which used tuples very frequently. With the same test programs, memory consumption of compiling increased between 22% to 27%. See [1, 2] for details.
Portability

The library code is(?) standard C++ and thus the library works with a standard conforming compiler. Below is a list of compilers and known problems with each compiler:
Compiler
Problems
gcc 2.95
-
edg 2.44
-
Borland 5.5
Can't use function pointers or member pointers as tuple elements
Metrowerks 6.2
Can't use ref and cref wrappers
MS Visual C++
No reference elements (tie still works). Can't use ref and cref wrappers
Acknowledgements

Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the library. The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
References

[1] Järvi J.: Tuples and multiple return values in C++, TUCS Technical Report No 249, 1999.
[2] Järvi J.: ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism, TUCS Technical Report No 267, 1999.
[3] Järvi J.:Tuple Types and Multiple Return Values, C/C++ Users Journal, August 2001.

Last modified 2003-09-07
© Copyright Jaakko Järvi 2001. Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.

volnet 2010-03-25 17:46 发表评论

C语言位域

volnet — Tue, 29 Dec 2009 17:02:00 GMT
�q�个概念昄��是知道的�Q�不�q�刚才忘了，然后写了个程序就明白了，记录一下，也许以后又健忘了�Q?br>
1 #include <stdio.h>
2 typedef struct _SimpleType1 {
3     int Variable1;    //4bytes(32bits)
4     int Variable2;    //4bytes(32bits)
5     int Variable3;    //4bytes(32bits)
6     int Variable4;    //4bytes(32bits)
7 } SimpleType1;
8
9 typedef struct _ComplexType1 {
10     int Variable1 : 8;    //1bytes(8bits)
11     int Variable2 : 8;    //1bytes(8bits)
12     int Variable3 : 8;    //1bytes(8bits)
13     int Variable4 : 8;    //1bytes(8bits)
14 } ComplexType1;
15
16 typedef struct _ComplexType2 {
17     int Variable1 : 8;    //1bytes(8bits)
18     int Variable2 : 8;    //1bytes(8bits)
19     int Variable3 : 8;    //1bytes(8bits)
20     int Variable4 : 8;    //1bytes(8bits)
21     int Variable5 : 1;    //0.125bytes(1bits) but the it also hold 32bits
22 } ComplexType2;
23
24 int main(void){
25     printf("sizeof SimpleType1 = %d\n", sizeof(SimpleType1));
26     printf("sizeof ComplexType1 = %d\n", sizeof(ComplexType1));
27     printf("sizeof ComplexType2 = %d\n", sizeof(ComplexType2));
28 }
�l�果�Q?br>sizeof SimpleType1 = 16
sizeof ComplexType1 = 4
sizeof ComplexType2 = 8

volnet 2009-12-30 01:02 发表评论

volnet — Fri, 25 Dec 2009 21:53:00 GMT

自旋锁同�?/h3>
一般是��Z��内核态下各个�z�N��函数之间做同步作用的�?/li>
原理是（单CPU�Q�将IRQL从��Y件中断提升到��g中断。PASSIVE_LEVEL->DISPATCH_LEVEL。因为在DISPATCH_LEVEL中是不会出现�U�程切换的（只有高��别能打断低��别，而低�U�别不能打断高��别）�?/li>
因�ؓ分页内存��导致如果线�E�切换的时候会引�v分页数据交换�Q�数据交换是通过引发��|��障来实现的，而页故障是不允许出现在DISPATCH_LEVEL中的�Q�否则将引�v�pȝ��崩溃�Q�PASSIVE_LEVEL则允许）。驱动程序的StartIO例程、DPC例程、中断服务例�E�都�q�行在DISPATCH_LEVEL或者更高的IRQL。因此这些例�E�不能��用分��内存，否则��导致系�l�崩溃�?/li>
自旋锁在不同IRP之间同步的时候，则需要放在DeviceExtension中传递�?/li>
互锁
�c�M��于number++; //汇编后将不止一条语句，非原子操作number--; //同上因�ؓ语句会变成多句，在线�E�切换的时候，两个�U�程下的该例�E�将会交�l�在一��h��行，��D��错误。可以：
先加�?br />number++;
解锁
再加�?br />number--;
解锁
来实��C��句话的同步（按指定顺序执行，而不受到�U�程切换的媄响）加锁解锁可以使用自旋�?/li>
在系�l�中提供了Interlocked***/ExInterlocked***实现
信号灯同�?/h3>
�U�程1关闭信号灯，以至于��用Wait****的时候，当前�U�程处于暂停状态�?/li>
�U�程2的作用就是在执行�l�束后，点亮信号灯（增加计数器）。当�U�程切换回来的时候，�U�程1��因��数器不是0而��信号灯处于激�zȝ��态，从而��l�执行线�E?�?/li>
事�g的同�?/h3>�Q�不能递归获取互斥体）
�ȝ��E�在辅助�U�程上设�|�了事�g�Q�如果不使用Wait**�{�待事�g�q�回�Q�则�ȝ��E�可能直接执行完毕了�Q�而导致辅助线�E�还在执行�?/li>
使用Wait****可以使主�U�程�{�待事�g执行完成�?/li>
互斥体同�?/h3>�Q�允讔R��归获取互斥体（得到互斥体的�U�程�q�可以再�ơ获得这个互斥体�Q�或者说互斥体对于已�l�获得互斥体的线�E�不产生“互斥”关系�Q�）
创徏一个互斥体对象�Q�将互斥体对象传递给多个�U�程�?/li>
在每个线�E�操作的步骤中，调用Wait*****�Q�如果互斥体处于�Ȁ�z�（内部�l�护一个计数器�Q�，则��l�执行后�l�代码，�q�在调用�l�束后恢复互斥体Release****�Q�这样当别的�U�程试图使用互斥体后面的代码的时候，因�ؓ互斥体状态未�Ȁ�z�，则无法��l�执行代码�?/li>
快速互斥体同步
与互斥体同步�c�M��Q�唯一区别是不允许递归获取互斥�?/li>

volnet 2009-12-26 05:53 发表评论

如何�~�译TrueCrypt源码

volnet — Wed, 23 Dec 2009 15:47:00 GMT

相关配置

Intel x86 Core 2 Duo

Windows 7 Ultimate x86 version

Windows Driver Develop Kit 7600.16385.0

TrueCrypt 6.3a Source.zip

Microsoft Visual Studio 2008 SP1 (VC++ 2008)

Microsoft Visual Studio VC++ 1.52

NASM version 2.07 compiled on Jul 19 2009

gzip 1.2.4 Win32 (02 Dec 97)

......

配置TrueCrypt
下蝲MSVC++ 1.52�Q�安装在C盘下�Q�C:\MSVC
下蝲NASM�Q�也安装在C盘下�Q�C:\NASM
http://www.nasm.us/pub/nasm/releasebuilds/2.07/win32/
下蝲GZIP�Q�也安装在C盘下�Q�C:\gzip
下蝲�q�安装WINDDK�Q�http://www.microsoft.com/whdc/DevTools/WDK/WDKpkg.mspx
我将它们安装在D盘，路径�Q�D:\WinDDK
讄��pȝ��变量�Q�（WIN7�Q�控刉��板\所有控刉��杉K��\�pȝ��\高��pȝ��讄��\环境变量�Q�：�pȝ��变量中，新增�Q?br />变量1�Q�MSVC16_ROOT    ��|��C:\MSVC
变量2�Q�WINDDK_ROOT    ��|��D:\WinDDK\7600.16385.0
其中7600.16385.0为WinDDK的第二��目录名，同时也是版本��P��7600是Windows7的发行版本号�?br />双击变量�Q�PATH�Q�在其值的末尾补上�Q�C:\NASM;C:\gzip
目的是�ؓ了让我们可以直接在命令行实用nasm以及gzip作�ؓ命��o行�?br />
下蝲PKCS11�Q�三个文�Ӟ��右键另存为即可�?br />http://svn.openvpn.net/projects/openvpn/test/time/openvpn/pkcs11-headers/
��三个文�Ӟ��pkcs11.h、pkcs11f.h、pkcs11t.h�Q�拷贝到源码下的Common文�g夹下�Q�我的源码放在D盘根目录�Q�三个源码我��放�?#8220;D:\TrueCrypt\Common”文�g夹中�?br />
�~�译�Q�会发现有两个错误�?br />CKR_NEW_PIN_MODE和CKR_NEXT_OTP未定义，补充定义一下即可�?br />在d:\TrueCrypt\Common\pkcs11t.h文�g里（��h��据您自己的�\径进行复�Ӟ��
�q�里��它们设�|��ؓ�Q?br />
#define CKR_NEW_PIN_MODE      0x000001B0
#define CKR_NEXT_OTP          0x000001B1
我的�Ҏ��是找到实用它的语句附�q�的同类语句�Q�找到相同的定义�Q�在其下�Ҏ��加�?br />比如�Q?br />
            TC_TOKEN_ERR (CKR_MUTEX_NOT_LOCKED)
            TC_TOKEN_ERR (CKR_NEW_PIN_MODE)
            TC_TOKEN_ERR (CKR_NEXT_OTP)
�q�三句话攑֜�一��P��后两句有问题�Q�但�W�一句正常，则查找CKR_MUTEX_NOT_LOCKED的存放位�|�，在其下方��d��如上两句�Q�其中定义的值参�?br />http://www.cryptsoft.com/pkcs11doc/STANDARD/include/v220/otp-pkcs11.h�Q�这里的值只不过是一�U�错误码�Q�只要它不重复，��可以了�?br />
再编译，可能会遇��C��些警告：
nasm.exe正在停止�Q�而因为没有正��执行，又导�?#8220;fatal error LNK1136: invalid or corrupt file”错误�?br />遇到�q�个可能是因��Z��的nasm正在试图�~�译ase_amdX64.asm文�g�Q�而nasm�?4位的asm�~�译对你可能意义不大�Q��v码对我而言是这��L��Q�于是，我就��它转成�~�译x86体系架构的，也许是因为参数配�|�的问题�Q�你可以��试别的�Ҏ��Q�如果有更好的话�Q�请告诉我�?br />�q�里我搜索：x64、asm�{�关键字�Q�修改d:\TrueCrypt\Crypto\Makefile.inc文�g��Z��面这样即可：
�?    !if "$(TC_ARCH)" == "x86"
�?    TC_OBJ_FORMAT = win32
�?    !else
�?    #TC_OBJ_FORMAT = win64
�?    #edit by gocool, if the x64 system need the nasm.exe use the x64 format parameters for executing.
�?    #abort the x64 system here for building.
�?    #2009/12/23
�?    TC_OBJ_FORMAT = win32
�?    TC_ARCH = x86
�?0    !endif
�?1
�?2    "$(OBJ_PATH)\$(O)\Aes_$(TC_ARCH).obj": Aes_$(TC_ARCH).asm
�?3        nasm.exe -Xvc -f $(TC_OBJ_FORMAT) -Ox -D DLL_EXPORT -o "$@" -l "$(OBJ_PATH)\$(O)\Aes_$(TC_ARCH).lst" Aes_$(TC_ARCH).asm
其中�Q��ؓ了减��变化量�Q�也利于以后恢复�Q�第4-7行�ؓ注释�Q�第8�?行我��非x86的情况也定义成x86的情况，�q�样无论如何下面�W?3行的语句都将执行以x86体系为结构的讄��Q�而这��L��讄��通常是正��的�?br />
fatal error LNK1000: Internal error during IncrBuildImage
据说是Microsoft Visual Studio 2008的一个BUG。http://blog.csdn.net/just_one_two/archive/2009/10/05/4634391.aspx
听说有两�U�方法，一�U�是�Ҏ��1�Q�需要下载补丁，我没有尝试。第二种通过修改配置的方法我成功了，步骤如下�Q?br />�Ҏ��Q�项�?>属�?>链接�?>常规   下面�?#8220;启用增量链接”�Q�将“�?/INCREMENTAL)”改�ؓ“�?/INCREMENTAL:NO)”�?br />不过�q�又引入了另外一个警告：3>FormatCom.obj : warning LNK4075: 忽略“/EDITANDCONTINUE”(�׃��“/INCREMENTAL:NO”规范)
选择��目,属�?>配置属�?>C/C++�Q�修�?#8220;调试信息格式”�?#8220;�E�序数据�?/Zi)”卛_��?br />
警告�Q�未扑ֈ�下列环境变量
4>��目 : warning PRJ0018 : 未找��C��列环境变�?
4>$(PKCS11_INC)
�׃��目属性里讄��有附加包含目�?#8220;$(PKCS11_INC)”�Q�因此编译的时候会在系�l�变量里��L��PKCS11_INC��目�Q�如果找不到�Q�则�l�出警告�Q�因此，我们需要手动补充这个项。方法同步骤5�Q�增加一个变量�ؓPKCS11_INC�Q��|��D:\TrueCrypt\Common�Q�其中，值就是之前我们拷贝三个文�Ӟ��pkcs11.h、pkcs11f.h、pkcs11t.h�Q�的目录�?br />
如果不出意外的话�Q�你可能�q�会得到一个��用了PKEY_AppUserModel_ID未定义的声明�W�的错误。这个是用于标识用户态应用程序的唯一标识。你可以在Setup.h文�g中定义：
/*---region add by gc---*/
#include "wtypes.h"
    const PROPERTYKEY PKEY_AppUserModel_ID = {
        {
            (unsigned long)2009,/*unsigned long Data1;*/
            (unsigned short)12,/*unsigned short Data2;*/
            (unsigned short)23,/*unsigned short Data3;*/
            0x44,0x55,0x55,0x55,0x55,0x55,0x55,0x55
        },/*GUID fmtid;*/
        (DWORD)PID_FIRST_USABLE /*DWORD pid;*/
    };
/*---endregion---*/
其中�Q�这个结构体是由GUID和PID共同�l�成的�?br />
下蝲链接
TrueCrypt下蝲�Q�http://www.sfr-fresh.com/windows/misc/TrueCrypt-6.2a-Source.zip:a/Boot/Windows/Makefile
WinDDK下蝲�Q�http://www.microsoft.com/whdc/DevTools/WDK/WDKpkg.mspx
PKCS11下蝲�Q�http://svn.openvpn.net/projects/openvpn/test/time/openvpn/pkcs11-headers/
GZip下蝲�Q�http://www.gzip.org/ 或�?http://www.gzip.org/gz124src.zip
Nasm下蝲�Q�http://www.nasm.us/pub/nasm/releasebuilds/2.07/win32/
MSVC1.52下蝲�Q�http://download.csdn.net/source/620960 �Q?5.02MB�Q�（��g��|�上很多人都在找1.52�Q�最后一个可以编�?6bit�E�序的VC�~�译器）�Q�但官方�|�站上没有公开下蝲的链接，实在非常郁闷�Q�我从MSDN订阅下蝲�Q�收费的噢，杯具�Q�则�?7.6MB�Q�，如果大家实在找不��C��载或�?5.02MB的不可用�Q�可以联�p�L��?/li>
参考链�?/h3>
http://blog.csdn.net/skyremember/archive/2009/09/17/4562090.aspx
http://blog.sina.com.cn/s/blog_4758691d0100d8mc.html
http://lll332.blog.163.com/blog/static/1553692220093404635752/
http://msdn.microsoft.com/en-us/library/aa373931%28VS.85%29.aspx
http://hi.baidu.com/hhacker/blog/item/2fc5b3fb0b24132a4f4aea1d.html
http://blog.csdn.net/just_one_two/archive/2009/10/05/4634391.aspx
http://blog.csdn.net/liufei_learning/archive/2009/12/21/5047632.aspx
http://msdn.microsoft.com/zh-cn/library/958x11bc%28VS.80%29.aspx
http://bbs.xiakexing.com/cgi-bin/topic.cgi?forum=22&topic=498

volnet 2009-12-23 23:47 发表评论

QuickSort快速排序法(2009-10-28)

volnet — Tue, 27 Oct 2009 16:38:00 GMT

在本博客�Q�之前有一个版本的QuickSort�Q�其实网友很早就提出了相关的BUG�Q�但是我一直没有时间进行修正，今天又有朋友提出了这个BUG�Q�我刚好抽空看了一下，看来自己是相当不严�}以至于犯下了如此大错�?/p>
原文链接�Q?a href="http://www.shnenglu.com/mymsdn/archive/2009/03/06/quicksort.aspx">http://www.shnenglu.com/mymsdn/archive/2009/03/06/quicksort.aspx �Q�未修复�Q?/p>
关于修复BUG后的代码�Q�将在本文中提供�Q�原文中不进行修改，但会有提�C�指明是错误的，有兴��的朋友也可以直接在原文的代码中��L��错误来锻��D��己排错的能力�?/p>
下面��是几段代码�Q?/p>
Algorithms.cpp
#include "StdAfx.h" #include "Algorithms.h" Algorithms::Algorithms(void) { } Algorithms::~Algorithms(void) { }

Algorithms.h
#pragma once #include class Algorithms { public: Algorithms(void); ~Algorithms(void); public: template <typename T> static void QuickSort(T* arr, size_t min, size_t max); private: template <typename T> static size_t qsort_helper_partition(T* arr, size_t min, size_t max); template <typename T> static inline void swap(T* arr, size_t x, size_t y); // helper template <typename T> static inline void helper_show_all(T* arr, size_t min, size_t max, char *msg); }; template <typename T> void Algorithms::QuickSort(T* arr, size_t min, size_t max) { if(min >= max || max == 0 - 1) return; helper_show_all(arr, min, max, "before qsort_helper_partition"); size_t p = qsort_helper_partition(arr, min, max); helper_show_all(arr, min, max, "after qsort_helper_partition"); QuickSort(arr, min, p - 1); QuickSort(arr, p + 1, max); } /* * @BUG: bug200910280001 * @DESC: �׃��在��@环while(true)中，假设原代�? 01 while(true) 02 { 03 while(cmp < arr[i]) 04 ++i; 05 while(arr[j] < cmp) 06 --j; 07 if(i >= j) break; 08 09 swap(arr, i, j); 10 } 中，前两�D�（行号�Q�行��P��中的代码均返回false�Q? 则无法进�?+i或�?-j�Q�那么在�q�个while(true)中， i和j的值将无法发生变化�Q�从而导致死循环�? @LINK:http://www.shnenglu.com/mymsdn/archive/2009/03/06/quicksort.aspx#99606 */ template <typename T> size_t Algorithms::qsort_helper_partition(T* arr, size_t min, size_t max) { T cmp = arr[min]; int i = min, j = max; // bug200910280001:修正i = min+1�Q�将+1的动作放在��@环内�? while(true) { while(cmp < arr[++i]) // bug200910280001:��原本在循环外的min+1�Q�移�q��@环内�Q��ƈ首先+1 ; // bug200910280001:��?+1�U�至while条�g中�? while(arr[j] < cmp) --j; if(i >= j) break; helper_show_all(arr, min, max, "before swap(arr, i, j)"); swap(arr, i, j); helper_show_all(arr, min, max, "after swap(arr, i, j)"); } swap(arr, min, j); return j; } template <typename T> void Algorithms::swap(T* arr, size_t x, size_t y) { T tmp = arr[x]; arr[x] = arr[y]; arr[y] = tmp; } template <typename T> void Algorithms::helper_show_all(T* arr, size_t min, size_t max, char *msg) { std::cout << "current array :\t"; for(int i = min; i < max; ++i) { std::cout << arr[i] << " "; } std::cout<<"\t//"<
cpp_quickSort.cpp
// cpp_quickSort.cpp : 定义控制台应用程序的入口炏V�? // #include "stdafx.h" #include "Algorithms.h" #include #include #include int _tmain(int argc, _TCHAR* argv[]) { int arr_begin = 0; int arr_length = 12; //The length will instead of the magic numbers int arr[] = {8, 3, 7, 1, 5, 6, 2, 1, 9, 9, 1, 1}; // Test for : 20091028bug0001 // int arr[] = {1, 1, 1}; std::cout << "input array :\t"; for(size_t i = arr_begin; i != arr_length; ++i) { std::cout<" "; } std::cout<"result array :\t"; for(size_t i = arr_begin; i != arr_length; ++i) { std::cout<" "; } std::cout<"--------------------" << std::endl; std::cout << "input array :\t"; std::vector<int> vec; vec.push_back(3); vec.push_back(1); vec.push_back(4); vec.push_back(1); vec.push_back(7); vec.push_back(6); for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++ iter) { std::cout<<*iter<<" "; } std::cout<for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++ iter) { std::cout<<*iter<<" "; } std::cout<return 0; }

volnet 2009-10-28 00:38 发表评论

关于NULL在C和C++中的区别

volnet — Sun, 31 May 2009 12:50:00 GMT
�q�个问题源自�?\0'�Q?�Q�以及NULL的探�IӞ��
先看看标题所提到的内容：
�Ҏ��https://research.microsoft.com/en-us/um/redmond/projects/invisible/include/__defs.h.htm文档中的定义�Q?br>
#if !defined(NULL) && defined(__NEEDS_NULL)
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void *)0)
#endif
#endif
在C和C++中，分别是由(void*)0�?来表�C�的�?br>�?\0'是ASCII中的��|��ASCII中它的值就�?�?br>所以它们三者是相同的�?br>
参考资料：
https://research.microsoft.com/en-us/um/redmond/projects/invisible/include/__defs.h.htm

在探�I�的�q�程中找��C��面的一个帖子。很是不错，COPY如下�?br>转蝲自：http://blog.chinaunix.net/u/18517/showart_309917.html

    本文转自�Q?a >http://bbs.chinaunix.net/viewthread.php?tid=544415&extra=&page=7

    帖子里讨��Z��C语言中的�I�指针、空指针帔R��、NULL�?�{�概念及�怺�关系及区别。这里摘录whyglinux兄的�ȝ��。做个标�{�，呵呵^_^

什么是�I�指针常量（null pointer constant�Q?

[6.3.2.3-3] An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.

�q�里告诉我们�Q?�?L�?\0'�? - 3�? * 17 �Q�它们都�?#8220;integer constant expression”�Q�以�?(void*)0 �Q?font color="#990033">tyc�Q? 我觉�?void*)0应该��是一个空指针吧，更恰当一�?/font>�Q�等都是�I�指针常量（注意 (char*) 0 不叫�I�指针常量，只是一个空指针��|��?font color="#0000ff">至于�pȝ��选取哪种形式作�ؓ�I�指针常量��用，则是实现相关�?/font>。一般的 C �pȝ��选择 (void*)0 或�?0 的居多（也有个别的选择 0L�Q�；至于 C++ �pȝ��Q�由于存在严格的�c�d��转化的要求，void* 不能�?C 中那栯��p�{换�ؓ其它指针�c�d��Q�所以通常�?0 作�ؓ�I�指针常量（tyc: C++标准推荐�Q�，而不选择 (void*)0�?br>

什么是�I�指针（null pointer�Q?

[6.3.2.3-3] If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.

因此�Q�如�?p 是一个指针变量，�?p = 0;、p = 0L;、p = '\0';、p = 3 - 3;、p = 0 * 17; 中的��M��一�U�赋值操作之后（对于 C 来说�q�可以是 p = (void*)0;�Q�， p 都成��Z��个空指针�Q?font color="#0000ff">��q��l�保证空指针不指向�Q何实际的对象或者函�?/font>。反�q�来��_��M��对象或者函数的地址都不可能是空指针。（tyc: 比如�q�里�?void*)0��是一个空指针。把它理解�ؓnull pointer�q�是null pointer constant会有微秒的不同，当然也不是紧要了�Q?br>

什么是 NULL�Q?br>
[6.3.2.3-Footnote] The macro NULL is defined in (and other headers) as a null pointer constant

�?NULL 是一个标准规定的宏定义，用来表示�I�指针常�?/font>。因此，除了上面的各�U�赋值方式之外，�q�可以用 p = NULL; 来�� p 成�ؓ一个空指针。（tyc�Q�很多系�l�中的实玎ͼ�#define NULL (void*)0�Q�与�q�里�?#8220;a null pointer constant”�q�不是完全一致的�Q?br>

�I�指针（null pointer�Q�指向了内存的什么地方（�I�指针的内部实现�Q�？

标准�q�没有对�I�指针指向内存中的什么地方这一个问题作��定，也就是说用哪个具体的地址��|��0x0 地址�q�是某一特定地址�Q�表�C�空指针取决于系�l�的实现。我们常见的�I�指针一般指�?0 地址�Q�即�I�指针的内部用全 0 来表�C�（zero null pointer�Q�零�I�指针）�Q�也有一些系�l�用一些特�D�的地址值或者特�D�的方式表示�I�指针（nonzero null pointer�Q�非零空指针�Q�，具体请参�?a target="_blank">C FAQ�?br>
�q�运的是�Q�在实际�~�程中不需要了解在我们的系�l�上�I�指针到底是一�?zero null pointer �q�是 nonzero null pointer�Q?font color="#0000ff">我们只需要了解一个指针是否是�I�指针就可以了——编译器会自动实现其中的转换�Q��ؓ我们屏蔽其中的实现细节�?/font>注意�Q�不要把�I�指针的内部表示�{�同于整�? 0 的对象表�C�——如上所�q�ͼ�有时它们是不同的�?br>

如何判断一个指针是否是一个空指针�Q?/font>

�q�可以通过与空指针帔R��或者其它的�I�指针的比较来实玎ͼ�注意与空指针的内部表�C�无养I��。例如，假设 p 是一个指针变量，q 是一个同�c�d��的空指针�Q�要��?p 是否是一个空指针�Q�可以采用下列�Q意�Ş式之一——它们在实现的功能上都是�{��h的，所不同的只是风格的差别�?br>
指针变量 p 是空指针的判断：
if ( p == 0 )
if ( p == '\0' )
if ( p == 3 - 3 )
if ( p == NULL )  /* 使用 NULL 必须包含相应的标准库的头文�g */
if ( NULL == p )
if ( !p )
if ( p == q )
...

指针变量 p 不是�I�指针的判断�Q?br>if ( p != 0 )
if ( p != '\0' )
if ( p != 3 - 3 )
if ( p != NULL )  /* 使用 NULL 必须包含相应的标准库的头文�g */
if ( NULL != p )
if ( p )
if ( p != q )
...

可以�?memset 函数来得��C��个空指针吗？

�q�个问题�{�同于：如果 p 是一个指针变量，那么

memset( &p, 0, sizeof(p) ); �?p = 0;

是等��L��吗？

�{�案是否定的�Q�虽然在大多数系�l�上是等��L��Q�但是因为有的系�l�存在着“非零�I�指�?#8221; �Q�nonzero null pointer�Q�，所以这时两者不�{��h。由于这个原因，要注意当惛_��指针讄��为空指针的时候不应该使用 memset�Q�而应该用�I�指针常量或�I�指针对指针变量赋值或者初始化的方法�?br>

可以定义自己�?NULL 的实现吗�Q�兼�{?NULL 的值可以是 1�?�? �{�值吗�Q?�c�M��问题

[7.1.3-2] If the program declares or defines an identifier in a context in which it is reserved (other than as allowed by 7.1.4), or defines a reserved identifier as a macro name, the behavior is undefined.

NULL 是标准库中的一个符合上�q�条件的 reserved identifier �Q�保留标识符�Q�。所以，如果包含了相应的标准头文件而引入了 NULL 的话�Q�则再在�E�序中重新定�?NULL ��Z��同的内容是非法的�Q�其行�ؓ是未定义的。也��是��_��如果是符合标准的�E�序�Q�其 NULL 的值只能是 0�Q�不可能是除 0 之外的其它��|��比如 1�?�? �{��?br>

malloc 函数在分配内存失败时�q�回 0 �q�是 NULL�Q?br>
malloc 函数是标�?C 规定的库函数。在标准中明��规定了在其内存分配��p�|时返回的是一�?“null pointer”�Q�空指针�Q�：

[7.20.3-1] If the space cannot be allocated, a null pointer is returned.

对于�I�指针��|��一般的文档�Q�比�? man�Q�中們֐�于用 NULL 表示�Q�而没有直接说�?0。但是我们应该清楚：对于指针�c�d��来说�Q�返�?NULL �?�q�回 0 是完全等��L��Q�因�?NULL �?0 都表�C?“null pointer”�Q�空指针�Q�。（tyc�Q�一般系�l�中手册中都�q�回NULL�Q�那我们��q��NULL�?/font>�Q?/li>

另外�Q�附C FAQ上关于null pointer的解释：C FAQ�Q�null pointer

volnet 2009-05-31 20:50 发表评论

volnet — Sun, 24 May 2009 17:37:00 GMT

#include #include int main(void){ int MB = 0; while(malloc(1 << 20)) ++MB; printf("Allocated %d MB total\n", MB); return EXIT_SUCCESS; }

原理�Q�因�?�?0�ơ方��是1MB�Q?�?0�ơ方�?KB�Q?�?0�ơ方�?GB�Q�以此类推）�?/p>
如果你请求分配的内存块小�?MB�Q�你得到的内存是否比�q�要多一些呢�Q��ؓ什么？

�{�：

�q�不是绝对的�Q?/p>
在本例中使用

1<<22�Q?MB�Q�得到的�l�果�?�?000MB

1<<21�Q?MB�Q�得到的�l�果�?�?972MB

1<<20�Q?MB�Q�得到的�l�果�?918MB

1<<19�Q?.5MB�Q�得到的�l�果�?�?812MB

1<<18�Q?.25MB�Q�得到的�l�果�?�?003MB

1<<17�Q?.125MB�Q�得到的�l�果�?�?034MB

昄��出现了一个意外的�l�果�?/p>

volnet 2009-05-25 01:37 发表评论

static in C

volnet — Sun, 24 May 2009 10:17:00 GMT

#include #include char * favorite_fruit1(void); char * favorite_fruit2(void); void favorite_fruit3(char **); int main(void) { char * fruit1 = favorite_fruit1(); printf("%s\n", fruit1); char * fruit2 = favorite_fruit2(); printf("%s\n", fruit2); char * fruit3 = NULL; favorite_fruit3(&fruit3); printf("%s\n", fruit3); printf("------END of CODE------"); return EXIT_SUCCESS; } char * favorite_fruit1(void){ char deciduous[] = "apple"; return deciduous; } char * favorite_fruit2(void){ static char deciduous[] = "apple"; return deciduous; } void favorite_fruit3(char ** fruit){ static char deciduous[] = "apple"; *fruit = deciduous; }

favorite_fruit1很明显会出现问题�Q�原因是因�ؓchar deciduous[]是局部变量，在函数调用返回后�Q�就释放了�?/p>
favorite_fruit2因�ؓ使用了static�Q�而static限定了变量被保存在数据段�Q�data segment�Q�中�Q�它的声明周期同�E�序一样长。所以不会出错�?/p>
favorite_fruit3是另一�U�有效的写法�Q�其原理�?�?/p>

volnet 2009-05-24 18:17 发表评论

volnet — Tue, 19 May 2009 15:50:00 GMT
本部分内容详见《C专家�~�程》P119
查看可执行文件中的段
1.�~�译“hello world”�E�序�Q�在可执行文件中执行ls -l�Q�得到文件的��M��大小。运行size得到文�g里各个段的大��?br>2.增加一个全局的int[1000]数组声明�Q�重新进行编译，再用上面的命令得到��M��及各个段的大��，注意前后的区别�?br>3.现在�Q�在数组的声明中增加初始��|��C��Q�C语言�q�不��Ҏ��l�进行初始化时�ؓ每个元素提供初始��|��。这��数组从BSS�D��{换到数据�D�c��重复上面的��量�Q�注意各个段前后大小的区别�?br>4.现在�Q�在函数内声明一个巨大的数组。然后再声明一个巨大的局部数�l�，但这�ơ加上初始倹{��重复上面的��量。定义于函数内部的局部数�l�存储在可执行文件中吗？有没有初始化有什么不同吗�Q?br>5.如果在调试状态下�~�译�Q�文件和�D늚�大小有没有变化？是�ؓ了最大程度的优化吗？
分析上面“�~�程挑战”的结果，使自��q��信：

数据�D�保存在目标文�g中�?/li>
BSS�D�不保存在目标文件中�Q�除了记录BSS�D�在�q�行时所需要的大小�Q��?/li>
文本�D�|��最�Ҏ��受优化措施媄响的�D�c�?/li>
a.out文�g的大��受调试状态下�~�译的媄响，但段不受影响�?/li>
helloworld.c的文件最�l�如下：

#include <stdio.h>
int global_array[1000] = {100, 101, 102};
void SayGoodBye(void);
int main(void)
{
        printf("hello Linux world");
        int main_array[1000] = {10, 20, 30, 40};
        SayGoodBye();
        return 0;
}

void SayGoodBye(void)
{
        int goodbye_array[1000] = {1024, 2048, 4096};
        printf("good bye user!");
}

以下命��o按照文中步骤依次修改上文代码�Q�过�E�不赘述�Q�，�q�行size后的数据如下所�C�：

[volnet@GoCool c]$ echo "size helloworld1"; size helloworld1; echo "size helloworld2"; size helloworld2; echo "size helloworld3"; size helloworld3; echo "size helloworld4"; size helloworld4;
size helloworld1
   text       data        bss        dec        hex    filename
   1015        252          8       1275        4fb    helloworld1
size helloworld2
   text       data        bss        dec        hex    filename
   1015        252       4032       5299       14b3    helloworld2
size helloworld3
   text       data        bss        dec        hex    filename
   1015       4280          8       5303       14b7    helloworld3
size helloworld4
   text       data        bss        dec        hex    filename
   1270       4280          8       5558       15b6    helloworld4

注：
BSS的全�U�是�Q�Block Started by Symbol�Q�由�W�号开始的块）�Q�它是旧式IBM704汇编�E�序的一个伪指��o�Q�UNIX借用了这个名字，至今依然沿用�?br>

volnet 2009-05-19 23:50 发表评论

Expert C Programming notes

volnet — Tue, 31 Mar 2009 16:31:00 GMT

1、const其实�q�不是真正的帔R��Q�P32�Q?/p>

2、早期的gets()中的Bug��D��了Internet蠕虫�Q�P42�Q?/p>
gets()函数�q�不��查缓冲区的空��_��事实上它也无法检查缓冲区的空间。如果函数的调用者提供了一个指向堆栈的指针�Q��ƈ且gets()函数��d��的字�W�数量超�q�缓冲区的空��_��gets()函数��会愉快地将多出来的字符�l�箋写入到堆栈中�Q�这��p��盖了堆栈原先的内宏V��——这��是病毒利用它来写入额外�I�间�Q��ƈ引发蠕虫病毒的前提�?/p>
推荐的方式是��?/p>
gets(line)

替换�?/p>
if(fgets(line, sizeof(line), stdin) == NULL)

exit(1);

3、相��d��W�串帔R��自动�q�接�Q�P45�Q?/p>
�q�个其实已经应用很普遍了�Q�但是我个�h用的比较��，�Ҏ��记录一下�?/p>

4、返回一个指针？�Q�P48�Q?/p>
�q�个话题围绕一个程序的BUG来展开�Q�这个程序返回了局部变量的值的指针�Q�这么说当然你一眼就能看得出来问题所在，但是在很多时候，�q�个错误却��L��在你的眼皮子底下溜走�?/p>
作者提供了五种方式�Q�只能说可以用，但唯一推荐的只有一个，详见作者的分析�Q�P48�Q�（不是什么高��q��理论�Q�你自己也能分析地出来）�?/p>
a.�q�回一个字�W�串帔R��的指针。因为常量存在静态数据存储区�Q�所以指针没问题�?/p>
b.使用全局声明的数�l�。提到全局两个字，��q��道这个方法有很大的局限性�?/p>
c.使用静态数�l�。下一�ơ调用将覆盖�q�个数组内容�?/p>

char * func() {

static char buffer[20];

�?/p>
return buffer;

}

d.昑ּ�分配一些内存，保存�q�回的倹{�?/p>

char * func() {

char * s = malloc(120);

�?/p>
return s;

}

既然用到了malloc�Q�就必然伴随着free�Q�因此带来了内存��理的问题，增加了开发者负担�?/p>
e.�Q?u>推荐�Q�在调用前后�Q�由函数调用者分配内存，�q�由光��放，在同一地方释放对于内存��理来说代�h相对最��?/p>

void func( char * result, int size) {

�?/p>
strncpy(result, “That’d be in the data segment, Bob�? size);

}

buffer = malloc(size);

func(buffer, size);

�?/p>
free(buffer);

volnet 2009-04-01 00:31 发表评论

QuickSort快速排序法(2009-03-06)

volnet — Thu, 05 Mar 2009 19:03:00 GMT

本文代码已经更新�Q�修正严重BUG�Q�最新版本详见�?a href="http://www.shnenglu.com/mymsdn/archive/2009/10/28/quicksort20091028.html">QuickSort快速排序法(2009-10-28)》！

本文中所涉及的代码未做更斎ͼ��L��步最新版查阅正确代码�Q?/p>
链接�Q?a title="http://www.shnenglu.com/mymsdn/archive/2009/10/28/quicksort20091028.html" href="http://www.shnenglu.com/mymsdn/archive/2009/10/28/quicksort20091028.html">http://www.shnenglu.com/mymsdn/archive/2009/10/28/quicksort20091028.html

快速排序法�Q�（好土�Q�感觉满世界都会�Q�不�q�还是写一下，当然了，标准库里多的是排序算法）�Q�这里还是实现经典版的快速排序了�Q�时间复杂度O(nlogn)

Algorithms.h
#pragma once #include class Algorithms { public: Algorithms(void); ~Algorithms(void); public: template <typename T> static void QuickSort(T* arr, size_t min, size_t max); private: template <typename T> static size_t qsort_helper_partition(T* arr, size_t min, size_t max); template <typename T> static inline void swap(T* arr, size_t x, size_t y); }; template <typename T> void Algorithms::QuickSort(T* arr, size_t min, size_t max) { if(min >= max || max == 0 - 1) return; size_t p = qsort_helper_partition(arr, min, max); QuickSort(arr, min, p - 1); QuickSort(arr, p + 1, max); } template <typename T> size_t Algorithms::qsort_helper_partition(T* arr, size_t min, size_t max) { T cmp = arr[min]; int i = min + 1, j = max; while(true) { while(cmp < arr[i]) ++i; while(arr[j] < cmp) --j; if(i >= j) break; swap(arr, i, j); } swap(arr, min, j); return j; } template <typename T> void Algorithms::swap(T* arr, size_t x, size_t y) { T tmp = arr[x]; arr[x] = arr[y]; arr[y] = tmp; }

用法�Q�（��Z��有标准库的排序法�Q�当然只是调一下，没有什么可说的了）
#include "Algorithms.h" #include #include #include int _tmain(int argc, _TCHAR* argv[]) { int arr[] = {4, 8, 3, 7, 1, 5, 6, 2}; for(size_t i = 0; i != 8; ++i) { std::cout<" "; } std::cout<for(size_t i = 0; i != 8; ++i) { std::cout<" "; } std::cout<int> vec; vec.push_back(3); vec.push_back(1); vec.push_back(4); vec.push_back(1); vec.push_back(7); vec.push_back(6); for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++ iter) { std::cout<<*iter<<" "; } std::cout<for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++ iter) { std::cout<<*iter<<" "; } std::cout<return 0; }

volnet 2009-03-06 03:03 发表评论

麻豆精品久久精品色综合,久久亚洲高清观看,四虎国产精品免费久久5151

zig-zag�~�码方式

IsWow64�q�不能用来检���是否是Windows 32bit�pȝ���q�是64bit�pȝ��

[转]C/C++中动态链接库的创建和调用

两个有用的宏�Q?amp;ldquo;���止�c�L��员复�?amp;rdquo;以及“���止隐式构�?amp;rdquo;

size_t的倒序遍历问题

C++ Traits

[���译]高效使用auto_ptr

本文来自C/C++用户日志�Q?7�Q?0�Q�，1999�q?0�?/i> 原文链接

��Z��么它是一个“自动”指�?

包装指针数据成员

所有权�Q�源�Q�以及调用�?Sinks)

不可以做的事情，以及��Z��么不能做

使用const auto_ptr是一个好习惯

auto_ptr以及异常安全

致谢

注释

[转]从C++的Return Value Optimization (RVO)到C#的value type

模板�c�d��推断的一个小问题

单参数构造函数的问题�Q�single-argument construct

[C++]namespace&using keyword

boost::tuple

The Boost Tuple Library

Table of Contents

More details

Ignore

Effect on Compile Time

C语言位域

互锁

快速互斥体同步

如何�~�译TrueCrypt源码

相关配置

配置TrueCrypt

下蝲链接

QuickSort快速排序法(2009-10-28)

关于NULL在C和C++中的区别

static in C

Expert C Programming notes

QuickSort快速排序法(2009-03-06)

IsWow64�q�不能用来检��是否是Windows 32bit�pȝ��q�是64bit�pȝ��

两个有用的宏�Q?amp;ldquo;��止�c�L��员复�?amp;rdquo;以及“��止隐式构�?amp;rdquo;

[��译]高效使用auto_ptr