输出具有begin和end函数的容器

最新推荐文章于 2023-03-29 11:36:47 发布
最新推荐文章于 2023-03-29 11:36:47 发布
阅读量1.7k 收藏
点赞数
文章标签： c++ STL Container
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqdjyy01234/article/details/19234329
版权
Print containers in a generic way, as long as the functions begin and end applies. 
#ifndef MY_container_io_HEADER
#define MY_container_io_HEADER

#include 
   
   
    
    
#include 
    
    
     
     // 保证T[N]的begin和end函数能找到
#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
         #include 
        
          namespace std{ template 
         
           class basic_ostream; namespace{ template 
          
            false_type has_begin_end_helper(int, Container&&); template 
           
             auto has_begin_end_helper(double, Container&& container)-> typename enable_if 
            
              ::type; template 
             
               struct has_begin_end: decltype(has_begin_end_helper(0., declval 
              
                ())){}; template 
               
                 struct format_t : boost::intrusive_ref_counter 
                 
                 
                   >{ public: using intrusive_ptr = boost::intrusive_ptr 
                  
                    ; static format_t*& get_format_ptr(ios_base &ios){ return reinterpret_cast 
                   
                     (ios.pword(get_index())); } static format_t& instance(CharType const *open, CharType const *close, CharType const* del){ size_t const len_o = strlen(open), len_c = strlen(close), len_d = strlen(del); if (len_o != len_c || len_c != len_d) throw invalid_argument("size not consistant"); using const_ptr = CharType *const; const_ptr o = new CharType[len_o + 1], c = new CharType[len_o + 1], d = new CharType[len_o + 1]; strcpy(o, open); strcpy(c, close); strcpy(d, del); return *(new format_t 
                    
                      (o, c, d, len_o)); } private: boost::scoped_array 
                     
                       open_str, close_str, delimiter_str; ptrdiff_t level; format_t(CharType const* o, CharType const* c, CharType const* d, size_t const l) : open_str(o), close_str(c), delimiter_str(d), level(l){} static int get_index(){ static const int index = std::ios::xalloc(); return index; } static void call_back(ios_base::event type, ios_base& ios, int index){ switch (type){ case std::ios_base::erase_event: intrusive_ptr_release(get_format_ptr(ios)); break; case std::ios_base::copyfmt_event: intrusive_ptr_add_ref(get_format_ptr(ios)); break; } } static intrusive_ptr& get_intrusive_ptr(ios_base &ios){ return reinterpret_cast 
                      
                        (ios.pword(get_index())); } template 
                       
                         friend basic_ostream 
                        
                          & operator<<(basic_ostream 
                         
                           & ostr, format_t &format){ intrusive_ptr& p = get_intrusive_ptr(ostr); if (!p) ostr.register_callback(&call_back, get_index());// 没有注册过回调函数 intrusive_ptr(std::addressof(format)).swap(p); return ostr; } friend void open(format_t *const format, CharType &o, CharType &c, CharType &d){ if (format && --format->level >= 0){ auto const level = format->level; o = format->open_str[level]; c = format->close_str[level]; d = format->delimiter_str[level]; } else{ o = '('; c = ')'; d = ' '; } } friend void close(format_t *const format){ if (format) ++format->level; } }; } template 
                          
                            format_t 
                           
                             & container(CharType const *open, CharType const *close, CharType const* del){ return format_t 
                            
                              ::instance(open, close, del); } template 
                             
                               typename enable_if 
                               
                               
                                 ::value, basic_ostream 
                                
                                  &>::type operator<<(basic_ostream 
                                 
                                   & ostr, Container const &v){ auto const format = format_t 
                                  
                                    ::get_format_ptr(ostr); CharT o, c, d; open(format, o, c, d); ostr << o; auto p = begin(v); auto const q = end(v); if (p != q){ ostr << *p++; while (p != q){ ostr << d << *p++; } } ostr << c; close(format); return ostr; } template 
                                   
                                     basic_ostream 
                                    
                                      & operator<<(basic_ostream 
                                     
                                       & ostr, std::pair 
                                      
                                        const &v){ auto const format = format_t 
                                       
                                         ::get_format_ptr(ostr); CharT o, c, d; open(format, o, c, d); ostr << o << v.first << d << v.second << c; close(format); return ostr; } } #endif #include 
                                        
                                          #include 
                                         
                                           #include 
                                          
                                            #include 
                                           
                                             #include 
                                            
                                              #include 
                                             
                                               #include 
                                               #include 
                                               
                                                 #include 
                                                
                                                  #include 
                                                 
                                                   #include 
                                                  
                                                    #include 
                                                   
                                                     int main(){ std::vector 
                                                    
                                                      v{1, 2, 3}; std::list 
                                                     
                                                       l{1, 2, 3}; std::array 
                                                      
                                                        a{{1, 2, 3}}; std::set 
                                                       
                                                         s{1, 2, 3}; int r[] = {1, 2, 3}; std::deque 
                                                        
                                                          d{1, 2, 3}; std::forward_list 
                                                         
                                                           f{1, 2, 3}; std::string str("1-2-3"); std::map 
                                                          
                                                            m{{1, 1}, {2, 2}, {3, 3}}; std::cout< 
                                                           
                                                             <<"\n" < 
                                                            
                                                              <", ">", " ")< 
                                                             
                                                               <<"\n" < 
                                                              
                                                                t(1, .1, '1'); std::cout< 
                                                               
                                                                 <<"\n"; return 0; }

使用的技术在C++中称为SFINAE。

终极目标是做得和boost::tuple一样方便地输入输出，并支持左括弧、右括弧、分隔符。

欢迎转载，请注明出处。

Alternative: http://louisdx.github.io/cxx-prettyprint/ 目前，需要将37~45行进行修改才能在vs2013上编译。

cqdjyy01234
关注
C++ 标准库函数的begin和end函数与标准库容器的begin和end成员
MISAYAONE的博客
04-01 1万+
如果你手边有C++Primer，这两点分别在P106、P298，不想翻书的话，就好好看看这篇文章吧，书上有更多的细节，有时间还是多翻书吧！ 标准库的begin()和end()函数是C++11新标准引入的函数，可以对数组类型进行操作，返回其首尾指针。 标准库容器的begin()和end()成员函数属于对应类的成员，返回的是对象容器的首尾迭代器。 新标准库的begin()和end
C++ 标准库函数的 begin 和 end 与标准库容器的 begin 和 end 成员
最新发布
zhouKouUU的博客
09-17 507
begin 函数返回容器的起始位置的迭代器，而 end 函数返回容器的结束位置的迭代器。begin 成员函数返回容器的起始位置的迭代器，而 end 成员函数返回容器的结束位置的迭代器。在上面的代码中，我们使用 numbers.begin() 获取 numbers 容器的起始位置的迭代器，使用 numbers.end() 获取结束位置的迭代器。在上面的代码中，我们使用 begin(numbers) 获取 numbers 容器的起始位置的迭代器，使用 end(numbers) 获取结束位置的迭代器。
C++编程语言STL之begin和end函数介绍
liitdar的博客
03-29 3765
c.begin()形式：返回指向容器首元素的iterator；begin(array)或begin(c)形式：返回数组的头指针。c.end()形式：返回指向紧挨尾元素的元素的iterator；end(array)或end(c)形式：返回紧挨数组尾指针的指针。说明：对于end函数来说，给定范围的“终止点”并不包含在给定范围内，而是紧挨着范围内最后一个可用元素的元素。c: 包括begin成员函数/end成员函数的容器；array: 任意类型的数组。
打印begin~end
weixin_34162629的博客
10-24 119
要求： 　　输入：begin和end 　　输出：依次打印出begin到end 　　 1 import java.util.Scanner; 2 //递归打印begin —— end 3 public class demo1 { 4 5 public static void f(int begin,int end){ 6 if(end-1&...
[C++] C++中的begin和end
wangmj_hdu的博客
08-08 1万+
容器：begin和end函数 begin和end是vector的两个成员函数 begin和end begin：返回指向容器第一个元素的迭代器 end：返回指向容器最后一个元素下一个位置的迭代器 begin和end返回的具体类型由对象是否是常量决定： 如果对象是常量，begin和end返回const_iterator 如果对象不是常量，返回iterator vector<int> v1; const vector<int> v2; auto itr1 = v1.be
C++begin和end运算符的返回迭代器的类型如何判断?
08-26
C++中的begin和end运算符是STL（Standard Template Library）中最常用的两个运算符，它们分别返回容器的开始和结束迭代器。然而，在实际编程中，我们经常会遇到一个问题，即begin和end运算符的返回迭代器的类型如何...
begin和end函数需要用什么类型来接收
06-13
begin和end函数通常用来返回表示容器中第一个元素和最后一个元素之后位置的迭代器，其类型取决于容器的类型。例如，对于一个vector容器，begin函数返回一个指向第一个元素的int型指针，而end函数返回一个指向最后一...
C++语法 容器相关函数
weixin_46284432的博客
02-27 213
C++语法 容器相关函数
C++STL中vector容器 begin()与end()、front()与back()、find()函数的用法
热门推荐
那年聪聪
06-15 3万+
C++STL中vector容器 begin()与end()、front()与back()、find()函数的用法
C/C++编程：标准库函数begin和end
OceanStar的博客
03-22 1795
问题 假设有一个数组： int a1[]{1, 2, 3, 4, 5}; 可以这样： for(unsigned int i = 0; i < sizeof(a1) / sizeof(a1[0]); i++){ printf("%d\t", a1[i]); } 或者这样： for(int *p = a1; p != a1 + sizeof(a1) / sizeof(a1[0]); p++){ printf("%d\t", *p); } 多少还是需要
标准库函数begin和end
程序人生
11-16 1万+
在C++05中对于string类和各种容器类（如vector等）添加了T.begin()和T.end()两个成员函数，分别返回指向首元素的迭代器和尾后元素的迭代器。但是对于复合类型数组却一直只能用指针和数组元素地址来实现。以遍历输出数组为例： int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int *b = &a[0], *e = &a[10];//数组a
C++11之begin、end函数
半雨微凉
11-21 1万+
C++11引入了 begin 和 end 的函数，这两个函数与容器中的两个同名成员功能类似，不过这两个函数不是成员函数，而是含有参数的函数。 用法说明： begin 返回首元素的地址，end 返回尾元素的下一个地址。 示例代码： #include &lt;iostream&gt; using namespace std; //by zhaocl int main() { in...
TYPES - BEGIN OF struct_type （结构申明）
beyond911的专栏
08-15 1092
Syntax TYPES BEGIN OF struc_type. … TYPES comp … TYPES comp TYPE struc_type BOXED. INCLUDE TYPE|STRUCTURE … … TYPES END OF struc_type. Effect Defines a structured type struc_type. This is introduced using a TYPES statement with the addition BEGIN OF and mu
容器的end()方法
weixin_33739523的博客
01-11 519
容器的end()方法，返回一个迭代器，需要注意：这个迭代器不指向实际的元素，而是表示末端元素的下一个元素，这个迭代器起一个哨兵的作用，表示已经处理完所有的元素。 因此，在查找的时候，返回的迭代器，不等于end()，说明找到了目标。等于end()，说明检查了所有元素，没有找到目标。...
【数据库】（二）——存储过程的本质
To Begin,Begin　　
09-03 883
如果说视图是对SELECT这样的SQL语句封装，那么存储过程就是一条或多条SQL语句的集合。这些SQL语句，可能包括SELECT，UPDATE或是INSERT,DELETE。 通常这些SQL语句的集合代表一个完整的操作，同时这个SQL语句可能包含着某些逻辑（类似于if……else），也就是说有些语句可能执行，可能不执行。为什么要使用?如果不使用存储过程，在多个需要这一完整操作的处理中，或应用中，我们
vector容器 begin()与end()函数、front()与back()的用法
AplusX
09-03 926
begin函数： 函数原型: iterator begin(); const_iterator begin(); 功能： 返回一个当前vector容器中起始元素的迭代器。 end函数： 函数原型： iterator end(); const_iterator end(); 功能： 返回一个当前vector容器中末尾元素的迭代器。 front函数： 函数原型： reference front()...
迭代器的begin，end和指针的begin，end
学习ing
04-17 2737
迭代器的begin，end：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cqdjyy01234

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值