复数类CComplex

编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法）；如果没有成员方法，就砸全局作用域找合适的运算符重载函数

++和--运算符是单目运算符，在参数列表里放上一个int表示其在数的前面还是后面：operator++()表示前置，operator++(int)表示后置，括号里的int没有任何作用。

复数类的具体实现：

  1. //
  2. // Created by 26685 on 2022-05-16 13:43.
  3. // Description:CComplex.h
  4. //
  6. #ifndef C___CCOMPLEX_H
  7. #define C___CCOMPLEX_H
  9. #include <iostream>
  11. using namespace std;
  13. class CComplex {
  14.     friend CComplex operator+(const CComplex &l, const CComplex &r);
  16.     friend iostream &operator<<(ostream &os, const CComplex &src);
  18.     friend istream & operator>>(istream& is, CComplex &src);
  20. public:
  21.     explicit CComplex(int r = 0, int i = 0) : _real(r), _image(i) {}
  23. //    CComplex operator+(const CComplex& src) const{
  24. //        return CComplex(this->_real+src._real,this->_image+src._image);
  25. //    }
  26.     void show() {
  27.         cout << "real: " << _real << " image: " << _image << endl;
  28.     }
  30.     CComplex &operator++() {
  31.         ++_real;
  32.         ++_image;
  33.         return *this;
  34.     }
  36.     CComplex operator++(int) {
  37.         return CComplex(_real++, _image++);
  38.     }
  40. private:
  41.     int _real;
  42.     int _image;
  43. };
  45. inline CComplex operator+(const CComplex &l, const CComplex &r) {
  46.     return CComplex(l._real + r._real, l._image + r._image);
  47. }
  49. inline iostream &operator<<(ostream &os, const CComplex &src) {//重载输出操作
  50.     os << "real: " << src._real << " image: " << src._image << endl;
  51. }
  53. inline istream & operator>>(istream& is,CComplex &src){//重载输入操作
  54.     is>>src._real>>src._image;
  55. }
  57. #endif //C___CCOMPLEX_H

主函数：

  1. int main(){
  2.     CComplex cp1(10,15);
  3.     CComplex cp2(20,30);
  4.     CComplex cp3=cp2+cp1;
  5.     cp3.show();
  7.     CComplex cp4=cp3++;
  8.     cp4.show();
  9.     cp3.show();
  10.     CComplex cp5= ++cp3;
  11.     cp5.show();
  12.     cp3.show();
  14.     cout<<cp4;
  16.     CComplex cp6;
  17.     cin>>cp6;
  18.     cout<<cp6;
  20.     return 0;
  21. }

模拟实现string类的代码

  1. //
  2. // Created by 26685 on 2022-05-16 14:30.
  3. // Description:String.h
  4. //
  6. #ifndef C___STRING_H
  7. #define C___STRING_H
  9. #include <iostream>
  10. #include <cstring>
  12. class String {
  14.     friend std::ostream &operator<<(std::ostream &os, const String &src);
  16. public:
  17.     String(const char *src = nullptr) {
  18.         if (src == nullptr) {
  19.             _pstr = new char[1];
  20.             *_pstr = '\0';
  21.         } else {
  22.             _pstr = new char[strlen(src) + 1];
  23.             strcpy(_pstr, src);
  24.         }
  25.     }
  27.     ~String() {
  28.         delete[] _pstr;
  29.         _pstr = nullptr;
  30.     }
  32.     String(const String &src) {
  33.         _pstr = new char[strlen(src._pstr) + 1];
  34.         strcpy(_pstr, src._pstr);
  35.     }
  37.     bool operator>(const String &str) const {
  38.         return strcmp(_pstr, str._pstr) > 0;
  39.     }
  41.     bool operator<(const String &str) const {
  42.         return strcmp(_pstr, str._pstr) < 0;
  43.     }
  45.     bool operator==(const String &str) const {
  46.         return strcmp(_pstr, str._pstr) == 0;
  47.     }
  49.     int length() const {
  50.         return strlen(_pstr);
  51.     }
  53.     char &operator[](int index) {
  54.         return _pstr[index];
  55.     }
  57.     char *c_str() const {
  58.         return _pstr;
  59.     }
  61. private:
  62.     char *_pstr;
  63. };
  65. inline std::ostream &operator<<(std::ostream &os, const String &src) {
  66.     os << src._pstr;
  67.     return os;
  68. }
  70. inline String operator+(const String& l,const String& r){
  71.     char* ptmp=new char[strlen(l.c_str())+ strlen(r.c_str())+1];
  72.     strcpy(ptmp,l.c_str());
  73.     strcat(ptmp,r.c_str());
  74.     String temp(ptmp);
  75.     delete[] ptmp;
  76.     return temp;
  77. }
  79. #endif //C___STRING_H

