How do I print out the contents of a vector

Question

How do I print out the contents of a std  vector to the screen   A solution that implements the following operator lt  lt  would be nice as well  template lt container C  class T  String delim    quot    quot   String open    quot   quot   String close    quot   quot  gt  std  ostream  amp  operator lt  lt  std  ostream  amp  o  const C lt T gt   amp  x             What can I write here      Here is what I have so far  without a separate function   include  lt iostream gt   include  lt fstream gt   include  lt string gt   include  lt cmath gt   include  lt vector gt   include  lt sstream gt   include  lt cstdio gt  using namespace std   int main         ifstream file  quot maze txt quot        if  file            vector lt char gt  vec istreambuf iterator lt char gt  file    istreambuf iterator lt char gt               vector lt char gt  path          int x   17          char entrance   vec at 16           char firstsquare   vec at x           if  entrance     S                  path push back entrance                      for  x   17  isalpha firstsquare   x                  path push back firstsquare                     for  int i   0  i  lt  path size    i                  cout  lt  lt  path i   lt  lt   quot   quot                     cout  lt  lt  endl          return 0

User · Answer

In C  11 for  auto i   path begin    i    path end      i  std  cout  lt  lt   i  lt  lt        for int i 0  i lt path size      i  std  cout  lt  lt  path i   lt  lt

User · Answer

You can use an iterator  std  vector lt char gt  path         for  std  vector lt char gt   const iterator i   path begin    i    path end      i      std  cout  lt  lt   i  lt  lt        If you want to modify the vector s contents in the for loop  then use iterator rather than const iterator  But there s lots more that can be said about this  If you just want an answer you can use  then you can stop here  otherwise  read on  auto  C  11    typedef   type alias  C  11  This is not another solution  but a supplement to the above iterator solution  If you are using the C  11 standard  or later   then you can use the auto keyword to help the readability  for  auto i   path begin    i    path end      i      std  cout  lt  lt   i  lt  lt        But the type of i will be non-const  i e   the compiler will use std  vector lt char gt   iterator as the type of i   In this case  you might as well just use a typedef  which also brings with it its own benefits  which I won t expound upon here   typedef std  vector lt char gt  Path      Path  now a synonym for the vector Path path         for  Path  const iterator i   path begin    i    path end      i      std  cout  lt  lt   i  lt  lt        C  11 also introduced a type alias  which does the same job as a typedef and you may find more readable than using typedef  using Path   std  vector lt char gt      C  11 onwards only Path path         for  Path  const iterator i   path begin    i    path end      i      std  cout  lt  lt   i  lt  lt        counter You can  of course  use a integer type to record your position in the for loop  for int i 0  i lt path size      i    std  cout  lt  lt  path i   lt  lt        If you are going to do this  it s better to use the container s member types  if they are available and appropriate  std  vector has a member type called size type for this job  it is the type returned by the size method     Path typedef d to std  vector lt char gt  for  Path  size type i 0  i lt path size      i    std  cout  lt  lt  path i   lt  lt        Why not just use this over the iterator solution  For simple cases you might as well  but the point is that an iterator is an object designed to do this job for more complicated objects where this solution is not going to be ideal  range-based for loop  C  11  See Jefffrey s solution  In C  11  and later  you can use the new range-based for loop  which looks like this  for  auto i  path    std  cout  lt  lt  i  lt  lt        Since path is a vector of items  explicitly std  vector lt char gt    the object i is of type of the item of the vector  i e   explicitly  it is of type char   The object i has a value that is a copy of the actual item in the path object  Thus  all changes to i in the loop are not preserved in path itself  Additionally  if you would like to enforce the fact that you don t want to be able to change the copied value of i in the loop  you can force the type of i to be const char like this  for  const auto i  path    std  cout  lt  lt  i  lt  lt        If you would like to modify the items in path  you can use a reference  for  auto amp  i  path    std  cout  lt  lt  i  lt  lt        and even if you don t want to modify path  if the copying of objects is expensive you should use a const reference instead of copying by value  for  const auto amp  i  path    std  cout  lt  lt  i  lt  lt        std  copy  C  11  See Joshua s answer  You can use the STL algorithm std  copy to copy the vector contents onto the output stream  This is an elegant solution if you are comfortable with it  Getting more familiar with STL algorithms should be encouraged  and they provide a lot of functionality that beginners may fall into reinventing themselves  Read Joshua s post for more info  overload std  ostream  operator lt  lt  See Chris s answer  this is more a complement to the other answers since you will still need to implement one of the solutions above in the overloading  In his example he used a counter in a for loop  For example  this is how you could quickly use Joshua s solution   include  lt iterator gt     needed for std  ostram iterator  template  lt typename T gt  std  ostream amp  operator lt  lt   std  ostream amp  out  const std  vector lt T gt  amp  v      if    v empty           out  lt  lt           std  copy  v begin    v end    std  ostream iterator lt T gt  out   quot    quot         out  lt  lt   quot  b b  quot         return out     Using any of the other solutions should be equally straightforward  conclusion Any of the solutions presented here will work  It s up to you and the code on which one is the  quot best quot   Anything more detailed than this is probably best left for another question where the pros cons can be properly evaluated  but as always user preference will always play a part  none of the solutions presented are wrong  but some will look nicer to each individual coder  addendum This is an expanded solution of an earlier one I posted  Since that post kept getting attention  I decided to expand on it and refer to the other excellent solutions that were posted here  My original post had a remark that mentioned that if you were intending on modifying your vector inside a for loop then there are two methods provided by std  vector to access elements  std  vector  operator   which does not do bounds checking  and std  vector  at which does perform bounds checking  In other words  at will throw if you try to access an element outside the vector and operator   wouldn t  I only added this comment  originally  for the sake of mentioning something that it might be useful to know of if anyone already didn t  And I see no difference now  Hence this addendum

User · Answer

overload operator lt  lt    template lt typename OutStream  typename T gt  OutStream amp  operator lt  lt   OutStream amp  out  const vector lt T gt  amp  v        for  auto const amp  tmp   v          out  lt  lt  tmp  lt  lt           out  lt  lt  endl      return out      Usage    vector  lt int gt  test  1 2 3   wcout  lt  lt  test     or any output stream

User · Answer

For those that are interested  I wrote a generalized solution that takes the best of both worlds  is more generalized to any type of range and puts quotes around non-arithmetic types  desired for string-like types   Additionally  this approach should not have any ADL issues and also avoid  surprises   since it s added explicitly on a case-by-case basis    template  lt typename T gt  inline constexpr bool is string type v   std  is convertible v lt const T amp   std  string view gt    template lt class T gt  struct range out     range out T amp  range    r  range          T amp  r     static assert    is string type v lt T gt    strings and string-like types should use operator  lt  lt  directly        template  lt typename T gt  std  ostream amp  operator lt  lt   std  ostream amp  out  range out lt T gt  amp  range      constexpr bool is string like   is string type v lt T  value type gt     constexpr std  string view sep  is string like                       if   range r  empty          out  lt  lt   is string like                    out  lt  lt   range r  begin        for  auto it   range r  begin     1  it    range r  end      it          out  lt  lt  sep  lt  lt   it            out  lt  lt   is string like                      else       out  lt  lt               return out      Now it s fairly easy to use on any range   std  cout  lt  lt  range out  my vector      The string-like check leaves room for improvement  I do also have static assert check in my solution to avoid std  basic string lt  gt   but I left it out here for simplicity

User · Answer

Here is a working library  presented as a complete working program  that I just hacked together    include  lt set gt   include  lt vector gt   include  lt iostream gt    include  lt boost utility enable if hpp gt      Default delimiters template  lt class C gt  struct Delims   static const char  delim 3      template  lt class C gt  const char  Delims lt C gt   delim 3                       Special delimiters for sets                                                                                                               template  lt typename T gt  struct Delims lt  std  set lt T gt   gt    static const char  delim 3      template  lt typename T gt  const char  Delims lt  std  set lt T gt   gt   delim 3                     template  lt class C gt  struct IsContainer   enum   value   false       template  lt typename T gt  struct IsContainer lt  std  vector lt T gt   gt    enum   value   true       template  lt typename T gt  struct IsContainer lt  std  set lt T gt      gt    enum   value   true        template  lt class C gt  typename boost  enable if lt IsContainer lt C gt   std  ostream amp  gt   type operator lt  lt  std  ostream  amp  o  const C  amp  x      o  lt  lt  Delims lt C gt   delim 0     for  typename C  const iterator i   x begin    i    x end      i              if  i    x begin    o  lt  lt  Delims lt C gt   delim 1         o  lt  lt   i          o  lt  lt  Delims lt C gt   delim 2     return o     template  lt typename T gt  struct IsChar   enum   value   false       template  lt  gt  struct IsChar lt char gt    enum   value   true        template  lt typename T  int N gt  typename boost  disable if lt IsChar lt T gt   std  ostream amp  gt   type operator lt  lt  std  ostream  amp  o  const T   amp x  N       o  lt  lt         for  int i   0  i    N    i              if  i  o  lt  lt             o  lt  lt  x i           o  lt  lt         return o     int main       std  vector lt int gt  i    i push back 23     i push back 34      std  set lt std  string gt  j    j insert  hello      j insert  world       double k       1 1  2 2  M PI  -1 0 123 0       std  cout  lt  lt  i  lt  lt    n   lt  lt  j  lt  lt    n   lt  lt  k  lt  lt    n       It currently only works with vector and set  but can be made to work with most containers  just by expanding on the IsContainer specializations  I haven t thought much about whether this code is minimal  but I can t immediately think of anything I could strip out as redundant   EDIT  Just for kicks  I included a version that handles arrays  I had to exclude char arrays to avoid further ambiguities  it might still get into trouble with wchar t

