string类的实现

1.     String(const char* str=NULL);                //赋值构造兼默认构造函数(char)  

1.     String(const String &other);                 //赋值构造函数(String)  

 CExample(const CExample&); //拷贝构造函数  
     CExample& operator = (const CExample&); //赋值符重载  

 A & operate =( const A &other); // 赋值函数

000000000000000000000000000000000000000000000000000000000000000000000000000

构造函数是一种特殊的类成员函数，是当创建一个类的对象时，它被调用来对类的数据成员进行初始化和分配内存

构造函数可以被重载，可以多个，可以带参数；

析构函数只有一个，不能被重载，不带参数

 

而默认构造函数没有参数，它什么也不做。当没有重载无参构造函数时，

  A a就是通过默认构造函数来创建一个对象

0000000000000000000000000000000000000000000000000000000000000000000000000000

对象不存在，且没用别的对象来初始化，就是调用了构造函数；

                对象不存在，且用别的对象来初始化，就是拷贝构造函数（上面说了三种用它的情况！）

                 对象存在，用别的对象来给它赋值，就是赋值函数

0000000000000000000000000000000000000000000000000000000000000000000000000000

拷贝构造函数

拷贝构造函数是C++独有的，它是一种特殊的构造函数，用基于同一类的一个对象构造和初始化另一个对象。

当没有重载拷贝构造函数时，通过默认拷贝构造函数来创建一个对象

A a;

A b(a);

A b=a;  都是拷贝构造函数来创建对象b

强调：这里b对象是不存在的，是用a 对象来构造和初始化b的！！

先说下什么时候拷贝构造函数会被调用：

在C++中，3种对象需要复制，此时拷贝构造函数会被调用

1）一个对象以值传递的方式传入函数体

2）一个对象以值传递的方式从函数返回

3）一个对象需要通过另一个对象进行初始化

什么时候编译器会生成默认的拷贝构造函数：

1）如果用户没有自定义拷贝构造函数，并且在代码中使用到了拷贝构造函数，编译器就会生成默认的拷贝构造函数。但如果用户定义了拷贝构造函数，编译器就不在生成。

2）如果用户定义了一个构造函数，但不是拷贝构造函数，而此时代码中又用到了拷贝构造函数，那编译器也会生成默认的拷贝构造函数。

 

因为系统提供的默认拷贝构造函数工作方式是内存拷贝，也就是浅拷贝。如果对象中用到了需要手动释放的对象，则会出现问题，这时就要手动重载拷贝构造函数，实现深拷贝。

下面说说深拷贝与浅拷贝：

浅拷贝：如果复制的对象中引用了一个外部内容（例如分配在堆上的数据），那么在复制这个对象的时候，让新旧两个对象指向同一个外部内容，就是浅拷贝。（指针虽然复制了，但所指向的空间内容并没有复制，而是由两个对象共用，两个对象不独立，删除空间存在）

深拷贝：如果在复制这个对象的时候为新对象制作了外部对象的独立复制，就是深拷贝。

拷贝构造函数重载声明如下： 

A (const A&other)

下面为拷贝构造函数的实现：

[cpp]  view plain  copy

1. <span style="font-size:14px;">class A  
2. {  
3.   int m_i  
4.   A(const A& other):m_i(other.m_i)  
5. {  
6.   Cout<<”拷贝构造函数”<<endl;  
7. }  
8. }</span>  

00000000000000000000000000000000000000000000000000000000000000000000000000000000000

拷贝构造函数是一个对象初始化一块内存区域，这块内存就是新对象的内存区，而赋值函数是对于一个已经被初始化的对象来进行赋值操作。

[cpp]  view plain  copy

1. <span style="font-size:14px;">class  A;  
2. A a;  
3. A b=a;   //调用拷贝构造函数（b不存在）  
4. A c(a) ;   //调用拷贝构造函数  
5.   
6. /****/  
7.   
8. class  A;  
9. A a;  
10. A b;     
11. b = a ;   //调用赋值函数(b存在)</span>  

2）一般来说在数据成员包含指针对象的时候，需要考虑两种不同的处理需求：一种是复制指针对象，另一种是引用指针对象。拷贝构造函数大多数情况下是复制，而赋值函数是引用对象

