关于string的‘\0‘与string，vector构造特点，反迭代器与迭代器类等的讨论

目录

问题一：关于string的''\0''问题讨论

问题二：C++标准库中的string内存是分配在堆上面吗？

问题三：string与vector的capacity大小设计的特点

问题四：string的流提取问题

问题五：迭代器失效

 问题六：Vector 最大 最小值 索引 位置

问题7：反迭代器的实现（包含迭代器类的介绍）

前言：

前几篇文章我们已经介绍完了string，vector，list的使用与string的使用原理，但是仅仅知道这些对于我们日常使用来说已经够了，但是在我们日常使用的时候，不免会有报错与相关的疑惑，那么这里我介绍几个我认为有问题的地方，后续有问题的话，还会继续补充。

问题一：关于string的''\0''问题讨论

之前在某篇文章中看到，C语言字符串是以'\0'结尾的，但是C++string类型的字符串并不是以'\0'结尾。话不多说，直接放代码（vsX86环境）：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string b("abc");
	cout << b.capacity() << endl;
	cout << b.size() << endl;

	if (b[3] == '\0')
		cout << "yes" << endl;
	else
		cout << "no" << endl;
	return 0;
}

运行结果：

.

可以看到我们创建的这个string，他的容器大小为15，这个string存储大小为3，但是我们却可以通过越界访问  b[3]   ，并且通过验证字符串的结尾就是'\0'。此时我的内心是疑惑的，心想"abc"是C语言风格的字符串给b构造，肯定会把"abc"后面影藏的'\0'给构造进去，如果不会这样就会在迭代器里面不会遇见结束表示符。那么至于这里的结尾的最后一个'\0'，从结果来说是大小size不计算的，所以大小size是3。

但是我们又尝试别的构造的话又会尝试别的疑惑，比如这个代码：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string b("abcd",3);//这种构造方法是通过字符串abcd，然后只取前3个字符进行构造string
	//但是这个字符串存放的其实是 abcd\0
	cout << b.capacity() << endl;
	cout << b.size() << endl;

	if (b[3] == '\0')
		cout << "yes" << endl;
	else
		cout << "no" << endl;
	return 0;
}

结果跟上面一模一样。此刻我又想，构造函数会在末尾自动添加一个'\0'，并且size和capacity函数都不计算'\0'的。

但是我们一开始是假设他跟c语言的风格相似的会把abc后面的'\0'会自动添加上，但是我们这个代码是只取了abcd\0这个字符串的前三个，没有'\0'啊~！

所以此刻，我肯定是矛盾的！！因为最开始说string字符串是不以'\0'结尾的，但是测试下来，确实是以'\0'结尾的。

哎呀~为什么呢？经过查阅资料后，才得知了其中的奥妙，奥妙如下：

std::string：标准中未明确规定需要\0作为字符串结尾。编译器在实现时既可以在结尾加\0，也可以不加。（因编译器不同，就比如vs就不用）

但是，当通过c_str()或data()（二者在 C++11 及以后是等价的）来把std::string转换为const char *时，会发现最后一个字符是\0。但是C++11，string字符串都是以'\0'结尾（这也是c++祖师爷为以前的自己的规定的优化）。

为什么C语言风格的字符串要以'\0'结尾，C++可以不要？

c语言用char*指针作为字符串时，在读取字符串时需要一个特殊字符0来标记指针的结束位置，也就是通常认为的字符串结束标记。而c++语言则是面向对象的，长度信息直接被存储在了对象的成员中，读取字符串可以直接根据这个长度来读取，所以就没必要需要结束标记了。而且结束标记也不利于读取字符串中夹杂0字符的字符串。

这里我们深入一下string的构造时的细节：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	int aa = 0;
	printf("栈区的地址：%p\n", &aa);
	int* pl = new int;
	printf("堆区的地址：%p\n", pl);
	string a("abcddddddddddddddddddddddddd", 20);
	printf("a的地址:    %p\n", &a);
	printf("a[0]的地址: %p\n", &a[0]);
	a[1] = 'X';
	cout << a << endl;
	printf("a的地址:    %p\n", &a);
	printf("a[0]的地址: %p\n", &a[0]);
	string b("abc");
	printf("b的地址:    %p\n", &b);
	printf("b[0]的地址: %p\n", &b[0]);
	return 0;
}

