• Soldier

    人生得意须尽欢,莫使金樽空对月🥳

    2022-09-04 00:05:36

  • Soldier

    std::prev_permutation
    它用于将[first, last)范围内的元素重新排列为上一个按字典顺序排列的排列。排列是N的每一个!元素可以采用的可能排列方式(其中N是范围内的元素数量)。可以根据它们在字典上的比较方式来排列不同的排列顺序。
    与std::next_permutation相对应

    2022-07-03 17:26:18

  • Soldier

    std::next_permutation
    std::next_permutation它用于将[first, last]范围内的元素重新排列到下一个字典上更大的排列。排列是N的每一个!元素可以采用的可能排列方式(其中N是范围内的元素数量)。可以根据它们在字典上的比较方式来排序不同的排列。
    556. 下一个更大元素 III

    2022-07-03 17:22:57

  • Soldier
    template <typename Alloc>
    void TestAlloc(Alloc&& alloc, int32_t count)
    {
    	typedef Alloc::value_type ValueType;
    	const size_t value_size = sizeof(ValueType);
    
    	ValueType *p1{ nullptr }, *p2{ nullptr }, *p3{ nullptr };
    
    	p1 = alloc.allocate(count);
    	p2 = alloc.allocate(count);
    	p3 = alloc.allocate(count);
    
    	std::cout << "p1:[" << (void*)p1 << "] p2:[" << (void*)p2 << "] p3:[" << (void*)p3 << "]\n";
    
    	alloc.deallocate(p1, value_size);
    	alloc.deallocate(p2, value_size);
    	alloc.deallocate(p3, value_size);
    }
    
    void TestAlloc()
    {
    	TestAlloc(std::allocator<int32_t>(), 1);
    }
    
    

    2022-05-06 14:58:15

  • Soldier

    vector删除元素会消耗额外的时间用于内存拷贝,删除尾部元素时消耗时间是常数值与大小无关。
    xutility
    4417-4434
    _InIt _First, //需要删除元素的下一个元素
    _InIt _Last, //end
    _OutIt _Dest//需要删除的元素位置

    template <class _InIt, class _OutIt>
    _CONSTEXPR20 _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
        // move [_First, _Last) to [_Dest, ...)
        // note: _Move_unchecked has callers other than the move family
        if constexpr (_Ptr_move_cat<_InIt, _OutIt>::_Trivially_copyable) {
    #ifdef __cpp_lib_is_constant_evaluated
            if (!_STD is_constant_evaluated())
    #endif // __cpp_lib_is_constant_evaluated
            {
                return _Copy_memmove(_First, _Last, _Dest);
            }
        }
    //删除一个元素时,会将要删除元素之后的所有元素都向前移一个位置
        for (; _First != _Last; ++_Dest, (void) ++_First) {
            *_Dest = _STD move(*_First);
        }
    
        return _Dest;
    }
    

    2022-05-01 14:16:29

  • Soldier

    vector扩容机制,不同厂商有不同的方式。
    linux下以2倍扩容,vs下为1.5倍扩容
    VS:
    vector文件
    1683-1699 row
    重点为1629行:

     const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;
    
        _CONSTEXPR20_CONTAINER size_type _Calculate_growth(const size_type _Newsize) const {
            // given _Oldcapacity and _Newsize, calculate geometric growth
            const size_type _Oldcapacity = capacity();
            const auto _Max              = max_size();
    
            if (_Oldcapacity > _Max - _Oldcapacity / 2) {
                return _Max; // geometric growth would overflow
            }
    
            const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;
    
            if (_Geometric < _Newsize) {
                return _Newsize; // geometric growth would be insufficient
            }
    
            return _Geometric; // geometric growth is sufficient
        }
    

    2022-05-01 13:53:11

  • Soldier

    malloc
    32位程序8字节对齐
    64位程序16字节对齐

    32位程序 malloc 自带8字节cookie

    32位程序:
    malloc(sizeof(char)*8) //实际占用16字节
    malloc(sizeof(char)*9) //实际占用24字节

    2022-04-30 18:09:55

  • Soldier

    重载输出流运算符

    template <typename _Type>
    std::ostream& operator<<(std::ostream& s, const Z<_Type>& z)
    {
    	return s << z.Get();
    }
    
    template <typename _Type>
    std::ostream& operator<<(std::ostream& s, const vector<Z<_Type>>& vec)
    {
    	for (const auto& it : vec)s << it << " ";
    	return s;
    }
    

    2021-12-01 15:41:47

  • Soldier

    对于map,删除erase之后,只会影响到当前的iterator

    for (auto iter = mmmap.begin(); iter != mmmap.end(); )
    {
    	if (iter->second % 2 == 0)
    	{
    	        mmmap.erase(iter++);
    	}
    	else
    	{
    		++iter;
    	}
    }
    

    2021-12-01 15:35:11

  • Soldier

    std::vector安全删除元素。
    vector删除元素会导致迭代器失效,后面的迭代器未知。

    for (auto iter = findTest.begin(); iter != findTest.end();)
    {
    	if (*iter % 2 == 0)
    	{
    		iter = findTest.erase(iter);
    	}
    	else
    	{
    		++iter;
    	}
    }
    

    2021-12-01 15:32:04