C++之类成员间指针处理

最新推荐文章于 2023-03-13 11:46:13 发布
最新推荐文章于 2023-03-13 11:46:13 发布
阅读量8.8k 收藏
点赞数
分类专栏： C++ 文章标签： 类 指针 成员 delete 栈堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33567641/article/details/81198589
版权

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

在<<c++ primer>> 中写到，如果一个类需要我们自己写析构函数，那么这个类，也会需要我们自己写拷贝构造函数和拷贝赋值函数。

下面我们先定义一个类头文件带指针：

HasPtr.h

#ifndef CLASSPOINTER_HASPTR_H
#define CLASSPOINTER_HASPTR_H


class HasPtr {
public:
    HasPtr(int i, int *p);   //构造函数

    ~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 //CLASSPOINTER_HASPTR_H

HasPtr.cpp类的实现：

#include "HasPtr.h"
#include <iostream>

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

main.cpp

#include <iostream>
#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;
}

结果：

100
2
请按任意键继续. . .

按下任意键：

100
2
请按任意键继续. . .

Destructor of HasPtr!

Process finished with exit code 0

执行主函数，我们发现在按下任意键时，析构函数自动调用了。

在main方法中，stack（栈）上定义好了一个类的实例化对象，当退出main函数之后，自动调用类的析构函数。

如果我们将对象的声明改为动态的，也即是放在heap（堆）上，会有什么特点，因此main函数我们将改为：

main.cpp

#include <iostream>
#include "HasPtr.h"

using namespace std;

int main() {
    int temp = 100;
    HasPtr *ptr = new HasPtr(2, &temp);
    cout << ptr->get_ptr_value() << endl;
    cout << ptr->get_val() << endl;
    system("PAUSE");
    return 0;
}

结果：

100
2
请按任意键继续. . .

按下任意键：

100
2
请按任意键继续. . .


Process finished with exit code 0

细心的同学已经发现，这时候的析构函数并没有执行。要怎么做它才会执行呢？我们可以尝试删除指针，在return前增加delete (ptr)：

main.cpp

#include <iostream>
#include "HasPtr.h"

using namespace std;

int main() {
    int temp = 100;
    HasPtr *ptr = new HasPtr(2, &temp);
    cout << ptr->get_ptr_value() << endl;
    cout << ptr->get_val() << endl;
    system("PAUSE");
    delete(ptr);
    return 0;
}

结果：

100
2
请按任意键继续. . .

按下任意键：

100
2
请按任意键继续. . .

Destructor of HasPtr!

Process finished with exit code 0

这时我们发现析构函数执行了！

结论：

  1. 当一个对象在stack（栈）上时，析构函数自动调用。
  2. 方一个函数在heap（堆）上时，需要用delete语句，析构函数才会被执行。

下面我们演示在栈上删除指针会有什么发生（仅需修改部分代码即可）：

HasPtr.cpp

#include "HasPtr.h"
#include <iostream>

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); // 析构函数中删除指针
}

main.cpp

#include <iostream>
#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;
}

结果：

100
2
请按任意键继续. . .

Destructor of HasPtr!

Process finished with exit code 0

正常打印，那也没有问题啊。由于本人测试实在CLion里面执行的，编译器具有保护机制，故而没有出现错误。当尝试使用命令行执行后，正常打印，但是抛出了类似这样的错误。

由此看来delete不能删除stack上的指针。

下面我们使用动态参数来测试（仅需改变main.cpp）：

main.cpp

#include <iostream>
#include "HasPtr.h"

using namespace std;

int main() {
    int *temp = new int(100);
    HasPtr ptr(2, temp);
    cout << ptr.get_ptr_value() << endl;
    cout << ptr.get_val() << endl;
    system("PAUSE");
    return 0;
}

结果：

100
2
请按任意键继续. . .

Destructor of HasPtr!

Process finished with exit code 0

无论在哪里执行，都不会抛出错误，因为指针的删除是在堆上操作的。

结论：

  1. delete语句不能够直接删除stack上的指针值。
  2. delete语句只能删除heap上的指针值，也就是new的对象。

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

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

HasPtr.cpp

#include "HasPtr.h"
#include <iostream>

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