然后通过运行的知，

用红色标注出来的是在栈上存储的，蓝色标注的时在堆上存储的，然而a，b就与指针类似，他们指向一片空间，空间内存储的对象信息， 对象地址分别是006FF6AC与006FF688,他俩的地址跟栈区地址最为接近所以该对象存储在栈区上。同理a[0]是堆区上，但是b[0]按道理也应该是在堆区上，但是为什么会是是在栈区上呢？其实这是c++的一个特殊处理，这里留下一个小疑问，（下一个问题进行解答，这里先给出为什么的答案：当string内存存储的个数在16以内（包括'\0'）（后面解释为什么是16）在栈上，超过以后在堆上。）

所以，string在构造函数的时候，会在堆上开辟一块内存存放字符串，并且指向这块字符串。

（这里给大家提问一个小问题：就是为什么a先定义的，但是a对象地址为什么比b的大？）

解答：a、b是两个局部对象变量，栈是向下增长的，所以先入栈的变量地址高，即&a > &b，

问题二：C++标准库中的string内存是分配在堆上面吗？

例如我声明一个string变量。
string str;
一直不停的str.append("xxxxx");时，str会不停的增长。

我想问的是这个内存的增长，标准库中的string会把内存放置到堆上吗？

另外STL中的其他容器是否遵循相同的规则。

首先我们给出结论：16以内在栈上，超过以后在堆上。(这句话的答案省略上面的问题的前提条件：【在栈上构造的 string 对象】，如果string 是 new 出来的即在堆上构造的，当然内部的缓冲区总是在堆上的）。(vector也是如此，但是细节上略有不同）

为什么要这样做呢？

如果以动态增长来解释就是：

因为栈通常是一种具有固定大小的数据结构，如数组实现的栈在创建时会指定一个固定的容量。因此，一般情况下，栈是不支持动态增长的。 

所以是存储在堆上的。

其实还有另一个原因，那么下一个问题给出解答；

问题三：string与vector的capacity大小设计的特点

在我们设计string与vector的时候，你是否观察过他的capacity的大小呢？就比如vs里面为什么会让string与vector在其存储的内存个数小于16时会将数据存储在栈上，大于16存储在堆上呢？

这是因为string与vector第一次会在栈上开辟空间，直接开辟16个单位空间，然后挨个进行流提取，这样的话就会方便很多 ，就算要再添加数据，也不需要进行动态增长，然后这个16个单位空间就是string与vector的capacity。这里的证明可以通过调试自己查看他的capacity，当然编译器不同，可能这个首次开辟空间大小略有不同，但是不影响。

总的来说这两种解释都是解决的次要问题，他这样设计主要为了解决内存碎片的问题；如果存储的内容大小小于16，他就会先存在栈上的数组里面，当大于16，就会进行拷贝到堆上，然后栈上的数组就会进行浪费，这样达到了利用空间换时间的效果

问题四：string的流提取问题

首先如果我们自己实现string的流提取，我们会下意识认为会挨个提取输入的字符，然后挨个与s进行对接，代码试下如下： （这个代码实现的流提取是完全没有问题的）

istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

但是这样写会有一个弊端，就是会多次进行扩容，俗话常说：扩容本身就是一件麻烦的时，浅拷贝就不多说了，深拷贝就更麻烦了；

所以后来就进行了优化，会先开辟一个数组，然后将流提取的字符挨个放到数组里面，当数组满的时候（或者流提取的字符提取完了）我们当让s+=数组；这样既保证了存储的数据在堆上，也避免了多次进行扩容；（需要注意的是我们要自己添加 '\0' 在string的末尾）

	istream& operator>>(istream& in, string& s)
	{
		s.clear();

		char buff[129];
		size_t i = 0;
		char ch;
		//in >> ch;
		ch = in.get();
		s.reserve(128);

		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 128)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			//in >> ch;
			ch = in.get();
		}
		if (i != 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

当然这上面的两个问题都是存在于string于vector上的，因为他们存储的数据是连续的，二list作为链表就不存在这样的问题。 

问题五：迭代器失效

然而迭代器失效就不一样了，string，vector，list都存在。

在我们使用迭代器进行遍历的时候，不免会出现不正当的使用而使其迭代器失效；

失效的主要原因就是：迭代器对应的指针所指向的空间已经被销毁了，而使用一块已经被释放的空间的时候，就会造成程序崩溃(即如果继续使用已经失效的迭代器， 程序可能会崩溃)。俗话来说就是野指针了。

前面我们都在用string来进行解释，这里我们使用vector来解释，

1

就比如下面这个代码：

include<iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int> v(10, 1);
    auto it = v.begin();
    v.insert(it, 0);
    (*it)++;
    return 0;
}

看起来没有问题，但是我们是先给迭代器赋值，然后进行插入，但是有一点问题就是如果插入时恰好进行扩容，并且时异地扩容，那么这个it就会变为野指针。从而达到迭代器失效的问题。

2

同样插入存在异地扩容，当然删除也存在着迭代器失效的问题；

#include<iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int> v(10, 1);
    auto it = v.end() - 1;
    v.erase(it);
    (*it)++;
    return 0;
}

