list常用接口模拟实现

文章目录

    • 一、模拟list类的框架
    • 二、函数接口实现
      • 1、迭代器接口
      • 2、常用删除、插入接口
      • 3、常用其他的一些函数接口
      • 4、默认成员函数

一、模拟list类的框架

1、使用带哨兵的双向链表实现。
2、链表结点：

// List的结点类
template<class T>
struct ListNode
{
    ListNode<T>* _pPre; //后继指针
    ListNode<T>* _pNext; //前驱指针
    T _val; //数据
    //构造结点
    ListNode(const T& val = T()) :_val(val), _pPre(nullptr), _pNext(nullptr)
    {}
};

3、list类的成员变量和构造双向链表的哨兵位结点函数。

 //让哨兵位结点指向自己
typedef ListNode<T> Node;
typedef Node* PNode;

void CreateHead()
 {
     _pHead = new  Node;
     _pHead->_pNext = _pHead;
     _pHead->_pPre = _pHead;
 }
 
 PNode _pHead;   //哨兵位结点

二、函数接口实现

1、迭代器接口

list的迭代器是双向迭代器，支持++、–，但是它们在内存上储存是不连续的，无法简单通过指针去进行++、–操作，所以我们要对list的迭代器进行封装。
(1)list正向迭代器类
成员变量：两个结点指针。

typedef ListNode<T>* PNode;
PNode _pNode;	//结点指针
PNode _P;//保存哨兵位结点指针，用于判断解引用是否访问哨兵位结点

构造函数：

//构造函数 ，获取一个结点指针
  ListIterator(const PNode & pNode = nullptr, const PNode& const P = nullptr) :_pNode(pNode),_P(P)
    {}

拷贝构造、赋值、析构函数：
因为_pNode的指针指向的内存是有list类释放的，所以该类无需进行资源清理，使用浅拷贝即可，所以拷贝、赋值、析构都使用编译器生成的即可。

重载操作符：

	//Ref为T& Ptr为T*
   typedef ListIterator<T, Ref, Ptr> Self;
   	//解引用
    Ref operator*()
    {
          assert(_P != _pNode);

        return _pNode->_val;
    }
    //该运算符重载的意义为T为自定义类型时使用，迭代器可以通过该运算符直接访问自定义类型成员
    Ptr operator->()
    {
        return &(_pNode->_val);
    }
    //前置++
    Self& operator++()
    {
        _pNode = _pNode->_pNext;
        return *this;
    }
    //后置++
    Self operator++(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pNext;
        return tmp;
    }
    //前置--
    Self& operator--()
    {
        _pNode = _pNode->_pPre;
        return *this;
    }
    //后置--
    Self& operator--(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pPre;
        return tmp;
    }
    //比较
    bool operator!=(const Self& l)
    {
        return l._pNode != _pNode;
    }
    bool operator==(const Self& l)
    {
        return l._pNode == _pNode;
    }

获取成员变量函数：

 //获取该迭代器成员变量
    PNode get()
    {
        return _pNode;
    }

ListIterator类一览：

//Ref为T& Ptr为T*
template<class T, class Ref, class Ptr>
class ListIterator
{
    typedef ListNode<T>* PNode;
    typedef ListIterator<T, Ref, Ptr> Self;
public:
    //构造函数 ，获取一个结点指针
    ListIterator(const PNode & pNode = nullptr, const PNode& const P = nullptr) :_pNode(pNode),_P(P)
    {}
    Ref operator*()
    {
        assert(_P != _pNode);

        return _pNode->_val;
    }
    Ptr operator->()
    {
        return &(operator*());
    }
    Self& operator++()
    {
        _pNode = _pNode->_pNext;
        return *this;
    }
    Self operator++(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pNext;
        return tmp;
    }
    Self& operator--()
    {
        _pNode = _pNode->_pPre;
        return *this;
    }
    Self& operator--(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pPre;
        return tmp;
    }
    bool operator!=(const Self& l)
    {
        return l._pNode != _pNode;
    }
    bool operator==(const Self& l)
    {
        return l._pNode == _pNode;
    }
    PNode get()
    {
        return _pNode;
    }
private:
    PNode _pNode;
    PNode _P;
};
};