User · Answer

This worked for me       for  auto amp  i   name            int r   0      for  int j   0  j  lt  name r  size   j               std  cout  lt  lt  i j             r        std  cout  lt  lt  std  endl

User · Answer

You can print containers as well as ranges and tuples using the  fmt  library  For example   include  lt vector gt   include  lt fmt ranges h gt   int main       auto v   std  vector lt int gt  1  2  3     fmt  print  quot    quot   v      prints  1  2  3   to stdout  godbolt   I wouldn t recommend overloading operator lt  lt  for standard containers because it may introduce ODR violations  Disclaimer  I m the author of  fmt

User · Answer

In C  11  a range-based for loop might be a good solution   vector lt char gt  items     a   b   c    for  char n   items      cout  lt  lt  n  lt  lt         Output   a b c

User · Answer

For people who want one-liners without loops   I can t believe that noone has though of this  but perhaps it s because of the more C-like approach  Anyways  it is perfectly safe to do this without a loop  in a one-liner  ASSUMING that the std  vector lt char gt  is null-terminated   std  vector lt char gt  test    H    e    l    l    o              w    o    r    l    d          0     std  cout  lt  lt  test data    lt  lt  std  endl    But I would wrap this in the ostream operator  as  Zorawar suggested  just to be safe   template  lt typename T gt std  ostream amp  operator lt  lt   std  ostream amp  out  std  vector lt T gt  amp  v        v push back   0       safety-check      out  lt  lt  v data        return out     std  cout  lt  lt  test  lt  lt  std  endl     will print  Hello  world     We can achieve similar behaviour by using printf instead   fprintf stdout    s n    amp test 0       will also print  Hello  world     NOTE   The overloaded ostream operator needs to accept the vector as non-const  This might make the program insecure or introduce misusable code  Also  since null-character is appended  a reallocation of the std  vector might occur  So using for-loops with iterators will likely be faster

User · Answer

The goal here is to use ADL to do customization of how we pretty print   You pass in a formatter tag  and override 4 functions  before  after  between and descend  in the tag s namespace   This changes how the formatter prints  adornments  when iterating over containers   A default formatter that does   a- gt b   c- gt d   for maps   a b c  for tupleoids   hello  for strings   x y z  for everything else included   It should  just work  with 3rd party iterable types  and treat them like  everything else     If you want custom adornments for your 3rd party iterables  simply create your own tag   It will take a bit of work to handle map descent  you need to overload pretty print descend  your tag to return pretty print  decorator  map magic tag lt your tag gt     Maybe there is a cleaner way to do this  not sure   A little library to detect iterability  and tuple-ness   namespace details     using std  begin  using std  end    template lt class T  class void gt    struct is iterable test std  false type      template lt class T gt    struct is iterable test lt T      decltype  void          void  begin std  declval lt T gt      end std  declval lt T gt                void  std  next begin std  declval lt T gt                  void   begin std  declval lt T gt               1           gt  std  true type      template lt class T gt struct is tupleoid std  false type      template lt class   Ts gt struct is tupleoid lt std  tuple lt Ts    gt  gt  std  true type      template lt class   Ts gt struct is tupleoid lt std  pair lt Ts    gt  gt  std  true type         template lt class T  size t N gt struct is tupleoid lt std  array lt T N gt  gt  std  true type       complete  but problematic   template lt class T gt struct is iterable details  is iterable test lt std  decay t lt T gt  gt     template lt class T  std  size t N gt struct is iterable lt T  amp   N  gt  std  true type       bypass decay template lt class T gt struct is tupleoid details  is tupleoid lt std  decay t lt T gt  gt      template lt class T gt struct is visitable std  integral constant lt bool  is iterable lt T gt     is tupleoid lt T gt    gt        A library that lets us visit the contents of an iterable or tuple type object   template lt class C  class F gt  std  enable if t lt is iterable lt C gt    gt  visit first C amp  amp  c  F amp  amp  f      using std  begin  using std  end    auto amp  amp  b   begin c     auto amp  amp  e   end c     if  b  e        return    std  forward lt F gt  f   b     template lt class C  class F gt  std  enable if t lt is iterable lt C gt    gt  visit all but first C amp  amp  c  F amp  amp  f      using std  begin  using std  end    auto it   begin c     auto amp  amp  e   end c     if  it  e        return    it   std  next it     for    it  e  it   std  next it          f  it          namespace details     template lt class Tup  class F gt    void visit first  std  index sequence lt  gt   Tup amp  amp   F amp  amp         template lt size t    Is  class Tup  class F gt    void visit first  std  index sequence lt 0 Is    gt   Tup amp  amp  tup  F amp  amp  f         std  forward lt F gt  f   std  get lt 0 gt   std  forward lt Tup gt  tup             template lt class Tup  class F gt    void visit all but first  std  index sequence lt  gt   Tup amp  amp   F amp  amp         template lt size t    Is class Tup  class F gt    void visit all but first  std  index sequence lt 0 Is    gt   Tup amp  amp  tup  F amp  amp  f         int unused      0   void         f  std  get lt Is gt  std  forward lt Tup gt  tup           0            void  unused         template lt class Tup  class F gt  std  enable if t lt is tupleoid lt Tup gt    gt  visit first Tup amp  amp  tup  F amp  amp  f      details  visit first  std  make index sequence lt  std  tuple size lt std  decay t lt Tup gt  gt     gt     std  forward lt Tup gt  tup   std  forward lt F gt  f       template lt class Tup  class F gt  std  enable if t lt is tupleoid lt Tup gt    gt  visit all but first Tup amp  amp  tup  F amp  amp  f      details  visit all but first  std  make index sequence lt  std  tuple size lt std  decay t lt Tup gt  gt     gt     std  forward lt Tup gt  tup   std  forward lt F gt  f         A pretty printing library   namespace pretty print     namespace decorator       struct default tag         template lt class Old gt      struct map magic tag Old        magic for maps         Maps get   s  Write trait  is associative  to generalize      template lt class CharT  class Traits  class   Xs  gt      void pretty print before  default tag  std  basic ostream lt CharT  Traits gt  amp  s  std  map lt Xs    gt  const amp            s  lt  lt  CharT                  template lt class CharT  class Traits  class   Xs  gt      void pretty print after  default tag  std  basic ostream lt CharT  Traits gt  amp  s  std  map lt Xs    gt  const amp            s  lt  lt  CharT                     tuples and pairs get         template lt class CharT  class Traits  class Tup  gt      std  enable if t lt is tupleoid lt Tup gt    gt  pretty print before  default tag  std  basic ostream lt CharT  Traits gt  amp  s  Tup const amp            s  lt  lt  CharT                  template lt class CharT  class Traits  class Tup  gt      std  enable if t lt is tupleoid lt Tup gt    gt  pretty print after  default tag  std  basic ostream lt CharT  Traits gt  amp  s  Tup const amp            s  lt  lt  CharT                     strings with the same character type get   s      template lt class CharT  class Traits  class   Xs  gt      void pretty print before  default tag  std  basic ostream lt CharT  Traits gt  amp  s  std  basic string lt CharT  Xs    gt  const amp            s  lt  lt  CharT                 template lt class CharT  class Traits  class   Xs  gt      void pretty print after  default tag  std  basic ostream lt CharT  Traits gt  amp  s  std  basic string lt CharT  Xs    gt  const amp            s  lt  lt  CharT                    and pack the characters together      template lt class CharT  class Traits  class   Xs  gt      void pretty print between  default tag  std  basic ostream lt CharT  Traits gt  amp   std  basic string lt CharT  Xs    gt  const amp               map magic  When iterating over the contents of a map  use the map magic tag      template lt class   Xs gt      map magic tag lt default tag gt  pretty print descend  default tag  std  map lt Xs    gt  const amp            return               template lt class old tag  class C gt      old tag pretty print descend  map magic tag lt old tag gt   C const amp            return                   When printing a pair immediately within a map  use - gt  as a separator      template lt class old tag  class CharT  class Traits  class   Xs  gt      void pretty print between  map magic tag lt old tag gt   std  basic ostream lt CharT  Traits gt  amp  s  std  pair lt Xs    gt  const amp            s  lt  lt  CharT  -    lt  lt  CharT   gt                     default behavior    template lt class CharT  class Traits  class Tag  class Container  gt    void pretty print before  Tag const amp   std  basic ostream lt CharT  Traits gt  amp  s  Container const amp          s  lt  lt  CharT             template lt class CharT  class Traits  class Tag  class Container  gt    void pretty print after  Tag const amp   std  basic ostream lt CharT  Traits gt  amp  s  Container const amp          s  lt  lt  CharT             template lt class CharT  class Traits  class Tag  class Container  gt    void pretty print between  Tag const amp   std  basic ostream lt CharT  Traits gt  amp  s  Container const amp          s  lt  lt  CharT             template lt class Tag  class Container gt    Tag amp  amp  pretty print descend  Tag amp  amp  tag  Container const amp          return std  forward lt Tag gt  tag             print things by default by using  lt  lt     template lt class Tag decorator  default tag  class Scalar  class CharT  class Traits gt    std  enable if t lt  is visitable lt Scalar gt    gt  print  std  basic ostream lt CharT  Traits gt  amp  os  Scalar amp  amp  scalar  Tag amp  amp  Tag           os  lt  lt  std  forward lt Scalar gt  scalar            for anything visitable  see above   use the pretty print algorithm    template lt class Tag decorator  default tag  class C  class CharT  class Traits gt    std  enable if t lt is visitable lt C gt    gt  print  std  basic ostream lt CharT  Traits gt  amp  os  C amp  amp  c  Tag amp  amp  tag Tag           pretty print before  std  forward lt Tag gt  tag   os  std  forward lt C gt  c         visit first  c    amp   auto amp  amp  elem          print  os  std  forward lt decltype elem  gt  elem   pretty print descend  std  forward lt Tag gt  tag   std  forward lt C gt  c                   visit all but first  c    amp   auto amp  amp  elem          pretty print between  std  forward lt Tag gt  tag   os  std  forward lt C gt  c           print  os  std  forward lt decltype elem  gt  elem   pretty print descend  std  forward lt Tag gt  tag   std  forward lt C gt  c                   pretty print after  std  forward lt Tag gt  tag   os  std  forward lt C gt  c             Test code   int main       std  vector lt int gt  x    1 2 3      pretty print  print  std  cout  x      std  cout  lt  lt    n      std  map lt  std  string  int  gt  m    m  hello     3    m  world     42     pretty print  print  std  cout  m      std  cout  lt  lt    n       live example  This does use C  14 features  some  t aliases  and auto amp  amp  lambdas   but none are essential