这时候如果再进行使用it，那么就会报错。

注意：

  1. vs 对于迭代器失效检查很严格，如使用了 erase 之后，之前的迭代器就不允许使用，只有重新给迭代器赋值，才可以继续使用
  2. Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

 问题六：Vector 最大 最小值 索引 位置

#include<iostream>
#include<vector>
using namespace std;

int main()
{
    vector<double> v{ 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0, 4.0, 5.0 };

    vector<double>::iterator biggest = max_element(begin(v), end(v));
    cout << "Max element is " << *biggest << " at position " << distance(begin(v), biggest) << endl;

    auto smallest = min_element(begin(v), end(v));
    cout << "min element is " << *smallest << " at position " << distance(begin(v), smallest) << endl;

    return 0;
}

运行结果：

问题7：反迭代器的实现

在上一篇文章中的list的迭代器是没有进行实现的，关于list的迭代器他的实现还是有点特殊的地方； 

迭代器类存在的意义

之前模拟实现string和vector时都没有说要实现一个迭代器类，为什么实现list的时候就需要实现一个迭代器类了呢？

因为string和vector对象都将其数据存储在了一块连续的内存空间，我们通过指针进行自增、自减以及解引用等操作，就可以对相应位置的数据进行一系列操作，因此string和vector当中的迭代器就是原生指针。

然而对于list的来说，他的每个结点的存储都不是连续的，是随机的，不可以像string，vector那样仅仅通过与简单的自增，自减以及进行解引用等操作对相应的结点做操作。 

而迭代器的意义就是，让使用者可以不必关心容器的底层实现，可以用简单统一的方式对容器内的数据进行访问。

既然list的结点指针的行为不满足迭代器定义，那么我们可以对这个结点指针进行封装，对结点指针的各种运算符操作进行重载，使得我们可以用和string和vector当中的迭代器一样的方式使用list当中的迭代器。就比如，当你使用list当中的迭代器进行自增操作时，实际上执行了p = p->next语句，只是你不知道而已，这一步迭代器替你进行了复杂的操作，这样就可以在各种操作上进行了统一。

总结： list迭代器类，实际上就是对结点指针进行了封装，对其各种运算符进行了重载，使得结点指针的各种行为看起来和普通指针一样。（例如，对结点指针自增就能指向下一个结点）

迭代器类的模板参数说明 

查阅相关std源文件库里面的设计，发现迭代器类的模板参数的设计为3个。

template<class T, class Ref, class Ptr>

这里就引发出来思考为什么要这样设计呢？

在list的模拟实现当中，我们typedef了两个迭代器类型，普通迭代器和const迭代器。

typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;

 这里我们就可以看出，迭代器类的模板参数列表当中的Ref和Ptr分别代表的是引用类型和指针类型

 当我们使用普通迭代器时，编译器就会实例化出一个普通迭代器对象；当我们使用const迭代器时，编译器就会实例化出一个const迭代器对象。

若该迭代器类不设计三个模板参数，那么就不能很好的区分普通迭代器和const迭代器。（换句话来说，按照与string与vector的思路来写list的const与非const迭代器再使用的时候会报错，编译器不知道走那个迭代器）

