C++_string简单源码剖析：模拟实现string

news2024/10/6 12:18:53

文章目录

    • 🚀1.构造与析构函数
    • 🚀2.迭代器
    • 🚀3.获取
    • 🚀 4.内存修改
    • 🚀5. 插入
    • 🚀6. 删除
    • 🚀7. 查找
    • 🚀8. 交换swap
    • 🚀9. 截取substr
    • 🚀10. 比较符号重载
    • 🚀11. 清除
    • 🚀12.流插入与流提取

大家好！本文会模拟一个基本的string类，帮助我们更好的理解string的内置函数的实现与规则。

先在.h文件声明每个需要实现的函数，需要实现的成员：

namespace bit
{
	class string
	{
	public:
		//1. 构造函数
		string(const char* tmp= "");
		string(const string& tmp);
		string&operator=(const string& s);
		~string();
		
		//2. 迭代器
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;

		//3. 获取
		size_t size() const;
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;

		//4. 内存修改
		void reserve(size_t n);

		//5. 插入
		string& operator+=(char ch);
		string& operator+=(const char* str);
		void push_back(char c);
		void append(const char* tmp);
		void insert(int pos, char c);
		void insert(int pos, const char* tmp);

		//6. 删除
		void erase(size_t pos = 0, size_t len = npos);

		//7. 查找
		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);
		
		//8. 交换swap
		void swap(string& s);

		//9. 截取substr
		string substr(size_t pos = 0, size_t len = npos);

		//10. 比较符号重载
		bool operator<(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator==(const string& s) const;
		bool operator!=(const string& s) const;
		//11. 清除
		void clear();
	private:
		char* _ptr;
		size_t _capacity;
		size_t _size;

		const static size_t npos = -1;
	};
	//12.流插入与流提取
	istream& operator>> (istream& is, string& str);
	ostream& operator<< (ostream& os, const string& str);
}

备注(重要)：npos是 const static修饰的变量，它实际上不在类中，其在.h声明后，必须在.cpp的全局域(如果有命名空间限定则在命名空间中)定义赋值。这里在.h给予一个缺省值也能到达定义的效果，但是仅限整形！！，double类型或者其他的任何类型都不能在声明时给缺省值

接下来在另一个.cpp后缀的文件中一步一步的剖析实现。

注意：

  1. 在.h声明的函数的形参如果有缺省值，.cpp去实现的函数的形参是不带缺省值的
  2. 我这边模拟的string是放在命名bit里面的，在.cpp去实现时，也要放在bit内实现（就是把实现的函数全部用命名空间bit包起来）

🚀1.构造与析构函数

//1. 构造函数
		string(const char* tmp= "");
		string(const string& tmp);
		string&operator=(const string& s);
		~string();
  1. string::string(const char* tmp):
string::string(const char* tmp) :
	_size(strlen(tmp))
{
	_ptr = new char[_size + 1];
	_capacity = _size;
	strcpy(_ptr,tmp);
}

备注：其中运用到初始化列表的知识，可以到C++入门 类和对象：深入构造函数，static成员，友元函数这个链接了解了解。


2. string(const string& tmp):

string::string(const string& tmp)
{
	string s(tmp);
	swap(s);
}

备注：这是一个比较流氓的写法，生成一个临时的 s去拷贝tmp，然后直接用swap函数交换s里面的内容，完成了拷贝tmp里的内容，同时s在到了生命周期也自动的将释放之前在_ptr指针指向的空间 (注：这个swap函数是我们实现的string内置的函数，它的实现在后文，作用就是交换private里面的三个成员参数：_ptr _capacity _size )

  1. string& operator=(const string& s)
string& string::operator=(const string& s){
	string s(tmp);
	swap(s);
}

备注：赋值重载用的方法与拷贝构造(上一个实现的函数)相同。


4. ~string()：

string::~string()
{
	delete[] _ptr;
	_capacity =  _size = 0;
}

备注：释放_ptr指向的空间

🚀2.迭代器

typedef char* iterator;
typedef const char* const_iterator;
iterator string::begin()
{
	return _ptr;
}
iterator string::end()
{
	return _ptr+ _size;
}
const_iterator string::begin() const
{
	return _ptr;
}
const_iterator string::end() const
{
	return _ptr+ _size;
}

备注： begin()返回首元素的指针，end()返回尾元素下一个位置的指针，当然也要多实现一个const的版本，以适应const string类型。

🚀3.获取

