ASM/C/C++

[转载] Microsoft Visual C++ 浮点优化

周星星 — Sun, 01 Mar 2009 04:53:00 GMT

Microsoft Visual C++ 浮点优化

原址：http://msdn.microsoft.com/en-us/library/aa289157(VS.71).aspx

Eric Fleegal
Microsoft Corporation
适用于：Microsoft Visual C++

C++ 中的浮点代码优化
C++ 优化编译器不仅能够将源代码转换为机器码，而且能够对机器指令进行适当的排列以便改善性能和/或减小大小。遗憾的是，许多常用的优化在应用于浮点计算时未必安全。在下面的求和算法 [1] 中，可以看到这方面的一个恰当的示例：
float KahanSum( const float A[], int n )
{
   float sum=0, C=0, Y, T;
   for (int i=0; i<n; i++)
   {
      Y = A[i] - C;
      T = sum + Y;
      C = T - sum - Y;
      sum = T;
   }
   return sum;
}

该函数将数组向量 A 中的 n 个浮点值相加。在循环体中，算法计算一个“修正”值，然后将其应用于求和的下一步。与简单的求和相比，该方法大大减小了累积性舍入误差，同时保持了 O(n) 时间复杂性。
一个不完善的 C++ 编译器可能假设浮点算法遵循与实数算法相同的代数规则。这样的编译器可能继而错误地断定
C = T - sum - Y ==> (sum+Y)-sum-Y ==> 0;
也就是说，C 得到的值总是常量零。如果随后将该常量值传播到后续表达式中，循环体将化简为简单的求和。更准确地说，就是
Y = A[i] - C ==> Y = A[i]
T = sum + Y ==> T = sum + A[i]
sum = T ==> sum = sum + A[i]
因此，对于不完善的编译器而言，KahanSum 函数的逻辑转换将是：
float KahanSum( const float A[], int n )
{
   float sum=0; // C, Y & T are now unused
   for (int i=0; i<n; i++)
      sum = sum + A[i];
   return sum;
}

尽管转换后的算法更快，但它根本没有准确表达程序员的意图。精心设计的误差修正已经被完全消除，只剩下一个具有所有其关联误差的简单的直接求和算法。
当然，完善的 C++ 编译器知道实数算法的代数规则通常并不适用于浮点算法。然而，即使是完善的 C++ 编译器，也可能错误地解释程序员的意图。
考虑一种常见的优化措施，它试图在寄存器中存放尽可能多的值（称为“登记”值）。在 KahanSum 示例中，这一优化可能试图登记变量 C、Y 和 T，因为这些变量仅在循环体内使用。如果寄存器精度为 52 位（双精度）而不是 23 位（单精度），这一优化可以有效地将 C、Y 和 T 的类型提升为 double。如果没有以同样的方式登记 sum 变量，则它仍将编码为单精度。这会将 KahanSum 的语义转换为下面的语义
float KahanSum( const float A[], int n )
{
   float sum=0;
   double C=0, Y, T; // now held in-register
   for (int i=0; i<n; i++)
   {
      Y = A[i] - C;
      T = sum + Y;
      C = T - sum - Y;
      sum = (float) T;
   }
   return sum;
}

尽管现在 Y、T 和 C 以更高的精度进行计算，但新的编码可能产生精确性较低的结果，具体取决于 A[] 中的值。因而，即使看起来无害的优化也可能具有消极的后果。
这些种类的优化问题并不局限于“棘手”的浮点代码。即使是简单的浮点算法，在经过错误的优化后也可能失败。考虑一个简单的直接求和算法：
float Sum( const float A[], int n )
{
   float sum=0;
   for (int i=0; i<n; i++)
      sum = sum + A[i];
   return sum;
}

因为一些浮点单元能够同时执行多个运算，所以编译器可能选择采用标量简化优化。这一优化有效地将简单的 Sum 函数从上述形式转换为以下形式：
float Sum( const float A[], int n )
{
   int n4 = n-n%4; // or n4=n4&(~3)
   int i;
   float sum=0, sum1=0, sum2=0, sum3=0;
   for (i=0; i<n4; i+=4)
   {
      sum = sum + A[i];
      sum1 = sum1 + A[i+1];
      sum2 = sum2 + A[i+2];
      sum3 = sum3 + A[i+3];
   }
   sum = sum + sum1 + sum2 + sum3;
   for (; i<n; i++)
      sum = sum + A[i];
   return sum;
}

该函数现在保持了四个独立的求和运算，它们可以在每个步骤同时处理。尽管优化后的函数现在要快得多，但优化结果可能与非优化结果完全不同。在进行这一变化时，编译器采用了具有结合律的浮点加法；即以下两个表达式等效：(a+b)+c == a+(b+c)。然而，对于浮点数而言，结合律并不总是适用。现在，转换后的函数不是按以下方法求和：
sum = A[0]+A[1]+A[2]+...+A[n-1]
而是按以下方法计算结果：
sum = (A[0]+A[4]+A[8]+...)
      +(A[1]+A[5]+A[9]+...)
      +(A[2]+A[6]+A[10]+...)
      +(A[3]+A[7]+A[11]+...)
      +...
对于 A[] 的某些值而言，不同的加法运算顺序可能产生意外的结果。更为复杂的是，某些程序员可能选择预先针对此类优化做准备，并相应地对这些优化进行补偿。在此情况下，程序可以按不同的顺序构建数组 A，以便优化的 sum 产生预期的结果。而且，在许多情况下，优化结果的精确性可能“足够严密”。当优化提供了令人信服的速度优点时，尤其如此。例如，视频游戏要求具有尽可能快的速度，但通常并不要求进行高度精确的浮点计算。因此，编译器制造商必须为程序员提供一种机制，以便控制速度和精确性之间经常背离的目标。
某些编译器通过为每种类型的优化单独提供“开关”在速度和精确性之间进行折衷。这使开发人员可以禁用可能为其特定应用程序的浮点精确性带来变化的优化。尽管该解决方案可能提供对编译器的高度控制，但它也会带来其他一些问题：
? 通常很难搞清楚需要启用或禁用哪些开关。
? 禁用任一优化都可能对非浮点代码的性能带来不利影响。
? 每个附加的开关都会引起许多新的开关组合；组合数目将很快变得难以控制。

因此，尽管为每种优化提供单独的开关看起来似乎很有吸引力，但使用此类编译器可能非常麻烦并且不可靠。
许多 C++ 编译器提供了“一致性”浮点模型（通过 /Op 或 /fltconsistency 开关），从而使开发人员能够创建符合严格浮点语义的程序。采用该模型时，可以防止编译器对浮点计算使用大多数优化，同时允许其对非浮点代码使用这些优化。但是，该一致性模型具有一个缺点。为了在不同的 FPU 体系结构中返回可预测的结果，几乎所有 /Op 实现都将中间表达式舍入到用户指定的精度；例如，考虑下面的表达式：
float a, b, c, d, e;
. . .
a = b*c + d*e;
为了在使用 /Op 开关时产生一致的且可重复的结果，该表达式的计算方式按如下方式实现：
float x = b*c;
float y = d*e;
a = x+y;
现在，最终结果在计算该表达式的每一步中都产生了单精度舍入误差。尽管这种解释在严格意义上并未破坏任何 C++ 语义规则，但它几乎肯定不是计算浮点表达式的最佳方法。通常，以尽可能高的可行精度计算中间结果更为可取。例如，以如下所示的较高精度计算表达式 a=b*c+d*e 将会更好：
double x = b*c;
double y = d*e;
double z = x+y;
a = (float)z;
或者，采用以下方式会更好：
long double x = b*c;
long double y = d*e
long double z = x+y;
a = (float)z;
在以较高精度计算中间结果时，最终结果显然会更为精确。具有讽刺意味的是，如果采用一致性模型，则当用户试图通过禁用不安全的优化来减少误差时，出现误差的可能性却恰恰增加了。因此，一致性模型不仅严重降低了效率，同时还无法对精确性的提高提供任何保证。对于认真的数值程序员而言，这看起来不像是一个很好的折衷，这也是该模型没有被广泛接受的主要原因。
从版本 8.0 (Visual C++?2005) 开始，Microsoft C++ 编译器提供了一种更好的选择。它使程序员可以选择以下三种常规浮点模式之一：fp:precise、fp:fast 和 fp:strict。

