c++ - 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/681424.html

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

相关文章

opencv进阶 ——（十一）基于RMBG实现生活照生成寸照

opencv进阶 ——（十一）基于RMBG实现生活照生成寸照

实现步骤 1、检测人脸&#xff0c;可以使用opencv自带的级联分类器或者dlib实现人脸检测 2、放大人脸范围&#xff0c;调整到正常寸照尺寸 3、基于RMGB算法得到人像掩码 4、生成尺寸相同的纯色背景与当前人像进行ALPHA融合即可 alpha融合实现 void alphaBlend(cv::Mat&…
阅读更多...
场外个股期权交易最新指南

场外个股期权交易最新指南

场外个股期权交易最新指南 场外个股期权作为一种灵活的衍生品工具&#xff0c;允许投资者在特定条件下对交易所指定的股票进行买卖。相较于标准化的场内个股期权&#xff0c;场外个股期权为投资者提供了更大的自由度。以下是关于场外个股期权交易的基本步骤和要点&#xff1a;…
阅读更多...
股票期权是什么意思？期权懂为你介绍股票期权操作方法

股票期权是什么意思？期权懂为你介绍股票期权操作方法

今天带你了解股票期权是什么意思&#xff1f;期权懂为你介绍股票期权操作方法。股票期权是一种有着多种用途的金融工具&#xff0c;它给企业、员工、投资人和公司带来了丰厚的收益&#xff0c;对于投资人而言&#xff0c;在市场风险和机会之间寻找平衡&#xff0c;从而实现稳健…
阅读更多...
bbbike下载OSM路网数据后使用GraphHopper离线进行路径规划

bbbike下载OSM路网数据后使用GraphHopper离线进行路径规划

一、bbbike下载OSM路网数据 GraphHopper是一种快速且内存有效的Java导航引擎&#xff0c;默认使用OSM和GTFS数据&#xff0c;也可导入其他的数据源。支持CH&#xff08;Contraction Hierarchies&#xff09;、A*、Dijkstra算法。 1、搭建之前要保证jdk安装完成&#xff0c;且完…
阅读更多...
openeuler系统配置dns

openeuler系统配置dns

openeuler系统配置dns 第1步 在/etc/sysconfig/network-scripts/ifcfg-ens192文件配置 注意PEERDNSno一定要配上 第2步 vim /etc/resolv.conf #编辑dns指向文件 nameserver 192.168.187.129 #添加我们配置的dns服务器的ip第3步 # 配置完以后需要重启网卡 systemctl res…
阅读更多...
每天的CTF小练--6.5(ascll码高级运用)

每天的CTF小练--6.5(ascll码高级运用)

题目&#xff1a;[HUBUCTF 2022 新生赛]baby_encrypt hint&#xff1a; 781612443113954655886887407898899451044114412011257135914071455155316031651170318041861191719652013207021272183228423832485254125932643269827992924 注意查看前面的数字&#xff0c;这题不想现…
阅读更多...
python入门3

python入门3

文章目录 前言一、函数为什么要使用函数&#xff1f;函数定义函数定义和调用定义函数返回值定义空函数函数参数传递传递实参位置实参关键词实参默认值实参等效函数调用实参可选传递任意数量的实参任意数量关键字实参任意参数*与** 的区别使用元组和字典传参如果既有实参又有任意…
阅读更多...
高效管理近30万稳定运力，科技物流企业万联易达这样做

高效管理近30万稳定运力，科技物流企业万联易达这样做

万联易达物流科技有限公司&#xff08;以下简称“万联易达”&#xff09;&#xff0c;是由中泽集团投资设立的创新型物流科技企业。为提高平台数智化服务水平&#xff0c;提升业务开展效率&#xff0c;达到运输全场景合规化管理&#xff0c;万联易达平台引用法大大电子合同&…
阅读更多...
Hadoop3：MapReduce之MapTask的FileInputFormat的切片原理解读（2）

Hadoop3：MapReduce之MapTask的FileInputFormat的切片原理解读（2）

Job那块的断点代码截图省略&#xff0c;直接进入切片逻辑 参考&#xff1a;Hadoop3&#xff1a;MapReduce之MapTask的Job任务提交流程原理解读&#xff08;1&#xff09; 4、FileInputFormat切片源码解析 切片入口 获取切片数 获取最大和最小切片数 判断文件是否可以切片&…
阅读更多...
MFC 模态对话框的实现原理

MFC 模态对话框的实现原理

参考自MFC 模态对话框的实现原理 - 西昆仑 - OSCHINA - 中文开源技术交流社区 1. 模态对话框 在涉及 GUI 程序开发的过程中&#xff0c;常常有模态对话框以及非模态对话框的概念 模态对话框&#xff1a;在模态对话框活动期间&#xff0c;父窗口是无法进行消息响应&#xff0…
阅读更多...
JVM类加载机制和双亲委派

