类
struct	base_iterator_t

struct	reverse_base_t

class	same_base_t

类型定义
template<typename value_t , typename base_t_w = value_t*>
using	iterator_t = base_iterator_t< remove_cvref< value_t >, base_t_w >

template<typename value_t , typename base_t_w = const value_t*>
using	const_iterator_t = base_iterator_t< const remove_cvref< value_t >, base_t_w >

template<typename value_t , typename base_t_w = value_t*>
using	reverse_iterator_t = base_iterator_t< remove_cvref< value_t >, reverse_base_t< base_t_w, value_t > >

template<typename value_t , typename base_t_w = const value_t*>
using	reverse_const_iterator_t = base_iterator_t< const remove_cvref< value_t >, reverse_base_t< base_t_w, value_t > >

函数
template<typename base_t , typename value_t > requires (compare.able<base_t>)
auto	operator<=> (const reverse_base_t< base_t, value_t > &a, const reverse_base_t< base_t, value_t > &b) noexcept(compare.nothrow< base_t >)

template<typename base_t , typename value_t , typename T > requires (compare.able<T,base_t> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)
auto	operator<=> (const reverse_base_t< base_t, value_t > &a, T &&b) noexcept(compare.nothrow< T, base_t >)

template<typename base_t , typename value_t , typename T > requires (compare.able<base_t,T> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)
auto	operator<=> (T &&a, const reverse_base_t< base_t, value_t > &b) noexcept(compare.nothrow< base_t, T >)

template<typename base_t , typename value_t , typename T > requires (equal.able<T,base_t> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)
auto	operator== (const reverse_base_t< base_t, value_t > &a, T &&b) noexcept(equal.nothrow< T, base_t >)

template<typename base_t , typename value_t , typename T > requires (equal.able<base_t,T> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)
auto	operator== (T &&a, const reverse_base_t< base_t, value_t > &b) noexcept(equal.nothrow< base_t, T >)

template<typename base_t , typename value_t >
void	swap (reverse_base_t< base_t, value_t > &a, reverse_base_t< base_t, value_t > &b) noexcept(noexcept((swap(a._m, b._m))))

template<typename value_t , typename base_t_w >
void	swap (same_base_t< value_t, base_t_w > &a, same_base_t< value_t, base_t_w > &b) noexcept(noexcept((a.swap_with(b))))

template<typename value_t , typename base_t_w >
	base_iterator_t (base_iterator_t< value_t, base_t_w >) -> base_iterator_t< value_t, base_t_w >

template<typename value_t , typename base_t_w >
	base_iterator_t (value_t *) -> base_iterator_t< value_t, base_t_w >

类型定义说明

◆ const_iterator_t

template<typename value_t , typename base_t_w = const value_t*>

using elc::defs::base::iterator_n::const_iterator_t = typedef base_iterator_t<const remove_cvref<value_t>,base_t_w>

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

◆ iterator_t

template<typename value_t , typename base_t_w = value_t*>

using elc::defs::base::iterator_n::iterator_t = typedef base_iterator_t<remove_cvref<value_t>,base_t_w>

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

◆ reverse_const_iterator_t

template<typename value_t , typename base_t_w = const value_t*>

using elc::defs::base::iterator_n::reverse_const_iterator_t = typedef base_iterator_t<const remove_cvref<value_t>,reverse_base_t<base_t_w,value_t> >

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

◆ reverse_iterator_t

template<typename value_t , typename base_t_w = value_t*>

using elc::defs::base::iterator_n::reverse_iterator_t = typedef base_iterator_t<remove_cvref<value_t>,reverse_base_t<base_t_w,value_t> >

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

函数说明

◆ base_iterator_t() [1/2]

template<typename value_t , typename base_t_w >

elc::defs::base::iterator_n::base_iterator_t ( base_iterator_t< value_t, base_t_w > ) -> base_iterator_t< value_t, base_t_w >

◆ base_iterator_t() [2/2]

template<typename value_t , typename base_t_w >

elc::defs::base::iterator_n::base_iterator_t ( value_t * ) -> base_iterator_t< value_t, base_t_w >

◆ operator<=>() [1/3]

template<typename base_t , typename value_t >
requires (compare.able<base_t>)

auto elc::defs::base::iterator_n::operator<=>	(	const reverse_base_t< base_t, value_t > &	a,
		const reverse_base_t< base_t, value_t > &	b
	)

noexcept

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

                                                                                                                                                 {
        return compare((const base_t&)b._m,(const base_t&)a._m);
    }

◆ operator<=>() [2/3]

template<typename base_t , typename value_t , typename T >
requires (compare.able<T,base_t> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)

auto elc::defs::base::iterator_n::operator<=>	(	const reverse_base_t< base_t, value_t > &	a,
		T &&	b
	)

noexcept

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

                                                                                                                   {
        return compare(b,(const base_t&)a._m);
    }

◆ operator<=>() [3/3]

template<typename base_t , typename value_t , typename T >
requires (compare.able<base_t,T> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)

auto elc::defs::base::iterator_n::operator<=>	(	T &&	a,
		const reverse_base_t< base_t, value_t > &	b
	)

noexcept

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

                                                                                                                   {
        return compare((const base_t&)b._m,a);
    }

◆ operator==() [1/2]

template<typename base_t , typename value_t , typename T >
requires (equal.able<T,base_t> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)

auto elc::defs::base::iterator_n::operator==	(	const reverse_base_t< base_t, value_t > &	a,
		T &&	b
	)

noexcept

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

                                                                                                                {
        return equal(b,(const base_t&)a._m);
    }

◆ operator==() [2/2]

template<typename base_t , typename value_t , typename T >
requires (equal.able<base_t,T> && type_info<remove_cvref<T>> != type_info<reverse_base_t<base_t,value_t>::base_t_rw>)

auto elc::defs::base::iterator_n::operator==	(	T &&	a,
		const reverse_base_t< base_t, value_t > &	b
	)

noexcept

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

                                                                                                                {
        return equal((const base_t&)b._m,a);
    }