305-STL的空间配置器(1)

梦里梦外; 2023-01-19 09:46 56阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
**头文件<stl\_alloc.h>专门用于管理内存，内存的申请和释放（我们可以想象成operator new）  
头文件<stl\_construct.h>，专门管理某个内存空间中的构建或者析构对象。  
头文件<stl\_uninitialized.h>是对大块内存的填充和拷贝**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
**在多线程情况下，需要加锁和解锁。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
当这个内存块的大小大于128字节，我们认为这个块足够大，把它交给第一级配置器（直接使用malloc和free）去配置。  
当这个内存块的大小小于128字节，我们认为这个块小，**为了降低额外负担**（我们malloc分配一块内存时，真实的情况是，系统分配的内存大小远大于我们申请的大小，包含了4字节的上越界标记，4字节的下越界标记和28字节的头部信息，造成内存和时间效率降低），，我们把它交给内存池，第二级配置器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]

## 封装第一级配置器 ##

**包装了C语言的malloc ,free , realloc**

#ifndef YHP_ALLOC_H
    #define YHP_ALLOC_H
    #include<iostream>
    namespace yhp
    {
        
    #if 0
    #include<new>
    #define __THROW_BAD_ALLOC throw std::bad_alloc;
    #elif !defined(__THREAD_BAD_ALLOC)//如果没有定义 ，就打印内存溢出 
    //#include<iostream>
    #define __THROW_BAD_ALLOC std::cerr<<"out of memory"<<std::endl; exit(1)
    #endif
    
    //第一级配置器 
    template<int inst>
    class __malloc_alloc_template
    {
        
    private:
    	static void *oom_malloc(size_t n)//分配n个空间 
    	//要么能申请到空间然后走人，要么抛出异常 
    	{
        
    		void * result = NULL;
    		void (*my_malloc_handler)() = NULL;
    		for(;;)//无限循环 
    		{
        
    			my_malloc_handler = __malloc_alloc_oom_handler;
    			if(NULL == my_malloc_handler)
    			{
        
    				__THROW_BAD_ALLOC;//调用宏，抛出异常 
    			}
    			(*my_malloc_handler)();
    //回调函数，1、释放更多的空间2、指明新的释放函数3、如果没有指明新的释放函数把程序结束掉 
    			result = malloc(n);
    			if(result != NULL)
    			{
        
    				return result;//成功了，内存的返回 
    			}
    		}
    	}
    	static void *oom_realloc(void *p,size_t new_sz)//追加内存的分配 
    	{
        
    		void * result = NULL;
    		void (*my_malloc_handler)() = NULL;
    		for(;;)
    		{
        
    			my_malloc_handler = __malloc_alloc_oom_handler;
    			if(NULL == my_malloc_handler)
    			{
        
    				__THROW_BAD_ALLOC;
    			}
    			(*my_malloc_handler)();
    			result = realloc(p,new_sz);
    			if(result != NULL)
    			{
        
    				return result;
    			}
    		}
    	}
    	static void (*__malloc_alloc_oom_handler)();//函数指针 
    public:
    	static void *allocate(size_t n)//n是字节个数，不是元素的个数，内存的分配 
    	{
        
    		void *result = malloc(n);
    		if(NULL == result)
    		{
        
    			result = oom_malloc(n);
    		}
    		return result;
    	}
    	static void deallocate(void *p,size_t n)//释放内存空间 
    	{
        
    		free(p);
    	}
    	static void *reallocate(void *p,size_t old_sz,size_t new_sz)//追加内存空间 
    	{
        
    		void *result = realloc(p,new_sz);
    		if(NULL == result)
    		{
        
    			result = oom_realloc(p,new_sz);
    		}
    		return result;
    	}
    	static void (*set_malloc_handler(void (*f)()) )() 
    	{
        
    		void (*old)() = __malloc_alloc_oom_handler;
    		__malloc_alloc_oom_handler = f;
    		return old;
    	}
    };
    
    template<int inst>
    void (*__malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = NULL;
    ///
    typedef __malloc_alloc_template<0>   malloc_alloc;

**测试代码如下**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]

## 如果我们在程序的运行过程中，内存不足了怎么办？ ##

**进入主函数之前，p1,p2指向相应的申请的内存空间。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
**我们写了一个函数yhp，把p1释放掉，把第二个函数rj放进去，  
rj这个函数的作用是释放p2，如果释放空间后，把空放进去。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]  
**然后我们书写主函数**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
运行程序，我们看到，首先调用set\_malloc\_handler，把这个函数指针指向hp这个函数，申请空间的时候，调动malloc，如果我把result置为空，要调动oom\_malloc，my\_malloc\_handler获得了hp的指针，不为空，调动hp的函数释放更多的空间，把rj这个函数注册进去，假设我再把result置为空，没有申请到空间，my\_malloc\_handler获得了rj的指针，不为空，再调动rj的释放内存函数，malloc再申请，我们又给个result=0，my\_malloc\_handler变成了空，调动宏，打印了错误，程序退出，内存用完了。  
**也就是说，先开始估算这个程序所需要的内存，直接先占领，我的程序在运行的过程中，如果内存不足，通过oom\_malloc，调动回调函数，首先指向hp函数，释放内存，再申请空间，释放内存，如果还要申请，为空了，就确实是内存用完了。**  
**注意**：rj的函数里直接置为空放进去。防止如果再调用回调函数，那个回调函数中又占用了空间，但是内存不足，从而造成了死循环。