User · Answer

You can write your own function     void printVec vector lt char gt  vec       for int i   0  i  lt  vec size    i             cout  lt  lt  vec i   lt  lt                 cout  lt  lt  endl

User · Answer

I see two problems  As pointed out in for  x   17  isalpha firstsquare   x     there s either an infinite loop or never executed at all  and also in if  entrance     S   if the entrance character is different than  S  then nothing in pushed to the path vector  making it empty and thus printing nothing on screen  You can test the latter checking for path empty   or printing path size    Either way  wouldn t it be better to use a string instead of a vector  You can access the string contents like an array as well  seek characters  extract substrings and print the string easily  without a loop   Doing it all with strings might be the way to have it written in a less convoluted way and make it easier to spot the problem

User · Answer

I think the best way to do this is to just overload operator lt  lt  by adding this function to your program    include  lt vector gt  using std  vector   include  lt iostream gt  using std  ostream   template lt typename T gt  ostream amp  operator lt  lt   ostream amp  out  const vector lt T gt  amp  v        out  lt  lt           size t last   v size   - 1      for size t i   0  i  lt  v size      i            out  lt  lt  v i           if  i    last               out  lt  lt                  out  lt  lt           return out      Then you can use the  lt  lt  operator on any possible vector  assuming its elements also have ostream amp  operator lt  lt  defined   vector lt string gt   s     first    second    third    vector lt bool gt     b    true  false  true  false  false   vector lt int gt      i    1  2  3  4   cout  lt  lt  s  lt  lt  endl  cout  lt  lt  b  lt  lt  endl  cout  lt  lt  i  lt  lt  endl    Outputs    first  second  third   1  0  1  0  0   1  2  3  4

User · Answer

My solution is simple h  which is part of scc package  All std containers  maps  sets  c-arrays are printable

User · Answer

Coming out of one of the first BoostCon  now called CppCon   I and two others worked on a library to do just this  The main sticking point was needing to extend namespace std  That turned out to be a no-go for a boost library  Unfortunately the links to the code no longer work  but you might find some interesting tidbits in the discussions  at least those that aren t talking about what to name it   http   boost 2283326 n4 nabble com explore-Library-Proposal-Container-Streaming-td2619544 html

User · Answer

