What s the best way to do a backwards loop in C C C

Question

I need to move backwards through an array  so I have code like this   for  int i   myArray Length - 1  i  gt   0  i--           Do something     myArray i    42      Is there a better way of doing this   Update  I was hoping that maybe C  had some built-in mechanism for this like   foreachbackwards  int i in myArray           so easy     Update 2  There are better ways  Rune takes the prize with   for  int i   myArray Length  i--  gt  0                do something     or for  int i   myArray Length  i -- gt  0             do something     which looks even better in regular C  thanks to Twotymz    for  int i   lengthOfArray  i--                do something

User · Accepted Answer

While admittedly a bit obscure  I would say that the most typographically pleasing way of doing this is  for  int i   myArray Length  i -- gt  0            do something

User · Answer

For C    As mentioned by others  when possible  i e  when you only want each element at a time  it is strongly preferable to use iterators to both be explicit and avoid common pitfalls  Modern C   has a more concise syntax for that with auto  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec rend      it        std  cout lt  lt  it lt  lt  quot   quot      prints 4 3 2 1   You can also modify the value during the loop  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec rend      it         it    it   10      std  cout lt  lt  it lt  lt  quot   quot      leading to 14 13 12 11  being printed and  11  12  13  14  being in the std  vector afterwards  If you don t plan on modifying the value during the loop  you should make sure that you get an error when you try to do that by accident  similarly to how one might write for const auto amp  element   vec   This is possible like this  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec crbegin    it    vec crend      it       used crbegin   crend   here         it    it   10         so that this is a compile-time error     std  cout lt  lt  it lt  lt  quot   quot      The compiler error in this case for me is   tmp main cpp 20 9  error  assignment of read-only location    it std  reverse iterator lt   gnu cxx    normal iterator lt const int   std  vector lt int gt   gt   gt   operator          20        it    it   10                              Also note that you should make sure not to use different iterator types together  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec end      it       mixed rbegin   and end       std  cout lt  lt  it lt  lt  quot   quot      leads to the verbose error   tmp main cpp  In function    int main        tmp main cpp 19 33  error  no match for    operator       operand types are    std  reverse iterator lt   gnu cxx    normal iterator lt int   std  vector lt int gt   gt   gt     and    std  vector lt int gt   iterator     aka      gnu cxx    normal iterator lt int   std  vector lt int gt   gt          19   for  auto it   vec rbegin    it    vec end      it                                                                                                                                                               std  vector lt int gt   iterator  aka   gnu cxx    normal iterator lt int   std  vector lt int gt   gt                                        std  reverse iterator lt   gnu cxx    normal iterator lt int   std  vector lt int gt   gt   gt   If you have C-style arrays on the stack  you can do things like this  int vec      1 2 3 4   for  auto it   std  crbegin vec   it    std  crend vec     it        std  cout lt  lt  it lt  lt  quot   quot      If you really need the index  consider the following options   check the range  then work with signed values  e g    void loop reverse std  vector lt int gt  amp  vec        if  vec size    gt  static cast lt size t gt  std  numeric limits lt int gt   max               throw std  invalid argument  quot Input too large quot              const int sz   static cast lt int gt  vec size         for int i sz-1  i  gt   0  --i               do something with i           Work with unsigned values  be careful  and add comments  e g    void loop reverse2 std  vector lt int gt  amp  vec        for size t i vec size    i--  gt  0        reverse indices from N-1 to 0            do something with i           calculate the actual index separately  e g    void loop reverse3 std  vector lt int gt  amp  vec        for size t offset 0  offset  lt  vec size      offset            const size t i   vec size  -1-offset     reverse indices from N-1 to 0            do something with i

User · Answer

I d use the code in the original question  but if you really wanted to use foreach and have an integer index in C    foreach  int i in Enumerable Range 0  myArray Length  Reverse          myArray i    42

User · Answer

this is how I always do it for  i   n  --i  gt   0

User · Answer

I m going to try answering my own question here  but I don t really like this  either   for  int i   0  i  lt  myArray Length  i          int iBackwards   myArray Length - 1 - i     ugh     myArray iBackwards    666

User · Answer

I would always prefer clear code against  typographically pleasing  code  Thus  I would always use      for  int i   myArray Length - 1  i  gt   0  i--               Do something               You can consider it as the standard way to loop backwards  Just my two cents

User · Answer

In C   using Visual Studio 2005 or later  type  forr  and hit  TAB   TAB    This will expand to a for loop that goes backwards through a collection   It s so easy to get wrong  at least for me   that I thought putting this snippet in would be a good idea   That said  I like Array Reverse     Enumerable Reverse   and then iterate forwards better - they more clearly state intent

User · Answer

