也就是说，如果是负数，对于32位最多能省去30格（其中1格是符号位，另一个代表最小值1，此处假设“正负0”不合法）。同理，64位最多能省去62位。当然比较极端的是所有的位数都被用上了。

首先什么是Wow64？很多朋友一看到64就认为这个方法是判断当前系统是否是64bit的，其实不然。Wow64是Windows-On-Windows64的意思，它是指在64位的操作系统上（不是指64位的CPU）运行32位应用程序的兼容平台。

下面是MSDN中一段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; 
}

下面的代码用来检测这个程序的结果：

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

让我们编译一下这个程序。

我们需要的是64位的操作系统，比如XP64bit，Windows 2008 R2等都是64bit操作系统。

在64位的操作系统上运行的kernel32.dll中，将会实现IsWow64Process方法，而在32位系统中提供的kernel32.dll中则没有提供相关函数的实现。

比较迷惑人的则是bIsWow64，其实仔细看MSDN中的Remark，会发现：

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

因此我们需要分别将我们的程序编译成Win32平台和x64平台的，如果你用Visual Studio进行编译，默认安装则只包含32位的编译器/链接器，即便你是在64位操作系统上安装，也是一样的。你需要在VC++节点下勾选x64选项才可以，Itanium则需要在Server平台下安装才可勾选。然后在编译的时候，分别选择Win32和x64进行编译。

编译后，运行，结果如我们分析的一样：

在64位系统上运行Win32编译配置的结果是IsWow64() == TRUE，而x64编译配置的结果是IsWow64() == FALSE。

如果想要知道当前系统是否是64位的，则可以通过下面的方法：

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

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

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

动态连接库的创建步骤：

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

1、打开File —> New —> Project选项，选择Win32 Dynamic-Link Library —>sample project —>工程名：DllDemo

2、新建一个.h文件DllDemo.h

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

3、在DllDemo.cpp文件中导入DllDemo.h文件，并实现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文件创建动态连接库DllDemo.dll

1、删除DllDemo工程中的DllDemo.h文件。

2、在DllDemo.cpp文件头，删除 #include DllDemo.h语句。

3、向该工程中加入一个文本文件，命名为DllDemo.def并写入如下语句：

LIBRARY MyDll

EXPORTS

Max@1

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

动态链接的调用步骤：

一、隐式调用

1、建立DllCnslTest工程

2、将文件DllDemo.dll、DllDemo.lib拷贝到DllCnslTest工程所在的目录

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

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

4、在DllCnslTest.cpp文件中添加如下语句：

#include "DllCnslTest.h"//或者 #include "DllDemo.h" 
void main() 
{ 
int value; 
value = Max(2,9); 
printf("The Max value is %d\n",value); 
}

5、编译并生成应用程序DllCnslTest.exe

二、显式调用

1、建立DllWinTest工程。

2、将文件DllDemo.dll拷贝到DllWinTest工程所在的目录或Windows系统目录下。

3、用vc/bin下的Dumpbin.exe的小程序，查看DLL文件(DllDemo.dll)中的函数结构。

4、使用类型定义关键字typedef，定义指向和DLL中相同的函数原型指针。

例：

typedef int(*lpMax)(int a,int b); //此语句可以放在.h文件中

5、通过LoadLibray()将DLL加载到当前的应用程序中并返回当前DLL文件的句柄。

例：

HINSTANCE hDll; //声明一个Dll实例文件句柄 
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、函数调用完毕后，使用FreeLibrary()卸载DLL文件。

FreeLibrary(hDll);

8、编译并生成应用程序DllWinTest.exe

注：显式链接应用程序编译时不需要使用相应的Lib文件。

下载（Visual Studio 2008验证通过）：http://www.cppblog.com/Files/mymsdn/DllCnsTest.7z

#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
private:                     \
TypeName(const TypeName&);               \
TypeName& operator=(const TypeName&)

#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
private:                     \
TypeName();                                    \
DISALLOW_COPY_AND_ASSIGN(TypeName)

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

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

其实这个时候可能是一些Vista以上版本的OS所提供的新功能引起的限制。就当前的这个例子而言，是因为编译的时候，启用用户帐户控制(UAC)默认为“是”所致，将解决方案内所有工程选中，右键属性，修改“配置属性”->“链接器”->“清单文件”->“启用用户帐户控制(UAC)”为“否”，重新生成解决方案，即可。

今晚在类中加入两个数组用来做计数，因为之前代码有所改动，VS编译（增量）的结果居然出现了无数次的程序崩溃，害我一度怀疑是不是我的数组写的有问题。囧。最后无奈之下，点了重新生成，居然顺利通过了，很生气，愤怒中。

但是另外却发现了一个问题，也就是当size_t用作循环的时候。因为以前都是用int做循环的，现在换成unsigned int（也就是size_t）后，一下子没反应过来，就顺手这么写了：

乍一看似乎没啥问题，因为我循环内的代码是删除资源的，因此程序也频频崩溃。

step over的结果才让人惊讶，因为当size_t i = 0的时候，--i的结果是无穷大，而无穷大则肯定满足i>=0的条件，所以当我们期待程序停住的时候，程序是不会停住的。

修正的方式：

1、使用正向遍历。

2、增加判断条件（i>=0 && i < MAX），但这里也可能存在问题，因为size_t可能被定义为unsigned int，但是MAX可能是个更大的数，比如unsigned long long，当然这样的比较不是很有意义，或者会实现一些转换，但是如果这种情况发生的话，程序可能还是会通过一个随机的i进入到一个未知的空间中，从而造成崩溃。而且增加判断条件也使得程序的运行成本提高。

/*
 * cpp_traits.cpp
 *
 *  Created on: 2010-4-26
 *      Author: volnet@tom.com
 */
#include <iostream>
// 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;
}

大部分人都听说过auto_ptr指针，但是并非所有人都每天使用它。不使用它是不明智的（可耻的），因为auto_ptr的设计初衷是为了解决C++设计和编码的普遍问题，将它用好可以写出更健壮的代码。本文指出如何正确使用auto_ptr以使程序变得安全，以及如何避开危险，而不是一般使用auto_ptr的恶习所致的创建间歇性和难以诊断的问题。

为什么它是一个“自动”指针

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

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

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

      /*...more code...*/

      delete pt;
    }

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

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

    // Example 1(b): Safe code, with auto_ptr
    //
    void f()
    {
      auto_ptr<T> pt( new T );

      /*...more code...*/

    } // cool: pt's destructor is called as it goes out
      // of scope, and the object is deleted automatically

现在这段代码将不会再T对象上发生泄漏了，不必在意这个方法是正常退出还是异常退出，因为pt的析构函数将总是在堆栈弹出的时候被调用。清理工作将自动进行。