The code proved to be handy on several occasions now and I feel the expense to get into customization as usage is quite low  Thus  I decided to release it under MIT license and provide a GitHub repository where the header and a small example file can be downloaded    http   djmuw github io prettycc  0  Preface and wording  A  decoration  in terms of this answer is a set of prefix-string  delimiter-string  and a postfix-string  Where the prefix string is inserted into a stream before and the postfix string after the values of a container  see 2  Target containers   The delimiter string is inserted between the values of the respective container   Note  Actually  this answer does not address the question to 100  since the decoration is not strictly compiled time constant because runtime checks are required to check whether a custom decoration has been applied to the current stream  Nevertheless  I think it has some decent features   Note2  May have minor bugs since it is not yet well tested   1  General idea usage  Zero additional code required for usage  It is to be kept as easy as   include  lt vector gt   include  pretty h   int main       std  cout  lt  lt  std  vector lt int gt  1 2 3 4 5      prints 1  2  3  4  5   return 0      Easy customization          with respect to a specific stream object   include  lt vector gt   include  pretty h   int main          set decoration for std  vector lt int gt  for cout object   std  cout  lt  lt  pretty  decoration lt std  vector lt int gt  gt                    std  cout  lt  lt  std  vector lt int gt  1 2 3 4 5      prints  1 2 3 4 5    return 0      or with respect to all streams    include  lt vector gt   include  pretty h      set decoration for std  vector lt int gt  for all ostream objects PRETTY DEFAULT DECORATION std  vector lt int gt                    int main       std  cout  lt  lt  std  vector lt int gt  1 2 3 4 5      prints  1  2  3  4  5    std  cout  lt  lt  pretty  decoration lt std  vector lt int gt  gt                    std  cout  lt  lt  std  vector lt int gt  1 2 3 4 5      prints  1 2 3 4 5    return 0      Rough description   The code includes a class template providing a default decoration for any type which can be specialized to change the default decoration for  a  certain type s  and it is using the private storage provided by ios base using xalloc pword in order to save a pointer to a pretty  decor object specifically decorating a certain type on a certain stream    If no pretty  decor lt T gt  object for this stream has been set up explicitly pretty  defaulted lt T  charT  chartraitT gt   decoration   is called to obtain the default decoration for the given type  The class pretty  defaulted is to be specialized to customize default decorations   2  Target objects   containers  Target objects obj for the  pretty decoration  of this code are objects having either   overloads std  begin and std  end defined  includes C-Style arrays   having begin obj  and end obj  available via ADL  are of type std  tuple  or of type std  pair    The code includes a trait for identification of classes with range features  begin end    There s no check included  whether begin obj     end obj  is a valid expression  though    The code provides operator lt  lt s in the global namespace that only apply to classes not having a more specialized version of operator lt  lt  available  Therefore  for example std  string is not printed using the operator in this code although having a valid begin end pair   3  Utilization and customization  Decorations can be imposed separately for every type  except different tuples  and stream  not stream type     I e  a std  vector lt int gt  can have different decorations for different stream objects    A  Default decoration  The default prefix is     nothing  as is the default postfix  while the default delimiter is       comma space    B  Customized default decoration of a type by specializing the pretty  defaulted class template  The struct defaulted has a static member function decoration   returning a decor object which includes the default values for the given type   Example using an array   Customize default array printing   namespace pretty     template lt class T  std  size t N gt    struct defaulted lt T N  gt          static decor lt T N  gt  decoration               return                                              Print an arry array   float e 5      3 4f  4 3f  5 2f  1 1f  22 2f    std  cout  lt  lt  e  lt  lt    n      prints  3 4 4 3 5 2 1 1 22 2    Using the PRETTY DEFAULT DECORATION TYPE  PREFIX  DELIM  POSTFIX       macro for char streams  The macro expands to  namespace pretty      template lt    VA ARGS    gt    struct defaulted lt  TYPE  gt        static decor lt  TYPE  gt  decoration           return   PREFIX  DELIM  POSTFIX                      enabling the above partial specialization to be rewritten to  PRETTY DEFAULT DECORATION T N                class T  std  size t N    or inserting a full specialization like  PRETTY DEFAULT DECORATION std  vector lt int gt                     Another macro for wchar t streams is included  PRETTY DEFAULT WDECORATION   C  Impose decoration on streams  The function pretty  decoration is used to impose a decoration on a certain stream  There are overloads taking either  - one string argument being the delimiter  adopting prefix and postfix from the defaulted class  - or three string arguments assembling the complete decoration  Complete decoration for given type and stream  float e 3      3 4f  4 3f  5 2f    std  stringstream u     add       decoration to u u  lt  lt  pretty  decoration lt float 3  gt                       use       decoration u  lt  lt  e  lt  lt    n      prints  3 4  4 3  5 2      uses decoration returned by defaulted lt float 3  gt   decoration   std  cout  lt  lt  e     prints 3 4  4 3  5 2   Customization of delimiter for given stream  PRETTY DEFAULT DECORATION float 3                       std  stringstream v  v  lt  lt  e     prints    3 4 4 3 5 2     v  lt  lt  pretty  decoration lt float 3  gt        v  lt  lt  e     prints    3 4 4 3 5 2     v  lt  lt  pretty  decoration lt float 3  gt                    v  lt  lt  e     prints   3 4 4 3 5 2     4  Special handling of std  tuple  Instead of allowing a specialization for every possible tuple type  this code applies any decoration available for std  tuple lt void  gt  to all kind of std  tuple lt     gt s   5  Remove custom decoration from the stream  To go back to the defaulted decoration for a given type use pretty  clear function template on the stream s   s  lt  lt  pretty  clear lt std  vector lt int gt  gt       5  Further examples  Printing  matrix-like  with newline delimiter  std  vector lt std  vector lt int gt  gt  m   1 2 3    4 5 6    7 8 9     std  cout  lt  lt  pretty  decoration lt std  vector lt std  vector lt int gt  gt  gt    n    std  cout  lt  lt  m    Prints  1  2  3 4  5  6 7  8  9   See it on ideone KKUebZ  6  Code   ifndef pretty print 0x57547 sa4884X 0 1 h guard   define pretty print 0x57547 sa4884X 0 1 h guard    include  lt string gt   include  lt iostream gt   include  lt type traits gt   include  lt iterator gt   include  lt utility gt    define PRETTY DEFAULT DECORATION TYPE  PREFIX  DELIM  POSTFIX             namespace pretty   template lt    VA ARGS    gt       struct defaulted lt  TYPE  gt         static decor lt  TYPE  gt  decoration           return   PREFIX  DELIM  POSTFIX             decoration        defaulted      pretty     define PRETTY DEFAULT WDECORATION TYPE  PREFIX  DELIM  POSTFIX             namespace pretty   template lt    VA ARGS    gt       struct defaulted lt  TYPE  wchar t  std  char traits lt wchar t gt   gt         static decor lt  TYPE  wchar t  std  char traits lt wchar t gt   gt  decoration           return   PREFIX  DELIM  POSTFIX             decoration        defaulted      pretty    namespace pretty      namespace detail            drag in begin and end overloads     using std  begin      using std  end         helper template     template  lt int I gt  using  ol   std  integral constant lt int  I gt           SFINAE check whether T is a range with begin end     template lt class T gt      class is range                helper function declarations using expression sfinae       template  lt class U   ol lt 0 gt    nullptr gt        static std  false type b             template  lt class U   ol lt 1 gt    nullptr gt        static auto b U  amp v  - gt  decltype begin v   std  true type           template  lt class U   ol lt 0 gt    nullptr gt        static std  false type e             template  lt class U   ol lt 1 gt    nullptr gt        static auto e U  amp v  - gt  decltype end v   std  true type              return types       using b return   decltype b lt T gt  std  declval lt T amp  gt             using e return   decltype e lt T gt  std  declval lt T amp  gt           public        static const bool value   b return  value  amp  amp  e return  value                   holder class for data   template lt class T  class CharT   char  class TraitT   std  char traits lt CharT gt  gt    struct decor         static const int xindex      std  basic string lt CharT  TraitT gt  prefix  delimiter  postfix      decor std  basic string lt CharT  TraitT gt  const  amp  pre             std  basic string lt CharT  TraitT gt  const  amp  delim             std  basic string lt CharT  TraitT gt  const  amp  post               prefix pre   delimiter delim   postfix post             template lt class T  class charT  class traits gt    int const decor lt T  charT  traits gt   xindex   std  ios base  xalloc       namespace detail          template lt class T  class CharT  class TraitT gt      void manage decor std  ios base  event evt  std  ios base  amp s  int const idx              using deco type   decor lt T  CharT  TraitT gt         if  evt    std  ios base  erase event             erase deco         void const   const p   s pword idx           if  p                      delete static cast lt deco type const   const gt  p             s pword idx    nullptr                          else if  evt    std  ios base  copyfmt event             copy deco         void const   const p   s pword idx           if  p                      auto np   new deco type   static cast lt deco type const   const gt  p               s pword idx    static cast lt void  gt  np                                template lt class T gt  struct clearer          template lt class T  class CharT  class TraitT gt      std  basic ostream lt CharT  TraitT gt  amp  operator lt  lt          std  basic ostream lt CharT  TraitT gt   amp s  clearer lt T gt  const  amp               using deco type   decor lt T  CharT  TraitT gt         void const   const p   s pword deco type  xindex         if  p             delete if set         delete static cast lt deco type const   gt  p           s pword deco type  xindex    nullptr                return s             template  lt class CharT gt       struct default data   static const CharT   decor 3          template  lt  gt       const char   default data lt char gt   decor 3                          template  lt  gt       const wchar t   default data lt wchar t gt   decor 3      L    L      L                 Clear decoration for T   template lt class T gt    detail  clearer lt T gt  clear     return        template lt class T  class CharT  class TraitT gt    void clear std  basic ostream lt CharT  TraitT gt   amp s    s  lt  lt  detail  clearer lt T gt             impose decoration on ostream   template lt class T  class CharT  class TraitT gt    std  basic ostream lt CharT  TraitT gt  amp  operator lt  lt       std  basic ostream lt CharT  TraitT gt   amp s  decor lt T  CharT  TraitT gt   amp  amp  h          using deco type   decor lt T  CharT  TraitT gt       void const   const p   s pword deco type  xindex          delete if already set     if  p  delete static cast lt deco type const   gt  p       s pword deco type  xindex    static cast lt void   gt  new deco type  std  move h             check whether we alread have a callback registered     if  s iword deco type  xindex     0           if this is not the case register callback and set iword       s register callback detail  manage decor lt T  CharT  TraitT gt   deco type  xindex         s iword deco type  xindex    1            return s         template lt class T  class CharT   char  class TraitT   std  char traits lt CharT gt  gt    struct defaulted         static inline decor lt T  CharT  TraitT gt  decoration               return  detail  default data lt CharT gt   decor 0           detail  default data lt CharT gt   decor 1           detail  default data lt CharT gt   decor 2                   template lt class T  class CharT   char  class TraitT   std  char traits lt CharT gt  gt    decor lt T  CharT  TraitT gt  decoration      std  basic string lt CharT  TraitT gt  const  amp  prefix      std  basic string lt CharT  TraitT gt  const  amp  delimiter      std  basic string lt CharT  TraitT gt  const  amp  postfix          return  prefix  delimiter  postfix           template lt class T  class CharT   char    class TraitT   std  char traits  lt  CharT  gt  gt      decor lt T  CharT  TraitT gt  decoration        std  basic string lt CharT  TraitT gt  const  amp  delimiter          using str type   std  basic string lt CharT  TraitT gt       return  defaulted lt T  CharT  TraitT gt   decoration   prefix        delimiter  defaulted lt T  CharT  TraitT gt   decoration   postfix           template lt class T  class CharT   char    class TraitT   std  char traits  lt  CharT  gt  gt      decor lt T  CharT  TraitT gt  decoration CharT const   const prefix        CharT const   const delimiter  CharT const   const postfix          using str type   std  basic string lt CharT  TraitT gt       return  str type  prefix    str type  delimiter    str type  postfix             template lt class T  class CharT   char    class TraitT   std  char traits  lt  CharT  gt  gt      decor lt T  CharT  TraitT gt  decoration CharT const   const delimiter          using str type   std  basic string lt CharT  TraitT gt       return  defaulted lt T  CharT  TraitT gt   decoration   prefix        str type  delimiter    defaulted lt T  CharT  TraitT gt   decoration   postfix           template lt typename T  std  size t N  std  size t L gt    struct tuple         template lt class CharT  class TraitT gt      static void print std  basic ostream lt CharT  TraitT gt  amp  s  T const  amp  value        std  basic string lt CharT  TraitT gt  const  amp delimiter              s  lt  lt  std  get lt N gt  value   lt  lt  delimiter        tuple lt T  N   1  L gt   print s  value  delimiter                 template lt typename T  std  size t N gt    struct tuple lt T  N  N gt          template lt class CharT  class TraitT gt      static void print std  basic ostream lt CharT  TraitT gt  amp  s  T const  amp  value        std  basic string lt CharT  TraitT gt  const  amp           s  lt  lt  std  get lt N gt  value                  template lt class CharT  class TraitT gt  std  basic ostream lt CharT  TraitT gt   amp  operator lt  lt      std  basic ostream lt CharT  TraitT gt   amp s  std  tuple lt  gt  const  amp  v      using deco type   pretty  decor lt std  tuple lt void  gt   CharT  TraitT gt     using defaulted type   pretty  defaulted lt std  tuple lt void  gt   CharT  TraitT gt     void const   const p   s pword deco type  xindex     auto const d   static cast lt deco type const   const gt  p     s  lt  lt   d   d- gt prefix   defaulted type  decoration   prefix     s  lt  lt   d   d- gt postfix   defaulted type  decoration   postfix     return s     template lt class CharT  class TraitT  class     T gt  std  basic ostream lt CharT  TraitT gt   amp  operator lt  lt      std  basic ostream lt CharT  TraitT gt   amp s  std  tuple lt T    gt  const  amp  v      using deco type   pretty  decor lt std  tuple lt void  gt   CharT  TraitT gt     using defaulted type   pretty  defaulted lt std  tuple lt void  gt   CharT  TraitT gt     using pretty tuple   pretty  tuple lt std  tuple lt T    gt   0U  sizeof    T -1U gt     void const   const p   s pword deco type  xindex     auto const d   static cast lt deco type const   const gt  p     s  lt  lt   d   d- gt prefix   defaulted type  decoration   prefix     pretty tuple  print s  v  d   d- gt delimiter        defaulted type  decoration   delimiter     s  lt  lt   d   d- gt postfix   defaulted type  decoration   postfix     return s     template lt class T  class U  class CharT  class TraitT gt  std  basic ostream lt CharT  TraitT gt   amp  operator lt  lt      std  basic ostream lt CharT  TraitT gt   amp s  std  pair lt T  U gt  const  amp  v      using deco type   pretty  decor lt std  pair lt T  U gt   CharT  TraitT gt     using defaulted type   pretty  defaulted lt std  pair lt T  U gt   CharT  TraitT gt     void const   const p   s pword deco type  xindex     auto const d   static cast lt deco type const   const gt  p     s  lt  lt   d   d- gt prefix   defaulted type  decoration   prefix     s  lt  lt  v first    s  lt  lt   d   d- gt delimiter   defaulted type  decoration   delimiter     s  lt  lt  v second    s  lt  lt   d   d- gt postfix   defaulted type  decoration   postfix     return s      template lt class T  class CharT   char  class TraitT   std  char traits  lt  CharT  gt  gt    typename std  enable if  lt  pretty  detail  is range lt T gt   value    std  basic ostream  lt  CharT  TraitT  gt  gt    type  amp  operator lt  lt        std  basic ostream lt CharT  TraitT gt   amp s  T const  amp  v      bool first true     using deco type   pretty  decor lt T  CharT  TraitT gt     using default type   pretty  defaulted lt T  CharT  TraitT gt     void const   const p   s pword deco type  xindex     auto d   static cast lt pretty  decor lt T  CharT  TraitT gt  const   const gt  p     s  lt  lt   d   d- gt prefix   default type  decoration   prefix     for  auto const  amp  e   v         v is range thus range based for works     if   first  s  lt  lt   d   d- gt delimiter   default type  decoration   delimiter       s  lt  lt  e      first   false        s  lt  lt   d   d- gt postfix   default type  decoration   postfix     return s      endif    pretty print 0x57547 sa4884X 0 1 h guard

