C++|智能指针

目录

引入

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

1.1RAII

1.2智能指针原理

1.3智能指针发展

1.3.1std::auto_ptr

1.3.2std::unique_ptr

1.3.3std::shared_ptr 

二、循环引用问题及解决方法

2.1循环引用

2.2解决方法 

三、删除器

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

引入

回顾上一篇章，学习了异常机制，但面临了一种情况还没有解决，就是异常带来的内存泄漏，如下：

#include <iostream>
using namespace std;


double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";//抛出的异常是字符串
	else
		return ((double)a / (double)b);
}
void Func() 
{
    int* p = new int[1];
    int len, time;
    cin >> len >> time;

    cout << Division(len, time) << endl;

    delete[] p;

}

int main() {
    try 
    {
        Func();
    }
    catch (const char* errmsg) 
    {
        cout << "Caught in main: " << errmsg << endl;
    }
    return 0;
}

调用Division函数时，若抛出异常，最终是被main函数中的catch所捕获，直接进入到main函数中的catch中了，但是，delete[] p不会被执行了 ，导致的问题就是内存泄漏。那么可以通过智能指针来解决这个问题

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

1.1RAII

RAII是一种利用对象生命周期来控制程序资源的简单技术。在对象构造时获取对象资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候由编译器顺带释放资源。实际上把控资源就是管理对象。

这种做法体现的优势是：

  • 不需要显示地释放资源
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效

RAII是一种设计思想，而智能指针正是采用了这种思想。

RAII思想设计： 

#include <iostream>
using namespace std;

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

private:
	T* _ptr;
};
double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";//抛出的异常是字符串
	else
		return ((double)a / (double)b);
}
void Func()
{
	int* p = new int[1];
	int len, time;
	cin >> len >> time;

	cout << Division(len, time) << endl;

	SmartPtr<int> sp(p);//当Division抛异常时，会被main函数中的catch捕获，那么程序会直接跳到main函数所在的catch
	//对此了，Func函数的栈帧会自动销毁，对于内置类型会自动释放，对于自定义类型而言会去调用它的析构函数
	//所以sp会去调用析构函数，同时释放了p的资源

}

int main() {
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << "Caught in main: " << errmsg << endl;
	}
	return 0;
}

输出结果：

1.2智能指针原理

上述的SmartPtr虽然是通过RAII思想设计的类，但还不能真正称作为智能指针，因为它还不有指针的行为。指针可以解引用，也可以通过->去访问所指空间的内容，因此还需要重载*和->。

#include <iostream>
using namespace std;
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 = 10;
	cout << *sp1 << endl;

	SmartPtr<Date> sparray(new Date);

	sparray->_year = 2024;
	sparray->_month = 7;
	sparray->_day = 7;

	cout << (*sparray)._year << ":" << (*sparray)._month << ":" << (*sparray)._day << endl;

	return 0;
}

输出结果：

总结一下，智能指针是通过RAII思想设计出的类，它重载operator*和operator->,具有像指针一样的行为。 

1.3智能指针发展

对于上述代码，却有一个弊端，如下：

int main()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1);

	return 0;
}

 带来的问题是，sp1拷贝给sp2是一个浅拷贝，所以sp2._ptr和sp1._ptr指向同一块空间，在析构时候，sp2._ptr所指向空间先释放，随后释放sp1._ptr所指向空间，但是该空间已被释放，所以会报错。那么为了解决这个问题，在历史上，智能指针有了一定的发展，来看。

1.3.1std::auto_ptr

C++98版本库中提供了auto_ptr的智能指针。他上述问题的实现原理是：通过管理权转移思想。

// C++98 管理权转移 auto_ptr
#include <iostream>
using namespace std;
namespace bit
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		//ap2(ap1)
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;//相当于ap1._ptr不再管理资源了，被置空了
		}


		//ap2= ap1
		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;
	};
}