最后，使用auto_ptr和使用内建指针一样地容易，如果要“收回”资源并且再次手动管理的话，我们可以调用release()：

    // 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<T> 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已经获得一个对象，这个过程就像是它先删除已经拥有的对象，因此调用reset()，就像是先销毁了auto_ptr，然后重建了一个新的并拥有该新对象：

    // Example 3: Using reset()
    //
    void h()
    {
      auto_ptr<T> 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

包装指针数据成员

同样，auto_ptr也可以被用于安全地包装指针数据成员。考虑下面使用Pimpl idiom（或者，编译器防火墙）的例子：^[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的私有细节被实现为一个单独的对象，藏匿于一个指针之中。该思路要求C的构造函数负责为隐藏在类内部的辅助“Pimpl”对象分配内存，并且C的析构函数负责销毁它。使用auto_ptr，我们会发现这非常容易：

    // Example 4(b): A safer Pimpl, using auto_ptr
    //

    // file c.h
    //
    class C
    {
    public:
      C();
      /*...*/
    private:
      class CImpl; // forward declaration
      auto_ptr<CImpl> pimpl_;
    };

    // file c.cpp
    //
    class C::CImpl { /*...*/ };

    C::C() : pimpl_( new CImpl ) { }

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

所有权，源，以及调用者(Sinks)

它本身很漂亮，并且做得非常好：从函数传入或传出auto_ptrs，是非常有用的，比如函数的参数或者返回值。

让我们看看为什么，首先我们考虑当拷贝auto_ptr的时候会发生什么：一个auto_ptr获得一个拥有指针的对象，并且在同一时间只允许有一个auto_ptr可以拥有这个对象。当你拷贝一个auto_ptr的时候，你自动将源auto_ptr的所有权，传递给目标auto_ptr；如果目标auto_ptr已经拥有了一个对象，这个对象将先被释放。在拷贝完之后，只有目标auto_ptr拥有指针，并且负责在合适的时间销毁它，而源将被设置为空（null），并且不能再被当作原有指针的代表来使用。

例如：

    // Example 5: Transferring ownership from
    //            one auto_ptr to another
    //
    void f()
    {
      auto_ptr<T> pt1( new T );
      auto_ptr<T> 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

但是要避免陷阱再次使用已经失去所有权的auto_ptr：

    // Example 6: Never try to do work through
    //            a non-owning auto_ptr
    //
    void f()
    {
      auto_ptr<T> pt1( new T );
      auto_ptr<T> pt2;

      pt2 = pt1;  // now pt2 owns the pointer, and
                  // pt1 does not

      pt1->DoSomething();
                  // error! following a null pointer
    }

谨记于心，我们现在看看auto_ptr如何在源和调用者之间工作。“源”这里是指一个函数，或者其它创建一个新资源的操作，并且通常将移交出资源的所有权。一个“调用者”函数反转这个关系，也就是获得已经存在对象的所有权（并且通常还负责释放它）。而不是有一个源和调用者，返回并且利用一个秃头指针（译者注：而不是使用一个局部变量来传递这个指针），虽然，通过一个秃头指针来获得一个资源通常很好：

    // Example 7: Sources and sinks
    //

    // A creator function that builds a new
    // resource and then hands off ownership.
    //
    auto_ptr<T> Source()
    {
      return auto_ptr<T>( new T );
    }

    // A disposal function that takes ownership
    // of an existing resource and frees it.
    //
    void Sink( auto_ptr<T> pt )
    {
    }

    // Sample code to exercise the above:
    auto_ptr<T> pt( Source() ); // takes ownership

注意下面的微妙的变化：

1. Source()分配了一个新对象并且以一个完整安全的方式将它返回给调用者，并让调用者成为指针的拥有着。即使调用者忽略了返回值（显然，如果调用者忽略了返回值，你应该从来没有写过代码来删除这个对象，对吧？），分配的对象也将被自动安全地删除。

   在本文的最后，我将演示返回一个auto_ptr是一个好习惯。让返回值包裹进一些东西比如auto_ptr通常是使得函数变得强健的有效方式。

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

不可以做的事情，以及为什么不能做

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

For auto_ptr, copies are NOT equivalent. （复制auto_ptr将与原来的不相等）

当你试着在一般的代码中使用auto_ptrs的时候，它将执行拷贝，并且没有任何提示，拷贝是不相等的（结果，它确实就是拷贝）。看下面这段代码，这是我在C++新闻组经常看见的：

    // Example 8: Danger, Will Robinson!
    //
    vector< auto_ptr<T> > v;

    /* ... */

    sort( v.begin(), v.end() );

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

问题是auto_ptr并不完全符合一个可以放进容器类型的前提，因为拷贝auto_ptrs是不等价的。首先，没有任何东西说明，vector不能决定增加并制造出“扩展”的内部拷贝。再次，当你调用一个一般函数的时候，它可能会拷贝元素，就像sort()那样，函数必须有能力假设拷贝是等价的。至少一个流行的排序拷贝“核心”的元素，如果你试着让它与auto_ptrs一起工作的话，它将拷贝一份“核心”的auto_ptr对象（因此转移所有权并且将所有权转移给一个临时对象），然后对其余的元素也采取相同的方式（从现有成员创建更多的拥有所有权的auto_ptr），当排序完成后，核心元素将被销毁，并且你将遇到一个问题：这组序列里至少一个auto_ptr（也就是刚才被掉包的那个核心元素）不再拥有对象所有权，而那个真实的指针已经随着临时对象的销毁而被删除了！

于是标准委员会回退并希望做一些能够帮助你避免这些行为的事情：标准的auto_ptr被故意设计成当你希望在使用标准容器的时候使用它时打断你（或者，至少，在大部分的标准库实现中打断你）。为了达到这个目的，标准委员会利用这样一个技巧：让auto_ptr's的拷贝构造函数和赋值操作符的右值（rhs）指向非常量。因为标准容器的单元素insert()函数，需要一个常量作为参数，因此auto_ptrs在这里就不工作了。（译者注：右值不能赋值给非常量）

使用const auto_ptr是一个好习惯

将一个auto_ptr设计成const auto_ptrs将不再丢失所有权：拷贝一个const auto_ptr是违法的（译者注：没有这样的构造函数），实际上你可以针对它做的唯一事情就是通过operator*()或者operator->()解引用它或者调用get()来获得所包含的指针的值。这意味着我们有一个简单明了的风格来表达一个绝不丢失所有权的auto_ptr：

    // Example 9: The const auto_ptr idiom
    //
    const auto_ptr<T> 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<T> pt2( pt1 ); // illegal
    auto_ptr<T> pt3;
    pt3 = pt1;              // illegal
    pt1.release();          // illegal
    pt1.reset( new T );     // illegal

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

auto_ptr以及异常安全

最后，auto_ptr对写出异常安全的代码有时候非常必要，思考下面的代码：

    // Example 10(a): Exception-safe?
    //
    String f()
    {
      String result;
      result = "some value";
      cout << "some output";
      return result;
    }

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

虽然在例10(a)中的代码非常精巧，看起来相当接近于异常安全的代码，但仍然有一些小的瑕疵，就像下面的客户代码所示：

    String theName;
    theName = f();

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

我们可以做的更好吗，是否可以通过避免拷贝来避免这个问题？例如，我们可以 让函数有一个非常量引用参数并向下面这样返回值：

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

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

解决这个问题的一个方法是返回一个指向动态分配指针的String对象，但是最好的解决方案是让我们做的更多，返回一个指针包含在auto_ptr：

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

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

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

致谢

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.

注释

1. Pimpl风格可以有效减少项目构建时间，因为它在C私有部分改变的时候，阻止客户代码引起广泛的重新编译。更多关于Pimpl风格以及如何部署编译器墙，参考这本Exceptional C++的条款26到30。（Addison-Wesley, 2000）

2. See the article "Exception-Safe Generic Containers" 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).

Type get(int I){
    return Type(i);
} 

Type t = get(1); 

这里， 我们从C++的基本语义看上去， 应该是Type(i) 调用一次拷贝构造函数， 在堆栈中生成一个临时对象；然后，用该对象构造返回对象；然后对这个临时对象调用析构函数；在调用者方， 用返回的临时对象调用拷贝构造函数以初始化对象t, 返回对象的析构函数在这之后， 函数返回之前调用。

所以， Type t = get(i); 应该有三个拷贝构造函数和两个析构函数的调用.

可是， 还有一种说法是， 编译器可能会对这两个临时对象进行优化，最终的优化结果会是只有一次的构造函数。因为很明显地可以看到， 这里我们其实只是要用一个整数构造一个Type对象。

嗯. 似乎很有道理！

那么， 哪一种说法对呢？ 没有调查就没有发言权，于是本人用VC++6.0做了实验。 放了些cout<<…..在拷贝构造函数里，观察打印的结果， 结果却是跟我的simple, naïve的预测一致。三个拷贝构造函数， 两个析构函数。

“你个弱智编译器！脑袋进水了吧？”(忘了编译器没脑袋了)“很明显在这个例子里我的两个临时对象都没有用的啊！”

于是，上网， 查资料， google一下吧！

下面是我查到的一些结果：

其实， 这种对值传递的优化的研究， 并不只局限于返回值。对下面这个例子：

void f(T t) { } 
void main(void){ 
    T t1;
    f(t1); 
} 

也有这种考虑。

f(T)是按值传递的。语义上应该做一个复制， 使得函数内部对T的改变不会影响到原来的t1.

但是，因为在调用f(t1)之后， 我们没有再使用t1(除了一个隐含的destructor调用)，是否可能把复制优化掉， 直接使用t1呢？这样可以节省掉一个拷贝构造函数和一个析构函数。

可是， 不论是对返回值的优化， 还是对上面这种局部对象的优化，在1995年的C++新标准草案出台前都是为标准所严格限制的 (虽然有些编译器并没有遵行这个标准， 还是支持了这种“优化”)

那么， 这又是为什么呢？

这里面涉及到一个普遍的对side-effect的担忧。

什么又是side-effect呢？

所谓side-effect就是一个函数的调用与否能够对系统的状态造成区别。

int add(int i, int j){ return i+j; }就是没有side-effect的，而

void set(int* p, int I, int v){ p[I]=v; }就是有side-effect的。因为它改变了一个数组元素的值， 而这个数组元素在函数外是可见的。

通常意义上来说， 所有的优化应该在不影响程序的可观察行为的基础上进行的。否则，快则快了， 结果却和所想要的完全不同！

而C++的拷贝构造函数和析构函数又很多都是有side-effect的。如果我们的“优化”去掉了一个有side-effect的拷贝构造函数和一个析构函数， 这个“优化”就有可能改变程序的可观察行为。（注意， 我这里说的是“可能”，因为“负负得正”， 两个有side-effect的函数的调用， 在不考虑并行运行的情况下， 也许反而不会影响程序的可观察行为。不过， 这种塞翁失马的事儿， 编译器就很难判断了）

基于这种忧虑, 1995年以前的标准， 明确禁止对含有side-effect的拷贝构造函数和析构函数的优化。同时， 还有一些对C++扩充的提议， 考虑让程序员自己对类进行允许优化的声明。 程序员可以明确地告诉编译器：不错， 我这个拷贝构造函数， 析构函数是有side-effect, 但你别管， 尽管优化， 出了事有我呢！

哎， side-effect真是一个让人又恨又爱的东西！它使编译器的优化变得困难；加大了程序维护和调试的难度。因此 functional language 把side-effect当作洪水猛兽一样，干脆禁止。但同时，我们又很难离开side-effect. 不说程序员们更习惯于imperative 的编程方法, 象数据库操作，IO操作都天然就是side-effect.

不过，个人还是认为C++标准对“优化”的保守态度是有道理的。无论如何，让“优化”可以潜在地偷偷地改变程序的行为总是让人想起来就不舒服的。

但是， 矛盾是对立统一的。（想当年俺马列可得了八十多分呢）。 对这种aggressive的“优化”的呼声是一浪高过一浪。 以Stan Lippeman为首的一小撮顽固分子对标准的颠覆和和平演变的阴谋从来就没有停止过。 这不？在1996年的一个风雨交加的夜晚， 一个阴险的C++新标准草案出炉了。在这个草案里， 加入了一个名为RVO (Return Value Optimization) 的放宽对优化的限制， 妄图走资本主义道路， 给资本家张目的提案。其具体内容就是说：允许编译器对命名过的局部对象的返回进行优化， 即使拷贝构造函数/析构函数有side-effect也在所不惜。这个提议背后所隐藏的思想就是：为了提高效率， 宁可冒改变程序行为的风险。宁要资本主义的苗， 不要社会主义的草了！

我想， 这样的一个罪大恶极的提案竟会被提交，应该是因为C++的值拷贝的语义的效率实在太“妈妈的”了。 当你写一个 Complex operator+(const Complex& c1, const Complex& c2);的时候， 竟需要调用好几次拷贝构造函数和析构函数！同志们！（沉痛地， 语重心长地）社会主义的生产关系的优越性怎么体现啊？

接下来， 当我想Google C++最新的标准， 看RVO是否被最终采纳时， 却什么也找不到了。 到ANSI的网站上去， 居然要付钱才能DOWNLOAD文档。 “老子在城里下馆子都不付钱， down你几个烂文档还要给钱？！”

故事没有结局， 实在是不爽。 也不知是不是因为标准还没有敲定， 所以VC++6 就没有优化， 还是VC根本就没完全遵守标准。

不过，有一点是肯定的。 当写程序的时候， 最好不要依赖于RVO (有人， 象Stan Lippeman, 又叫它NRV优化)。 因为， 不论对标准的争论是否已经有了结果， 实际上各个编译器的实现仍还是各自为政， 没有统一。 一个叫SCOtt Meyers的家伙(忘了是卖什么的了)就说， 如果你的程序依赖于RVO, 最好去掉这种依赖。也就是说， 不管RVO到底标准不标准， 你还是不能用。 不仅不能用， 还得时刻警惕着RVO可能带来的程序行为上的变化。 （也不知这帮家伙瞎忙了半天到底为啥！）

说到这里， 倒想起了C#里一个困惑了我很久的问题。记得读C#的specification的时候， 非常不解为什么C#不允许给value type 定义析构函数。

这里， 先简略介绍一下C#里的value type (原始数据类型， struct 类型)。

在C#里的value_type就象是值， 永远只能copy, 取值。因此， 它永远是in-place的。如果你把一个value type的数据放在一个对象里，它的生命期就和那个对象相同；如果你声明一个value type 的变量在函数中， 它的生命期就在lexical scope里。

{

  The_ValueType value;

}//value 到这里就死菜了

啊呀呀！ 这不正是我们怀念的C++的stack object吗？

在C++里，Auto_ptr, shared_ptr, 容器们， 不都是利用析构函数来管理资源的吗？

C#，Java 虽然利用garbage collection技术来收集无用对象， 使我们不用再担心内存的回收。 但garbage collection并不保证无用对象一定被收集， 并不保证Dispose()函数一定被调用， 更不保证一个对象什么时候被回收。 所以对一些非内存的资源， 象数据库连接， 网络连接， 我们还是希望能有一个类似于smart pointer的东西来帮我们管理啊。（try-finally 虽然可以用， 但因为它影响到lexical scope, 有时用起来不那么方便）

于是， 我对C#的取消value type的析构函数充满了深厚的阶级仇恨。

不过， 现在想来， C#的这种设计一定是惩于C++失败的教训：

   1. value type 没有拷贝构造函数。C#只做缺省copy, 没有side-effect
   2. value type 不准有析构函数。C#有garbage collection, 析构函数的唯一用途只会是做一些side-effect象关闭数据库连接。 所以取消了析构函数， 就取消了value type的side-effect.
   3. 没有了side-effect, 系统可以任意地做优化了

对以下程序：

The_Valuetype get(int I){return The_Valuetype(i);}

The_Valuetype t = get(1);

在C#里我们可以快乐地说：只调用了一次构造函数。 再没有side-effect的沙漠， 再没有难以优化的荒原， smart pointer望而却步， 效率之花处处开遍。 I have a dream, ……

转载自：http://gugu99.itpub.net/post/34143/466008

于是就有了下面的做法，应该不难理解：

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

我们希望我们的智能指针能够像指针一样地工作，但下面的工作方式似乎存在问题：

在普通的dumb指针中，以下行为是正确的：

void letUsGo(BaseClass* objPtr);

DerivedClass* derivedObjPtr2 = new DerivedClass();
letUsGo(derivedObjPtr2);
delete derivedObjPtr2;

但是，以下代码呢？

void letUsSmartGo(const smart_ptr<BaseClass>& objPtr);
smart_ptr<DerivedClass> smartDerivedObjPtr2(new DerivedClass());
// the smart_ptr<DerivedClass> is not inherited from the smart_ptr<BaseClass>
// the compiler can't find the class to cast it, so it must cause the error.
letUsSmartGo(smartDerivedObjPtr2);

下面的过程描述了这个变化所需要的一些支持：

1、error C2664: “letUsSmartGo”: 不能将参数 1 从“smart_ptr<T>”转换为“const smart_ptr<T> &”
2、smartDerivedObjPtr2的类型：
    smart_ptr<DerivedClass> smartDerivedObjPtr2(new DerivedClass());
3、letUsSmartGo的声明：
    void letUsSmartGo(const smart_ptr<BaseClass>&);
4、问题转化为，如何从smart_ptr<DerivedClass>到const smart_ptr<BaseClass>&的转变。
5、针对letUsSmartGo的声明，可以有的实参类型包括：
    const smart_ptr<BaseClass>
    smart_ptr<BaseClass>
    假设存在以下类型 smart_derived_ptr : smart_ptr<BaseClass>，那么smart_derived_ptr也是可以被传递的。
6、这里存在这样一个问题：
    new DerivedClass() 被传递给smartDerivedObjPtr2之后，smartDerivedObjPtr2就拥有了它的指针。如果从smartDerivedObjPtr2隐式转换成另一个smart_ptr<X>后，我们需要解决的就是将smartDerivedObjPtr2所拥有的指针传递给smart_ptr<X>并将smartDerivedObjPtr2的内部指针清零（这样就不会在smartDerivedObjPtr2被销毁的时候，因为调用delete real_ptr，而它的新拷贝在离开作用域的时候，一样会再次调用delete real_ptr，而此时real_ptr指向的对象已经被释放，因此这样的行为是未定义的。）
7、因此，定义如下方法即可：

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<U>& rhs) : real_ptr(rhs.real_ptr){
        std::cout << "creating smart_ptr ...smart_ptr(smart_ptr<U>& 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按照习惯应该是一个私有成员，而且我们在完成该方法时候，希望能够实现一种所谓的所有权转移，也就是将内部的指针传递给另一个智能指针，而这应该是一个原子过程。因此，我们实现以下方法：

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<U>& rhs) : real_ptr(rhs.release()){
        std::cout << "creating smart_ptr ...smart_ptr(smart_ptr<U>& 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; 
};

1、设置“生成时启用C/C++代码分析”为“是”，如果不设置此项，程序速度将出乎你的意料……

2、点击“分析”->“启动性能向导”

3、在“性能资源管理器”中右键新建的性能报告节点，右键“启动并启用分析功能”。

虽然此处有“启用分析功能”，但如果在配置里面没有进行设置，第一次的测试报告结果将是不准确的。

4、选择两个性能报告（ctrl+鼠标），右键“比较性能报告”。

用性能报告将有助于提高程序的性能，并且快速定位问题所在，剩下的结果就是你自己需要多观察，分析性能报告所反映的问题了。

更多

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

第三方工具>> http://www.semdesigns.com/Products/Profilers/CppProfiler.html

1. 下载boost。（http://cdnetworks-kr-1.dl.sourceforge.net/project/boost/boost/1.42.0/boost_1_42_0.tar.bz2）
2. 解压到指定文件夹，我是将它解压到根目录下的一个sourcecode文件夹下。
       /home/volnet/sourcecode/boost_1_42_0
3. 启动终端（ctrl+f2,输入“gnome-terminal”）。生成bjam脚本。
       ./bootstrap.sh --prefix=/home/volnet/sourcecode/boost_install
   如果不带--prefix参数的话（推荐），默认的路径是/usr/local/include和/usr/local/lib
       ./bootstrap.sh
   使用--help参数可以查看帮助，用-h可以查看简要帮助。
       ./bootstrap.sh --help
   生成脚本bjam，已经存在的脚本将被自动备份。

   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
   
   

4. 然后就是利用生成的bjam脚本编译源码了。
   
   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系统执行文件的前缀，这里就是指要执行bjam文件。
   • -a是参数，代表重新编译（Rebuild）。输入./bjam -h获得更多帮助。
   • -sHAVE_ICU=1，代表支持Unicode/ICU。点击这里（http://goo.gl/ySEe）
     
     前提：系统内需要安装有libicu-dev，可以在终端输入：
     

     sudo apt-get install libicu-dev
   • install，表示安装
   • --clean，表示清理。当前语句中包含-a，则不需要先手动清理，否则需要先运行
     ./bjam --clean
5. 如果你执行上一步，会出现诸如：mpi的问题，多半是本机没有安装mpi。根据系统提示，你可以找到有/home/volnet/sourcecode/boost_1_42_0/tools/build/v2/user-config.jam。在文件最后跟上
   using mpi ;
   即可。然后如果还是有mpi问题，说明本机没有安装mpi。
   sudo apt-get install mpi-default-dev

/*
 * 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 <stdlib.h>
#include <iostream>
#include <sstream>

// 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”类型的右操作数的运算符(或没有可接受的转换)    {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”类型的右操作数的运算符(或没有可接受的转换)    {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;
}

解决方法：

1、explicit关键字，在单参数构造函数前使用explicit参数，可以避免单参数构造函数被用于隐式转换。

2、利用中间类的方式，详见代码“SingleArgumentClassFixedBugByHelperClass相关部分”。如果编译器不支持解决方法1，则建议使用此方法。上面代码所提及的两款主流编译器均支持explicit关键字。

有时候我们可以用namespace来组织命名空间。

有时候我们又希望将一些较深层次的类变成我们比较容易访问的对象。

下面的代码提供了一种简单的示例来满足这样的需求。

1、用namespace来组织各个类的层级关系。

2、用using关键字，将深层次结构暴露到较外层。

//============================================================================
// Name        : namespace.cpp
// Author      : Volnet
// Version     :
// Copyright   : reserve by volnet@tom.com
// Description : namespace in C++, Ansi-style
//============================================================================

#include <iostream>

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

boost::tuple<derived> tup4;
boost::tuple<base> tup5;
tup5 = tup4;
tup4.get<0>().test();
tup5.get<0>().test(); // 丢失多态性

derived d;
boost::tuple<derived*> tup6(&d);
boost::tuple<base*> tup7;
tup7 = tup6;
tup6.get<0>()->test();
tup7.get<0>()->test(); // 恢复多态性（方法1）

boost::tuple<derived&> tup8(d);
boost::tuple<base&> tup9(tup8);

// tup9 = tup8; 不能使用该方法，因为无法对引用赋值。
tup8.get<0>().test();
tup9.get<0>().test(); // 恢复多态性（方法2）

/*
 * tuple.cpp
 *
 *  Created on: 2010-3-25
 *      Author: GoCool
 */
#include <stdlib.h>
#include <iostream>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#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<double&>(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<char[2]>(arr); // error, arrays can not be copied
    // boost::tuple<char[2], Y>(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::tuple<boost::tuple<void (&)(int)> > pFTuple4(f);
    pFTuple4.get<0>().get<0>()(40);

    cut_off_rule();

    // boost::tuple<int, char> stdPairToTuple = std::make_pair(1, 'a');

    cut_off_rule();

    boost::tuple<std::string, int, A> t1(std::string("same?"), 2, A());
    boost::tuple<std::string, long> t2(std::string("same?"), 2);
    boost::tuple<std::string, 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 = " <<myY << endl;
}
void cut_off_rule(void) {
    cout << "-----------------------------------" << endl;
}

