STL —— list

news2025/1/17 1:46:42
图片名称

博主首页： 有趣的中国人

专栏首页： C++专栏

    本篇文章主要讲解 list模拟实现的相关内容

    １. list简介


    列表（list）是C++标准模板库（STL）中的一个容器，它是一个双向链表数据结构，用于存储元素。与vector不同，列表中的元素在内存中不是连续存储的，而是通过指针相互连接形成链表。这种设计使得列表对于插入和删除操作非常高效，但是在查找特定元素时相对较慢，因为需要按序遍历整个链表。

      ２. list模拟实现

      ２.１ list类的相关成员变量

      在C++的标准库中，list的实现方式是带头双向循环链表，因此在类中，我们需要一个头指针_head。至于每个节点，我们也同样需要构造一个类，其中成员变量包含_prev， _next和数据_val。

      template<class T>
struct ListNode
{
	ListNode<T>* _prev;
	ListNode<T>* _next;
	T _val;
	ListNode(const T& x = T())
		:_prev(nullptr)
		,_next(nullptr)
		,_val(x)
	{}
};
template<class T>
class list
{
public:
	typedef ListNode<T> Node;
	list()
	{
		_head = new Node;
		_head->_prev = _head;
		_head->_next = _head;
	}
private:
	Node* _head;
};

        ２.２ 尾插

        尾插太简单了，直接上代码：

        void push_back(const T& x)
{
	Node* newnode = new Node(x);
	Node* tail = _head->_prev;
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;
}

          ２.３ 迭代器

          在库中，我们不管迭代器的底层是如何实现的，但是我们都要用相同的方法使用迭代器，例如之前讲过的 vector，string，在g++中的实现方法就是原生指针，来实现例如＋＋、－－、＊等功能，但是这里list由于不是连续存储的，所以用原生指针正常的＋＋、－－等功能并不能达到我们的预期，因此我们可以把迭代器搞成一个类类型，并用运算符重载来改变它的功能。

          下面的代码是迭代器正常的使用方法，我们需要用运算符重载来实现这些功能： 
          void list_test1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

            2.3.1 迭代器类的成员变量

            迭代器类中其实就包含了一个指向结点类型的指针，因为我们的目的就是改变原生指针的相关操作，来实现迭代器相关的操作。
            代码如下：

            struct ListNodeIterator
{
	typedef ListNode<T> Node;
	Node* _node;
	ListNodeIterator(Node* node)
		:_node(node)
	{}
};

              2.3.2 迭代器类的实现

              template<class T>
struct ListNodeIterator
{
	typedef ListNode<T> Node;
	typedef ListNodeIterator<T> Self;
	Node* _node;
	ListNodeIterator(Node* node)
		:_node(node)
	{}
	T& operator*()
	{
		return _node->_val;
	}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
};

                2.3.3 insert 和 erase

                insert和erase传的参数就是iterator，模拟实现代码如下：

                void insert(iterator pos, const T& x)
{
	Node* newnode = new Node(x);
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
}
void erase(iterator pos)
{
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* next = cur->_next;
	prev->_next = next;
	next->_prev = prev;
	delete cur;
	cur = nullptr;
}
                这里需要注意，在erase的时候由于迭代器指向的空间被释放了，会导致迭代器失效的问题，之前的文章讲过相关的内容，因此我们需要更新iterator，指向被删除的位置的下一个位置即可，代码如下： 
                iterator erase(iterator pos)
{
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* next = cur->_next;
	prev->_next = next;
	next->_prev = prev;
	delete cur;
	cur = nullptr;
	return next;
}

                  2.3.4 begin 和 end

                  begin 和 end是在迭代器中的成员函数，返回头和尾的迭代器即可：

                  typedef ListNodeIterator<T> iterator;