(2)反向迭代器类
与正向迭代器不一样的有 * 操作符，_pNode保存的是有效元素的下一个位置，如：想要的是_pNode->_pPre指向的元素，但是该迭代器保存的是_pNode的指针，还有++，–与正向迭代器相反。
其他操作与正向迭代器一致。

template<class T, class Ref, class Ptr>
class Reverse_ListIterator
{
    typedef ListNode<T>* PNode;
    typedef Reverse_ListIterator<T, Ref, Ptr> Self;
public:
    Reverse_ListIterator(const PNode& pNode = nullptr, const PNode& const P = nullptr) :_pNode(pNode), _P(P)
    {}
    Ref operator*()
    {
        assert(_P != _pNode ->_pPre);
        return _pNode->_pPre->_val;
    }
    Ptr operator->()
    {
        return &(operator*());
    }
    Self& operator++()
    {
        _pNode = _pNode->_pPre;
        return *this;
    }
    Self operator++(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pPre;
        return tmp;
    }
    Self& operator--()
    {
        _pNode = _pNode->_pNext;
    }
    Self& operator--(int)
    {
        Self tmp(_pNode);
        _pNode = _pNode->_pNext;
        return tmp;
    }
    bool operator!=(const Self& l)
    {
        return l._pNode != _pNode;
    }
    bool operator==(const Self& l)
    {
        return l._pNode == _pNode;
    }
    PNode get()
    {
        return _pNode;
    }
private:
    PNode _pNode;
    PNode _P;
};

(3)list迭代器接口

//一些类型的重命名
 typedef ListIterator<T, T&, T*> iterator;
 typedef ListIterator<T, const T&, const T*> const_iterator;
 typedef Reverse_ListIterator<T, T&, T*> reverse_iterator;
 typedef Reverse_ListIterator<T, const T&, const T*> reverse_const_iterator;

// List Iterator

//第一个有效元素位置的迭代器
iterator begin()
{
    return iterator(_pHead->_pNext,_pHead);
}
//最后一个有效元素位置的下一个位置的迭代器
iterator end()
{
    return iterator(_pHead,_pHead);
}
//加了const 修饰
const_iterator begin() const
{
    return const_iterator(_pHead->_pNext,_pHead);
}
const_iterator end()const
{
    return const_iterator(_pHead,_pHead);
}

//反向迭代器
//哨兵位的位置
  reverse_iterator rbegin()
  {
      return reverse_iterator(_pHead,_pHead);
  }
//第一个有效元素位置
  reverse_iterator rend()
  {
      return reverse_iterator(_pHead ->_pNext,_pHead);
  }
//加了const修饰
  reverse_const_iterator rbegin() const
  {
      return reverse_const_iterator(_pHead,_pHead);
  }
  reverse_const_iterator rend()const
  {
      return reverse_const_iterator(_pHead->_pNext,_pHead);
  }

2、常用删除、插入接口

(1)insert
在迭代器位置前插入一个结点。

// 在pos位置前插入值为val的节点
iterator insert(iterator pos, const T & val)
{
    //创造一个结点
    PNode tmp = new Node(val);

    //获取迭代器中的指针
    PNode _pos = pos.get();

    //进行插入
    PNode prv = _pos->_pPre;
    prv->_pNext = tmp;
    tmp->_pPre = prv;
    tmp->_pNext = _pos;
    _pos->_pPre = tmp;

    //返回新迭代器
    return iterator(tmp);
}

迭代器是否失效：
因为插入新的结点，不会影响到原来的结点，所以该迭代器不会失效。

(2)erase
删除迭代器位置结点。

// 删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
{
    //判断是否为哨兵位结点
    iterator it = end();
    assert(pos != it);

    //获取迭代器结点指针
    PNode tmp = pos.get();

    //进行删除
    PNode next = tmp->_pNext;
    PNode prv = tmp->_pPre;
    prv->_pNext = next;
    next->_pPre = prv;
    delete tmp;
    tmp = nullptr;

    //返回被删除结点的下一个位置的结点迭代器
    return iterator(next);
}

