标签: copy-constructor

我知道如果你将一个成员从no-arg构造函数中的一个初始化列表中删除,那么将调用该成员的默认构造函数.

复制构造函数同样调用成员的复制构造函数,还是也调用默认构造函数？

class myClass {
  private:
    someClass a;
    someOtherClass b;
  public:
    myClass() : a(DEFAULT_A) {} //implied is b()
    myClass(const myClass& mc) : a(mc.a) {} //implied is b(mc.b)??? or is it b()?
}

对于这个计划

#include <iostream>
using std::cout;

struct C 
{
    C() { cout << "Default C called!\n"; }
    C(const C &rhs) { cout << "CC called!\n"; }
};

const C f()
{
    cout << "Entered f()!\n";
    return C();
}

int main()
{
    C a = f();
    C b = a;

    return 0;
}

我得到的输出是:

Entered f()!
Default C called!
CC called!

由于f()按值返回,它应该返回一个临时值.由于T a = x;是T a(x);,是不是要求建设的拷贝构造函数a,使用临时传入作为它的参数？

在阅读了C++中的复制构造函数和复制赋值运算符之后,我尝试创建一个简单的例子.虽然下面的代码片段显然有用,但我不确定我是否正确地实现了复制构造函数和复制赋值运算符.能不能指出是否有任何错误/改进或更好的例子来理解相关概念.

class Foobase
{
    int bInt;

public:
    Foobase() {}

    Foobase(int b) { bInt = b;}

    int GetValue() { return bInt;}

    int SetValue(const int& val) { bInt = val; }
};


class Foobar
{
    int var;    
    Foobase *base;      

public:
    Foobar(){}

    Foobar(int v)
    {
        var = v;        
        base = new Foobase(v * -1);

    }

    //Copy constructor
    Foobar(const Foobar& foo)
    {       
        var = foo.var;
        base = new Foobase(foo.GetBaseValue());
    }

    //Copy assignemnt operator
    Foobar& operator= (const Foobar& other)
    {
        if (this != &other) // …

我正在尝试复制自定义类的对象Event.我有一个指向我从其分配中获得的对象的共享指针:

std::shared_ptr<Event> e = std::make_shared<Event>();

为了获得e(不仅仅是指针的副本)的真实副本,我尝试过:

std::shared_ptr<Event> o = std::make_shared<Event>(*e);

但我不确定这是否是正确的方式,因为如果我删除e它也会删除o...

顺便说一句,我还没有定义一个拷贝构造函数,Event::Event(const Event &orig)但在我的理解中,这并不是必需的,因为编译器提供了一个默认的拷贝构造函数.事件类只包含变量而没有其他指针.

我有一个类,需要一个非默认的复制构造函数和赋值运算符(它包含指针列表).有没有通用的方法来减少复制构造函数和赋值运算符之间的代码重复？

我对复制构造函数的机制有点困惑.如我错了请纠正我:

如果一个方法将一个对象的引用作为参数,并且该类定义了一个复制构造器,那么该类使用构造函数来创建自身的副本,并将其传递给函数而不是对原始对象的引用？

此外,人们可以打电话

Object * obj = new Object(&anotherObject);

创建另一个对象的副本？

public class SuperCar: Car
{
     public bool SuperWheels { get {return true; } }
}

public class Car 
{
     public bool HasSteeringWheel { get {return true;} }
}

如何设置派生Supercar的基类？

例如,我想简单地设置SuperCars基类,如下所示:

public void SetCar( Car car )
{
SuperCar scar = new SuperCar();
car.Base = car; 
}

基本上,如果我有Car对象,我不想手动遍历汽车的每个属性以设置SuperCar对象,我认为这是你可以做到的唯一方法,但如果你能以另一种方式做到这一点会好得多.

我已经阅读了很多关于C++ 三规则的内容.很多人都发誓.但是当规则被陈述时,它几乎总是包括像"通常","可能"或"可能"这样的词,表示存在例外.我没有看到很多关于这些例外情况的讨论 - 三法则不成立的情况,或者至少在坚持它的情况下没有提供任何优势的情况.

我的问题是我的情况是否是三法则的合法例外.我相信在我下面描述的情况下,需要一个明确定义的复制构造函数和复制赋值运算符,但默认(隐式生成的)析构函数将正常工作.这是我的情况:

我有两个类,A和B.这里讨论的是A. B是A的朋友.A包含B对象.B包含一个A指针,用于指向拥有B对象的A对象.B使用此指针来操纵A对象的私有成员.除了A构造函数之外,B永远不会被实例化.像这样:

// A.h

#include "B.h"

class A
{
private:
    B b;
    int x;
public:
    friend class B;
    A( int i = 0 )
    : b( this ) {
        x = i;
    };
};

和...

// B.h

#ifndef B_H // preprocessor escape to avoid infinite #include loop
#define B_H

class A; // forward declaration

class B
{
private:
    A * ap;
    int y;
public:
    B( A * a_ptr = 0 ) {
        ap …

我有以下代码:

class C {
public:
    C(int) {}
    C(const C&) {}
    C() {}
};  

class D : public C { 
public:
    using C::C;
};  

int main() {
    C c;
    D d_from_c(c); // does not compile, copy ctor is not inherited
    D d_from_int(1); // compiles, C(int) is inherited
}   

衍生类应该继承除默认ctor之外的所有基数(这里解释).但为什么复制ctor也不是继承的呢？相关问题的论据在这里是不可接受的.

代码使用g ++ 4.8.1编译.

我有以下字段和构造函数:

private final Properties properties;

public PropertiesExpander(Properties properties) {
    this.properties = properties;
}

好的做法是在构造函数中复制每个可变集合.我想制作一份浅薄的独立副本.我怎样才能做到这一点？

我的第一个想法是使用putAll()方法:

private final Properties properties = new Properties();

public PropertiesExpander(Properties properties) {
    this.properties.putAll(properties);
}

有没有更简单,更高效或更惯用的方式呢？也许在Guava或Apache Commons中有一些实用工具？