智能指针(内存泄漏问题)

🌻个人主页:路飞雪吖~

       🌠专栏:C/C++


目录

一、为什么需要智能指针?

二、内存泄露

三、智能指针的使用及原理

⭐RAII

⭐智能指针的原理

🌠小贴士:

⭐std::auto_ptr

​编辑 ✨auto_ptr模拟实现

⭐std::unique_ptr

✨unique_ptr 的模拟实现

⭐std::shared_ptr

✨std::shared_ptr的模拟实现

🌠小贴士:

✨std::shared_ptr的循环引用问题

 ✨std::weak_ptr的模拟实现

四、C++11和boost中智能指针的关系


一、为什么需要智能指针?

下面我们先分析一下下面这段程序有没有什么内存方面的问题?

int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}void Func()
{// 1、如果p1这里new 抛异常会如何?// 2、如果p2这里new 抛异常会如何?// 3、如果div调用这里又会抛异常会如何?int* p1 = new int;int* p2 = new int;cout << div() << endl;delete p1;delete p2;
}int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

1、如果p1这里new 抛异常会如何?不用管,因为还没有东西申请出来。
2、如果p2这里new 抛异常会如何?要先释放p1。

3、如果div调用这里又会抛异常会如何? 要释放p1和p2。

二、内存泄露

内存泄露的危害

• 什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对 该段内存的控制,因而造成了内存的浪费。

• 内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现 内存泄漏会导致响应越来越慢,最终卡死。

void MemoryLeaks()
{// 1.内存申请了忘记释放int* p1 = (int*)malloc(sizeof(int));int* p2 = new int;// 2.异常安全问题int* p3 = new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.delete[] p3;
}

内存泄露的分类

C/C++程序中一般我们关心两种方面的内存泄漏:

• 堆内存泄漏(Heap leak)

      堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。

• 系统资源泄漏

     指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放 掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。

三、智能指针的使用及原理

RAII

RAII(Resource Acquisition Is Initialization)是一种 利用生命周期来控制程序资源(如内存、文件句柄、网络连接等等)的简单技术。

 在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种方法有两大好处:

• 不需要显式的释放资源;

• 采用这种方式,对象所需的资源在其生命期内始终保持有效。

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr)// 在对象构造时获取资源: _ptr(ptr){}~SmartPtr() // 最后在对象析构的时候释放资源{if(_ptr)delete _ptr;}private:T* _ptr;
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}void Func()
{ShardPtr<int> sp1(new int);ShardPtr<int> sp2(new int);cout << div() << endl;
}// 好处:
// 不需要显式地释放资源
// 采用这种方式,对象所需的资源在其生命期内始终保持有效int main()
{try{Func();}catch(const exception& e){cout<<e.what()<<endl;}return 0;
}

智能指针的原理

上述的SmartPtr还不能将其称为智能指针,因为它还不具有指针的行为。指针可以解引用 * ,也可以通过 ->  去访问所指空间中的内容,因此:SmartPtr模板类中还得需要将 * 、 -> 重载,才可让其像指针一样去使用。

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if(_ptr)delete _ptr;}T& operator*() {return *_ptr;}T* operator->() {return _ptr;}private:T* _ptr;
};
struct Date
{int _year;int _month;int _day;
};int main()
{SmartPtr<int> sp1(new int);*sp1 = 10cout<<*sp1<<endl;SmartPtr<int> sparray(new Date);// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性,省略了一个->sparray->_year = 2018;sparray->_month = 1;sparray->_day = 1;
}
🌠小贴士:

总结一下智能指针的原理:

1. RAII特性;

2. 重载operator*和opertaor->,具有像指针一样的行为。 

std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针;

auto_ptr 的实现原理:管理权转移的思想。

有些地方明确要求 禁止使用!

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }
private:T* _ptr;
};struct Date
{int _year;int _month;int _day;Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}~Date(){cout << "~Date()" << endl;}
};int main()
{//SmartPtr<Date> sp1(new Date);//SmartPtr<Date> sp2(sp1);//浅拷贝/值拷贝(sp1、sp2指向同一块空间,析构两次,导致程序错误)auto_ptr<Date> ap1(new Date);// 拷贝时,管理权限转移,被拷贝(ap1)悬空auto_ptr<Date> ap2(ap1);ap1->_year++;return 0;
}

 ✨auto_ptr模拟实现