For C    As mentioned by others  when possible  i e  when you only want each element at a time  it is strongly preferable to use iterators to both be explicit and avoid common pitfalls  Modern C   has a more concise syntax for that with auto  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec rend      it        std  cout lt  lt  it lt  lt  quot   quot      prints 4 3 2 1   You can also modify the value during the loop  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec rend      it         it    it   10      std  cout lt  lt  it lt  lt  quot   quot      leading to 14 13 12 11  being printed and  11  12  13  14  being in the std  vector afterwards  If you don t plan on modifying the value during the loop  you should make sure that you get an error when you try to do that by accident  similarly to how one might write for const auto amp  element   vec   This is possible like this  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec crbegin    it    vec crend      it       used crbegin   crend   here         it    it   10         so that this is a compile-time error     std  cout lt  lt  it lt  lt  quot   quot      The compiler error in this case for me is   tmp main cpp 20 9  error  assignment of read-only location    it std  reverse iterator lt   gnu cxx    normal iterator lt const int   std  vector lt int gt   gt   gt   operator          20        it    it   10                              Also note that you should make sure not to use different iterator types together  std  vector lt int gt  vec    1 2 3 4   for  auto it   vec rbegin    it    vec end      it       mixed rbegin   and end       std  cout lt  lt  it lt  lt  quot   quot      leads to the verbose error   tmp main cpp  In function    int main        tmp main cpp 19 33  error  no match for    operator       operand types are    std  reverse iterator lt   gnu cxx    normal iterator lt int   std  vector lt int gt   gt   gt     and    std  vector lt int gt   iterator     aka      gnu cxx    normal iterator lt int   std  vector lt int gt   gt          19   for  auto it   vec rbegin    it    vec end      it                                                                                                                                                               std  vector lt int gt   iterator  aka   gnu cxx    normal iterator lt int   std  vector lt int gt   gt                                        std  reverse iterator lt   gnu cxx    normal iterator lt int   std  vector lt int gt   gt   gt   If you have C-style arrays on the stack  you can do things like this  int vec      1 2 3 4   for  auto it   std  crbegin vec   it    std  crend vec     it        std  cout lt  lt  it lt  lt  quot   quot      If you really need the index  consider the following options   check the range  then work with signed values  e g    void loop reverse std  vector lt int gt  amp  vec        if  vec size    gt  static cast lt size t gt  std  numeric limits lt int gt   max               throw std  invalid argument  quot Input too large quot              const int sz   static cast lt int gt  vec size         for int i sz-1  i  gt   0  --i               do something with i           Work with unsigned values  be careful  and add comments  e g    void loop reverse2 std  vector lt int gt  amp  vec        for size t i vec size    i--  gt  0        reverse indices from N-1 to 0            do something with i           calculate the actual index separately  e g    void loop reverse3 std  vector lt int gt  amp  vec        for size t offset 0  offset  lt  vec size      offset            const size t i   vec size  -1-offset     reverse indices from N-1 to 0            do something with i

User · Answer

In C   you basicially have the choice between iterating using iterators  or indices   Depending on whether you have a plain array  or a std  vector  you use different techniques    Using std  vector  Using iterators  C   allows you to do this using std  reverse iterator   for std  vector lt T gt   reverse iterator it   v rbegin    it    v rend      it           std  cout  lt  lt   it             Using indices  The unsigned integral type returned by std  vector lt T gt   size is not always std  size t  It can be greater or less  This is crucial for the loop to work    for std  vector lt int gt   size type i   someVector size   - 1       i     std  vector lt int gt   size type  -1  i--           std  cout  lt  lt  someVector i              It works  since unsigned integral types values are defined by means of modulo their count of bits  Thus  if you are setting -N  you end up at  2   BIT SIZE  -N  Using Arrays  Using iterators  We are using std  reverse iterator to do the iterating   for std  reverse iterator lt element type  gt  it a   sizeof a   sizeof  a   itb a        it    itb         it           std  cout  lt  lt   it              Using indices  We can safely use std  size t here  as opposed to above  since sizeof always returns std  size t by definition   for std  size t i    sizeof a   sizeof  a  - 1  i     std  size t  -1  i--          std  cout  lt  lt  a i              Avoiding pitfalls with sizeof applied to pointers  Actually the above way of determining the size of an array sucks  If a is actually a pointer instead of an array  which happens quite often  and beginners will confuse it   it will silently fail  A better way is to use the following  which will fail at compile time  if given a pointer   template lt typename T  std  size t N gt  char   amp  array size T  amp   N     N     It works by getting the size of the passed array first  and then declaring to return a reference to an array of type char of the same size  char is defined to have sizeof of  1  So the returned array will have a sizeof of  N   1  which is what we are looking for  with only compile time evaluation and zero runtime overhead   Instead of doing    sizeof a   sizeof  a    Change your code so that it now does   sizeof array size a

User · Answer

That s definitely the best way for any array whose length is a signed integral type   For arrays whose lengths are an unsigned integral type  e g  an std  vector in C     then you need to modify the end condition slightly   for size t i   myArray size   - 1  i     size t -1  i--         blah   If you just said i  gt   0  this is always true for an unsigned integer  so the loop will be an infinite loop

User · Answer

The best way to do that in C   is probably to use iterator  or better  range  adaptors  which will lazily transform the sequence as it is being traversed   Basically   vector lt value type gt  range  foreach value type v  range   reversed      cout  lt  lt  v    Displays the range  range   here  it s empty  but i m fairly sure you can add elements yourself  in reverse order  Of course simply iterating the range is not much use  but passing that new range to algorithms and stuff is pretty cool   This mechanism can also be used for much more powerful uses   range   transformed f    filtered p    reversed   Will lazily compute the range  range   where function  f  is applied to all elements  elements for which  p  is not true are removed  and finally the resulting range is reversed   Pipe syntax is the most readable IMO  given it s infix  The Boost Range library update pending review implements this  but it s pretty simple to do it yourself also  It s even more cool with a lambda DSEL to generate the function f and the predicate p in-line

User · Answer