int main()
{
	 std::auto_ptr<int> sp1(new int);
	 std::auto_ptr<int> sp2(sp1); // 管理权转移，sp1不再管理资源了，在析构的时候，确实没啥问题
	 //但带来了另一个问题，sp1所管理资源，被置空了，即sp1._ptr1 ==  nullptr，但对于外人来说并不知道
	 //若有人使用已被释放的资源，如下：
	 *sp2 = 10;
	 cout << *sp2 << endl;
	 cout << *sp1 << endl;//对空指针解引用，报错
	 return 0;
}

auto_ptr指针虽然解决了析构带来的问题，但是带来了新的问题，采用管理权转移思想，将资源由最后一个拷贝对象管理，而被拷贝对象都被置空了，导致有人使用被置空的拷贝对象时，会出现对空指针解引用，报错。所以该智能指针也可以算是一个"失败的man",很多公司也明确要求不能使用它。

1.3.2std::unique_ptr

随着C++的发展，C++11提供了更靠谱的智能指针unique_ptr,其实现原理：简单粗暴的防拷贝。

#include <iostream>
using namespace std;
namespace bit
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}


		//只声明不实现,但是不能防止有人在类外实现，所以此方法不行
		//unique_ptr(unique_ptr<T>& sp);


		//c++11仿拷贝
		/*unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;*/
	private:
		T* _ptr;

		//将拷贝私有化可以防拷贝，但这是c++98用法
		//unique_ptr(unique_ptr<T>& sp);

	};
}

//类外实现拷贝
//template<class T>
//bit::unique_ptr<T>::unique_ptr(bit:: unique_ptr<T>& sp)
//{
//	//...
//}

int main()
{
	 bit::unique_ptr<int> sp1(new int);
	 //bit::unique_ptr<int> sp2(sp1);//拷贝构造被删除了，编译器也不会默认生成了

     return 0;
}

 由于前面出现的问题都是因为拷贝带来的，那么unique_ptr了就直接把拷贝给禁了，不让你因为各种操作而导致额外的问题，这确实解决了。但是不能使用拷贝了，这也不是办法呀

1.3.3std::shared_ptr 

随着前面智能指针问题的暴露，C++11不断发展，最终也完善了该问题，提出了更靠谱且支持拷贝的shared_ptr。其原理：是通过引用计数方式来实现多个shared_ptr对象之间共享资源。

其满足以下规则：

1.每个shared_ptr对象，其都包含着一个指针，该指针所指向空间内容用来计数有多少个指针指向该空间，即有多少个对象管理同一份资源，当多个对象管理同一份资源，那么他们的指针就会指向同一份空间，空间内容记录着这些数量，每增加一个对象管理相同资源，则计数也会加1

2.当对象销毁时即调用析构函数，就说明该对象不再管理这份资源，其对应的指针不再指向计数的空间，引用计数就会减1

3.如果引用计数是0，就说明没有对象管理该资源了，则必须释放该资源，相反地，如果不是0，说明还有对象管理资源，则就不能释放该资源，否则，对于其他对象中的指针就成野指针了。

#include <iostream>
using namespace std;

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{
				
				_ptr = sp._ptr;

				_pcount = sp._pcount;
				(*_pcount)++;
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				if (--(*sp._pcount) == 0)
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				(*_pcount)++;
			}
			return *this;
		}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

        T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pcount;

	};
}

调试结果： 

shared_ptr解决了拷贝带来的问题，不幸的是，又出来了新的问题，那就是在线程安全和循环引用问题，对于线程问题，先放放，那我们要讲的是循环引用问题。

二、循环引用问题及解决方法

2.1循环引用

根据上述shared_ptr的代码，在外头定义一个类，进行以下操作：

struct ListNode
{
	bit::shared_ptr<ListNode> _next;
	bit::shared_ptr<ListNode> _prev;
	
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	bit::shared_ptr<ListNode> node1(new ListNode);
	bit::shared_ptr<ListNode> node2(new ListNode);
	
	node1->_next = node2;
	node2->_prev = node1;


	return 0;
}

输出结果：

