标签: copy-constructor

我正在尝试为qt脚本编写示例代码.当我向QObjecy副本建设者宣布时,我认为我做的是正确的事情,我也冒昧宣布=运营商.但是这段代码一直在给我

'QObject::QObject' : cannot access private member declared in class 'QObject'

错误.

我声明MyClass这是一个QObject如下.我知道这可以让人看到我在这里做什么.

标题:

#ifndef SCRIPT_CLASSES_H
#define SCRIPT_CLASSES_H
#include "QObject"
#include "QtScript/QScriptValue"
#include "QtScript/QScriptable"
#include "QtScript/QScriptClass"

class MyClass : public QObject
{
    Q_OBJECT
//    Q_PROPERTY( int _id WRITE setId READ id )
public :
    MyClass(QObject *aparent =0) ;
    ~MyClass();

//     bool operator =(MyClass obj);

public slots:
    void setId(int d);
    int id() const ;
//    bool MyClass::equals(const MyClass &other);
private :
    int _id; …

例如,您的构造函数可能如下所示:

myClass::myClass(Mesh &mesh) : baseClass(mesh) 
{
    pointer = new Thing(mesh);
}

mesh没有保存在myClass中,也没有在baseClass中保存的网格的getter.这只是必须在基类中实现getter的情况吗？

例如,你不能这样做:

myClass::myClass(const myClass& original) : baseClass(mesh) //there is no mesh
{
    pointer = new Thing(mesh); //mesh is no longer in the parameter list
} 

编译器在为这些类创建默认复制构造函数时如何制作此副本？或者这是一个需要复制构造函数的情况？网格不是大脑的私人成员,并且没有吸气剂,所以我们如何制作新的东西？

编辑 - 通过添加更新问题 Thing

我的考试得到了这个问题

在传递参数中,在函数调用期间,复制参数=>调用每个参数的复制构造函数.假设将List作为参数传递,则复制列表的所有元素.如果它是对列表的引用,则仅复制列表的地址.你对这些陈述有什么看法？

我的回答是"如果它是对列表的引用,不仅复制了地址而且复制了值",我得到5分中的5分.我的回答错了吗？对我来说,这就是我得到的.上述陈述是否正确？

我正在尝试测试RVO和右值参考.这是代码:

#include <iostream>

using namespace std;

class B{
public:
    int i;

    B(){
        i = 0;
        cout << "B() " << i << endl;
    }

    B(const B& b){
        i = 1;
        cout << "B(const B&) " << i << endl;
    }

    B(const B&& b){//if remove this constructor, then call B(const B& b)
        i = 2;
        cout << "B(const B&&) " << i << endl;
    }

    ~B(){
        cout << "~B() " << i << endl;
    }
};

B …

我已经读过,如果我们在类中有指针,那么我们需要实现自己的复制构造函数; 否则,两个类将指向同一个内存位置的指针,并且在其中一个类上调用delete会使另一个类也为空.我试图通过编写如下代码来模拟上述条件:

class A
{
    private:
        int *p;
    public:
        A()
        {
            p = new int(10);
        }

        ~A()
        {
            delete p;
            cout << "Calling destructor" << endl;
        }
};

int main(int argc, char **argv)
{
    A a;
    A aa = a;
}

我期待抛出一些异常,因为我没有明确声明我的拷贝构造函数,我也在使用指针.但程序运行完美.任何人都可以建议修改,以便我能够理解在什么条件下会发生异常？

我有一个class1带有构造函数class1(int i)和复制构造函数的类class1(const class1& other).

实例class1是动态创建的,因为int在编译时不知道参数.

我的问题是我必须在生成器对象和使用者对象之间传递此指针:

void producer::produceAndSend(...) {
    class1 *c1 = generate(...); 
    consumerObj.set(c1);
}

class consumer {
    class1 *internalC;
    void set(class1 *c);
}

void consumer::set(class1 *c) {
    this->internalC = c; //This only copies the pointer, not the content
}

我想存储指向的对象的副本,c1并且必须指向此副本internalC.我怎样才能做到这一点？

检查这个答案后,我似乎无法解决我的问题:

我目前有一个test_iterator结构,它将不同类型的迭代器标记包装到它上,允许我使用所有类型的迭代器测试函数.在为这个迭代器创建一个拷贝构造函数时,我遇到了问题.当前结构定义为

template <typename BaseIterator, typename IteratorTag>
struct test_iterator
  : boost::iterator_adaptor<
        test_iterator<BaseIterator, IteratorTag>,
        BaseIterator, boost::use_default, IteratorTag>
{
private:
    typedef boost::iterator_adaptor<
        test_iterator<BaseIterator, IteratorTag>,
        BaseIterator, boost::use_default, IteratorTag>
    base_type;

public:
    test_iterator() : base_type() {}
    test_iterator(BaseIterator base) : base_type(base) {};

    test_iterator(const test_iterator& cpy): 
        base_type(cpy.base_type) {};
};

最后一个构造函数(复制构造函数)给了我麻烦,我似乎无法理解我做错了什么.我收到的确切错误是

error C2274: 'function-style cast' : illegal as right side of '.' operator

这是这一行:

base_type(cpy.base_type) {};

我写了一个简单的C++程序来测试C++中默认复制行为的概念.所以,我有一个示例类X,我创建了一个名为"var"的X类对象,然后我尝试使用"var"初始化另一个名为"defaultCopyObject"的对象,假设默认复制行为只是一个对象的成员副本到另一个.我已正确理解了这个概念,但我无法理解用于初始化的语法.

X defaultCopyObject{var};// this code snippet works perfectly fine

// this code snippet returns a compile time error
X defaultCopyObject;
defaultCopyObject{var};

有人可以解释我为什么前一个声明有效而后一个无效？

空和已删除的副本构造函数的示例:

class A
{
public:
    // empty copy constructor
    A(const A &) {}
}

class B
{
public:
    // deleted copy constructor
    A(const A&) = delete;
}

他们是否在实践中做同样的事情(禁止复制对象)？为什么delete比这更好{}？

我有一个graph有成员的班级:

std::vector<std::unique_ptr<layer>> _layers;

我理解其性质std::unique_ptr是不可复制的.我的graph::graph(const graph & rhs);拷贝构造函数产生编译错误,因为我的普通实现违反了本质std::unique_ptr.

graph::graph(const graph & rhs)
: _layers(rhs._layers) {}

如果我这样做,std::move那么我将违反param 的常量rhs,这不是我想要的.我知道我可以制作深层副本(例如,为存储的每个对象创建新的唯一指针rhs._layers)但除了迭代每个项目rhs._layers并分配新的唯一指针之外,还有一些优雅的方法吗？

gcc/g ++是c ++ 11而不是c ++ 14

我目前的解决方案是深度复制对象并分配新指针:

graph::graph(const graph & rhs)
{
   for (const auto & ptr : rhs._layers)
       _layers.emplace_back(std::unique_ptr<layer>(new layer(*ptr)));
}