迭代器是否失效：
因为将结点删除了，所以原本的迭代器是不能使用的，所以迭代器失效了。

(3)push_back、pop_back、push_front、pop_front
这里的头插、尾插、头删、尾删均复用上面两个函数接口。

void push_back(const T & val) { insert(end(), val); }
void pop_back() { erase(--end()); }
void push_front(const T & val) { insert(begin(), val); }
void pop_front() { erase(begin()); }

3、常用其他的一些函数接口

(1)size
返回大小，通过遍历链表即可找到。

size_t size()const
{
	//保存哨兵位的下一个位置
    PNode tmp = _pHead->_pNext;
	
	//开始遍历
    size_t count = 0;
    while (tmp != _pHead)
    {
        tmp = tmp->_pNext;
        ++count;
    }
    
    return count;
}

(2)empty
是否为空，判断哨兵位结点是否指向自己即可。

bool empty()const
{
    return _pHead == _pHead->_pNext;
}

(3)clear
清空链表，遍历链表逐个清空，保留哨兵位结点，再让哨兵位结点自己连接自己。

  void clear()
  {
      //保存有效结点位置
      PNode tmp = _pHead->_pNext;

      //遍历删除
      while (tmp != _pHead)
      {
          PNode p = tmp->_pNext;
          delete tmp;
          tmp = p;
      }
      //重新指向
      _pHead->_pNext = _pHead;
      _pHead->_pPre = _pHead;

(4)swap
交换，只需要交换指向哨兵位结点的指针即可。
在这里插入图片描述

void swap(list<T>& l)
{
    std::swap(_pHead, l._pHead);         
}

(4)front
获取第一个位置的元素。

T& front()
{
    assert(!empty());
    return _pHead->_pNext->_val;
}
const T& front()const
{
    assert(!empty());
    return _pHead->_pNext->_val;
}

(5)back
获取最后一个位置元素。

T& back()
{
    assert(!empty());
    return _pHead->_pPre->_val;
}
const T& back()const
{
    assert(!empty());
    return _pHead->_pPre->_val;
}

4、默认成员函数

(1)构造函数
构造函数都会先进行构造哨兵位结点，再进行下面的操作，除了无参构造，其他都复用了尾插，将元素尾插到链表结尾。

//无参构造
list() 
{   //构造一个哨兵位结点
    CreateHead(); 
}

//利用n个val值进行构造
list(int n, const T& value = T())
{
    //构造一个哨兵位结点
    CreateHead();

    //将元素尾插入
    while (n != 0)
    {
        push_back(value);
        --n;
    }
}

//这里用迭代器区间构造，重写一个模板，使其可以使用其他容器的迭代器
template <class Iterator>
list(Iterator first, Iterator last)
{
    //构造一个哨兵位结点
    CreateHead();
    //将元素尾插入
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}

//拷贝构造
list(const list<T>& l)
{
    //构造一个哨兵位结点
    CreateHead();

    //遍历+将元素尾插入
    PNode tmp = l._pHead->_pNext;
    while (tmp != l._pHead)
    {
        push_back(tmp->_val);
        tmp = tmp->_pNext;
    }
}

(2)重载赋值运算符
通过传值传参构造一个临时容器 l ,再将其与原来的容器交换，当出了函数作用域之后临时容器就会调用析构函数，对临时容器的资源进行清理(就是原来容器的资源)。

list<T>& operator=(list<T> l)
{
    //与临时变量进行交换
    swap(l);
    return *this;
}

(3)析构函数
对链表清理。

~list()
{
    //清空链表
    clear();
    //删除哨兵位结点
    delete _pHead;
    _pHead = nullptr;
}

三、总代码

#pragma once
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;

namespace xu
{
    // List的结点类
    template<class T>
    struct ListNode
    {
        ListNode<T>* _pPre; //后继指针
        ListNode<T>* _pNext; //前驱指针
        T _val; //数据
        //构造结点
        ListNode(const T& val = T()) :_val(val), _pPre(nullptr), _pNext(nullptr)
        {}
    };


    //List的正向迭代器类
    //Ref为T& Ptr为T*
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T>* PNode;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        //构造函数 ，获取一个结点指针
        ListIterator(PNode pNode = nullptr) :_pNode(pNode)
        {}
        Ref operator*()
        {
            return _pNode->_val;
        }
        Ptr operator->()
        {
            return &(operator*());
        }
        Self& operator++()
        {
            _pNode = _pNode->_pNext;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp(_pNode);
            _pNode = _pNode->_pNext;
            return tmp;
        }
        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        Self& operator--(int)
        {
            Self tmp(_pNode);
            _pNode = _pNode->_pPre;
            return tmp;
        }
        bool operator!=(const Self& l)
        {
            return l._pNode != _pNode;
        }
        bool operator==(const Self& l)
        {
            return l._pNode == _pNode;
        }
        PNode get()
        {
            return _pNode;
        }
    private:
        PNode _pNode;
    };

    //List的反向迭代器类
    template<class T, class Ref, class Ptr>
    class Reverse_ListIterator
    {
        typedef ListNode<T>* PNode;
        typedef Reverse_ListIterator<T, Ref, Ptr> Self;
    public:
        Reverse_ListIterator(PNode pNode = nullptr) :_pNode(pNode)
        {}
        Ref operator*()
        {
            return _pNode->_pPre->_val;
        }
        Ptr operator->()
        {
            return &(operator*());
        }
        Self& operator++()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp(_pNode);
            _pNode = _pNode->_pPre;
            return tmp;
        }
        Self& operator--()
        {
            _pNode = _pNode->_pNext;
        }
        Self& operator--(int)
        {
            Self tmp(_pNode);
            _pNode = _pNode->_pNext;
            return tmp;
        }
        bool operator!=(const Self& l)
        {
            return l._pNode != _pNode;
        }
        bool operator==(const Self& l)
        {
            return l._pNode == _pNode;
        }
        PNode get()
        {
            return _pNode;
        }
    private:
        PNode _pNode;
    };

    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    public:
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;
        typedef Reverse_ListIterator<T, T&, T*> reverse_iterator;
        typedef Reverse_ListIterator<T, const T&, const T*> reverse_const_iterator;
    public:
        //默认构造

        list() 
        {   //构造一个哨兵位结点
            CreateHead(); 
        }
        list(int n, const T& value = T())
        {
            //构造一个哨兵位结点
            CreateHead();

            //将元素尾插入
            while (n != 0)
            {
                push_back(value);
                --n;
            }
        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            //构造一个哨兵位结点
            CreateHead();
            //将元素尾插入
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        list(const list<T>& l)
        {
            //构造一个哨兵位结点
            CreateHead();

            //遍历+将元素尾插入
            PNode tmp = l._pHead->_pNext;
            while (tmp != l._pHead)
            {
                push_back(tmp->_val);
                tmp = tmp->_pNext;
            }
        }

        list<T>& operator=(list<T> l)
        {
            //与临时变量进行交换
            swap(l);
            return *this;
        }

        ~list()
        {
            //清空链表
            clear();
            //删除哨兵位结点
            delete _pHead;
            _pHead = nullptr;
        }

        ///
        // List Iterator
        iterator begin()
        {
            return iterator(_pHead->_pNext);
        }
        iterator end()
        {
            return iterator(_pHead);
        }

        const_iterator begin() const
        {
            return const_iterator(_pHead->_pNext);
        }
        const_iterator end()const
        {
            return const_iterator(_pHead);
        }

        reverse_iterator rbegin()
        {
            return reverse_iterator(_pHead);
        }
        reverse_iterator rend()
        {
            return reverse_iterator(_pHead ->_pNext);
        }

        reverse_const_iterator rbegin() const
        {
            return reverse_const_iterator(_pHead);
        }
        reverse_const_iterator rend()const
        {
            return reverse_const_iterator(_pHead->_pNext);
        }


            ///
            // List Capacity
            size_t size()const
            {
                PNode tmp = _pHead->_pNext;

                size_t count = 0;
                while (tmp != _pHead)
                {
                    tmp = tmp->_pNext;
                    ++count;
                }
                return count;
            }
            bool empty()const
            {
                return _pHead == _pHead->_pNext;
            }


            
            // List Access
            T& front()
            {
                assert(!empty());
                return _pHead->_pNext->_val;
            }
            const T& front()const
            {
                assert(!empty());
                return _pHead->_pNext->_val;
            }
            T& back()
            {
                assert(!empty());
                return _pHead->_pPre->_val;
            }
            const T& back()const
            {
                assert(!empty());
                return _pHead->_pPre->_val;
            }


            
            // List Modify
            void push_back(const T & val) { insert(end(), val); }
            void pop_back() { erase(--end()); }
            void push_front(const T & val) { insert(begin(), val); }
            void pop_front() { erase(begin()); }

            // 在pos位置前插入值为val的节点
            iterator insert(iterator pos, const T & val)
            {
                //创造一个结点
                PNode tmp = new Node(val);

                //获取迭代器中的指针
                PNode _pos = pos.get();

                //进行插入
                PNode prv = _pos->_pPre;
                prv->_pNext = tmp;
                tmp->_pPre = prv;
                tmp->_pNext = _pos;
                _pos->_pPre = tmp;

                //返回新迭代器
                return iterator(tmp);
            }
            // 删除pos位置的节点，返回该节点的下一个位置
            iterator erase(iterator pos)
            {
                //判断是否为哨兵位结点
                iterator it = end();
                assert(pos != it);

                //获取迭代器结点指针
                PNode tmp = pos.get();

                //进行删除
                PNode next = tmp->_pNext;
                PNode prv = tmp->_pPre;
                prv->_pNext = next;
                next->_pPre = prv;
                delete tmp;
                tmp = nullptr;

                //返回被删除结点的下一个位置的结点迭代器
                return iterator(next);
            }
          
            void clear()
            {
                //保存有效结点位置
                PNode tmp = _pHead->_pNext;

                //遍历删除
                while (tmp != _pHead)
                {
                    PNode p = tmp->_pNext;
                    delete tmp;
                    tmp = p;
                }
                //重新指向
                _pHead->_pNext = _pHead;
                _pHead->_pPre = _pHead;
            }

            void swap(list<T>& l)
            {
                std::swap(_pHead, l._pHead);
            }

        private:
            //让哨兵位结点指向自己
            void CreateHead()
            {
                _pHead = new  Node;
                _pHead->_pNext = _pHead;
                _pHead->_pPre = _pHead;
            }
            PNode _pHead;   //哨兵位结点
        };
    };

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

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