In C   you basicially have the choice between iterating using iterators  or indices   Depending on whether you have a plain array  or a std  vector  you use different techniques    Using std  vector  Using iterators  C   allows you to do this using std  reverse iterator   for std  vector lt T gt   reverse iterator it   v rbegin    it    v rend      it           std  cout  lt  lt   it             Using indices  The unsigned integral type returned by std  vector lt T gt   size is not always std  size t  It can be greater or less  This is crucial for the loop to work    for std  vector lt int gt   size type i   someVector size   - 1       i     std  vector lt int gt   size type  -1  i--           std  cout  lt  lt  someVector i              It works  since unsigned integral types values are defined by means of modulo their count of bits  Thus  if you are setting -N  you end up at  2   BIT SIZE  -N  Using Arrays  Using iterators  We are using std  reverse iterator to do the iterating   for std  reverse iterator lt element type  gt  it a   sizeof a   sizeof  a   itb a        it    itb         it           std  cout  lt  lt   it              Using indices  We can safely use std  size t here  as opposed to above  since sizeof always returns std  size t by definition   for std  size t i    sizeof a   sizeof  a  - 1  i     std  size t  -1  i--          std  cout  lt  lt  a i              Avoiding pitfalls with sizeof applied to pointers  Actually the above way of determining the size of an array sucks  If a is actually a pointer instead of an array  which happens quite often  and beginners will confuse it   it will silently fail  A better way is to use the following  which will fail at compile time  if given a pointer   template lt typename T  std  size t N gt  char   amp  array size T  amp   N     N     It works by getting the size of the passed array first  and then declaring to return a reference to an array of type char of the same size  char is defined to have sizeof of  1  So the returned array will have a sizeof of  N   1  which is what we are looking for  with only compile time evaluation and zero runtime overhead   Instead of doing    sizeof a   sizeof  a    Change your code so that it now does   sizeof array size a

User · Answer

The best way to do that in C   is probably to use iterator  or better  range  adaptors  which will lazily transform the sequence as it is being traversed   Basically   vector lt value type gt  range  foreach value type v  range   reversed      cout  lt  lt  v    Displays the range  range   here  it s empty  but i m fairly sure you can add elements yourself  in reverse order  Of course simply iterating the range is not much use  but passing that new range to algorithms and stuff is pretty cool   This mechanism can also be used for much more powerful uses   range   transformed f    filtered p    reversed   Will lazily compute the range  range   where function  f  is applied to all elements  elements for which  p  is not true are removed  and finally the resulting range is reversed   Pipe syntax is the most readable IMO  given it s infix  The Boost Range library update pending review implements this  but it s pretty simple to do it yourself also  It s even more cool with a lambda DSEL to generate the function f and the predicate p in-line

User · Answer

In C  using Linq   foreach var item in myArray Reverse             do something

User · Answer

In C   you basicially have the choice between iterating using iterators  or indices   Depending on whether you have a plain array  or a std  vector  you use different techniques    Using std  vector  Using iterators  C   allows you to do this using std  reverse iterator   for std  vector lt T gt   reverse iterator it   v rbegin    it    v rend      it           std  cout  lt  lt   it             Using indices  The unsigned integral type returned by std  vector lt T gt   size is not always std  size t  It can be greater or less  This is crucial for the loop to work    for std  vector lt int gt   size type i   someVector size   - 1       i     std  vector lt int gt   size type  -1  i--           std  cout  lt  lt  someVector i              It works  since unsigned integral types values are defined by means of modulo their count of bits  Thus  if you are setting -N  you end up at  2   BIT SIZE  -N  Using Arrays  Using iterators  We are using std  reverse iterator to do the iterating   for std  reverse iterator lt element type  gt  it a   sizeof a   sizeof  a   itb a        it    itb         it           std  cout  lt  lt   it              Using indices  We can safely use std  size t here  as opposed to above  since sizeof always returns std  size t by definition   for std  size t i    sizeof a   sizeof  a  - 1  i     std  size t  -1  i--          std  cout  lt  lt  a i              Avoiding pitfalls with sizeof applied to pointers  Actually the above way of determining the size of an array sucks  If a is actually a pointer instead of an array  which happens quite often  and beginners will confuse it   it will silently fail  A better way is to use the following  which will fail at compile time  if given a pointer   template lt typename T  std  size t N gt  char   amp  array size T  amp   N     N     It works by getting the size of the passed array first  and then declaring to return a reference to an array of type char of the same size  char is defined to have sizeof of  1  So the returned array will have a sizeof of  N   1  which is what we are looking for  with only compile time evaluation and zero runtime overhead   Instead of doing    sizeof a   sizeof  a    Change your code so that it now does   sizeof array size a

User · Answer

Looks good to me  If the indexer was unsigned  uint etc   you might have to take that into account  Call me lazy  but in that  unsigned  case  I might just use a counter-variable   uint pos   arr Length  for uint i   0  i  lt  arr Length   i          arr --pos    42       actually  even here you d need to be careful of cases like arr Length   uint MaxValue    maybe a    somewhere    of course  that is a very unlikely case

User · Answer

That s definitely the best way for any array whose length is a signed integral type   For arrays whose lengths are an unsigned integral type  e g  an std  vector in C     then you need to modify the end condition slightly   for size t i   myArray size   - 1  i     size t -1  i--         blah   If you just said i  gt   0  this is always true for an unsigned integer  so the loop will be an infinite loop

User · Answer

