elc::defs::memory::get_n 命名空间参考

类
struct	base_get_t
struct	copy_get_t
struct	get_forward_resize_t
struct	get_resize_t
struct	get_size_of_get_t
struct	get_t
struct	unget_t

函数
template<typename T >
void	alloc_size_cut (T *&arg, size_t to_size) noexcept
template<typename T >
void	alloc_size_grow (T *&arg, size_t to_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
void	alloc_size_grow_with_insert_uninitialized_data (T *&arg, size_t insert_pos, size_t insert_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
auto	alloc_size_grow_with_insert_uninitialized_data (T *&arg, size_t to_size, size_t insert_pos, size_t insert_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
auto	part_used_block_alloc_size_grow_with_insert_uninitialized_data (T *&arg, size_t to_size, size_t insert_pos, size_t insert_size, size_t used_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
void	forward_alloc_size_cut (T *&arg, size_t to_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
void	forward_alloc_size_grow (T *&arg, size_t to_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
auto	forward_alloc_size_grow_with_insert_uninitialized_data (T *&arg, size_t to_size, size_t insert_pos, size_t insert_size) noexcept(move.trivial< T > or move.nothrow< T >)
template<typename T >
auto	part_used_block_forward_alloc_size_grow_with_insert_uninitialized_data (T *&arg, size_t to_size, size_t insert_pos, size_t insert_size, size_t used_size) noexcept(move.trivial< T > or move.nothrow< T >)

变量
template<typename T >
constexpr get_t< T >	get {}
constexpr struct elc::defs::memory::get_n::unget_t	unget
constexpr struct elc::defs::memory::get_n::get_resize_t	get_resize
constexpr struct elc::defs::memory::get_n::get_forward_resize_t	get_forward_resize
constexpr struct elc::defs::memory::get_n::get_size_of_get_t	get_size_of_get
constexpr struct elc::defs::memory::get_n::copy_get_t	copy_get

函数说明

alloc_size_cut()

template<typename T >

void elc::defs::memory::get_n::alloc_size_cut ( T *&  arg, size_t  to_size  )

noexcept

向后减小数据块大小并转移原有实例的生命周期，但并不析构旧的实例

参数

arg	原有数据块
to_size	新的数据块大小

在文件 all_defs.cpp 第 21217 行定义.

                                                      {
        realloc(arg,to_size);
    }

函数调用图:

这是这个函数的调用关系图:

alloc_size_grow()

template<typename T >

void elc::defs::memory::get_n::alloc_size_grow ( T *&  arg, size_t  to_size  )

noexcept

向后扩大数据块大小并转移原有实例的生命周期，但并不构造新的实例

参数

arg	原有数据块
to_size	新的数据块大小

在文件 all_defs.cpp 第 21227 行定义.

                                                                                           {
        if constexpr(move.trivial<T>)
            realloc(arg,to_size);
        else{
            T*tmp=alloc<T>(to_size);
            const auto from_size=get_size_of_alloc(arg);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[from_size](note::from(arg),note::to(tmp));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[from_size](note::from(arg),note::to(tmp));
            }
            free(arg);
            arg=tmp;
        }
    }

函数调用图:

这是这个函数的调用关系图:

alloc_size_grow_with_insert_uninitialized_data() [1/2]

template<typename T >

void elc::defs::memory::get_n::alloc_size_grow_with_insert_uninitialized_data ( T *&  arg, size_t  insert_pos, size_t  insert_size  )

noexcept

在指定位置插入未初始化数据块并转移原有实例的生命周期，但并不构造新的实例

参数

arg	原有数据块
insert_pos	插入位置
insert_size	插入大小

在文件 all_defs.cpp 第 21256 行定义.

                                                                                                                                                {
        const auto from_size=get_size_of_alloc(arg);
        const auto to_size=from_size+insert_size;
        const auto size_before_insert=insert_pos;
        #if in_debug || defined(ELC_CHECK_MEMORYS_ERROR)
            if(from_size<insert_pos)
                __debugbreak();//？
        #endif
        const auto size_after_insert=from_size-insert_pos;
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            memmove(arg+size_before_insert+insert_size,arg+size_before_insert,size_after_insert*sizeof(T));
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[size_before_insert](note::from(arg),note::to(tmp));
                    move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[size_before_insert](note::from(arg),note::to(tmp));
                move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
            }
            free(arg);
            arg=tmp;
        }
    }

函数调用图:

这是这个函数的调用关系图:

alloc_size_grow_with_insert_uninitialized_data() [2/2]

template<typename T >

auto elc::defs::memory::get_n::alloc_size_grow_with_insert_uninitialized_data ( T *&  arg, size_t  to_size, size_t  insert_pos, size_t  insert_size  )

inlinenoexcept

在指定位置插入未初始化数据块并转移原有实例的生命周期，但并不构造新的实例 若有多余的大小，追加到末尾

参数

arg	原有数据块
to_size	新的数据块大小
insert_pos	插入位置
insert_size	插入大小

返回

详细的操作信息

在文件 all_defs.cpp 第 21300 行定义.

                                                                                                                                                                            {
        const auto from_size=get_size_of_alloc(arg);
        const auto size_before_insert=insert_pos;
        #if in_debug || defined(ELC_CHECK_MEMORYS_ERROR)
            if(from_size<insert_pos)
                __debugbreak();//？
        #endif
        const auto size_after_insert=from_size-insert_pos;
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            memmove(arg+size_before_insert+insert_size,arg+size_before_insert,size_after_insert*sizeof(T));
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[size_before_insert](note::from(arg),note::to(tmp));
                    move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[size_before_insert](note::from(arg),note::to(tmp));
                move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
            }
            free(arg);
            arg=tmp;
        }
        struct result_t{
            size_t from_size;
            size_t to_size;
            size_t size_before_insert;
            size_t size_after_insert;
            size_t insert_pos;
            size_t insert_size;
            size_t end_grow_size()const noexcept{return to_size-from_size-insert_size;}
            T* origin_data_ptr(T*arg)const noexcept{return arg;}
            T* insert_data_ptr(T*arg)const noexcept{return arg+insert_pos;}
            T* end_growth_data_ptr(T*arg)const noexcept{return arg+to_size-end_grow_size();}
        } result{
            from_size,
            to_size,
            size_before_insert,
            size_after_insert,
            insert_pos,
            insert_size
        };
        return result;
    }

函数调用图:

forward_alloc_size_cut()

template<typename T >

void elc::defs::memory::get_n::forward_alloc_size_cut ( T *&  arg, size_t  to_size  )

noexcept

向前减小数据块大小并转移原有实例的生命周期，但并不析构旧的实例

参数

arg	原有数据块
to_size	新的数据块大小

在文件 all_defs.cpp 第 21430 行定义.

                                                                                                  {
        const auto from_size=get_size_of_alloc(arg);
        #if in_debug || defined(ELC_CHECK_MEMORYS_ERROR)
            if(to_size>from_size)
                __debugbreak();//？
        #endif
        const auto cut_size=from_size-to_size;
        if constexpr(move.trivial<T>){
            ::std::memmove(arg,add_const(arg+cut_size),to_size*sizeof(T));
            realloc(arg,to_size);
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[to_size](note::from(arg+cut_size),note::to(tmp));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[to_size](note::from(arg+cut_size),note::to(tmp));
            }
            free(arg);
            arg=tmp;
        }
    }

