vector的底层原理剖析及其实现

news2024/11/15 8:37:48

vector

  • 一、定义
    • 二、常用接口及模拟实现
      • 三、vector迭代器失效问题
        • 四、使用memcpy拷贝会出现的问题
          • 五、二维数组vector<vector< T >> vv

一、定义

vector 是 C++ 标准模板库（Standard Template Library, STL）中的一个非常有用的容器。它是一个序列容器，可以存储具有相同数据类型的元素集合，这些元素在内存中连续存储。与数组相似，但 vector 提供了更多的灵活性和功能。

主要特点：

1.动态数组：vector 可以动态地增加或减少其大小，这意味着你可以根据需要存储更多的元素，而不需要担心数组越界的问题。
2.随机访问：vector 支持随机访问，即你可以使用下标（索引）直接访问容器中的任何元素，其时间复杂度为 O(1)。
3.内存连续：vector 中的元素在内存中是连续存储的，这使得在需要时（如使用迭代器）可以高效地遍历整个容器。
4.容量和大小：vector 有两个重要的属性：size() 和 capacity()。size() 返回容器中当前元素的数量，而 capacity() 返回容器在不重新分配内存的情况下可以存储的元素的最大数量。当 vector 的大小超过其容量时，它会分配更多的内存空间并可能移动所有元素到新的内存位置。

常用操作：

1.插入元素：可以使用 push_back() 在 vector 的末尾添加新元素，或者使用 insert() 在指定位置插入元素。
2.删除元素：可以使用 pop_back() 删除 vector 的最后一个元素，或者使用 erase() 删除指定位置的元素或元素范围。
3.访问元素：可以直接使用下标操作符 [] 访问元素。
4.遍历元素：可以使用迭代器或者范围基 for 循环遍历 vector 中的所有元素。
获取大小和容量：如前所述，可以使用 size() 和 capacity() 方法分别获取 vector 的大小和容量。

二、常用接口及模拟实现

成员变量：

/这里加缺省值的原因：当对象是通过拷贝构造形成的时，这三个指针
/就不会初始化了（默认是随机值，而不是nullptr(0)），而在拷贝构造函数里，会运用到size(),capacity()之类的需要
/这三个指针相减，而随机值相减可能是很大的数字
/而加了缺省值，进入拷贝构造函数后会先进入这里初始化这三个值

iterator _start=nullptr;   /指向第一个元素
iterator _finish=nullptr;   /指向最后一个元素的下一个位置
iterator _end_of_storage=nullptr;  /指向最大容量的位置

（1）构造函数

(constructor)构造函数声明接口说明
vector()无参构造
vector（size_type n, const value_type& val =value_type()构造并初始化n个val
vector (const vector& x)拷贝构造
vector (InputIterator first, InputIterator last)使用迭代器进行初始化构

模拟实现：

vector():_start(nullptr),_finish(nullptr),_end_of_storage(nullptr) {
}

vector(size_t n, const T& val) {
 _start = new T[n](val);
 _finish = _start + n;
 _end_of_storage = _finish;
}

vector(const vector<T>& v) {
 /写法1:
 /_start = new T[v.capacity()];
 memcpy(_start, v._start, sizeof(T) * v.size());
 _finish = _start + v.size();
 _end_of_storage = _start + v.capacity();/

 /写法2：
 reserve(v.capacity()); /避免push_back多次扩容
 for (auto& num : v) {
	 push_back(num);
 }
}

 template<class Inputiterator> //说明：成员函数里面可以有模板函数
 vector(Inputiterator begin, Inputiterator end) {  //用迭代器区间进行构造和初始化
	    //这里重新定义一个Inputiterator而不用vector里面的iterator，是
	 //因为如果用了iterator,那么调用该函数构造的对象所传的实参只能是vector的迭代器
	 //而不能是诸如list ,map等容器的迭代器，而如果想用list或者其他容器的值来
	 //初始化vector对象的话，只能如此定义一个迭代器模板 。
	 
	 //该构造函数支持任意容器的迭代器来初始化，但前提是这些容器所存的数据与
	 //该vector所存的数据类型一致，如：list<int>l 用该方法来初始化 vector<int> v
	 //它们存的都是int类型的数据

	 while (begin != end) {
		 push_back(*begin);
		 begin++;
	 }
 }

