标签: copy-constructor

class A
{
 public:
  A(const int n_);
  A(const A& that_);
  A& operator=(const A& that_);
};

A::A(const int n_)
{ cout << "A::A(int), n_=" << n_ << endl; }

A::A(const A& that_)    // This is line 21
{ cout << "A::A(const A&)" << endl; }

A& A::operator=(const A& that_)
{ cout << "A::operator=(const A&)" << endl; }

int foo(const A& a_)
{ return 20; }

int main()
{
  A a(foo(A(10)));    // This is line 38
  return 0;
}

执行此代码给出了o/p:

A :: …

我试图解决的问题产生于容器,例如std::vector包含引用和const数据成员的对象:

struct Foo;

struct Bar {
  Bar (Foo & foo, int num) : foo_reference(foo), number(num) {}
private:
  Foo & foo_reference;
  const int number;
  // Mutable member data elided
};

struct Baz {
  std::vector<Bar> bar_vector;
};

这不会按原样工作,因为Foo由于引用成员foo_reference和const成员,无法构建类的默认赋值运算符number.

一种解决方案是将其更改foo_reference为指针并删除const关键字.然而,这会失去引用优于指针的优点,而该const成员确实应该这样做const.他们是私人成员,所以唯一可以造成伤害的是我自己的代码,但是我用自己的代码射击了自己的脚(或更高).

我已经看到了解决这一问题的形式在网络上swap出现的基础上的奇迹被座充满不确定的行为方式reinterpret_cast和const_cast.碰巧这些技术确实在我的计算机上运行.今天.使用一个特定编译器的特定版本.明天还是用不同的编译器？谁知道.我不打算使用依赖于未定义行为的解决方案.

stackoverflow的相关问题:

• 在具有所有const数据成员的类中实现复制赋值运算符是否有意义？
  第一个答案是有趣的一句话"如果那个是不可改变的,你的搞砸了."
• 使用const成员
  的交换方法第一个答案在这里并不真正适用,第二个答案有点像kludge.

那么有没有办法swap为这样一个不调用未定义行为的类编写方法/复制构造函数,或者我只是搞砸了？

编辑
只是为了说清楚,我已经非常了解这个解决方案:

struct Bar {
  Bar (Foo & foo, int …

我正在审查自定义容器的代码,它的一些部分创建这样的元素:

::new( (void*)&buffer[index] ) CStoredType( other );

有些人喜欢这样:

::new( &buffer[index] ) CStoredType( other );

因此,两者都使用placement new来调用复制构造函数来通过复制其他元素来创建元素,但是在一种情况下,指向新元素存储的指针按原样传递,而在另一种情况下,它将被传递给void*.

这会void*产生什么影响吗？

在大多数情况下,在C++中很容易实现复制构造函数(或重载赋值运算符),因为有一个指针的概念.但是,我对如何在Python中实现浅层和深层复制感到困惑.

我知道其中一个库中有特殊命令,但它们不适用于您自己编写的类.那么实施的常用方法有哪些？

PS将显示一些基本数据结构(链表或树)上的显示过程.

编辑:谢谢,他们工作,这是我在语法上的错误.我很感兴趣用__copy__()和覆盖这些函数__deep_copy()__.例如.如何在不知道数据结构中包含哪种类型的信息的情况下进行深层复制？

在这段代码中:

#include <iostream>

using std::cout;

class Foo {
    public:
        Foo(): egg(0) {}
        Foo(const Foo& other): egg(1) {}

        int egg;
};

Foo bar() {
    Foo baz;
    baz.egg = 3;
    return baz;
}

int main(void) {
    Foo spam(bar());
    cout << spam.egg;
    return 0;
}

输出是3,虽然我预期它1.

这意味着不会在行中调用复制构造函数Foo spam(bar()).

我想这是因为bar函数没有返回引用.

你能解释一下初始化时真正发生了spam什么吗？

如果这是一个愚蠢的问题,我会提前道歉.

谢谢!

如何为具有接口成员变量的类编写复制构造函数？

例如:

public class House{

    // IAnimal is an interface
    IAnimal pet;

    public House(IAnimal pet){
        this.pet = pet;
    }

    // my (non-working) attempt at a copy constructor
    public House(House houseIn){
        // The following line doesn't work because IAnimal (an interface) doesn't 
        // have a copy constructor
        this.pet = new IAnimal(houseIn.pet);
    }
}

我被迫有一个混凝土Animal吗？如果是这样的话,似乎重复使用课程与狗的房子与猫的房子变得错综复杂!

在更新一些代码以使用统一初始化时,我认为它将成为现在"旧式"括号样式的现代替代品.我知道情况并非总是如此(显而易见的例子vector<int>),但我偶然发现了另一个我不理解的差异.

class Object {
    public:
        Object() = default;
        Object(const Object&) = default;
};

int main() {
    Object o;
    Object copy{o}; // error
    Object copy2(o); // OK
}

无法在clang3.5下编译并出现错误:(在gcc下也失败)

error: excess elements in struct initializer

这有两个不同的变化Object使这项工作.向其添加数据成员,或为其提供空复制构造函数体

class Object {
    private:
        int i; // this fixes it
    public:
        Object() = default;
        Object(const Object&) { } // and/or this fixes it as well
};

我不明白为什么这些应该有所作为.

std::copy是一种更通用的方法,因为它可以处理具有不同值类型的容器(例如从中复制std::vector<float>到std::vector::<double>).但是当两个容器的值类型相同时,我是否使用复制构造函数而不是std::copy？

假设我有一个包含多个构造函数的类,其中一个是复制构造函数(复制对象):

public class Rectangle {

    int width, height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public Rectangle(Rectangle source) {
        this(source.width, source.height);
    }
}

有没有什么办法可以让检查,如果source是null在拷贝构造函数和抛出IllegalArgumentException,如果它是什么？因为其他构造函数调用必须是我的构造函数中的第一个语句.

任何人都可以解释*p=*q这个C++代码的含义吗？这是一个复制构造函数的概念吗？

class A{
  //any code
}

int main(){
  A *p=new A();
  A *q=new A();
  *p=*q;
  return 0;
}