NOTE  This post ended up being far more detailed and therefore off topic  I apologize   That being said my peers read it and believe it is valuable  somewhere   This thread is not the place  I would appreciate your  feedback on where this should go  I am new to the site      Anyway this is the C  version in  NET 3 5 which is amazing in that it works on any collection type using the defined semantics  This is a default measure  reuse   not performance or CPU cycle minimization in most common dev scenario although that never seems to be what happens in the real world  premature optimization        Extension method working over any collection type and taking an action delegate expecting a single value of the type  all executed over each item in reverse     Requres 3 5   public static void PerformOverReversed lt T gt  this IEnumerable lt T gt  sequenceToReverse  Action lt T gt  doForEachReversed                    foreach  var contextItem in sequenceToReverse Reverse                  doForEachReversed contextItem             Older  NET versions or do you want to understand Linq internals better  Read on   Or not    ASSUMPTION  In the  NET type system the Array type inherits from the IEnumerable interface  not the generic IEnumerable only IEnumerable    This is all you need to iterate from beginning to end  however you want to move in the opposite direction  As IEnumerable works on Array of type  object  any type is valid    CRITICAL MEASURE  We assume if you can process any sequence in reverse order that is  better  then only being able to do it on integers    Solution a for  NET CLR 2 0-3 0   Description  We will accept any IEnumerable implementing instance with the mandate that each instance it contains is of the same type  So if we recieve an array the entire array contains instances of type X  If any other instances are of a type   X an exception is thrown   A singleton service   public class ReverserService               private ReverserService                 lt summary gt          Most importantly uses yield command for efficiency          lt  summary gt           lt param name  enumerableInstance  gt  lt  param gt           lt returns gt  lt  returns gt      public static IEnumerable ToReveresed IEnumerable enumerableInstance                if  enumerableInstance    null                        throw new ArgumentNullException  enumerableInstance                          First we need to move forwarad and create a temp            copy of a type that allows us to move backwards            We can use ArrayList for this as the concrete            type          IList reversedEnumerable   new ArrayList            IEnumerator tempEnumerator   enumerableInstance GetEnumerator             while  tempEnumerator MoveNext                          reversedEnumerable Add tempEnumerator Current                         Now we do the standard reverse over this using yield to return            the result            NOTE  This is an immutable result by design  That is             a design goal for this simple question as well as most other set related             requirements  which is why Linq results are immutable for example            In fact this is foundational code to understand Linq          for  var i   reversedEnumerable Count - 1  i  gt   0  i--                        yield return reversedEnumerable i                        public static class ExtensionMethods          public static IEnumerable ToReveresed this IEnumerable enumerableInstance                    return ReverserService ToReveresed enumerableInstance                 TestFixture      public class Testing123                 lt summary gt           NET 1 1 CLR          lt  summary gt       Test      public void Tester fornet 1 dot 1                 const int initialSize   1000              Create the baseline data         int   myArray   new int initialSize            for  var i   0  i  lt  initialSize  i                          myArray i    i   1                     IEnumerable  revered   ReverserService ToReveresed myArray            Assert IsTrue TestAndGetResult  revered  Equals 1000                Test      public void tester why this is good                  ArrayList names   new ArrayList            names Add  Jim            names Add  Bob            names Add  Eric            names Add  Sam             IEnumerable  revered   ReverserService ToReveresed names            Assert IsTrue TestAndGetResult  revered  Equals  Sam                   Test      public void tester extension method                   Extension Methods No Linq  Linq does this for you as I will show          var enumerableOfInt   Enumerable Range 1  1000               Use Extension Method - which simply wraps older clr code         IEnumerable  revered   enumerableOfInt ToReveresed             Assert IsTrue TestAndGetResult  revered  Equals 1000                   Test      public void tester linq 3 dot 5 clr                     Extension Methods No Linq  Linq does this for you as I will show          IEnumerable enumerableOfInt   Enumerable Range 1  1000               Reverse is Linq  which is are extension methods off IEnumerable lt T gt             Note you must case IEnumerable  non generic  using OfType or Cast         IEnumerable  revered   enumerableOfInt Cast lt int gt    Reverse             Assert IsTrue TestAndGetResult  revered  Equals 1000                    Test      public void tester final and recommended colution                  var enumerableOfInt   Enumerable Range 1  1000           enumerableOfInt PerformOverReversed i   gt  Debug WriteLine i                  private static object TestAndGetResult IEnumerable enumerableIn                  IEnumerable x   ReverserService ToReveresed names            Assert IsTrue enumerableIn    null           IEnumerator  test   enumerableIn GetEnumerator                Move to first         Assert IsTrue  test MoveNext             return  test Current

User · Answer

Looks good to me  If the indexer was unsigned  uint etc   you might have to take that into account  Call me lazy  but in that  unsigned  case  I might just use a counter-variable   uint pos   arr Length  for uint i   0  i  lt  arr Length   i          arr --pos    42       actually  even here you d need to be careful of cases like arr Length   uint MaxValue    maybe a    somewhere    of course  that is a very unlikely case

User · Answer

In C I like to do this     int i   myArray Length  while  i--      myArray i    42       C  example added by MusiGenesis    int i   myArray Length  while  i--  gt  0        myArray i    42

User · Answer

this is how I always do it for  i   n  --i  gt   0

User · Answer