//3. 获取
		size_t string::size() const{
			return _size;
		}
		size_t string::capacity() const
		{
			return _capacity;
		}
		char& string::operator[](size_t pos){
			return _ptr[pos];
		}
		const char& string::operator[](size_t pos) const{
			return _ptr[pos];
		}

备注：其中运用到运算符重载的知识，可以到这个链接了解了解。C++入门 类和对象：深入构造函数，static成员，友元函数

🚀 4.内存修改

//4. 内存修改
void string::reserve(size_t n)
{
	if(n > _capacity)
	{
		iterator tmp = _ptr;
		_ptr = new char[n+1];
		_capacity = n;
		strcpy(ptr, tmp);
		delete[] _tmp;
	}
}

备注：用tmp保存原先_ptr指向的空间，_ptr去开新空间，之后拷贝，再释放tmp。这个函数我们不会太经常使用它，但是其他的内部函数经常使用。

🚀5. 插入

//5. 插入
		void push_back(char c);
		void append(const char* tmp);
		void insert(int pos, char c);
		void insert(int pos, const char* tmp);
		string& operator+=(char ch);
		string& operator+=(const char* str);

不同的插入函数代表不同的职能，可以到这个链接去了解C++入门 string类(第一章)：string类对象的构造，string类对象的访问即遍历，string类对象的增与删。

push_back：

void string::push_back(char c)
{
	if(size() == capacity())
	{
		int new_capacity = _capacity==0? 4: _capacity*2;
		reserve(new_capacity);
	}
	_ptr[_size] = c;
	_size++;
	_ptr[_size] = '\0';
}

备注：先判断是否扩容，再赋值，注意 下标为 _size 位置的是 ‘\0’ ，别忘了在最后补上 ‘\0’


append:

void string::append(const char* tmp)
{
	int len = strlen(tmp);
	if(size()+ len >= capacity())
	{
		reserve(size()+ len);
	}
	strcpy(_ptr+_size,tmp);
	_size+=len;
}

备注：不用考虑’ \0’的问题，tmp内自带一个’\0’

insert:

void  string::insert(int pos, char c)
{
	if(size() == capacity())
	{
		int new_capacity = _capacity==0? 4: _capacity*2;
		reserve(new_capacity);
	}
	int end = size();
	while(end >= pos)
	{
		_ptr[end+1] = _ptr[end];
	}
	_size++;
	_ptr[pos] = c;
}
void  string::insert(int pos, const char* tmp)
{
	int len = strlen(tmp);
	if(size()+ len >= capacity())
	{
		reserve(size()+ len);
	}
	int end = size() +len;
	while(end>= pos+len)
	{
		_prt[end] = _ptr[len-len]
	}
	memcpy(_ptr+pos,tmp,len);
	_size +=len;
}

备注：插入字符串的时，图例：
在这里插入图片描述

且不能使用strcpy了，strcpy会同\0一起拷贝，所以这里用memcpy

operator+=:

string& string::operator+=(char ch)
{
	push_back(ch);
}
string& string::operator+=(const char* str)
{
	append( str);
}

备注：复用push_back与append

🚀6. 删除

void string::erase(size_t pos , size_t len )
{
	if(pos+len >= size())
	{
		ptr[pos] = '\0';
		_size = pos+1;
	}
	else
	{
		strcpy(_ptr+pos,_ptr+pos+len);
		_size -= len;
	}
}

备注：从pos开始，删除长度大于size的，直接在pos下标赋值’\0’ ; 除此之外，都将_ptr+pos+len后的字符拷贝到_ptr+pos位置。

🚀7. 查找

//7. 查找
		size_t find(char ch, size_t pos )
		{
			for(int i = 0;  i< size();i++)
			{
				if(ch == _ptr[i])return i;
			}
			return npos;
		}
		size_t find(const char* str, size_t pos)
		{
			char* p = strstr(_ptr + pos, str);
			return  p - _ptr;
		}

备注：查找字符串是直接复用库里的strstr函数。

🚀8. 交换swap

//8. 交换swap
		void swap(string& s)
		{
			std::swap(s._ptr, _ptr);
			std::swap(s._size, _size);
			std::swap(s._capacity, _capacity);
		}

备注：本质是交换private的三个参数。

🚀9. 截取substr

//9. 截取substr
		string substr(size_t pos, size_t len)
		{
			if(pos+len >= size())
			{
				string tmp(_ptr+pos);
				return tmp;
			}
			else
			{
				string tmp(_ptr+pos);
				tmp[len+1] = '\0';
				tmp._size() = len;
				return tmp;
			}
		}

