【十四】【C++】list 的常见用法

news2024/11/16 16:28:51

list 的初始化和遍历

 
/*list的初始化和遍历*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;

void TestList1()
 {
    list<int> L1;
    list<int> L2(10, 5);
    
     vector<int> v{1,2,3,4,5};
    
     list<int> L3(v.begin(), v.end());
    
     list<int> L4(L3);
    
     // C++11
    list<int> L5{ 1, 2, 3, 4, 5 };
    
     /
    // 链表遍历
    for (auto e : L2)
        cout << e << " ";
    cout << endl;
    
     // list<int>::iterator it = L3.begin();
    auto it = L3.begin();
    while (it != L3.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    
     auto rit = L4.rbegin();
    while (rit != L4.rend())
    {
        cout << *rit << " ";
        ++rit;
    }
    cout << endl;
    
     // 注意：list不能使用原生态指针，即Node*来遍历链表
    // 因为list没有提供获取头指针的方法
}

int main(){
    TestList1();
 }
#endif

d96b97f6d3ee43cabc19248b44f8e51e.png

std::list 是一个双向链表，提供了双向序列的特性，包括有效地进行插入、删除操作等，但不支持随机访问。

初始化 std::list

空初始化： list<int> L1; 创建了一个空的 int 类型的 list。

填充初始化： list<int> L2(10, 5); 创建了一个包含 10 个元素，每个元素都初始化为 5 的 list。

范围初始化： list<int> L3(v.begin(), v.end()); 使用 vector<int> v 的迭代器范围来初始化 L3，即将 v 中的元素复制到 L3 中。

拷贝初始化： list<int> L4(L3); 使用另一个 list L3 来初始化 L4，复制 L3 的所有元素。

列表初始化 （C++11）: list<int> L5{ 1, 2, 3, 4, 5 }; 使用初始化列表直接初始化 L5。

链表遍历

范围 for 循环： 使用范围 for 循环遍历 L2，打印出其所有元素。这是 C++11 引入的一种简洁的遍历容器的方式。

使用迭代器： 通过迭代器 it 遍历 L3，同样打印出所有元素。std::list 提供的迭代器是双向迭代器。

使用反向迭代器： 通过反向迭代器 rit 遍历 L4，但这次是逆序打印出所有元素。反向迭代器从容器的末尾开始遍历至开始。

注意

代码中提到，“list不能使用原生态指针，即 Node*来遍历链表”，这是因为 std::list 的实现细节被抽象化了，用户无法像操作普通链表那样通过节点指针进行遍历或访问。std::list 提供了迭代器来抽象这些细节，使得操作更安全、更容易。

list 的 resize 操作探究

 
/*list的resize操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;

void TestList2()
 {
    list<int> L{ 1, 2, 3, 4, 5 };
    cout << L.size() << endl;
    
     L.resize(10, 6);
    for (auto e : L)
        cout << e << " ";
    cout << endl;
    
     L.resize(20);
    for (auto e : L)
        cout << e << " ";
    cout << endl;
    
     L.resize(7);
    for (auto e : L)
        cout << e << " ";
    cout << endl;
 }

int main(){
    TestList2();
 }
#endif

 

2f7e5c580ed04fe684331efa3a9b5b34.png

resize 方法用于调整链表的大小，即元素的数量。以下是对 TestList2 函数中各个操作的详细解释：

初始化 std::list

list<int> L{ 1, 2, 3, 4, 5 };

使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list。

调整大小并填充新元素

L.resize(10, 6);

调整 L 的大小至 10 个元素。由于新大小大于当前大小，resize 方法会添加额外的元素。在这个例子中，新增的元素被初始化为 6。因此，调整后的 list 包含元素 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6}。

再次调整大小，使用默认值填充

L.resize(20);

这次 L 的大小被调整至 20 个元素。因为没有指定新元素的初始化值，新增的元素会被默认初始化。对于整数类型，这意味着它们被初始化为 0。现在，list 包含 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}。

减少 list 的大小

L.resize(7);

L 的大小被减少至 7 个元素。resize 方法会移除超出新大小的元素。因此，list 现在包含 {1, 2, 3, 4, 5, 6, 6}。

在每次调整大小之后，代码通过一个范围 for 循环遍历 L 并打印其所有元素，这样可以直观地看到 resize 操作的结果。

list 的插入删除操作探究

 
/*list的插入删除操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;


void TestList3()
 {
    list<int> L{ 1, 2, 3, 4, 5 };
    L.push_back(6);
    L.push_back(7);
    L.push_back(8);
    L.push_back(9);
    cout << L.size() << endl;
    cout << L.front() << endl;
    cout << L.back() << endl;
    
     L.pop_back();
    L.pop_back();
    for (auto e : L)
        cout << e << " ";
    cout << endl;
    
     L.push_front(0);
    for (auto e : L)
        cout << e << " ";
    cout << endl;
    
     L.pop_front();
    for (auto e : L)
        cout << e << " ";
    cout << endl;
    
     L.insert(L.begin(), 0);
    
     auto pos = find(L.begin(), L.end(), 5);
    if (pos != L.end())
        L.insert(pos, 5, 8);
    
     int array[] = { 10, 20, 30, 40, 50 };
    
     L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));
 }

int main(){
    TestList3();
 }
#endif

80797022737a47aab4aa8bccc651420f.png

std::list 是一个双向链表，支持在任何位置高效插入和删除元素。

初始化 std::list

list<int> L{ 1, 2, 3, 4, 5 };

使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的链表 L。

添加元素到链表尾部

通过 push_back 方法，在链表的尾部依次添加了元素 6、7、8 和 9。

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

这些操作将 L 扩展为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。

移除链表尾部的元素

通过 pop_back 方法移除了链表尾部的两个元素（8 和 9）。

L.pop_back();

L.pop_back();

L 现在包含 {1, 2, 3, 4, 5, 6, 7}。

在链表头部添加元素

通过 push_front 方法在链表的头部添加了元素 0。

L.push_front(0);

L 现在包含 {0, 1, 2, 3, 4, 5, 6, 7}。

移除链表头部的元素

通过 pop_front 方法移除了链表头部的元素 0。

L.pop_front();

L 恢复为 {1, 2, 3, 4, 5, 6, 7}。

在链表特定位置插入元素

首先，在链表的开始位置插入元素 0。

L.insert(L.begin(), 0);

然后，找到元素 5 的位置，并在该位置前插入五个 8。

auto pos = find(L.begin(), L.end(), 5);

if (pos != L.end())

L.insert(pos, 5, 8);

这使得 L 变为 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7}。

从数组中插入多个元素

通过 insert 方法，将一个整型数组 {10, 20, 30, 40, 50} 的所有元素插入到链表的末尾。

int array[] = { 10, 20, 30, 40, 50 };

L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));

这将数组中的元素添加到了 L 的末尾，使得 L 最终包含 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7, 10, 20, 30, 40, 50}。

list 的 erase、assign 操作探究

 
/*list的erase、assign操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include<algorithm>
using namespace std;


void TestList4()
 {
    list<int> L{ 1, 2, 3, 4, 5 };
    L.push_back(6);
    L.push_back(7);
    L.push_back(8);
    L.push_back(9);
    
     L.erase(L.begin());
    L.erase(find(L.begin(), L.end(), 8));
    L.erase(L.begin(), L.end());    // clear();
    
     L.assign(10, 5);
    
     int array[] = { 10, 20, 30, 40, 50 };
    L.assign(array, array + sizeof(array) / sizeof(array[0]));
 }

int main(){
    TestList4();
 }
#endif

803b55a31497485bb33cd62aa394bea5.png

初始链表的创建和元素添加

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

首先，通过初始化列表创建一个包含 {1, 2, 3, 4, 5} 的 list，然后依次添加元素 6、7、8 和 9 到链表的末尾，使得链表变为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。

删除链表中的元素

L.erase(L.begin());

删除链表的第一个元素（1）。此时链表变为 {2, 3, 4, 5, 6, 7, 8, 9}。

L.erase(find(L.begin(), L.end(), 8));

使用 find 函数查找值为 8 的元素，并将其删除。此时链表变为 {2, 3, 4, 5, 6, 7, 9}。

L.erase(L.begin(), L.end()); // clear();

删除链表中从开始到结束的所有元素，相当于清空整个链表。这行代码实际上清空了链表，使其不包含任何元素。

重新分配链表内容

L.assign(10, 5);

assign 方法用于将链表的内容替换为指定数量（这里是 10）的重复元素（这里是 5）。执行这个操作后，链表包含了 10 个值为 5 的元素。

使用数组重新分配链表内容

int array[] = { 10, 20, 30, 40, 50 };

L.assign(array, array + sizeof(array) / sizeof(array[0]));

再次使用 assign 方法，但这次是用数组的元素来重新分配链表的内容。通过计算数组的大小，将整个 array 的内容赋值给链表 L。执行这个操作后，链表的内容变为 {10, 20, 30, 40, 50}。

list 的 remove、sort、unique、reverse 操作探究

 
/*list的remove、sort、unique、reverse操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
void TestList5() {
    list<int> L{ 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 1, 1};
    L.remove(1);

    L.sort();

    L.unique();

    L.reverse();
 }

int main() {
    TestList5();
 }
#endif

626de949630242159a936d7e9536fb00.png

初始链表的创建

list<int> L{ 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 1, 1};

首先，通过初始化列表创建了一个包含重复元素的 list。

删除特定元素

L.remove(1);

remove 方法从链表中删除所有值为 1 的元素。执行这个操作后，链表中所有的 1 被移除，链表变为 {2, 3, 4, 5, 2, 3, 4, 5}。

对链表进行排序

L.sort();

sort 方法对链表中的元素进行排序。std::list 提供了自己的 sort 成员函数，因为标准算法库中的 std::sort 需要随机访问迭代器，而 list 只提供双向迭代器。排序后，链表变为 {2, 2, 3, 3, 4, 4, 5, 5}。

移除连续重复的元素

L.unique();

unique 方法移除链表中连续重复的元素，只保留了每组重复元素中的第一个元素。在排序后的链表中应用 unique，会移除所有的连续重复项，链表变为 {2, 3, 4, 5}。

反转链表

L.reverse();

reverse 方法将链表中的元素反向排列。执行这个操作后，链表中的元素顺序被反转，即 {5, 4, 3, 2}。

list 的 remove_if 操作探究

 
/*list的remove_if操作探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

bool IsEven(int data) {
    // 5的二进制：0000 0101
    //          0000 0001
    // return 0 == (data & 0x01);
    return 0 == data % 2;
 }



void TestList6() {
    list<int> L{ 1, 2, 3, 4, 5 };
    L.push_back(6);
    L.push_back(7);
    L.push_back(8);
    L.push_back(9);

    L.remove_if(IsEven);
 }

int main() {
    TestList6();
 }
#endif

3fa71dc98de64517ae95790ce1adf394.png

remove_if 方法允许用户指定一个谓词（一个返回布尔值的函数或函数对象），根据这个谓词来决定哪些元素应该被移除。

定义判定函数

bool IsEven(int data) {

return 0 == data % 2;

}

这个函数 IsEven 检查给定的整数是否为偶数。如果是偶数，返回 true；否则返回 false。

初始化 std::list 并添加元素

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

首先，通过初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list，然后依次添加了元素 6、7、8 和 9 到链表的末尾。

使用 remove_if 根据条件移除元素

L.remove_if(IsEven);

remove_if 方法接受一个谓词函数 IsEven 作为参数，并移除 L 中所有使得 IsEven 返回 true 的元素。在这个例子中，它会移除链表中所有的偶数。

执行 remove_if 之后，原始链表 {1, 2, 3, 4, 5, 6, 7, 8, 9} 中的偶数元素被移除，留下了 {1, 3, 5, 7, 9}。

list 的迭代器失效探究

 
/*list的迭代器失效探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void TestList7() {
    list<int> L{ 1, 2, 3, 4, 5 };
    L.push_back(6);
    L.push_back(7);
    L.push_back(8);
    L.push_back(9);

//1
    auto it = L.begin();
    L.pop_front();
    while (it != L.end())
    {
        cout << *it << " ";
        ++it;
    }
//2
    L.resize(0);
    while (it != L.end())
    {
        cout << *it << " ";
        ++it;
    }
//3
    L.assign(10, 5);
    list<int> L1{ 10, 20, 30, 40, 50 };
    L = L1;

    while (it != L.end())
    {
        cout << *it << " ";
        ++it;
    }
//4
    while (it != L.end()) {
        // L.erase(it);
        // ++it;
        it = L.erase(it);
    }
 }

int main() {
    TestList7();
 }
#endif

 

 

初始化列表和添加元素

list<int> L{ 1, 2, 3, 4, 5 };

L.push_back(6);

L.push_back(7);

L.push_back(8);

L.push_back(9);

这段代码初始化了一个包含 {1, 2, 3, 4, 5, 6, 7, 8, 9} 的 list。

删除链表的第一个元素

auto it = L.begin();

L.pop_front();

it 初始化为指向链表的第一个元素。随后，pop_front() 删除了链表的第一个元素。由于 it 此时指向的元素被删除，it 的状态变得未定义，导致迭代器失效。正确的做法是在删除操作之后重新获取 begin() 的迭代器。

52eb30ebdd304006b957ee71ae095ef7.png

清空链表

L.resize(0);

这段代码将链表的大小调整为 0，相当于清空了链表。此时，除了 end() 迭代器之外，任何其他迭代器都变得无效，包括之前的 it。

50e8144ebd1d4da98a40cdd2e3161cef.png

stl_list_h 中"operator ="底层代码

 
/*operator = 重载*/
template <class T, class Alloc>
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x) {
  if (this != &x) {
    iterator first1 = begin();
    iterator last1 = end();
    const_iterator first2 = x.begin();
    const_iterator last2 = x.end();
    while (first1 != last1 && first2 != last2) *first1++ = *first2++;
    if (first2 == last2)
      erase(first1, last1);
    else
      insert(last1, first2, last2);
  }
  return *this;
 }