本文来自: 乘风原创程序(http://www.qqcf.com) 详细出处参考：http://study.qqcf.com/web/217/23399.htm

小心前置声明

周星星 — Tue, 07 Oct 2008 02:34:00 GMT

原文章来源： http://bbs.pfan.cn/post-286402.html，作者：eastcowboy

// 前置声明
struct foo;
foo& create_foo();

// 调用foo::operator&和foo::~foo
int main()
{
foo& a = create_foo();
delete &a;

return 0;
}

// 一般放在另一个不同的文件中
#include <iostream>
using namespace std;

struct foo
{
    foo()
    {
        cout << "foo()" << endl;
    }
    foo( const foo& )
    {
        cout << "foo( const foo& )" << endl;
    }
    foo& operator=( const foo& )
    {
        cout << "operator=" << endl;
        return *this;
    }
    ~foo()
    {
        cout << "~foo()" << endl;
    }
private:
    const foo* operator&() const
    {
        cout << "operator&" << endl;
        return this;
    }
    foo* operator&()
    {
        cout << "operator&" << endl;
        return this;
    }
};

foo& create_foo()
{
return *new foo;
}

tree容器（0.0.0.4 版）

周星星 — Thu, 03 Apr 2008 06:13:00 GMT

// tree.hpp

#ifndef TREE_HEADER__
#define TREE_HEADER__

#include <iostream>

template<typename T> class tree;
template<typename T> std::basic_ostream<char>& operator<<( std::basic_ostream<char>&, const tree<T>& );
//template<typename T> std::basic_ostream<wchar_t>& operator<<( std::basic_ostream<wchar_t>&, const tree<T>& );

////// definition /////////////////////////////////////////////////////////

template<typename T>
class tree
{
    friend std::basic_ostream<char>& operator<< <T>( std::basic_ostream<char>&, const tree<T>& );
    //friend std::basic_ostream<wchar_t>& operator<< <T>( std::basic_ostream<wchar_t>&, const tree<T>& );
public:
    typedef T value_type;

    tree();
    explicit tree( const T& t );
    tree( const tree& rhs );
    tree& operator=( const tree& rhs );
    ~tree();

T& val();
const T& val() const;

    tree& parent();
    tree& left();
    tree& right();
    tree& childfirst();
    tree& childlast();
    const tree& parent() const;
    const tree& left() const;
    const tree& right() const;
    const tree& childfirst() const;
    const tree& childlast() const;

tree& root();
const tree& root() const;

    tree* traverse_front();
    tree* traverse_back();
    tree* traverse_next( int& depth_diff = *(int*)0 );
    tree* traverse_prev( int& depth_diff = *(int*)0 );
    const tree* traverse_front() const;
    const tree* traverse_back() const;
    const tree* traverse_next( int& depth_diff = *(int*)0 ) const;
    const tree* traverse_prev( int& depth_diff = *(int*)0 ) const;

    template<class F> F traverse( F f, int start_depth_diff, tree<T>* from, tree<T>* to );
    template<class F> F traverse( F f, int start_depth_diff, tree<T>* from );
    template<class F> F traverse( F f, int start_depth_diff );
    template<class F> F traverse( F f, int start_depth_diff, const tree<T>* from, const tree<T>* to ) const;
    template<class F> F traverse( F f, int start_depth_diff, const tree<T>* from ) const;
    template<class F> F traverse( F f, int start_depth_diff ) const;
    template<class F> F traverse_reverse( F f, int start_depth_diff, tree<T>* from, tree<T>* to );
    template<class F> F traverse_reverse( F f, int start_depth_diff, tree<T>* from );
    template<class F> F traverse_reverse( F f, int start_depth_diff );
    template<class F> F traverse_reverse( F f, int start_depth_diff, const tree<T>* from, const tree<T>* to ) const;
    template<class F> F traverse_reverse( F f, int start_depth_diff, const tree<T>* from ) const;
    template<class F> F traverse_reverse( F f, int start_depth_diff ) const;

    void erase();
    void erasesubs();
    tree& addfirstchild( const T& t=T() );
    tree& addright( const T& t=T() );

void swap( tree& t );

    size_t cal_bin_size() const;
    size_t write_to( void* ) const;
    size_t read_from( const void* );
    size_t write_to( std::ostream& ) const;
    size_t read_from( std::istream& );

protected:
void init_();
void destroysubs_();

protected:
    T val_;
    tree* ptrparent_;
    tree* ptrleft_;
    tree* ptrright_;
    tree* ptrchildfirst_;
    tree* ptrchildlast_;

#ifndef TREE_DEBUG__
};
#else
public:
    static int m;
    static void* operator new( size_t n )
    {
        ++m;
        return ::operator new(n);
    }
    static void operator delete( void* p )
    {
        --m;
        ::operator delete(p);
    }
};
template<class T> int tree<T>::m = 0;
#endif

#define TREE_MACRO_TRAVERSE_BEGIN( type, start_depth_diff, from, to, next ) \
{                                                                           \
    type* to_ = to;                                                         \
    int depth_diff = start_depth_diff;                                      \
    for( type* ptree=from; ptree; )                                         \
    {                                                                       \
        int tmp_dd;                                                         \
        type* tmp_p;                                                        \
        if( ptree != to_ ) tmp_p = ptree->next(tmp_dd);

#define TREE_MACRO_TRAVERSE_END                                             \
        if( ptree == to_ ) break;                                           \
        depth_diff = tmp_dd;                                                \
        ptree = tmp_p;                                                      \
    }                                                                       \
}

////// implement /////////////////////////////////////////////////////////

#include <iomanip>
#include <utility>
#include <cassert>
template<typename T> struct tree_trait;

template<typename T> tree<T>::tree() : val_(T())
{
    init_();
}
template<typename T> tree<T>::tree( const T& t ) : val_(t)
{
    init_();
}
template<typename T> tree<T>::tree( const tree<T>& rhs ) : val_(rhs.val_)
{
    init_();

    tree<T>* p = this;
    TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 1, rhs.traverse_next(), rhs.traverse_back(), traverse_next )
        if( depth_diff > 0 )
        {
            p = &p->addfirstchild( ptree->val_ );
        }
        else
        {
            for( ; depth_diff!=0; ++depth_diff )
                p = p->ptrparent_;

            p = &p->addright( ptree->val_ );
        }
    TREE_MACRO_TRAVERSE_END
}
template<typename T> tree<T>& tree<T>::operator=( const tree<T>& rhs )
{
    if( this != &rhs )
    {
        tree<T> bk = rhs;

destroysubs_();

        std::swap( val_, bk.val_ );
        ptrchildfirst_=bk.ptrchildfirst_; ptrchildfirst_->ptrparent_=this; bk.ptrchildfirst_=0;
        ptrchildlast_ =bk.ptrchildlast_; ptrchildlast_->ptrparent_ =this; bk.ptrchildlast_ =0;
    }
    return *this;
}
template<typename T> tree<T>::~tree()
{
    destroysubs_();
}

template<typename T> inline T& tree<T>::val() { return val_; }
template<typename T> inline const T& tree<T>::val() const { return ((tree*)this)->val(); }

template<typename T> inline tree<T>& tree<T>::parent() { return *ptrparent_; }
template<typename T> inline tree<T>& tree<T>::left() { return *ptrleft_; }
template<typename T> inline tree<T>& tree<T>::right() { return *ptrright_; }
template<typename T> inline tree<T>& tree<T>::childfirst() { return *ptrchildfirst_; }
template<typename T> inline tree<T>& tree<T>::childlast() { return *ptrchildlast_; }
template<typename T> inline const tree<T>& tree<T>::parent() const { return ((tree*)this)->parent(); }
template<typename T> inline const tree<T>& tree<T>::left() const { return ((tree*)this)->left(); }
template<typename T> inline const tree<T>& tree<T>::right() const { return ((tree*)this)->right(); }
template<typename T> inline const tree<T>& tree<T>::childfirst() const { return ((tree*)this)->childfirst(); }
template<typename T> inline const tree<T>& tree<T>::childlast() const { return ((tree*)this)->childlast(); }

template<typename T> tree<T>& tree<T>::root()
{
    tree* p;
    for( p=this; p->ptrparent_; p=p->ptrparent_ );
    return *p;
}
template<typename T> inline const tree<T>& tree<T>::root() const { return ((tree*)this)->root(); }

template<typename T> inline tree<T>* tree<T>::traverse_front()
{
    return this;
}
template<typename T> tree<T>* tree<T>::traverse_back()
{
    tree* p = this;
    for( ; p->ptrchildlast_; p=p->ptrchildlast_ );
    return p;
}
template<typename T> tree<T>* tree<T>::traverse_next( int& depth_diff )
{
    int dd = 0;

    tree* p = this;
    if( p->ptrchildfirst_ )
    {
        p = p->ptrchildfirst_;
        ++dd;
    }
    else if( p->ptrright_ )
    {
        p = p->ptrright_;
    }
    else
    {
        while( 1 )
        {
            p = p->ptrparent_;
            --dd;
            if( !p )
                break;
            if( p->ptrright_ )
            {
                p = p->ptrright_;
                break;
            }
        }
    }

    if( &depth_diff )
        depth_diff = dd;
    return p;
}
template<typename T> tree<T>* tree<T>::traverse_prev( int& depth_diff )
{
    int dd = 0;

    tree* p = this;
    if( p->ptrleft_ )
    {
        p = p->ptrleft_;
        for( ; p->ptrchildlast_; p=p->ptrchildlast_ )
        {
            ++dd;
        }
    }
    else if( p->ptrparent_ )
    {
        p = p->ptrparent_;
        --dd;
    }
    else
        p = 0;

    if( &depth_diff )
        depth_diff = dd;
    return p;
}

template<typename T> inline const tree<T>* tree<T>::traverse_front() const { return ((tree*)this)->traverse_front(); }
template<typename T> inline const tree<T>* tree<T>::traverse_back() const { return ((tree*)this)->traverse_back(); }
template<typename T> inline const tree<T>* tree<T>::traverse_next( int& depth_diff ) const { return ((tree*)this)->traverse_next(depth_diff); }
template<typename T> inline const tree<T>* tree<T>::traverse_prev( int& depth_diff ) const { return ((tree*)this)->traverse_prev(depth_diff); }