🚀10. 比较符号重载

//10. 比较符号重载
bool string::operator<(const string& s) const
{
	return strcmp(this->_ptr, s._ptr)<0 ;
}
bool string::operator>(const string& s) const
{
	return strcmp(this->_ptr, s._ptr) > 0;
}

bool string::operator<=(const string& s) const
{
	return strcmp(this->_ptr, s._ptr) <= 0;

}
bool string::operator>=(const string& s) const
{
	return strcmp(this->_ptr, s._ptr) >= 0;
}

bool string::operator==(const string& s) const
{
	return !strcmp(this->_ptr, s._ptr);
}
bool string::operator!=(const string& s) const
{
	return strcmp(this->_ptr, s._ptr);
}

备注：复用的是库里的strcmp函数。一个一个字符比较，不相等就返回结果，字符大小的判断咨询ASCll码

🚀11. 清除

//11. 清除
	void string::clear(){
		_size = 0;
		_ptr[0] = '\0';
	}

备注：clear同样也可以复用erase去实现

🚀12.流插入与流提取

//12.流插入与流提取
	istream& operator>> (istream& is, string& str){
		str.clear();
		char ch = get();
		while(ch != '\0')
		{
			str+=ch;
			get();
		}
		return is;
	}
	ostream& operator<< (ostream& os, const string& str){
		for (size_t i = 0; i < str.size(); i++)
		{
			os << str[i];
		}
		return os;
	}

备注：流插入与流提取不是成员函数，实现在类外。 >>重载用到get函数，取得一个输入的字符并尾插到str，当这个字符是换行’\n’时，就不再获取。

全部代码：

//.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <cstring>
#include<string>
using namespace std;
namespace bit
{
	class string
	{
	public:
		//构造函数
		//string();
		string(const char* tmp= "");
		string(const string& tmp);
		string&operator=(const string& s);
		~string();
		
		//迭代器
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin();
		iterator end();
		const_iterator begin() const;
		const_iterator end() const;

		//获取
		size_t size() const;
		size_t capacity() const;
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;

		//内存修改
		void reserve(size_t n);

		//插入
		string& operator+=(char ch);
		string& operator+=(const char* str);
		void push_back(char c);
		void append(const char* tmp);
		void insert(int pos, char c);
		void insert(int pos, const char* tmp);

		//删除
		void erase(size_t pos = 0, size_t len = npos);

		//查找
		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);
		
		//交换swap
		void swap(string& s);

		//截取substr
		string substr(size_t pos = 0, size_t len = npos);

		//比较符号重载
		bool operator<(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator==(const string& s) const;
		bool operator!=(const string& s) const;
		//清除
		void clear();
	private:
		char* _ptr;
		size_t _capacity;
		size_t _size;

		const static size_t npos = -1;
	};
	//流插入与流提取
	istream& operator>> (istream& is, string& str);
	ostream& operator<< (ostream& os, const string& str);
}


//.cpp
#include "string.h"

namespace bit
{
	//构造函数
	//string();

	string::string(const char* tmp) :
		_size(strlen(tmp))
	{
		_ptr = new char[_size + 1];
		_capacity = _size;
		strcpy(_ptr,tmp);
	}
	
	string::~string()
	{
		delete[] _ptr;
		_capacity = _size = 0;
	}
	