函数调用图:

这是这个函数的调用关系图:

forward_alloc_size_grow()

template<typename T >

void elc::defs::memory::get_n::forward_alloc_size_grow ( T *&  arg, size_t  to_size  )

noexcept

向前扩大数据块大小并转移原有实例的生命周期，但并不构造新的实例

参数

arg	原有数据块
to_size	新的数据块大小

在文件 all_defs.cpp 第 21465 行定义.

                                                                                                   {
        const auto from_size=get_size_of_alloc(arg);
        #if in_debug || defined(ELC_CHECK_MEMORYS_ERROR)
            if(to_size<from_size)
                __debugbreak();//？
        #endif
        const auto grow_size=to_size-from_size;
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            ::std::memmove(arg+grow_size,add_const(arg),from_size*sizeof(T));
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[from_size](note::from(arg),note::to(tmp+grow_size));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[from_size](note::from(arg),note::to(tmp+grow_size));
            }
            free(arg);
            arg=tmp;
        }
    }

函数调用图:

这是这个函数的调用关系图:

forward_alloc_size_grow_with_insert_uninitialized_data()

template<typename T >

auto elc::defs::memory::get_n::forward_alloc_size_grow_with_insert_uninitialized_data ( T *&  arg, size_t  to_size, size_t  insert_pos, size_t  insert_size  )

inlinenoexcept

在指定位置插入未初始化数据块并转移原有实例的生命周期，但并不构造新的实例 若有多余的大小，追加到前端

参数

arg	原有数据块
to_size	新的数据块大小
insert_pos	插入位置
insert_size	插入大小

返回

详细的操作信息