template<typename T> template<class F> F tree<T>::traverse( F f, int start_depth_diff, tree<T>* from, tree<T>* to )
{
    TREE_MACRO_TRAVERSE_BEGIN( tree<T>, start_depth_diff, from, to, traverse_next )
        f( ptree, depth_diff );
    TREE_MACRO_TRAVERSE_END
    return f;
}
template<typename T> template<class F> inline F tree<T>::traverse( F f, int start_depth_diff, tree<T>* from )
{
    return traverse( f, start_depth_diff, from, traverse_back() );
}
template<typename T> template<class F> inline F tree<T>::traverse( F f, int start_depth_diff )
{
    return traverse( f, start_depth_diff, traverse_front() );
}
template<typename T> template<class F> F tree<T>::traverse( F f, int start_depth_diff, const tree<T>* from, const tree<T>* to ) const
{
    TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, start_depth_diff, from, to, traverse_next )
        f( ptree, depth_diff );
    TREE_MACRO_TRAVERSE_END
    return f;
}
template<typename T> template<class F> inline F tree<T>::traverse( F f, int start_depth_diff, const tree<T>* from ) const
{
    return traverse( f, start_depth_diff, from, traverse_back() );
}
template<typename T> template<class F> inline F tree<T>::traverse( F f, int start_depth_diff ) const
{
    return traverse( f, start_depth_diff, traverse_front() );
}
template<typename T> template<class F> F tree<T>::traverse_reverse( F f, int start_depth_diff, tree<T>* from, tree<T>* to )
{
    TREE_MACRO_TRAVERSE_BEGIN( tree<T>, start_depth_diff, from, to, traverse_prev )
        f( ptree, depth_diff );
    TREE_MACRO_TRAVERSE_END
    return f;
}
template<typename T> template<class F> inline F tree<T>::traverse_reverse( F f, int start_depth_diff, tree<T>* from )
{
    return traverse_reverse( f, start_depth_diff, from, traverse_front() );
}
template<typename T> template<class F> inline F tree<T>::traverse_reverse( F f, int start_depth_diff )
{
    return traverse_reverse( f, start_depth_diff, traverse_back() );
}
template<typename T> template<class F> F tree<T>::traverse_reverse( F f, int start_depth_diff, const tree<T>* from, const tree<T>* to ) const
{
    TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, start_depth_diff, from, to, traverse_prev )
        f( ptree, depth_diff );
    TREE_MACRO_TRAVERSE_END
    return f;
}
template<typename T> template<class F> inline F tree<T>::traverse_reverse( F f, int start_depth_diff, const tree<T>* from ) const
{
    return traverse_reverse( f, start_depth_diff, from, traverse_front() );
}
template<typename T> template<class F> inline F tree<T>::traverse_reverse( F f, int start_depth_diff ) const
{
    return traverse_reverse( f, start_depth_diff, traverse_back() );
}

template<typename T> void tree<T>::erase()
{
destroysubs_();

    if( ptrparent_ )
    {
        if( ptrleft_ )
            ptrleft_->ptrright_ = ptrright_;
        else
            ptrparent_->ptrchildfirst_ = ptrright_;

        if( ptrright_ )
            ptrright_->ptrleft_ = ptrleft_;
        else
            ptrparent_->ptrchildlast_ = ptrleft_;

        val_.~T();
        operator delete( this );
    }
    else
    {
        ptrchildfirst_ = 0;
        ptrchildlast_ = 0;
        val_ = T();
    }
}
template<typename T> void tree<T>::erasesubs()
{
    destroysubs_();
    ptrchildfirst_ = 0;
    ptrchildlast_ = 0;
}
template<typename T> tree<T>& tree<T>::addfirstchild( const T& t )
{
    tree* pnew = new tree(t);
    if( ptrchildfirst_ )
    {
        ptrchildfirst_->ptrleft_ = pnew;
        pnew->ptrright_ = ptrchildfirst_;
        ptrchildfirst_ = pnew;
        pnew->ptrparent_ = this;
    }
    else
    {
        ptrchildfirst_ = pnew;
        ptrchildlast_ = pnew;
        pnew->ptrparent_ = this;
    }
    return *pnew;
}
template<typename T> tree<T>& tree<T>::addright( const T& t )
{
    assert( ptrparent_ );

    tree* pnew = new tree(t);
    pnew->ptrparent_ = ptrparent_;
    pnew->ptrleft_ = this;
    pnew->ptrright_ = ptrright_;
    if( ptrright_ )
        ptrright_->ptrleft_ = pnew;
    else
        ptrparent_->ptrchildlast_ = pnew;
    ptrright_ = pnew;

return *pnew;
}

template<typename T> void tree<T>::swap( tree<T>& t )
{
    if( this != &t )
    {
#ifdef _DEBUG
        for( tree<T>* p=this; p; p=p->ptrparent_ ) assert( p != &t   );
        for( tree<T>* p=&t;   p; p=p->ptrparent_ ) assert( p != this );
#endif
        std::swap( val_, t.val_ );

        if( ptrchildfirst_ )
        {
            ptrchildfirst_->ptrparent_ = &t;
            ptrchildlast_->ptrparent_ = &t;
        }
        if( t.ptrchildfirst_ )
        {
            t.ptrchildfirst_->ptrparent_ = this;
            t.ptrchildlast_->ptrparent_ = this;
        }

        tree* p;
        p=ptrchildfirst_; ptrchildfirst_=t.ptrchildfirst_; t.ptrchildfirst_=p;
        p=ptrchildlast_; ptrchildlast_ =t.ptrchildlast_; t.ptrchildlast_ =p;
    }
}
namespace std
{
    template<typename T> inline void swap( tree<T>& lhs, tree<T>& rhs )
    {
        return lhs.swap( rhs );
    }
}

namespace
{
    inline size_t fit_size( size_t n )
    {
        return (n+sizeof(size_t)-1)/sizeof(size_t)*sizeof(size_t);
    }
    template<typename T, bool IS_SOLID=true> struct cal_bin_size_
    {
        // [ size_t:depth, T:val(algin align of size_t) ], ..., size_t:0
        size_t operator()( const tree<T>& t )
        {
            size_t n=0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                ++n;
            TREE_MACRO_TRAVERSE_END

            return n*( sizeof(size_t) + fit_size(sizeof(T)) ) + sizeof(size_t);
        }
    };
    template<typename T> struct cal_bin_size_<T,false>
    {
        // [ size_t:depth, size_t:val_size, T:val(algin align of size_t) ], ..., size_t:0
        size_t operator()( const tree<T>& t )
        {
            size_t n=0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                n += sizeof(size_t) + sizeof(size_t) + fit_size(tree_trait<T>::bin_size(ptree->val()));
            TREE_MACRO_TRAVERSE_END

            return n + sizeof(size_t);
        }
    };

    template<typename T, bool IS_SOLID=true> struct write_to_
    {
        size_t operator()( const tree<T>& t, void* dst )
        {
            // [ size_t:depth, T:val(algin align of size_t) ], ..., size_t:0
            char* pdst = (char*)dst;
            size_t fill = 0;

            size_t depth = 0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                depth += depth_diff;
                *(size_t*)pdst = depth; pdst+=sizeof(size_t);
                *(T*)pdst = ptree->val(); pdst+=sizeof(T);
                if( sizeof(T)%sizeof(size_t) != 0 ) // fill interval with 0
                    for( size_t i=0; i<sizeof(size_t)-sizeof(T)%sizeof(size_t); ++i )
                        *pdst++ = 0;
            TREE_MACRO_TRAVERSE_END
            *(size_t*)pdst = 0; pdst+=sizeof(size_t);

return pdst-(char*)dst;
}

        size_t operator()( const tree<T>& t, std::ostream& dst )
        {
            // [ size_t:depth, T:val(algin align of size_t) ], ..., size_t:0
            size_t n = 0;
            size_t depth = 0;
            const size_t bk = 0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                depth += depth_diff;
                dst.write( (const char*)&depth, sizeof(depth) ); n+=sizeof(size_t); assert( dst );
                dst.write( (const char*)&ptree->val(), sizeof(T) ); n+=sizeof(T); assert( dst );
                if( sizeof(T)%sizeof(size_t) != 0 ) // fill interval with 0
                {
                    dst.write( (const char*)&bk, sizeof(size_t)-sizeof(T)%sizeof(size_t) ); n+=sizeof(size_t)-sizeof(T)%sizeof(size_t); assert( dst );
                }
            TREE_MACRO_TRAVERSE_END

dst.write( (const char*)&bk, sizeof(size_t) ); n+=sizeof(size_t); assert( dst );

            return n;
        }
    };

    template<typename T> struct write_to_<T,false>
    {
        size_t operator()( const tree<T>& t, void* dst )
        {
            // [ size_t:depth, size_t:val_size, T:val(algin align of size_t) ], ..., size_t:0
            char* pdst = (char*)dst;

            size_t depth = 0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                depth += depth_diff;
                *(size_t*)pdst = depth; pdst+=sizeof(size_t);
                size_t len = tree_trait<T>::bin_size(ptree->val()); *(size_t*)pdst = len; pdst+=sizeof(size_t);
                tree_trait<T>::bin_write( ptree->val(), pdst ); pdst+=len;
                if( len%sizeof(size_t) != 0 ) // fill interval with 0
                    for( size_t i=0; i<sizeof(size_t)-len%sizeof(size_t); ++i )
                        *pdst++ = 0;
            TREE_MACRO_TRAVERSE_END
            *(size_t*)pdst = 0; pdst+=sizeof(size_t);

return pdst-(char*)dst;
}

        size_t operator()( const tree<T>& t, std::ostream& dst )
        {
            // [ size_t:depth, size_t:val_size, T:val(algin align of size_t) ], ..., size_t:0
            size_t n = 0;
            size_t depth = 0;
            const size_t bk = 0;
            TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
                depth += depth_diff;
                dst.write( (const char*)&depth, sizeof(depth) ); n+=sizeof(size_t); assert( dst );
                size_t len = tree_trait<T>::bin_size(ptree->val()); dst.write( (const char*)&len, sizeof(size_t) ); n+=sizeof(size_t); assert( dst );
                tree_trait<T>::bin_write( ptree->val(), dst ); n+=len; assert( dst );
                if( len%sizeof(size_t) != 0 ) // fill interval with 0
                {
                    dst.write( (const char*)&bk, (std::streamsize)(sizeof(size_t)-len%sizeof(size_t)) ); n+=sizeof(size_t)-len%sizeof(size_t); assert( dst );
                }
            TREE_MACRO_TRAVERSE_END
            dst.write( (const char*)&bk, sizeof(size_t) ); n+=sizeof(size_t); assert( dst );

            return n;
        }
    };