相关文章

【YashanDB知识库】OCI驱动类问题定位方法

【YashanDB知识库】OCI驱动类问题定位方法

【标题】OCI驱动类问题定位方法 【需求分类】故障分析 【关键字】OCI 【需求描述】由于我们的OCI接口目前尚不完善&#xff0c;经常会遇见OCI接口能力不足导致应用功能无法运行的问题&#xff0c;需要定位手段确定底层是哪个接口报错 【需求原因分析】方便一线数据库管理员…
阅读更多...
Spring OAuth2：开发者的安全盾牌！(下)

Spring OAuth2：开发者的安全盾牌！(下)

上文我们教了大家如何像海盗一样寻找宝藏&#xff0c;一步步解锁令牌的奥秘&#xff0c;今天将把更加核心的技巧带给大家一起学习&#xff0c;共同进步&#xff01; 文章目录 6. 客户端凭证与密码模式6.1 客户端凭证模式应用适用于后端服务间通信 6.2 密码模式考量直接传递用户…
阅读更多...
RabbitMQ详情

RabbitMQ详情

一.MQ简介 什么是MQ MQ本质是队列&#xff0c;FIFO先入先出&#xff0c;队列中存放的内容是message&#xff08;消息&#xff09;&#xff0c;还是一种跨进程的通信机制&#xff0c;用于上下游传递消息。在互联网架构中是常见的上下游“逻辑解耦物理解耦”的消息通信服务。 主…
阅读更多...
win10双网卡如何同时上内网和外网?