（2）vector的迭代器
vector的迭代器有两种：

  1. iterator：typedef T* iterator
  2. const_iterator：typedef const T* const_iterator
    (T是vector存的数据类型)

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对
指针进行了封装（list容器的迭代器），比如：vector的迭代器就是原生态指针T* 。

（3）begin()/end()，rbegin()/rend()接口函数

接口说明
begin()、end()获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin()、rend()获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

在这里插入图片描述
在这里插入图片描述
模拟实现：

 iterator begin() const{
	 return _start;
 }
 iterator end()const {
	 return _finish;
 }

（4）空间增长函数

容量空间接口说明
size()获取容器中数据个数
capacity()获取容量大小
empty()判断容器是否为空
resize()改变vector的size
reserve()改变vector的capacity
  1. capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2
    倍增长的。因此vector的增容都具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
  2. reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代
    价缺陷问题。
  3. resize在开空间的同时还会进行初始化，影响size。

模拟实现：

size_t size()const {
 return _finish - _start; //两指针相减，结果为两指针之间的数据个数
}
size_t capacity() const{
 return _end_of_storage - _start;
}
void resize(size_t n, T val = T()) {
 if (n < size()) {//保留n个数据    
	 _finish = _start + n;
 }
 else {
	 reserve(n);
	 while (_finish < _start + n) {  //扩容并追加n-size()个val值
		 (*_finish) = val;
		 _finish++;
	 }
 }
}

 void reserve(size_t n) {
	 if (n > capacity()) {
		 size_t presize = size(); //要提前记录_start 与_finish 的相对位置
		                       //因为下面的_start先更新了，会导致size()函数
		                       //出错 (除非_finish先更新：_finish=tmp+size(),_start=tmp
		 T* tmp = new T[n];

		 //不严谨的拷贝数据：
		 //memcpy(tmp, _start, sizeof(T) * presize); //拷贝数据

		 //严谨的拷贝数据：
		 for (size_t i = 0; i < presize; i++) {
			 tmp[i] = _start[i];
		 }//这是因为假如类型T是string或者是vector<int>，而memcpy又是单纯的将内存的空间逐个字节拷贝
		 //就导致vector存的string对象的char*指针（或者vector<int>的int*）
		 // 也是单纯的直接拷贝给tmp,
		 //即tmp里的string对象里的指针指向的空间和待释放的vector对象存的
		 //string对象里的指针指向的空间是一样的。
		 //下面delete[] _start 时，会先调用每个string对象的析构函数。
		 //其实就是，vector深拷贝了，但是vector存的string没有深拷贝
		 
		 //而如果将该this对象的内容逐个拷贝给tmp，每次拷贝时都会调用string的深拷贝
		 //从而避免了该情况。
		 // tmp[i]=_start[i]本质上是：string s =string s'（string的拷贝构造) 


		 delete[] _start;
		 //更新三个迭代器所指向的位置：
		 _start = tmp;
		 _finish = tmp + presize;
		 _end_of_storage = tmp + n;
	 }
 }

测试vector在不同平台下的扩容机制：

// 测试vector的默认扩容机制
void TestVectorExpand()
{
   size_t sz;
   vector<int> v;
   sz = v.capacity();
   cout << "making  grow:\n";
   for (int i = 0; i < 100; ++i)
  {
    v.push_back(i);
    if (sz != v.capacity())
    {
      sz = v.capacity();
      cout << "capacity changed: " << sz << '\n';
    }
  }
}
/vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making  grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141

/g++运行结果：linux下使用的STL基本是按照2倍方式扩容
making  grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128

// 如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够
// 就可以避免边插入边扩容导致效率低下的问题了
void TestVectorExpandOP()
{
   vector<int> v;
   size_t sz = v.capacity();
   v.reserve(100); / 提前将容量设置好，可以避免一遍插入一遍扩容
   cout << "making bar grow:\n";
   for (int i = 0; i < 100; ++i)
 {
    v.push_back(i);
    if (sz != v.capacity())
   {
     sz = v.capacity();
     cout << "capacity changed: " << sz << '\n';
   }
 }
}