	string& string::operator=(const string& s)
	{
		//方法1 ： 传统方法
		if (this != &s)
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._ptr);
			delete[] _ptr;
			_ptr = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		//新派方法,使用swap直接拷贝
		//string tmp_s(s._ptr);
		//this->swap(tmp_s);
		return *this;
	}

	string::string(const string& tmp) 
	{
		//方法1 ： 传统方法
		 /*_size = tmp._size  ;
		 _capacity = tmp._capacity;
		 _ptr = new char[_capacity + 1];
		 strcpy(_ptr, tmp._ptr);*/

		//方法2 ：新派方法,使用swap直接拷贝
		string tmp_s(tmp._ptr);
		this->swap(tmp_s);
	}

	//迭代器
	string::iterator string::begin()
	{
		return _ptr;
	}
	string::iterator string::end()
	{
		return _ptr+_size;
	}

	string::const_iterator string::begin() const
	{
		return _ptr;
	}
	string::const_iterator string::end() const
	{
		return _ptr + _size;
	}
	//获取
	size_t string::size() const
	{
		return _size;
	}

	size_t string::capacity() const
	{
		return  _capacity;
	}
	char& string::operator[](size_t pos)
	{
		return _ptr[pos];
	}

	const char& string::operator[](size_t pos) const
	{
		return _ptr[pos];
	}
	//内存修改
	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			iterator tmp = _ptr;
			_ptr = new char[n + 1];
			_capacity = n;
			strcpy(_ptr, tmp);
			delete[] tmp;
		}
	}	

	/*void string::print()
	{
		int i = 0;
		while (i != _size)
		{
			cout << _ptr[i] ;
			i++;
		}
	}*/
	
	//插入
	void string::push_back(char c)
	{
		if (_size == _capacity)
		{
			int new_capacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(new_capacity);
		}
		_ptr[_size] = c;
		_size++;
		_ptr[_size] = '\0';
	}

	void string::append(const char* tmp)
	{
		int len = strlen(tmp);
		if (size() + len >= capacity())
		{
			reserve(size() + len);
		}
		strcpy(_ptr + _size, tmp);
		_size += len;
	}
	void string::insert(int pos, char c)
	{
		if (_size == _capacity)
		{
			int new_capacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(new_capacity);
		}
		size_t end = _size;
		while ((int)end >= pos)
		{
			_ptr[end + 1] = _ptr[end];
		end--;
		}
		_ptr[pos] = c;
		_size++;
	}
	void string::insert(int pos, const char* tmp)
	{
		int len = strlen(tmp);
		if (_size + len >= _capacity)
		{
			reserve(size() + len);
		}
		
		int end = (int)_size + len;
		while (end >= pos + len)
		{
			_ptr[end] = _ptr[end - len];
			end--;
		}

		memcpy(_ptr + pos, tmp, len);
		_size += len;
	}

	string& string::operator+=(char ch)
	{
		this->push_back(ch);
		return *this;
	}
	string& string::operator+=(const char* str)
	{
		this->append(str);
		return *this;
	}

	//删除
	void string::erase(size_t pos, size_t len)
	{
		if (pos + len >= _size)
		{
			_ptr[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_ptr + pos, _ptr + pos+len);
			_size -= len;
		}
	}
	//查找
	size_t string::find(char ch, size_t pos )
	{
		for (int i = pos; i < _size; i++)
		{
			if (ch == _ptr[i])
			{
				return i;
			}
		}
		return npos;
	}
	size_t string::find(const char* str, size_t pos )
	{
		char* p = strstr(_ptr + pos, str);
		return  p - _ptr;
	}

	void string::swap(string& s)
	{
		std::swap(s._ptr, _ptr);
		std::swap(s._size, _size);
		std::swap(s._capacity, _capacity);
	}
	string string::substr(size_t pos , size_t len)
	{
		if (pos + len >= _size)
		{
			string tmp(_ptr + pos);
			return  tmp;
		}
		else
		{
			string tmp(_ptr + pos);
			tmp._size = len;
			tmp._ptr[len] = '\0';
			return tmp;
		}
	}
	bool string::operator<(const string& s) const
	{
		return strcmp(this->_ptr, s._ptr)<0 ;
	}
	bool string::operator>(const string& s) const
	{
		return strcmp(this->_ptr, s._ptr) > 0;
	}
	
	bool string::operator<=(const string& s) const
	{
		return strcmp(this->_ptr, s._ptr) <= 0;
	
	}
	bool string::operator>=(const string& s) const
	{
		return strcmp(this->_ptr, s._ptr) >= 0;
	}

	bool string::operator==(const string& s) const
	{
		return !strcmp(this->_ptr, s._ptr);
	}
	bool string::operator!=(const string& s) const
	{
		return strcmp(this->_ptr, s._ptr);
	}
	void string::clear()
	{
		_size = 0;
		_ptr[0] = '\0';
	}
	istream& operator>> (istream& is, string& str)
	{
		str.clear();
		char ch = is.get();
		while ( ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
		return is;
	}
	ostream& operator<< (ostream& os, const string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			os << str[i];
		}
		return os;
	}

}

本文就到这里，感谢你看到这里！
我知道一些人看文章喜欢静静看，不评论，但是他会点赞，这样的人，帅气低调有内涵，美丽大方很优雅，明人不说暗话，要你手上的一个点赞！

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

pod install 报错 ‘SDK does not contain ‘libarclite‘ at the path...‘

pod install 报错 ‘SDK does not contain ‘libarclite‘ at the path...‘