目前代码中的加法的重载运算效率不高，需要进一步改进。

上面代码的加法重载函数，会生成临时对象，影响性能。

暂时改进为：

  1. inline String operator+(const String &l, const String &r) {
  2. //    char *ptmp = new char[strlen(l.c_str()) + strlen(r.c_str()) + 1];
  3.     String temp;
  4.     temp._pstr=new char[strlen(l.c_str()) + strlen(r.c_str()) + 1];//避免了开辟两次内存空间
  5.     strcpy(temp._pstr, l.c_str());
  6.     strcat(temp._pstr, r.c_str());
  7. //    String temp(ptmp);
  8. //    delete[] ptmp;
  9.     return temp;
  10. }

String对象的迭代器的实现

迭代器可以透明的访问容器内部元素的值

foreach遍历容器，其底层是用迭代器实现的

迭代器的功能：提供一种统一的方式，透明的遍历容器

在对迭代器加加时，一般用前置的++，因为不会生成新的对象，效率会高一些

  1.  /**
  2.      * 迭代器的实现, 放在String类中
  3.      */
  4.     class Iterator{
  5.     public:
  6.         Iterator(char* p= nullptr):_p(p){}
  8.         bool operator!=(const String::Iterator&it){//判断两个迭代器是否相等
  9.             return _p!=it._p;
  10.         }
  12.         void operator++(){
  13.             ++ _p;
  14.         }
  16.         char& operator*(){return *_p;}
  18.     private:
  19.         char* _p;
  20.     };
  22.     Iterator begin(){
  23.         return {_pstr};
  24.     }
  25.     Iterator end(){
  26.         return {_pstr+length()};
  27.     }

实现vector容器中的迭代器

迭代器一般实现成容器的嵌套结构。

在VectorT类中添加以下代码：

  1. class iterator {
  2.     public:
  3.         iterator(const T *p = nullptr)
  4.                 : _ptr((int *) p) {}
  6.         bool operator!=(const VectorT::iterator &it) {
  7.             return _ptr != it._ptr;
  8.         }
  10.         void operator++() {
  11.             ++_ptr;
  12.         }
  14.         T &operator*() { return *_ptr; }
  16.     private:
  17.         T *_ptr;
  18.     };
  20.     iterator begin(){
  21.         return {_first};
  22.     }
  24.     iterator end(){
  25.         return {_last};
  26.     }

迭代器的失效问题

1、调用erase后，当前位置到末尾元素的迭代器就会失效。

2、调用insert后，当前位置到末尾元素的迭代器就会失效

3、容器扩容后迭代器也会失效

首元素到插入点/删除点的迭代器依然有效

迭代器失效该怎么解决？要对迭代器进行更新操作！

不同容器的迭代器是不能进行比较运算的