void f(int i) {
    cout << "f(" << i << ")" << endl;
}

tuple是boost库中一个类似标准std::pair库库，但pair只能支持两种元素，而tuple则可以支持大于两种的。

更多详解：http://www.boost.org/doc/libs/1_42_0/libs/tuple/doc/tuple_users_guide.html

以下内容直接引自原文：

#include "boost/tuple/tuple.hpp"

#include "boost/tuple/tuple_comparison.hpp"

#include "boost/tuple/tuple_io.hpp"

tuple<int>
tuple<double&, const double&, const double, double*, const double*>
tuple<A, int(*)(char, int), B(A::*)(C&), C>
tuple<std::string, std::pair<A, B> >

tuple<A*, tuple<const A*, const B&, C>, bool, void*>

tuple<int, double>() 
tuple<int, double>(1) 
tuple<int, double>(1, 3.14)

class X {
  X(); 
public:
  X(std::string);
};

tuple<X,X,X>()                                              // error: no default constructor for X
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok

tuple<double&>()                // error: reference must be 
                                // initialized explicitly

double d = 5; 
tuple<double&>(d)               // ok


tuple<double&>(d+3.14)          // error: cannot initialize 
                                // non-const reference with a temporary

tuple<const double&>(d+3.14)    // ok, but dangerous: 

                                // the element becomes a dangling reference 

