把类成员改成指针_C++带有指针成员的类处理方式详解

悠悠 2022-10-26 14:17 131阅读 0赞

在一个类中，如果类没有指针成员，一切方便，因为默认合成的析构函数会自动处理所有的内存。但是如果一个类带了指针成员，那么需要我们自己来写一个析构函数来管理内存。在<> 中写到，如果一个类需要我们自己写析构函数，那么这个类，也会需要我们自己写拷贝构造函数和拷贝赋值函数。

析构函数：

我们这里定义一个类HasPtr，这个类中包含一个int 类型的指针。然后定义一个析构函数，这个函数打印一句话。

HasPtr.h 类的头文件

\#pragma once

\#ifndef \_\_HASPTR\_\_

\#define \_\_HASPTR\_\_

class HasPtr

public:

HasPtr(int i,int \*p);

//HasPtr& operator=(HasPtr&);

//HasPtr(const HasPtr&);

~HasPtr();

int get\_ptr\_value();

void set\_ptr\_value(int \*p);

int get\_val();

void set\_val(int v);

private:

int val;

int \*ptr;

\};

\#endif // !\_\_HASPTR\_\_

HasPtr.cpp 类的实现

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

HasPtr::HasPtr(int i, int \*p)

val = i;

ptr = p;

int HasPtr::get\_ptr\_value()

return \*ptr;

void HasPtr::set\_ptr\_value(int \*p)

ptr = p;

int HasPtr::get\_val()

return val;

void HasPtr::set\_val(int v)

val = v;

HasPtr::~HasPtr()

cout << "destructor of HasPtr " << endl;

ClassWithPointer 类，包含main入口，HasPtr在stack上。

// ClassWithPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

int main()

int temp = 100;

HasPtr ptr(2,&temp);

cout << ptr.get\_ptr\_value() << endl;

cout << ptr.get\_val() << endl;

system("PAUSE");

return 0;

执行该入口方法，发现最后还是打印了析构函数这句话，OK，在main 方法中，stack上定义了一个HasPtr，在main方法退出前，析构函数自动调用了。

如果将HasPtr改为动态对象，也就是放在堆上呢？

ClassWithPointer 类，包含main入口，HasPtr在heap上。

// ClassWithPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

int main()

int temp = 100;

//HasPtr ptr(2,&temp);

HasPtr \*ptr = new HasPtr(2,&temp);

cout << ptr->get\_ptr\_value() << endl;

cout << ptr->get\_val() << endl;

system("PAUSE");

return 0;

执行一下，发现析构函数没有调用。OK，我们在return 0前面添加一个delete ptr; 析构函数执行了。

所以，这里有两个结论：

当一个对象在stack 上时，析构函数自动调用。

当一个对象在heap上时，需要调用delete 语句，析构函数才会被执行。

现在在析构函数中调用delete 语句来删除指针成员。

头文件不变，HasPtr.cpp 文件代码如下：

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

HasPtr::HasPtr(int i, int \*p)

val = i;

ptr = p;

int HasPtr::get\_ptr\_value()

return \*ptr;

void HasPtr::set\_ptr\_value(int \*p)

ptr = p;

int HasPtr::get\_val()

return val;

void HasPtr::set\_val(int v)

val = v;

HasPtr::~HasPtr()

cout << "destructor of HasPtr " << endl;

delete ptr;

ClassWithPointer 代码如下：

// ClassWithPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

int main()

int temp = 100;

HasPtr ptr(2,&temp);

cout << ptr.get\_ptr\_value() << endl;

cout << ptr.get\_val() << endl;

system("PAUSE");

return 0;

执行一下，正常打印结束后，抛出错误：

![882a822f213b03455fc3f842c0ff6420.png][]

这里说明delete 不能删除stack 上的指针值。

现在在ClassWithPointer传入一个动态指针来测试一下。

// ClassWithPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

int main()

int temp = 100;

HasPtr ptr(2,&temp);

cout << ptr.get\_ptr\_value() << endl;

cout << ptr.get\_val() << endl;

system("PAUSE");

return 0;

执行后析构函数正常运行。所以这里有两个结论：

delete 语句不能删除stack 上的指针值。

delete 语句只能删除heap上的指针值，也就是new 出来的对象。

默认拷贝构造函数和默认赋值操作：

这里我们调用默认的构造函数和默认的赋值操作，看看会出现什么，为了方便查看，我在析构函数中打印了当前对象的地址，以及在main方法中打印了对象地址，这样就可以看到哪个对象调用了析构函数：

HasPtr.cpp 代码如下：

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

HasPtr::HasPtr(int i, int \*p)

val = i;

ptr = p;

int HasPtr::get\_ptr\_value()

return \*ptr;

void HasPtr::set\_ptr\_value(int \*p)

ptr = p;

int HasPtr::get\_val()

return val;

void HasPtr::set\_val(int v)

val = v;

HasPtr::~HasPtr()

cout << "destructor of HasPtr " << this << endl;

delete ptr;

ClassWithPointer 代码如下：

// ClassWithPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include

\#include "HasPtr.h"

using namespace std;

int main()

int \*temp = new int(100);

HasPtr ptr(2,temp);

cout << "ptr-------------->" << &ptr << endl;

cout << ptr.get\_ptr\_value() << endl;

cout << ptr.get\_val() << endl;

HasPtr ptr2(ptr);

cout << "ptr2-------------->" << &ptr2 << endl;

cout << ptr2.get\_ptr\_value() << endl;

cout << ptr2.get\_val() << endl;

HasPtr ptr3 = ptr;

cout << "ptr3-------------->" << &ptr3 << endl;

cout << ptr3.get\_ptr\_value() << endl;

cout << ptr3.get\_val() << endl;

system("PAUSE");

return 0;

运行结果如下，最后还是报错了：

![295ec09f8d6aba9a5e8c60b295d952c0.png][]

其实程序运行到第二个析构函数时，报错了。报错原因是，ptr 其实已经是pending指针了，因为这个ptr 指针所指向的地址已经被delete了。

不过我们这里最起码可以知道默认的拷贝构造函数和赋值操作，也是会直接复制指针值的，不是指针所指向的值。是指针变量的值，也就是地址。

所以这里引申出来的问题是：如何管理对象中指针成员的内存？这个是一个核心问题。

上面的例子，就是默认的方式，但是管理失败了，因为析构函数到最后会删除pending 指针，导致异常发生。

智能指针：

引入一个类U\_Ptr，用来管理我们需要在业务对象中需要的指针变量，假设为int \*p。头文件如下：

\#pragma once

\#ifndef \_\_UPTR\_\_

\#define \_\_UPTR\_\_

\#include "HasPtr.h"

\#include

using namespace std;

class U\_Ptr

friend class HasPtr;

int \*ip;

size\_t use;

U\_Ptr(int \*p):ip(p),use(1) \{\}

~U\_Ptr()

cout << "destruction:"<< \*ip << endl;

delete ip;

\};

\#endif // !\_\_UPTR\_\_

现在我们的业务对象还是HasPtr。头文件如下：

\#pragma once

\#ifndef \_\_HASPTR\_\_

\#define \_\_HASPTR\_\_

\#include "U\_Ptr.h"

class HasPtr

public:

HasPtr(int \*p, int i):ptr(new U\_Ptr(p)),val(i)\{\}

HasPtr(const HasPtr &orgi) :ptr(orgi.ptr), val(orgi.val)

\++ptr->use;

cout << "coming into copy construction:" << ptr->use << endl;

HasPtr& operator=(const HasPtr &rhs);

~HasPtr();

int get\_ptr\_value() const;

int get\_int() const;

void set\_ptr(int \*p);

void set\_int(int i);

private:

U\_Ptr \*ptr;

int val;

\};

\#endif // !\_\_HASPTR\_\_

HasPtr.cpp 实现如下：

\#include "stdafx.h"

\#include "HasPtr.h"

\#include

using namespace std;

HasPtr& HasPtr::operator=(const HasPtr &rhs)

\++rhs.ptr->use;

if (--ptr->use == 0)

delete ptr;

ptr = rhs.ptr;

val = rhs.val;

return \*this;

HasPtr::~HasPtr()

cout << "destruction:" << ptr->use << endl;

if (--ptr->use == 0)

delete ptr;

int HasPtr::get\_ptr\_value() const

return \*ptr->ip;

int HasPtr::get\_int() const

return val;

void HasPtr::set\_ptr(int \*p)

ptr->ip = p;

void HasPtr::set\_int(int i)

val = i;

测试类如下：

// SmartPointer.cpp : 定义控制台应用程序的入口点。

\#include "stdafx.h"

\#include "HasPtr.h"

\#include

using namespace std;

int main()

int \*temp = new int(100);

HasPtr ptr(temp,22);

cout << "ptr------------>" << endl;

cout << ptr.get\_ptr\_value() << endl;

cout << ptr.get\_int() << endl;

HasPtr ptr2(ptr);

cout << "ptr2------------>" << endl;

cout << ptr2.get\_ptr\_value() << endl;

cout << ptr2.get\_int() << endl;

system("PAUSE");

return 0;

我们把U\_Ptr 叫做智能指针，用于帮我们管理需要的指针成员。我们的业务对象HasPtr对象包含一个智能指针，这个指针在HasPtr 对象创建时创建，智能指针的use 变量用来记录业务对象HasPtr对象被复制了多少次，也就是说，有多少个相同的指针指向了ptr所指向的地方。如果要记录HasPtr对象一共有多少个一样的，那么就需要在拷贝构造函数和赋值操作处进行对use变量加一操作，在析构函数处进行减一操作。当减到0时，删除指针。

[882a822f213b03455fc3f842c0ff6420.png]: /images/20221024/93d75f757db443ac92c953ff2a10ad37.png
[295ec09f8d6aba9a5e8c60b295d952c0.png]: /images/20221024/1d79faeab6aa4a778bacab0ffbe5bce8.png