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

c++ convert a pointer to a class into a instance of a class

本文关键字：转换 实例 指针 c++      更新时间：2023-10-16

想象一下，我有一些类：

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

CCD_ 1就是我被卡住的地方。我希望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());
}

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

使用参考：

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

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

假设要销毁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>();
}

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

根据您的代码，<->0数组无法复制，因为默认的复制构造函数/复制运算符只执行指针的重新分配；

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

您应该浏览到这篇文章并阅读。

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

您应该更改的返回类型

MyClass* get_MyClass(){return p;};

至

MyClass& get_MyClass(){return p;};

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

然后只需使用检索实例

MyClass& mc = moc.get_MyClass ();
相关文章：