在文件 all_defs.cpp 第 21505 行定义.

                                                                                                                                                                                    {
        const auto from_size=get_size_of_alloc(arg);
        const auto grow_size=to_size-from_size;
        #if in_debug || defined(ELC_CHECK_MEMORYS_ERROR)
            if(grow_size<insert_size)
                __debugbreak();//？
        #endif
        const auto before_grow_size=grow_size-insert_size;
        const auto size_before_insert=insert_pos;
        const auto size_after_insert=from_size-insert_pos;
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            const auto origin_data_ptr=arg+before_grow_size;
            ::std::memmove(origin_data_ptr+size_before_insert+insert_size,arg+size_before_insert,size_after_insert*sizeof(T));
            ::std::memmove(origin_data_ptr,arg,size_before_insert*sizeof(T));
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    const auto origin_data_ptr=tmp+before_grow_size;
                    move[size_before_insert](note::from(arg),note::to(origin_data_ptr));
                    move[size_after_insert](note::from(arg+size_before_insert),note::to(origin_data_ptr+size_before_insert+insert_size));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                const auto origin_data_ptr=tmp+before_grow_size;
                move[size_before_insert](note::from(arg),note::to(origin_data_ptr));
                move[size_after_insert](note::from(arg+size_before_insert),note::to(origin_data_ptr+size_before_insert+insert_size));
            }
            free(arg);
            arg=tmp;
        }
        struct result_t{
            size_t from_size;
            size_t to_size;
            size_t before_grow_size;
            size_t size_before_insert;
            size_t size_after_insert;
            size_t insert_pos;
            size_t insert_size;
            T* origin_data_ptr(T*arg)const noexcept{return arg+before_grow_size;}
            T* insert_data_ptr(T*arg)const noexcept{return origin_data_ptr(arg)+insert_pos;}
        } result{
            from_size,
            to_size,
            before_grow_size,
            size_before_insert,
            size_after_insert,
            insert_pos,
            insert_size
        };
        return result;
    }

函数调用图:

这是这个函数的调用关系图:

part_used_block_alloc_size_grow_with_insert_uninitialized_data()

template<typename T >

auto elc::defs::memory::get_n::part_used_block_alloc_size_grow_with_insert_uninitialized_data ( T *&  arg, size_t  to_size, size_t  insert_pos, size_t  insert_size, size_t  used_size  )

inlinenoexcept

假设尾部有未使用的对象前提下，在指定位置插入未初始化数据块并转移原有实例的生命周期，允许新的参数描述已使用的对象多少，并不构造新的实例 若有多余的大小，追加到末尾

参数

arg	原有数据块
to_size	新的数据块大小
insert_pos	插入位置
insert_size	插入大小
used_size	已使用的对象多少

返回

详细的操作信息

在文件 all_defs.cpp 第 21364 行定义.

                                                                                                                                                                                                             {
        const auto from_size=get_size_of_alloc(arg);
        const auto size_before_insert=insert_pos;
        const auto size_after_insert=used_size-insert_pos;
        const auto unused_size_before_insert=from_size-used_size;
        const auto unused_size_after_insert=to_size-insert_size-used_size;
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            //先移动插入末尾的元素
            memmove(arg+size_before_insert+insert_size,arg+insert_pos,size_after_insert*sizeof(T));
            //插入前的元素没有移动
        }
        else{
            T*tmp=alloc<T>(to_size);
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
                    //这里我们需要移动插入前的元素因为这是新的空间
                    move[size_before_insert](note::from(arg),note::to(tmp));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[size_after_insert](note::from(arg+insert_pos),note::to(tmp+insert_pos+insert_size));
                //这里我们需要移动插入前的元素因为这是新的空间
                move[size_before_insert](note::from(arg),note::to(tmp));
            }
            free(arg);
            arg=tmp;
        }
        struct result_t{
            size_t from_size;
            size_t to_size;
            size_t unused_size_before_insert;
            size_t unused_size_after_insert;
            size_t used_size;
            size_t size_before_insert;
            size_t size_after_insert;
            size_t insert_pos;
            size_t insert_size;
            size_t end_grow_size()const noexcept{return to_size-from_size-insert_size;}
            T* origin_data_ptr(T*arg)const noexcept{return arg;}
            T* insert_data_ptr(T*arg)const noexcept{return arg+insert_pos;}
            T* end_growth_data_ptr(T*arg)const noexcept{return arg+to_size-used_size;}
        } result{
            from_size,
            to_size,
            unused_size_before_insert,
            unused_size_after_insert,
            used_size,
            size_before_insert,
            size_after_insert,
            insert_pos,
            insert_size
        };
        return result;
    }

函数调用图:

这是这个函数的调用关系图:

part_used_block_forward_alloc_size_grow_with_insert_uninitialized_data()

template<typename T >