没有任何结果，而当屏蔽node1->_next = node2;或者node2->_prev = node1;中的任何一句，

其输出结果：

这是为何？如图：

两边的节点各自受到_next,_prev牵连，造成了一个循环，且引用计数一直维持在1，并没有减到0，只要屏蔽其中一条语句就不会受到限制，正常析构。虽然这个智能指针是模拟的，就算是库里面的也有一样的问题。

2.2解决方法 

那么为了解决该问题，专门引入了一个智能指针来处理--weak_ptr

#include <iostream>
using namespace std;

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				_ptr = sp._ptr;

				_pcount = sp._pcount;
				++(*_pcount);
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				if (--(*_pcount) == 0)
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;

	};

	// 简化版本的weak_ptr实现
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}
		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

}


struct ListNode
{
	bit::weak_ptr<ListNode> _next;
	bit::weak_ptr<ListNode> _prev;
	
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};


int main()
{
	bit::shared_ptr<ListNode> node1(new ListNode);
	bit::shared_ptr<ListNode> node2(new ListNode);
	
	

	node1->_next = node2;
	node2->_prev = node1;


	return 0;
}

 输出结果：

那么weak_ptr是怎样解决问题的了，其实很简单，weak_ptr不在对引用计数进行管理了，所以shared_ptr对象初始化时的引用计数都是为1，在进行析构的时候，引用计数都会减到0，然后释放对应的_ptr,_pcount。

三、删除器

对于智能指针的析构还有一个问题，就是对于不是通过new出来的对象或者说new出来的对象是带有[]的如何通过智能指针进行管理，总不能每一种情况来一份代码。那么shared_ptr设计了一个删除器来解决这个问题。

// 仿函数的删除器

#include <iostream>
using namespace std;

template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);


	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2(new int[4], deleteArrayFunc);

	
	shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
	{fclose(p); });

	return 0;
}

输出结果：

如上代码，删除器可以通过自己定义的方式来释放空间，这只是展示了仿函数删除器，仅仅是九牛一毛。

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

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

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

不好的设计，对象悬空(不建议使用)
2.C++ boost给出了更实用的scoped ptr和shared ptr和weak ptr.

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中的实现的。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

休息时间c++

休息时间c++

题目描述 小杨计划在某个时刻开始学习&#xff0c;并决定在学习k秒后开始休息。 小杨想知道自己开始休息的时刻是多少。 输入 前三行每行包含一个整数&#xff0c;分别表示小杨开始学习时刻的时h、分m、秒s(h&#xff0c;m&#xff0c;s的值符合1≤h≤12,0≤m≤59,0≤s≤59)…
阅读更多...
外贸展示型网站设计

外贸展示型网站设计

清洁能源风能设备wordpress外贸公司模板 风能设备wordpress外贸公司模板&#xff0c;做新能源网通设备的公司网站模板。 https://www.jianzhanpress.com/?p3606 钢材wordpress外贸公司模板 金属钢材wordpress外贸公司模板&#xff0c;做金属成品贸易公司的企业网站模板。 …
阅读更多...
智慧营区人员考勤管理系统|DW-S406系统实现无感考勤

智慧营区人员考勤管理系统|DW-S406系统实现无感考勤

智慧营区人员管理系统&#xff08;DW-S406系统&#xff09;通过建设人员基本信息管理功能&#xff0c;实现人力资源可视化、规范化管理&#xff0c;使人力资源管理工作决策的高效化、制度化得到有力保障&#xff0c;真正达到集中管理、集权管理的目标。主要实现营区人员管理、访…
阅读更多...
Apache Dubbo与Nacos整合过程

Apache Dubbo与Nacos整合过程

Dubbo服务发现 Dubbo 提供的是一种 Client-Based 的服务发现机制&#xff0c;依赖第三方注册中心组件来协调服务发现过程&#xff0c;支持常用的注册中心如 Nacos、Consul、Zookeeper 等。 以下是 Dubbo 服务发现机制的基本工作原理图&#xff1a; 服务发现包含提供者、消费者…
阅读更多...
C++:重定义