vector中迭代器的实现（包含迭代器失效的判断）

  1. //
  2. // Created by 26685 on 2022-05-15 20:33.
  3. // Description:
  4. //
  6. #ifndef C___VECTORT_H
  7. #define C___VECTORT_H
  9. #include "AllocatorT.h"
  11. using namespace std;
  13. /**
  14.  * 容器底层内存开辟，内存释放，对象构造和析构都通过allocator实现
  15.  * @tparam T
  16.  * @tparam Alloc
  17.  */
  18. template<typename T, typename Alloc=AllocatorT<T> >
  19. class VectorT {
  20. public:
  21.     VectorT(int size = 10) {
  22. //        _first=new T[size];
  23.         _first = _alloctor.allocate(size);
  24.         _last = _first;
  25.         _end = _first + size;
  26.     }
  28.     ~VectorT() {
  29. //        delete[] _first;
  30.         //使用allocator对vector逐个删除
  31.         for (T *p = _first; p != _last; ++p) {
  32.             _alloctor.destory(p);
  33.         }
  34.         _alloctor.deallocate(_first);
  35.         _first = _last = _end = nullptr;
  36.     }
  38.     VectorT(const VectorT<T> &src) {
  39.         int size = src._end - src._first;
  40. //        _first = new T[size];
  41.         _first = _alloctor.allocate(size);
  42.         int len = src._last - src._first;
  43.         for (int i = 0; i < len; i++) {
  44. //            _first[i] = src._first[i];
  45.             _alloctor.contruct(_first + 1, src._first[i]);
  46.         }
  47.         _last = _first + len;
  48.         _end = _first + size;
  49.     }
  51.     VectorT<T> &operator=(const VectorT<T> &src) {
  52.         if (src == *this) {
  53.             return *this;
  54.         }
  55.         //delete[] _first;
  56.         for (T *p = _first; p != _last; p++) {
  57.             _alloctor.destory(p);
  58.         }
  59.         _alloctor.deallocate(_first);
  61.         int size = src._end - src._first;
  62.         _first = new T[size];
  63.         int len = src._last - src._first;
  64.         for (int i = 0; i < len; i++) {
  65. //            _first[i] = src._first[i];
  66.             _alloctor.contruct(_first + 1, src._first[i]);
  67.         }
  68.         _last = _first + len;
  69.         _end = _first + size;
  70.         return *this;
  71.     }
  73.     T &operator[](int index) {
  74.         if (index < 0 || index >= size()) {
  75.             throw "OutOfRangeException";
  76.         }
  77.         return _first[index];
  78.     }
  80.     void push_back(T val) {
  81.         if (full()) {
  82.             expend();
  83.         }
  84.         //*_last++ = val;
  85.         _alloctor.construct(_last, val);
  86.         _last++;
  87.     }
  89.     void pop_back() {
  90.         if (empty()) { return; }
  91.         verify(_last - 1, _last);
  92.         --_last;
  93.         _alloctor.destory(_last);
  94.     }
  96.     T back() const {
  97.         return *(_last - 1);
  98.     }
  100.     bool full() const {
  101.         return _last == _end;
  102.     }
  104.     bool empty() const {
  105.         return _first == _last;
  106.     }
  108.     int size() const {
  109.         return _last - _first;
  110.     }
  112.     /**
  113.      * 实现迭代器
  114.      */
  115.     class iterator {
  116.         friend void VectorT<T, Alloc>::verify(T *first, T *last);
  117.         friend iterator VectorT<T, Alloc>::insert(iterator it,const T& val);
  118.         friend iterator VectorT<T, Alloc>::erase(iterator it);
  120.     public:
  121.         /*iterator(const T *p = nullptr)
  122.                 : _ptr((int *) p) {}*/
  123.         /**
  124.          * 根据新的成员变量实现新的构造函数，使其能实现迭代器失效
  125.          * @param pvec 容器指针
  126.          * @param ptr 位置指针
  127.          */
  128.         iterator(VectorT<T, Alloc> *pvec = nullptr, T *ptr = nullptr) : _ptr(ptr), _pVec(pvec) {
  129.             Iterator_Base *itb = new Iterator_Base(this, _pVec->_head._next);//构造新节点
  130.             _pVec->_head._next = itb;//将头结点连接新节点
  131.         }//接下来就是在改变数组的过程中使迭代器失效
  133.         bool operator!=(const VectorT<T, Alloc>::iterator &it) {
  134.             /**
  135.              * 判断迭代器是否失效
  136.              */
  137.             if (_pVec == nullptr || _pVec != it._pVec) {
  138.                 throw "iterator incompatable!";
  139.             }
  141.             return _ptr != it._ptr;
  142.         }
  144.         void operator++() {
  145.             if (_pVec == nullptr) {
  146.                 throw "iterator invalid!";
  147.             }
  148.             ++_ptr;
  149.         }
  151.         T &operator*() {
  152.             if (_pVec == nullptr) {
  153.                 throw "iterator invalid!";
  154.             }
  155.             return *_ptr;
  156.         }
  158.     private:
  159.         T *_ptr;
  161.         /**
  162.          * 实现迭代器失效，首先要添加一个指向容器的指针
  163.          */
  164.         VectorT<T, Alloc> *_pVec;
  165.     };
  167.     /**
  168.      * 根据新的成员方法生成相应的begin和end方法
  169.      * @return
  170.      */
  171.     iterator begin() {
  172.         return {this, _first};
  173.     }
  175.     iterator end() {
  176.         return {this, _last};
  177.     }
  179.     /**
  180.      * 最后一步：判断迭代器是否失效
  181.      * @param first
  182.      * @param last
  183.      */
  184.     void verify(T *first, T *last) {
  185.         Iterator_Base *pre = &this->_head;
  186.         Iterator_Base *it = this->_head._next;
  187.         while (it != nullptr) {
  188.             if (it->_cur->_ptr > first && it->_cur->_ptr <= last) {
  189.                 //迭代器失效，把iterator持有的容器指针置null
  190.                 it->_cur->_pVec = nullptr;
  191.                 //删除当前迭代器节点，继续判断后面的迭代器节点是否失效
  192.                 pre->_next = it->_next;
  193.                 delete it;
  194.                 it = pre->_next;
  195.             }else{
  196.                 pre=it;
  197.                 it=it->_next;
  198.             }
  199.         }
  200.     }
  201.     /**
  202.      * 插入操作
  203.      * @param it 迭代器位置
  204.      * @param val 插入的值
  205.      * @return 迭代器
  206.      */
  207.     iterator insert(iterator it,const T& val){
  208.         /*
  209.          * 不考虑扩容，
  210.          * 不考虑指针的合法性
  211.          */
  212.         verify(it._ptr-1,_last);
  213.         T* p=_last;
  214.         while(p>it._ptr){
  215.             _alloctor.construct(p,*(p-1));
  216.             _alloctor.destory(p-1);
  217.             p--;
  218.         }
  219.         _alloctor.construct(p,val);
  220.         _last++;
  221.         return {this,p};
  223.     }
  225.     iterator erase(iterator it){
  226.         verify(it._ptr-1,_last);
  227.         T* p=it._ptr;
  228.         while(p<_last-1){//元素向前移
  229.             _alloctor.destory(p);
  230.             _alloctor.construct(p,*(p+1));
  231.             p++;
  232.         }
  233.         _alloctor.destory(p);
  234.         _last--;
  235.         return {this,it._ptr-1};
  237.     }
  239. private:
  240.     T *_first;//表示vector起始位置
  242.     T *_last;//表示vector定义元素的末尾
  244.     T *_end;//表示vector的末尾
  246.     Alloc _alloctor;//负责内存管理
  248.     /**
  249.      * 在链表的结构中保存每个迭代器
  250.      */
  251.     struct Iterator_Base {
  252.         Iterator_Base(iterator *c = nullptr, VectorT<T, Alloc>::Iterator_Base *n = nullptr) : _cur(c), _next(n) {}
  254.         iterator *_cur;
  255.         Iterator_Base *_next;
  256.     };
  258.     /**
  259.      * 头结点
  260.      */
  261.     Iterator_Base _head;
  263.     void expend() {//size扩大两倍
  264.         int size = _end - _first;
  265. //        T *ptmp = new T[size * 2];
  266.         T *ptmp = _alloctor.allocate(2 * size);
  267.         for (int i = 0; i < size; i++) {
  268.             //ptmp[i] = _first[i];
  269.             _alloctor.construct(ptmp + i, _first[i]);
  270.         }
  271.         //delete[] _first;
  272.         for (T *p = _first; p != _last; p++) {
  273.             _alloctor.destory(p);
  274.         }
  275.         _alloctor.deallocate(_first);
  277.         _first = ptmp;
  278.         _last = _first + size;
  279.         _end = _first + (2 * size);
  280.     }
  281. };
  283. #endif //C___VECTORT_H