那么就再前面文章的基础上加上迭代器类吧。

template <class T>
struct list_node
{
	T _data;
	list_node<T>* _prev;
	list_node<T>* _next;
	list_node(const T& x = T())
		:_data(x)
		, _prev(nullptr)
		, _next(nullptr)
	{}
};
template<class T, class Ref, class Ptr>
struct __list_iterator 
{
	typedef list_node<T> Node;
	typedef __list_iterator<T, Ref, Ptr> self;
    Node* _node;		
    __list_iterator(Node* node)
			:_node(node)
		{}
}
class list
{
    typedef list_node<T> Node;
public:
    typedef __list_iterator<T, T&, T*> iterator;
    typedef __list_iterator<T,const T&,const T*> const_iterator;
    const_iterator begin() const
    {
    	return const_iterator(_head->_next);
    }
    const_iterator end() const
    {
    	return const_iterator(_head);
    }
    iterator begin()
    {
    	return _head->_next;
    }
    iterator end()
    {
    	return _head;
    }
private:
		Node* _head;
		size_t _size;
};

 我们们迭代器类的构造函数就是用我们传的结点参数来进行初始化。

 运算符重载需要注意要返回self就行

self是当前迭代器对象的类型：

介绍完迭代器类，下面就介绍反迭代器是怎么实现的吧；

同样反迭代器我们也需要设计一个反迭代器类；

但是反迭代器的实现由于正向迭代器实现的思路又有所不一样

其中他的成员变量是正向迭代器

大致如图所示：

template<class Iterator, class Ref, class Ptr>
class Reserve_iterator
{
	typedef Reserve_iterator<Iterator, Ref, Ptr> Self;

public:

	Reserve_iterator(Iterator it)
		:_it(it)
	{}
private:
	Iterator _it;
};

 同样他与正向迭代器一样，为了方便会进行typedef

rbegin与rend 

rbegin是其实是返回的end，rend其实是返回的begin，弄清楚这一点就比较好说了，只需要将begin传到反迭代器类的rendend传到反迭代器类的rbegin就可以了；

reserve_iterator rbegin()
{
	return reserve_iterator(end());
}
reserve_iterator rend()
{
	return reserve_iterator(begin());
}
const_reserve_iterator rbegin() const
{
	return const_reserve_iterator(end());
}
const_reserve_iterator rend() const
{
	return const_reserve_iterator(begin());
}
 operator++

对于反迭代器的++其实对应的就是正向迭代器的--

所以在实现的时候只需要进行减减就可以

	Self& operator++()
	{
		--_it;
		return *this;
	}

 这里返回的是引用其实很好理解，因为这里的++产生的效果是前置++，所以直接在原来的基础上进行操作就可以，返回进行返回引用；

 operator--

同样还有--，对应的也是正向迭代器的++，还是返回引用就可以

	Self& operator--()
	{
		++_it;
		return *this;
	}

 

这里就不一样了，一个是返回的ref一个是ptr，这是因为我们在开始的情况下 ，就将ref为引用，ptr为解引用。

到这里就完了，写作不易还请点赞；

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

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

相关文章

05_Shell索引数组

05_Shell索引数组

05_Shell索引数组 数组定义 #!/bin/basharr(1 2 3 "www.baidu.com")获取数组元素 #!/bin/basharr(1 2 3 "www.baidu.com")#通过下表获取元素 下标从1开始 ${arr[1]}#获取数组所有元素 ${arr[*]} 或者 ${arr[]}#获取数组长度 ${#arr[*]} 或者 ${#arr[*]}#获…
阅读更多...
LeetCode（2）合并链表、环形链表的约瑟夫问题、链表分割

LeetCode（2）合并链表、环形链表的约瑟夫问题、链表分割

一、合并链表 . - 力扣&#xff08;LeetCode&#xff09; 题目描述&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ typedef struct ListNode ListNode; struct ListNode* mergeTwoLists(struct …
阅读更多...
选择最佳工具：评估8款顶级App界面设计软件

选择最佳工具：评估8款顶级App界面设计软件

