int   test( int value )
{
     if ( value > 0 ) return value;
}

   调用 int value = test( -1 );

   看下test的汇编代码.

关于8个程序寄存器一般只有esp寄存器作为入栈，出栈，调用和返回指令作为栈指针，其余

比如eax,exc等寄存器都没有固定的含义和固定值.
看下面test汇编代码.
int   test( int value )
{

; 4个寄存器入栈
; ebp 用于存放函数栈的栈顶指针
; esp 用于存放函数栈的栈底指针

004113A0  push        ebp              ;将寄存器ebp的内容压入程序栈
004113A1  mov         ebp,esp             ;保留esp寄存器
004113A3  sub         esp,0C0h             ;为该函数留出临时存储区
004113A9  push        ebx  
004113AA  push        esi  
004113AB  push        edi  

; 用0CCCCCCCCh初始化堆栈                
004113AC  lea         edi,[ebp-0C0h]        ;lea直接寻址
004113B2  mov         ecx,30h             ;利用编译器的offset立即寻址
004113B7  mov         eax,0CCCCCCCCh         ;eax=0CCCCCCCCh
004113BC  rep stos    dword ptr es:[edi]     ;根据edi的大小来重复指令执行次数

; 如果 cmp为真则把value的值保存到eax寄存器中
; 否则跳转到地址4113C7h,并没有对eax做处理

     if ( value > 0 ) return value;
004113BE  cmp         dword ptr [value],0 
004113C2  jle         test+27h (4113C7h) 
004113C4  mov         eax,dword ptr [value] 
}

;各指针出栈，对应前面3条push

004113C7  pop         edi              ;弹出edi
004113C8  pop         esi              ;弹出esi
004113C9  pop         ebx              ;弹出ebx
004113CA  mov         esp,ebp             ;把esp重新指向ebp(函数栈的栈顶指

针，test函数栈顶)
004113CC  pop         ebp              ;ebp重新指向test调用函数返回地址
004113CD  ret

调用汇编代码

int value = test ( 1 );
004113FE  push        1    
00411400  call        test (4110AFh) 
00411405  add         esp,4             ;Call test 函数时将压入栈数据，

由于只有一个参数，所以只有4字节
00411408  mov         dword ptr [value],eax 

当test 调用小于0时最后value指向的eax是一个0CCCCCCCCh，而对于基本数据类型大多value得到的是0CCCCCCCCh值.
如果我们的test函数:

int   test( int value )
{
     if ( value > 0 ) return value;
     return 0;
}

那么汇编代码会如下:

     if ( value > 0 ) return value;
004113EE  cmp         dword ptr [value],0 
004113F2  jle         test+29h (4113F9h) 
004113F4  mov         eax,dword ptr [value] 
004113F7  jmp         test+2Bh (4113FBh) 
     return 0;
004113F9  xor         eax,eax   ;将eax清零,作为返回值

   2 )如果返回的是一个引用对象
    

obj &  test( type value )
{
    if( type2 ) return obj;
}

obj & ob = test( type1 );

   如果ob是个空引用的话，就出出错，关于这种出错是否可以通过什么方式避免呢？

   我觉得warning C4715就应该是error C4715.让开发者从最开始就避免这种错误的发生。

关于内存池的设计和实现网上遍地都是，本文不具体介绍关于内存池的具体实现和方式，主要是介绍设计一个内存池怎样去测试其性能和安全处理，有一个开源的内存池项目tcmalloc也有介绍很多，但是为了满足多种需求，代码过于庞大，最后我用来测试分配性能测试。

1个内存池的测试用例应该包含：
1）该项目内存分配概率随机性.
2）同时保证释放的随机性.
3）可以支持多种分配方式（不同大小，不同对象参数等）.

要达到上面要求则可以设计
1.一个数组来设定需要分配的大小。
   long  arr[ ] = { 16,32,64,128,256,512,1024,2048,5120,5130,7000,6000,10240,15000,20000};

2.根据需求来指定各个大小的分配几率，这好比有多少概率选中某个数（需特定的分配）:
   

 A.针对这个需求可以设定定一个概率数组Odds,数组值arrArr的索引。
    B.针对Odds指定数组数据，使其数据分配达到arr需要分配概率。
       /**////   被分配的概率
       long  Odds[ ] = { 0,0,0,1,1,2,2,2,3,3,4,4,4,4,5,5,5,5,6,6,,7,7,7,8,8,8,8,9,9,9,10,10,11,12,12};
    C.随机Odds数组，然后得到其值分配，其值则为Arr的索引。
        long  Asize= arr[ Odds[ rand()%size ] ] ;