深入理解new和delete的原理

1、malloc和new的区别：

  • malloc按字节开辟内存，new开辟内存时需要指定类型，如 new int[10]，所以malloc开辟内存返回的都是void*
  • malloc只负责开辟空间，new不仅有malloc的功能，还可以进行数据的初始化
  • malloc开辟内存失败返回nullptr指针，new抛出的是bad_alloc类型的异常

2、free和delete的区别：

  • delete调用析构函数，free是内存释放

检查内存泄漏要重写new和delete

new和delete能混用吗？C++为什么要区分单个元素和数组的内存分配和释放呢？

对于内置类型int等，可以混用。但是对于自定义的类，就不能混用，因为自定义的类类型有析构函数，为了正确的析构函数，在开辟对象数组的时候会在数组前多开辟4个字节，记录对象的个数。

  1. //两个操作符的重载
  2. void* operator new(size_t size){
  3.     void* p=malloc(size);
  4.     if(p== nullptr){
  5.         throw bad_alloc();
  6.     }
  7.     cout<<"opeartor new addr:"<<p<<endl;
  8.     return p;
  9. }
  11. void operator delete (void *ptr) noexcept{
  12.     cout<<"opeartor delete addr:"<<ptr<<endl;
  13.     free(ptr);
  14. }

new和delete重载实现对象池应用

对象池是在堆上开辟的静态链表

  1. //
  2. // Created by 26685 on 2022-05-17 9:40.
  3. // Description:
  4. //
  6. #ifndef C___QUEUEWITHITEMPOOL_H
  7. #define C___QUEUEWITHITEMPOOL_H
  9. #include <iostream>
  11. using namespace std;
  13. template<typename T>
  14. class Queue {
  16. public:
  17.     Queue(){//默认构造
  18.         _front=_rear=new QueueItem();
  19.     }
  20.     ~Queue(){
  21.         QueueItem* cur=_front;
  22.         while(cur!= nullptr){//遍历链表，依次删除元素
  23.             _front=_front->_next;
  24.             delete cur;
  25.             cur=_front;
  26.         }
  27.     }
  29.     void push(const T& val){
  30.         QueueItem* item=new QueueItem(val);
  31.         _rear->_next=item;
  32.         _rear=item;//尾部元素置为新值，与front区分开
  33.     }
  35.     void pop(){
  36.         if(empty()){
  37.             return;
  38.         }
  39.         QueueItem* first=_front->_next;
  40.         _front->_next=first->_next;
  41.         if(_front->_next== nullptr){//如果队列只有一个有效节点
  42.             _rear=_front;
  43.         }
  44.         delete first;
  45.     }
  47.     bool empty() const{
  48.         return _front==_rear;
  49.     }
  51.     T front()const {
  52.         return _front->_next->_data;
  53.     }
  55. private:
  56.     /**
  57.      * 实现一个链式的队列，带有头结点
  58.      */
  59.     struct QueueItem {
  60.         QueueItem(T data=T()):_data(data),_next(nullptr){}
  62.         //重载new实现对象池
  63.         void* operator new (size_t size){
  64.             if(_itemPool== nullptr){//如果未开辟空间；如果当前内存池使用完，最后一个元素指向的也是nullptr，会分配新的内存池
  65.                 _itemPool=(QueueItem*)new char[POOL_ITEM_SIZE*sizeof(QueueItem)];//开辟对象池
  66.                 //我们用char，按字节开辟，因为如果用new QueueItem,
  67.                 //就又会调用到当前这个方法了，
  68.                 //我们现在就是在给QueueItem自定义new运算符重载
  69.                 QueueItem* p=_itemPool;
  70.                 for(;p<_itemPool+POOL_ITEM_SIZE-1;++p){
  71.                     p->_next=p+1;//初始化连续链表
  72.                 }
  73.                 p->_next= nullptr;
  74.             }
  75.             //新建queueItem的时候会使用对象池中未使用的节点，然后指向下一个未使用的节点
  77.             QueueItem* p=_itemPool;
  78.             _itemPool=_itemPool->_next;
  80.             return p;
  81.         }
  83.         void operator delete (void* ptr){
  84.             QueueItem* p=(QueueItem*)ptr;
  85.             p->_next=_itemPool;
  86.             _itemPool=p;
  87.         }
  89.         T _data;
  90.         QueueItem *_next;
  92.         static const int POOL_ITEM_SIZE=100000;
  94.         static QueueItem *_itemPool;
  96.     };
  98.     QueueItem* _front;//指向头结点
  99.     QueueItem* _rear;//指向队尾，
  100. };
  102. template<typename T>
  103. typename Queue<T>::QueueItem* Queue<T>::QueueItem::_itemPool= nullptr;
  105. #endif //C___QUEUEWITHITEMPOOL_H

五、C++运算符重载，使面向对象编程更方便的更多相关文章

  1. 四、C# 5.0 新特性——Async和Await使异步编程更简单

    一.引言 .NET 4.5 的推出,对于C#又有了新特性的增加--就是C#5.0中async和await两个关键字,这两个关键字简化了异步编程,之所以简化了,还是因为编译器给我们做了更多的工作,下面就 ...

  2. 【转】【C#】C# 5.0 新特性——Async和Await使异步编程更简单

    一.引言 在之前的C#基础知识系列文章中只介绍了从C#1.0到C#4.0中主要的特性,然而.NET 4.5 的推出,对于C#又有了新特性的增加--就是C#5.0中async和await两个关键字,这两 ...

  3. 转：[你必须知道的异步编程]C# 5.0 新特性——Async和Await使异步编程更简单

    本专题概要: 引言 同步代码存在的问题 传统的异步编程改善程序的响应 C# 5.0 提供的async和await使异步编程更简单  async和await关键字剖析 小结 一.引言 在之前的C#基础知 ...

  4. [你必须知道的异步编程]C# 5.0 新特性——Async和Await使异步编程更简单

    本专题概要: 引言 同步代码存在的问题 传统的异步编程改善程序的响应 C# 5.0 提供的async和await使异步编程更简单  async和await关键字剖析 小结 一.引言 在之前的C#基础知 ...

  5. C++（三十五） — 运算符重载

    运算符重载的实质:函数重载.除了增加一个关键字 operator 外,与函数重载没有区别,都是通过该类的某个对象来访问重载运算符. (1)重载运算符时,运算符运算顺序和优先级不变,操作数个数不变: ( ...

  6. Python之路【第五篇续】：面向对象编程二

    aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAABgQAAALaCAIAAABxja8cAAAgAElEQVR4nOzd6X9Tdd74/+uv+f5uzF

  7. C# 5.0 新特性——Async和Await使异步编程更简单

    http://www.cnblogs.com/zhili/archive/2013/05/15/csharp5asyncandawait.html http://blog.zhaojie.me/201 ...

  8. C++ 关于运算符重载

    转载来源:http://c.biancheng.net/cpp/biancheng/view/216.html 重载运算符的函数一般格式如下:    函数类型 operator 运算符名称 (形参表列 ...

  9. C++ 运算符重载三（链式编程）

    //运算符重载之链式编程 #include<iostream> using namespace std; //对于友元函数重载运算符只适用于左操作数是系统变量的场景 //因为成员无法在系统 ...

随机推荐

  1. 路径规划—BUG算法

  2. Spring Security OAuth 笔记

    1  单点登录 关于单点登录的原理,我觉得下面这位老哥讲的比较清楚,有兴趣可以看一下,下面我把其中的重点在此做个笔记总结 https://juejin.cn/post/6844904079274197 ...

  3. 【转载】10个Web3D可视化精彩案例

    1.化学元素周期表 六种排列方式,炫酷动画效果,TWaver 3D轻松实现. 演示地址:http://demo.servasoft.com/che... 2.DNA螺旋图 DNA3D模型,包含几千个球 ...

  4. javaweb图书管理系统之账号密码验证登录

    验证账号与密码是否正确功能 一.注册功能 首先,在验证账号与密码是否正确的前提下的,需要先注册一个账号,如果没有账号,就会进不去,也无法验证. 其实,注册功能就是一个添加的功能,仿照我的第一篇文章,往 ...

  5. mysql在cmd中查询到的汉字乱码问题解决 方法一

    只要执行如上两个 set character_set_connection = gbk; set character_set_results= gbk; 将编码格式转换成gbk即可

  6. jdbc连接MySQL数据库＋简单实例（普通JDBC方法实现和连接池方式实现）

    jdbc连接数据库 总结内容 1. 基本概念 jdbc的概念 2. 数据库连接 数据库的连接 DAO层思想 重构设计 3. 事务 概念 事务的ACID属性 事务的操作 4. 连接池 为什么要使用连接池 ...

  7. C++---变量、数据类型和运算符

    内存 计算机使用内存来记忆或存储计算时所使用的的数据. 计算机执行程序时, 组成程序的指令和程序所操作的数据都必须存放在某个地方, 而这个地方就是计算机的内存, 也称为主存, 或随机访问存储器(RAM ...

  8. Go语言 映射（map）

    Go语言  映射(map) 1. 什么是 map2. 创建 map3. 访问 map4. nil map和空map5. map中元素的返回值6. len()和delete()7. 测试map中元素是否 ...

  9. linux中查看端口号使用情况

    百度一圈,以下是整理来的操作命令. 1.netstat -anp |grep (端口号) 这个方法可以直观看到对应端口号是否被使用. 2.netstat -nultp 这个方法可以看到该机上所有以用的 ...

  10. SSM实现个人博客-day04

    项目源码免费下载:SSM实现个人博客 有问题询问vx:kht808 3.项目搭建(SSM整合) (1)创建maven工程,导入相应的依赖 <properties> <project. ...