修改

Question

想象一下，我有一些课程：

class MyClass{
    public:
        MyClass(unsigned int N): a(new double[N]){};
        ~MyClass(){delete[] a;};

    private:
         double* a;
}

在另一个类中，我使用指向此类的指针：

class MyOtherClass{
    public:
        MyOtherClass(unsigned int N):p(new MyClass(N)){};
        ~MyOtherClass(){delete p;};

        MyClass* get_MyClass(){return p;};

    private:
        MyClass *p;
}

然后，在主要内容中我需要获取MyOtherClass中包含的MyClass

int main(){
    MyOtherClass moc(1e100);
    MyClass mc;

    mc <-> moc.get_MyClass();
}

<->是我被困的地方。我希望mc成为p指向但不复制（巨大的）静态数组。有没有办法有效地进行这种转换？

修改

感谢您的回答，但我会准确一些。因为MyClass副本的耗时部分来自静态数组的副本，我想我可以做类似的事情：

class MyClass{
    public:
        MyClass(unsigned int N): a(new double[N]),del(true){};
        MyClass(MyClass* mc): a(mc.get_a()),del(true){};
        ~MyClass(){if(del){delete[] a;}};

        double* get_a(){
            del = false;
            return a;
        }

    private:
         double* a;
         bool del;
}

主要：

int main(){
    MyOtherClass moc(1e100);
    MyClass mc(moc.get_MyClass());
}

但我不知道我是否会有内存泄漏...

Answer 1

使用参考：

int main(){
    MyOtherClass moc(1e100);
    MyClass& mc = *moc.get_MyClass();
}

通过引用，您可以避免复制，仍然可以避免使用指针语法。

Answer 2

假设您希望销毁p个内容，请为MyClass编写移动构造函数。

通常，像您一样存储原始指针通常会产生问题。如果你使用vector<double>代替，整个任务会更容易，因为在这种方法中，不必要地使用指针只会给你增加问题。

我就是这样做的：

class MyClass{
    std::vector<double> a;
public:
    MyClass(unsigned int N): a(N) { }
    // no destructor!
};

class MyOtherClass{
    MyClass p;
public:
    MyOtherClass(unsigned int N) : p(N) {};
    // no destructor!!

    MyClass& getMyClass() { return p; };
}

现在可以清楚地看到，您不能仅使用getMyClass初始化新MyClass而不进行复制，因为它是一个参考。但是，如果您确定以后不需要使用MyOtherClass，或者您只是想“窃取”其数据，那么您应该能够安全地move MyOtherClass：

MyClass(MyClass&& other) : a(std::move(other.a)) {
    // now, I am not sure what will be left in other.a, but you can clean it up
    // (you can because it's in valid, only undefined state)
    other.a = std::vector<double>();
}

如果您对窃取数据不感兴趣，但想要访问它，请像其他人建议的那样使用参考。

Answer 3

您应该更改

的返回类型

MyClass* get_MyClass(){return p;};

到

MyClass& get_MyClass(){return p;};

因为你所描述的似乎是这个功能的主要用途。

然后只需使用：

检索实例

MyClass& mc = moc.get_MyClass ();

Answer 4

根据你的代码，double* MyClass::a;数组无法复制，因为默认的复制构造函数/复制操作符只执行指针的重新分配;

您应该使用智能指针来包装double* MyClass::a变量以启用引用计数，并在析构函数内的同一个addr上防止执行删除操作符两次。

您应该导航到this article并阅读。

如何使用智能指针与您可以找到的数组here

c ++将指向类的指针转换为类的实例

修改

4 个答案: