复数类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. SQL数据库之“TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)”

    一.介绍 样本:TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2) 解析:TIMESTAMPDIFF(格式,开始时间,结束时间) 二.参数解析 格式: ...

  2. InfoQ Trends Report

    InfoQ Trends Report InfoQ Trends Report Culture & Methods Trends Report - March 2021 DevOps and ...

  3. 设计模式之：抽象工厂模式AbstractFactoryPattern的实现

    相比于工厂模式,抽象工厂模式的每个工厂可以创建产品系列,而不是一个产品: 抽象工厂用到的技术:接口.多态.配置文件.反射: 抽象工厂模式的设计原则: 实现客户端创建产品和使用产品的分离,客户端无须了解 ...

  4. spark-shell报错java.lang.IllegalArgumentException: java.net.UnknownHostException: namenode

    在使用spark on yarn启动spark-shell时,发现报错: 是说找不到主机名为namenode的主机,那么应该是配置文件出错了. 经过检查,发现是spark-defaults.conf文 ...

  5. java中hashCode和equals什么关系，hashCode到底怎么用的

    Object类的hashCode的用法:(新手一定要忽略本节,否则会很惨) 马 克-to-win:hashCode方法主要是Sun编写的一些数据结构比如Hashtable的hash算法中用到.因为ha ...

  6. Blazor组件自做三 : 使用JS隔离封装ZXing扫码

    Blazor组件自做三 : 使用JS隔离封装ZXing扫码 本文基础步骤参考前两篇文章 Blazor组件自做一 : 使用JS隔离封装viewerjs库 Blazor组件自做二 : 使用JS隔离制作手写 ...

  7. QT 如何让release生成的EXE可在他人电脑上运行（尝试了全网的方法后，这应该能帮你解决）

    这两天,迅速上手了QT并用其基于C++编写了一个含UI的小程序 跳过中间的开发阶段 当我兴致满满的要将程序打包时,却是费尽周折,搜尽全网的关于QT的打包教程,最后都不顶用. 后面自己和队友的共同发现, ...

  8. Water 2.5.8 发布，一站式服务治理平台

    Water(水孕育万物...) Water 为项目开发.服务治理,提供一站式解决方案(可以理解为微服务架构支持套件).基于 Solon 框架开发,并支持完整的 Solon Cloud 规范:已在生产环 ...

  9. c++对于c的拓展_引用的本质是指针常量

    本质:c++底层实现的指针常量(Type & ref =val; // Type *const ref =&val)

  10. Mybatis-typeAliases的作用

    其他具体代码请访问->mybatis的快速入门 1.在mybatis核心配置文件SqlMapperConfig.xml中配置别名 <!-- 定义别名--> <typeAlias ...