Thread: Broken for loop in c++

^yes that's what the code looks like in my compiler. Sorry it got jacked up in translation.

By "size member" if you mean what "requests.size()" would return, it returns an int, not an unsigned int.

Vector<ValueType>

the header for the Vector type

Code:

/*
 * File: vector.h
 * --------------
 * This file exports the <code>Vector</code> class, which provides an
 * efficient, safe, convenient replacement for the array type in C++.
 */

#ifndef _vector_h
#define _vector_h

#include <iterator>
#include <iostream>
#include <sstream>
#include <string>
#include "foreach.h"
#include "strlib.h"

/*
 * Class: Vector<ValueType>
 * ------------------------
 * This class stores an ordered list of values similar to an array.
 * It supports traditional array selection using square brackets, but
 * also supports inserting and deleting elements.  It is similar in
 * function to the STL <code>vector</code> type, but is simpler both
 * to use and to implement.
 */

template <typename ValueType>
class Vector {

public:

/*
 * Constructor: Vector
 * Usage: Vector<ValueType> vec;
 *        Vector<ValueType> vec(n, value);
 * ---------------------------------------
 * Initializes a new vector.  The default constructor creates an
 * empty vector.  The second form creates an array with <code>n</code>
 * elements, each of which is initialized to <code>value</code>;
 * if <code>value</code> is missing, the elements are initialized
 * to the default value for the type.
 */

   Vector();
   explicit Vector(int n, ValueType value = ValueType());

/*
 * Destructor: ~Vector
 * -------------------
 * Frees any heap storage allocated by this vector.
 */

   virtual ~Vector();

/*
 * Method: size
 * Usage: int nElems = vec.size();
 * -------------------------------
 * Returns the number of elements in this vector.
 */

   int size() const;

/*
 * Method: isEmpty
 * Usage: if (vec.isEmpty()) ...
 * -----------------------------
 * Returns <code>true</code> if this vector contains no elements.
 */

   bool isEmpty() const;

/*
 * Method: clear
 * Usage: vec.clear();
 * -------------------
 * Removes all elements from this vector.
 */

   void clear();

/*
 * Method: get
 * Usage: ValueType val = vec.get(index);
 * --------------------------------------
 * Returns the element at the specified index in this vector.  This
 * method signals an error if the index is not in the array range.
 */

   const ValueType & get(int index) const;

/*
 * Method: set
 * Usage: vec.set(index, value);
 * -----------------------------
 * Replaces the element at the specified index in this vector with
 * a new value.  The previous value at that index is overwritten.
 * This method signals an error if the index is not in the array range.
 */

   void set(int index, const ValueType & value);

/*
 * Method: insert
 * Usage: vec.insert(0, value);
 * ----------------------------
 * Inserts the element into this vector before the specified index.
 * All subsequent elements are shifted one position to the right.  This
 * method signals an error if the index is outside the range from 0
 * up to and including the length of the vector.
 */

   void insert(int index, ValueType value);

/*
 * Method: remove
 * Usage: vec.remove(index);
 * -------------------------
 * Removes the element at the specified index from this vector.
 * All subsequent elements are shifted one position to the left.  This
 * method signals an error if the index is outside the array range.
 */

   void remove(int index);

/*
 * Method: add
 * Usage: vec.add(value);
 * ----------------------
 * Adds a new value to the end of this vector.  To ensure compatibility
 * with the <code>vector</code> class in the Standard Template Library,
 * this method is also called <code>push_back</code>.
 */

   void add(ValueType value);
   void push_back(ValueType value);

/*
 * Operator: []
 * Usage: vec[index]
 * -----------------
 * Overloads <code>[]</code> to select elements from this vector.
 * This extension enables the use of traditional array notation to
 * get or set individual elements.  This method signals an error if
 * the index is outside the array range.  The file supports two
 * versions of this operator, one for <code>const</code> vectors and
 * one for mutable vectors.
 */

   ValueType & operator[](int index);
   const ValueType & operator[](int index) const;

/*
 * Operator: +
 * Usage: v1 + v2
 * --------------
 * Concatenates two vectors.
 */

