C++young程序库——y_iterator.hpp和y_type_traits.hpp

作者：zongnaxxl240 | 来源：互联网 | 2023-05-19 16:31

文件位置：young/y_iterator.hpp

/*
The young Library
Copyright (c) 2005 by 杨桓

Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_ITERATOR_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_ITERATOR_HEADER_FILE__
//-----------------------------------------------------------------------------
#include
#include "y_define.hpp"
#include "y_pair.hpp"
#include "y_type_traits.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

/*
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag,
public output_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
*/

typedef std::input_iterator_tag          input_iterator_tag;
typedef std::output_iterator_tag         output_iterator_tag;
typedef std::forward_iterator_tag        forward_iterator_tag;
typedef std::bidirectional_iterator_tag bidirectional_iterator_tag;
typedef std::random_access_iterator_tag random_access_iterator_tag;

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template
struct iterator_traits
{
    typedef false_type is_pointer;
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::value_type         value_type;
    typedef typename Iterator::reference          reference;
    typedef typename Iterator::pointer            pointer;
    typedef typename Iterator::size_type          size_type;
    typedef typename Iterator::difference_type    difference_type;
};

template
struct iterator_traits
{
    typedef true_type is_pointer;
    typedef random_access_iterator_tag iterator_category;
    typedef T                           value_type;
    typedef value_type&                 reference;
    typedef value_type*                 pointer;
    typedef def_size_t                  size_type;
    typedef def_ptrdiff_t               difference_type;
};