C++:重定义

派生类和基类的同名成员问题 派生类中再实现一个基类中的方法会怎样 (1)代码实验&#xff1a;派生类和基类中各自实现一个内容不同但函数原型完全相同的方法&#xff0c;会怎么样 (2)结论&#xff1a;基类对象调用的是基类的方法&#xff0c;派生类对象调用执行的是派生类中重…
阅读更多...
AWS认证考试流程：从准备到通过

AWS认证考试流程：从准备到通过

AWS认证是IT行业中备受推崇的专业资格认证之一&#xff0c;它不仅可以验证您的AWS技能&#xff0c;还能提升您的职业竞争力。本文将为您详细介绍AWS认证考试的完整流程&#xff0c;从初步准备到最终通过认证。 选择适合的认证级别 AWS提供多个级别的认证&#xff0c;包括&…
阅读更多...
OWASP ZAP

OWASP ZAP

OWASP ZAP简介 开放式Web应用程序安全项目&#xff08;OWASP&#xff0c;Open Web Application Security Project&#xff09;是一个组织&#xff0c;它提供有关计算机和互联网应用程序的公正、实际、有成本效益的信息。ZAP则是OWASP里的工具类项目&#xff0c;也是旗舰项目&a…
阅读更多...
DP(2) | Java | LeetCode 62, 63, 343, 96 做题总结（96 未完）

DP(2) | Java | LeetCode 62, 63, 343, 96 做题总结（96 未完）

62.不同路径 我的代码&#xff08;报错&#xff09; 写的过程中感到很迷惑的点&#xff1a;①二维数组和这道题目的对应弄不清除&#xff0c;m n的初始化 是 dp[m][n] 还是 dp[n][m] ② class Solution {public int uniquePaths(int m, int n) {int[][]dp new int[m1][n1];d…
阅读更多...
JavaScript(9)——作用域的一些问题

JavaScript(9)——作用域的一些问题

如果在函数内部&#xff0c;变量没有声明直接赋值&#xff0c;也会当做全局变量看。强烈不推荐&#xff01;&#xff01; function op() {num 80}op()console.log(num) 在不同作用域下&#xff0c;可能存在变量命名冲突的情况&#xff1a; let num 10 function fn(){let num…
阅读更多...
【PTA天梯赛】L1-003 个位数统计（15分）

【PTA天梯赛】L1-003 个位数统计（15分）

作者&#xff1a;指针不指南吗 专栏&#xff1a;算法刷题 &#x1f43e;或许会很慢&#xff0c;但是不可以停下来&#x1f43e; 文章目录 题目题解总结 题目 题目链接 题解 使用string把长度达1000位的数字存起来开一个代表个位数的数组 a[11]倒序计算最后一位&#xff0c;…
阅读更多...
SQL基础-DQL 小结

SQL基础-DQL 小结

SQL基础-DQL 小结 学习目标&#xff1a;学习内容&#xff1a;SELECTFROMWHEREGROUP BYHAVINGORDER BY运算符ASC 和 DESC 总结 学习目标&#xff1a; 1.理解DQL&#xff08;Data Query Language&#xff09;的基本概念和作用。 2.掌握SQL查询的基本语法结构&#xff0c;包括SEL…
阅读更多...
PHP 安装Memcached 扩展 PHP使用Memcache

PHP 安装Memcached 扩展 PHP使用Memcache

memcache扩展下载 访问官网&#xff1a;https://pecl.php.net/package/memcache&#xff0c;下载合适的memcache版本的安装包&#xff0c;注意要与php版本相匹配。 1、查看运行环境php版本,可以运行以下代码 <?php phpinfo(); ?>2、查看版本信息以及是否支持多线程…
阅读更多...
Google登录时人机身份验证的图片类型和通过的经验建议，以及一些常见问题

Google登录时人机身份验证的图片类型和通过的经验建议，以及一些常见问题