   Vector operator+(const Vector & v2) const;

/*
 * Operator: +=
 * Usage: v1 += v2;
 *        v1 += value;
 * -------------------
 * Adds all of the elements from <code>v2</code> (or the single
 * specified value) to <code>v1</code>.  As a convenience, the
 * <code>Vector</code> package also overloads the comma operator so
 * that it is possible to initialize a vector like this:
 *
 *<pre>
 *    Vector&lt;int&gt; digits;
 *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
 *</pre>
 */

   Vector & operator+=(const Vector & v2);
   Vector & operator+=(const ValueType & value);

/*
 * Method: toString
 * Usage: string str = vec.toString();
 * -----------------------------------
 * Converts the vector to a printable string representation.
 */

   std::string toString();

/*
 * Method: mapAll
 * Usage: vec.mapAll(fn);
 * ----------------------
 * Calls the specified function on each element of the vector in
 * ascending index order.
 */

   void mapAll(void (*fn)(ValueType)) const;
   void mapAll(void (*fn)(const ValueType &)) const;

   template <typename FunctorType>
   void mapAll(FunctorType fn) const;

/*
 * Additional Vector operations
 * ----------------------------
 * In addition to the methods listed in this interface, the Vector
 * class supports the following operations:
 *
 *   - Stream I/O using the << and >> operators
 *   - Deep copying for the copy constructor and assignment operator
 *   - Iteration using the range-based for statement or STL iterators
 *
 * The iteration forms process the Vector in index order.
 */

/* Private section */

/**********************************************************************/
/* Note: Everything below this point in the file is logically part    */
/* of the implementation and should not be of interest to clients.    */
/**********************************************************************/

private:

/*
 * Implementation notes: Vector data structure
 * -------------------------------------------
 * The elements of the Vector are stored in a dynamic array of
 * the specified element type.  If the space in the array is ever
 * exhausted, the implementation doubles the array capacity.
 */

/* Instance variables */

   ValueType *elements;        /* A dynamic array of the elements   */
   int capacity;               /* The allocated size of the array   */
   int count;                  /* The number of elements in use     */

/* Private methods */

   void expandCapacity();
   void deepCopy(const Vector & src);

/*
 * Hidden features
 * ---------------
 * The remainder of this file consists of the code required to
 * support deep copying and iteration.  Including these methods
 * in the public interface would make that interface more
 * difficult to understand for the average client.
 */

public:

/*
 * Deep copying support
 * --------------------
 * This copy constructor and operator= are defined to make a deep copy,
 * making it possible to pass or return vectors by value and assign
 * from one vector to another.
 */

   Vector(const Vector & src);
   Vector & operator=(const Vector & src);

/*
 * Operator: ,
 * -----------
 * Adds an element to the vector passed as the left-hand operatand.
 * This form makes it easier to initialize vectors in old versions of C++.
 */

   Vector & operator,(const ValueType & value);

/*
 * Iterator support
 * ----------------
 * The classes in the StanfordCPPLib collection implement input
 * iterators so that they work symmetrically with respect to the
 * corresponding STL classes.
 */

   class iterator :
      public std::iterator<std::random_access_iterator_tag, ValueType> {

   private:
      const Vector *vp;
      int index;

   public:

      iterator() {
         this->vp = NULL;
      }

      iterator(const iterator & it) {
         this->vp = it.vp;
         this->index = it.index;
      }

      iterator(const Vector *vp, int index) {
         this->vp = vp;
         this->index = index;
      }

      iterator & operator++() {
         index++;
         return *this;
      }

      iterator operator++(int) {
         iterator copy(*this);
         operator++();
         return copy;
      }

      iterator & operator--() {
         index--;
         return *this;
      }

      iterator operator--(int) {
         iterator copy(*this);
         operator--();
         return copy;
      }

      bool operator==(const iterator & rhs) {
         return vp == rhs.vp && index == rhs.index;
      }

      bool operator!=(const iterator & rhs) {
         return !(*this == rhs);
      }

      bool operator<(const iterator & rhs) {
         extern void error(std::string msg);
         if (vp != rhs.vp) error("Iterators are in different vectors");
         return index < rhs.index;
      }

      bool operator<=(const iterator & rhs) {
         extern void error(std::string msg);
         if (vp != rhs.vp) error("Iterators are in different vectors");
         return index <= rhs.index;
      }

      bool operator>(const iterator & rhs) {
         extern void error(std::string msg);
         if (vp != rhs.vp) error("Iterators are in different vectors");
         return index > rhs.index;
      }

      bool operator>=(const iterator & rhs) {
         extern void error(std::string msg);
         if (vp != rhs.vp) error("Iterators are in different vectors");
         return index >= rhs.index;
      }

      iterator operator+(const int & rhs) {
         return iterator(vp, index + rhs);
      }

      iterator operator+=(const int & rhs) {
         index += rhs;
         return *this;
      }

      iterator operator-(const int & rhs) {
         return iterator(vp, index - rhs);
      }

      iterator operator-=(const int & rhs) {
         index -= rhs;
         return *this;
      }

      int operator-(const iterator & rhs) {
         extern void error(std::string msg);
         if (vp != rhs.vp) error("Iterators are in different vectors");
         return index - rhs.index;
      }

      ValueType & operator*() {
         return vp->elements[index];
      }

      ValueType *operator->() {
         return &vp->elements[index];
      }

      ValueType & operator[](int k) {
         return vp->elements[index + k];
      }

   };

   iterator begin() const {
      return iterator(this, 0);
   }

   iterator end() const {
      return iterator(this, count);
   }

};

/* Implementation section */

extern void error(std::string msg);

/*
 * Implementation notes: Vector constructor and destructor
 * -------------------------------------------------------
 * The constructor allocates storage for the dynamic array
 * and initializes the other fields of the object.  The
 * destructor frees the memory used for the array.
 */

template <typename ValueType>
Vector<ValueType>::Vector() {
   count = capacity = 0;
   elements = NULL;
}

template <typename ValueType>
Vector<ValueType>::Vector(int n, ValueType value) {
   count = capacity = n;
   elements = (n == 0) ? NULL : new ValueType[n];
   for (int i = 0; i < n; i++) {
      elements[i] = value;
   }
}

template <typename ValueType>
Vector<ValueType>::~Vector() {
   if (elements != NULL) delete[] elements;
}

/*
 * Implementation notes: Vector methods
 * ------------------------------------
 * The basic Vector methods are straightforward and should require
 * no detailed documentation.
 */

template <typename ValueType>
int Vector<ValueType>::size() const {
   return count;
}

template <typename ValueType>
bool Vector<ValueType>::isEmpty() const {
   return count == 0;
}

template <typename ValueType>
void Vector<ValueType>::clear() {
   if (elements != NULL) delete[] elements;
   count = capacity = 0;
   elements = NULL;
}

template <typename ValueType>
const ValueType & Vector<ValueType>::get(int index) const {
   if (index < 0 || index >= count) error("get: index out of range");
   return elements[index];
}

template <typename ValueType>
void Vector<ValueType>::set(int index, const ValueType & value) {
   if (index < 0 || index >= count) error("set: index out of range");
   elements[index] = value;
}

/*
 * Implementation notes: insert, remove, add
 * -----------------------------------------
 * These methods must shift the existing elements in the array to
 * make room for a new element or to close up the space left by a
 * deleted one.
 */

template <typename ValueType>
void Vector<ValueType>::insert(int index, ValueType value) {
   if (count == capacity) expandCapacity();
   if (index < 0 || index > count) {
      error("insert: index out of range");
   }
   for (int i = count; i > index; i--) {
      elements[i] = elements[i - 1];
   }
   elements[index] = value;
   count++;
}

template <typename ValueType>
void Vector<ValueType>::remove(int index) {
   if (index < 0 || index >= count) error("remove: index out of range");
   for (int i = index; i < count - 1; i++) {
      elements[i] = elements[i + 1];
   }
   count--;
}