（5）vector的增删查改

vector增删查改接口说明
push_back()（重点）尾插
pop_back() （重点）尾删
find()查找。（注意这个是算法模块实现，不是vector的成员接口）
insert()在position之前插入val
erase()删除position位置的数据
swap()交换两个vector的数据空间
operator （重点）像数组一样访问

模拟实现：

void push_back(const T& x) { //T可能是自定义类型，所以用const引用较好
 if (_finish == _end_of_storage) {//扩容
	 reserve(capacity() == 0 ? 4 : 2 * capacity());
  }
 *_finish = x; //如果T是string ,这里会调用string的拷贝构造
 _finish++;
}

 void pop_back() {		
	 assert(_start != _finish);
	 --_finish;
 } 

 iterator find(iterator begin, iterator end, const T& x) {
	 vector<T>::iterator it = begin;
	 while (it != end) {
		 if (*it == x) {
			 return it;
		 }
		 it++;
	 }
	 return end;
 }

void insert(iterator pos, const T& x) {
 if (_finish == _end_of_storage) {//扩容
	 size_t pre_distance = pos - _start;
	 reserve(capacity() == 0 ? 4 : 2 * capacity());
	 pos = _start + pre_distance;  //因为_start在扩容时指向的空间变化了，
	                               //因此pos也要相应的变化
 }                                 //否则会出现迭代器失效的情况
 iterator end = _finish-1;
 while (end >=pos) {
    *(end + 1) = *end;
	 end--;
 }
 *pos = x;
 ++_finish;
}

 void erase(iterator pos) {
	 assert(pos >= _start);
	 assert(pos < _finish);
	 iterator it = pos;
	 while (it < _finish-1) {
		 *(it) = *(it + 1);
		 it++;
	 }
	 _finish--;
 }

 void swap(vector<T>& v) {
	 std::swap(_start, v._start);
	 std::swap(_finish, v._finish);
	 std::swap(_end_of_storage, v._end_of_storage);
 }

 T& operator[](int i) {
	 assert(i < size() && i >= 0);
	 return _start[i];
 }

三、vector迭代器失效问题

迭代器失效实际就是迭代器
底层对应指针所指向的空间被销毁了，而仍然使用这一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

对于vector可能会导致其迭代器失效的操作有：

  1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。即如果已经有了一个迭代器指向一块空间，但是这个空间被上述可以改变空间结构的函数给销毁了，那么这个迭代器也就失效了。
  2. 指定位置元素的删除操作–erase
using namespace std;
#include <vector>
int main()
{
   int a[] = { 1, 2, 3, 4 };
   vector<int> v(a, a + sizeof(a) / sizeof(int));//发生隐式类型转化，调用迭代器区间构造函数
   
   // 使用find查找3所在位置的iterator
   vector<int>::iterator pos = find(v.begin(), v.end(), 3);
   
   // 删除pos位置的数据，导致pos迭代器失效。
    v.erase(pos);
    cout << *pos << endl; // 此处会导致非法访问
    return 0;
}

说明：
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理
论上讲迭代器不应该会失效。但是，如果pos刚好是最后一个元素，删完之后pos刚好是end
的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素
时，vs就认为该位置迭代器失效了。

3.注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

/ 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
vector<int> v{1,2,3,4,5};
for(size_t i = 0; i < v.size(); ++i)
cout << v[i] << " ";
cout << endl;
auto it = v.begin();
cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
v.reserve(100);
cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
// 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux
下不会
// 虽然可能运行，但是输出的结果是不对的
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
程序输出：
1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5


/ 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
vector<int> v{1,2,3,4,5};
vector<int>::iterator it = find(v.begin(), v.end(), 3);
v.erase(it);
cout << *it << endl;
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
程序可以正常运行，并打印：
4
4 5

/ 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
/ 此时迭代器是无效的，++it导致程序崩溃
int main()
{
vector<int> v{1,2,3,4,5};
// vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
while(it != v.end())
{
if(*it % 2 == 0)
v.erase(it);
++it;
}
for(auto e : v)
cout << e << " ";
cout << endl;
return 0;
}