auto elc::defs::memory::get_n::part_used_block_forward_alloc_size_grow_with_insert_uninitialized_data ( T *&  arg, size_t  to_size, size_t  insert_pos, size_t  insert_size, size_t  used_size  )

inlinenoexcept

假设头部有未使用的对象前提下，在指定位置插入未初始化数据块并转移原有实例的生命周期，允许新的参数描述已使用的对象多少，并不构造新的实例 若有多余的大小，追加到前端

参数

arg	原有数据块
to_size	新的数据块大小
insert_pos	插入位置
insert_size	插入大小
used_size	已使用的对象多少

返回

详细的操作信息

在文件 all_defs.cpp 第 21575 行定义.

                                                                                                                                                                                                                     {
        const auto from_size=get_size_of_alloc(arg);//原有数据块大小
        const auto grow_size=to_size-from_size;//扩大的大小
        const auto used_size_after_insert=used_size+insert_size;//插入后的已使用大小
        const auto unused_size_after_insert=to_size-used_size_after_insert;//插入后的未使用大小
        const auto unused_size_before_insert=from_size-used_size;//插入前的未使用大小
 
        const auto after_insert_size=from_size-insert_pos;//插入位置之后的数据块的大小
        const auto before_insert_size=insert_pos-unused_size_before_insert;//插入位置之前的数据块的大小
        insert_pos-=unused_size_before_insert;//插入位置
        if constexpr(move.trivial<T>){
            realloc(arg,to_size);
            const auto new_data_ptr=arg+unused_size_after_insert;
            const auto origin_data_ptr=arg+unused_size_before_insert;
            //先移动插入末尾的元素
            ::std::memmove(new_data_ptr+insert_pos+insert_size,origin_data_ptr+insert_pos,after_insert_size*sizeof(T));
            //再移动插入前的元素
            ::std::memmove(new_data_ptr,origin_data_ptr,before_insert_size*sizeof(T));
        }
        else{
            T*tmp=alloc<T>(to_size);
            const auto new_data_ptr=tmp+unused_size_after_insert;
            const auto origin_data_ptr=arg+unused_size_before_insert;
            if constexpr(!move.nothrow<T>){
                template_warning("the move of T was not noexcept,this may cause memory lack.");
                try{
                    move[after_insert_size](note::from(origin_data_ptr+insert_pos),note::to(new_data_ptr+insert_pos+insert_size));
                    move[before_insert_size](note::from(origin_data_ptr),note::to(new_data_ptr));
                }catch(...){
                    free(tmp);
                    throw;
                }
            }else{
                move[after_insert_size](note::from(origin_data_ptr+insert_pos),note::to(new_data_ptr+insert_pos+insert_size));
                move[before_insert_size](note::from(origin_data_ptr),note::to(new_data_ptr));
            }
            free(arg);
            arg=tmp;
        }
        struct result_t{
            size_t from_size;
            size_t to_size;
            size_t unused_size_before_insert;
            size_t unused_size_after_insert;
            size_t used_size_after_insert;
            size_t before_insert_size;
            size_t after_insert_size;
            size_t used_size;
            size_t grow_size;
            size_t insert_pos;
            size_t insert_size;
            T* new_data_ptr(T*arg)const noexcept{return arg+unused_size_after_insert;}
            T* origin_data_ptr(T*arg)const noexcept{return arg+unused_size_before_insert;}
            size_t before_grow_size()const noexcept{return grow_size+used_size-insert_size;}
            T* insert_data_ptr(T*arg)const noexcept{return arg+unused_size_after_insert+insert_pos;}
        } result{
            from_size,
            to_size,
            unused_size_before_insert,
            unused_size_after_insert,
            used_size_after_insert,
            before_insert_size,
            after_insert_size,
            used_size,
            grow_size,
            insert_pos,
            insert_size
        };
        return result;
    }

函数调用图:

这是这个函数的调用关系图:

变量说明

copy_get

constexpr struct elc::defs::memory::get_n::copy_get_t elc::defs::memory::get_n::copy_get

get

template<typename T >

constexpr get_t<T> elc::defs::memory::get_n::get {}

constexpr

在文件 all_defs.cpp 第 21763 行定义.

{};

get_forward_resize

constexpr struct elc::defs::memory::get_n::get_forward_resize_t elc::defs::memory::get_n::get_forward_resize

get_resize

constexpr struct elc::defs::memory::get_n::get_resize_t elc::defs::memory::get_n::get_resize

get_size_of_get

constexpr struct elc::defs::memory::get_n::get_size_of_get_t elc::defs::memory::get_n::get_size_of_get

unget

constexpr struct elc::defs::memory::get_n::unget_t elc::defs::memory::get_n::unget