// auto_ptr
namespace xlf
{template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}// sp1(sp2)auto_ptr(auto_ptr<T>& sp):_ptr(sp._ptr){//管理权转移sp._ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T>& ap){//检测是否为自己给自己赋值if (this != &ap){// 释放当前对象中资源if (_ptr)delete _ptr;// 转移ap中资源到当前对象中_ptr = ap._ptr;ap._ptr = NULL;}return *this;}~auto_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}// 结论:auto_ptr是一个失败设计,很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr;

unique_ptr的实现原理:简单粗暴的防拷贝。

🔥扩展:

Boost库:为C++语言标准库提供扩展C++程序库的总称。

 Boost库是为C++语言标准库提供扩展的一些C++程序库的总称,由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作,并且为其提供扩展功能。

Boost功能引入C++11

scoped_ptr /

scoped_array

禁止拷贝unique_ptr

shared_ptr /

shared_array

引用计数的方式支持shared_ptr
weak_ptr

不同于上面的智能指针,

不支持直接管理资源,

配合解决 shared_ptr 的一个缺陷,

循环引用会导致内存泄露。 

weak_ptr

template<class T>
class DeleteArray
{
public:void operator()(T* ptr){delete[] ptr;}
};class Fclose
{
public:void operator()(FILE* ptr1){cout << "fclose:" << ptr1 << endl;Fclose(ptr);}
};int main()
{// C++11unique_ptr<Date> up1(new Date);// 不支持拷贝(拷贝会被悬空)//auto_ptr<Date> up2(up1);//定制删除器//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);// delete[] 不匹配,要单独写unique_ptr<Date[]> up2(new Date[5]);//调用特化版本unique_ptr<FILE, Fclose> up3(fopen("test.cpp","r"));
}

unique_ptr 的模拟实现

// C++11库才更新智能指针实现
// C++11出来之前,boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr// unique_ptr/scoped_ptr
// 原理:简单粗暴 -- 防拷贝namespace xlf
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}// 禁止拷贝unique_ptr(const unique_ptr<T>& sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;private:T* _ptr;};
}int main()
{xlf::unique_ptr<int> sp1(new int);//xlf::unique_ptr<int> sp2(sp1);不能进行拷贝std::unique_ptr<int> sp1(new int);//std::unique_ptr<int> sp2(sp1);不能进行拷贝return 0;
}

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

shared_ptr 的原理:是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源。

 

int main()
{//vector<shared_ptr<Date>> v;  涉及左值右值要拷贝的场景shared_ptr<Date> sp1(new Date);shared_ptr<Date> sp2(sp1);// 多个对象共享资源shared_ptr<Date> sp3(sp2);cout << sp1.use_count() << endl;shared_ptr<Date[]> sp4(new Date[5]);//shared_ptr<FILE, Fclose> up4(fopen("test.cpp", "r"));//不支持在类模板参数传,要在构造函数的参数去传shared_ptr<FILE> up4(fopen("test.cpp", "r"), Fclose());//要在构造函数的参数去传shared_ptr<Date> sp6 = make_shared<Date>(2024, 8, 5);return 0;
}

std::shared_ptr的模拟实现

☄️我们如何设计引用计数

引用计数是共同管理一块资源,共同的一个技术,而不是各自有一个各自的技术。

 

 ☄️ 定制删除器如何设计?

采用function包装器:

#include<functional>
namespace xlf
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)){}// D函数模板是给 del这个成员函数用的,不是给整个类用的// 只有把D写成类模板才能用,但是库里面没有写成类模板,只有unique_ptr写成类模板template<class D>//定制删除器:即可调用对象shared_ptr(T* ptr, D del)//  困境:删除器要传到release,:_ptr(ptr)                   // release要给删除和operator=用,,_pcount(new int(1))        // 所以release要改变,_del(del)               //成员函数里面,一个类的要给另外一个类的用的话,要通过成员变量{}//sp2(sp1)shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);}void Release(){if (--(*_pcount) == 0){//delete _ptr;_del(_ptr);delete _pcount;_ptr = nullptr;_pcount = nullptr;}}//sp1=sp3             const会引用左值也会引用右值shared_ptr& operator=(const shared_ptr<T>& sp)// 如果是一个右值可以转移资源{造成内存泄露//_ptr = sp._ptr;//_pcount = sp._pcount;//++(*_pcount);//return *this;if (_ptr != sp._ptr)//防止自己给自己赋值{Release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}~shared_ptr(){Release();}T* get() const{return _ptr;}int use_count() const {return *_pcount;}T& operator*() { return *_ptr; }T* operator->() { return _ptr; }private:T* _ptr;int* _pcount;//增加引用计数//D _del;可调用对象function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };//删除器};
}
struct Date
{int _year;int _month;int _day;Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}~Date(){cout << "~Date()" << endl;}
};class Fclose
{
public:void operator()(FILE* ptr1){cout << "fclose:" << ptr1 << endl;Fclose(ptr);}
};#include"shared_ptr.h"int main()
{xlf::shared_ptr<Date> sp1(new Date);// 没传删除器,此时调用function(包装器)的默认构造,// 但是function里面没有可调用对象,会报错,// 因此function要给缺省值_ptr,回调自己xlf::shared_ptr<Date> sp2(sp1);xlf::shared_ptr<Date> sp3(new Date);//自己给自己赋值sp3 = sp3;//出现问题,此时,sp3只有一个对象管理sp1 = sp2;sp1 = sp3;xlf::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());xlf::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr){cout << "free:" << ptr << endl;free(ptr);});return 0;
}

🌠小贴士:

严格来说,不是深拷贝的类都不需要移动构造,浅拷贝的类,移动构造和移动赋值都没有特别大的意义,所以不需要实现,编译器一般也不会默认生成。 

std::shared_ptr的循环引用问题

struct ListNode
{int _data;//ListNode* _next;//ListNode* _prev;std::shared_ptr<ListNode> _next;std::shared_ptr<ListNode> _prev;~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{//循环引用的场景---(互相指向)导致内存泄露//std::shared_ptr<ListNode> n1 = new ListNode;//不支持这样子给,因为它的构造加了explicit,所以不支持转换std::shared_ptr<ListNode> n1(new ListNode);std::shared_ptr<ListNode> n2(new ListNode);cout << n1.use_count() << endl;cout << n2.use_count() << endl;//n1->_next = n2;// 不能, n1->_next是原生指针   n2是智能指针对象,// 智能指针不能给原生指针,所以要把原生指针的类型改为智能指针//互相指向造成内存泄露(没有析构)n1->_next = n2;// errorn2->_prev = n1;// errorcout << n1.use_count() << endl;cout << n2.use_count() << endl;//std::weak_ptr<ListNode> wp(new ListNode);return 0;
}

解决方案:在引用计数的场景下,把节点中的_prev和_next改成weak_ptr就可以了;

原理就是:node1->_next = node2 和 node2->_prev = node1时 weak_ptr的_next和 _prev不会增加node1和node2的引用计数。 

struct ListNode
{int _data;// weak_ptr的特点,当你用shared_ptr赋值或者拷贝构造时,不增加引用计数// 意味着我指向了它,但是我不增加计数std::weak_ptr<ListNode> _next;std::weak_ptr<ListNode> _prev;~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{//循环引用的场景---(互相指向)导致内存泄露std::shared_ptr<ListNode> n1(new ListNode);std::shared_ptr<ListNode> n2(new ListNode);n1->_next = n2;n2->_prev = n1;return 0;
}

 ✨std::weak_ptr的模拟实现

 weak_ptr的特点:当你用shared_ptr赋值或者拷贝构造时,不增加引用计数,意味着我指向了它,但是我不增加计数。

template<class T>
class weak_ptr
{
public:weak_ptr(){}weak_ptr(const shared_ptr<T>& sp)//拷贝构造:_ptr(sp.get())// 不增加 shared_ptr的引用计数,严格来说,weak_ptr是要拿到计数的,才能判断过期{}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}private:T* _ptr = nullptr;T* _pcount;
};

四、C++11和boost中智能指针的关系

1. C++ 98 中产生了第一个智能指针auto_ptr.