template <class T, class Alloclist<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x) {

这一行声明了一个模板函数，这个函数是list类的成员函数，用于重载赋值运算符=。T是列表中存储元素的类型，而Alloc是分配器类型，用于控制元素的内存分配。该函数接收一个常量引用x作为参数，这个参数是另一个list对象，表示要从中复制数据。函数返回对当前对象的引用，允许链式赋值。

if (this != &x) {

这一行检查自赋值的情况。如果被赋值的对象（*this）和赋值来源对象（x）是同一个对象，则不执行任何操作。这是为了防止自我复制时可能发生的资源泄露或不必要的操作。

iterator first1 = begin(); iterator last1 = end(); const_iterator first2 = x.begin(); const_iterator last2 = x.end();

这四行代码初始化四个迭代器。first1和last1分别是当前list对象的起始和结束位置的迭代器。first2和last2是参数x（即要复制的list对象）的起始和结束位置的常量迭代器。

while (first1 != last1 && first2 != last2) *first1++ = *first2++;

这行代码在两个列表都没有遍历完之前，逐个元素地从x复制元素到当前对象。*first1++ = *first2++这个表达式复制元素值，并将两个迭代器分别向前移动到下一个元素。

if (first2 == last2)erase(first1, last1);elseinsert(last1, first2, last2);

在完成上述循环后，会有两种情况：

如果x的元素已经复制完，但当前对象中还有剩余元素，这些剩余元素需要被删除。这通过调用erase(first1, last1)实现，它删除从first1到last1（不包括last1）范围内的所有元素。

如果当前对象的元素已经被完全覆盖，但x中还有未复制的元素，这些元素需要被插入到当前对象的末尾。这通过调用insert(last1, first2, last2)实现，它从first2到last2的范围内插入元素到last1位置之前。

return *this;

最后，函数返回当前对象的引用，使得可以进行链式赋值操作（例如，a = b = c）。

重新分配链表内容

L.assign(10, 5);

list<int> L1{ 10, 20, 30, 40, 50 };

L = L1;

05f453db694040959c799b1d7b5a02ea.png

assign底层实现和operator=大致是相同的。根据迭代器指向的位置元素是否被销毁来判断迭代器是否失效。示例代码迭代器没有发生失效。

删除操作

while (it != L.end()) {

it = L.erase(it);

}

6f1b7b56d82e48e59c2c050ec054f5bf.png

这种模式是正确的方式来删除链表中的元素，因为 erase 返回指向被删除元素下一个元素的迭代器。

 

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

 

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

 

谢谢您的支持，期待与您在下一篇文章中再次相遇！

 

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

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

相关文章

奇异值分解（SVD）的应用——图像压缩

奇异值分解（SVD）的应用——图像压缩

SVD方法是模型降阶的一类重要方法&#xff0c;本征正交分解&#xff08;POD&#xff09;和平衡截断&#xff08;BT&#xff09;都属于SVD类方法。 要想深入了解模型降阶技术&#xff0c;我们可以先从SVD的应用入手&#xff0c;做一个直观的了解。 1. SVD的定义和分类 我们想寻找…
阅读更多...
01-Spring实现重试和降级机制

01-Spring实现重试和降级机制

主要用于在模块调用中&#xff0c;出现失败、异常情况下&#xff0c;仍需要进行重复调用。并且在最终调用失败时&#xff0c;可以采用降级措施&#xff0c;返回一般结果。 1、重试机制 我们采用spring 提供的retry 插件&#xff0c;其原理采用aop机制&#xff0c;所以需要额外…
阅读更多...
无人机应用场景和发展趋势，无人机技术的未来发展趋势分析

无人机应用场景和发展趋势，无人机技术的未来发展趋势分析

随着科技的不断发展&#xff0c;无人机技术也逐渐走进了人们的生活和工作中。无人机被广泛应用于很多领域&#xff0c;例如遥感、民用、军事等等。本文将围绕无人机技术的应用场景和发展趋势&#xff0c;从多角度展开分析。 无人机技术的应用场景 无人机在遥感方面的应用&…
阅读更多...
2024 年，如何用 6 个月拿下 30 万年薪的区块链开发？

2024 年，如何用 6 个月拿下 30 万年薪的区块链开发？

《区块链简易速速上手小册》开源系列专栏 文章目录 一、了解区块链二、简易速速上手小册系列&#xff08;开源版&#xff09;三、具体安排参考第1个月&#xff1a;基础加固第2个月&#xff1a;区块链原理与技术第3个月&#xff1a;深入智能合约开发第4个月&#xff1a;区块链平…
阅读更多...
vtkActor 设置特定图层 显示及置顶显示

vtkActor 设置特定图层 显示及置顶显示

问题&#xff0c;有时我们需要显示某个 Actor 在相机最前面&#xff0c;可以遮盖后面的物体;显示在顶层有点不准确&#xff1b;因为这个还相机位置也有关系&#xff1b; 这里讲三种情况&#xff1a; 1. 设置 Mapper 顶层&#xff0c;尝试了一下&#xff0c;可以用于某些场景&…
阅读更多...
C++ 模板初阶【函数模板，类模板】

C++ 模板初阶【函数模板，类模板】

文章目录 泛型编程函数模板概念函数模板的格式函数模板的原理函数模板的实例化隐式实例化:让编译器根据实参推演模板参数的实际类型显式实例化&#xff1a;在函数名后的<>中指定模板参数的实际类型 函数模板的匹配规则 类模板概念类模板格式类模板的实例化 泛型编程 在我…
阅读更多...
【计算几何】确定两条连续线段向左转还是向右转

【计算几何】确定两条连续线段向左转还是向右转

确定两条连续线段向左转还是向右转 目录 一、说明二、算法2.1 两点的叉积2.2 两个段的叉积 三、旋转方向判别3.1 左转3.2、右转3.3 共线判别 一、说明 如果是作图&#xff0c;或者是判别小车轨迹。为了直观地了解&#xff0c;从当前点到下一个点过程中&#xff0c;什么是左转、…
阅读更多...
2-1 动手学深度学习v2-Softmax回归-笔记

2-1 动手学深度学习v2-Softmax回归-笔记

回归 VS 分类 回归估计一个连续值分类预测一个离散类别 从回归到多类分类 回归 单连续数值输出输出的区间&#xff1a;自然区间 R \mathbb{R} R损失&#xff1a;跟真实值的区别 分类 通常多个输出&#xff08;这个输出的个数是等于类别的个数&#xff09;输出的第 i i i…
阅读更多...
Redis核心技术与实战【学习笔记】 - 27.限制Redis Cluster规模的因素（通信开销）

Redis核心技术与实战【学习笔记】 - 27.限制Redis Cluster规模的因素（通信开销）

简述 Redis Cluster 能保存的数据量以及支撑的吞吐量&#xff0c;跟集群实例规模相关。 Redis 官方给出了 Redis Cluster 的规模上线&#xff0c;就是一个集群运行 1000 个实例。 其实&#xff0c;限定 Redis Cluster 集群规模的一个关键因素就是&#xff0c;实例间的通信开销…
阅读更多...
MySQL优化器

MySQL优化器

优化器 MySQL存储引擎中存在了一个可插拔的优化器OPTIMIZER_TRACE&#xff0c;可以看到内部查询计划的TRACE信息&#xff0c;从而可以知道MySQL内部执行过程 查询优化器状态 show variables like optimizer_trace;Variable_name Valueoptimizer_trace enabledoff,one_lineoff…
阅读更多...
大模型实战营第二期——3. 基于 InternLM 和 LangChain 搭建你的知识库

大模型实战营第二期——3. 基于 InternLM 和 LangChain 搭建你的知识库

github地址&#xff1a;InternLM/tutorial-书生浦语大模型实战营文档地址&#xff1a;基于 InternLM 和 LangChain 搭建你的知识库视频地址&#xff1a;基于 InternLM 和 LangChain 搭建你的知识库Intern Studio: https://studio.intern-ai.org.cn/console/instance动手学大模型…
阅读更多...
如何在苹果Mac上进行分屏，多任务处理？

如何在苹果Mac上进行分屏，多任务处理？

Apple 在 macOS Catalina 中引入了 Split View&#xff0c;让您可以同时查看两个应用程序。如果同时处理多个应用程序&#xff0c;但在它们之间切换时感到沮丧&#xff0c;小编教给大家在 Macbook Pro/Air 或 iMac 上使用分屏功能流畅地进行多任务处理。 注意&#xff1a;您可…
阅读更多...
C# 委托（delegate）本质理解

C# 委托（delegate）本质理解

目录 代码如下&#xff0c;很简单 运行的结果 反编译程序查看 关注两点&#xff1a; 什么是委托 委托的三个步骤 委托的意义 代码如下&#xff0c;很简单 namespace Delegate { class Program { delegate void SayHi(); void SayHi_1() …
阅读更多...
专业135+总400+中国科学院大学859国科大信号与系统考研经验电子信息与通信，真题，大纲，参考书

专业135+总400+中国科学院大学859国科大信号与系统考研经验电子信息与通信，真题，大纲，参考书

今年考研专业课859信号与系统135&#xff0c;总分400上岸国科大&#xff0c;总结一下自己这一年的复习经验&#xff0c;希望对后面报考中科院大学的同学有所帮助。 专业课&#xff1a; 国科大不同研究所都是统一命题&#xff0c;859信号与系统的参考书目是郑君里的《信号与系…
阅读更多...
移动光猫gs3101超级密码及改桥接模式教程

移动光猫gs3101超级密码及改桥接模式教程

文章目录 超级管理员账号改桥接模式路由器连接光猫&#xff0c;PPPOE拨号即可&#xff01;附录&#xff1a;如果需要改桥接的话不知道拨号密码咋办打开光猫Telnet功能Telnet 登录 参考文章 移动光猫吉比特GS3101超级账号获取更改桥接 移动光猫gs3101超级密码及改桥接模式教程 …
阅读更多...
C#入门及进阶|数组和集合（六）：集合概述

C#入门及进阶|数组和集合（六）：集合概述

1.集合概述 数组是一组具有相同名称和类型的变量集合&#xff0c;但是数组初始化后就不便于再改变其大小&#xff0c;不能实现在程序中动态添加和删除数组元素&#xff0c;使数组的使用具有很多局限性。集合能解决数组存在的这个问题&#xff0c;下面我们来学习介绍集合…
阅读更多...
微服务入门篇：http客户端Feign（远程调用，自定义配置，Feign的性能优化，Feign服务抽取）

微服务入门篇：http客户端Feign（远程调用，自定义配置，Feign的性能优化，Feign服务抽取）

目录 1.基于Feign的远程调用1.RestTemplate方式调用存在的问题2.Feign的介绍3.定义和使用Feign客户端 2.自定义配置1.方式一&#xff1a;配置文件方式2.方式二: java代码方式&#xff0c;需要先声明一个Bean: 3.Feign的性能优化1.Feign底层的客户端实现2.连接池配置 4.Feign的最…
阅读更多...
春节假期：思考新一年的发展思路

春节假期：思考新一年的发展思路

春节假期是人们放松身心、享受家庭团聚的时刻&#xff0c;但除了走亲戚、玩、吃之外&#xff0c;我们确实也需要思考新的一年的发展思路。以下是一些建议&#xff0c;帮助您在春节假期中为新的一年做好准备&#xff1a; 回顾过去&#xff0c;总结经验&#xff1a;在春节期间&a…
阅读更多...
Blazor 子组件交互例子

Blazor 子组件交互例子

源码 子组件 SwitchBar.razor &#xfeff;using Microsoft.Extensions.Logging inject ILogger<Index> Logger<div style"ClassString" onclick"OnClick">ChildContent </div>code {[Parameter]public RenderFragment? ChildContent…
阅读更多...
AJAX——认识URL

AJAX——认识URL

1 什么是URL&#xff1f; 统一资源定位符&#xff08;英语&#xff1a;Uniform Resource Locator&#xff0c;缩写&#xff1a;URL&#xff0c;或称统一资源定位器、定位地址、URL地址&#xff09;俗称网页地址&#xff0c;简称网址&#xff0c;是因特网上标准的资源的地址&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023