在如今的数字化时代&#xff0c;设计师也离不开各种界面设计软件来辅助自己的设计工作。在各种界面设计软件的帮助下&#xff0c;设计师们能够更好、更快地完成自己的设计工作。而今天本文要为大家推荐的这 8 款界面设计软件&#xff0c;分别是国产APP界面设计软件、Figma、Ske…
阅读更多...
【数据库】Redis主从复制、哨兵模式、集群

【数据库】Redis主从复制、哨兵模式、集群

目录 一、Redis的主从复制 1.1 主从复制的架构 1.2 主从复制的作用 1.3 注意事项 1.4 主从复制用到的命令 1.5 主从复制流程 1.6 主从复制实现 1.7 结束主从复制 1.8 主从复制优化配置 二、哨兵模式 2.1 哨兵模式原理 2.2 哨兵的三个定时任务 2.3 哨兵的结构 2.4 哨…
阅读更多...
校园外卖系统带万字文档在线外卖管理系统java项目java课程设计java毕业设计

校园外卖系统带万字文档在线外卖管理系统java项目java课程设计java毕业设计

文章目录 校园外卖系统一、项目演示二、项目介绍三、万字项目文档四、部分功能截图五、部分代码展示六、底部获取项目源码带万字文档&#xff08;9.9&#xffe5;带走&#xff09; 校园外卖系统 一、项目演示 校园外卖服务系统 二、项目介绍 语言&#xff1a;java 数据库&…
阅读更多...
ARM功耗管理标准接口之ACPI

ARM功耗管理标准接口之ACPI

安全之安全(security)博客目录导读 思考&#xff1a;功耗管理有哪些标准接口&#xff1f;ACPI&PSCI&SCMI&#xff1f; Advanced Configuration and Power Interface Power State Coordination Interface System Control and Management Interface ACPI可以被理解为一…
阅读更多...
2023年高教杯数学建模2023B题解析(仅从代码角度出发)

2023年高教杯数学建模2023B题解析(仅从代码角度出发)

前言 最近博主正在和队友准备九月的数学建模,在做往年的题目&#xff0c;博主主要是负责数据处理&#xff0c;运算以及可视化&#xff0c;这里分享一下自己部分的工作,相关题目以及下面所涉及的代码后续我会作为资源上传 问题求解 第一题 第一题的思路主要如下&#xff1a;…
阅读更多...
单链表--续（C语言详细版）

单链表--续（C语言详细版）

2.6 在指定位置之前插入数据 // 在指定位置之前插入数据 void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); 分为两种情况&#xff1a;1. 插入的数据在链表中间&#xff1b;2. 插入的数据在链表的前面。 // 在指定位置之前插入数据 void SLTInsert(SLTNode** …
阅读更多...
TISAX认证是什么？

TISAX认证是什么？

TISAX认证是一种针对汽车行业数据安全和隐私保护的评估认证&#xff0c;其全称在不同资料中有所差异&#xff0c;但普遍认可的是它作为汽车行业信息安全评估体系的重要性。以下是对TISAX认证的详细解读&#xff1a; 一、背景和目的 随着汽车技术的不断发展&#xff0c;汽车数…
阅读更多...
MySQL—统计函数和数学函数以及GROUP BY配合HAVING

MySQL—统计函数和数学函数以及GROUP BY配合HAVING

合计/统计函数 count -- 演示 mysql 的统计函数的使用 -- 统计一个班级共有多少学生&#xff1f; SELECT COUNT(*) FROM student -- 统计数学成绩大于 90 的学生有多少个&#xff1f; SELECT COUNT(*) FROM student WHERE math > 90 -- 统计总分大于 250 的人数有多少&…
阅读更多...
git-工作场景

git-工作场景

1. 远程分支为准 强制切换到远程分支并忽略本地未提交的修改 git fetch origin # 获取最新的远程分支信息 git reset --hard origin/feature_server_env_debug_20240604 # 强制切换到远程分支&#xff0c;并忽略本地修改 2. 切换分支 1. **查看所有分支&#xff1a;**…
阅读更多...
NewStarCTF2023-Misc

NewStarCTF2023-Misc