In C   you basicially have the choice between iterating using iterators  or indices   Depending on whether you have a plain array  or a std  vector  you use different techniques    Using std  vector  Using iterators  C   allows you to do this using std  reverse iterator   for std  vector lt T gt   reverse iterator it   v rbegin    it    v rend      it           std  cout  lt  lt   it             Using indices  The unsigned integral type returned by std  vector lt T gt   size is not always std  size t  It can be greater or less  This is crucial for the loop to work    for std  vector lt int gt   size type i   someVector size   - 1       i     std  vector lt int gt   size type  -1  i--           std  cout  lt  lt  someVector i              It works  since unsigned integral types values are defined by means of modulo their count of bits  Thus  if you are setting -N  you end up at  2   BIT SIZE  -N  Using Arrays  Using iterators  We are using std  reverse iterator to do the iterating   for std  reverse iterator lt element type  gt  it a   sizeof a   sizeof  a   itb a        it    itb         it           std  cout  lt  lt   it              Using indices  We can safely use std  size t here  as opposed to above  since sizeof always returns std  size t by definition   for std  size t i    sizeof a   sizeof  a  - 1  i     std  size t  -1  i--          std  cout  lt  lt  a i              Avoiding pitfalls with sizeof applied to pointers  Actually the above way of determining the size of an array sucks  If a is actually a pointer instead of an array  which happens quite often  and beginners will confuse it   it will silently fail  A better way is to use the following  which will fail at compile time  if given a pointer   template lt typename T  std  size t N gt  char   amp  array size T  amp   N     N     It works by getting the size of the passed array first  and then declaring to return a reference to an array of type char of the same size  char is defined to have sizeof of  1  So the returned array will have a sizeof of  N   1  which is what we are looking for  with only compile time evaluation and zero runtime overhead   Instead of doing    sizeof a   sizeof  a    Change your code so that it now does   sizeof array size a

User · Answer

this is how I always do it for  i   n  --i  gt   0

User · Answer

The best way to do that in C   is probably to use iterator  or better  range  adaptors  which will lazily transform the sequence as it is being traversed   Basically   vector lt value type gt  range  foreach value type v  range   reversed      cout  lt  lt  v    Displays the range  range   here  it s empty  but i m fairly sure you can add elements yourself  in reverse order  Of course simply iterating the range is not much use  but passing that new range to algorithms and stuff is pretty cool   This mechanism can also be used for much more powerful uses   range   transformed f    filtered p    reversed   Will lazily compute the range  range   where function  f  is applied to all elements  elements for which  p  is not true are removed  and finally the resulting range is reversed   Pipe syntax is the most readable IMO  given it s infix  The Boost Range library update pending review implements this  but it s pretty simple to do it yourself also  It s even more cool with a lambda DSEL to generate the function f and the predicate p in-line

User · Answer

this is how I always do it for  i   n  --i  gt   0

User · Answer

I would always prefer clear code against  typographically pleasing  code  Thus  I would always use      for  int i   myArray Length - 1  i  gt   0  i--               Do something               You can consider it as the standard way to loop backwards  Just my two cents

User · Answer

I m going to try answering my own question here  but I don t really like this  either   for  int i   0  i  lt  myArray Length  i          int iBackwards   myArray Length - 1 - i     ugh     myArray iBackwards    666

User · Answer

In C  using Linq   foreach var item in myArray Reverse             do something

User · Answer

That s definitely the best way for any array whose length is a signed integral type   For arrays whose lengths are an unsigned integral type  e g  an std  vector in C     then you need to modify the end condition slightly   for size t i   myArray size   - 1  i     size t -1  i--         blah   If you just said i  gt   0  this is always true for an unsigned integer  so the loop will be an infinite loop

User · Answer

In C   using Visual Studio 2005 or later  type  forr  and hit  TAB   TAB    This will expand to a for loop that goes backwards through a collection   It s so easy to get wrong  at least for me   that I thought putting this snippet in would be a good idea   That said  I like Array Reverse     Enumerable Reverse   and then iterate forwards better - they more clearly state intent

User · Answer

Looks good to me  If the indexer was unsigned  uint etc   you might have to take that into account  Call me lazy  but in that  unsigned  case  I might just use a counter-variable   uint pos   arr Length  for uint i   0  i  lt  arr Length   i          arr --pos    42       actually  even here you d need to be careful of cases like arr Length   uint MaxValue    maybe a    somewhere    of course  that is a very unlikely case

User · Answer

In C I like to do this     int i   myArray Length  while  i--      myArray i    42       C  example added by MusiGenesis    int i   myArray Length  while  i--  gt  0        myArray i    42

User · Answer

I prefer a while loop  It s more clear to me than decrementing i in the condition of a for loop  int i   arrayLength  while i        i--        do something with array i

User · Answer

In C  using Linq   foreach var item in myArray Reverse             do something

User · Answer

