class CStack
{
public:
       CStack();  
       CStack(int  size); 
       CStack(const CStack& st);   //复制构造函数，注意使用引用
private:    
       int _size;
       int _count;
       int* _s;           
};
CStack::CStack(const CStack& st)
{
      _size=st._size;
      if(_size > 0)
      {
               _s = new int[_size];
               _count = st._count;                  //访问st的私有数据
               for(int i=0; i<_count; ++i)
                       _s[i] = st._s[i];             
      }         
      else
      {
          _s =  0;
          _count = 0;           
      }                                            
}

      在C++模型中，保护是在类层次应用的，而不是在对象层次。
      这句话的意思是，类的任意一个对象可以访问该类的另一个对象的内部的任何东西。在上面的例子中，复制构造函数中的赋值语句_size = st._size;访问了st的私有数据。
      这说明，C++中的访问保护是按照层次的原则定义的，那么什么事对象层次的保护呢？
      在Smalltalk中，成员函数可以当前对象的私有数据，但不能访问任何其它对象的私有数据，即使它们属于相同的类。

class CStack
{
public:
       CStack();  
       CStack(int  size=100); 
       CStack(const CStack& st);   //复制构造函数，注意使用引用
private:    
       int _size;
       int _count;
       int* _s;           
};
CStack::CStack(const CStack& st)
{
      _size=st._size;
      if(_size > 0)
      {
               _s = new int[_size];
               _count = st._count;         
               for(int i=0; i<_count; ++i)
                       _s[i] = st._s[i];             
      }         
      else
      {
          _s =  0;
          _count = 0;           
      }                                            
}

int main()
{
    CStack st;
    return 0;    
}

一. 在main()中，对象st不知道该调用哪一个构造函数，因为CStack()和CStack(int  size=100)都满足条件，此时正确的编译器会立即标示这种冲突，强迫实现者解决这个问题。

二. 假设我们已经有了一个CStack对象s1
CSatck s2=s1;      //这个句子将会调用复制构造函数
CStack s3 = CStack(200);   //这个句子将会做什么呢？

首先，产生一个临时CStack对象，不妨命名为sss，并调用构造函数CStack::CStack(200)，随后执行复制构造函数。也就是说，它相当于

CStack sss(200);
CStack s3(sss);

这很浪费时间，不过，大多数编译器还是能优化这种语句。但是我们为什么不养成一个好的习惯，直接写成
CStack s3(200)呢？