win10双网卡如何同时上内网和外网?

win10双网卡如何同时上内网和外网? Chapter1 win10双网卡如何同时上内网和外网?Chapter2 网络基础--win10双网卡设置成访问不同的网络 Chapter1 win10双网卡如何同时上内网和外网? 原文链接&#xff1a;https://www.jb51.net/os/win10/806585.html 场景&#xff1a;很多办…
阅读更多...
反射器与联邦实验

反射器与联邦实验

反射器与联邦实验 一.拓扑 二.实验要求: 1.AS1存在两个环回&#xff0c;一个地址为192.168.1.0/24&#xff0c;该地址不能在任何协议中宣告&#xff0c;AS3存在两个环回&#xff0c;一个地址为192.168.2.0/24&#xff0c;该地址不能在任何协议中宣告&#xff0c;As1还有一个环…
阅读更多...
GPT-4O神器来袭！自动生成Figma设计稿，移动端开发瞬间加速！

GPT-4O神器来袭！自动生成Figma设计稿，移动端开发瞬间加速！

2024年5月29日- 近日&#xff0c;一款基于GPT-4O技术的创新工具成功实现根据产品需求文档&#xff08;PRD&#xff09;自动生成Figma设计稿的功能&#xff0c;为移动端应用开发者带来革命性的便捷。据悉&#xff0c;该功能主要针对移动端应用进行优化&#xff0c;并支持使用高质…
阅读更多...
php之sql代码审计

