C++空类和string类

1. 空类

1.1 空类默认哪六个成员函数。

 class Empty
 {
   public:
       Empty(); //缺省构造函数 Empty e;
       Empty( const Empty& ); //拷贝构造函数 Empty e2(e1);
       ~Empty(); //析构函数
       Empty& operator=( const Empty& ); //赋值运算符 Empty e2 = e1;
       Empty* operator&(); //取址运算符 &e
       const Empty* operator&() const; //取址运算符const &e
 };

1.2 空类的sizeof()=1

每个实例在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址。

2. string类

以下四个函数，是C++编译器会自动加入的四个函数。

 class MyString
 {
 public:
     MyString(const char *str = NULL);//默认参数，不传递的该参数的时候发挥作用。
     MyString(const MyString &other);
     MyString& operator=(const MyString &other);
     ~MyString();
 private:
     char *m_data;
 };
 MyString::~MyString()
 {
     delete [] m_data;
 }
 MyString::MyString(const char *str)
 {
     if(NULL == str)
     {    cout<<"调用普通构造函数1"<<endl;
         m_data = new char[];
         *m_data = '\0';
     }
     else
     {
         cout<<"调用普通构造函数2"<<endl;
         size_t length = strlen(str);
         m_data = new char[length+];
         strcpy(m_data,str);
     }
 }
 MyString::MyString(const MyString &other)
 {    cout<<"调用拷贝构造函数"<<endl;
     size_t length = strlen(other.m_data);
     m_data = new char[length+];
     strcpy(m_data,other.m_data);
 }
 MyString& MyString::operator =(const MyString &other)
 {
     cout<<"调用赋值函数"<<endl;
     //检查自赋值
     if(this == &other)
         return *this;
     //释放原有的内存资源
     delete [] m_data;
     int length = strlen(other.m_data);
     m_data = new char[length+];
     strcpy(m_data,other.m_data);
     return *this;
 }
 int _tmain(int argc, _TCHAR* argv[])
 {
     MyString s0;//"调用普通构造函数1"
     MyString s1 = "hi";//"调用普通构造函数2"
     MyString s2("hi");//"调用普通构造函数2"

     MyString s3 = s1;//"调用拷贝构造函数"上述实现为深拷贝。
     MyString s4(s2);//"调用拷贝构造函数"
     s4 = "hello!";//将"hello!"传入赋值函数形参时，要调用普通构造函数2;接着调用赋值函数。
     s4 = s3;//"调用赋值函数"
     return ;
 }

总结：仅定义对象或者传递对象的时候调用构造函数。

说明：拷贝构造函数必须传引用。调用拷贝构造函数如果传值，编译器会新开辟一段栈内存，建立此对象的临时拷贝，而建立临时拷贝又需要值传递调用拷贝构造函数，如此

进入死循环，直至内存耗尽死机。而传引用则无需新开辟内存空间，无需调用构造函数，形参对象只是另一个对象的别名。