NOTE  This post ended up being far more detailed and therefore off topic  I apologize   That being said my peers read it and believe it is valuable  somewhere   This thread is not the place  I would appreciate your  feedback on where this should go  I am new to the site      Anyway this is the C  version in  NET 3 5 which is amazing in that it works on any collection type using the defined semantics  This is a default measure  reuse   not performance or CPU cycle minimization in most common dev scenario although that never seems to be what happens in the real world  premature optimization        Extension method working over any collection type and taking an action delegate expecting a single value of the type  all executed over each item in reverse     Requres 3 5   public static void PerformOverReversed lt T gt  this IEnumerable lt T gt  sequenceToReverse  Action lt T gt  doForEachReversed                    foreach  var contextItem in sequenceToReverse Reverse                  doForEachReversed contextItem             Older  NET versions or do you want to understand Linq internals better  Read on   Or not    ASSUMPTION  In the  NET type system the Array type inherits from the IEnumerable interface  not the generic IEnumerable only IEnumerable    This is all you need to iterate from beginning to end  however you want to move in the opposite direction  As IEnumerable works on Array of type  object  any type is valid    CRITICAL MEASURE  We assume if you can process any sequence in reverse order that is  better  then only being able to do it on integers    Solution a for  NET CLR 2 0-3 0   Description  We will accept any IEnumerable implementing instance with the mandate that each instance it contains is of the same type  So if we recieve an array the entire array contains instances of type X  If any other instances are of a type   X an exception is thrown   A singleton service   public class ReverserService               private ReverserService                 lt summary gt          Most importantly uses yield command for efficiency          lt  summary gt           lt param name  enumerableInstance  gt  lt  param gt           lt returns gt  lt  returns gt      public static IEnumerable ToReveresed IEnumerable enumerableInstance                if  enumerableInstance    null                        throw new ArgumentNullException  enumerableInstance                          First we need to move forwarad and create a temp            copy of a type that allows us to move backwards            We can use ArrayList for this as the concrete            type          IList reversedEnumerable   new ArrayList            IEnumerator tempEnumerator   enumerableInstance GetEnumerator             while  tempEnumerator MoveNext                          reversedEnumerable Add tempEnumerator Current                         Now we do the standard reverse over this using yield to return            the result            NOTE  This is an immutable result by design  That is             a design goal for this simple question as well as most other set related             requirements  which is why Linq results are immutable for example            In fact this is foundational code to understand Linq          for  var i   reversedEnumerable Count - 1  i  gt   0  i--                        yield return reversedEnumerable i                        public static class ExtensionMethods          public static IEnumerable ToReveresed this IEnumerable enumerableInstance                    return ReverserService ToReveresed enumerableInstance                 TestFixture      public class Testing123                 lt summary gt           NET 1 1 CLR          lt  summary gt       Test      public void Tester fornet 1 dot 1                 const int initialSize   1000              Create the baseline data         int   myArray   new int initialSize            for  var i   0  i  lt  initialSize  i                          myArray i    i   1                     IEnumerable  revered   ReverserService ToReveresed myArray            Assert IsTrue TestAndGetResult  revered  Equals 1000                Test      public void tester why this is good                  ArrayList names   new ArrayList            names Add  Jim            names Add  Bob            names Add  Eric            names Add  Sam             IEnumerable  revered   ReverserService ToReveresed names            Assert IsTrue TestAndGetResult  revered  Equals  Sam                   Test      public void tester extension method                   Extension Methods No Linq  Linq does this for you as I will show          var enumerableOfInt   Enumerable Range 1  1000               Use Extension Method - which simply wraps older clr code         IEnumerable  revered   enumerableOfInt ToReveresed             Assert IsTrue TestAndGetResult  revered  Equals 1000                   Test      public void tester linq 3 dot 5 clr                     Extension Methods No Linq  Linq does this for you as I will show          IEnumerable enumerableOfInt   Enumerable Range 1  1000               Reverse is Linq  which is are extension methods off IEnumerable lt T gt             Note you must case IEnumerable  non generic  using OfType or Cast         IEnumerable  revered   enumerableOfInt Cast lt int gt    Reverse             Assert IsTrue TestAndGetResult  revered  Equals 1000                    Test      public void tester final and recommended colution                  var enumerableOfInt   Enumerable Range 1  1000           enumerableOfInt PerformOverReversed i   gt  Debug WriteLine i                  private static object TestAndGetResult IEnumerable enumerableIn                  IEnumerable x   ReverserService ToReveresed names            Assert IsTrue enumerableIn    null           IEnumerator  test   enumerableIn GetEnumerator                Move to first         Assert IsTrue  test MoveNext             return  test Current

User · Answer

I d use the code in the original question  but if you really wanted to use foreach and have an integer index in C    foreach  int i in Enumerable Range 0  myArray Length  Reverse          myArray i    42

User · Answer

I d use the code in the original question  but if you really wanted to use foreach and have an integer index in C    foreach  int i in Enumerable Range 0  myArray Length  Reverse          myArray i    42

User · Answer

In C I like to do this     int i   myArray Length  while  i--      myArray i    42       C  example added by MusiGenesis    int i   myArray Length  while  i--  gt  0        myArray i    42

User · Answer

In C  using Linq   foreach var item in myArray Reverse             do something

User · Answer