template
inline T* const_iter_cast( const T* cptr )
{
return const_cast( cptr );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//必须是双向迭代器以上的迭代器
template
class Reverse_Iterator
{
public:
    typedef typename iterator_traits::iterator_category iterator_category;
    typedef typename iterator_traits::value_type         value_type;
    typedef typename iterator_traits::reference          reference;
    typedef typename iterator_traits::pointer            pointer;
    typedef typename iterator_traits::size_type          size_type;
    typedef typename iterator_traits::difference_type    difference_type;
    typedef const pointer    const_pointer;
    typedef const reference const_reference;

typedef Reverse_Iterator self;
typedef Iterator iterator_type;

Reverse_Iterator() {}
Reverse_Iterator( iterator_type it ) : current(it) {}

iterator_type base() const { return current; }

    reference operator*() const
    {
    iterator_type result = current;
    return *(--result);
    }
    pointer operator->() const
    {
        return &( operator*() );
    }

    self& operator++()     { --current; return this; }
    self& operator--()     { ++current; return this; }
    self operator++(int)   { self temp = *this; --current; return temp; }
    self operator--(int)   { self temp = *this; ++current; return temp; }

self& operator+=( difference_type n ) { current -= n; return *this; }
self& operator-=( difference_type n ) { current += n; return *this; }

self operator+( difference_type n ) const { return self( current - n ); }
self operator-( difference_type n ) const { return self( current + n ); }

reference operator[]( difference_type n ) const
{ return *( *this + n ); }

protected:
iterator_type current;

}; //end class

template
inline typename Reverse_Iterator::difference_type
operator-( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return rhs.base() - lhs.base();
}

template
inline Reverse_Iterator
operator+( typename Reverse_Iterator::difference_type n,
const Reverse_Iterator& rhs )
{
return Reverse_Iterator( rhs.base() - n );
}

template
inline bool operator==( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return ( lhs.base() == rhs.base() );
}

template
inline bool operator!=( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return ( lhs.base() != rhs.base() );
}

template
inline bool operator<( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return ( rhs.base() }

template
inline bool operator>( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return ( rhs }

template
inline bool operator<=( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return !( rhs }

template
inline bool operator>=( const Reverse_Iterator& lhs,
const Reverse_Iterator& rhs )
{
return !( lhs }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template
inline typename iterator_traits::difference_type
distance( ForwardIterator first, ForwardIterator last )
{
    typedef typename iterator_traits::iterator_category cate;
    typedef typename iterator_traits::difference_type diff_t;
    return distance_aux( first, last, cate() );
}

template
typename iterator_traits::difference_type
distance_aux( ForwardIterator first, ForwardIterator last,
input_iterator_tag )
{
typedef typename iterator_traits::difference_type diff_t;

    diff_t len = 0;
    while( first != last )
    {
    ++first;
        ++len;
    }
    return len;
}

template
inline typename iterator_traits::difference_type
distance_aux( ForwardIterator first, ForwardIterator last,
random_access_iterator_tag )
{
return ( last - first );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template
inline void advance( InputIterator& iter, Integer n )
{
typedef typename iterator_traits::iterator_category cate;
advance_aux( iter, n, cate() );
}

template
void advance_aux( InputIterator& iter, Integer n, input_iterator_tag )
{
while( n-- )
++iter;
}

template
void advance_aux( InputIterator& iter, Integer n, bidirectional_iterator_tag )
{
    if( n >= 0 )
    {
    while( n-- )
         ++iter;
    }
    else
    {
    while( n++ )
         --iter;
    }
}

template
inline void advance_aux( InputIterator& iter, Integer n,
random_access_iterator_tag )
{
iter += n;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template
inline
Integer range_length( InputIterator first, InputIterator last, Integer length )
{
typedef typename iterator_traits::iterator_category cate;
return range_len_aux( first, last, length, cate() );
}

template
inline Integer range_len_aux( InputIterator first, InputIterator last,
                              Integer length, input_iterator_tag tag )
{
    if( length <1 )
        length = distance_aux( first, last, tag );
    return length;
}

template
inline Integer range_len_aux( InputIterator first, InputIterator last,
Integer length, random_access_iterator_tag )
{
return ( last - first );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//返回值为最后一个有效的迭带器和区间长度
template
inline
pair::difference_type>
pair_iter_len( InputIterator first, InputIterator last )
{
typedef typename iterator_traits::iterator_category cate;
return iter_len_aux( first, last, cate() );
}

template
pair::difference_type>
iter_len_aux( InputIterator first, InputIterator last,
input_iterator_tag )
{
typedef typename iterator_traits::difference_type diff_t;

if( first == last )
return pair( first, 0 );

    diff_t len = 1;
    InputIterator result = first;
    ++first;
    while( first != last )
    {
    ++first;
    ++result;
        ++len;
    }
    return pair( result, len );
}

template
pair::difference_type>
iter_len_aux( InputIterator first, InputIterator last,
random_access_iterator_tag )
{
typedef typename iterator_traits::difference_type diff_t;

    diff_t len = last - first;
    if( len == 0 )
        return pair( first, 0 );
    else
        return pair( first + (len - 1), len );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

文件位置：young/y_type_traits.hpp

/*
The young Library
Copyright (c) 2005 by 杨桓

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_TYPE_TRAITS_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_TYPE_TRAITS_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "y_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

struct true_type {};
struct false_type {};

template
struct type_traits
{
    typedef false_type has_trivial_default_constructor;
    typedef false_type has_trivial_copy_constructor;
    typedef false_type has_trivial_assignment_operator;
    typedef false_type has_trivial_destructor;
    typedef false_type is_POD_type;
};

template
struct type_traits
{
    typedef true_type has_trivial_default_constructor;
    typedef true_type has_trivial_copy_constructor;
    typedef true_type has_trivial_assignment_operator;
    typedef true_type has_trivial_destructor;
    typedef true_type is_POD_type;
};

template<>
struct type_traits
{
    typedef true_type has_trivial_default_constructor;
    typedef true_type has_trivial_copy_constructor;
    typedef true_type has_trivial_assignment_operator;
    typedef true_type has_trivial_destructor;
    typedef true_type is_POD_type;
};

/*
template<>
struct type_traits
{
    typedef true_type has_trivial_default_constructor;
    typedef true_type has_trivial_copy_constructor;
    typedef true_type has_trivial_assignment_operator;
    typedef true_type has_trivial_destructor;
    typedef true_type is_POD_type;
};

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template
struct primal_type
{
    typedef T primal_t;
    typedef const T   const_t;
    typedef const T* const_ptr;
    typedef const T& const_ref;
    typedef const T   contrary_const;
    typedef const T* contrary_const_ptr;
    typedef const T& contrary_const_ref;
};

template
struct primal_type
{
    typedef T primal_t;
    typedef const T   const_t;
    typedef const T* const_ptr;
    typedef const T& const_ref;
    typedef T   contrary_const;
    typedef T* contrary_const_ptr;
    typedef T& contrary_const_ref;
};

//-----------------------------------------------------------------------------

struct same_type {};
struct different_type {};

template
struct types_matching
{
typedef different_type result;
};

template
struct types_matching
{
typedef same_type result;
};

//-----------------------------------------------------------------------------

template
struct double_types_traits
{
typedef typename primal_type::primal_t primal_t1;
typedef typename primal_type::primal_t primal_t2;

typedef typename types_matching::result
matching_result;

    typedef typename type_traits::has_trivial_default_constructor
             has_trivial_default_constructor_t1;
    typedef typename type_traits::has_trivial_copy_constructor
             has_trivial_copy_constructor_t1;
    typedef typename type_traits::has_trivial_assignment_operator
             has_trivial_assignment_operator_t1;
    typedef typename type_traits::has_trivial_destructor
             has_trivial_destructor_t1;
    typedef typename type_traits::is_POD_type
             is_POD_type_t1;

    typedef typename type_traits::has_trivial_default_constructor
             has_trivial_default_constructor_t2;
    typedef typename type_traits::has_trivial_copy_constructor
             has_trivial_copy_constructor_t2;
    typedef typename type_traits::has_trivial_assignment_operator
             has_trivial_assignment_operator_t2;
    typedef typename type_traits::has_trivial_destructor
             has_trivial_destructor_t2;
    typedef typename type_traits::is_POD_type
             is_POD_type_t2;
};

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

推荐阅读

sum
UE4 中的距离场技术详解

本文将深入探讨 Unreal Engine 4 (UE4) 中的距离场技术，包括其原理、实现细节以及在渲染中的应用。距离场技术在现代游戏引擎中用于提高光照和阴影的效果，尤其是在处理复杂几何形状时。文章将结合具体代码示例，帮助读者更好地理解和应用这一技术。 ... [详细]

蜡笔小新 2024-11-19 18:21:03
c语言
Logistic回归模型（C++代码实现）

Logistic回归主要针对输入的数据是多个，输出则是有限的数值型，多为2个分类。涉及到以下方面：1.输出yw0+w1*x1+w2*x2+..(x1,x2,是样本的 ... [详细]

蜡笔小新 2024-09-27 10:00:45
io
从ifstream读取不会读取空格 - Reading from ifstream won't read whitespace

ImimplementingacustomlexerinC++andwhenattemptingtoreadinwhitespace,theifstreamwont ... [详细]

蜡笔小新 2024-10-11 11:26:47
io
像Eum中的Enum一样使用C ++中的Enum？ - Enum in C++ like Enum in Ada?

AtonepointIhadlookedatimplementingaclasstemplateinC++thatwouldsupportanEnumthatwo ... [详细]

蜡笔小新 2023-10-15 15:41:16
install
Ubuntu 14.04 环境下搭建 Caffe（仅限 CPU）

本文详细介绍了如何在 Ubuntu 14.04 系统上搭建仅使用 CPU 的 Caffe 深度学习框架，包括环境准备、依赖安装及编译过程。 ... [详细]

蜡笔小新 2024-11-22 16:43:30
window
WPF菜单控件前景与背景颜色设置指南

尽管在WPF中工作了一段时间，但在菜单控件的样式设置上遇到了一些基础问题，特别是关于如何正确配置前景色和背景色。 ... [详细]

蜡笔小新 2024-11-22 15:30:54
io
Spring MVC 中利用拦截器与自定义注解实现权限控制

本文探讨了如何在 Spring MVC 框架下，通过自定义注解和拦截器机制来实现细粒度的权限管理功能。 ... [详细]

蜡笔小新 2024-11-22 14:35:02
io
解决 ChinaASP.Upload 错误 '80040002' - 必须添加版权信息

本文介绍了如何解决 ChinaASP.Upload 错误 '80040002'，即必须添加版权信息的问题，并提供了详细的步骤和注意事项。 ... [详细]

蜡笔小新 2024-11-19 15:12:54
tree
华为鲲鹏平台适配的Redis Docker镜像构建指南

本文详细介绍如何在华为鲲鹏平台上构建和使用适配ARM架构的Redis Docker镜像，解决常见错误并提供优化建议。 ... [详细]

蜡笔小新 2024-11-19 15:04:08
less
Java代码保护与混淆：ProGuard详解

在Java开发中，保护代码安全是一个重要的课题。由于Java字节码容易被反编译，因此使用代码混淆工具如ProGuard变得尤为重要。本文将详细介绍如何使用ProGuard进行代码混淆，以及其基本原理和常见问题。 ... [详细]

蜡笔小新 2024-11-18 16:46:17
utf-8
5分钟快速筛选特定候选人的简历

介绍一个新的系列，专注于提供能在5分钟内完成的简单实用案例。本文将以办公中常见的需求为例，展示如何快速从大量简历中筛选出特定候选人的简历。 ... [详细]

蜡笔小新 2024-11-18 12:12:26
window
教你从写一个迷你koarouter到阅读koarouter源码

本打算教一步步实现koa-router，因为要解释的太多了，所以先简化成mini版本，从实现部分功能到阅读源码，希望能让你好理解一些。希望你之前有读过koa源码，没有的话，给你链接 ... [详细]

蜡笔小新 2024-11-17 13:09:46
window
Cocos2dx 3.0 过渡篇（二十六）C++11多线程std::thread的简单使用

转自star特530的博客。http:blog.csdn.netstar530articledetails24186783andhttp:blog.csdn.netstar530a ... [详细]

蜡笔小新 2024-10-14 16:30:03
sum
如何将fucntion sumVec转换为模板函数 - How do I turn the fucntion sumVec into a template function

Igotthiscode(IknowitsinSpanishIcantranslateifneeded)wheretheygivemethefunctionS ... [详细]

蜡笔小新 2023-10-13 11:43:08
io
数据结构-图详解（图基本概念、图的存储结构及C++实现）

本文主要介绍关于数据结构,c++,图论的知识点，对【数据结构-图详解（图基本概念、图的存储结构及C++实现）】和【数据结构图的存储结构代码】有兴趣的朋友可以看下由【NUC_Dodamce】投稿的技术文 ... [详细]

蜡笔小新 2023-10-13 10:51:25

zongnaxxl240

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章