    template<typename T, bool IS_SOLID=true> struct read_from_
    {
        size_t operator()( tree<T>& t, const void* src )
        {
            // [ size_t:depth, T:val(algin align of size_t) ], ..., size_t:0
            const char* psrc = (const char*)src;
            size_t fz = fit_size(sizeof(T));

            t.erasesubs();
            size_t depth_begin = *(size_t*)psrc; psrc+=sizeof(size_t);
            t.val() = *(T*)psrc; psrc+=fz;
            tree<T>* p = &t;

            size_t depth_pre = depth_begin;
            size_t depth = *(size_t*)psrc; psrc+=sizeof(size_t);
            while( depth != depth_begin )
            {
                if( depth == depth_pre )
                {
                    p=&p->addright( *(T*)psrc ); psrc+=fz;
                }
                else if( depth > depth_pre )
                {
                    assert( depth = depth_pre+1 );
                    p=&p->addfirstchild( *(T*)psrc ); psrc+=fz;
                }
                else
                {
                    for( size_t i=depth; i!=depth_pre; ++i )
                        p = &p->parent();
                    p=&p->addright( *(T*)psrc ); psrc+=fz;
                }
                depth_pre = depth;
                depth = *(size_t*)psrc; psrc+=sizeof(size_t);
            }

return psrc-(char*)src;
}

        size_t operator()( tree<T>& t, std::istream& src )
        {
            // [ size_t:depth, T:val(algin align of size_t) ], ..., size_t:0
            size_t n = 0;
            size_t w = 0;
            size_t y = sizeof(size_t) - sizeof(T) % sizeof(size_t);

            t.erasesubs();
            size_t depth_begin = 0;
            src.read( (char*)&depth_begin, sizeof(size_t) ); n+=sizeof(size_t);
            assert( src && src.gcount()==sizeof(size_t) );
            src.read( (char*)&t.val(), sizeof(T) ); n+=sizeof(T);
            assert( src && src.gcount()==sizeof(T) );
            if( sizeof(T)%sizeof(size_t) )
            {
                src.read( (char*)&w, (std::streamsize)y ); n += y;
                assert( src && src.gcount()==y );
            }
            tree<T>* p = &t;

            size_t depth_pre = depth_begin;
            size_t depth = 0; src.read( (char*)&depth, sizeof(size_t) ); n+=sizeof(size_t);
            assert( src && src.gcount()==sizeof(size_t) );
            while( depth != depth_begin )
            {
                if( depth == depth_pre )
                {
                    p=&p->addright();
                }
                else if( depth > depth_pre )
                {
                    assert( depth = depth_pre+1 );
                    p=&p->addfirstchild();
                }
                else
                {
                    for( size_t i=depth; i!=depth_pre; ++i )
                        p = &p->parent();
                    p=&p->addright();
                }
                src.read( (char*)&p->val(), sizeof(T) ); n+=sizeof(T);
                assert( src && src.gcount()==sizeof(T) );
                if( sizeof(T)%sizeof(size_t) )
                {
                    src.read( (char*)&w, (std::streamsize)y ); n += y;
                    assert( src && src.gcount()==y );
                }

                depth_pre = depth;
                src.read( (char*)&depth, sizeof(size_t) ); n+=sizeof(size_t);
                assert( src && src.gcount()==sizeof(size_t) );
            }

            return n;
        }
    };

    template<typename T> struct read_from_<T,false>
    {
        size_t operator()( tree<T>& t, const void* src )
        {
            // [ size_t:depth, size_t:val_size, T:val(algin align of size_t) ], ..., size_t:0
            const char* psrc = (const char*)src;

            t.erasesubs();
            size_t depth_begin = *(size_t*)psrc; psrc+=sizeof(size_t);
            size_t n = *(size_t*)psrc; psrc+=sizeof(size_t);
            size_t m = tree_trait<T>::bin_read( t.val(), n, psrc ); psrc+=fit_size(m);
            assert( m == n );
            tree<T>* p = &t;

            size_t depth_pre = depth_begin;
            size_t depth = *(size_t*)psrc; psrc+=sizeof(size_t);
            while( depth != depth_begin )
            {
                if( depth == depth_pre )
                {
                    p=&p->addright();
                }
                else if( depth > depth_pre )
                {
                    assert( depth = depth_pre+1 );
                    p=&p->addfirstchild();
                }
                else
                {
                    for( size_t i=depth; i!=depth_pre; ++i )
                        p = &p->parent();
                    p=&p->addright();
                }
                n = *(size_t*)psrc; psrc+=sizeof(size_t);
                m = tree_trait<T>::bin_read( p->val(), n, psrc ); psrc+=fit_size(m);
                assert( m == n );

                depth_pre = depth;
                depth = *(size_t*)psrc; psrc+=sizeof(size_t);
            }

return psrc-(char*)src;
}

        size_t operator()( tree<T>& t, std::istream& src )
        {
            // [ size_t:depth, size_t:val_size, T:val(algin align of size_t) ], ..., size_t:0
            size_t n = 0;
            size_t w = 0;

            t.erasesubs();
            size_t depth_begin = 0;
            src.read( (char*)&depth_begin, sizeof(size_t) ); n+=sizeof(size_t);
            assert( src && src.gcount()==sizeof(size_t) );
            size_t m = 0;
            src.read( (char*)&m, sizeof(size_t) ); n+=sizeof(size_t);
            assert( src && src.gcount()==sizeof(size_t) );
            tree_trait<T>::bin_read( t.val(), m, src ); n+=m;
            if( m%sizeof(size_t) )
            {
                size_t y = sizeof(size_t) - m % sizeof(size_t);
                src.read( (char*)&w, (std::streamsize)y ); n += y;
                assert( src && src.gcount()==y );
            }
            tree<T>* p = &t;

            size_t depth_pre = depth_begin;
            size_t depth = 0;
            src.read( (char*)&depth, sizeof(size_t) ); n+=sizeof(size_t);
            assert( src && src.gcount()==sizeof(size_t) );
            while( depth != depth_begin )
            {
                if( depth == depth_pre )
                {
                    p=&p->addright();
                }
                else if( depth > depth_pre )
                {
                    assert( depth = depth_pre+1 );
                    p=&p->addfirstchild();
                }
                else
                {
                    for( size_t i=depth; i!=depth_pre; ++i )
                        p = &p->parent();
                    p=&p->addright();
                }
                src.read( (char*)&m, sizeof(size_t) ); n+=sizeof(size_t);
                assert( src && src.gcount()==sizeof(size_t) );
                tree_trait<T>::bin_read( p->val(), m, src ); n+=m;
                if( m%sizeof(size_t) )
                {
                    size_t y = sizeof(size_t) - m % sizeof(size_t);
                    src.read( (char*)&w, (std::streamsize)y ); n += y;
                    assert( src && src.gcount()==y );
                }

                depth_pre = depth;
                src.read( (char*)&depth, sizeof(size_t) ); n+=sizeof(size_t);
                assert( src && src.gcount()==sizeof(size_t) );
            }

            return n;
        }
    };
}
template<typename T> size_t tree<T>::cal_bin_size() const
{
    return cal_bin_size_< T, tree_trait<T>::is_solid >()( *this );
}
template<typename T> size_t tree<T>::write_to( void* dst) const
{
    return write_to_< T, tree_trait<T>::is_solid >()( *this, dst );
}
template<typename T> size_t tree<T>::write_to( std::ostream& dst) const
{
    return write_to_< T, tree_trait<T>::is_solid >()( *this, dst );
}
template<typename T> size_t tree<T>::read_from( const void* src )
{
    return read_from_< T, tree_trait<T>::is_solid >()( *this, src );
}
template<typename T> size_t tree<T>::read_from( std::istream& src )
{
    return read_from_< T, tree_trait<T>::is_solid >()( *this, src );
}

template<typename T> inline void tree<T>::init_()
{
    ptrparent_ = 0;
    ptrleft_ = 0;
    ptrright_ = 0;
    ptrchildfirst_ = 0;
    ptrchildlast_ = 0;
}
template<typename T> void tree<T>::destroysubs_()
{
    if( ptrchildlast_ )
    {
        TREE_MACRO_TRAVERSE_BEGIN( tree<T>, 0, traverse_back(), traverse_next(), traverse_prev )
            ptree->val_.~T();
            operator delete( ptree );
        TREE_MACRO_TRAVERSE_END
    }
}

template<typename T> std::basic_ostream<char>& operator<<( std::basic_ostream<char>& os, const tree<T>& t )
{
    int depth = 0;
    TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
        depth += depth_diff;
        os << std::setw(depth) << "" << ptree->val_ << '\n';
    TREE_MACRO_TRAVERSE_END

    return os;
}
//template<typename T> std::basic_ostream<wchar_t>& operator<<( std::basic_ostream<wchar_t>& os, const tree<T>& t )
//{
//    int depth = 0;
//    TREE_MACRO_TRAVERSE_BEGIN( const tree<T>, 0, t.traverse_front(), t.traverse_back(), traverse_next )
//        depth += depth_diff;
//        os << std::setw(depth) << L"" << ptree->val_ << L'\n';
//    TREE_MACRO_TRAVERSE_END
//
//    return os;
//}