3）实现不一样。拷贝构造函数首先是一个构造函数，它调用时候是通过参数的对象初始化产生一个对象。赋值函数则是把一个新的对象赋值给一个原有的对象，所以如果原来的对象中有内存分配要先把内存释放掉，而且还要检察一下两个对象是不是同一个对象，如果是，不做任何操作，直接返回。（这些要点会在下面的String实现代码中体现）

 

！！！如果不想写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，最简单的办法是将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。如：

[cpp]  view plain  copy

1. <span style="font-size:14px;">class A  
2. {  
3.  private:  
4.  A(const A& a); //私有拷贝构造函数  
5.  A& operate=(const A& a); //私有赋值函数  
6. }</span>  

如果程序这样写就会出错：

[cpp]  view plain  copy

1. <span style="font-size:14px;">A a;  
2. A b(a); //调用了私有拷贝构造函数，编译出错  
3.   
4. A b;  
5. b=a; //调用了私有赋值函数，编译出错</span>  

所以如果类定义中有指针或引用变量或对象，为了避免潜在错误，最好重载拷贝构造函数和赋值函数。

0000000000000000000000000000000000000000000000000000000000000000000000000

拷贝构造函数和赋值函数的区别

拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗？

String a(“hello”);

String b(“world”);

String c = a; // 调用了拷贝构造函数，最好写成c(a);

c = b; // 调用了赋值函数

0000000000000000000000000000000000000000000000000000000000000000000000000

这个在面试或笔试的时候常问到或考到。

已知类String的原型为：
class String
{
public:
     String(const char *str = NULL);// 普通构造函数
     String(const String &other);    // 拷贝构造函数
     ~ String(void);    // 析构函数
     String & operate =(const String &other);// 赋值函数
private:
     char *m_data;// 用于保存字符串
}; 
请编写String的上述4个函数。
//普通构造函数
String::String(const char *str)
{
        if(str==NULL)
        {
                m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的//加分点：对m_data加NULL 判断
                *m_data = '\0';
        }    
        else
        {
         int length = strlen(str);
         m_data = new char[length+1]; // 若能加 NULL 判断则更好
         strcpy(m_data, str);
        }
} 
// String的析构函数
String::~String(void)
{
        delete [] m_data; // 或delete m_data;
}
//拷贝构造函数
String::String(const String &other) 　　　// 得分点：输入参数为const型
{     
        int length = strlen(other.m_data);
        m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断
        strcpy(m_data, other.m_data);    
} 
//赋值函数
String & String::operate =(const String &other) // 得分点：输入参数为const

型
{     
        if(this == &other)                  　　//得分点：检查自赋值
                return *this;   
        delete [] m_data;            　　　　//得分点：释放原有的内存资源
        int length = strlen( other.m_data );      
        m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断
        strcpy( m_data, other.m_data );   
        return *this;     　　　　　　　　//得分点：返回本对象的引用  

}

  
  

   
   

  
  
已知类String的原型为：class String{public:     String(const char *str = NULL);// 普通构造函数     String(const String &other);    // 拷贝构造函数     ~ String(void);    // 析构函数     String & operate =(const String &other);// 赋值函数private:     char *m_data;// 用于保存字符串}; 请编写String的上述4个函数。//普通构造函数String::String(const char *str){        if(str==NULL)        {                m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的//加分点：对m_data加NULL 判断                *m_data = '\0';        }            else        {         int length = strlen(str);         m_data = new char[length+1]; // 若能加 NULL 判断则更好         strcpy(m_data, str);        }} // String的析构函数String::~String(void){        delete [] m_data; // 或delete m_data;}//拷贝构造函数String::String(const String &other) 　　　// 得分点：输入参数为const型{             int length = strlen(other.m_data);        m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断        strcpy(m_data, other.m_data);    } //赋值函数String & String::operate =(const String &other) // 得分点：输入参数为const型{             if(this == &other)                  　　//得分点：检查自赋值                return *this;           delete [] m_data;            　　　　//得分点：释放原有的内存资源        int length = strlen( other.m_data );              m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断        strcpy( m_data, other.m_data );           return *this;     　　　　　　　　//得分点：返回本对象的引用  }