## 第二级配置器 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]  
**如下图，最上面的一排数字代表内存的大小。下排的数字代表数组的下标**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]  
在最开始的时候，都是空。假设我们需要12个字节，**选取** 1下标对应的16个字节的内存块，没有找到，我们就先malloc 16\*20 \*2=640个字节的内存空间，进行注水，提取出320字节，把16个字节给给用户，剩下19个16字节块变成一个块一个块，一个块大小为16个字节，以链表的形式，链起来，头结点指向1下标的位置，如果我们还需要16个字节，就使用链表的头删，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]  
**这样比malloc速度快多了，而且这16个字节是没有上越界下越界标记和头部信息的。**  
如果我们需要40个字节，下标4的位置为空，STL就要把剩下的320字节分了，40乘以20大于320,320除以40是8，刚好分配8个块出去。把第一个块给用户，剩下的字节划分为7个块，划分成一块一块大小为40字节，以链表的形式链到4下标的位置。如果我们又需要70字节，找到8下标，为空，池子里面没有水了，就再malloc 72x20x2个字节的内存块，注水，把池子分为一部分操作。

**函数实现的解释**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 18]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 19]  
![在这里插入图片描述][20210509210716881.png_pic_center]  
**obj是一个联合体，类型成员**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 21]  
**free\_list**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 24]

## 第二适配器的代码实现 ##