php之sql代码审计

1 SQL注入代码审计流程 1.1 反向查找流程 通过可控变量(输入点)回溯危险函数 查找危险函数确定可控变量 传递的过程中触发漏洞 1.2 反向查找流程特点 暴力&#xff1a;全局搜索危险函数 简单&#xff1a;无需过多理解目标网站功能与架构 快速&#xff1a;适用于自动化代码审…
阅读更多...
图书/科技馆进行客流统计的价值和意义是什么？

图书/科技馆进行客流统计的价值和意义是什么？

在当今数字化时代&#xff0c;图书/科技馆进行客流统计具有极其重要的价值和意义。 一、客流统计原因 首先探讨一下图书/科技馆进行客流统计的原因。其一&#xff0c;为了更好地规划和利用场馆空间。了解不同区域的客流分布情况&#xff0c;能够针对性地进行布局调整&#xff0…
阅读更多...
【漏洞复现】大华智能物联综合管理平台 log4j远程代码执行漏洞

【漏洞复现】大华智能物联综合管理平台 log4j远程代码执行漏洞

0x01 产品简介 大华ICC智能物联综合管理平台对技术组件进行模块化和松耦合&#xff0c;将解决方案分层分级&#xff0c;提高面向智慧物联的数据接入与生态合作能力。 0x02 漏洞概述 大华ICC智能物联综合管理平台/evo-apigw/evo-brm/1.2.0/user/is-exist 接口处存在 l0g4i远程…
阅读更多...
matlab工具使用记录-编辑器和命令行窗口分开还原

matlab工具使用记录-编辑器和命令行窗口分开还原

工具&#xff1a;matlab2021b 场景&#xff1a;在使用软件的过程中&#xff0c;我们误操作将matlab的编辑器单独出来了。这时候对软件进行各种操作都还原不回去。 matlab中编辑器和命令行窗口分开了如下图所示。 这时候只需要使用快捷键在编辑器窗口按CtrlshiftD&#xff0c;…
阅读更多...
QGIS开发笔记（三）：Windows安装版二次开发环境搭建（下）：将QGis融入QtDemo，添加QGis并加载tif遥感图的Demo

QGIS开发笔记（三）：Windows安装版二次开发环境搭建（下）：将QGis融入QtDemo，添加QGis并加载tif遥感图的Demo

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/139136356 长沙红胖子Qt&#xff08;长沙创微智科&#xff09;博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV…
阅读更多...
Redis-事务

Redis-事务

简介 说到事务&#xff0c;一般都会第一时间的想到MySQL的事务。 在MySQL中事务的提出是为了解决解决原子性操作的&#xff0c;一组执行命令要么全部执行成功&#xff0c;要么执行失败进行回滚&#xff0c;一条也不执行。 在Redis中也有事务这个概念&#xff0c;但与MySQL相…
阅读更多...
Windows内核函数 - 添加、修改注册表键值