总结：
从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行
结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

四、使用memcpy拷贝会出现的问题

注：reserve接口：

 void reserve(size_t n) {
	 if (n > capacity()) {
		 size_t presize = size(); //要提前记录_start 与_finish 的相对位置
		                       //因为下面的_start先更新了，会导致size()函数
		                       //出错 (除非_finish先更新：_finish=tmp+size(),_start=tmp
		 T* tmp = new T[n];

		 memcpy(tmp, _start, sizeof(T) * presize); //拷贝数据
		 delete[] _start;
		 //更新三个迭代器所指向的位置：
		 _start = tmp;
		 _finish = tmp + presize;
		 _end_of_storage = tmp + n;
	 }
 }

#include<string>
int main()
{
Myvector::vector<string> v;  //vector是自己实现的，string是库实现的

v.push_back("wwww");
v.push_back("eeee");
v.push_back("rrrr");
return 0;
}

上述代码所导致的问题剖析：
在这里插入图片描述
在这里插入图片描述
正确拷贝数据的方法：（逐个数据拷贝）

 void reserve(size_t n) {
	 if (n > capacity()) {
		 size_t presize = size(); //要提前记录_start 与_finish 的相对位置
		                       //因为下面的_start先更新了，会导致size()函数
		                       //出错 (除非_finish先更新：_finish=tmp+size(),_start=tmp
		 T* tmp = new T[n];

		 for (size_t i = 0; i < presize; i++) {
			 tmp[i] = _start[i];
		 }//这是因为假如类型T是string或者是vector<int>，而memcpy又是单纯的将内存的空间逐个字节拷贝
		 //就导致vector存的string对象的char*指针（或者vector<int>的int*）
		 // 也是单纯的直接拷贝给tmp,
		 //即tmp里的string对象里的指针指向的空间和待释放的vector对象存的
		 //string对象里的指针指向的空间是一样的。
		 //下面delete[] _start 时，会先调用每个string对象的析构函数。
		 //其实就是，vector深拷贝了，但是vector存的string没有深拷贝
		 
		 //而如果将该this对象的内容逐个拷贝给tmp，每次拷贝时都会调用string的深拷贝
		 //从而避免了该情况。
		 // tmp[i]=_start[i]本质上是：string s =string s'（string的拷贝构造) 

		 delete[] _start;
		 //更新三个迭代器所指向的位置：
		 _start = tmp;
		 _finish = tmp + presize;
		 _end_of_storage = tmp + n;
	 }
 }

总结：不仅vector存stirng类型会出现该问题，只要是存的对象里有指向堆空间的类型（如还有下面的二维数组），都是有memcpy拷贝问题的，而存储自定义类型就不会。

五、二维数组vector<vector< T >> vv

对c语言来说，创建一个二维数组的方法：

test()
{
    //三行四列
    int **two=(int**)malloc(sizeof(int*)*3);
    for(int i=0;i<3;i++){
      two[i]=(int*)malloc(sizeof(int)*4);
    }
}

vector<vecot< T >> vv 的底层空间示意图：
在这里插入图片描述

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

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

相关文章

23款奔驰GLS450加装原厂电吸门配置，提升车辆舒适性和便利性

23款奔驰GLS450加装原厂电吸门配置，提升车辆舒适性和便利性

今天是一台22款奔驰GLS450&#xff0c;车主是佛山的 以前被不良商家坑了 装了副厂的电吸门 刚开始就很正常 用了半年之后 就开始开不了门&#xff0c;被锁在里面&#xff0c;刚开始车主以为是零件坏了 后来越来越频繁&#xff0c;本来是为了家里老人小孩关门方便而升级的&#…
阅读更多...
J031_使用TCP协议支持与多个客户端同时通信

J031_使用TCP协议支持与多个客户端同时通信

