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

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

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

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

您应该导航到 this article 并阅读相关信息。

如何在数组中使用智能指针你可以找到here

Answer 4

你应该改变返回类型

MyClass* get_MyClass(){return p;};

到

MyClass& get_MyClass(){return p;};

因为你描述的似乎是这个函数的主要用途。

然后只需检索实例：

MyClass& mc = moc.get_MyClass ();