//第二级适配器 
    enum {
         __ALIGN = 8};//起始块的大小，8的倍数 
    enum {
         __MAX_BYTES = 128};//最大字节个数是128 
    enum {
         __NFREELISTS = __MAX_BYTES / __ALIGN }; //自由链的大小是16
    
    template<bool threads,int ints>//是否是多线程 
    class __default_alloc_template//默认空间配置器 
    {
        
    private:
    	union obj//这个结构就是一个一个的块 
    	{
        
    		union obj * free_list_link;// 相当于next，链 
    		char client_data[1];//客户 
    	};
    private:
    	static obj * volatile free_list[__NFREELISTS];//从内存查，数组下标0 1 ... 15
    	static char *start_free;//指向池子的开头 
    	static char *end_free;//指向池子的结尾 
    	static size_t heap_size;//累计从堆区申请的空间大小 
    
    	static size_t ROUND_UP(size_t bytes)//变成8的倍数 
    	{
        
    		return (bytes + __ALIGN - 1) & ~(__ALIGN - 1);
    	}
    	static size_t FREELIST_INDEX(size_t bytes)//计算申请空间大小的对应块的大小，返回下标 
    	{
        
    		return (bytes + __ALIGN -1) / __ALIGN  - 1;
    	}
    	
    	static char *chunk_alloc(size_t size,int &nobjs)//往池子里注水 
    	{
        //                              16       20
    		char *result = NULL;
    		size_t total_bytes = size * nobjs; //总的大小 
    		size_t bytes_left = end_free - start_free;//大小 
    		if(bytes_left >= total_bytes) // 满足了20块
    		{
        
    			result = start_free;
    			start_free = start_free + total_bytes;
    			return result;
    		}else if(bytes_left >= size) //不够20个块，看看能不能足够1块
    		{
        
    			nobjs = bytes_left / size;//新的块 
    			total_bytes = size*nobjs; //新的大小 
    			result = start_free;
    			start_free = start_free + total_bytes;
    			return result;
    		}else//连一块都不够 
    		{
        
    			size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size>>4);//申请新的池子 
    			if(bytes_left > 0)//剩下的但是不够的内存填充进去 
    			{
        
    				obj * volatile * my_free_list = free_list + FREELIST_INDEX(bytes_left);
    				((obj*)start_free)->free_list_link = *my_free_list;
    				*my_free_list = (obj*)start_free;
    			}
    			start_free = (char*)malloc(bytes_to_get);
    			if(NULL == start_free)//通过malloc申请空间失败了 
    			{
        
    				obj * volatile * my_free_list = NULL;
    				for(int i = size ; i <= __MAX_BYTES; i += __ALIGN )//每次加8，扫描 
    				{
        
    					my_free_list = free_list + FREELIST_INDEX(i);
    					obj * p = *my_free_list;
    					if(p != NULL)//不为空 
    					{
        
    						*my_free_list = p->free_list_link;
    						start_free = (char*)p;
    						end_free = start_free + i;
    						return chunk_alloc(size,nobjs);//是原来池子上的内存 
    					}
    				}
    				start_free = (char*)malloc_alloc::allocate(bytes_to_get);
    			}
    			end_free = start_free + bytes_to_get;
    			heap_size += bytes_to_get;
    			return chunk_alloc(size,nobjs);
    		}
    	}
    	static void *refill(size_t n) //把池子里的空间拿出来进行分块，链起来， n byte num ; n % 8 == 0;
    	{
        
    		int nobjs = 20;
    		char *chunk = chunk_alloc(n,nobjs);//注水20个块 
    		if(1 == nobjs)
    		{
        
    			return chunk;//?
    		}
    		obj * volatile * my_free_list = NULL;
    		obj * result = (obj*)chunk;
    		obj * current_obj = NULL, *next_obj = NULL;
    		int i = 0;
    		my_free_list = free_list + FREELIST_INDEX(n);
    		*my_free_list = next_obj = (obj*)(chunk + n);
    		for(i = 1; ; ++i)
    		{
        
    			current_obj = next_obj;
    			next_obj = (obj*)((char*)next_obj + n);
    			if(i == nobjs - 1)
    			{
        
    				current_obj->free_list_link = NULL;
    				break;
    			}
    			current_obj->free_list_link = next_obj;
    		}
    		return result;
    	}
    
    public:
    	static void *allocate(size_t n)// 申请空间，n byte num;
    	{
        
    		if(n > (size_t)__MAX_BYTES)//大于128 
    		{
        
    			return malloc_alloc::allocate(n);//调用第一级适配器 
    		}
    		obj * volatile * my_free_list = NULL;//二级指针 
    		obj * result = NULL;//一级指针 
    
    		my_free_list = free_list + FREELIST_INDEX(n); 
    		result = *my_free_list;
    		if(NULL == result)
    		{
        
    			void *r = refill(ROUND_UP(n));// n 12 = 16
    			return r;
    		}
    		*my_free_list = result->free_list_link;
    		return result;
    	}
    	
    	static void deallocate(void *p,size_t n)//释放空间 
    	{
        
    		if(n > (size_t) __MAX_BYTES)
    		{
        
    			malloc_alloc::deallocate(p,n);
    			return ;
    		}
    		obj *q = (obj*)p;//把块还回去 
    		obj * volatile * my_free_list = free_list + FREELIST_INDEX(n);//12//16
    		q->free_list_link = *my_free_list;
    		*my_free_list = q;//把块链接起来 
    		return ;
    	} // malloc realloc , 
    	static void *reallocate(void *p,size_t old_sz,size_t new_sz)//追加空间 
    	{
        
    		if(old_sz > __MAX_BYTES && new_sz > __MAX_BYTES)
    		{
        
    			return malloc_alloc::reallocate(p,old_sz,new_sz);
    		}
    		if(ROUND_UP(old_sz) == ROUND_UP(new_sz))// 12 14 // 16
    		{
        
    			return p;//足够了，不需要重新分配 
    		}
    		// old_sz < 128  new_sz < 128;
    		//    >               <
    		//   <                >
    		size_t sz = old_sz < new_sz ? old_sz:new_sz;
    		void *s = allocate(new_sz);//调动一级适配器 
    		memmove(s,p,sz);
    		deallocate(p,old_sz);//释放p 
    		return s;
    	}
    };
    template<bool threads,int ints>
    typename __default_alloc_template<threads,ints>::obj * volatile
    __default_alloc_template<threads,ints>::free_list[__NFREELISTS]={
        NULL}; 
    
    template<bool threads,int ints>
    char * __default_alloc_template<threads,ints>::start_free = NULL;
    
    template<bool threads,int ints>
    char * __default_alloc_template<threads,ints>::end_free = NULL;
    
    template<bool threads,int ints>
    size_t __default_alloc_template<threads,ints>::heap_size = 0;

