Vector Implimentation Help

[Nerdrage23]

Hello everyone. I am currently on vacation at the moment and am quite a distance away from any computer with a compiler to be able to help test and debug my code. I was hoping that someone might be able to help me go about figuring out my header file while I am away? That would be great!

The assignment is to be able to implement a vector class with upper and lower bounds to allow the usage of negative indexes. I'm having trouble with making sure that my code is solid and solves the problem at hand. There is a need to keep track of where the zero-th element from the original vector would be in relation to the negative index(s).

I was wondering, if someone wouldn't mind telling me what is wrong/'could be better' with each method, that would be awesome! I really don't want to be GIVEN code but examples that touch on the subject would be acceptable too.

(**Trying to remain within the code of ethics and such so I am not expelled - primarily because I enjoy the challenge of programming and don't like being given the answer on a silver platter.)

If you could format the corrective criticism in this format**, that would be great!

Method Name('parameters'){

'''Put what you think needs/can be improved upon here'''
'''(No 'actual' code for this assignment should be placed here-only examples)'''

}

Any help with this would be wonderful. Thanks. :3

lwer_bnd_vector header file (.h)

#ifndef _LBVECTOR_H
#define _LBVECTOR_H

#include <cstdlib>
#include <cassert>
#include <iostream>

template <class Item> class lbvector
{
public:
   // default constructor
	lbvector( ) 
	{
		  myCapacity = 0;
		  Item* myList = new Item [];
		  myUpper = 0;
		  myLower = 0;
		  *myZero = nullptr;
	}
   
  // lbvector constructor given lower and upper bounds
   lbvector(int vLow, int vHigh) 
   {
   
	  myLower = vLow;
	  myUpper = vHigh;
	  const int size = 1 + (myUpper - myLower);
	  assert(size >= 0);
      Item* myList = new Item [size];
	  assert(myList != 0);
	  Item* myZero = myList - myLower;  
   }

   // lbvector constructor, given lower bound, upper bound and a fill value
   lbvector(int vLow, int vHigh, Item fillValue) 
   {
		myLower = vLow;
		myUpper = vHigh;
		const int size = 1 + (myUpper - myLower);
		assert(size >= 0);
		Item* myList = new Item [size];
		assert(myList != 0);
		fill(fillValue);
		Item* myZero = myList - myLower;
   }
   
   // copy constructor - makes a duplicate lbvector
       
   lbvector(const lbvector<Item> & vec) 
   {
      myUpper = vec.myUpper;
	  mylower = vec.myLower;
	  myCapacity = vec.myCapacity;
      myList* = new Item [myCapacity];
      assert(myList != 0);
        
      // copy elements from vec
      for (int k = 0; k < vec.myCapacity; k++) {
         myList[k] = vec.myList[k];
      }
	  Item* myZero = myList - myLower;
   }
    
   // destructs unneeded 'lower-bound' vector
   ~lbvector ( ) 
   {
      delete [] myList;
   }

   // assignment method
   //    need a deep copy when using dynamic memory
   // precondition: Item supports assignment     
   // postcondition: self is assigned vec
   lbvector & operator = (const lbvector<Item> & vec) 
   {
 
      if (this != &vec) {
         // out with old list, in with new
         delete [] myList;
         myCapacity = vec.myCapacity;
         myList = new Item [myCapacity];
         assert(myList != 0);
            
         // copy elements from vec
         for (int k=0; k < vec.myCapacity; k++) {
            myList[k] = vec.myList[k];
         }
      }
      return *this;           
   }

   //  resizes the applied lbvector to a new size, given a lower bound, upper bound
   //   and a desired new size
   void resize(int newLow, int newHigh, int newSize) 
   {
      assert(newSize >= 0);
      	  
      // allocate new storage
      Item * newList = new Item[newSize];
      assert(newList != 0);

      // copy retained values from old to new        
      for (int k=newLow; k < newHigh;k++) {
         newList[k] = myList[k];
      }

      // return space no longer needed        
      delete [] myList;

      // update instance variables to reflect changes
      myCapacity = newSize;
      myList = newList;
   }

   
   //retrieves the upper bound of the applied vector
   int upper( ) const
   {
		return myUpper;
   }
   
   //retrieves the lower bound of the applied vector 
   int lower( ) const
   {
		return myLower;   
   }

   //retrieves the capacity of the applied vector
   int capacity( ) const 
   {
      return myCapacity;
   }

   // fills a given vector with the given 'fillvalue'
   void fill(Item fillValue) 
   {
      for (int k=0; k < myCapacity; k++) {
         myList[k] = fillValue;
      }
   }

   // safe indexing, returning reference
   // precondition: 0 <= index < myCapacity
   // postcondition: return index-th item
   // exception: aborts if index is out-of-bounds
   Item & operator [] (int index) 
   {
      checkIndex(index);
      return myList[index];     
   }
    
   // const index 
   // safe indexing, returning const reference to avoid modification
   // precondition: 0 <= index < myCapacity
   // postcondition: return index-th item
   // exception: aborts if index is out-of-bounds
   const Item & operator [] (int index) const 
   {
      checkIndex(index);
      return myList[index]; 
   }

private:
	
	
	lbvector <Item> *  myList;  	// the array of items
	Item* myZero;  	//pointer to the element in the array that is considered to be the original '0'
	int myCapacity; // # things in vector (array), 0,1,...,(myCapacity-1)
	int myUpper;
	int myLower;
	
   
   // aborts with appropriate message if index is not in appropriate range
   // use std:: to access names in std namespace
   void checkIndex ( int index) const 
   {
      if (index < 0 || myCapacity <= index) {
         std::cerr << "Illegal vector index: " << index
                   << " (max = " << myCapacity-1 << ")" 
                   << std::endl;
         assert(index >= 0);
         assert(index < myCapacity);
      }
   }
};

#endif                // _LBVECTOR_H not defined 

[naraku9333]

You are leaking memory in your constructors and this *myZero = nullptr; is wrong.

[Nerdrage23]

@naraku9333: I think I understand the pointer issue (it should read 'int * myZero = nullptr;'), but your statement about 'leaking memory' is a bit broad. Could you be a bit more specific?

[naraku9333]

it should read 'int * myZero = nullptr;'

No that would declare an int pointer names myZero local to the function. You want myZero = nullptr;

Lines 29 and 41 Item* myList = new Item [size]; these are created local to the function and are not deleted so the memory is leaked.

Also, in resize() you have

Item * newList = new Item[newSize];
     ...
      myList = newList;

myList is an lbvector<Item>* but you are setting it to an Item*.