template <typename ValueType>
void Vector<ValueType>::add(ValueType value) {
   insert(count, value);
}

template <typename ValueType>
void Vector<ValueType>::push_back(ValueType value) {
   insert(count, value);
}

/*
 * Implementation notes: Vector selection
 * --------------------------------------
 * The following code implements traditional array selection using
 * square brackets for the index.
 */

template <typename ValueType>
ValueType & Vector<ValueType>::operator[](int index) {
   if (index < 0 || index >= count) error("Selection index out of range");
   return elements[index];
}
template <typename ValueType>
const ValueType & Vector<ValueType>::operator[](int index) const {
   if (index < 0 || index >= count) error("Selection index out of range");
   return elements[index];
}

template <typename ValueType>
Vector<ValueType> Vector<ValueType>::operator+(const Vector & v2) const {
   Vector<ValueType> vec = *this;
   foreach (ValueType value in v2) {
      vec.add(value);
   }
   return vec;
}

template <typename ValueType>
Vector<ValueType> & Vector<ValueType>::operator+=(const Vector & v2) {
   foreach (ValueType value in v2) {
      *this += value;
   }
   return *this;
}

template <typename ValueType>
Vector<ValueType> & Vector<ValueType>::operator+=(const ValueType & value) {
   this->add(value);
   return *this;
}

template <typename ValueType>
std::string Vector<ValueType>::toString() {
   ostringstream os;
   os << *this;
   return os.str();
}

/*
 * Implementation notes: copy constructor and assignment operator
 * --------------------------------------------------------------
 * The constructor and assignment operators follow a standard paradigm,
 * as described in the associated textbook.
 */

template <typename ValueType>
Vector<ValueType>::Vector(const Vector & src) {
   deepCopy(src);
}

template <typename ValueType>
Vector<ValueType> & Vector<ValueType>::operator=(const Vector & src) {
   if (this != &src) {
      if (elements != NULL) delete[] elements;
      deepCopy(src);
   }
   return *this;
}

template <typename ValueType>
void Vector<ValueType>::deepCopy(const Vector & src) {
   count = capacity = src.count;
   elements = (capacity == 0) ? NULL : new ValueType[capacity];
   for (int i = 0; i < count; i++) {
      elements[i] = src.elements[i];
   }
}

/*
 * Implementation notes: The , operator
 * ------------------------------------
 * The comma operator works adding the right operand to the vector and
 * then returning the vector by reference so that it is set for the next
 * value in the chain.
 */

template <typename ValueType>
Vector<ValueType> & Vector<ValueType>::operator,(const ValueType & value) {
   this->add(value);
   return *this;
}

/*
 * Implementation notes: mapAll
 * ----------------------------
 * The various versions of the mapAll function apply the function or
 * function object to each element in ascending index order.
 */

template <typename ValueType>
void Vector<ValueType>::mapAll(void (*fn)(ValueType)) const {
   for (int i = 0; i < count; i++) {
      fn(elements[i]);
   }
}

template <typename ValueType>
void Vector<ValueType>::mapAll(void (*fn)(const ValueType &)) const {
   for (int i = 0; i < count; i++) {
      fn(elements[i]);
   }
}

template <typename ValueType>
template <typename FunctorType>
void Vector<ValueType>::mapAll(FunctorType fn) const {
   for (int i = 0; i < count; i++) {
      fn(elements[i]);
   }
}

/*
 * Implementation notes: expandCapacity
 * ------------------------------------
 * This function doubles the array capacity, copies the old elements
 * into the new array, and then frees the old one.
 */

template <typename ValueType>
void Vector<ValueType>::expandCapacity() {
   capacity = max(1, capacity * 2);
   ValueType *array = new ValueType[capacity];
   for (int i = 0; i < count; i++) {
      array[i] = elements[i];
   }
   if (elements != NULL) delete[] elements;
   elements = array;
}

/*
 * Implementation notes: << and >>
 * -------------------------------
 * The insertion and extraction operators use the template facilities in
 * strlib.h to read and write generic values in a way that treats strings
 * specially.
 */

