online compiler and debugger for c/c++

/* Lawrenceville Press PegClass type DECLARATION */ /* October 1997 */ #ifndef _PEGCLASS_ #define _PEGCLASS_ #include <iostream> #include "vector.h" //#include <lvp\bool.h> class PegClass { public: PegClass(); // Not configured; must call SetPeg() later PegClass(int Height); ~PegClass(); void SetPeg(int Height); void AddRing(int Size); int RemoveRing(); int TopRing() const; // Returns size of top Ring int RingsOnPeg() const; // Returns number of Rings on peg void ShowAll() const; // Shows _all_ declared and configured pegs const PegClass & operator = ( const PegClass & P ); // Assignment private: struct PegData { // Data needed for a single Peg vector<int> PegStack; // An array representing the rings bool Configured; //False, if init'ed by default, // parameterless constructor int NumRings; // Number of rings currently on peg int Hgt; // Height of peg }; static vector<PegData> PegList; // List of all Pegs constructed static int MaxRingSize; // Used in spacing the pegs int MySpot; // Location of _this_ peg in PegList // Copy constructor "hidden" by private definition. PegClass(const PegClass &PegClass); // Copy constructor void DrawBlanks(int N) const; // Utility function for spacing the Pegs }; #include "pegclass.cpp" #endif

/* Lawrenceville Press PegClass type IMPLEMENTATION */ /* October 1997 */ /* Revised: March 1999 TopRing calls abort() if there */ /* are no rings on the peg */ // Must initialize static members here vector<PegClass::PegData> PegClass::PegList; int PegClass::MaxRingSize = 7; const PegClass & PegClass::operator = ( const PegClass & P ) // Assignment { PegList[MySpot].PegStack = PegList[P.MySpot].PegStack; PegList[MySpot].Hgt = PegList[P.MySpot].Hgt; PegList[MySpot].NumRings = PegList[P.MySpot].NumRings; PegList[MySpot].Configured = PegList[P.MySpot].Configured; return *this; } //------------------------------------------- PegClass::~PegClass() /* Deletes the peg (by flagging) */ { PegList.resize(PegList.length()-1); } //------------------------------------------- PegClass::PegClass(int Height) /* Creates a PegClass object with given height. Pre: Height > 0 Post: Peg is created with given height*/ { int spot = PegList.length(); PegList.resize(PegList.length()+1); PegList[spot].PegStack.resize(Height); PegList[spot].Hgt = Height; PegList[spot].NumRings = 0; PegList[spot].Configured = true; MySpot = spot; } //------------------------------------------- PegClass::PegClass() /* Creates an unconfigured PegClass object Post: Peg is created */ { int spot = PegList.length(); PegList.resize(PegList.length()+1); PegList[spot].Configured = false; MySpot = spot; } //------------------------------------------- void PegClass::SetPeg(int Height) /* Sets the height of a previously unconfigured peg Pre: Height > 0 Post: Peg is configured with given height */ { PegList[MySpot].PegStack.resize(Height); PegList[MySpot].Hgt = Height; PegList[MySpot].NumRings = 0; PegList[MySpot].Configured = true; } //------------------------------------------- int PegClass::RingsOnPeg() const /* Returns number of rings on peg Post: Number of rings on peg returned */ { if (!PegList[MySpot].Configured) { cout << "Peg not configured!" << endl; abort(); } return(PegList[MySpot].NumRings); } //------------------------------------------- void PegClass::AddRing(int Size) /* Adds a ring of given size to top of peg. Pre: 1 <= Size <= MaxRingSize Post: Ring has been added to top of peg */ { if (!PegList[MySpot].Configured) { cout << "Peg not configured!" << endl; abort(); } if (PegList[MySpot].NumRings < PegList[MySpot].Hgt && Size <= MaxRingSize && Size > 0) { PegList[MySpot].PegStack[PegList[MySpot].NumRings] = Size; PegList[MySpot].NumRings++; } else abort(); } //------------------------------------------- int PegClass::RemoveRing() /* Removes top ring from the peg and returns its size. Pre: Peg is not empty Post: Top ring removed, and size returned. */ { if (!PegList[MySpot].Configured) { cout << "Peg not configured!" << endl; abort(); } if (PegList[MySpot].NumRings > 0) { PegList[MySpot].NumRings--; } else abort(); return(PegList[MySpot].PegStack[PegList[MySpot].NumRings]); } //------------------------------------------- int PegClass::TopRing() const /* Returns size of top ring. Pre: Peg is not empty Post: Size of top ring on peg returned. */ { if (!PegList[MySpot].Configured) { cout << "Peg not configured!" << endl; abort(); } if (PegList[MySpot].NumRings > 0) return(PegList[MySpot].PegStack[PegList[MySpot].NumRings-1]); else abort(); } //------------------------------------------- void PegClass::DrawBlanks(int N) const /* Draws N blanks Pre: N >= 0 Post: N blanks have been drawn */ { for (int i=1; i <= N; i++) cout << " "; } //------------------------------------------- void PegClass::ShowAll() const /* Shows all declared and configured pegs Post: All configured pegs have been displayed */ { int i; int PegCount = 0; int MaxHgt = 0; for (i=0; i < PegList.length() ; i++) { if (PegList[i].Configured) { PegCount++; if (PegList[i].Hgt > MaxHgt) MaxHgt = PegList[i].Hgt; } } for (int Row = MaxHgt-1; Row >= 0; Row--) { // do a Row for (i=0; i < PegList.length() ; i++) // Do Peg i in this Row if (!PegList[i].Configured) ; // Do nothing else if (PegList[i].Hgt > Row) { if (PegList[i].NumRings > Row) { // If a Ring on this row // Draw a Ring (possibly empty) int Col; for (Col=(-MaxRingSize); Col <= (-1); Col++) if ( PegList[i].PegStack[Row] >= (-Col) ) cout << "X"; else cout << " "; cout << "|"; for (Col=1; Col <= MaxRingSize; Col++) if (PegList[i].PegStack[Row] >= Col) cout << "X"; else cout << " "; } else { DrawBlanks(MaxRingSize); cout << "|"; DrawBlanks(MaxRingSize); } } else { DrawBlanks(MaxRingSize); cout << " "; DrawBlanks(MaxRingSize); } cout << endl; } for (int Col = 1; Col <= (2*MaxRingSize+1)*PegCount; Col++) cout <<"-"; cout << endl; }