Windows内核函数 - 添加、修改注册表键值

打开注册表的句柄后&#xff0c;就可以对该项进行设置和修改了。注册表是以二元形式存储的&#xff0c;即“键名”和“键值”。通过键名设置键值&#xff0c;而键值可以划分几个类&#xff0c;如下表所示。 表1 键值的分类 在添加和修改注册表键值的时候&#xff0c;要分类进行…
阅读更多...
非线性优化：高斯-牛顿法的原理与实现

非线性优化：高斯-牛顿法的原理与实现

非线性优化&#xff1a;高斯-牛顿法的原理与实现 引言 在实际应用中&#xff0c;很多问题都是非线性的。非线性优化问题广泛应用于机器学习、数据拟合、工程设计等领域。高斯-牛顿法是一种常用于解决非线性最小二乘问题的迭代算法。本文将详细介绍高斯-牛顿法的原理、推导过程…
阅读更多...
重磅发布，2024精选《制造业商业智能BI最佳实践合集 》

重磅发布，2024精选《制造业商业智能BI最佳实践合集 》

在数字时代&#xff0c;中国制造业正面临着前所未有的深刻变革。 商业环境的复杂性与多变性、全球化竞争的激烈程度、消费需求的快速演变&#xff0c;以及新技术的持续进步等多种因素共同推动着制造企业积极加入数字化转型的潮流。 在这个转型的过程中&#xff0c;转型的速度…
阅读更多...
超好用的加密工具

超好用的加密工具

超好用的加密工具 背景 介于行业原因经常要对相关文件进行加密传输&#xff0c;尽可能避免文件的泄漏&#xff0c;保护群众的隐私。于是我就开发了一个非常好用的加密工具。 环境 本工具目前只适用 Windows 操作系统,最好是Windows8以上&#xff0c;否则需要下载额外的依赖…
阅读更多...
使用PyAutoGUI识别PNG图像并自动点击按钮

使用PyAutoGUI识别PNG图像并自动点击按钮

在自动化测试、任务批处理等场景中,我们常常需要控制GUI程序的鼠标键盘操作。PyAutoGUI就是一个非常方便的Python模块,可以帮助我们实现这些操作。今天我们就来看看如何使用PyAutoGUI识别屏幕上的PNG图像,并自动点击图像所在位置。 C:\pythoncode\new\autoguirecongnizepng.py …
阅读更多...
AlexNet，LeNet-5，ResNet，VGG-19，VGG-16模型

AlexNet，LeNet-5，ResNet，VGG-19，VGG-16模型

模型 AlexNet导入必要的库&#xff1a;加载类别名称&#xff1a;创建标签映射字典&#xff1a;加载图像数据和对应的标签&#xff1a;构建AlexNet模型&#xff1a;编译模型&#xff1a;训练模型&#xff1a; LeNet-5导入必要的库&#xff1a;加载类别名称&#xff1a;创建标签映…
阅读更多...
程序卡在 B.处什么原因？如何处理？（串口配置无问题，重写putc无问题，但不打印）

程序卡在 B.处什么原因？如何处理？（串口配置无问题，重写putc无问题，但不打印）

文章目录 前提现象&#xff1a;debug&#xff1a;原因总结 前提 为了张流量券多加更一篇&#xff0c;是我2月份遇到的问题的总结&#xff0c;在我的笔记中&#xff0c;一直没发 现象&#xff1a; 已经配置好串口但不打印输出&#xff08;printf指向串口1 的SR寄存器&#xf…
阅读更多...
CentOS下安装SVN客户端及使用方法

CentOS下安装SVN客户端及使用方法

一、前言 Subversion&#xff08;SVN&#xff09;是一款开源的版本控制系统&#xff0c;它可以帮助开发者追踪和管理代码、文档或其他文件的更改历史。在Linux系统中&#xff0c;特别是在CentOS环境下&#xff0c;安装和使用SVN客户端是日常工作中常见的任务。本文将介绍如何在…
阅读更多...
最新文章

Copyright @ 2022~2023