0

想象一下，我有一些课：

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());
}

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

4

4 回答 4

3

使用参考：

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

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

于 2013-06-26T12:45:07.783 回答
1

假设您想要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>();
}

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

于 2013-06-26T12:40:24.757 回答
0

您应该更改的返回类型

MyClass* get_MyClass(){return p;};

至

MyClass& get_MyClass(){return p;};

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

然后只需检索实例：

MyClass& mc = moc.get_MyClass ();
于 2013-06-26T12:45:01.300 回答
0

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

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

您应该导航到这篇文章并阅读相关内容。

如何将智能指针与数组一起使用，您可以在此处找到

于 2013-06-26T12:48:56.317 回答