template <typename ValueType>
std::ostream & operator<<(std::ostream & os, const Vector<ValueType> & vec) {
   os << "{";
   int len = vec.size();
   for (int i = 0; i < len; i++) {
      if (i > 0) os << ", ";
      writeGenericValue(os, vec[i], true);
   }
   return os << "}";
}

template <typename ValueType>
std::istream & operator>>(std::istream & is, Vector<ValueType> & vec) {
   char ch;
   is >> ch;
   if (ch != '{') error("operator >>: Missing {");
   vec.clear();
   is >> ch;
   if (ch != '}') {
      is.unget();
      while (true) {
         ValueType value;
         readGenericValue(is, value);
         vec += value;
         is >> ch;
         if (ch == '}') break;
         if (ch != ',') {
            error(std::string("operator >>: Unexpected character ") + ch);
         }
      }
   }
   return is;
}

#endif

Did I read you correctly to say that index=-1? If so, your for loop isn't (hopefully!) running, not even once, and you are (hopefully!) looking at debugging printouts from somewhere else, or maybe just the regular output of your program. Are you definitely getting the "zinfor" printout? What about if you cut out the bits we can't replicate, and just try something like

Code:

#include <iostream>

int main() {

    int index = -1;
    std::cout << index << std::endl;
    for (int z = index; z >= 0; z--, std::cout << "zinfor: " << z << std::endl)
        std::cout << "Inside for loop: z=" << z << std::endl;
    std::cout << "for loop finished";
    return 0;
}

Does that work?

First, here's the problem, paraphrased.

The problem, as it appears in the book, is copyrighted stuff. To me it doesn't seem like a big deal to post this practice problem from the book, but I don't want any trouble, so if its inappropriate to post it, let me know and I'll delete it or ask a mod to delete it or whatever I need to do.

Paraphrased from Programming Abstractions in C++ by Eric Roberts, Chapter 9:

Suppose you have a list of varying lengths of pipe needed for a job, but the distributor sells stock pipe in only one fixed size, that you can cut in any way needed.

Write a recursive function that takes as an argument a vector of the lengths needed and returns the minimum number of stock pipes required to service all requests in the vector.

For example, if the vector contains [ 4, 3, 4, 1, 7, 8 ] and the stock pipe length is 10, you can purchase 3 stock pipes and divide them as follows:

Pipe 1: 4, 4, 1
Pipe 2: 3, 7
Pipe 3: 8

And here's my solution, all pretty and overly-commented and hopefully not trashy looking like my original post.

Code:

#include <iostream>

#include "console.h"
#include "vector.h"
#include "simpio.h"

using namespace std;

//constants
const int STOCK_PIPE_LENGTH = 10;

//prototypes
int cutStock(Vector<int> &requests);
void recursiveCut(Vector<int> &requests, Vector<int> remainingPipes, Vector<int> &answers);

/*
 * The main function creates a Vector<int> called requests that represents the list of
 * pipe lengths needed.  The getInteger() function is used to get this list from the user.
 * The user repreatedly enters lengths, prompted by the message "Enter pipe length: ".
 * To signal the end of input, the user enters any value equal to or less than 0, or greater
 * than the length of the constant STOCK_PIPE_LENGTH.  The program cannot accomodate lengths
 * greater than STOCK_PIPE_LENGTH.
 *
 * int main() then outputs to the console the minimum number of pipes of length STOCK_PIPE_LENGTH
 * needed to accomodate the list of lengths provided by the user, represented by the
 * Vector<int> requests. For example, assuming STOCK_PIPE_LENGTH is equal to 10, and the user has
 * given the values 2 and 8, the program should output the answer 1, as one stock pipe of length
 * 10 can be cut into lengths 2 and 8. If the user entered 6, 6, and 6, the program should
 * output the answer 3.  If the user entered 3, 3, 3, and 3, the answer would be 2.
 *
 * This is all assuming the function cutStock(Vector<int> &requests) will successfully return
 * the correct answer.
 */

