C++ 为什么重新分配unique_ptr会增加内存使用率？

我有一个基类和它的一些变形。我希望能够创建一个class base类型的对象，然后将其变形为class派生对象，然后返回到base。一个人能做到吗？我的做法如下，但我不确定这是否正确：

假设我有这些课程：

class base {
public:
    int var;
    base();
    virtual ~base();
    virtual void func1();
    void func2();
}

class derived1 : base {
public:
    unique_ptr<otherClass> otherVar;
    vector<unique_ptr<anotherClass>> myVec;
    derived1();
    ~ derived1() {
    otherVar.reset();
    for (unsigned int i=0; i< myVec.size(); i++) {
    myVec[i].reset();
    }
    myVec.clear();
    vector<unique_ptr< anotherClass >>().swap(myVec);
    }
    void  func1(){
       //do something
    }
}

class derived2 : base {
public:
    derived2();
    ~ derived2();
    void  func1(){
       //do something else
    }
}

此otherVar包含OpenGL纹理。该对象的析构函数应至少通过以下调用一次删除Mac上的所有纹理：

glDeleteTextures(textureCount, textures);

但在iOS OpenGL ES上，我必须单独删除纹理，如下所示：

glDeleteTextures(1, &tex.textureID);

尽管如此，我不知道为什么glDeleteTexturestextureCount，纹理不会在iOS应用程序中一次删除所有纹理，但至少我找到了一种解决方法

---

谢谢大家

不可能确定，但我怀疑您的代码中可能存在循环所有权模式。下面是一个简单的例子：

#include <iostream>
#include <memory>

struct B;
struct C;

struct A
{
    std::unique_ptr<B> b_ptr_;

    ~A();
};

struct B
{
    std::unique_ptr<C> c_ptr_;

    ~B();
};

struct C
{
    std::unique_ptr<A> a_ptr_;

    ~C();
};


A::~A()
{
    std::cout << "~A()\n";
}

B::~B()
{
    std::cout << "~B()\n";
}

C::~C()
{
    std::cout << "~C()\n";
}

int
main()
{
    std::unique_ptr<A> a_ptr(new A);
    a_ptr->b_ptr_ = std::unique_ptr<B>(new B);
    a_ptr->b_ptr_->c_ptr_ = std::unique_ptr<C>(new C);
    a_ptr->b_ptr_->c_ptr_->a_ptr_ = std::move(a_ptr);
}

正确输出：

~A()
~B()
~C()

即，在循环中插入一个不属于自己的原始指针。也可以使用共享的ptr和弱ptr来打破循环：

#include <iostream>
#include <memory>

struct B;
struct C;

struct A
{
    std::shared_ptr<B> b_ptr_;

    ~A();
};

struct B
{
    std::shared_ptr<C> c_ptr_;

    ~B();
};

struct C
{
    std::weak_ptr<A> a_ptr_;

    ~C();
};


A::~A()
{
    std::cout << "~A()\n";
}

B::~B()
{
    std::cout << "~B()\n";
}

C::~C()
{
    std::cout << "~C()\n";
}

int
main()
{
    std::shared_ptr<A> a_ptr(new A);
    a_ptr->b_ptr_ = std::shared_ptr<B>(new B);
    a_ptr->b_ptr_->c_ptr_ = std::shared_ptr<C>(new C);
    a_ptr->b_ptr_->c_ptr_->a_ptr_ = std::move(a_ptr);
}

~A()
~B()
~C()

---

如果我错误地认为循环所有权是您案例中的罪魁祸首，那么您的时间不会完全浪费在回顾上，理解并记录代码中的所有权路径。

您分配了一个新对象，并想知道计算机为什么为它分配内存？现在，在代码中的其他地方，我这样做：如果以后我这样做：所以我想这意味着您不能用一个简单的3行或4行程序重复这个问题。你说在别的地方，然后我说，这表明你的程序比你给我们看的要大得多。也许你没有向我们展示的是导致这种行为的原因。重新分配内存后，内存会变大。我希望重置会释放一些内存，但似乎没有任何效果。您如何知道堆大小显著增加，以及如何定义显著增加？@DARKMATTER您如何确定内存未释放？希望不是通过使用任务管理器或类似程序之类的操作系统工具实现的。谢谢Howard，但是代码中没有循环所有权。该应用程序在Mac上运行良好，但iOS版本在运行一段时间后由于内存逐渐增长而崩溃。这是一个OpenGL ES图形密集型应用程序，所以我真的不能忽视内存问题。

#include <iostream>
#include <memory>

struct B;
struct C;

struct A
{
    std::unique_ptr<B> b_ptr_;

    ~A();
};

struct B
{
    std::unique_ptr<C> c_ptr_;

    ~B();
};

struct C
{
    std::unique_ptr<A> a_ptr_;

    ~C();
};


A::~A()
{
    std::cout << "~A()\n";
}

B::~B()
{
    std::cout << "~B()\n";
}

C::~C()
{
    std::cout << "~C()\n";
}

int
main()
{
    std::unique_ptr<A> a_ptr(new A);
    a_ptr->b_ptr_ = std::unique_ptr<B>(new B);
    a_ptr->b_ptr_->c_ptr_ = std::unique_ptr<C>(new C);
    a_ptr->b_ptr_->c_ptr_->a_ptr_ = std::move(a_ptr);
}

#include <iostream>
#include <memory>

struct B;
struct C;

struct A
{
    std::unique_ptr<B> b_ptr_;

    ~A();
};

struct B
{
    std::unique_ptr<C> c_ptr_;

    ~B();
};

struct C
{
    A* a_ptr_;

    ~C();
};


A::~A()
{
    std::cout << "~A()\n";
}

B::~B()
{
    std::cout << "~B()\n";
}

C::~C()
{
    std::cout << "~C()\n";
}

int
main()
{
    std::unique_ptr<A> a_ptr(new A);
    a_ptr->b_ptr_ = std::unique_ptr<B>(new B);
    a_ptr->b_ptr_->c_ptr_ = std::unique_ptr<C>(new C);
    a_ptr->b_ptr_->c_ptr_->a_ptr_ = a_ptr.get();
}

~A()
~B()
~C()

#include <iostream>
#include <memory>

struct B;
struct C;

struct A
{
    std::shared_ptr<B> b_ptr_;

    ~A();
};

struct B
{
    std::shared_ptr<C> c_ptr_;

    ~B();
};

struct C
{
    std::weak_ptr<A> a_ptr_;

    ~C();
};


A::~A()
{
    std::cout << "~A()\n";
}

B::~B()
{
    std::cout << "~B()\n";
}

C::~C()
{
    std::cout << "~C()\n";
}

int
main()
{
    std::shared_ptr<A> a_ptr(new A);
    a_ptr->b_ptr_ = std::shared_ptr<B>(new B);
    a_ptr->b_ptr_->c_ptr_ = std::shared_ptr<C>(new C);
    a_ptr->b_ptr_->c_ptr_->a_ptr_ = std::move(a_ptr);
}

~A()
~B()
~C()