NOTE  This post ended up being far more detailed and therefore off topic  I apologize   That being said my peers read it and believe it is valuable  somewhere   This thread is not the place  I would appreciate your  feedback on where this should go  I am new to the site      Anyway this is the C  version in  NET 3 5 which is amazing in that it works on any collection type using the defined semantics  This is a default measure  reuse   not performance or CPU cycle minimization in most common dev scenario although that never seems to be what happens in the real world  premature optimization        Extension method working over any collection type and taking an action delegate expecting a single value of the type  all executed over each item in reverse     Requres 3 5   public static void PerformOverReversed lt T gt  this IEnumerable lt T gt  sequenceToReverse  Action lt T gt  doForEachReversed                    foreach  var contextItem in sequenceToReverse Reverse                  doForEachReversed contextItem             Older  NET versions or do you want to understand Linq internals better  Read on   Or not    ASSUMPTION  In the  NET type system the Array type inherits from the IEnumerable interface  not the generic IEnumerable only IEnumerable    This is all you need to iterate from beginning to end  however you want to move in the opposite direction  As IEnumerable works on Array of type  object  any type is valid    CRITICAL MEASURE  We assume if you can process any sequence in reverse order that is  better  then only being able to do it on integers    Solution a for  NET CLR 2 0-3 0   Description  We will accept any IEnumerable implementing instance with the mandate that each instance it contains is of the same type  So if we recieve an array the entire array contains instances of type X  If any other instances are of a type   X an exception is thrown   A singleton service   public class ReverserService               private ReverserService                 lt summary gt          Most importantly uses yield command for efficiency          lt  summary gt           lt param name  enumerableInstance  gt  lt  param gt           lt returns gt  lt  returns gt      public static IEnumerable ToReveresed IEnumerable enumerableInstance                if  enumerableInstance    null                        throw new ArgumentNullException  enumerableInstance                          First we need to move forwarad and create a temp            copy of a type that allows us to move backwards            We can use ArrayList for this as the concrete            type          IList reversedEnumerable   new ArrayList            IEnumerator tempEnumerator   enumerableInstance GetEnumerator             while  tempEnumerator MoveNext                          reversedEnumerable Add tempEnumerator Current                         Now we do the standard reverse over this using yield to return            the result            NOTE  This is an immutable result by design  That is             a design goal for this simple question as well as most other set related             requirements  which is why Linq results are immutable for example            In fact this is foundational code to understand Linq          for  var i   reversedEnumerable Count - 1  i  gt   0  i--                        yield return reversedEnumerable i                        public static class ExtensionMethods          public static IEnumerable ToReveresed this IEnumerable enumerableInstance                    return ReverserService ToReveresed enumerableInstance                 TestFixture      public class Testing123                 lt summary gt           NET 1 1 CLR          lt  summary gt       Test      public void Tester fornet 1 dot 1                 const int initialSize   1000              Create the baseline data         int   myArray   new int initialSize            for  var i   0  i  lt  initialSize  i                          myArray i    i   1                     IEnumerable  revered   ReverserService ToReveresed myArray            Assert IsTrue TestAndGetResult  revered  Equals 1000                Test      public void tester why this is good                  ArrayList names   new ArrayList            names Add  Jim            names Add  Bob            names Add  Eric            names Add  Sam             IEnumerable  revered   ReverserService ToReveresed names            Assert IsTrue TestAndGetResult  revered  Equals  Sam                   Test      public void tester extension method                   Extension Methods No Linq  Linq does this for you as I will show          var enumerableOfInt   Enumerable Range 1  1000               Use Extension Method - which simply wraps older clr code         IEnumerable  revered   enumerableOfInt ToReveresed             Assert IsTrue TestAndGetResult  revered  Equals 1000                   Test      public void tester linq 3 dot 5 clr                     Extension Methods No Linq  Linq does this for you as I will show          IEnumerable enumerableOfInt   Enumerable Range 1  1000               Reverse is Linq  which is are extension methods off IEnumerable lt T gt             Note you must case IEnumerable  non generic  using OfType or Cast         IEnumerable  revered   enumerableOfInt Cast lt int gt    Reverse             Assert IsTrue TestAndGetResult  revered  Equals 1000                    Test      public void tester final and recommended colution                  var enumerableOfInt   Enumerable Range 1  1000           enumerableOfInt PerformOverReversed i   gt  Debug WriteLine i                  private static object TestAndGetResult IEnumerable enumerableIn                  IEnumerable x   ReverserService ToReveresed names            Assert IsTrue enumerableIn    null           IEnumerator  test   enumerableIn GetEnumerator                Move to first         Assert IsTrue  test MoveNext             return  test Current

User · Answer

That s definitely the best way for any array whose length is a signed integral type   For arrays whose lengths are an unsigned integral type  e g  an std  vector in C     then you need to modify the end condition slightly   for size t i   myArray size   - 1  i     size t -1  i--         blah   If you just said i  gt   0  this is always true for an unsigned integer  so the loop will be an infinite loop

User · Answer

I d use the code in the original question  but if you really wanted to use foreach and have an integer index in C    foreach  int i in Enumerable Range 0  myArray Length  Reverse          myArray i    42

User · Answer

I m going to try answering my own question here  but I don t really like this  either   for  int i   0  i  lt  myArray Length  i          int iBackwards   myArray Length - 1 - i     ugh     myArray iBackwards    666

User · Answer

In C I like to do this     int i   myArray Length  while  i--      myArray i    42       C  example added by MusiGenesis    int i   myArray Length  while  i--  gt  0        myArray i    42

User · Answer

Looks good to me  If the indexer was unsigned  uint etc   you might have to take that into account  Call me lazy  but in that  unsigned  case  I might just use a counter-variable   uint pos   arr Length  for uint i   0  i  lt  arr Length   i          arr --pos    42       actually  even here you d need to be careful of cases like arr Length   uint MaxValue    maybe a    somewhere    of course  that is a very unlikely case

User · Answer

In C   using Visual Studio 2005 or later  type  forr  and hit  TAB   TAB    This will expand to a for loop that goes backwards through a collection   It s so easy to get wrong  at least for me   that I thought putting this snippet in would be a good idea   That said  I like Array Reverse     Enumerable Reverse   and then iterate forwards better - they more clearly state intent

User · Answer

The best way to do that in C   is probably to use iterator  or better  range  adaptors  which will lazily transform the sequence as it is being traversed   Basically   vector lt value type gt  range  foreach value type v  range   reversed      cout  lt  lt  v    Displays the range  range   here  it s empty  but i m fairly sure you can add elements yourself  in reverse order  Of course simply iterating the range is not much use  but passing that new range to algorithms and stuff is pretty cool   This mechanism can also be used for much more powerful uses   range   transformed f    filtered p    reversed   Will lazily compute the range  range   where function  f  is applied to all elements  elements for which  p  is not true are removed  and finally the resulting range is reversed   Pipe syntax is the most readable IMO  given it s infix  The Boost Range library update pending review implements this  but it s pretty simple to do it yourself also  It s even more cool with a lambda DSEL to generate the function f and the predicate p in-line