#ifndef _VECTOR_H #define _VECTOR_H /* Lawrenceville Press vector type DECLARATION */ /* June 1997, updated March 1999 comments updated */ /* */ /* The vector class is based on the class apvector defined */ /* for use in the AP Computer Science courses. */ /* */ /* Inclusion of the C++ classes defined for use in the */ /* Advanced Placement Computer Science courses does not */ /* constitute endorsement of the other material in */ /* "A Guide to Programming in C++" (Lawrenceville Press, */ /* June 1997) by the College Board, Educational Testing */ /* Service, or the AP Computer Science Development Committee.*/ /* */ /* vector class consistent with a subset of the standard C++ */ /* vector class as defined in the draft ANSI standard */ // ******************************************************************* // Revised: January 13,1998, added explicit to int constructor // Revised: 8/14/98 abort changed to exit // // APCS vector class template // // implements "safe" (range-checked) arrays // examples are given at the end of this file // ******************************************************************* // If your compiler supports the keyword explicit, comment out the // #define explicit line below, leaving the #define means explicit // is ignored, but doesn't generate an error // // This will disallow a typically erroneous implicit type-conversion: // vector<int> v( 10 ); // v = 0; // Oops!! Allowed because of implicit type-con2lversion. #define explicit template <class itemType> class vector { public: // constructors/destructor vector( ); // default constructor (size==0) explicit vector( int size ); // initial size of vector is size vector( int size, const itemType & fillValue ); // all entries == fillValue vector( const vector & vec ); // copy constructor ~vector( ); // destructor // assignment const vector & operator = ( const vector & vec ); // accessors int length( ) const; // capacity of vector // indexing itemType & operator [ ] ( int index ); // indexing with range checking const itemType & operator [ ] ( int index ) const; // indexing with range checking // modifiers void resize( int newSize ); // change size dynamically; // can result in losing values private: int mySize; // # elements in array itemType * myList; // array used for storage }; // ******************************************************************* // Specifications for vector functions // // The template parameter itemType must satisfy the following two conditions: // (1) itemType has a 0-argument constructor // (2) operator = is defined for itemType // Any violation of these conditions may result in compilation failure. // // Any violation of a function's precondition will result in an error message // followed by a call to exit. // // constructors/destructor // // vector( ) // postcondition: vector has a capacity of 0 items, and therefore it will // need to be resized // // vector( int size ) // precondition: size >= 0 // postcondition: vector has a capacity of size items // // vector( int size, const itemType & fillValue ) // precondition: size >= 0 // postcondition: vector has a capacity of size items, all of which are set // by assignment to fillValue after default construction // // vector( const vector & vec ) // postcondition: vector is a copy of vec // // ~vector( ) // postcondition: vector is destroyed // // assignment // // const vector & operator = ( const vector & rhs ) // postcondition: normal assignment via copying has been performed; // if vector and rhs were different sizes, vector // has been resized to match the size of rhs // // accessor // // int length( ) const // postcondition: returns vector's size (number of memory cells // allocated for vector) // // indexing // // itemType & operator [ ] ( int k ) -- index into nonconst vector // const itemType & operator [ ] ( int k ) const -- index into const vector // description: range-checked indexing, returning kth item // precondition: 0 <= k < length() // postcondition: returns the kth item // // modifier // // void resize( int newSize ) // description: resizes the vector to newSize elements // precondition: the current capacity of vector is length; newSize >= 0 // // postcondition: the current capacity of vector is newSize; for each k // such that 0 <= k <= min(length, newSize), vector[k] // is a copy of the original; other elements of vector are // initialized using the 0-argument itemType constructor // Note: if newSize < length, elements may be lost // // examples of use // vector<int> v1; // 0-element vector // vector<int> v2(4); // 4-element vector // vector<int> v3(4, 22); // 4-element vector, all elements == 22. #include "vector.cpp" #endif

