标签: copy-constructor

#include <iostream>


int main(void)
{

class date {
private:
  int day;
  int month;
  int year;
public:
  date( )  { std::cout << "default constructor called" << std::endl; }
  date& operator=(const date& a) { std::cout << "copy constructor called" << std::endl; day=a.day; month=a.month; year=a.year; }
  date(int d ,int m ,int y  ) : day(d),month(m),year(y){ std::cout << "constructor called" << std::endl; }
  void p_date(){ std::cout << "day=" << day << ",month=" << month  << ",year=" << year << std::endl; }
  date& add_day(int d) …

早上好 - 这些都是我的面条烹饪了一点(同样,谷歌关于我注意到的c编程语言很难...)

void prepareFrames(PDouble prep){
  int gap = prep->gap;
  printf("Gap is %d\n", gap);
  prep->intFrames = (PFrame*)malloc(gap*sizeof(PFrame));
  PFrame copyFrame = prep->first;
  int i;
  for(i=0; i < gap; i++){
    prep->intFrames[i] = (PFrame)malloc(sizeof(Frame));
    copyFrame(prep->intFrames[i], prep->first, i);          //LINE 189
  }
}

void copyFrame(PFrame new, PFrame copy, int num){
  new->sequence = copy->sequence;
  new->evaluatedFrame = copy->evaluatedFrame + num;
  new->numBoxes = copy->numBoxes;
  new->boxes = (PBox*)malloc(copy->numBoxes*sizeof(PBox));
  int i;
  for(i=0; i < copy->numBoxes; i++){
    PBox old = copy->boxes[i];
    new->boxes[i] = (PBox)malloc(sizeof(Box));
    copyBox(new->boxes[i], old);
  }
}

我收到这个错误:

error: called …

void ParticleGeneratorController::generate() {
    for( unsigned i = 0; i < generators.size(); i++) {
        ParticleGenerator generator = *generators[i];
        generator.update();
    }
}

似乎调用了复制构造函数或其他东西,但我没有定义一个.我只有一个显式的默认构造函数.

https://github.com/ChrisLundquist/Waveform/blob/master/src/models/particle_generator.h

鉴于我的上述代码,通过测试失败.https://github.com/ChrisLundquist/Waveform/blob/master/spec/controllers/particle_generator_controller_spec.cpp#L21

写作时

void ParticleGeneratorController::generate() {
    for( unsigned i = 0; i < generators.size(); i++) {
        generators[i]->update();
    }
}

测试通过.

为什么在第一个实现中调用了复制构造函数？它是如何由编译器生成的？

我们的教授在网上发布了一个自定义的"String"模板文件,并在不久前问我们填写下面的功能.我的问题是,为了尝试理解这一点,这就是为什么排名前三的构造函数Text = NULL;在其下面,以及它的this = source;其他形式.我觉得每个人都应该说Text = the_input_parameter.

非常感谢,这是代码:

class String
{
public:
    // Default constructor
    String()
    {
        Text = NULL;
    }
    String(const String& source)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy
        *this = source;     
    }
    String(const char* text)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy

        *this = text;

    }
~String()
    {
        delete[] Text;
    }

    // Assignment operator to perform deep copy
    String& …

考虑一个类:

class loc{
    int x;
    int y;
    public:
    loc();
    loc(int x,int y);
    loc(const loc& l);//Copy Constructor
    loc operator + (const loc& l);
    loc operator - (const loc& l);
    loc& operator = (const loc& l);//Assignment Operator
    const loc& operator ++ ();
    friend ostream& operator << (ostream& os,const loc& l);
    friend istream& operator >> (istream& is,loc& l);
    ~loc();
    };

当我调用Assignment运算符时:

int main()
{
loc Ob;


cout << "########\n\n";
cin >> Ob;
cout << "Ob : " << Ob;

cout << "\n\n########\n\n";

loc …

这个问题是关于类对象的按位复制.为什么没有调用构造函数,而是在下面的代码中调用析构函数？输出为

HowMany h2 = f(h); //没有构造函数get; s在这里调用..

after construction of h: objectCount = 1
x argument inside f(): objectCount = 1
~HowMany(): objectCount = 0
after call to f(): objectCount = 0
~HowMany(): objectCount = -1
~HowMany(): objectCount = -2




class HowMany {
    static int objectCount;
public:
    HowMany() { objectCount++; }
    static void print(const string& msg = "") {
        if(msg.size() != 0) cout << msg << ": ";
        cout << "objectCount = "
            << objectCount << endl;
    }
    ~HowMany() { …

有没有办法在C++中实现复制构造函数,它只复制某些特定成员并为其他成员实现移动.

例如,我有一个班级

class partialCopy
{
   int a;
   int largeArray[1000] ;
}

现在假设使用移动构造函数我想只保留largeArray两个对象之间的一个副本并使用副本我可以在同一个两个对象之间保留整数a的单独副本.

编码时可能会出现这种情况.

任何人都可以分享这个想法吗？

为什么这个论点不是通过价值传递的？

当我尝试它时,我的编译器只给了我一条消息,说"你可能意味着" Foo(const Foo&).

这是什么原因？

我想要一个具有第三级继承的类.我不会移动我的课程或复制它们.实际上,它们只会创建一次.我想测试是否可以删除移动和复制构造函数和赋值,如下所示:

MyClass ( MyClass && ) = delete;
MyClass ( const MyClass & ) = delete;
MyClass & MyClass :: operator= ( const MyClass & ) = delete;
MyClass & MyClass :: operator= ( MyClass && ) = delete;

当我这样做时,我在基类构造函数和基类的基础上得到一个错误:

initializing argument 1 of ‘Base::Base(const int&)’ [-fpermissive]

我的构造函数是这样的:

Base(const string & name):BaseOfBase(name){

    };

我的问题是:

1. 是否可以删除所有移动和复制构造函数和赋值运算符？
2. 如果有可能,为什么我会收到错误？
3. 如果可能的话,这是一个不错的选择吗？

当我们定义复制构造函数时,是否需要清除我们正在编写的对象的内容？我正在实现一个二叉搜索树,并想知道我是否会有内存泄漏,除非我在实现复制构造函数和赋值运算符时清理它.