iterator begin()
{
	return iterator(_head->_next);
	// 单参数类型的构造函数支持隐式类型转换，以下依法也可以：
	// return _head->_next;
}
iterator end()
{
	return iterator(_head);
	// return _head;
}

                    2.3.5 insert 和 erase的复用

                    push＿back、push＿front、pop＿back、pop＿front都可以复用insert和erase，代码如下：

                    void push_back(const T& x)
{
	/*Node* newnode = new Node(x);
	Node* tail = _head->_prev;
	tail->_next = newnode;
	newnode->_prev = tail;
	newnode->_next = _head;
	_head->_prev = newnode;*/
	insert(end(), x);
}
void pop_back()
{
	erase(--end());
}
void push_front(const T& x)
{
	insert(begin(), x);
}
void pop_front()
{
	erase(begin());
}

                    测试代码：

                    void list_test1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	lt.pop_back();
	lt.pop_back();
	it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	lt.push_front(100);
	lt.push_front(200);
	lt.push_front(300);
	it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	lt.pop_front();
	lt.pop_front();
	it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

                    在这里插入图片描述

                      2.3.5 operator->的重载

                      • 先看一下这段代码：
                      void list_test2()
{
	struct A
	{
		int _a1;
		int _a2;
		A(int a1 = 0, int a2 = 0)
			:_a1(a1)
			,_a2(a2)
		{}
	};
	list<A> lt;
	A a(1, 2);
	lt.push_back(a);
	lt.push_back(A(3, 4));
	lt.push_back({ 5,6 });
	list<A>::iterator it = lt.begin();
	while (it != lt.end())
	{
		／／　主要看这里
		cout << (*it)._a1 << " " << (*it)._a2 << " ";
		cout << endl;
		++it;
	}
}

                      我们注意到当我们访问自定义类型的数据需要这样：(*it)._a1进行访问，但是迭代器就是为了模仿指针的相关操作，例如我们有A*这种类型的指针如何进行访问A中的数据呢？

                      A* aa;