////// trait for native types /////////////////////////////////////////////////////////

template<typename T> struct wipeoff_const_volatile { typedef T Type; };
template<typename T> struct wipeoff_const_volatile<const T> { typedef T Type; };
template<typename T> struct wipeoff_const_volatile<volatile T> { typedef T Type; };

template<typename T> struct tree_trait_           { static const bool is_solid = false; };
template<> struct tree_trait_<bool>               { static const bool is_solid = true; };
template<> struct tree_trait_<signed char>        { static const bool is_solid = true; };
template<> struct tree_trait_<unsigned char>      { static const bool is_solid = true; };
template<> struct tree_trait_<signed short>       { static const bool is_solid = true; };
template<> struct tree_trait_<unsigned short>     { static const bool is_solid = true; };
template<> struct tree_trait_<signed int>         { static const bool is_solid = true; };
template<> struct tree_trait_<unsigned int>       { static const bool is_solid = true; };
template<> struct tree_trait_<signed long>        { static const bool is_solid = true; };
template<> struct tree_trait_<unsigned long>      { static const bool is_solid = true; };
template<> struct tree_trait_<signed long long>   { static const bool is_solid = true; };
template<> struct tree_trait_<unsigned long long> { static const bool is_solid = true; };
template<> struct tree_trait_<float>              { static const bool is_solid = true; };
template<> struct tree_trait_<double>             { static const bool is_solid = true; };
template<> struct tree_trait_<long double>        { static const bool is_solid = true; };

template<typename T> struct tree_trait
{
static const bool is_solid = tree_trait_< typename wipeoff_const_volatile<T>::Type >::is_solid;
};

////// trait for std::string /////////////////////////////////////////////////////////
#include <string>

template<typename T> struct tree_trait< std::basic_string<T> >
{
static const bool is_solid = false;

    static inline size_t bin_size( const std::basic_string<T>& s )
    {
        return s.size()*sizeof(T);
    }
    static inline size_t bin_write( const std::basic_string<T>& s, void* p )
    {
        memcpy( (T*)p, s.c_str(), s.size()*sizeof(T) );
        return s.size()*sizeof(T);
    }
    static inline size_t bin_read( std::basic_string<T>& s, size_t n, const void* p )
    {
        s = std::basic_string<T>( (const T*)p, n/sizeof(T) );
        return n;
    }
    static inline size_t bin_write( const std::basic_string<T>& s, std::ostream& os )
    {
        os.write( (const char *)s.c_str(), (std::streamsize)s.size()*sizeof(T) );
        assert( os );
        return s.size()*sizeof(T);
    }
    static inline size_t bin_read( std::basic_string<T>& s, size_t n, std::istream& is )
    {
        char* p = new char[n];
        is.read( p, (std::streamsize)n );
        assert( is && is.gcount() == n );
        s = std::basic_string<T>( (T*)p, n/sizeof(T) );
        delete[] p;
        return n;
    }
};

template<typename T> struct tree_trait< const std::basic_string<T> > : tree_trait< std::basic_string<T> > {};
template<typename T> struct tree_trait< volatile std::basic_string<T> > : tree_trait< std::basic_string<T> > {};

////// trait for std::vector<unsigned char> /////////////////////////////////////////////////////////
#include <vector>

template<> struct tree_trait< std::vector<unsigned char> >
{
static const bool is_solid = false;

    static inline size_t bin_size( const std::vector<unsigned char>& s )
    {
        return s.size();
    }
    static inline size_t bin_write( const std::vector<unsigned char>& s, void* p )
    {
        memcpy( (char*)p, &s[0], s.size() );
        return s.size();
    }
    static inline size_t bin_read( std::vector<unsigned char>& s, size_t n, const void* p )
    {
        s = std::vector<unsigned char>( (const unsigned char*)p, (const unsigned char*)p+n );
        return n;
    }
    static inline size_t bin_write( const std::vector<unsigned char>& s, std::ostream& os )
    {
        os.write( (char*)&s[0], (std::streamsize)s.size() );
        assert( os );
        return s.size();
    }
    static inline size_t bin_read( std::vector<unsigned char>& s, size_t n, std::istream& is )
    {
        unsigned char* p = new unsigned char[n];
        is.read( (char*)p, (std::streamsize)n );
        assert( is && is.gcount() == n );
        s = std::vector<unsigned char>( (const unsigned char*)p, (const unsigned char*)p+n );
        delete[] p;
        return n;
    }
};

template<> struct tree_trait<const std::vector<unsigned char> > : tree_trait< std::vector<unsigned char> > {};
template<> struct tree_trait<volatile std::vector<unsigned char> > : tree_trait< std::vector<unsigned char> > {};

std::ostream& operator<<( std::ostream& os, const std::vector<unsigned char>& s )
{
char pf = os.fill('0');

    os << '[';
    if( !s.empty() )
    {
        os << std::setw(2) << std::setfill('0') << s[0];
        for( size_t i=1; i<s.size(); ++i )
            os << ',' << std::setw(2) << std::setfill('0') << s[0];
    }
    os << ']';

os.fill(pf);
return os;
}

#endif // TREE_HEADER__

// test.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#define TREE_DEBUG__
#include "tree.hpp"
using namespace std;

struct foo //for test
{
static int n;
int v;

    foo( int i=0 ) : v(i)
    {
        ++n;
    }
    foo( const foo& I ) : v(I.v)
    {
        ++n;
    }
    ~foo()
    {
        --n;
    }

    operator int&()
    {
        return v;
    }
    operator int() const
    {
        return v;
    }
};
int foo::n = 0;
template<> struct tree_trait_<foo>            { static const bool is_solid = true; };

struct foo2
{
    char v[5];
    foo2( int i=0 )
    {
        *(int*)v = i;
        v[4] = 0;
    }
    operator int() const
    {
        return *(int*)v;
    }
};
template<> struct tree_trait_<foo2>           { static const bool is_solid = true; };

template <typename T>
void test( tree<T>& t )
{
    const tree<T>* p = 0;
    const tree<T>* pend = t.traverse_back();
    for( p=t.traverse_front(); p!=pend; p=p->traverse_next() )
    {
        if( &p->left() )
        {
            assert( &p->left().right() == p );

            assert( &p->left().parent() == &p->parent() );
        }
        else
        {
            if( &p->parent() )
                assert( &p->parent().childfirst() == p );
        }

        if( &p->right() )
        {
            assert( &p->right().left() == p );
        }
        else
        {
            if( &p->parent() )
                assert(&p->parent().childlast() == p );
        }
    }

    assert( &p->childfirst() == 0 );
    assert( &p->childlast() == 0 );
    assert( &p->right() == 0 );
}

int main3()
{
    cout << "--- vector<BYTE> <--> memory ---" << endl;
    {
        tree< vector<unsigned char> > a1( vector<unsigned char>(1,'1') );
        tree< vector<unsigned char> >& a2 = a1.addfirstchild( vector<unsigned char>(2,'2') );
        tree< vector<unsigned char> >& a3 = a2.addfirstchild( vector<unsigned char>(3,'3') );
        tree< vector<unsigned char> >& a4 = a3.addright( vector<unsigned char>(4,'4') );
        tree< vector<unsigned char> >& a5 = a2.addright( vector<unsigned char>(5,'5') );
        tree< vector<unsigned char> >& a6 = a5.addfirstchild( vector<unsigned char>(6,'6') );
        tree< vector<unsigned char> >& a7 = a6.addright( vector<unsigned char>(7,'7') );

        size_t len = a1.cal_bin_size();
        char* p = new char[len];
        size_t n1 = a1.write_to( p );
        assert( n1 == len );

        tree< vector<unsigned char> > b1;
        size_t n2 = b1.read_from( p );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        tree< vector<unsigned char> > c1 = b1;
        size_t n3 = c1.read_from( p );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );

        delete[] p;
    }
    cout << "--- vector<BYTE> <--> stream ---" << endl;
    {
        tree< vector<unsigned char> > a1( vector<unsigned char>(1,'1') );
        tree< vector<unsigned char> >& a2 = a1.addfirstchild( vector<unsigned char>(2,'2') );
        tree< vector<unsigned char> >& a3 = a2.addfirstchild( vector<unsigned char>(3,'3') );
        tree< vector<unsigned char> >& a4 = a3.addright( vector<unsigned char>(4,'4') );
        tree< vector<unsigned char> >& a5 = a2.addright( vector<unsigned char>(5,'5') );
        tree< vector<unsigned char> >& a6 = a5.addfirstchild( vector<unsigned char>(6,'6') );
        tree< vector<unsigned char> >& a7 = a6.addright( vector<unsigned char>(7,'7') );

fstream ios( "test.bin", ios_base::binary|ios_base::in|ios_base::out|ios_base::trunc );

        size_t len = a1.cal_bin_size();
        size_t n1 = a1.write_to( ios );
        assert( n1 == len );

        ios.seekg( 0 );
        tree< vector<unsigned char> > b1;
        size_t n2 = b1.read_from( ios );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        ios.seekg( 0 );
        tree< vector<unsigned char> > c1 = b1;
        size_t n3 = c1.read_from( ios );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );
    }

return 0;
}