很多朋友在登录谷歌账号时&#xff0c;都遇到过要求人机身份验证的步骤&#xff0c;而且有一些时候人机身份验证这个步骤很让人纠结&#xff0c;甚至压根就出不来具体的验证图片&#xff0c;或者花了十几分钟、几十分钟都过不去。 所以今天GG账号服务就来为您解析一下谷歌登录…
阅读更多...
论文学习_An Empirical Study of Deep Learning Models for Vulnerability Detection

论文学习_An Empirical Study of Deep Learning Models for Vulnerability Detection

1. 引言 研究背景：近年来，深度学习漏洞检测工具取得了可喜的成果。最先进的模型报告了 0.9 的 F1 分数，并且优于静态分析器。结果令人兴奋，因为深度学习可能会给软件保障带来革命性的变化。因此，IBM、谷歌和亚马逊等行业公司非常感兴趣，并投入巨资开发此类工具和数据集。…
阅读更多...
【Ubuntu-18.04.6 LTS (Bionic Beaver)】串口无法root登录解决方案

【Ubuntu-18.04.6 LTS (Bionic Beaver)】串口无法root登录解决方案

root用户无法再窗口登录 用户界面登录提示 soory that didnot work 解决方案 GDM 配置 /etc/gdm3/custom.conf 中增加或删除注释 [security] AllowRoottrue重启服务 service gdm restart确认 PAM 配置 GDM 使用 PAM 进行认证&#xff0c;可能 PAM 配置中限制了 root 登录…
阅读更多...
网络基础：Vlan原理与配置

网络基础：Vlan原理与配置

VLAN&#xff08;Virtual Local Area Network&#xff0c;虚拟局域网&#xff09;是一种将一个物理网络划分为多个逻辑子网的技术。它通过在网络交换机上配置&#xff0c;使得不同VLAN中的设备即使连接在同一个物理交换机上&#xff0c;也不能直接进行通信&#xff0c;从而实现…
阅读更多...
【JavaScript 报错】未定义的变量或函数：Uncaught ReferenceError

【JavaScript 报错】未定义的变量或函数：Uncaught ReferenceError

&#x1f525; 个人主页&#xff1a;空白诗 文章目录 一、错误原因分析1. 变量未定义2. 函数未定义3. 块级作用域问题 二、解决方案1. 确保变量已定义2. 确保函数已定义3. 正确使用块级作用域 三、实例讲解四、总结 在JavaScript开发中&#xff0c;Uncaught ReferenceError 是一…
阅读更多...
改变Ubuntu的Tab没有缩进4格（Makefile）

改变Ubuntu的Tab没有缩进4格（Makefile）

1.vim里的Tab 用vi指令打开这个文件&#xff0c;没有的话就新创建一个 vi ~/.vimrc在打开的文件中输入以下两行 1 set tabstop42 set shiftwidth4 ~ Esc &#xff1a; x&#xff0c;保存并退出即可 资料来源&#xff1a; 2024年5月21日-vi/vim …
阅读更多...
9.4 栅格图层符号化山体阴影渲染

9.4 栅格图层符号化山体阴影渲染

文章目录 前言山体阴影渲染QGis设置为山体阴影二次开发代码实现山体阴影 总结 前言 介绍栅格图层数据渲染之山体阴影渲染说明&#xff1a;文章中的示例代码均来自开源项目qgis_cpp_api_apps 山体阴影渲染 以“3420C_2010_327_RGB_LATLNG.tif”数据为例&#xff0c;在QGis中加…
阅读更多...
Typescript 模块小知识-global scope

Typescript 模块小知识-global scope

问题表现 在编写ts代码的时候遇到一个问题, 表现为, 如果在某个ts工程中, 如果多个文件里面没有任何导出export或者是export default, 那么这些文件如果有const或者是let定义相同的声明都会报错如下 无法重新声明块范围变量 a/a.ts 和 index.ts 和 index2.ts 都没有进行expor…
阅读更多...
最新文章

Copyright @ 2022~2023