class Y { 
  Y(const Y&); 
public:
  Y();
};

char a[10];

tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
tuple<char[10], Y>();       // ok

Y y;
tuple<char(&)[10], Y&>(a, y); 

tuple<int, int, double> add_multiply_divide(int a, int b) {
  return make_tuple(a+b, a*b, double(a)/double(b));
}

void foo(const A& a, B& b) { 
  ...
  make_tuple(a, b);

A a; B b; const A ca = a;
make_tuple(cref(a), b);      // creates tuple<const A&, B>
make_tuple(ref(a), b);       // creates tuple<A&, B>
make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>

make_tuple(cref(ca));        // creates tuple<const A&>
make_tuple(ref(ca));         // creates tuple<const A&>

make_tuple("Donald", "Daisy");

void f(int i);
  ...
make_tuple(&f); // tuple<void (*)(int)>
  ...

volnet:
	boost::tuple<void (&)(int)> pFTuple3(f);

	pFTuple3.get<0>()(30);

tuple<tuple<void (&)(int)> > a(f) // ok
make_tuple(f);                    // not ok

t.get<N>()

get<N>(t)

double d = 2.7; A a;
tuple<int, double&, const A&> t(1, d, a);
const tuple<int, double&, const A&> 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

class A {};
class B : public A {};
struct C { C(); C(const B&); };
struct D { operator C() const; };
tuple<char, B*, B, D> t;
  ...
tuple<int, A*, C, C> a(t); // ok 

a = t;                     // ok 

tuple<float, int> a = std::make_pair(1, 'a');

volnet:(Eclipse with MinGW g++
conversion from `std::pair<int, char>' to non-scalar type `boost::tuples::tuple<float, int, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>' requested

tuple<std::string, int, A> t1(std::string("same?"), 2, A());
tuple<std::string, long, A> t2(std::string("same?"), 2, A());
tuple<std::string, long, A> 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..."

int i; char c; double d; 
  ...
tie(i, c, a);

int i; char c; double d; 
tie(i, c, d) = make_tuple(1,'a', 5.5);
std::cout << i << " " <<  c << " " << d;

int i; char c;
tie(i, c) = std::make_pair(1, 'a');

char c;
tie(tuples::ignore, c) = std::make_pair(1, 'a');

tuple<float, int, std::string> a(1.0f,  2, std::string("Howdy folks!");

cout << a; 

cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a; 

(1 2 3) [4:5]

tuple<int, int, int> i;
tuple<int, int> j;

cin >> i;
cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');

cin >> j;

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();

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

void f1(int&, double&);
tuple<int, double> f2();

int i; double d;
  ...
f1(i,d);         // #1
tie(i,d) = f2(); // #2

volnet:

	int myX = -1;
	double myY = -2;

	boost::tuple<int, double> f2(2);
	boost::tie(myX, myY) = f2; // #2

	cout << "myX = " << myX << ", myY = " <<myY << endl;

自旋锁同步

1. 一般是为了内核态下各个派遣函数之间做同步作用的。
2. 原理是（单CPU）将IRQL从软件中断提升到硬件中断。PASSIVE_LEVEL->DISPATCH_LEVEL。因为在DISPATCH_LEVEL中是不会出现线程切换的（只有高级别能打断低级别，而低级别不能打断高级别）。
3. 因为分页内存将导致如果线程切换的时候会引起分页数据交换，数据交换是通过引发页故障来实现的，而页故障是不允许出现在DISPATCH_LEVEL中的，否则将引起系统崩溃（PASSIVE_LEVEL则允许）。驱动程序的StartIO例程、DPC例程、中断服务例程都运行在DISPATCH_LEVEL或者更高的IRQL。因此这些例程不能使用分页内存，否则将导致系统崩溃。
4. 自旋锁在不同IRP之间同步的时候，则需要放在DeviceExtension中传递。

互锁

1. 类似于number++; //汇编后将不止一条语句，非原子操作number--; //同上因为语句会变成多句，在线程切换的时候，两个线程下的该例程将会交织在一起执行，导致错误。可以：
   先加锁
   number++;
   解锁
   再加锁
   number--;
   解锁
   
   来实现两句话的同步（按指定顺序执行，而不受到线程切换的影响）加锁解锁可以使用自旋锁
2. 在系统中提供了Interlocked***/ExInterlocked***实现

信号灯同步

1. 线程1关闭信号灯，以至于使用Wait****的时候，当前线程处于暂停状态。
2. 线程2的作用就是在执行结束后，点亮信号灯（增加计数器）。当线程切换回来的时候，线程1就因为计数器不是0而使信号灯处于激活状态，从而继续执行线程1。

事件的同步

1. 主线程在辅助线程上设置了事件，如果不使用Wait**等待事件返回，则主线程可能直接执行完毕了，而导致辅助线程还在执行。
2. 使用Wait****可以使主线程等待事件执行完成。

互斥体同步

1. 创建一个互斥体对象，将互斥体对象传递给多个线程。
2. 在每个线程操作的步骤中，调用Wait*****，如果互斥体处于激活（内部维护一个计数器），则继续执行后续代码，并在调用结束后恢复互斥体Release****，这样当别的线程试图使用互斥体后面的代码的时候，因为互斥体状态未激活，则无法继续执行代码。

快速互斥体同步

1. 与互斥体同步类似，唯一区别是不允许递归获取互斥体

   
• 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

1. 下载MSVC++ 1.52，安装在C盘下：C:\MSVC
   
2. 下载NASM，也安装在C盘下：C:\NASM
   http://www.nasm.us/pub/nasm/releasebuilds/2.07/win32/
   
3. 下载GZIP，也安装在C盘下：C:\gzip
   
4. 下载并安装WINDDK，http://www.microsoft.com/whdc/DevTools/WDK/WDKpkg.mspx
   我将它们安装在D盘，路径：D:\WinDDK
   
5. 设置系统变量（（WIN7）控制面板\所有控制面板项\系统\高级系统设置\环境变量）：系统变量中，新增：
   变量1：MSVC16_ROOT    值：C:\MSVC
   变量2：WINDDK_ROOT    值：D:\WinDDK\7600.16385.0
   其中7600.16385.0为WinDDK的第二级目录名，同时也是版本号，7600是Windows7的发行版本号。
   双击变量：PATH，在其值的末尾补上：C:\NASM;C:\gzip
   目的是为了让我们可以直接在命令行实用nasm以及gzip作为命令行。
   
6. 下载PKCS11，三个文件，右键另存为即可。
   http://svn.openvpn.net/projects/openvpn/test/time/openvpn/pkcs11-headers/
   将三个文件（pkcs11.h、pkcs11f.h、pkcs11t.h）拷贝到源码下的Common文件夹下，我的源码放在D盘根目录，三个源码我就放在“D:\TrueCrypt\Common”文件夹中。
   
7. 编译，会发现有两个错误。
   CKR_NEW_PIN_MODE和CKR_NEXT_OTP未定义，补充定义一下即可。
   在d:\TrueCrypt\Common\pkcs11t.h文件里（请根据您自己的路径进行复制）
   这里将它们设置为：
   
   #define CKR_NEW_PIN_MODE      0x000001B0
   #define CKR_NEXT_OTP          0x000001B1
   
   我的方法是找到实用它的语句附近的同类语句，找到相同的定义，在其下方添加。
   比如：
   
               TC_TOKEN_ERR (CKR_MUTEX_NOT_LOCKED)
               TC_TOKEN_ERR (CKR_NEW_PIN_MODE)
               TC_TOKEN_ERR (CKR_NEXT_OTP)
   
   这三句话放在一起，后两句有问题，但第一句正常，则查找CKR_MUTEX_NOT_LOCKED的存放位置，在其下方添加如上两句，其中定义的值参考
   http://www.cryptsoft.com/pkcs11doc/STANDARD/include/v220/otp-pkcs11.h，这里的值只不过是一种错误码，只要它不重复，就可以了。
   
8. 再编译，可能会遇到一些警告：
   
   1. nasm.exe正在停止，而因为没有正确执行，又导致“fatal error LNK1136: invalid or corrupt file”错误。
      遇到这个可能是因为你的nasm正在试图编译ase_amdX64.asm文件，而nasm对64位的asm编译对你可能意义不大，起码对我而言是这样的，于是，我就将它转成编译x86体系架构的，也许是因为参数配置的问题，你可以尝试别的方案，如果有更好的话，请告诉我。
      这里我搜索：x64、asm等关键字，修改d:\TrueCrypt\Crypto\Makefile.inc文件为下面这样即可：
      
      行1    !if "$(TC_ARCH)" == "x86"
      行2    TC_OBJ_FORMAT = win32
      行3    !else
      行4    #TC_OBJ_FORMAT = win64
      行5    #edit by gocool, if the x64 system need the nasm.exe use the x64 format parameters for executing.
      行6    #abort the x64 system here for building.
      行7    #2009/12/23
      行8    TC_OBJ_FORMAT = win32
      行9    TC_ARCH = x86
      行10    !endif
      行11   
      行12    "$(OBJ_PATH)\$(O)\Aes_$(TC_ARCH).obj": Aes_$(TC_ARCH).asm
      行13        nasm.exe -Xvc -f $(TC_OBJ_FORMAT) -Ox -D DLL_EXPORT -o "$@" -l "$(OBJ_PATH)\$(O)\Aes_$(TC_ARCH).lst" Aes_$(TC_ARCH).asm
      
      其中，为了减少变化量，也利于以后恢复，第4-7行为注释，第8、9行我将非x86的情况也定义成x86的情况，这样无论如何下面第13行的语句都将执行以x86体系为结构的设置，而这样的设置通常是正确的。
      
   2. 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
      听说有两种方法，一种是方法1，需要下载补丁，我没有尝试。第二种通过修改配置的方法我成功了，步骤如下：
      方法：项目->属性->链接器->常规   下面的“启用增量链接”，将“是(/INCREMENTAL)”改为“否(/INCREMENTAL:NO)”。
      不过这又引入了另外一个警告：3>FormatCom.obj : warning LNK4075: 忽略“/EDITANDCONTINUE”(由于“/INCREMENTAL:NO”规范)
      选择项目,属性->配置属性->C/C++，修改“调试信息格式”为“程序数据库(/Zi)”即可。
      
   3. 警告：未找到下列环境变量
      
      4>项目 : warning PRJ0018 : 未找到下列环境变量:
      4>$(PKCS11_INC)
      
      由于项目属性里设置有附加包含目录“$(PKCS11_INC)”，因此编译的时候会在系统变量里寻找PKCS11_INC项目，如果找不到，则给出警告，因此，我们需要手动补充这个项。方法同步骤5，增加一个变量为PKCS11_INC，值：D:\TrueCrypt\Common，其中，值就是之前我们拷贝三个文件（pkcs11.h、pkcs11f.h、pkcs11t.h）的目录。
      
   4. 如果不出意外的话，你可能还会得到一个使用了PKEY_AppUserModel_ID未定义的声明符的错误。这个是用于标识用户态应用程序的唯一标识。你可以在Setup.h文件中定义：
      /*---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---*/
      
      其中，这个结构体是由GUID和PID共同组成的。
      

下载链接

参考链接

• 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

原文链接：http://www.cppblog.com/mymsdn/archive/2009/03/06/quicksort.aspx （未修复）

关于修复BUG后的代码，将在本文中提供，原文中不进行修改，但会有提示指明是错误的，有兴趣的朋友也可以直接在原文的代码中寻找错误来锻炼自己排错的能力。

下面就是几段代码：

Algorithms.cpp

#include "StdAfx.h"
#include "Algorithms.h"
Algorithms::Algorithms(void)
{
}

Algorithms::~Algorithms(void)
{
}

Algorithms.h

#pragma once

#include <iostream>

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    }
            中，前两段（行号，行号）中的代码均返回false，
            则无法进入++i或者--j，那么在这个while(true)中，
            i和j的值将无法发生变化，从而导致死循环。
    @LINK:http://www.cppblog.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，将+1的动作放在循环内。
    while(true)
    {
        while(cmp < arr[++i]) // bug200910280001:将原本在循环外的min+1，移进循环内，并首先+1
            ; // bug200910280001:将++1移至while条件中。
        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//"<<msg;
    std::cout<<std::endl;
}

cpp_quickSort.cpp

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

#include "stdafx.h"
#include "Algorithms.h"
#include <iostream>
#include <vector>
#include <algorithm>

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<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    Algorithms::QuickSort(arr, arr_begin, arr_length);

    std::cout << "result array :\t";
    for(size_t i = arr_begin; i != arr_length; ++i)
    {
        std::cout<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    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<<std::endl;

    std::sort(vec.begin(), vec.end());

    for(std::vector<int>::iterator iter = vec.begin();
        iter != vec.end(); ++ iter)
    {
        std::cout<<*iter<<" ";
    }
    std::cout<<std::endl;

    return 0;
}

1. 什么是空指针常量（null pointer constant）?
   
   [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.
   
   这里告诉我们：0、0L、'\0'、3 - 3、0 * 17 （它们都是“integer constant expression”）以及 (void*)0 （tyc： 我觉得(void*)0应该算是一个空指针吧，更恰当一点）等都是空指针常量（注意 (char*) 0 不叫空指针常量，只是一个空指针值）。至于系统选取哪种形式作为空指针常量使用，则是实现相关的。一般的 C 系统选择 (void*)0 或者 0 的居多（也有个别的选择 0L）；至于 C++ 系统，由于存在严格的类型转化的要求，void* 不能象 C 中那样自由转换为其它指针类型，所以通常选 0 作为空指针常量（tyc: C++标准推荐），而不选择 (void*)0。
   
   
2. 什么是空指针（null pointer）?
   
   [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.
   
   因此，如果 p 是一个指针变量，则 p = 0;、p = 0L;、p = '\0';、p = 3 - 3;、p = 0 * 17; 中的任何一种赋值操作之后（对于 C 来说还可以是 p = (void*)0;）， p 都成为一个空指针，由系统保证空指针不指向任何实际的对象或者函数。反过来说，任何对象或者函数的地址都不可能是空指针。（tyc: 比如这里的(void*)0就是一个空指针。把它理解为null pointer还是null pointer constant会有微秒的不同，当然也不是紧要了）
   
   
3. 什么是 NULL？
   
   [6.3.2.3-Footnote] The macro NULL is defined in <stddef.h> (and other headers) as a null pointer constant
   
   即 NULL 是一个标准规定的宏定义，用来表示空指针常量。因此，除了上面的各种赋值方式之外，还可以用 p = NULL; 来使 p 成为一个空指针。（tyc：很多系统中的实现：#define NULL (void*)0，与这里的“a null pointer constant”并不是完全一致的）
   
   
4. 空指针（null pointer）指向了内存的什么地方（空指针的内部实现）？
   
   标准并没有对空指针指向内存中的什么地方这一个问题作出规定，也就是说用哪个具体的地址值（0x0 地址还是某一特定地址）表示空指针取决于系统的实现。我们常见的空指针一般指向 0 地址，即空指针的内部用全 0 来表示（zero null pointer，零空指针）；也有一些系统用一些特殊的地址值或者特殊的方式表示空指针（nonzero null pointer，非零空指针），具体请参见C FAQ。
   
   幸运的是，在实际编程中不需要了解在我们的系统上空指针到底是一个 zero null pointer 还是 nonzero null pointer，我们只需要了解一个指针是否是空指针就可以了——编译器会自动实现其中的转换，为我们屏蔽其中的实现细节。注意：不要把空指针的内部表示等同于整数 0 的对象表示——如上所述，有时它们是不同的。
   
   
5. 如何判断一个指针是否是一个空指针？
   
   这可以通过与空指针常量或者其它的空指针的比较来实现（注意与空指针的内部表示无关）。例如，假设 p 是一个指针变量，q 是一个同类型的空指针，要检查 p 是否是一个空指针，可以采用下列任意形式之一——它们在实现的功能上都是等价的，所不同的只是风格的差别。
   
   指针变量 p 是空指针的判断：
   if ( p == 0 )
   if ( p == '\0' )
   if ( p == 3 - 3 )
   if ( p == NULL )  /* 使用 NULL 必须包含相应的标准库的头文件 */
   if ( NULL == p )
   if ( !p )
   if ( p == q )
   ...
   
   指针变量 p 不是空指针的判断：
   if ( p != 0 )
   if ( p != '\0' )
   if ( p != 3 - 3 )
   if ( p != NULL )  /* 使用 NULL 必须包含相应的标准库的头文件 */
   if ( NULL != p )
   if ( p )
   if ( p != q )
   ...
   
   
6. 可以用 memset 函数来得到一个空指针吗？
   
   这个问题等同于：如果 p 是一个指针变量，那么
   
   memset( &p, 0, sizeof(p) ); 和 p = 0;
   
   是等价的吗？
   
   答案是否定的，虽然在大多数系统上是等价的，但是因为有的系统存在着“非零空指针” （nonzero null pointer），所以这时两者不等价。由于这个原因，要注意当想将指针设置为空指针的时候不应该使用 memset，而应该用空指针常量或空指针对指针变量赋值或者初始化的方法。
   
   
7. 可以定义自己的 NULL 的实现吗？兼答"NULL 的值可以是 1、2、3 等值吗？"类似问题
   
   [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 是标准库中的一个符合上述条件的 reserved identifier （保留标识符）。所以，如果包含了相应的标准头文件而引入了 NULL 的话，则再在程序中重新定义 NULL 为不同的内容是非法的，其行为是未定义的。也就是说，如果是符合标准的程序，其 NULL 的值只能是 0，不可能是除 0 之外的其它值，比如 1、2、3 等。
   
   
8. malloc 函数在分配内存失败时返回 0 还是 NULL？
   
   malloc 函数是标准 C 规定的库函数。在标准中明确规定了在其内存分配失败时返回的是一个 “null pointer”（空指针）：
   
   [7.20.3-1] If the space cannot be allocated, a null pointer is returned.
   
   对于空指针值，一般的文档（比如 man）中倾向于用 NULL 表示，而没有直接说成 0。但是我们应该清楚：对于指针类型来说，返回 NULL 和 返回 0 是完全等价的，因为 NULL 和 0 都表示 “null pointer”（空指针）。（tyc：一般系统中手册中都返回NULL，那我们就用NULL吧）

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

原理，因为2的20次方就是1MB（2的10次方为1KB，2的30次方为1GB，以此类推）。

如果你请求分配的内存块小于1MB，你得到的内存是否比这要多一些呢？为什么？

答：

这不是绝对的！

在本例中使用

1<<22（4MB）得到的结果乘4是2000MB

1<<21（2MB）得到的结果乘2是1972MB

1<<20（1MB）得到的结果是1918MB

1<<19（0.5MB）得到的结果除2是1812MB

1<<18（0.25MB）得到的结果除4是2003MB

1<<17（0.125MB）得到的结果除8是2034MB

显然出现了一个意外的结果。

#include <stdio.h>
#include <stdlib.h>

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很明显会出现问题，原因是因为char deciduous[]是局部变量，在函数调用返回后，就释放了。

favorite_fruit2因为使用了static，而static限定了变量被保存在数据段（data segment）中，它的声明周期同程序一样长。所以不会出错。

favorite_fruit3是另一种有效的写法，其原理同2。

• 数据段保存在目标文件中。
• BSS段不保存在目标文件中（除了记录BSS段在运行时所需要的大小）。
• 文本段是最容易受优化措施影响的段。
• a.out文件的大小受调试状态下编译的影响，但段不受影响。

2、早期的gets()中的Bug导致了Internet蠕虫（P42）

gets()函数并不检查缓冲区的空间，事实上它也无法检查缓冲区的空间。如果函数的调用者提供了一个指向堆栈的指针，并且gets()函数读入的字符数量超过缓冲区的空间，gets()函数将会愉快地将多出来的字符继续写入到堆栈中，这就覆盖了堆栈原先的内容。——这就是病毒利用它来写入额外空间，并引发蠕虫病毒的前提。

推荐的方式是将

gets(line)

替换为

if(fgets(line, sizeof(line), stdin) == NULL)

exit(1);

3、相邻字符串常量自动连接（P45）

这个其实已经应用很普遍了，但是我个人用的比较少，特此记录一下。

4、返回一个指针？（P48）

这个话题围绕一个程序的BUG来展开，这个程序返回了局部变量的值的指针，这么说当然你一眼就能看得出来问题所在，但是在很多时候，这个错误却总是在你的眼皮子底下溜走。

作者提供了五种方式，只能说可以用，但唯一推荐的只有一个，详见作者的分析（P48）（不是什么高深的理论，你自己也能分析地出来）。

a.返回一个字符串常量的指针。因为常量存在静态数据存储区，所以指针没问题。

b.使用全局声明的数组。提到全局两个字，就知道这个方法有很大的局限性。

c.使用静态数组。下一次调用将覆盖这个数组内容。

char * func() {

static char buffer[20];

…

return buffer;

}

d.显式分配一些内存，保存返回的值。

char  * func() {

char * s = malloc(120);

…

return s;

}

既然用到了malloc，就必然伴随着free，因此带来了内存管理的问题，增加了开发者负担。

e.（推荐）在调用前后，由函数调用者分配内存，并由其释放，在同一地方释放对于内存管理来说代价相对最小。

void func( char * result, int size) {

…

strncpy(result, “That’d be in the data segment, Bob”, size);

}

buffer = malloc(size);

func(buffer, size);

…

free(buffer);

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

Algorithms.h

#pragma once

#include <iostream>

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

用法：（顺便有标准库的排序法，当然只是调一下，没有什么可说的了）

#include "Algorithms.h"
#include <iostream>
#include <vector>
#include <algorithm>

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<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    Algorithms::QuickSort(arr,0, 7);

    for(size_t i = 0; i != 8; ++i)
    {
        std::cout<<arr[i]<<" ";
    }
    std::cout<<std::endl;

    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<<std::endl;

    std::sort(vec.begin(), vec.end());

    for(std::vector<int>::iterator iter = vec.begin();
        iter != vec.end(); ++ iter)
    {
        std::cout<<*iter<<" ";
    }
    std::cout<<std::endl;

    return 0;
}