//int main2()
//{
//    cout << "--- wstring <--> memory ---" << endl;
//    {
//        tree<wstring> a1( L"1" );
//        tree<wstring>& a2 = a1.addfirstchild( L"22" );
//        tree<wstring>& a3 = a2.addfirstchild( L"333" );
//        tree<wstring>& a4 = a3.addright( L"4444" );
//        tree<wstring>& a5 = a2.addright( L"55555" );
//        tree<wstring>& a6 = a5.addfirstchild( L"666666" );
//        tree<wstring>& a7 = a6.addright( L"7777777" );
//
//        size_t len = a1.cal_bin_size();
//        char* p = new char[len];
//        size_t n1 = a1.write_to( p );
//        assert( n1 == len );
//
//        tree<wstring> b1;
//        size_t n2 = b1.read_from( p );
//        assert( n2 == len );
//        wcout << b1 << endl;
//        test( b1 );
//
//        tree<wstring> c1 = b1;
//        size_t n3 = c1.read_from( p );
//        assert( n3 == len );
//        wcout << c1 << endl;
//        test( c1 );
//
//        delete[] p;
//    }
//    cout << "--- wstring <--> stream ---" << endl;
//    {
//        tree<wstring> a1( L"1" );
//        tree<wstring>& a2 = a1.addfirstchild( L"22" );
//        tree<wstring>& a3 = a2.addfirstchild( L"333" );
//        tree<wstring>& a4 = a3.addright( L"4444" );
//        tree<wstring>& a5 = a2.addright( L"55555" );
//        tree<wstring>& a6 = a5.addfirstchild( L"666666" );
//        tree<wstring>& a7 = a6.addright( L"7777777" );
//
//        fstream ios( "test.bin", ios_base::binary|ios_base::in|ios_base::out|ios_base::trunc );
//
//        size_t len = a1.cal_bin_size();
//        size_t n1 = a1.write_to( ios );
//        assert( n1 == len );
//
//        ios.seekg( 0 );
//        tree<wstring> b1;
//        size_t n2 = b1.read_from( ios );
//        assert( n2 == len );
//        wcout << b1 << endl;
//        test( b1 );
//
//        ios.seekg( 0 );
//        tree<wstring> c1 = b1;
//        size_t n3 = c1.read_from( ios );
//        assert( n3 == len );
//        wcout << c1 << endl;
//        test( c1 );
//    }
//
//    return 0;
//}

int main1()
{
    cout << "--- solid(5bytes) <--> memory ---" << endl;
    {
        tree<foo2> a1( 1 );
        tree<foo2>& a2 = a1.addfirstchild(2);
        tree<foo2>& a3 = a2.addfirstchild(3);
        tree<foo2>& a4 = a3.addright(4);
        tree<foo2>& a5 = a2.addright(5);
        tree<foo2>& a6 = a5.addfirstchild(6);
        tree<foo2>& a7 = a6.addright(7);

        size_t len = a1.cal_bin_size();
        char* p = new char[len];
        size_t n1 = a1.write_to( p );
        assert( n1 == len );

        tree<foo2> b1;
        size_t n2 = b1.read_from( p );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        tree<foo2> c1 = b1;
        size_t n3 = c1.read_from( p );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );

        delete[] p;
    }
    cout << "--- solid(5bytes) <--> stream ---" << endl;
    {
        tree<foo2> a1( 1 );
        tree<foo2>& a2 = a1.addfirstchild(2);
        tree<foo2>& a3 = a2.addfirstchild(3);
        tree<foo2>& a4 = a3.addright(4);
        tree<foo2>& a5 = a2.addright(5);
        tree<foo2>& a6 = a5.addfirstchild(6);
        tree<foo2>& a7 = a6.addright(7);

        fstream ios( "test.bin", ios_base::binary|ios_base::in|ios_base::out|ios_base::trunc );
        assert( ios );
        //ios.write( "0", 1 );
        assert( ios );
        size_t len = a1.cal_bin_size();
        size_t n1 = a1.write_to( ios );
        assert( n1 == len );

        ios.seekg( 0 );
        tree<foo2> b1;
        size_t n2 = b1.read_from( ios );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        ios.seekg( 0 );
        tree<foo2> c1 = b1;
        size_t n3 = c1.read_from( ios );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );
    }

    cout << "--- solid <--> memory ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

        size_t len = a1.cal_bin_size();
        char* p = new char[len];
        size_t n1 = a1.write_to( p );
        assert( n1 == len );

        tree<foo> b1;
        size_t n2 = b1.read_from( p );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        tree<foo> c1 = b1;
        size_t n3 = c1.read_from( p );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );

        delete[] p;
    }
    cout << "--- solid <--> stream ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

fstream ios( "test.bin", ios_base::binary|ios_base::in|ios_base::out|ios_base::trunc );

        size_t len = a1.cal_bin_size();
        size_t n1 = a1.write_to( ios );
        assert( n1 == len );

        ios.seekg( 0 );
        tree<foo> b1;
        size_t n2 = b1.read_from( ios );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        ios.seekg( 0 );
        tree<foo> c1 = b1;
        size_t n3 = c1.read_from( ios );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );
    }
    cout << "--- non-solid <--> memory ---" << endl;
    {
        tree<string> a1( "1" );
        tree<string>& a2 = a1.addfirstchild( "22" );
        tree<string>& a3 = a2.addfirstchild( "333" );
        tree<string>& a4 = a3.addright( "4444" );
        tree<string>& a5 = a2.addright( "55555" );
        tree<string>& a6 = a5.addfirstchild( "666666" );
        tree<string>& a7 = a6.addright( "7777777" );

        size_t len = a1.cal_bin_size();
        char* p = new char[len];
        size_t n1 = a1.write_to( p );
        assert( n1 == len );

        tree<string> b1;
        size_t n2 = b1.read_from( p );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        tree<string> c1 = b1;
        size_t n3 = c1.read_from( p );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );

        delete[] p;
    }
    cout << "--- non-solid <--> stream ---" << endl;
    {
        tree<string> a1( "1" );
        tree<string>& a2 = a1.addfirstchild( "22" );
        tree<string>& a3 = a2.addfirstchild( "333" );
        tree<string>& a4 = a3.addright( "4444" );
        tree<string>& a5 = a2.addright( "55555" );
        tree<string>& a6 = a5.addfirstchild( "666666" );
        tree<string>& a7 = a6.addright( "7777777" );

fstream ios( "test.bin", ios_base::binary|ios_base::in|ios_base::out|ios_base::trunc );

        size_t len = a1.cal_bin_size();
        size_t n1 = a1.write_to( ios );
        assert( n1 == len );

        ios.seekg( 0 );
        tree<string> b1;
        size_t n2 = b1.read_from( ios );
        assert( n2 == len );
        cout << b1 << endl;
        test( b1 );

        ios.seekg( 0 );
        tree<string> c1 = b1;
        size_t n3 = c1.read_from( ios );
        assert( n3 == len );
        cout << c1 << endl;
        test( c1 );
    }
    cout << "--- 2node <--> 5node ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

        cout << a1 << endl;
        swap( a2, a5 );
        cout << a1 << endl;
        test( a1 );
    }
    cout << "--- 2node <--> 6node ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

        cout << a1 << endl;
        swap( a2, a6 );
        cout << a1 << endl;
        test( a1 );
    }
    cout << "--- move 7node to 2node.left ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);
        tree<foo>& a8 = a7.addfirstchild(8);
        tree<foo>& a9 = a8.addright(9);

        cout << a1 << endl;
        cout << "   --->" << endl;
        tree<foo>& b = a1.addfirstchild();
        b.swap( a7 );
        a7.erase();
        cout << a1 << endl;

        test( a1 );
    }
    cout << "--- 2node operator= 5node ---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

        cout << a1 << endl;
        a2 = a5;
        test( a1 );
        cout << a1 << endl;
    }
    cout << "--- search odd number---" << endl;
    {
        tree<foo> a1( 1 );
        tree<foo>& a2 = a1.addfirstchild(2);
        tree<foo>& a3 = a2.addfirstchild(3);
        tree<foo>& a4 = a3.addright(4);
        tree<foo>& a5 = a2.addright(5);
        tree<foo>& a6 = a5.addfirstchild(6);
        tree<foo>& a7 = a6.addright(7);

        TREE_MACRO_TRAVERSE_BEGIN( const tree<foo>, 0, a1.traverse_front(), a1.traverse_back(), traverse_next )
            if( ptree->val()&1 ) cout << ptree->val() << " ";
        TREE_MACRO_TRAVERSE_END
        cout << endl;

        TREE_MACRO_TRAVERSE_BEGIN( const tree<foo>, 0, a1.traverse_back(), a1.traverse_front(), traverse_prev )
            if( ptree->val()&1 ) cout << ptree->val() << " ";
        TREE_MACRO_TRAVERSE_END
        cout << endl;

        // cann't work over in g++3.4.2
        //struct print
        //{
        //    void operator()( const tree<foo>* ptree, int depth_diff )
        //    {
        //        if( ptree->val()&1 ) cout << ptree->val() << " ";
        //    }
        //} print;
        //a1.traverse( print, 0 );
        //cout << endl;
        //a1.traverse_reverse( print, 0 );
        //cout << endl;
    }

assert( foo::n == 0 ); // foo construct/destruct matching
assert( tree<foo>::m == 0 ); // new/delete matching

return 0;
}

int main()
{
    main1();
    //main2();
    main3();

system( "pause" );
return 0;
}

C简史（还真简）

周星星 — Tue, 08 Jan 2008 03:13:00 GMT