User · Answer

I am going to add another answer here  because I have come up with a different approach to my previous one  and that is to use locale facets   The basics are here  Essentially what you do is    Create a class that derives from std  locale  facet  The slight downside is that you will need a compilation unit somewhere to hold its id  Let s call it MyPrettyVectorPrinter  You d probably give it a better name  and also create ones for pair and map  In your stream function  you check std  has facet lt  MyPrettyVectorPrinter  gt  If that returns true  extract it with std  use facet lt  MyPrettyVectorPrinter  gt   os getloc     Your facet objects will have values for the delimiters and you can read them  If the facet isn t found  your print function  operator lt  lt   provides default ones  Note you can do the same thing for reading a vector    I like this method because you can use a default print whilst still being able to use a custom override   The downsides are needing a library for your facet if used in multiple projects  so can t just be headers-only  and also the fact that you need to beware about the expense of creating a new locale object    I have written this as a new solution rather than modify my other one because I believe both approaches can be correct and you take your pick

User · Answer

You can format containers as well as ranges and tuples using the  fmt  library  For example   include  lt vector gt   include  lt fmt ranges h gt   int main       std  vector lt char gt  path    for  int c    a   c  lt    z     c      path push back c      fmt  print  quot    quot   path      prints   a    b    c    d    e    f    g    h    i    j    k    l    m    n    o    p    q    r    s    t    u    v    w    x    y    z    to stdout  godbolt   Alternatively you can iterate over the elements and print them individually  Disclaimer  I m the author of  fmt

User · Answer

This solution was inspired by Marcelo s solution  with a few changes    include  lt iostream gt   include  lt iterator gt   include  lt type traits gt   include  lt vector gt   include  lt algorithm gt      This works similar to ostream iterator  but doesn t print a delimiter after the final item template lt typename T  typename TChar   char  typename TCharTraits   std  char traits lt TChar gt   gt  class pretty ostream iterator   public std  iterator lt std  output iterator tag  void  void  void  void gt    public      typedef TChar char type      typedef TCharTraits traits type      typedef std  basic ostream lt TChar  TCharTraits gt  ostream type       pretty ostream iterator ostream type  amp stream  const char type  delim   NULL             stream  amp stream    delim delim    insertDelim false                   pretty ostream iterator lt T  TChar  TCharTraits gt  amp  operator  const T  amp value                if   delim    NULL                            Don t insert a delimiter if this is the first time the function is called             if   insertDelim                      stream   lt  lt   delim              else                  insertDelim   true                       stream   lt  lt  value          return  this             pretty ostream iterator lt T  TChar  TCharTraits gt  amp  operator                  return  this             pretty ostream iterator lt T  TChar  TCharTraits gt  amp  operator                   return  this             pretty ostream iterator lt T  TChar  TCharTraits gt  amp  operator   int                return  this        private      ostream type   stream      const char type   delim      bool  insertDelim       if  MSC VER  gt   1400     Declare pretty ostream iterator as checked template lt typename T  typename TChar  typename TCharTraits gt  struct std   Is checked helper lt pretty ostream iterator lt T  TChar  TCharTraits gt   gt    public std  tr1  true type        endif     MSC VER  gt   1400  namespace std          Pre-declarations of container types so we don t actually have to include the relevant headers if not needed  speeding up compilation time         These aren t necessary if you do actually include the headers      template lt typename T  typename TAllocator gt  class vector      template lt typename T  typename TAllocator gt  class list      template lt typename T  typename TTraits  typename TAllocator gt  class set      template lt typename TKey  typename TValue  typename TTraits  typename TAllocator gt  class map        Basic is container template  specialize to derive from std  true type for all desired container types template lt typename T gt  struct is container   public std  false type          Mark vector as a container template lt typename T  typename TAllocator gt  struct is container lt std  vector lt T  TAllocator gt   gt    public std  true type          Mark list as a container template lt typename T  typename TAllocator gt  struct is container lt std  list lt T  TAllocator gt   gt    public std  true type          Mark set as a container template lt typename T  typename TTraits  typename TAllocator gt  struct is container lt std  set lt T  TTraits  TAllocator gt   gt    public std  true type          Mark map as a container template lt typename TKey  typename TValue  typename TTraits  typename TAllocator gt  struct is container lt std  map lt TKey  TValue  TTraits  TAllocator gt   gt    public std  true type          Holds the delimiter values for a specific character type template lt typename TChar gt  struct delimiters values       typedef TChar char type      const TChar  prefix      const TChar  delimiter      const TChar  postfix         Defines the delimiter values for a specific container and character type template lt typename T  typename TChar gt  struct delimiters       static const delimiters values lt TChar gt  values          Default delimiters template lt typename T gt  struct delimiters lt T  char gt    static const delimiters values lt char gt  values     template lt typename T gt  const delimiters values lt char gt  delimiters lt T  char gt   values                         template lt typename T gt  struct delimiters lt T  wchar t gt    static const delimiters values lt wchar t gt  values     template lt typename T gt  const delimiters values lt wchar t gt  delimiters lt T  wchar t gt   values     L      L      L            Delimiters for set template lt typename T  typename TTraits  typename TAllocator gt  struct delimiters lt std  set lt T  TTraits  TAllocator gt   char gt    static const delimiters values lt char gt  values     template lt typename T  typename TTraits  typename TAllocator gt  const delimiters values lt char gt  delimiters lt std  set lt T  TTraits  TAllocator gt   char gt   values                         template lt typename T  typename TTraits  typename TAllocator gt  struct delimiters lt std  set lt T  TTraits  TAllocator gt   wchar t gt    static const delimiters values lt wchar t gt  values     template lt typename T  typename TTraits  typename TAllocator gt  const delimiters values lt wchar t gt  delimiters lt std  set lt T  TTraits  TAllocator gt   wchar t gt   values     L      L      L            Delimiters for pair template lt typename T1  typename T2 gt  struct delimiters lt std  pair lt T1  T2 gt   char gt    static const delimiters values lt char gt  values     template lt typename T1  typename T2 gt  const delimiters values lt char gt  delimiters lt std  pair lt T1  T2 gt   char gt   values                       template lt typename T1  typename T2 gt  struct delimiters lt std  pair lt T1  T2 gt   wchar t gt    static const delimiters values lt wchar t gt  values     template lt typename T1  typename T2 gt  const delimiters values lt wchar t gt  delimiters lt std  pair lt T1  T2 gt   wchar t gt   values     L     L      L           Functor to print containers  You can use this directly if you want to specificy a non-default delimiters type  template lt typename T  typename TChar   char  typename TCharTraits   std  char traits lt TChar gt   typename TDelimiters   delimiters lt T  TChar gt   gt  struct print container helper       typedef TChar char type      typedef TDelimiters delimiters type      typedef std  basic ostream lt TChar  TCharTraits gt  amp  ostream type       print container helper const T  amp container             container  amp container                   void operator   ostream type  amp stream  const               if  delimiters type  values prefix    NULL               stream  lt  lt  delimiters type  values prefix          std  copy  container- gt begin     container- gt end    pretty ostream iterator lt typename T  value type  TChar  TCharTraits gt  stream  delimiters type  values delimiter            if  delimiters type  values postfix    NULL               stream  lt  lt  delimiters type  values postfix        private      const T   container         Prints a print container helper to the specified stream  template lt typename T  typename TChar  typename TCharTraits  typename TDelimiters gt  std  basic ostream lt TChar  TCharTraits gt  amp  operator lt  lt  std  basic ostream lt TChar  TCharTraits gt   amp stream  const print container helper lt T  TChar  TDelimiters gt   amp helper        helper stream       return stream        Prints a container to the stream using default delimiters template lt typename T  typename TChar  typename TCharTraits gt  typename std  enable if lt is container lt T gt   value  std  basic ostream lt TChar  TCharTraits gt  amp  gt   type     operator lt  lt  std  basic ostream lt TChar  TCharTraits gt   amp stream  const T  amp container        stream  lt  lt  print container helper lt T  TChar  TCharTraits gt  container       return stream        Prints a pair to the stream using delimiters from delimiters lt std  pair lt T1  T2 gt  gt   template lt typename T1  typename T2  typename TChar  typename TCharTraits gt  std  basic ostream lt TChar  TCharTraits gt  amp  operator lt  lt  std  basic ostream lt TChar  TCharTraits gt   amp stream  const std  pair lt T1  T2 gt   amp value        if  delimiters lt std  pair lt T1  T2 gt   TChar gt   values prefix    NULL           stream  lt  lt  delimiters lt std  pair lt T1  T2 gt   TChar gt   values prefix       stream  lt  lt  value first       if  delimiters lt std  pair lt T1  T2 gt   TChar gt   values delimiter    NULL           stream  lt  lt  delimiters lt std  pair lt T1  T2 gt   TChar gt   values delimiter       stream  lt  lt  value second       if  delimiters lt std  pair lt T1  T2 gt   TChar gt   values postfix    NULL           stream  lt  lt  delimiters lt std  pair lt T1  T2 gt   TChar gt   values postfix      return stream            Used by the sample below to generate some values struct fibonacci       fibonacci     f1 0   f2 1          int operator                   int r   f1   f2          f1   f2          f2   r          return f1        private      int f1      int f2      int main         std  vector lt int gt  v      std  generate n std  back inserter v   10  fibonacci          std  cout  lt  lt  v  lt  lt  std  endl          Example of using pretty ostream iterator directly     std  generate n pretty ostream iterator lt int gt  std  cout        20  fibonacci         std  cout  lt  lt  std  endl      Like Marcelo s version  it uses an is container type trait that must be specialized for all containers that are to be supported  It may be possible to use a trait to check for value type  const iterator  begin   end    but I m not sure I d recommend that since it might match things that match those criteria but aren t actually containers  like std  basic string  Also like Marcelo s version  it uses templates that can be specialized to specify the delimiters to use   The major difference is that I ve built my version around a pretty ostream iterator  which works similar to the std  ostream iterator but doesn t print a delimiter after the last item  Formatting the containers is done by the print container helper  which can be used directly to print containers without an is container trait  or to specify a different delimiters type   I ve also defined is container and delimiters so it will work for containers with non-standard predicates or allocators  and for both char and wchar t  The operator lt  lt  function itself is also defined to work with both char and wchar t streams   Finally  I ve used std  enable if  which is available as part of C  0x  and works in Visual C   2010 and g   4 3  needs the -std c  0x flag  and later  This way there is no dependency on Boost