(*aa)._a1;
／／　上面的方法很别扭，我们正常用指针都是用－＞访问的，所以我们如何实现－＞的重载呢？
aa->_a1;
                      • 实现方法如下：
                      T* operator->()
{
	return &_node->_val;
}

                      为什么这样就行了呢，我们知道自定义类型Ａ存储在了节点的＿val中，这里返回了＿val的地址，如果按照正常的思路进行访问，应该按照如下的方式：

                      • cout << it.operator->()->_a1 << " " << it.operator->()->_a2 << " ";

                      所以应该有两个箭头：第一个箭头代表运算符的重载，第二个代表指针解引用访问数据：

                      • cout << it->->_a1 << " " << it->->_a2 << " ";

                      但是编译器进行了简化，两个箭头变成了一个箭头

                      • cout << it->_a1 << " " << it->_a2 << " ";

                      `

                      void list_test2()
{
	struct A
	{
		int _a1;
		int _a2;
		A(int a1 = 0, int a2 = 0)
			:_a1(a1)
			,_a2(a2)
		{}
	};
	/*A* aa;
	(*aa)._a1;
	aa->_a1;*/
	list<A> lt;
	A a(1, 2);
	lt.push_back(a);
	lt.push_back(A(3, 4));
	lt.push_back({ 5,6 });
	list<A>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << (*it)._a1 << " " << (*it)._a2 << " ";
		cout << it.operator->()->_a1 << " " << it.operator->()->_a2 << " ";
		//cout << it->->_a1 << " " << it->->_a2 << " ";
		cout << it->_a1 << " " << it->_a2 << " ";
		
		cout << endl;
		++it;
	}
}

                      在这里插入图片描述

                        ２.４ const迭代器

                        • 我们先看以下这段代码：
                        void Print(const list<int>& lt)
{
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void list_test3()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(1);
	lt.push_back(8);
	lt.push_back(6);
	lt.push_back(0);
	Print(lt);
}
                        • 很明显，会报错，提示不能从const转换为非const：

                        在这里插入图片描述

                        • 很多人可能会想着在begin和end后加上const进行修饰，但其实也不行，这样虽然传入的值是const类型，但是返回的值不是const类型，就会导致返回的值能被修改，但是要求是返回的值是const类型，所以这种想法是不行的，下面是错误的示范：
                        iterator begin() const
{
	return iterator(_head->_next);
	// 单参数类型的构造函数支持隐式类型转换，以下写法也可以：
	// return _head->_next;
}
iterator end() const
{
	return iterator(_head);
	// return _head;
}
void Print(const list<int>& lt)
{
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		／／　这里可以修改
		*it += 10;
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void list_test3()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(1);
	lt.push_back(8);
	lt.push_back(6);
	lt.push_back(0);
	Print(lt);
}

                        在这里插入图片描述

                        • 那应该如何解决呢？在此之前，我们需要了解一下这段代码：
                        const iterator begin() 
{
	return iterator(_head->_next);
	// 单参数类型的构造函数支持隐式类型转换，以下写法也可以：
	// return _head->_next;
}
const iterator end() 
{
	return iterator(_head);
	// return _head;
}
                        • 当我们在返回值前加上const，代表返回的迭代器不能被修改，例如不能进行＋＋it；
                        • 但是我们是想着迭代器指向的内容不能被修改，因此这种方法是不可行的。
                        • 可以类比一下这段代码：
                        // const修饰的是解引用之后的内容
const int* a；
// const修饰的是指针本身
int* const a；
                        • 解决方法其实很简单，之前说过既然不满足要求，那我们就自己造轮子，自己写一个类；
                        • 这个类其实也很简单，就把ListNodeIterator这个类中的两个运算符重载函数的返回值改变一下就可以了，一个是＊，另一个是－＞：
                        template<class T>
struct ListNodeConstIterator
{
	typedef ListNode<T> Node;
	typedef ListNodeConstIterator<T> Self;
	Node* _node;
	ListNodeConstIterator(Node* node)
		:_node(node)
	{}
	const　T& operator*()
	{
		return _node->_val;
	}
	const　T* operator->()
	{
		return &_node->_val;
	}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}

	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
};

                        在list类中加入这两个函数：

                        const_iterator begin() const
{
	return const_iterator(_head->_next);
	// 单参数类型的构造函数支持隐式类型转换，以下写法也可以：
	// return _head->_next;
}

const_iterator end() const
{
	return const_iterator(_head);
	// return _head;
}
                        • 这时候就不能修改了

                        在这里插入图片描述
                        在这里插入图片描述

                          ２.５ 模板的作用

                          我们发现，在两个迭代器中，只用两个函数的返回值不同，其他的全部都一样，看上去非常冗余，那我们可不可以用一种方法来解决这种冗余呢？肯定是可以的，我们这个时候就可以用到模板：

                          template<class T, class Ref, class Ptr>
struct ListNodeIterator
{
	typedef ListNode<T> Node;
	typedef ListNodeIterator<T, Ref, Ptr> Self;
	Node* _node;
	ListNodeIterator(Node* node)
		:_node(node)
	{}
	Ref operator*()
	{
		return _node->_val;
	}
	Ptr operator->()
	{
		return &_node->_val;
	}
	Self& operator++()
	{
		_node = _node->_next;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}
	Self& operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}

	bool operator!=(const Self& it)
	{
		return _node != it._node;
	}
};
template<class T>
class list
{
public:
	typedef ListNode<T> Node;
	typedef ListNodeIterator<T, T&, T*> iterator;
	typedef ListNodeIterator<T,const T&, const T*> const_iterator;
	iterator begin() 
	{
		return iterator(_head->_next);
		// 单参数类型的构造函数支持隐式类型转换，以下写法也可以：
		// return _head->_next;
	}
	iterator end() 
	{
		return iterator(_head);
		// return _head;
	}

	const_iterator begin() const
	{
		return const_iterator(_head->_next);
		// 单参数类型的构造函数支持隐式类型转换，以下写法也可以：
		// return _head->_next;
	}

	const_iterator end() const
	{
		return const_iterator(_head);
		// return _head;
	}
	／／　．．．．．．
};

                          这里虽然只写了一份iterator类，但是在编译的时候，编译器会根据你的需要生成两份iterator类，所以模板很强大。

                            ３. 拷贝构造、赋值重载、析构

                            ３.１　析构函数

                            • 析构函数释放掉空间即可，记住更新一下迭代器。
                            void clear()
{
	iterator it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}

~list()
{
	clear();
	delete _head;
	_head = nullptr;
}

                            ３.２　拷贝构造

                            • 拷贝构造新建一个头节点，然后尾插。
                            void empty_init()
{
	_head = new Node;
	_head->_prev = _head;
	_head->_next = _head;
}

list(const list<T>& lt)
{
	empty_init();
	for (auto& e : lt)
	{
		push_back(e);
	}
}

                            ３.３　赋值重载

                            • 赋值重载现代写法，之前讲过类似的方法：
                            void swap(list<T>& lt)
{
	std::swap(_head, lt._head);
}

list<int>& operator=(list<T> lt)
{
	swap(lt);
	return *this;
}

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

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

                            相关文章

                            容器安全的防护之道

                            容器安全的防护之道

                            随着云计算的发展&#xff0c;云原生技术已经成为企业数字化转型的得力武器&#xff0c;如何保障容器安全&#xff0c;已成为企业最关心的问题。为此&#xff0c;德迅蜂巢原生安全平台由德迅云安全自主研发&#xff0c;能够很好集成到云原生复杂多变的环境中&#xff0c;如PaaS…
                            阅读更多...
                            【STL】栈

                            【STL】栈

                            笔者在做下面这道题的时候想到用栈&#xff0c;但写的很麻烦 代码&#xff1a; #include<bits/stdc.h> using namespace std; #define MAXC 255 typedef int SElemType; typedef struct StackNode {SElemType data;struct StackNode *next; }StackNode,*LinkStack; bool…
                            阅读更多...
                            【数据结构与算法】：直接插入排序和希尔排序

                            【数据结构与算法】：直接插入排序和希尔排序

                            1. 排序的概念及其意义 1.1 排序的概念 所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 1.2 排序的稳定性 假定在待排序的记录序列中&#xff0c;存在多个具有相同的关键字的记录&#xff0c;若…
                            阅读更多...
                            电商系列之风控安全

                            电商系列之风控安全

                            > 插&#xff1a;AI时代&#xff0c;程序员或多或少要了解些人工智能&#xff0c;前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。 坚持不懈&#xff0c;越努力越幸运&#xff0c;大家…
                            阅读更多...
                            243.回文链表

                            243.回文链表

                            给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为 回文链表 。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true示例 2&#xff1a; 输入&#xff1a;head …
                            阅读更多...
                            初始Java篇（JavaSE基础语法）（6）（继承和多态）（上）

                            初始Java篇（JavaSE基础语法）（6）（继承和多态）（上）

                            Java学习篇 个人主页&#xff08;找往期文章包括但不限于本期文章中不懂的知识点&#xff09;&#xff1a;我要学编程(ಥ_ಥ)-CSDN博客 目录 继承篇 为什么需要继承&#xff1f; 继承概念 继承的语法 父类成员访问 super关键字 子类构造方法 super和this的比较 再谈…
                            阅读更多...
                            CLoVe:在对比视觉语言模型中编码组合语言

                            CLoVe:在对比视觉语言模型中编码组合语言

                            CLoVe:在对比视觉语言模型中编码组合语言 摘要引言相关工作CLoVe: A Framework to Increase Compositionality in Contrastive VLMsSynthetic CaptionsHard NegativesModel Patching CLoVe: Encoding Compositional Language inContrastive Vision-Language Models 摘要 近年来…
                            阅读更多...
                            Spark 部署与应用程序交互简单使用说明

                            Spark 部署与应用程序交互简单使用说明

                            文章目录 前言步骤一&#xff1a;下载安装包Spark的目录和文件 步骤二&#xff1a;使用Scala或PySpark Shell本地 shell 运行 步骤3:理解Spark应用中的概念Spark Application and SparkSessionSpark JobsSpark StagesSpark Tasks 转换、立即执行操作和延迟求值窄变换和宽变换 S…
                            阅读更多...
                            【.Net】Polly

                            【.Net】Polly

                            文章目录 概述服务熔断、服务降级、服务限流、流量削峰、错峰、服务雪崩Polly的基本使用超时策略悲观策略乐观策略 重试策略请求异常响应异常 降级策略熔断策略与策略包裹&#xff08;多种策略组合&#xff09; 参考 概述 Polly是一个被.NET基金会支持认可的框架&#xff0c;同…
                            阅读更多...
                            使用Flutter创建带有图标提示的TextField

                            使用Flutter创建带有图标提示的TextField

                            在移动应用开发中&#xff0c;TextField是一种常用的用户输入小部件。然而&#xff0c;有时向用户提供有关他们应该输入什么的提示或说明是很有帮助的。在本教程中&#xff0c;我们将创建一个Flutter应用程序&#xff0c;演示如何在TextField旁边包含一个图标提示。 编写代码 …
                            阅读更多...
                            C语言计算任意位数的水仙花数

                            C语言计算任意位数的水仙花数

                            一、水仙花数定义&#xff1a; 水仙花数&#xff08;Narcissistic number&#xff09;是指一个 n&#xff08;n≥3&#xff09; 位数&#xff0c;它的每个数位上的数字的 n 次幂之和等于它本身。例如 3 位数的 153&#xff1a;1 5 3 153 二、C语言计算任意位数的水仙花数代…
                            阅读更多...
                            第十三届蓝桥杯C++A组 - B/D/E

                            第十三届蓝桥杯C++A组 - B/D/E

                            文章目录 前言一、灭鼠先锋1.题目描述2.算法 二、选数异或1.题目描述2.算法 三、爬树的甲壳虫1.问题描述2.算法 前言 题目考点灭鼠先锋bfs博弈论MEX运算SG函数选数异或二分线段树爬树的甲壳虫快速幂逆元扩展欧几里得裴蜀定理dp 一、灭鼠先锋 1.题目描述 2.算法 我们先要确定…
                            阅读更多...
                            顺序表的应用

                            顺序表的应用

                            文章目录 目录1. 基于动态顺序表实现通讯录项目2.顺序表经典算法2.1 [移除元素](https://leetcode.cn/problems/remove-element/description/)2.2 [合并两个有序数组](https://leetcode.cn/problems/merge-sorted-array/description/) 3. 顺序表的问题及思考 目录 基于动态顺序…
                            阅读更多...
                            华为CCE部署RabbitMQ中间件操作文档

                            华为CCE部署RabbitMQ中间件操作文档

                            1、创建有状态&#xff08;StatefulSet&#xff09;部署 中间件一般为有状态部署&#xff0c;有状态部署与无状态部署区别参考文档&#xff1a;K8S有无状态部署-CSDN博客 1.1、基本信息 注意&#xff1a; 应用名称命名规则&#xff1a;&#xff08;命名规则最好统一&#xff…
                            阅读更多...
                            深入理解计算机系统 家庭作业 2.85

                            深入理解计算机系统 家庭作业 2.85

                            A 7111.01.11*V E2,M1.11,f0.11 位表示: exp:10000...001其中0有k-2个.frac:1100...000其中0有n-2个 B 有个默认条件就是E>n, En,M1.111...(小数部分n个1),f0.1111(n个1),V exp:111...11其中1有n-1个.frac:111...111其中1有n个 C有个默认条件就是没有符号位.最小的规格…
                            阅读更多...
                            轻量的 WebHook 工具：歪脖虎克

                            轻量的 WebHook 工具：歪脖虎克

                            本篇文章聊聊轻量的网络钩子&#xff08;WebHook&#xff09;工具&#xff1a;歪脖虎克。 写在前面 这是一篇迟到很久的文章&#xff0c;在 21 年和 22 年的时候&#xff0c;我分享过两篇关于轻量的计划任务工具 Cronicle 的文章&#xff1a;《轻量的定时任务工具 Cronicle&a…
                            阅读更多...
                            EFK(elasticsearch+filebeat+kibana)日志分析平台搭建

                            EFK(elasticsearch+filebeat+kibana)日志分析平台搭建

                            本文是记录一下EFK日志平台的搭建过程 项目背景&#xff1a; 此次搭建的日志分析平台主要是采集服务器上的java服务的log日志(输出的日志已经是json格式)&#xff0c;这些日志都已经按照不同环境输出到/home/dev /home/test1 /home/test2 目录下了&#xff0c;按照不同的应…
                            阅读更多...
                            具身智能机器人实现新里程碑！新型3D世界模型问世

                            具身智能机器人实现新里程碑！新型3D世界模型问世

                            随着人工智能技术的不断进步&#xff0c;视觉-语言-动作&#xff08;VLA&#xff09;模型在机器人控制、自动驾驶、智能助手等领域展现出了广阔的应用前景。这类模型能够将视觉、语言、动作等多模态信息进行融合&#xff0c;实现从感知到决策的端到端学习。然而&#xff0c;现有…
                            阅读更多...
                            商业开源MES+源码+可拖拽式数据大屏

                            商业开源MES+源码+可拖拽式数据大屏

                            商业开源的一套超有价值的JAVA制造执行MES系统源码 带本地部署搭建教程 教你如何在本地运行运行起来。 开发环境&#xff1a;jdk11tomcatmysql8springbootmaven 需要源码&#xff0c;私信我付费获取。 一、系统概述&#xff1a; 万界星空科技免费试用MES、开源MES、商业开…
                            阅读更多...
                            SAR教程系列7——在cadence中用Spectrum工具FFT仿真ADC的ENOB、SNR等动态性能指标

                            SAR教程系列7——在cadence中用Spectrum工具FFT仿真ADC的ENOB、SNR等动态性能指标

                            首先在仿真之前&#xff0c;你得有一个ADC。然后是思考如何仿真的问题&#xff0c;如何加激励&#xff0c;如何使用相关工具查看仿真结果。假定你有一个可以仿真的ADC&#xff0c;大致经过下列步骤可以得到ADC的相关动态性能指标。 第一步&#xff1a;在ADC后面接一个理想的DA…
                            阅读更多...
                            推荐文章
                            最新文章

                            Copyright @ 2022~2023