1972 C 诞生
1978 K&R C 成为事实标准
1989 ANSI C (c89)
1990 ISO C (c90)
1999 ISO C 2nd (c99)

C设计哲学：
相信程序员；
不妨碍程序员做需要完成的事情；
让语言保持短小简单；
只提供一种方法来执行一种操作；
使程序运行速度快，即使不能保证其可移植性。（不追求定义的抽象统一，更优先考虑运行效率）

ListCtrl OwnerData example

周星星 — Fri, 16 Nov 2007 04:42:00 GMT

#pragma once
#include <atlbase.h>
#include <atlwin.h>

class CTest : public CDialogImpl<CTest>
{
public:
enum { IDD = IDD_DIALOG1 };

    CTest()
    {
    }
    ~CTest()
    {
    }

    BEGIN_MSG_MAP(CTest)
        MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
        COMMAND_HANDLER(IDOK, BN_CLICKED, OnClickedOK)
        COMMAND_HANDLER(IDCANCEL, BN_CLICKED, OnClickedCancel)
        NOTIFY_HANDLER(IDC_LIST1, LVN_GETDISPINFO, OnLvnGetdispinfoList1)
        NOTIFY_HANDLER(IDC_LIST1, LVN_ITEMCHANGED, OnItemChangedList1)
//        CHAIN_MSG_MAP(CDialogImpl<CTest>)
    END_MSG_MAP()

    LRESULT OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
    {
        HWND hList = ::GetDlgItem(m_hWnd,IDC_LIST1);
        // LVS_OWNERDATA不支持动态切换，当OnInitDialog()被调用时，列表视控件已经建立了
        // ListView_SetExtendedListViewStyle( hList, ListView_GetExtendedListViewStyle(m_hList2)|LVS_OWNERDATA|LVS_REPORT );

        // 16H*32W
        HIMAGELIST hImageList = ImageList_LoadBitmap( ::GetModuleHandle(0),MAKEINTRESOURCE(IDB_BITMAP1), 16, 0, 0x00ffffff);
        ListView_SetImageList(hList, hImageList, LVSIL_SMALL);

        LVCOLUMN lvc;
        lvc.mask = LVCF_TEXT|LVCF_WIDTH;
        lvc.pszText = _T("Column1");
        lvc.cx = 100;
        ListView_InsertColumn(hList, 0, &lvc);

        lvc.mask = LVCF_TEXT|LVCF_WIDTH;
        lvc.pszText = _T("Column2");
        lvc.cx = 100;
        ListView_InsertColumn(hList, 1, &lvc);

ListView_SetItemCount(hList,2);

return 1;
}

    LRESULT OnLvnGetdispinfoList1(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
    {
        NMLVDISPINFO* lpdi = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);

        switch( lpdi->item.iItem )
        {
        case 0:
            switch( lpdi->item.iSubItem )
            {
            case 0:
                lpdi->item.pszText = _T("00");
                lpdi->item.iImage = 0;
                lpdi->item.iIndent = 1;
                break;
            case 1:
                lpdi->item.pszText = _T("01");
                break;
            }
            break;
        case 1:
            switch( lpdi->item.iSubItem )
            {
            case 0:
                lpdi->item.pszText = _T("10");
                lpdi->item.iImage = 1;
                lpdi->item.iIndent = 0;
                break;
            case 1:
                lpdi->item.pszText = _T("11");
                break;
            }
            break;
        }

        return 0;
    }

    LRESULT OnItemChangedList1(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
    {
        LPNMLISTVIEW pNMListView = reinterpret_cast<LPNMLISTVIEW>(pnmh);

return 0;
}

    LRESULT OnClickedOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
    {
        EndDialog(wID);
        return 0;
    }

    LRESULT OnClickedCancel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
    {
        EndDialog(wID);
        return 0;
    }
};

控制台输入输出重定向的方法及疑问

周星星 — Fri, 29 Jun 2007 06:52:00 GMT


#include <windows.h>
#include <tchar.h>
typedef void (__stdcall* SNIFFER_THREAD_START_ROUTINE)( HANDLE hRead, HANDLE hWrite, LPVOID userfunparam );
struct SnfParam_
{
    SNIFFER_THREAD_START_ROUTINE userfunction;
    HANDLE hRead;
    HANDLE hWrite;
    LPVOID userfunparam;
};
DWORD __stdcall sniffer_( LPVOID lpParam )
{
    SnfParam_& ps = *(SnfParam_*)lpParam;
    (*ps.userfunction)( ps.hRead, ps.hWrite, ps.userfunparam );
    return 0;
}
#define IF_BAD_GOTO(EXPR,LABEL) if( !(EXPR) ) goto LABEL
#define CHECK(EXPR)             if( !(EXPR) ) goto error
#define CLOSEHANDLE(H)          if(INVALID_HANDLE_VALUE!=H) CloseHandle(H)
bool redirector( LPCTSTR cmd, SNIFFER_THREAD_START_ROUTINE lpSnfStartAddress, LPVOID lpSnfParam, LPDWORD lpRetVal=0, WORD wShowWindow=SW_HIDE
               , LPSECURITY_ATTRIBUTES lpCmdProcessAttributes=0,  LPSECURITY_ATTRIBUTES lpCmdThreadAttributes=0, DWORD dwCmdCreationFlags=NORMAL_PRIORITY_CLASS, LPVOID lpCmdEnvironment=0, LPCTSTR lpCmdCurrentDirectory=0
               , LPSECURITY_ATTRIBUTES lpSfrThreadAttributes=0, SIZE_T dwSfrStackSize=0 // sniffer
         )
{
    HANDLE hInput=INVALID_HANDLE_VALUE, hOutput=INVALID_HANDLE_VALUE, hError=INVALID_HANDLE_VALUE;
    HANDLE hRead_=INVALID_HANDLE_VALUE, hWrite_=INVALID_HANDLE_VALUE, hRead=INVALID_HANDLE_VALUE , hWrite=INVALID_HANDLE_VALUE;
    SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), 0, TRUE };
    HANDLE hProc = GetCurrentProcess();
    SnfParam_ sp;
    HANDLE hSnf = INVALID_HANDLE_VALUE;
    STARTUPINFO si;
    LPTSTR cmdline = 0;

    // 创建管道
    CHECK( CreatePipe(&hInput,&hWrite_,&sa,0) );
    CHECK( CreatePipe(&hRead_,&hOutput,&sa,0) );
    CHECK( DuplicateHandle(hProc,hOutput,hProc,&hError,0,TRUE,DUPLICATE_SAME_ACCESS) );  // 防止被获取数据的进程关闭hOutput时hError同时实效
    CHECK( DuplicateHandle(hProc,hRead_,hProc,&hRead,0,FALSE,DUPLICATE_SAME_ACCESS) );   // 不可继承
    CHECK( DuplicateHandle(hProc,hWrite_,hProc,&hWrite,0,FALSE,DUPLICATE_SAME_ACCESS) ); // 不可继承
    CloseHandle(hRead_); hRead_=INVALID_HANDLE_VALUE;
    CloseHandle(hWrite_); hWrite_=INVALID_HANDLE_VALUE;

    // 创建获取数据的线程
    sp.userfunction = lpSnfStartAddress;
    sp.userfunparam = lpSnfParam;
    sp.hRead        = hRead;
    sp.hWrite       = hWrite;
    hSnf = CreateThread( lpSfrThreadAttributes, dwSfrStackSize, &sniffer_, &sp, 0, 0 );
    CHECK( hSnf );

    // 创建被获取数据的进程
    GetStartupInfo( &si );
    si.dwFlags     = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
    si.wShowWindow = wShowWindow;
    si.hStdInput   = hInput;
    si.hStdOutput  = hOutput;
    si.hStdError   = hError;
    PROCESS_INFORMATION pi;
    cmdline = _tcsdup( cmd );
    CHECK( cmdline );
    CHECK( CreateProcess(NULL,cmdline,lpCmdProcessAttributes,lpCmdThreadAttributes,TRUE,dwCmdCreationFlags,lpCmdEnvironment,lpCmdCurrentDirectory,&si,&pi) );
    free(cmdline); cmdline=0;

    // 等待被获取数据的进程退出
    CHECK( WAIT_FAILED != WaitForSingleObject(pi.hProcess,INFINITE) );
    // 获取被获取数据的进程退出码
    if(lpRetVal) GetExitCodeProcess(pi.hProcess,lpRetVal);
    // 关闭被获取数据的进程句柄
    CloseHandle(pi.hThread ); pi.hThread =INVALID_HANDLE_VALUE;
    CloseHandle(pi.hProcess); pi.hProcess=INVALID_HANDLE_VALUE;
    
    // 关闭被获取数据的进程使用到的句柄
    CloseHandle(hInput ); hInput =INVALID_HANDLE_VALUE;
    CloseHandle(hOutput); hOutput=INVALID_HANDLE_VALUE;
    CloseHandle(hError ); hError =INVALID_HANDLE_VALUE;

    // 等待获取数据的线程退出
    CHECK( WAIT_FAILED != WaitForSingleObject(hSnf,INFINITE) );
    // 关闭获取数据的线程句柄
    CloseHandle(hSnf); hSnf=INVALID_HANDLE_VALUE;

    // 关闭获取数据的线程使用到的句柄
    CloseHandle(hRead ); hRead =INVALID_HANDLE_VALUE;
    CloseHandle(hWrite); hWrite=INVALID_HANDLE_VALUE;

    // 返回
    return true;