int main() {
 int x = 0;
 Vector<int> requests;
 while (true) {
  while (true) {
   x = getInteger("Enter pipe length: ");
   if (x <= 0) break;
   requests.add(x);
  }
  if (requests.size() <= 0) break;
  cout << cutStock(requests) << " stock pipes needed." << endl;
  requests.clear();
 }
 return 0;
}

/*
 * Function: int cutStock(Vector<int> &requests)
 * ---------------------------------------------
 * This function should return the smallest number of stock pipes of length STOCK_PIPE_LENGTH
 * needed to accomodate a list of lengths requested by the user.  This list is represented by
 * the Vector<int> requests, passed by reference as a parameter when the function is called.
 *
 * The function begins by creating two new Vector<int> objects, Vector<int> remainingPipes
 * and Vector<int> answers.
 *
 * Vector<int> remainingPipes will be used to represent all of the pipes from which a request
 * can be cut.  A pipe used in this way will have its length reduced by the ammount of the 
 * request it is being used to fill.  A pipe in remainingPipes will not be used unless its
 * length is greater than or equal to the length of the request.  Thus, an element of
 * remainingPipes can never be a negative number.  If a pipe is reduced to length 0, it is
 * still kept, as it is part of the answer.
 *
 * Vector<int> answers will be used to store a list of the number of pipes used in any 
 * possible strategy of cutting from and adding to the pipes in remainingPipes.  Assuming
 * the function recursiveCut() works as intended, the answer to the problem is simply
 * the lowest number in answers.  While a Set<int> object would be more appropriate in
 * this role, I have chosen to use a Vector<int> object so that readers of this code will
 * not need to be bothered to consider yet another type from an unfamiliar library.
 *
 * cutStock(Vector<int> &requests) therefore has three steps in its operation.
 *
 * 1. create the two new Vector<int> objects.
 *
 * 2. call the recursive function recursiveCut(), passing as parameters the Vector<int> requests
 * object, as well as the empty Vector<int> objects remainingPipes and answers.  requests and 
 * answers are passed by reference, while remainingPipes is not.
 *
 * 3. find the lowest element of the Vector<int> answers, and return it.
 */

int cutStock(Vector<int> &requests) {
 int result = -1;
 Vector<int> remainingPipes;
 Vector<int> answers;
 recursiveCut(requests, remainingPipes, answers);
 for (int i = 0; i < answers.size(); i++) {
  if (answers[i] < result || result == -1) {
   result = answers[i];
  }
 }
 return result;
}