3.释放保证随机性。
     什么时候释放，以及分配了做什么用，都是又应用层决定的，所以需要把分配出来的内存通过一个容器来存储.
     由于分配是随机性，那么释放的时候也保证了随机性。

4.支持多种分配方式。
     A. 对象分配:     

MemFactory  Memory;

    A* a = Memory.Alloc<A>( );
    B* b = Memory.Alloc<B,int>( 2 );

    Memory.FreeObj( a );
    Memory.FreeObj( b );

    B.直接分配

void* p1 = Memory.Alloc( Asize );

5.性能测试
   为了测试性能，我选择了分配1000W次，其中用一个容器保存分配的数据，然后当容器到达100W的时候释放60W数据(保证数据正在使用，随机释放)。
   下面的Alloc time 只是统计的Alloc时间累加，Free time只是统计的Free 时间累加，Total time记录这次测试总共花费时间。

 1测试结果如下:
 2MemPool Alloc time 3242 ms  Free time: 2412 ms Total time 22535 ms
 3System    Alloc time 33616 ms Free time: 6676 ms Total time 55013 ms
 4TCMalloc Alloc time 3451 ms   Free time 1896 ms  Toal  time 21078 ms
 5
 6可以看到TCMalloc的分配和释放都比较快。。
 7
 8其中arr每个分配的大小命中概率。
 9Count[ 1 ] = 2436395
10Count[ 2 ] = 1281728
11Count[ 3 ] = 1026009
12Count[ 4 ] = 769123
13Count[ 5 ] = 768911
14Count[ 6 ] = 769335
15Count[ 7 ] = 640757
16Count[ 8 ] = 640974
17Count[ 9 ] = 512378
18Count[ 10 ] = 384841
19Count[ 11 ] = 256135
20Count[ 12 ] = 257367
21Count[ 13 ] = 256047

PS：
1.内存池的使用：
  

   一般情况下内存池，是整理一整块内存，然后通过一个list串连起来，然后分配的时候从链表中获取，释放也是插入到链表中。
    为了方便多对象的多参数以及无参数的分配，可以一些列宏和模板来实现:
    
    具体的可以参考后面附带的内存池实现的代码:
    
    #define DEFINE_CALL_CON( paramcount ) template <class T, DP_STMP_##paramcount( typename, tp ) >\
    inline T * Alloc(DP_MTMP_##paramcount( tp, p ) ){\
           unsigned long lSize = sizeof(T);\
           void* ptMem = Alloc(lSize);\
          if( !ptMem) return NULL; \
          T * pt = new(ptMem)T( LP_SNMP_##paramcount( p ) );\
          return pt;\
      }
    
    A. 对象分配:      
    MemFactory  Memory;

    A* a = Memory.Alloc<A>( );
    B* b = Memory.Alloc<B,int>( 2 );
    C* c = Memory.Alloc<C,int,const char*>(1,"dd");
    Memory.FreeObj( a );
    Memory.FreeObj( b );
       Memory.FreeObj( c );

    B.直接分配
    void* p1 = Memory.Alloc( Asize );
        memset(p1,0,ASize);

2.内存池的代码：
   1)   实现全是利用的freelist,减少内存开销，分配速度，直接定位。
   2)   管理都是通过工厂类来同一的管理。
   3)   指定分配策略.

   源码为Vs2008版本...

   /Files/expter/Pool.rar

关于实现有疑问和建议，可以提出宝贵的意见。。

 1template<class T>
 2class Array
 3{
 4public:
 5    explicit Array(int _size = 0);
 6    T & operator [](int index);
 7    
 8};
 9
10Array<int> a(10);
11Array<int> b(10);
12
13if (a == b[i])
14{
15    // 如果没有加explicit，可以编译通过，加了就不能通过
16}
17// 要转换可以使用
18if (a == static_cast<int> b[i])
19{
20    ..
21}