User · Answer

How about for each   lambda expression   include  lt vector gt   include  lt algorithm gt         std  vector lt char gt  vec         std  for each                vec cbegin                  vec cend                      const char c   std  cout  lt  lt  c  lt  lt   quot   quot                              Of course  a range-based for is the most elegant solution for this concrete task  but this one gives many other possibilities as well  Explanation The for each algorithm takes an input range and a callable object  calling this object on every element of the range  An input range is defined by two iterators  A callable object can be a function  a pointer to function  an object of a class which overloads    operator or as in this case  a lambda expression  The parameter for this expression matches the type of the elements from vector  The beauty of this implementation is the power you get from lambda expressions - you can use this approach for a lot more things than just printing the vector

User · Answer

In C  11 you can now use a range-based for loop   for  auto const amp  c   path      std  cout  lt  lt  c  lt  lt

User · Answer

The problem is probably in the previous loop   x   17  isalpha firstsquare   x     This loop will run not at all  if firstsquare is non-alphabetic  or will run forever  if it is alphabetic   The reason is that firstsquare doesn t change as x is incremented

User · Answer

Here is my version of implementation done in 2016 Everything is in one header  so it s easy to use https   github com skident eos blob master include eos io print hpp      file       print hpp      brief      Useful functions for work with STL containers                    Now it supports generic print for STL containers like   elem1  elem2  elem3      Supported STL conrainers  vector  deque  list  set multiset  unordered set      map  multimap  unordered map  array         author     Skident      date       02 09 2016      copyright  Skident Inc        pragma once     check is the C  11 or greater available  special hack for MSVC   if  defined  MSC VER   amp  amp    cplusplus  gt   199711L       cplusplus  gt   201103L      define MODERN CPP AVAILABLE 1  endif    include  lt iostream gt   include  lt sstream gt   include  lt vector gt   include  lt deque gt   include  lt set gt   include  lt list gt   include  lt map gt   include  lt cctype gt    ifdef MODERN CPP AVAILABLE      include  lt array gt       include  lt unordered set gt       include  lt unordered map gt       include  lt forward list gt   endif    define dump value  std  cout  lt  lt    value   lt  lt   quot    quot   lt  lt   value   lt  lt  std  endl   define BUILD CONTENT                                                                 std  stringstream ss                                                          for    it    collection end      it                                                                                                                             ss  lt  lt   it  lt  lt  elem separator                                                                                                                        define BUILD MAP CONTENT                                                             std  stringstream ss                                                          for    it    collection end      it                                                                                                                             ss   lt  lt  it- gt first                                                                   lt  lt  keyval separator                                                            lt  lt  it- gt second                                                                  lt  lt  elem separator                                                                                                                              define COMPILE CONTENT                                                               std  string data   ss str                                                     if   data empty    amp  amp   elem separator empty                                        data   data substr 0  data rfind elem separator                           std  string result   first bracket   data   last bracket                      os  lt  lt  result                                                                  if  needEndl                                                                      os  lt  lt  std  endl                                                                       Template definitions            generic template for classes  deque  list  forward list  vector  define VECTOR AND CO TEMPLATE                                                template lt                                                                      template lt class T                                                                   class Alloc   std  allocator lt T gt   gt                                 class Container  class Type  class Alloc gt                            define SET TEMPLATE                                                          template lt                                                                      template lt class T                                                                   class Compare   std  less lt T gt                                               class Alloc   std  allocator lt T gt   gt                                     class Container  class T  class Compare  class Alloc gt            define USET TEMPLATE                                                         template lt                                                              template  lt  class Key                                                                 class Hash   std  hash lt Key gt                                                class Pred   std  equal to lt Key gt                                            class Alloc   std  allocator lt Key gt                                           gt                                                                   class Container  class Key  class Hash  class Pred  class Alloc            gt                                                                         define MAP TEMPLATE                                                          template lt                                                                      template lt class Key                                                                class T                                                                   class Compare   std  less lt Key gt                                             class Alloc   std  allocator lt std  pair lt const Key T gt   gt                       gt                                                                  class Container  class Key                                                class Value    class Compare  class Alloc   gt                          define UMAP TEMPLATE                                                         template lt                                                                      template lt class Key                                                                   class T                                                                   class Hash   std  hash lt Key gt                                                class Pred   std  equal to lt Key gt                                            class Alloc   std  allocator lt std  pair lt const Key T gt   gt                     gt                                                                 class Container  class Key  class Value                                   class Hash  class Pred  class Alloc                                                gt                                                             define ARRAY TEMPLATE                                                        template lt                                                                      template lt class T  std  size t N gt                                           class Array  class Type  std  size t Size gt                            namespace eos       static const std  string default elem separator        quot    quot       static const std  string default keyval separator      quot    gt   quot       static const std  string default first bracket         quot   quot       static const std  string default last bracket          quot   quot             Prints template Container lt T gt  as in Python         Supported containers  vector  deque  list  set  unordered set C  11   forward list C  11           param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    template lt class Container gt      void print  const Container amp  collection                 const std  string amp  elem separator     default elem separator                 const std  string amp  first bracket      default first bracket                 const std  string amp  last bracket       default last bracket                 std  ostream amp  os   std  cout                 bool needEndl   true                             typename Container  const iterator it   collection begin            BUILD CONTENT         COMPILE CONTENT                 Prints collections with one template argument and allocator as in Python          Supported standard collections  vector  deque  list  forward list          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    VECTOR AND CO TEMPLATE     void print  const Container lt Type gt  amp  collection                 const std  string amp  elem separator     default elem separator                 const std  string amp  first bracket      default first bracket                 const std  string amp  last bracket       default last bracket                 std  ostream amp  os   std  cout                 bool needEndl   true                             typename Container lt Type gt   const iterator it   collection begin            BUILD CONTENT         COMPILE CONTENT                 Prints collections like std set lt T  Compare  Alloc gt  as in Python          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    SET TEMPLATE     void print  const Container lt T  Compare  Alloc gt  amp  collection                 const std  string amp  elem separator     default elem separator                 const std  string amp  first bracket      default first bracket                 const std  string amp  last bracket       default last bracket                 std  ostream amp  os   std  cout                 bool needEndl   true                             typename Container lt T  Compare  Alloc gt   const iterator it   collection begin            BUILD CONTENT         COMPILE CONTENT                 Prints collections like std unordered set lt Key  Hash  Pred  Alloc gt  as in Python          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    USET TEMPLATE     void print  const Container lt Key  Hash  Pred  Alloc gt  amp  collection                 const std  string amp  elem separator     default elem separator                 const std  string amp  first bracket      default first bracket                 const std  string amp  last bracket       default last bracket                 std  ostream amp  os   std  cout                 bool needEndl   true                             typename Container lt Key  Hash  Pred  Alloc gt   const iterator it   collection begin            BUILD CONTENT         COMPILE CONTENT                Prints collections like std map lt T  U gt  as in Python         supports generic objects of std  map  multimap          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    MAP TEMPLATE     void print    const Container lt Key  Value gt  amp  collection                   const std  string amp  elem separator     default elem separator                   const std  string amp  keyval separator   default keyval separator                   const std  string amp  first bracket      default first bracket                   const std  string amp  last bracket       default last bracket                   std  ostream amp  os   std  cout                   bool needEndl   true                         typename Container lt Key  Value gt   const iterator it   collection begin            BUILD MAP CONTENT         COMPILE CONTENT                Prints classes like std unordered map as in Python          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    UMAP TEMPLATE     void print    const Container lt Key  Value  Hash  Pred  Alloc gt  amp  collection                   const std  string amp  elem separator     default elem separator                   const std  string amp  keyval separator   default keyval separator                   const std  string amp  first bracket      default first bracket                   const std  string amp  last bracket       default last bracket                   std  ostream amp  os   std  cout                   bool needEndl   true                         typename Container lt Key  Value  Hash  Pred  Alloc gt   const iterator it   collection begin            BUILD MAP CONTENT         COMPILE CONTENT                Prints collections like std array lt T  Size gt  as in Python          param collection which should be printed          param elem separator the separator which will be inserted between elements of collection          param keyval separator separator between key and value of map  For default it is the    gt            param first bracket data before collection s elements  usual it is the parenthesis  square or curly bracker                         param last bracket data after collection s elements  usual it is the parenthesis  square or curly bracker                    ARRAY TEMPLATE     void print    const Array lt Type  Size gt  amp  collection                   const std  string amp  elem separator     default elem separator                   const std  string amp  first bracket      default first bracket                   const std  string amp  last bracket       default last bracket                   std  ostream amp  os   std  cout                   bool needEndl   true                             typename Array lt Type  Size gt   const iterator it   collection begin            BUILD CONTENT         COMPILE CONTENT                Removes all whitespaces before data in string           param str string with data          return string without whitespaces in left part     std  string ltrim const std  string amp  str            Removes all whitespaces after data in string          param str string with data          return string without whitespaces in right part     std  string rtrim const std  string amp  str            Removes all whitespaces before and after data in string          param str string with data          return string without whitespaces before and after data in string     std  string trim const std  string amp  str                                                                                                   ostream logic                               Should be specified for concrete containers         because of another types can be suitable         for templates  for example templates break         the code like this  quot cout  lt  lt  string  quot hello quot    lt  lt  endl  quot                                                                       define PROCESS VALUE COLLECTION os  collection                                   print   collection                                                                    default elem separator                                                        default first bracket                                                         default last bracket                                                          os                                                                            false                                                                                                                                             define PROCESS KEY VALUE COLLECTION os  collection                               print   collection                                                                    default elem separator                                                        default keyval separator                                                      default first bracket                                                         default last bracket                                                          os                                                                            false                                                                                                                                                    lt  specialization for vector     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  vector lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for deque     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  deque lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for list     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  list lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for set     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  set lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for multiset     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  multiset lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os          ifdef MODERN CPP AVAILABLE         lt  specialization for unordered map     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  unordered set lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for forward list     template lt class T gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  forward list lt T gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os                 lt  specialization for array     template lt class T  std  size t N gt      std  ostream amp  operator lt  lt  std  ostream amp  os  const std  array lt T  N gt  amp  collection                PROCESS VALUE COLLECTION os  collection          return os         endif          lt  specialization for map  multimap     MAP TEMPLATE     std  ostream amp  operator lt  lt  std  ostream amp  os  const Container lt Key  Value gt  amp  collection                PROCESS KEY VALUE COLLECTION os  collection          return os                 lt  specialization for unordered map     UMAP TEMPLATE     std  ostream amp  operator lt  lt  std  ostream amp  os  const Container lt Key  Value  Hash  Pred  Alloc gt  amp  collection                PROCESS KEY VALUE COLLECTION os  collection          return os

