C++ 一次又一次地获得相同的记忆

在我的程序中，我在循环中创建一个类的对象，并将其存储在向量中。然后我打印对象和成员变量的地址。然后我把它们擦掉。每次我看到分配给我的对象和成员变量（指针）的地址都是一样的。有人能解释这种行为吗

#include <iostream>
#include <vector>

using namespace std;

typedef struct csock {
unsigned int _refCount;
mutable pthread_mutex_t _pdata_mutex;
pthread_attr_t attr;
bool _bSocketClosed;            /// used for testing while closing the socket
int _iSockFD;                   /// Holds the native socket descriptor
void* _pfnArgs; 
void* _logger;                  /// For debug logging
bool _isServiceRunning; 
pthread_t _thread_id;           /// Thread id for the listener service
int _pipes[2];                  /// For stop signal communication
pthread_mutex_t* _countMutex;
unsigned long  _idleTimeOut;                //Idle Time Out
FILE* fp;
} __attribute__((packed)) csock_t;




class csocket
{
protected:
void* _pImpl;

public :

csocket(){
csock_t* ps = new csock_t;
this->_pImpl = reinterpret_cast<void*> (ps);
std::cout<<"\n ps is "<<ps <<" _pImpl is "<<_pImpl <<endl;
}
void* getImpl()
{
    return _pImpl;
}
};


int main ()
{

vector<csocket> v;

 for (int i=0; i< 5; ++i) {
    v.push_back(csocket());
    cout<<"\n after pushback "<<v[v.size()-1].getImpl();
    cout<<"\n after pushback object is"<<&(v[v.size()-1]);
    delete (csock_t*) v[0].getImpl();
    v.erase(v.begin()+0);
}
cout <<"\n size of vector is "<<v.size();
return 0;
}

---

在

删除
对象后，它以前占用的内存被标记为空闲，其所有权被传递给堆，因此堆可以重用它所占用的空间以供将来分配。因此，堆恰好重用了完全相同的内存块。
在您
删除之前占用的内存对象后，
将其标记为空闲，并将其所有权传递给堆，因此允许堆重用其占用的空间以供将来分配。因此，堆恰好重用了完全相同的内存块。
一旦删除了一个对象，它所占用的内存将返回到运行时（或在某些情况下返回到操作系统）进行重用。如果您为另一个大小完全相同的对象分配内存，有时甚至更小一点，这一块内存可能是最合适的——因此，使用这一块内存，而不是从其他地方分割出另一块内存，从而提高以后出现内存碎片问题的可能性，是非常合理的。
一旦删除了一个对象，它占用的内存就会返回到运行时（或者在某些情况下会返回到操作系统）重复使用。如果您为另一个大小完全相同的对象分配内存，有时甚至更小一点，这一块内存可能是最合适的——因此，使用这一块内存，而不是从其他地方分割出另一块内存，从而提高以后出现内存碎片问题的可能性，是非常合理的。
我认为您需要的是基于弱指针的存储。你的
vector存储指向连接对象的弱指针。您的主要应用程序
获取共享指针。连接对象的析构函数释放
资源。通过清除所有弱指针，可以定期打包向量
使用计数为零

class Connect;

typedef boost::shared_ptr<Connect> ConnectPtr;
typedef boost::weak_ptr<Connect> ConnectWeakPtr;
typedef std::vector<ConnectWeakPtr> ConnectVector;

ConnectVector vector;

ConnectPtr ptr( new Connect ( ... ));

vector.push_back(ptr);

void pack() {
    ConnectVector tmp;
    BOOST_FOREACH(ConnectWeakPtr const & p, mMap){
        if (p.use_count() > 0){
            tmp.insert(p);
        }
        mMap.swap(tmp);
    }
}

类连接；
typedef boost：：共享_ptr ConnectPtr；
typedef boost:：弱_ptr ConnectWeakPtr；
typedef std:：vector ConnectVector；
连接向量；
连接ptr ptr（新连接（…）；
向量推回（ptr）；
空包（）{
连接向量tmp；
增压器（连接Weakptr const&p、mMap）{
如果（p.使用_count（）>0）{
tmp.插入（p）；
}
mMap掉期（tmp）；
}
}
我认为您需要的是基于弱指针的存储。你的
vector存储指向连接对象的弱指针。您的主要应用程序
获取共享指针。连接对象的析构函数释放
资源。通过清除所有弱指针，可以定期打包向量
使用计数为零

class Connect;

typedef boost::shared_ptr<Connect> ConnectPtr;
typedef boost::weak_ptr<Connect> ConnectWeakPtr;
typedef std::vector<ConnectWeakPtr> ConnectVector;

ConnectVector vector;

ConnectPtr ptr( new Connect ( ... ));

vector.push_back(ptr);

void pack() {
    ConnectVector tmp;
    BOOST_FOREACH(ConnectWeakPtr const & p, mMap){
        if (p.use_count() > 0){
            tmp.insert(p);
        }
        mMap.swap(tmp);
    }
}

类连接；
typedef boost：：共享_ptr ConnectPtr；
typedef boost:：弱_ptr ConnectWeakPtr；
typedef std:：vector ConnectVector；
连接向量；
连接ptr ptr（新连接（…）；
向量推回（ptr）；
空包（）{
连接向量tmp；
增压器（连接Weakptr const&p、mMap）{
如果（p.使用_count（）>0）{
tmp.插入（p）；
}
mMap掉期（tmp）；
}
}
对于与刚删除的对象类型相同的新对象，没有理由不能将相同的地址返回给您。你期望看到什么样的行为？坦率地说，我的问题更大。我认为共享指针可以解决我的问题。我维护一个tcp连接对象的向量。一旦它们不再需要，我就从vector中删除它们。但是向量是在互斥对象下的，所以当我从向量中删除它时，另一个具有相同地址的对象被创建并添加到向量中。我的删除标准是基于对象的地址，所以现在在向量中我有两个地址相同的对象，一个是死的，另一个是新创建的。这让我不合时宜地崩溃了。你做错了。运行删除（？）代码时，您必须更改删除条件/或/不删除任何对象。。。。或者，使用智能指针。没有理由不能为与刚删除的对象类型相同的新对象返回相同的地址。你期望看到什么样的行为？坦率地说，我的问题更大。我认为共享指针可以解决我的问题。我维护一个tcp连接对象的向量。一旦它们不再需要，我就从vector中删除它们。但是向量是在互斥对象下的，所以当我从向量中删除它时，另一个具有相同地址的对象被创建并添加到向量中。我的删除标准是基于对象的地址，所以现在在向量中我有两个地址相同的对象，一个是死的，另一个是新创建的。这让我不合时宜地崩溃了。你做错了。运行删除（？）代码时，您必须更改删除条件/或/不删除任何对象。。。。或者，使用智能指针。好的，我知道堆会重复使用它，但我没想到会这么快发生，我希望在重复使用同一地址之前会有一个小间隙。有时会有间隙，有时不会。取决于所使用的分配器、在此之前创建和删除的内容以及其他一些内容。但是一旦你删除了一些东西，在C和C++中，它的内存就立即被返回到运行时，并且立即有资格重用。它是否真正被立即重用取决于分配器。好的，我知道堆会重用它，但我没想到会这么快发生，我希望在重用相同地址之前会有一个小间隙。有时会有间隙，有时不会。取决于所使用的分配器、在此之前创建和删除的内容以及其他一些内容。但是一旦你删除了东西，在C和C++中，它的记忆就马上被手拿出来。