1#define  STR(ST) #ST

 1对于ma等关联容器的元素删除
 2map<int,int> mp;
 3for (map<int,int>::iterator it = mp.begin(); it != mp.end();)
 4{
 5    if ()  //满足删除条件
 6    {
 7        mp.erase(it++);//删除当前节点，并返回下一个元素，自加
 8    }
 9    else
10    {
11        it++;
12    }
13}
14对于vector等标准容器的元素删除
15vector<int> ve;
16for (vector<int>::iterator it = ve.begin(); it != ve.end();)
17{
18    if ()  //满足删除条件
19    {
20        it = ve.erase(it);
21    }
22    else
23    {
24        it++;
25    }
26}
27
28关于2者区别主要是erase返回值问题，可以在网上查相关的说明，

   根据 Boost 文档所述，当您分配和释放许多小型对象时，建议使用池。使用池的另一个不太明显的优点在于，作为程序员，您不必担心内存泄露：内存由 Boost 库在内部自动进行管理。要使用 pool 库，您不必在链接时提供特定的库——单凭头文件就足以完成链接了。 有多个接口对 pool 库可用：
   关于Boost pool可以阅读
  http://www.ibm.com/developerworks/cn/aix/library/au-util_boost_lib/

 1template<typename TyVal>
 2class Lock
 3{
 4public:
 5    explicit Lock()
 6    {}
 7    explicit Lock(TyVal val):_val(val)
 8    {
 9        //加锁
10    }
11    ~Lock(){//释放}
12private:
13    TyVal _val;
14};
15
16如果我们有一段代码需要加锁，则可以直接使用
17vector<int> Vint;
18Lock<vector<int> > lock(Vint);
19可以直到lock的声明周期结束，释放资源

 1struct Test
 2{
 3    //
 4    
 5    Test & operator = (const Test &_t)
 6    {
 7        //关于此处是否需要增加一个 _t与*this的判断,
 8       memcpy(this,&t,sizeof(t));      
 9        return *this;
10    }
11    
12    //
13};

1、关于初始化:

deque<string> Deque;// 一个deque容器

deque<string> Deque2(Deque.begin(),Deque.end());                // 一种初始化

copy(Deque.begin(),Deque.end(),back_inserter(Deque2) );         // 一种初始化

deque<string> Deque3(istream_iterator<string>(cin),istream_iterator<string>()); // 一种初始化

typedef istream_iteraor<string> (Func)();

deque<string> Deque3(istream_iteraotr<string> cin, Func);  
看上去像一个函数声明，

typedef istream_iteraor<string> (Func)();
deque<string> f(stream_iteraor<string> ,Func);
现在比较清晰了吧，很像一个函数声明了，

所以第三种初始化方式根本就不能做任何事情.

//如果真的要达到初始化的目标，可以通过括号来消除二义性
deque<string> Deque3( (istream_iterator<string> (cin)) , istream_iterator<string>() );

int main()
{

  double  x = 1e8;
  
  while(x >0)
      x--;


   return 0;
}

 

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    int x = 1;
    for (int i =0 ; i < 100; i++)
    {
        ;
    }

    //  下面这行代码会干些什么？递增???????/
    ++x;
    std::cout << x << std::endl; 
    return 0;
}

struct X 
{
    static bool f(int *p)
    {
        return p &&0[p] and not p[1:>>p[2];
    }
};

先一步一步的分析
1:0[p] 其实和p[0]一样
2: and not都是有效关键字 ，他们分别是&& 和!
3::>竟然也是合法的，他是]的双字符写法。

所以这个语句会被解析为 return p && p[0] && !p[1]>p[2] ，没有语法错误。
很诡异。

在复杂的国际形势和恶劣的经济环境下，独善其身的企业也不能侥幸。同样任何行业都必须为这此金融海啸埋单，包括银行。前几天我在回答和讯网马上访谈的栏目记者采访时，进一步提出“家电下乡”大跃进的危机所在，然而大量网友的指责并不能解除家电制造商脸上的尴尬。一方面来自渠道连锁的积怨已经爆发，另一方面内需的刺激几乎脱离了实际，还有内外交困的市场环境在一步步逼近并影响到其它行业。毫无疑问，矛盾在上升，众多的不确定性将在2009年1月-5月发生，不仅仅是将有更多的企业破产消逝，一系列社会问题也将考验我们每一个人。

这些图片说明什么？其背后究竟发生了什么？几乎每一个人都会异口同声地想到一点那就是就业形势的严峻，然而这只是其一，真正的原因还有经济形势不容乐观，企业竞争力在衰减，市场需求在减少，通涨通缩的变化太快，中国教育的垢病凸显愈加清晰。等等。但我们是否问过自己，究竟是谁导演了这一切？