/* Lawrenceville Press vector type IMPLEMENTATION */ /* June 1997, updated March 1999 comments updated */ /* */ /* The vector class is based on the class apvector defined */ /* for use in the AP Computer Science courses. */ /* */ /* Inclusion of the C++ classes defined for use in the */ /* Advanced Placement Computer Science courses does not */ /* constitute endorsement of the other material in */ /* "A Guide to Programming in C++" (Lawrenceville Press, */ /* June 1997) by the College Board, Educational Testing */ /* Service, or the AP Computer Science Development Committee.*/ /* */ /* vector class consistent with a subset of the standard C++ */ /* vector class as defined in the draft ANSI standard */ // ******************************************************************* // Revised: January 13,1998 // Revised: 8/14/98 abort changed to exit // // APCS vector class IMPLEMENTATION // // see vector.h for complete documentation of functions // // vector class consistent with a subset of the standard C++ vector class // as defined in the draft ANSI standard (part of standard template library) // ******************************************************************* #include <stdlib.h> #include <assert.h> #include <iostream> #include "vector.h" using namespace std; template <class itemType> vector<itemType>::vector() //postcondition: vector has a capacity of 0 items, and therefore it will // need to be resized : mySize(0), myList(0) { } template <class itemType> vector<itemType>::vector(int size) // precondition: size >= 0 // postcondition: vector has a capacity of size items : mySize(size), myList(new itemType[size]) { } template <class itemType> vector<itemType>::vector(int size, const itemType & fillValue) // precondition: size >= 0 // postcondition: vector has a capacity of size items, all of which are set // by assignment to fillValue after default construction : mySize(size), myList(new itemType[size]) { int k; for(k = 0; k < size; k++) { myList[k] = fillValue; } } template <class itemType> vector<itemType>::vector(const vector<itemType> & vec) // postcondition: vector is a copy of vec : mySize(vec.length()), myList(new itemType[mySize]) { int k; // copy elements for(k = 0; k < mySize; k++){ myList[k] = vec.myList[k]; } } template <class itemType> vector<itemType>::~vector () // postcondition: vector is destroyed { delete [] myList; } template <class itemType> const vector<itemType> & vector<itemType>::operator = (const vector<itemType> & rhs) // postcondition: normal assignment via copying has been performed; // if vector and rhs were different sizes, vector // has been resized to match the size of rhs { if (this != &rhs) // don't assign to self! { delete [] myList; // get rid of old storage mySize = rhs.length(); myList = new itemType [mySize]; // allocate new storage // copy rhs int k; for(k=0; k < mySize; k++) { myList[k] = rhs.myList[k]; } } return *this; // permit a = b = c = d } template <class itemType> int vector<itemType>::length() const // postcondition: returns vector's size (number of memory cells // allocated for vector) { return mySize; } template <class itemType> itemType & vector<itemType>::operator [] (int k) // description: range-checked indexing, returning kth item // precondition: 0 <= k < length() // postcondition: returns the kth item { if (k < 0 || mySize <= k) { cerr << "Illegal vector index: " << k << " max index = "; cerr << (mySize-1) << endl; exit(1); } return myList[k]; } template <class itemType> const itemType & vector<itemType>::operator [] (int k) const // safe indexing, returning const reference to avoid modification // precondition: 0 <= index < length // postcondition: return index-th item // exception: aborts if index is out-of-bounds { if (k < 0 || mySize <= k) { cerr << "Illegal vector index: " << k << " max index = "; cerr << (mySize-1) << endl; exit(1); } return myList[k]; } template <class itemType> void vector<itemType>::resize(int newSize) // description: resizes the vector to newSize elements // precondition: the current capacity of vector is length(); newSize >= 0 // postcondition: the current capacity of vector is newSize; for each k // such that 0 <= k <= min(length, newSize), vector[k] // is a copy of the original; other elements of vector are // initialized using the 0-argument itemType constructor // Note: if newSize < length, elements may be lost { int k; int numToCopy = newSize < mySize ? newSize : mySize; // allocate new storage and copy element into new storage itemType * newList = new itemType[newSize]; for(k=0; k < numToCopy; k++) { newList[k] = myList[k]; } delete [] myList; // de-allocate old storage mySize = newSize; // assign new storage/size myList = newList; }