2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.

3. C++ TR1,引入了shared_ptr等。不过注意的是TR1并不是标准版。

4. C++ 11,引入了unique_ptr和shared_ptr和weak_ptr。

需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

如若对你有帮助,记得点赞、收藏、关注哦!

若有误,望各位,在评论区留言或者私信我 指点迷津!!!谢谢^ ^ ~

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/462083.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

CSS例子: 横向排列的格子

效果 HTML <view class"content"><view class"item" v-for"item of 5">{{item}}</view></view> CSS .content {height: 100vh;display: flex;flex-direction: row; flex-wrap: wrap;align-content: flex-start;backgro…

面试题分享1

2024.11.1 1、过滤器和拦截器的区别 过滤器是基于spring的 拦截器是基于Java Web的 2、session 和 cookie 的区别、关系 cookie session 存储位置 保存在浏览器 &#xff08;客户端&#xff09; 保存在服务器 存储数据大小 限制大小&#xff0c;存储数据约为4KB 不限…

Python酷库之旅-第三方库Pandas(186)

目录 一、用法精讲 861、pandas.Index.names属性 861-1、语法 861-2、参数 861-3、功能 861-4、返回值 861-5、说明 861-6、用法 861-6-1、数据准备 861-6-2、代码示例 861-6-3、结果输出 862、pandas.Index.nbytes属性 862-1、语法 862-2、参数 862-3、功能 8…

Ansible 部署应用

Ansible Ansible 是基于 Python 开发&#xff0c;集合了众多优秀运维工具的优点&#xff0c;实现了批量运行命令、部署程序、配置系统等功能的自动化运维管理工具。默认通过 SSH 协议进行远程命令执行或下发配置&#xff0c;无需部署任何客户端代理软件&#xff0c;从而使得自动…

Python的全局锁GIL解析

Python的全局锁&#xff08;GIL&#xff09;是 CPython 解释器实现中的一个机制&#xff0c;用来确保任何时候只有一个线程执行 Python 字节码。这一机制存在于 CPython 中&#xff0c;主要是为了确保线程操作中的数据一致性&#xff0c;但也因此限制了多线程的并行执行效率。尤…

基于vue框架的的考研信息共享平台v0eyp(程序+源码+数据库+调试部署+开发环境)系统界面在最后面。

系统程序文件列表 项目功能&#xff1a;国家政策,用户,院校政策,院校信息,考研资料,资料分类,考研论坛 开题报告内容 基于Vue框架的考研信息共享平台开题报告 一、研究背景与意义 随着考研人数的逐年增长&#xff0c;考研学生对高效、便捷、个性化的信息获取需求愈发强烈。…

抽丝剥茧 分布式服务框架设计 理论设计篇

1、概述 前面几篇文章给大家详细的介绍了Zookeeper的基础概念以及应用的领域&#xff0c;今天我们讨论的话题是如何自研一套分布式服务框架。早些年有很多基于Dubbo和Zookeeper的分布式系统&#xff0c;这篇文章我们就来聊下如何设计一个分布式服务框架。 2、系统间交互 2.1、…

C++STL——list

C教学总目录 list 1、list简介2、构造函数3、迭代器4、访问和容量函数5、修改类函数6、操作类函数 1、list简介 list是带头双向循环链表&#xff0c;也是模板类&#xff0c;使用时要指明类型&#xff0c;包含于头文件<list> 由于list是双向循环链表&#xff0c;在任意位置…

YoloV8改进策略:Block改进|RFE模块,提高小物体的识别精度|即插即用|代码+修改过程

摘要 论文介绍 本文介绍了一种基于YOLOv5的人脸检测方法,命名为YOLO-FaceV2。该方法旨在解决人脸检测中的尺度变化、简单与困难样本不平衡以及人脸遮挡等问题。通过引入一系列创新模块和损失函数,YOLO-FaceV2在WiderFace数据集上取得了优异的表现,特别是在小物体、遮挡和困…

leaflet矢量瓦片vetorgrid显示聚合和图标裁剪显示不全的问题

1、问题现象 使用leaflet显示矢量瓦片会出现图片挤压的问题和图片裁剪显示不全的问题 2、解决办法和思路 1&#xff09;数据抽稀 方法一&#xff1a;在createTile方法通过控制feature在单张瓦片里面显示的数量&#xff0c;在小层级的时候进行筛选过滤&#xff0c;对点数据类…

Gitee push 文件

1、背景 想将自己的plecs仿真放到git中管理&#xff0c;以防丢失&#xff0c;以防乱改之后丢失之前版本仿真。此操作说明默认用户已下载git。 2、操作步骤 2.1 开启Git Bash 在文件夹中右键&#xff0c;开启Git Bash。 2.2 克隆文件 在Git Bash中打git clone git地址&#…

gitee 使用 webhoot 触发 Jenkins 自动构建

一、插件下载和配置 Manage Jenkins>Plugin Manager 搜索 gitee 进行安装 插件配置 1、前往Jenkins -> Manage Jenkins -> System -> Gitee Configuration -> Gitee connections 2、在 Connection name 中输入 Gitee 或者你想要的名字 3、Gitee host URL 中…

【JavaEE初阶 — 多线程】Thread类的属性

目录 Thread类的属性 1.Thread 的常见构造方法 2.Thread 的几个常见属性 2.1 前台线程与后台线程 2.2 setDaemon() 2.3 isAlive() Thread类的属性 Thread 类是JVM 用来管理线程的一个类&#xff0c;换句话说&#xff0c;每个线程都有一个唯一的Thread 对象与之关联&…

yocto是如何收集recipes,如何加入现有的bb文件

yocto通常是如何收集recipes: 在Yocto中&#xff0c;通过以下方式收集recipes&#xff1a; 层&#xff08;Layers&#xff09; Yocto项目使用层来组织recipes。层是包含配置文件、recipes和其他相关文件的目录结构。每个层有自己的目录&#xff0c;其中 recipes-* 目录用于存…

原生鸿蒙的竞争力到底如何?

目录 1. 崛起与挑战2. 安全机制3. 自动化检测前移4. 深入探讨开发者服务优势 1. 崛起与挑战 长期以来&#xff0c;移动操作系统市场被IOS和安卓所垄断&#xff0c;一直都难以推出完整的自主系统&#xff0c;面临诸多挑战&#xff0c;如推广困难、应用适配难度大&#xff0c;以及…

sublime Text中设置编码为GBK

要在sublime Text中设置编码为GBK&#xff0c;请按照以下步骤操作 1.打开Sublime Text编辑器, 2.点击菜单栏中的“Preferences”(首选项)选项&#xff0c;找打Package Control选项。 3.点击Package Control&#xff0c;随后搜索Install Package并点击&#xff0c;如下图 4.再…

KPRCB结构之ReadySummary和DispatcherReadyListHead

ReadySummary: Uint4B DispatcherReadyListHead : [32] _LIST_ENTRY 请参考 _KTHREAD *__fastcall KiSelectReadyThread(ULONG LowPriority, _KPRCB *Prcb)

Python爬虫:揭开淘宝商品描述的神秘面纱

在这个信息爆炸的时代&#xff0c;我们每天都在和时间赛跑。作为一名Python开发者&#xff0c;你是否曾梦想拥有超能力&#xff0c;能够瞬间揭开淘宝商品描述的神秘面纱&#xff1f;今天&#xff0c;就让我们一起化身为代码界的“福尔摩斯”&#xff0c;使用Python爬虫技术&…

HTML 多媒体标签详解:<img>、<object> 与 <embed>

文章目录 1. `<img>` 标签主要属性示例注意事项2. `<object>` 标签概述主要属性示例注意事项3. `<embed>` 标签概述主要属性示例注意事项小结在现代网页设计中,多媒体内容的使用变得越来越重要,因为它能够有效增强用户体验、吸引注意力并传达信息。HTML 提…

台式电脑如何改ip地址:全面解析与实操指南

有时候&#xff0c;由于IP地址冲突、网络安全、隐私保护或特定应用需求&#xff0c;我们可能需要更改台式电脑的IP地址。然而&#xff0c;对于不熟悉网络设置的用户来说&#xff0c;这一过程可能显得复杂而陌生。本文将通过全面解析与实操指南&#xff0c;帮助大家轻松掌握台式…