目录 week1 CyberChefs Secret 机密图片 流量&#xff01;鲨鱼&#xff01; 压缩包们 空白格 隐秘的眼睛 week2 新建Word文档 永不消逝的电波 1-序章 base! WebShell的利用 Jvav week3 阳光开朗大男孩 大怨种 2-分析 键盘侠 滴滴滴 week4 通大残 Nmap 依…
阅读更多...
buuctf被嗅探的流量

buuctf被嗅探的流量

下载出来是一个流量分析题 因为题目说了是联网状态下 嗅探到 所以一定有http协议 这里设置过滤器 一个一个去找吧 目前感觉wireshark的题都是http,太难的也不会
阅读更多...
最后纪元Last Epoch可以通过什么搬砖 游戏搬砖教程

最后纪元Last Epoch可以通过什么搬砖 游戏搬砖教程

来喽来喽&#xff0c;最后纪元&#xff0c;一款《最后纪元》是一款以获得战利品为基础的暗黑风格动作RPG游戏&#xff0c;玩家将从2281年的毁灭时代追溯到由女神Eterra创造的世界&#xff0c;通过多个时代与黑暗的命运对抗&#xff0c;找到拯救世界的方式。游戏有五种职业&…
阅读更多...
二叉平衡树（左单旋，右单旋，左右双旋、右左双旋）

二叉平衡树（左单旋，右单旋，左右双旋、右左双旋）

一、AVL树&#xff08;二叉平衡树&#xff1a;高度平衡的二叉搜索树&#xff09; 0、二叉平衡树 左右子树高度差不超过1的二叉搜索树。 public class AVLTree{static class AVLTreeNode {public TreeNode left null; // 节点的左孩子public TreeNode right null; // 节点的…
阅读更多...
【Unity2D 2022：NPC】制作NPC

【Unity2D 2022：NPC】制作NPC

一、创建NPC角色 1. 创建JambiNPC并同时创建Jambi站立动画 &#xff08;1&#xff09;点击第一张图片&#xff0c;按住shift不松&#xff0c;再选中后两张图片&#xff0c;拖到层级面板中 &#xff08;2&#xff09;将动画资源文件保存到Animation Clips文件夹中 &#xff08;…
阅读更多...
三维引擎实践 - OSG渲染线程创建过程（未完待续）

三维引擎实践 - OSG渲染线程创建过程（未完待续）

一&#xff1a;概述 一个3D应用程序&#xff0c;在创建好图形窗口之后&#xff0c;就要使用该窗口的OpenGL上下文进行渲染相关工作了&#xff0c;本节分析下OSG源码中渲染线程的建立过程。 二&#xff1a;OSG渲染线程用到了哪些类&#xff1f; 1. GraphicsThread 类&#xff0c…
阅读更多...
政安晨：【Keras机器学习示例演绎】（五十二）—— 使用门控残差和变量选择网络进行分类

政安晨：【Keras机器学习示例演绎】（五十二）—— 使用门控残差和变量选择网络进行分类

目录 简介 数据集 安装准备 数据准备 定义数据集元数据 创建用于训练和评估的 tf.data.Dataset 创建模型输入 对输入特征进行编码 实施门控线性单元 实施门控余留网络 实施变量选择网络 创建门控残差和变量选择网络模型 编译、训练和评估模型 政安晨的个人主页&am…
阅读更多...
怎么判断自己是否适合学习PMP？

怎么判断自己是否适合学习PMP？

判断自己是否适合学习PMP项目管理专业人士认证&#xff0c;可以从以下几个方面进行考量&#xff1a; 1、职业发展需求&#xff1a; 如果您在项目管理领域工作&#xff0c;或计划未来从事相关工作&#xff0c;PMP认证能显著提升您的竞争力。 对于项目经理、产品经理、技术领导…
阅读更多...
什么是边缘计算？创造一个更快、更智慧、更互联的世界

什么是边缘计算？创造一个更快、更智慧、更互联的世界

前言 如今&#xff0c;数十亿物联网传感器广泛部署在零售商店、城市街道、仓库和医院等各种场所&#xff0c;正在生成大量数据。从这些数据中更快地获得洞察&#xff0c;意味着可以改善服务、简化运营&#xff0c;甚至挽救生命。但要做到这一点&#xff0c;企业需要实时做出决策…
阅读更多...
最新文章

Copyright @ 2022~2023