error:
    CLOSEHANDLE( pi.hProcess );
    CLOSEHANDLE( pi.hThread  );
    free( cmdline );
    CLOSEHANDLE( hSnf    );
    CLOSEHANDLE( hInput  );
    CLOSEHANDLE( hOutput );
    CLOSEHANDLE( hError  );
    CLOSEHANDLE( hRead   );
    CLOSEHANDLE( hWrite  );
    CLOSEHANDLE( hRead_  );
    CLOSEHANDLE( hWrite_ );
    return false;
}


#include <iostream>
#include <string>
#include <cassert>
using namespace std;
void __stdcall foo( HANDLE hRead, HANDLE hWrite, LPVOID userfunparam )
{
    TCHAR buf[100] = _T("test\n");
    DWORD dwRead;

    BOOL ret = WriteFile( hWrite, buf, (DWORD)_tcslen(buf)*sizeof(buf[0]), &dwRead, 0 );
    assert( ret && dwRead==_tcslen(buf)*sizeof(buf[0]) );

    while( ReadFile(hRead,buf,sizeof(buf),&dwRead,0) )
    {
        _tprintf( _T("%.*s"), dwRead/sizeof(buf[0]), buf );
    }
}
int main( int argc, char** agrv )
{
    if( argc == 1 )
    {
        cout << "----------------------------" << endl;
        DWORD ret;
        BOOL f = redirector( _T("debug\\cpp16.exe x"), &foo, 0, &ret );
        cout << "----------------------------" << endl;
        if( f )
            cout << "redirector success, and cmd return " << ret << '.' << endl;
        else
            cout << "redirector failed." << endl;
    }
    else
    {
        string str;
        cin >> str;
        cout << str << endl;
    }
    
    return 0;
}

几个疑问：
1。如果使用UNICODE方式，那么ReadFile读到的不是 0074 0065 0073 0074 000d 000a，而是 0074 0065 0073 0074 0a0d，还有可能是更奇怪的结果。按理应当加上 cmd.exe /U /C，但还是错误。
2。如果被获取数据的程序同时使用 cout(有缓冲标准输出)，cerr(无缓冲错误输出), clog(有缓冲错误输出) ，fprintf(stdout,...)，fprintf(stderr,...)那么获取到的次序有点混乱。用 cmd.exe /C app 1>log.txt 2>&1 也同样如此，估计是没办法了。
3。对于直接写屏函数的输出，比如 _cputs，那么无法获取到。用 cmd.exe /C app 1>log.txt 2>&1 也同样如此，估计是没办法了。
4。对于DOS16程序，向标准错误设备的输出，比如 fprintf(stderr,...) ，在 xp 下可以获取到，但在 vista 下不行。

代码片断

周星星 — Thu, 19 Apr 2007 03:21:00 GMT

专门保存代码片断

_at_

周星星 — Thu, 22 Mar 2007 09:45:00 GMT

UCHAR IOBASE[0x20] _at_ 0x8300; [我自横刀向天笑]
51单片机的一句话，那么在ARM里类似 _at_ 的关键字吗??

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

#include <iostream>
using namespace std;

typedef char (&TYPE)[0x20];
inline TYPE foo( TYPE a )
{
    return a;
}
TYPE (*pfoo)(int) = ( TYPE (*)(int) )&foo;

int main( void )
{
    // UCHAR IOBASE[0x20] _at_ 0x8300;
    char (&test)[0x20] = pfoo(0x8300);
}

[暂存代码]

周星星 — Thu, 27 Jul 2006 03:52:00 GMT

// a.hpp
struct foo
{
    foo();
#ifdef SOMETHING
    int a;
#endif
    int b;
};

// a.cpp
#define SOMETHING
#include "a.hpp"
#undef SOMETHING
foo::foo()
{
     a = 1;
     b = 2;
}

// main.cpp
#include "a.hpp"
#include <iostream>
int main()
{
    foo test;                         // 理论上讲，a.cpp和main.cpp中的foo定义不同，是不同的类型，所以应当报foo()未实现，但实际上却正确
    std::cout << test.b << std::endl; // 输出1
}

------------------------------------------------------------------------------------
在VC2005中：
#include <iostream>
#include <fstream>
#include <string>

int main( void )
{
    std::locale prev_loc = std::locale::global( std::locale("chs") ); // 没有这一句的话，文件打开失败
    std::ifstream file( "d:\\测试\\test.txt" );
    std::locale::global( prev_loc ); // 没有这一句的话，文件中的中文无法输出，且wcout输出中文也失败

    for( std::string line; getline(file,line); )
    {
        std::cout << line << std::endl;
    }

    std::wcout.imbue( std::locale("chs") );
    std::wcout << L"结束" << std::endl;
}

------------------------------------------------------------------------------------
template<class T>
struct a
{
    void foo( void ) {}
};
template<class T>
struct b : a<T>
{
    void bar( void ) { foo(); } // g++3.4.2不能编译通过，必须写成 a<T>::foo();
};

------------------------------------------------------------------------------------
template<class T>
struct foo
{
    template<class U>
    void bar( void )
    {
    }
};

template<class T>
void test( void )
{
foo<int>().bar<T>();
foo<T>().bar<int>(); // g++3.4.2不能编译通过，必须写成foo<T>().template bar<int>();
}

一个简单Tree类

周星星 — Mon, 27 Mar 2006 04:35:00 GMT

Tree包含名称，和子Tree列表，在流中形式形如：
a
        b
        c
                d
                e
        f
注1: html中无法显示Tab符号，所以我以8个空格代替
注2: 不同的编译器应当使用不同的文本格式，比如VC++使用windows文本格式(\r\n作为行间隔)，dev-cpp使用Unix文本格式(\n作为行间隔)。

// 测试通过 by g++3.4.2 和 vc++2005

1. Tree.h文件：
#ifndef __TREE_H__
#define __TREE_H__

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

struct Tree
{
friend std::istream& operator>>( std::istream& is, Tree& tree );
friend std::ostream& operator<<( std::ostream& os, const Tree& tree );

typedef std::vector<Tree> sctype;
static const char Split;

    Tree();
    explicit Tree( const std::string nodename );
    void swap( Tree& tree );

std::string name;
sctype subs;
};

inline void swap( Tree& lhs, Tree& rhs )
{
lhs.swap( rhs );
}

#endif // __TREE_H__

2. Tree.cpp文件：
#include "Tree.h"
#include <iomanip>
using namespace std;

const char Tree::Split = '\t';

Tree::Tree()
{
}
Tree::Tree( const string nodename ) : name(nodename)
{
}
void Tree::swap( Tree& tree )
{
name.swap( tree.name );
subs.swap( tree.subs );
}

istream& operator>>( istream& is, Tree& tree )
{
    struct parse
    {
        void operator()( const string& line, size_t& level, string& name )
        {
            const char* whitespace = " \t\n";
            level = line.find_first_not_of( Tree::Split );
            if( level == string::npos ) level = line.size();
            size_t n1 = line.find_first_not_of( whitespace, level );
            if( n1 == string::npos )
            {
                name.erase();
            }
            else
            {
                size_t n2 = line.find_last_not_of( whitespace );
                name = line.substr( n1, n2-n1+1 );
            }
        }
    } parse;

if( is.fail() ) return is;
tree = Tree();

    typedef vector<Tree*> COLS;
    COLS cols;
    streampos prepos;
    for( string line; prepos=is.tellg(), getline(is,line); )
    {
        size_t level;
        string name;
        parse( line, level, name );
        if( name.empty() && tree.name.empty() && (is.flags() & is.skipws) )
        {
            continue;
        }
        if( name.empty() || level>cols.size() || ( level==0 && !tree.name.empty() ) )
        {
            is.seekg( prepos );
            if( tree.name.empty() )
                is.setstate( ios::failbit );
            return is;
        }
        cols.resize( level+1 );
        if( level == 0 )
        {
            tree.name = name;
            cols.back() = &tree;
        }
        else
        {
            COLS::reverse_iterator b = cols.rbegin();
            COLS::reverse_iterator a = b; ++a;
            (*a)->subs.push_back( Tree(name) );
            (*b) = &(*a)->subs.back();
        }
    }
    if( !is.bad() && is.eof() && !tree.name.empty() )
        is.clear();
    return is;
}

ostream& operator<<( ostream& os, const Tree& tree )
{
    os << tree.name << '\n';
    size_t level = 1;
    typedef pair<Tree::sctype::const_iterator,Tree::sctype::const_iterator> COL;
    vector<COL> cols( 1, COL(tree.subs.begin(),tree.subs.end()) );

    for( ; ; )
    {
        if( cols.back().first == cols.back().second )
        {
            --level;
            cols.pop_back();
            if( level == 0 ) break;
            ++cols.back().first;
        }
        else
        {
            os << setw((streamsize)level) << setfill(Tree::Split) << "" << cols.back().first->name << '\n';
            ++level;
            cols.push_back( COL(cols.back().first->subs.begin(),cols.back().first->subs.end()) );
        }
    }
    return os;
}

3. 测试文件：
#include "Tree.h"
#include <iostream>
#include <fstream>
using namespace std;

int main( int argc, char *argv[] )
{
    ifstream file( "test.txt" );
    for( Tree tree; file>>tree; cout<<tree );
    cout << "-------------" << endl;
    file.clear();
    for( string line; getline(file,line); cout<<line<<endl );

    return EXIT_SUCCESS;
}
test.txt文件内容：
a
        b
        c
                dm
                e
        f
a2
        b
        c
                   "test"

                e
        f
输出：
a
        b
        c
                dm
                e
        f
a2
        b
        c
                "test"
-------------
                e
        f