报错内容&#xff1a; SDK does not contain ‘libarclite’ at the path ‘/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/arc/libarclite_iphoneos.a’; 这是报错已经很明确告诉我们&#xff0c;Xcode默认的工具链中缺少一个工具…
阅读更多...
Linux Tcpdump抓包入门

Linux Tcpdump抓包入门

Linux Tcpdump抓包入门 一、Tcpdump简介 tcpdump 是一个在Linux系统上用于网络分析和抓包的强大工具。它能够捕获网络数据包并提供详细的分析信息&#xff0c;有助于网络管理员和开发人员诊断网络问题和监控网络流量。 安装部署 # 在Debian/Ubuntu上安装 sudo apt-get install…
阅读更多...
爬虫100个Python例子优化

爬虫100个Python例子优化

今天看到一个Python 100例的在线资源，感觉每个都需要去点，太费时间了，于是，使用Python将数据爬取下来，方便查看。实际效果如下： 。。。。。。 用了13分钟，当然，这是优化后的效果，如果没有优化，需要的时间更长。 爬取url如下： https://www.runoob.com/python/pytho…
阅读更多...
Pytorch深度学习实践笔记1

Pytorch深度学习实践笔记1

&#x1f3ac;个人简介&#xff1a;一个全栈工程师的升级之路&#xff01; &#x1f4cb;个人专栏&#xff1a;pytorch深度学习 &#x1f380;CSDN主页 发狂的小花 &#x1f304;人生秘诀&#xff1a;学习的本质就是极致重复! 《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibi…
阅读更多...
【数据结构与算法 刷题系列】移除链表元素

【数据结构与算法 刷题系列】移除链表元素

&#x1f493; 博客主页&#xff1a;倔强的石头的CSDN主页 &#x1f4dd;Gitee主页&#xff1a;倔强的石头的gitee主页 ⏩ 文章专栏&#xff1a;数据结构与算法刷题系列&#xff08;C语言&#xff09; 期待您的关注 目录 一、问题描述 二、解题思路 三、源代码实现 一、问题…
阅读更多...
不靠后端，前端也能搞定接口！

不靠后端，前端也能搞定接口！

嘿&#xff0c;前端开发达人们&#xff01;有个超酷的消息要告诉你们&#xff1a;MemFire Cloud来袭啦&#xff01;这个神奇的东东让你们不用依赖后端小伙伴们&#xff0c;也能妥妥地搞定 API 接口。是不是觉得有点不可思议&#xff1f;但是事实就是这样&#xff0c;让我们一起…
阅读更多...
软件项目详细设计说明书实际项目参考（word原件下载及全套软件资料包）

软件项目详细设计说明书实际项目参考（word原件下载及全套软件资料包）

系统详细设计说明书案例&#xff08;直接套用&#xff09; 1.系统总体设计 2.性能设计 3.系统功能模块详细设计 4.数据库设计 5.接口设计 6.系统出错处理设计 7.系统处理规定 软件开发全文档下载&#xff08;下面链接或者本文末个人名片直接获取)&#xff1a;软件开发全套资料-…
阅读更多...
指纹识别概念解析

指纹识别概念解析

目录 1. 指纹是物证之首 1.1 起源于中国 1.2 发展于欧洲 1.3 流行于全世界 2. 指纹图像 3. 指纹特征 4. 指纹注册 5. 指纹验证 6. 指纹辨识 1. 指纹是物证之首 指纹识别技术起源于中国、发展于欧洲、流行于全世界。自20世纪以来&#xff0c;指纹在侦破刑事案件、解决诉…
阅读更多...
06.逻辑回归

06.逻辑回归

文章目录 Generate Model优化边界为线性证明损失函数比较逻辑回归不能用均方误差Generative v.s. DiscriminativeMulti-class Classification逻辑回归的限制自己找线性变换 Generate Model 假设样本符合高斯分布 即找 μ \mu μ和 σ \sigma σ 优化 共用 Σ \Sigma Σ减少…
阅读更多...
Vue3实战笔记（45）—VUE3封装一些echarts常用的组件，附源码

Vue3实战笔记（45）—VUE3封装一些echarts常用的组件，附源码

文章目录 前言一、柱状图框选二、折线图堆叠总结 前言 日前使用hooks的方式封装组件&#xff0c;在我使用复杂的图标时候遇到了些问题&#xff0c;预想在onMounted中初始化echarts&#xff0c;在使用hooks的时候&#xff0c;组件没有渲染完&#xff0c;使用实例会出现各种各样…
阅读更多...
MongoDB（介绍，安装，操作，Springboot整合MonggoDB）