/*
 * Function: recursiveCut(Vector<int> &requests, Vector<int> remainingPipes, Vector<int> &answers)
 * ------------------------
 * This function is where the work is done in this program.  It takes as its paramenters
 * three Vector<int> objects.
 *
 * Vector<int> requests represents the list if lengths input by the user.
 * Vector<int> remainingPipes represents the list of pipes to be added to or cut from.
 * Vector<int> answers represents a list of the number of pipes used in any combination 
 *  of cutting and adding to remainingPipes.
 *
 * This is a recursive function.  The simple case occurs when the size of Vector<int> requests
 * is equal to 0.
 *
 * The function starts with a for loop that will, at each iteration, remove a single element 
 * from requests and store its value in a variable:
 *
 * int currentRequest
 *
 * This value is processed and then plugged back into the Vector<int> object at the same place
 * from which it was removed.  This is done for each element in the Vector<int> requests object.
 *
 * In a single iteration of this for loop, the idea is this:
 * Start by getting the value, storing it in currentRequest, and removing it from the vector.
 *
 * From here, there are two possibilities.  
 *
 * One possibility is that the ideal answer involves cutting this
 * length from a pipe already contained in the Vector<int> remainingPipes, which represents
 * the list of pipes already in use, and their current lengths.  To this end, the nested for
 * loop using int j as its index variable will cycle through each element of remainingPipes.
 * If the current element of remainingPipes is greater than or equal to the length of
 * the currentRequest (if (remainingPipes[j] >= currentRequest)) then the length of 
 * currentRequest is subtracted from that element of remainingPipes, and the function
 * recursiveCut calls itself recursively, in this new configuration.  In this new call, 
 * requests now has one less element than it did on the original call, remainingPipes contains
 * an element from which has been subtracted the length of the request that no longer exists
 * in requests, and everything is just generally awesome and everyone is having a great time.
 *
 * After this recursive call, the length of currentRequest is added back to the element of
 * remainingPipes from which it was subtracted, and the for loop moves on to the next element
 * of remainingPipes.  Note that if remainingPipes has 0 elements, this for loop is effectively
 * skipped entirely.
 * 
 * After this for loop completes, it is time to check for the other possibility, which is:
 * The ideal answer involves cutting the length of currentRequest from a brand new pipe instead 
 * of a pipe already contained in remainingPipes.  All new pipes will be of length STOCK_PIPE_LENGTH,
 * so to make this happen we just create a new pipe of length STOCK_PIPE_LENGTH - currentRequest.
 *
 * int newPipe = STOCK_PIPE_LENGTH - currentRequest
 *
 * This element is then added to the Vector<int> remainingPipes, and the function calls itself
 * recursively in this new configuration.  In this new call, Vector<int> requests has one less
 * element than it did in the original call, and remainingPipes has one new element added it,
 * of length STOCK_PIPE_LENGTH minus the length of the element that was removed from requests 
 * in the previous call.
 * After this recursive call is complete, the new element that was added to remainingPipes
 * is then removed. (remaining.remove(remaining.size() - 1))
 *
 * The simple case occurs when requests has no more elements (if (requests.size() <= 0))
 * In this case, the idea is to simply take the number of elements in remainingPipes (including,
 * of course, elements whose length is 0, as this is simply another pipe that has been used and
 * must have been purchased), and add this number as a new element to the Vector<int> answers.
 * 
 * In this way, every possible way of cutting from and adding new pipes to remainingPipes to 
 * cover all elements of requests will have been searched, and the Vector<int> answers will
 * contain as its elements the number of pipes of length STOCK_PIPE_LENGTH that were needed
 * in each configuration.  Thus, after the first call of recursiveCut() as called by the 
 * function cutStock() has completed, the program only needs to take the lowest number contained
 * in the Vector<int> answers and return this number as the solution to the problem, the least
 * number of pipes of length STOCK_PIPE_LENGTH needed to fill the set of requests represented
 * by the Vector<int> requests.
 */

void recursiveCut(Vector<int> &requests, Vector<int> remainingPipes, Vector<int> &answers) {
 if (requests.size() <= 0) {
  answers.add(remainingPipes.size());
  return;
 }
 for (int z = requests.size() - 1; z >= 0; z--) {
  int currentRequest = requests[z];
  requests.remove(z);
  for (int j = remainingPipes.size() - 1; j >= 0; j--) {
   if (remainingPipes[j] >= currentRequest) {
    if (requests.size() <= 0) {
     answers.add(remainingPipes.size());
    } else {
     remainingPipes[j] -= currentRequest;
     recursiveCut(requests, remainingPipes, answers);
     remainingPipes[j] += currentRequest;
    }
   }
  }
  int newPipe = STOCK_PIPE_LENGTH - currentRequest;
  remainingPipes.add(newPipe);
  recursiveCut(requests, remainingPipes, answers);
  remainingPipes.remove(remainingPipes.size() - 1);
  requests.insert(z, currentRequest);
 }
}

Now as far as I can tell, that program seems to work.

The broken for loop (which doesn't seem to be broken in this version) begins on line 178.

The identical for loop in the original program works fine until the variable "index" is -1, at which point the for loop, instead of skipping itself entirely (as its supposed to do when index is -1) decides to first assign z to 2 (weird) and then increment instead of decrementing (really weird) and then terminate at either 6 or 7 (where could it be getting this random number from???)

In the new version, there is no variable "index", and the for loop simply assigned its index "z" to be the size of the Vector<int> requests - 1, which is what "index" is assigned to in the original version. However, making this change in the original version still doesn't fix the broken for loop.

Im convinced I will never figure out why its been doing this. If someone else can see what I missed Id be more than happy to hear about it. Im just completely in the dark about what went wrong.