User · Answer

Just copy the container to the console   std  vector lt int gt  v 1 2 3 4   std  copy v begin   v end   std  ostream iterator lt int gt  std  cout            Should output    1 2 3 4

User · Answer

This answer is based on the answer from Zorawar  but I couldn t leave a comment there  You can make the auto  C  11  typedef version const by using cbegin and cend instead for  auto i   path cbegin    i    path cend      i      std  cout  lt  lt   i  lt  lt

User · Answer

A much easier way to do this is with the standard copy algorithm     include  lt iostream gt   include  lt algorithm gt     for copy  include  lt iterator gt     for ostream iterator  include  lt vector gt   int main            Set up vector to hold chars a-z        std  vector lt char gt  path      for  int ch    a   ch  lt    z     ch          path push back ch           Print path vector to console        std  copy path begin    path end    std  ostream iterator lt char gt  std  cout              return 0      The ostream iterator is what s called an iterator adaptor  It is templatized over the type to print out to the stream  in this case  char   cout  aka console output  is the stream we want to write to  and the space character       is what we want printed between each element stored in the vector    This standard algorithm is powerful and so are many others  The power and flexibility the standard library gives you are what make it so great  Just imagine  you can print a vector to the console with just one line of code  You don t have to deal with special cases with the separator character  You don t need to worry about for-loops  The standard library does it all for you

User · Answer

include lt bits stdc   h gt  using namespace std   int main         vector  lt pair lt string int gt   gt  v      int n      cin gt  gt n  int i      for  i 0 i lt n i                  int  end          string str          cin gt  gt str          cin gt  gt end          v push back make pair str end             for  int j 0 j lt n j          cout lt  lt v j  first lt  lt      lt  lt v j  second lt  lt endl

User · Answer

This has been edited a few times  and we have decided to call the main class that wraps a collection RangePrinter  This should work automatically with any collection once you have written the one-time operator lt  lt  overload  except that you will need a special one for maps to print the pair  and may want to customize the delimiter there  You could also have a special  quot print quot  function to use on the item instead of just outputting it directly  a bit like STL algorithms allow you to pass in custom predicates  With map you would use it this way  with a custom printer for the std  pair  Your  quot default quot  printer would just output it to the stream  Ok  let s work on a custom printer  I will change my outer class to RangePrinter  So we have 2 iterators and some delimiters but have not customized how to print the actual items  struct DefaultPrinter      template lt  typename T  gt     std  ostream  amp  operator    std  ostream amp  os  const T amp  t   const           return os  lt  lt  t              overload for std  pair    template lt  typename K  typename V  gt     std  ostream  amp  operator    std  ostream  amp  os  std  pair lt K V gt  const amp  p             return os  lt  lt  p first  lt  lt       lt  lt  p second              some prototypes template lt  typename FwdIter  typename Printer  gt  class RangePrinter   template lt  typename FwdIter  typename Printer  gt     std  ostream  amp  operator lt  lt   std  ostream  amp            RangePrinter lt FwdIter  Printer gt  const amp      template lt  typename FwdIter  typename Printer DefaultPrinter  gt  class RangePrinter       FwdIter begin      FwdIter end      std  string delim      std  string open      std  string close      Printer printer       friend std  ostream amp  operator lt  lt   lt  gt   std  ostream amp             RangePrinter lt FwdIter Printer gt  const amp      public      RangePrinter  FwdIter b  FwdIter e  Printer p           std  string const amp  d  std  string const  amp  o  std  string const amp  c           begin  b    end  e    printer  p    open  o    close  c                         with no  quot printer quot  variable     RangePrinter  FwdIter b  FwdIter e           std  string const amp  d  std  string const  amp  o  std  string const amp  c           begin  b    end  e    open  o    close  c                      template lt typename FwdIter  typename Printer gt  std  ostream amp  operator lt  lt   std  ostream amp  os             RangePrinter lt FwdIter  Printer gt  const amp  range         const Printer  amp  printer   range printer       os  lt  lt  range open      FwdIter begin   range begin  end   range end          print the first item     if  begin    end                return os  lt  lt  range close              printer  os   begin            print the rest with delim as a prefix     for    begin  begin    end    begin                os  lt  lt  range delim         printer  os   begin              return os  lt  lt  range close     Now by default it will work for maps as long as the key and value types are both printable and you can put in your own special item printer for when they are not  as you can with any other type   or if you do not want  quot   quot  as the delimiter  I am moving the free-function to create these to the end now  A free-function  iterator version  would look like something this and you could even have defaults  template lt typename Collection gt  RangePrinter lt typename Collection  const iterator gt  rangePrinter       const Collection amp  coll  const char   delim  quot   quot           const char   open  quot   quot   const char   close  quot   quot        return RangePrinter lt  typename Collection  const iterator  gt         coll begin    coll end    delim  open  close       You could then use it for std  set by  std  cout  lt  lt  outputFormatter  mySet     You can also write free-function version that take a custom printer and ones that take two iterators  In any case they will resolve the template parameters for you  and you will be able to pass them through as temporaries