main.cpp

#include <iostream>
#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----------------->" << &ptr << endl;
    cout << ptr2.get_ptr_value() << endl;
    cout << ptr2.get_val() << endl;

    HasPtr ptr3 = ptr;
    cout << "ptr3----------------->" << &ptr << endl;
    cout << ptr3.get_ptr_value() << endl;
    cout << ptr3.get_val() << endl;

    system("PAUSE");
    return 0;
}

结果：

ptr------------------>0x28ff24
100
2
ptr2----------------->0x28ff24
100
2
ptr3----------------->0x28ff24
100
2
请按任意键继续. . .

Destructor of HasPtr!0x28ff14
Destructor of HasPtr!0x28ff1c
Destructor of HasPtr!0x28ff24

Process finished with exit code 0

拷贝默认构造函数和赋值操作，将会直接复制指针值，不是指针所指向的值。是指针的变量，也是指针的地址。

调用delete指针值时，删除的值在不同调用时候不同，也就是说明指针值指向的内存地址在调用的时候是重新分配的。

 

zxnode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++类静态成员与类静态成员函数详解
01-20
当将类的某个数据成员声明为static时，该静态数据成员只能被定义一次，而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本，但静态数据成员只有一个实例存在，与定义了多少类对象无关。静态...
构造，析构，拷贝构造
最新发布
月上柳梢头的博客
12-08 857
C++
C++ 类和对象 构造与析构 new delete this指针 const
海吹的技术博客
07-10 246
一、面向对象的特点 抽象、封装、继承、多态 二、类的封装 1.struct和class的区别 struct定义类时，成员默认属性为public class定义类时，成员默认属性为private 2.类的访问控制权限 public：可在类内和类外被访问 private：只能在类内被访问 protected：只能在类内和派生类内被访问 cl...
析构函数 管理指针成员
Talents come from diligence
02-23 594
析构函数就是这样的一个特殊函数，它可以完成所需的资源回收，作为类构造函数的补充撤销类对象 时会自动调用析构函数   动态分配的对象只有在指向该对象的指针被删除时才撤销   当对象的引用或指针超出作用域时，不会运行析构函数，只有删除指向动态分配对象的指针或实际对 象（而不是对象的引用）超出作用域时，才会运行析构函数   撤销一个容器（不管是标准库容器还是内置数组）时，也会运行容器中的类类型元素的析构...
c++ 析构函数 指针成员 虚析构函数 基类与派生类的赋值兼容（乱七八糟……）
carol_in_love的博客
05-02 351
这是一个，在写析构函数的时候想系统理一下知识点，然后乱入了多态访问控制（在另一篇笔记里懒得发了），最后又乱入了基类派生类对象互相搅和的故事…… 借鉴了两篇优秀博文 https://blog.csdn.net/github_35160620/article/details/52602332 https://blog.csdn.net/starlee/article/details/619827 构造...
C++之类成员指针
e5Max的专栏
09-14 1万+
一、指向成员变量的指针并非指针          C++中指向成员变量的指针其实是一个相对于类对象的偏移量。《C++必知必会》的条款15讲述了这一说法：“与常规指针不同，一个指向成员变量的指针并不指向一个内存位置。它指向的是一个类的特定成员，而不是指向一个特定对象里的特定成员。通常最清晰的做法是将指向数据成员的指针看作为一个偏移量。......。这个偏移量告诉你，一个特定成员的位置距离对象的起点
C++学习笔记----类成员指针
qq_44664843的博客
03-01 795
1.类成员变量指针 成员指针的用法 我们通常用的指针，一般指向类的对象，其实我们也可以定义类的数据成员的指针，数据成员的指针可以简单的看成是类成员的一个别名，说如果是非const的指针则可以修改其绑定的对象的值。 成员指针使用案例： class test { public: friend void MePointer(); test() = default; test(string name):Name(name){} private: string Name; }; v
C++中的指针类型与构造函数，析构函数
chumingqian的博客
04-10 4057
1. 指针类型的作用 1.1 指针取出字节 任何类型的指针占用的空间大小都是相同的 （32位CPU是4字节；64位CPU是8字节） 既然任何类型的指针占用的空间大小都是相同的，为什么指针还需要类型呢？ 指针只是指向了一个内存地址，但是当存内存中取值的时候，系统不知道你要从当前指针指向的地址，取几个字节，指定了指针的类型后，系统就知道取几个字节了。 char类型取1个字节，short类型取2个字节，int类型去4个字节。 int main() { int i = 123456
第二周：C++实现一个带指针成员变量的类【Boolean】
cjolj的专栏
02-14 779
1.Big Threeclass String // Big Three: 拷贝构造、拷贝赋值、析构 { String (const String &str); String &operator=(const String &str); ~String();};(1).构造函数inline String::String(const char*cstr = 0) { if
c++ 的 指针析构 问题
ken2232的博客
03-13 1286
c++的指针析构问题
c++ A类包含B类指针，B类包含A类指针的情况
weixin_34064653的博客
05-06 538
#include&lt;stdio.h&gt; class Bclass; class Aclass { public: friend Bclass; void func() { pB-&gt;funcB(); } int data; Bclass* pB; }; class Bcla...
c++笔记之句柄类
12-22
因为句柄类使用指针执行操作，虚成员的行为将在运行时根据句柄实际绑定的对象的类型而变化。因此，句柄的用户可以获得动态行为但无需操心指针的管理。 　包装了继承层次的句柄有两个重要的设计考虑因素 　1、像...
C++基础之this指针与另一种“多态”
09-05
this指针识别了同一个类的不同的对象，换句话说，this指针使得成员函数可以访问同一个类的不同对象。再深入一点，this指针使得成员函数会因为this指针的不同而访问到了不同的成员变量
C++学习笔记之pimpl用法详解
12-26
前言 　本文主要给大家介绍了关于C++中pimpl用法的相关...　在C++语言中，要定义某个类型的变量或者使用类型的某个成员，就必须知道这个类的完整定义，其例外情况是：如果定义这个类型的指针，或者该类型是函数的参数或
C++指针释放问题
热门推荐
u011473714的专栏
03-02 1万+
今天看到了一个问题，其实在项目中也经常遇到指针释放的问题，先看看一个简单的指针释放的问题： **************************************问题如下： （1）一般在c++类中有成员指针的话，会在类的析构函数里释放（delete）这个指针？ （2）基于（1），如果传给这个成员指针不是一个堆分配的指针，那类发生析构会发生错误，这个怎么解决？？ 如下： class A {
C++之析构函数
闲某欧
10-30 472
没啥
C++核心准则C.33:如果类包含拥有所有权的指针成员，定义析构函数
面向对象思考
02-15 651
C.33: If a class has an owning pointer member, define a destructor C.33:如果类包含拥有所有权的指针成员，定义析构函数 Reason（原因） An owned object must be deleted upon destruction of the object that owns it. 从属对象必须通...
c++ 虚析构的作用以及成员变量为指针和普通数据成员在析构时的不同
struggle6688的专栏
04-19 774
一、派生类指针指向父类时父类的虚构函数必须设置为虚函数 看下面的代码： class Data { public: Data(int data) { a = data; cout << "Data构造" << endl; } ~Data() { cout << "~Data析构" << endl; } private: in...
【C&C++】类成员指针
love131452098的博客
06-09 815
背景 最近在进行C++开发时，发现自己对于普通的变量指针、函数指针与类的成员指针的理解出现了偏差和混乱，所以在这边文章中引用了<C++ Primer>书籍中的片段结合示例进行C++类成员指针的讲解，包含以下两点， 类数据成员指针 类成员函数指针 成员指针 成员指针(point to member)是指可以指向类的非静态成员的指针。一般情况下，指针指向一个对象，但是成员指针指示的是类的成员而非类的对象。类的静态成员不属于任何对象，因此无需特殊的执行静态成员的指针，指向静态成员的指针与普通指针没
c++使用结构体或类 其成员变量为数组
06-13
定义结构体或类的过程与定义普通的结构体或类类似，只需要将数组作为成员变量之一即可。 例如，下面的代码定义了一个包含数组成员的结构体： ```c++ #include using namespace std; struct MyClass { int arr[5...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值