## 书写<stl\_construct.h> ##

#ifndef YHP_CONSTRUCT_H
    #define YHP_CONSTRUCT_H
    #include"yhp_iterator.h"
    #include"yhp_type_traits.h"
    namespace yhp
    {
        
    template<class T1,class T2>
    inline void construct(T1 *p,const T2 &val)//带参数的构造函数 
    {
        
    	new(p) T1(val);//构建对象并初始化，定位new 
    }
    template<class T>
    inline void construct(T *p)//不带参数的构造函数 
    {
        
    	new(p)  T();
    }
    
    template<class T>
    inline void destroy(T *p)//销毁函数 
    {
        
    	p->~T();
    }
    
    template<class _FI>
    inline void destroy(_FI _F, _FI _L)
    {
        
    	__destroy(_F,_L,value_type(_F));
    }
    template<class _FI,class T>
    inline void __destroy(_FI _F,_FI _L , T *)
    {
        
    	__type_traits<T>();
    	typedef typename __type_traits<T>::has_trivial_destructor  dest;
    	__destroy_aux(_F,_L,dest());
    }
    template<class _FI>
    inline void __destroy_aux(_FI _F,_FI _L , __true_type)
    {
        }
    
    template<class _FI>
    inline void __destroy_aux(_FI _F,_FI _L , __false_type)
    {
        
    	for(; _F != _L; ++_F)
    	{
        
    		destroy(&*_F);
    	}
    }
    
    
    }
    #endif

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221021/37983d896000431da0a68f7490a16471.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221021/53fb9fbff8c9476b8feb01df6f9bc453.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221021/63c47eac8b524da39583468d5d63fdb6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221021/fcd01e338c294737b8abefe61b6d012a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221021/7daa150ed2d94c38897e821404332cd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221021/a37be56f92b14709a2cf57a162b909b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221021/b313173b6e8c4c548fad6c0e87dc2b3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221021/28b9842a85b048b48947ea57fda28b68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221021/9a1261116b084f488ba5ce746f6fda9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221021/d3bfa41bc5d74bf3af8de73e36ad2d96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221021/a00cae716bc34b8f86ba1fecd9deb036.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221021/9e25670f5a414853a07f7ca749c2c5d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221021/58f2ef955fdd4bd8b20c84811937a248.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221021/e877d8af02044a3db1f4fa04f0cd8198.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221021/6de64a12b30245dda51862c96f2eaa54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221021/3856b5aeac9e4b8ba60f86907647021b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221021/85c85fd17253434e9ef33c64657bd098.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221021/5d444ecda0f64092b44c0dc6129ce475.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221021/5924fc98414945b692af5e6803db7015.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221021/eedb9478c30d4ac6a46351723dd83e41.png
[20210509210716881.png_pic_center]: /images/20221021/00eb6fbdac58451894edaafa04df542c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221021/d92c1813e66847a8ac552c169efeb401.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221021/b4dcb8ad9e2f42e185fff8ca123ab195.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20221021/884cba018101408da54b68d216523f29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 23]: /images/20221021/ac59d390a0f84012b5d4cb14a9fbd662.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 24]: /images/20221021/5a469ccc046a421cb443eaa06ec087e4.png