User · Answer

template collection  apply std  cout  lt  lt  and std  to string to std  vector  std  array and std  tuple As printing a vector in cpp turned out to be surprisingly much work  at least compared to how basic this task is  and as one steps over the same problem again  when working with other container  here a more general solution     Template collection content This template collection handles 3 container types  std  vector  std  array and std  tuple  It defines std  to string   for those and makes it possible to directly print them out by std  cout  lt  lt  container   Further it defines the  lt  lt  operator for std  string  lt  lt  container  With this it gets possible to construct strings containig these container types in a compact way  From std  string s1    quot s1   quot    std  to string arr     quot    quot    std  to string vec     quot    quot    std  to string tup    we get to std  string s2   STR    lt  lt   quot s2   quot   lt  lt  arr  lt  lt   quot    quot   lt  lt  vec  lt  lt   quot    quot   lt  lt  tup   Code You can test this code interactively  here   include  lt iostream gt   include  lt string gt   include  lt tuple gt   include  lt vector gt   include  lt array gt   namespace std             declations  needed for std  to string std  vector lt std  tuple lt int  float gt  gt       std  string to string std  string str       std  string to string const char  str       template lt typename T  size t N gt      std  string to string std  array lt T  N gt  const amp  arr       template lt typename T gt      std  string to string std  vector lt T gt  const amp  vec       template lt typename    Args gt      std  string to string const std  tuple lt Args    gt  amp  tup            std  string to string std  string str                return std  string str             std  string to string const char  str                return std  string str              template lt typename T  size t N gt      std  string to string std  array lt T  N gt  const amp  arr                std  string s  quot   quot           for  std  size t t   0  t    N    t              s    std  to string arr t      t 1  lt  N    quot    quot   quot  quot            return s    quot   quot              template lt typename T gt      std  string to string std  vector lt T gt  const amp  vec                std  string s  quot   quot           for  std  size t t   0  t    vec size      t              s    std  to string vec t      t 1  lt  vec size      quot    quot   quot  quot            return s    quot   quot                     to string tuple         https   en cppreference com w cpp utility tuple operator 3D     template lt class Tuple  std  size t N gt      struct TupleString               static std  string str const Tuple amp  tup                        std  string out              out    TupleString lt Tuple  N-1 gt   str tup               out     quot    quot               out    std  to string std  get lt N-1 gt  tup                return out                       template lt class Tuple gt      struct TupleString lt Tuple  1 gt                static std  string str const Tuple amp  tup                        std  string out              out    std  to string std  get lt 0 gt  tup                return out                       template lt typename    Args gt      std  string to string const std  tuple lt Args    gt  amp  tup                std  string out    quot   quot           out    TupleString lt decltype tup   sizeof    Args  gt   str tup           out     quot   quot           return out             namespace std          cout  cout  lt  lt  continer     template  lt typename T  std  size t N gt     cout  lt  lt  array std  ostream amp  operator  lt  lt  std  ostream  amp out  std  array lt T  N gt   amp con        out  lt  lt   std  to string con       return out    template  lt typename T  typename A gt     cout  lt  lt  vector std  ostream amp  operator  lt  lt  std  ostream  amp out  std  vector lt T  A gt   amp con        out  lt  lt   std  to string con       return out    template lt typename    Args gt     cout  lt  lt  tuple std  ostream amp  operator  lt  lt  std  ostream  amp out  std  tuple lt Args    gt   amp con        out  lt  lt   std  to string con       return out            Concatenate  string  lt  lt  continer     template  lt class C gt  std  string operator  lt  lt  std  string str  C  amp con        std  string out   str      out    std  to string con       return out     define STR   std  string  quot  quot    int main         std  array lt int  3 gt  arr  1  2  3       std  string sArr   std  to string arr       std  cout  lt  lt   quot std  array quot   lt  lt  std  endl      std  cout  lt  lt   quot  ttest to string   quot   lt  lt  sArr  lt  lt  std  endl      std  cout  lt  lt   quot  ttest cout  lt  lt    quot   lt  lt  arr  lt  lt  std  endl      std  cout  lt  lt   quot  ttest string  lt  lt    quot   lt  lt   std  string    lt  lt  arr   lt  lt  std  endl           std  vector lt std  string gt  vec   quot a quot    quot b quot        std  string sVec   std  to string vec       std  cout  lt  lt   quot std  vector quot   lt  lt  std  endl      std  cout  lt  lt   quot  ttest to string   quot   lt  lt  sVec  lt  lt  std  endl      std  cout  lt  lt   quot  ttest cout  lt  lt    quot   lt  lt  vec  lt  lt  std  endl      std  cout  lt  lt   quot  ttest string  lt  lt    quot   lt  lt   std  string    lt  lt  vec   lt  lt  std  endl           std  tuple lt int  std  string gt  tup   std  make tuple 5   quot five quot        std  string sTup   std  to string tup       std  cout  lt  lt   quot std  tuple quot   lt  lt  std  endl      std  cout  lt  lt   quot  ttest to string   quot   lt  lt  sTup  lt  lt  std  endl      std  cout  lt  lt   quot  ttest cout  lt  lt    quot   lt  lt  tup  lt  lt  std  endl      std  cout  lt  lt   quot  ttest string  lt  lt    quot   lt  lt   std  string    lt  lt  tup   lt  lt  std  endl           std  vector lt std  tuple lt int  float gt  gt  vt  std  make tuple 1   1   std  make tuple 2   2        std  string sVt   std  to string vt       std  cout  lt  lt   quot std  vector lt std  tuple gt  quot   lt  lt  std  endl      std  cout  lt  lt   quot  ttest to string   quot   lt  lt  sVt  lt  lt  std  endl      std  cout  lt  lt   quot  ttest cout  lt  lt    quot   lt  lt  vt  lt  lt  std  endl      std  cout  lt  lt   quot  ttest string  lt  lt    quot   lt  lt   std  string    lt  lt  vt   lt  lt  std  endl           std  cout  lt  lt  std  endl           std  string s1    quot s1   quot    std  to string arr     quot    quot    std  to string vec     quot    quot    std  to string tup       std  cout  lt  lt  s1  lt  lt  std  endl           std  string s2   STR    lt  lt   quot s2   quot   lt  lt  arr  lt  lt   quot    quot   lt  lt  vec  lt  lt   quot    quot   lt  lt  tup      std  cout  lt  lt  s2  lt  lt  std  endl       return 0     Output std  array     test to string   1  2  3      test cout  lt  lt    1  2  3      test string  lt  lt    1  2  3  std  vector     test to string   a  b      test cout  lt  lt    a  b      test string  lt  lt    a  b  std  tuple     test to string   5  five      test cout  lt  lt    5  five      test string  lt  lt    5  five  std  vector lt std  tuple gt      test to string    1  0 100000    2  0 200000       test cout  lt  lt     1  0 100000    2  0 200000       test string  lt  lt     1  0 100000    2  0 200000    s1   1  2  3    a  b    5  five  s2   1  2  3    a  b    5  five

User · Answer

Using std  copy but without extra trailing separator  An alternative modified approach using std  copy  as originally used in  JoshuaKravtiz answer  but without including an additional trailing separator after the last element    include  lt algorithm gt   include  lt iostream gt   include  lt iterator gt   include  lt vector gt   template  lt typename T gt  void print contents const std  vector lt T gt  amp  v  const char   const separator              if  v empty                  std  copy v begin                      --v end                      std  ostream iterator lt T gt  std  cout  separator            std  cout  lt  lt  v back    lt  lt    n               example usage int main         std  vector lt int gt  v 1  2  3  4       print contents v            1 2 3 4      print contents v            1 2 3 4      v           print contents v               no std  cout     v    1       print contents v            1      return 0        Example usage applied to container of a custom POD type      includes and  print contents       as above      class Foo       int i      friend std  ostream amp  operator lt  lt  std  ostream amp  out  const Foo amp  obj   public      Foo const int i    i i         std  ostream amp  operator lt  lt  std  ostream amp  out  const Foo amp  obj        return out  lt  lt   foo    lt  lt  obj i      int main         std  vector lt Foo gt  v 1  2  3  4       print contents v            foo 1 foo 2 foo 3 foo 4      print contents v            foo 1 foo 2 foo 3 foo 4      v           print contents v               no std  cout     v    1       print contents v            foo 1      return 0

[c++] How do I print out the contents of a vector?

Examples related to c++

Examples related to vector

Examples related to output

Examples related to stdvector

Examples related to cout