JVM类加载机制和双亲委派

类加载机制 java文件需要编译成字节码文件(.class文件)&#xff0c;jvm是通过类加载机制&#xff0c;将.class文件加载进内存&#xff0c;经过验证连接->初始化直到使用该对象的过程就是类加载机制&#xff0c;当new对象的时候&#xff0c;jvm首先去常量池寻找该类的符号引用…
阅读更多...
罗永浩创业史！普通人也能逆袭！2024轻资产创业项目！2024普通人的出路！ 2024普通人做什么行业赚钱！

罗永浩创业史！普通人也能逆袭！2024轻资产创业项目！2024普通人的出路！ 2024普通人做什么行业赚钱！

罗永浩出身草根&#xff0c;一路打拼至今&#xff0c;虽然屡屡受挫但是从未妥协&#xff0c;罗永浩真正的诠释了什么叫“彪悍的人生不需要解释”&#xff01; 回顾罗永浩的传奇创业史: 1. 从新东方出来做牛博网--失败 2.创办老罗英语培训学校--失败 3.致敬乔布斯做锤子科技-…
阅读更多...
Mybatis01-初识Mybatis

Mybatis01-初识Mybatis

简介 1、 什么是Mybatis MyBatis 是一款优秀的持久层框架; 它支持自定义 SQL、存储过程以及高级映射 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO&#xff08;Plain Ol…
阅读更多...
实战shell免杀C2远控工具魔改（免杀日记 - 上篇）

实战shell免杀C2远控工具魔改（免杀日记 - 上篇）

声明&#xff1a;请勿利用文章内的相关技术从事非法测试&#xff0c;如因此产生的一切不良后果与文章作者和本博客号无关。 一、环境准备 系统&#xff1a;Win11物理机、Kali攻击机、4台Win10虚拟机【安装360杀毒、火绒、卡巴斯基、DF&#xff08;Win自带&#xff09;】工具&…
阅读更多...
揭秘成都跃享未来教育：安全靠谱，打造教育新未来？

揭秘成都跃享未来教育：安全靠谱，打造教育新未来？

在当今这个信息爆炸的时代&#xff0c;教育行业的变革日新月异&#xff0c;各种教育机构如雨后春笋般涌现。其中&#xff0c;成都跃享未来教育咨询有限公司以其独特的教育理念和创新的教学模式&#xff0c;吸引了众多家长和学生的目光。那么&#xff0c;这家公司到底安不安全&a…
阅读更多...
这款国内版Bookstack平替也很好用

这款国内版Bookstack平替也很好用

对于企业、团队或个人来说&#xff0c;一个高效、易用的知识库系统就是提升工作效率和团队协作的利器。一款国内版的BookStack平替——HelpLook AI知识库&#xff0c;它不仅功能强大&#xff0c;而且操作简单&#xff0c;对于国内使用者来说刚刚好&#xff0c;跟着LookLook同学…
阅读更多...
c++ - 模板(二)

c++ - 模板(二)

文章目录 一、模板参数缺省值二、非类型模板参数三、模板的特化四、模板的分离编译 一、模板参数缺省值 给模板初始值与给函数初始值类似&#xff0c;当需要给一部分缺省值时&#xff0c;参数缺省值必须从右向左给&#xff0c;中间不能留着参数不给缺省值。 template< cla…
阅读更多...
Ubuntu系统装显卡驱动

Ubuntu系统装显卡驱动

英文地址&#xff1a;https://www.nvidia.com/Download/Find.aspx?langen-us# 中文地址&#xff1a;https://www.nvidia.cn/Download/index.aspx?langcn# sudo apt-get updatesudo apt-get install gsudo apt-get install gccsudo apt-get install makesudo gedit /etc/modp…
阅读更多...
圈子社区系统源码 开源 多端圈子社区论坛系统 社区圈子管理系统

圈子社区系统源码 开源 多端圈子社区论坛系统 社区圈子管理系统

介绍 圈子论坛小程序&#xff0c;是一款为用户提供交流分享、互动沟通的平台。在这个小程序中&#xff0c;用户可以轻松地加入各种不同兴趣爱好的圈子&#xff0c;与志同道合的朋友们交流互动。圈子论坛小程序不仅仅是一个简单的社交工具&#xff0c;更是一个打开新世界大门的…
阅读更多...
Mybatis不明白？就这一篇带你轻松入门

Mybatis不明白？就这一篇带你轻松入门

引言&#xff1a;烧脑的我一直在烧脑的寻找资料&#xff0c;寻找网课&#xff0c;历经磨难让一个在大一期间只会算法的我逐渐走入Java前后端开发&#xff0c;也是一直在自学的道路上磕磕碰碰&#xff0c;也希望这篇文章对于也是同处于自学的你有所帮助&#xff0c;也希望你继续…
阅读更多...
最新文章

Copyright @ 2022~2023