为什么不只有一个?复制构造函数和赋值运算符

时间:2014-07-16 10:20:54

标签: c++

我明白在什么情况下会调用哪个......

Sample a;
Sample b = a; //calls copy constructor
Sample c;
c = a;        //calls assignment operator

我的问题是为什么存在这两种不同的东西?为什么两个人中只有一个能够处理这两种情况?

5 个答案:

答案 0 :(得分:4)

不,他们是不同的。

复制构造函数用于构造新对象(来自另一个对象)。在这种情况下,您只需要初始化成员。

赋值运算符用于现有对象(您可能已通过默认构造函数等构造它),然后由另一个对象分配。在这种情况下,您需要重新初始化成员,有时意味着再次销毁和初始化它们。

即便如此,它们的功能也非常相似,因此您可以共享它们的实现。例如:What is the copy-and-swap idiom?

答案 1 :(得分:1)

复制构造函数在创建时被调用,这意味着您不必处理对象中的旧资源。另一方面,赋值运算符必须释放旧资源。除此之外,它们具有不同的语义。

答案 2 :(得分:0)

假设String类:

class String
{
    char *m_str;
    size_t m_len, m_alloced;
public:
    String(const char *str = "")
    {
        m_len = strlen(str);
        m_alloced = m_len + 1;
        m_str = (char *)malloc(m_alloced);
        strcpy(m_str, str);
    }
    String(const String &other)
    {
        m_len = other.m_len;
        m_alloced = m_len + 1;
        m_str = (char *)malloc(m_alloced);
        strcpy(m_str, other.m_str);
    }
    String &operator =(const String &rhs)
    {
        if (m_alloced < rhs.m_len + 1)
        {
            m_alloced = rhs.m_len + 1;
            m_str = (char *)realloc(m_str, m_alloced);
        }

        m_len = rhs.m_len;
        strcpy(m_str, rhs.m_str);
        return *this;
    }
    const char *get() const
    {
        return m_str;
    }
};

(live example)

显然,复制构造函数复制赋值运算符会做不同的事情。查看String::String(const String &other)

m_len = other.m_len;
m_alloced = m_len + 1;
m_str = (char *)malloc(m_alloced);
strcpy(m_str, other.m_str);

初始化其对象。设置m_lenm_allocedm_str,然后绑定字符串。

然而,String &String::operator =(const String &rhs)确实 -

if (m_alloced < rhs.m_len + 1)
{
    m_alloced = rhs.m_len + 1;
    m_str = (char *)realloc(m_str, m_alloced);
}

m_len = rhs.m_len;
strcpy(m_str, rhs.m_str);
return *this;

修改其对象。如果需要,分配更多内存,重新设置m_len重新复制字符串。

复制构造函数在创建对象时调用,并初始化其对象。

但在创建对象后,复制赋值运算符会被称为,并且会修改其对象。


例如,请查看此代码。

String str1 = "asdf";
String str2 = str1;
String str3 = "12";
str3 = str1;

(it's also in the live example)

str1String::String(const char *)初始化。如您所知,它包含"asdf"

str2复制构造函数 String::String(const String &other)初始化。通过复制构造函数,str2将包含相同的内容。

str3String::String(const char *)初始化,与str1一样。但是,在第4行中,复制赋值运算符 修改。因此,str3首先包含"12",但其内容将通过复制赋值运算符修改为"asdf"

答案 3 :(得分:0)

好吧,你可以从技术上来说只需要一个复制构造函数和一个析构函数,但这需要每次你想要做一个赋值时你必须销毁该对象然后重建它。在绝大多数用例中,这将变得 HIGHLY 低效。

我们不能只有一个operator=,因为你还不知道如果尚未构建运算符的左侧是什么。它的成员可能会包含垃圾数据而且#3;狗屎会击中粉丝&#34;。

因此,您可以将operator=和复制构造函数都视为优化。


据说有一些设计模式可以减少你必须编写的代码量。例如,假设您有一个复制构造函数,一个析构函数和一个为您的类实现的交换函数。您可以使用复制交换操作实现operator=

MyClass & operator=( MyClass rhs ) { // notice the call by value, this will 
                                     // implicitly call the copy-constructor.
    swap(*this, rhs);
    return *this;
}

虽然此运算符具有强大的异常安全性,但值得注意的是,它可能比重用预分配资源(更高级的operator=可能执行的资源)效率低得多。

答案 4 :(得分:0)

基本上,它们用于不同的情况,许多正确的答案,我只是想添加一些东西来清除复制构造函数的使用位置:

例如:

void test(Fraction in){
    //Do something here
    }

Fraction test2(){
    Fraction a(1, 2);
    //Do something here
    return a; // construct a return value by copy a
}

int main()
{
    Fraction a(2, 3);
    Fraction b(a); //construct b by copy a
    Fraction c=a; //construct c by copy a
    test(a); //construct in by copy a
}