MongoDB（介绍，安装，操作，Springboot整合MonggoDB）

目录 MongoDB 1 MongoDB介绍 MongoDB简介 MongoDB的特点 MongoDB使用场景 小结 2 MongoDB安装 安装MongoDB 连接MongoDB MongoDB逻辑结构 MongoDB数据类型 小结 3 MongoDB操作 操作库和集合 操作文档-增删改 操作文档-查询 MongoDB索引 小结 4 SpringBoot整合…
阅读更多...
java -spring 15 配置类 ConfigurationClassPostProcessor

java -spring 15 配置类 ConfigurationClassPostProcessor

01Spring中定义的配置类 ConfigurationClassPostProcessor是一个BeanFactory的后置处理器&#xff0c;因此它的主要功能是参与BeanFactory的建造&#xff0c;在这个类中&#xff0c;会解析加了Configuration的配置类&#xff0c;还会解析ComponentScan、ComponentScans注解扫描…
阅读更多...
C语言笔记21 •模拟atoi函数•

C语言笔记21 •模拟atoi函数•

1.atoi的使用 atoi是将字符串转化为int类型数字的一个库函数 int main() { char str[] "123568"; int a; a atoi(str); /*将字符串转化为int型的数字*/ printf("%d\n", a); } 2.模拟atoi函数 #define _CRT_SECURE_NO_WARNINGS…
阅读更多...
Mac JDK和SDK环境变量配置

Mac JDK和SDK环境变量配置

一、Java JDK配置 1.下载并安装Java jdk1.8及以上&#xff0c;这个可以在网上自行搜索下载&#xff0c;这里不在详细描述 2.如果不知道JAVA_HOME的安装路径&#xff0c;可以输入命令查看&#xff1a;/usr/libexec/java_home -V &#xff0c;如图 3.在终端输入命令&#xff1…
阅读更多...
【openlayers系统学习】3.1-3.2彩色GeoTIFF图像渲染

【openlayers系统学习】3.1-3.2彩色GeoTIFF图像渲染

一、彩色GeoTIFF图像渲染 Sentinel-2 卫星任务收集并传播覆盖地球陆地表面的图像&#xff0c;重访频率为 2 至 5 天。传感器收集多波段图像&#xff0c;其中每个波段都是电磁频谱的一部分。 2A 级 (L2A) 产品提供以下频段的表面反射率测量&#xff1a; BandDescriptionCentra…
阅读更多...
【计算机毕业设计】030英语学习交流平台微信小程序

【计算机毕业设计】030英语学习交流平台微信小程序

&#x1f64a;作者简介&#xff1a;拥有多年开发工作经验&#xff0c;分享技术代码帮助学生学习&#xff0c;独立完成自己的项目或者毕业设计。 代码可以私聊博主获取。&#x1f339;赠送计算机毕业设计600个选题excel文件&#xff0c;帮助大学选题。赠送开题报告模板&#xff…
阅读更多...
前端CSS命名书写格式

前端CSS命名书写格式

遵循此规则的好处&#xff1a; - 代码易维护&#xff0c;出现问题容易排查。 - 开发速度快
阅读更多...
智能体（Agent）详细精讲

智能体（Agent）详细精讲

1.什么是智能体 智能体&#xff08;Agent&#xff09;是一种由大规模语言模型&#xff08;如GPT-4或本地模型&#xff09;驱动的先进系统&#xff0c;能够执行多种复杂任务。通过引入智能体&#xff0c;企业和个人可以实现自动化处理和高效管理各种事务。 智能体的核心是其“大…
阅读更多...
C++ | Leetcode C++题解之第111题二叉树的最小深度

C++ | Leetcode C++题解之第111题二叉树的最小深度

题目&#xff1a; 题解&#xff1a; class Solution { public:int minDepth(TreeNode *root) {if (root nullptr) {return 0;}queue<pair<TreeNode *, int> > que;que.emplace(root, 1);while (!que.empty()) {TreeNode *node que.front().first;int depth que…
阅读更多...
[数据结构] -- 双向循环链表

[数据结构] -- 双向循环链表

&#x1f308; 个人主页&#xff1a;白子寰 &#x1f525; 分类专栏&#xff1a;C打怪之路&#xff0c;python从入门到精通&#xff0c;数据结构&#xff0c;C语言&#xff0c;C语言题集&#x1f448; 希望得到您的订阅和支持~ &#x1f4a1; 坚持创作博文(平均质量分82)&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023