User · Answer

I m going to try answering my own question here  but I don t really like this  either   for  int i   0  i  lt  myArray Length  i          int iBackwards   myArray Length - 1 - i     ugh     myArray iBackwards    666

User · Answer

NOTE  This post ended up being far more detailed and therefore off topic  I apologize   That being said my peers read it and believe it is valuable  somewhere   This thread is not the place  I would appreciate your  feedback on where this should go  I am new to the site      Anyway this is the C  version in  NET 3 5 which is amazing in that it works on any collection type using the defined semantics  This is a default measure  reuse   not performance or CPU cycle minimization in most common dev scenario although that never seems to be what happens in the real world  premature optimization        Extension method working over any collection type and taking an action delegate expecting a single value of the type  all executed over each item in reverse     Requres 3 5   public static void PerformOverReversed lt T gt  this IEnumerable lt T gt  sequenceToReverse  Action lt T gt  doForEachReversed                    foreach  var contextItem in sequenceToReverse Reverse                  doForEachReversed contextItem             Older  NET versions or do you want to understand Linq internals better  Read on   Or not    ASSUMPTION  In the  NET type system the Array type inherits from the IEnumerable interface  not the generic IEnumerable only IEnumerable    This is all you need to iterate from beginning to end  however you want to move in the opposite direction  As IEnumerable works on Array of type  object  any type is valid    CRITICAL MEASURE  We assume if you can process any sequence in reverse order that is  better  then only being able to do it on integers    Solution a for  NET CLR 2 0-3 0   Description  We will accept any IEnumerable implementing instance with the mandate that each instance it contains is of the same type  So if we recieve an array the entire array contains instances of type X  If any other instances are of a type   X an exception is thrown   A singleton service   public class ReverserService               private ReverserService                 lt summary gt          Most importantly uses yield command for efficiency          lt  summary gt           lt param name  enumerableInstance  gt  lt  param gt           lt returns gt  lt  returns gt      public static IEnumerable ToReveresed IEnumerable enumerableInstance                if  enumerableInstance    null                        throw new ArgumentNullException  enumerableInstance                          First we need to move forwarad and create a temp            copy of a type that allows us to move backwards            We can use ArrayList for this as the concrete            type          IList reversedEnumerable   new ArrayList            IEnumerator tempEnumerator   enumerableInstance GetEnumerator             while  tempEnumerator MoveNext                          reversedEnumerable Add tempEnumerator Current                         Now we do the standard reverse over this using yield to return            the result            NOTE  This is an immutable result by design  That is             a design goal for this simple question as well as most other set related             requirements  which is why Linq results are immutable for example            In fact this is foundational code to understand Linq          for  var i   reversedEnumerable Count - 1  i  gt   0  i--                        yield return reversedEnumerable i                        public static class ExtensionMethods          public static IEnumerable ToReveresed this IEnumerable enumerableInstance                    return ReverserService ToReveresed enumerableInstance                 TestFixture      public class Testing123                 lt summary gt           NET 1 1 CLR          lt  summary gt       Test      public void Tester fornet 1 dot 1                 const int initialSize   1000              Create the baseline data         int   myArray   new int initialSize            for  var i   0  i  lt  initialSize  i                          myArray i    i   1                     IEnumerable  revered   ReverserService ToReveresed myArray            Assert IsTrue TestAndGetResult  revered  Equals 1000                Test      public void tester why this is good                  ArrayList names   new ArrayList            names Add  Jim            names Add  Bob            names Add  Eric            names Add  Sam             IEnumerable  revered   ReverserService ToReveresed names            Assert IsTrue TestAndGetResult  revered  Equals  Sam                   Test      public void tester extension method                   Extension Methods No Linq  Linq does this for you as I will show          var enumerableOfInt   Enumerable Range 1  1000               Use Extension Method - which simply wraps older clr code         IEnumerable  revered   enumerableOfInt ToReveresed             Assert IsTrue TestAndGetResult  revered  Equals 1000                   Test      public void tester linq 3 dot 5 clr                     Extension Methods No Linq  Linq does this for you as I will show          IEnumerable enumerableOfInt   Enumerable Range 1  1000               Reverse is Linq  which is are extension methods off IEnumerable lt T gt             Note you must case IEnumerable  non generic  using OfType or Cast         IEnumerable  revered   enumerableOfInt Cast lt int gt    Reverse             Assert IsTrue TestAndGetResult  revered  Equals 1000                    Test      public void tester final and recommended colution                  var enumerableOfInt   Enumerable Range 1  1000           enumerableOfInt PerformOverReversed i   gt  Debug WriteLine i                  private static object TestAndGetResult IEnumerable enumerableIn                  IEnumerable x   ReverserService ToReveresed names            Assert IsTrue enumerableIn    null           IEnumerator  test   enumerableIn GetEnumerator                Move to first         Assert IsTrue  test MoveNext             return  test Current

User · Answer

I prefer a while loop  It s more clear to me than decrementing i in the condition of a for loop  int i   arrayLength  while i        i--        do something with array i

User · Answer

In C   using Visual Studio 2005 or later  type  forr  and hit  TAB   TAB    This will expand to a for loop that goes backwards through a collection   It s so easy to get wrong  at least for me   that I thought putting this snippet in would be a good idea   That said  I like Array Reverse     Enumerable Reverse   and then iterate forwards better - they more clearly state intent

[c#] What's the best way to do a backwards loop in C/C#/C++?

Examples related to c#

Examples related to c++

Examples related to c