一、需求文档 使用TCP协议支持与多个客户端同时通信。 1.1 Client package com.itheima.tcp2;import java.io.DataOutputStream; import java.io.OutputStream; import java.net.Socket; import java.util.Scanner;public class Client {public static void main(String[] a…
阅读更多...
软件设计之Java入门视频(22)

软件设计之Java入门视频(22)

软件设计之Java入门视频(22) 视频教程来自B站尚硅谷&#xff1a; 尚硅谷Java入门视频教程&#xff0c;宋红康java基础视频 相关文件资料&#xff08;百度网盘&#xff09; 提取密码&#xff1a;8op3 idea 下载可以关注 软件管家 公众号 学习内容&#xff1a; 该视频共分为1-7…
阅读更多...
Flask 介绍

Flask 介绍

Flask 介绍 为什么要学 Flask框架对比设计哲学功能特点适用场景学习曲线总结 Flask 的特点Flask 常用扩展包Flask 的基本组件Flask 的应用场景官方文档官方文档链接文档内容概述学习建议 Flask 是一个使用 Python 编写的轻量级 Web 应用框架。它旨在让 Web 开发变得快速、简单且…
阅读更多...
ACl访问控制实验

ACl访问控制实验

要求&#xff1a;PC1可以telnet登录r1&#xff0c;不能ping通r1&#xff0c;pc1可以ping通r2&#xff0c;但不能telnet登录r2&#xff0c;pc2的所有限制与pc1相反 实验思路&#xff1a;因为华为的ensp默认允许所有&#xff0c;所以只写拒绝规则就行 rule 5 deny icmp source 19…
阅读更多...
只需0.5秒 Stability AI新模型超快生成3D图像

只需0.5秒 Stability AI新模型超快生成3D图像

生成式人工智能&#xff08;AI&#xff09;明星初创公司Stability AI 8月发布最新突破性3D模型Stable Fast 3D&#xff0c;将单张图片生成3D图像的速度大幅提升。Stability AI今年3月发布的3D模型SV3D需要多达10分钟生成3D资产&#xff0c;基于TripoSR的新模型Stable Fast 3D完…
阅读更多...
【面试官:我看你SQL语句掌握的怎么样？面试SQL语句专题3】

【面试官:我看你SQL语句掌握的怎么样？面试SQL语句专题3】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
【教程】Python语言的地球科学常见数据—— IMS积雪覆盖数据的处理

【教程】Python语言的地球科学常见数据—— IMS积雪覆盖数据的处理

将ASCII数据转化为netCDF数据、分析新疆北疆、青藏高原和东北地区气候态积雪分布、分析新疆北疆、青藏高原和东北地区积雪面积变化规律。 美国国家冰雪中心&#xff08;NSIDC&#xff09;从 1997 年 2 月至今的北半球雪盖和海冰的地图。这些数据以 ASCII 文本和 GeoTIFF 格式提…
阅读更多...
AIWEB1综合靶场通关教程，从外网打到内网【附靶场环境】

AIWEB1综合靶场通关教程，从外网打到内网【附靶场环境】

前言 靶场获取后台回【aiweb1】 下载之后设置为nat模式 启动即可&#xff0c;不需要登录 靶机复现 主机发现 访问即可 信息收集robots.txt文件 访问尝试&#xff0c;原来是什么也没有的&#xff0c;404 我们去访问这个上级目录&#xff0c;发现有一个id 注入测试 语法错误&am…
阅读更多...
基于Protobuf的RPC

基于Protobuf的RPC

先上UserServer提供服务的函数要求proto文件内容&#xff1a; syntax"proto3"; package fixbug; option cc_generic_servicestrue; message LoginRequest {bytes name1;bytes pwd2; } message LoginResponse {ResultCode result1;bool sucess2; } #调用远程服务的入…
阅读更多...
JAVA游戏源码：跑酷|大学生练手项目

JAVA游戏源码：跑酷|大学生练手项目

学习java朋友们&#xff0c;福利来了&#xff0c;今天小编给大家带来了一款跑酷源码。注意&#xff1a;此源码仅供学习使用!! 源码搭建和讲解 启动main入口&#xff1a; //************************************************************************ // ************完整源码…
阅读更多...
AcWing食物链

AcWing食物链

Q1&#xff1a;怎么判断X和Y是不是同类? A:判断这俩是不是在一个集合中,如果在同一个集合中&#xff0c;那么判断X到祖先节点的距离D[X]和D[Y]到祖先节点的距离是否有D[X]%3D[Y]%3,也就是3同余 若果是&#xff0c;那么是同类。如果X和Y不在一个集合里面&#xff0c;那么把X和Y…
阅读更多...
护网总结汇报PPT一键生成，还要啥售前工程师

护网总结汇报PPT一键生成，还要啥售前工程师

【文末送&#xff1a;技战法】 干技术的&#xff0c;特别是干安服的&#xff0c;你让我日个站觉得没问题&#xff0c;你让我写个文档我挠挠头&#xff0c;抓抓背也能凑一篇&#xff0c;但是你要让我写个ppt&#xff0c;那我觉得你在为难我。 报告我都写好了&#xff0c;为啥还…
阅读更多...
Eclipse Debug 配置

Eclipse Debug 配置

创建和使用 Debug 配置 Eclipse Debug 配置类似于运行配置但它是用于在调试模式下开启应用。 打开 Debug 配置对话框步骤为&#xff1a;Run > Debug Configurations 。 从左侧列表中选择 "Java Application" 选项来选择要调试的 Java 代码。 对话框中的描述信息…
阅读更多...
24年电赛——自动行驶小车（H题）MSPM0G3507-编码电机驱动与通用PID

24年电赛——自动行驶小车（H题）MSPM0G3507-编码电机驱动与通用PID

一、编码电机驱动 编码电机的详情可以查看此篇文章&#xff1a; stm32平衡小车--&#xff08;1&#xff09;JGB-520减速电机tb6612&#xff08;附测试代码&#xff09;_jgb520-CSDN博客 简单来说&#xff0c;编码电机的驱动主要是给一个 PWM 和一个正负级就能驱动。PWM 的大小…
阅读更多...
AI PC处理器架-低功耗、NPU算力、大模型

AI PC处理器架-低功耗、NPU算力、大模型

AI PC处理器架构变化&#xff1a;ARM低功耗、引入NPU算力、大模型落地端侧 ARM架构以简洁的指令集设计&#xff0c;快速执行每条命令&#xff0c;实现低功耗下的高效性能。其核心理念是节能和效率&#xff0c;为电池驱动设备提供了理想选择。相较之下&#xff0c;x86架构虽指令…
阅读更多...
Linux--shell脚本语言—/—＜1＞

Linux--shell脚本语言—/—＜1＞

一、shell简介 Shell是一种程序设计语言。作为命令语言&#xff0c;它交互式解释和执行用户输入的命令或者自动地解释和执行预先设定好的一连串的命令&#xff1b;作为程序设计语言&#xff0c;它定义了各种变量和参数&#xff0c;并提供了许多在高级语言中才具有的控制结构&am…
阅读更多...
【practise】大数相加、大数相乘

【practise】大数相加、大数相乘

通常&#xff0c;我们的int、long long类型都有最大的数字上限&#xff0c;也就是说再大了会有溢出问题&#xff0c;那么很大的数字是怎么进行运算的呢&#xff1f; 其中一种方法是把很大的数字转变成字符串存放到string中&#xff0c;然后用代码对字符串进行处理&#xff0c;…
阅读更多...
PHP最新可用获取QQ昵称API接口源码_非第三方

PHP最新可用获取QQ昵称API接口源码_非第三方

PHP最新可用获取QQ昵称API接口源码&#xff0c;运行环境为php7-8都可以&#xff0c;内容为直接调用QQ空间接口 在需要展示QQ昵称处&#xff0c;直接调用以下函数就可以。 例如&#xff1a;get_qq_nick(123456)就会直接输出123456的qq号昵称。 API源码下载&#xff1a;QQ昵称AP…
阅读更多...
【C语言】字符函数和字符串函数详解

【C语言】字符函数和字符串函数详解

&#x1f984;个人主页:小米里的大麦-CSDN博客 &#x1f38f;所属专栏:https://blog.csdn.net/huangcancan666/category_12718530.html &#x1f381;代码托管:黄灿灿 (huang-cancan-xbc) - Gitee.com ⚙️操作环境:Visual Studio 2022 目录 一、引言 内容一览 一、strlen …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023