From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../Codebeispiele/6_ch17/fig17_12/fig17_12test.cpp | 69 +++++++ .../Prog2/Codebeispiele/6_ch17/fig17_12/list.h | 216 +++++++++++++++++++++ .../Prog2/Codebeispiele/6_ch17/fig17_12/listnode.h | 56 ++++++ .../6_ch17/fig17_12/stackcomposition.h | 62 ++++++ 4 files changed, 403 insertions(+) create mode 100644 Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/fig17_12test.cpp create mode 100644 Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/list.h create mode 100644 Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/listnode.h create mode 100644 Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/stackcomposition.h (limited to 'Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12') diff --git a/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/fig17_12test.cpp b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/fig17_12test.cpp new file mode 100644 index 0000000..3adb315 --- /dev/null +++ b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/fig17_12test.cpp @@ -0,0 +1,69 @@ +// Fig. 17.11: fig17_11.cpp +// Template Stack class test program. +#include + +using std::endl; + +#include "stackcomposition.h" // Stack class definition + +int main() +{ + Stack< int > intStack; // create Stack of ints + int popInteger; + + cout << "processing an integer Stack" << endl; + + // push integers onto intStack + for ( int i = 0; i < 4; i++ ) { + intStack.push( i ); + intStack.printStack(); + + } // end for + + // pop integers from intStack + while ( !intStack.isStackEmpty() ) { + intStack.pop( popInteger ); + cout << popInteger << " popped from stack" << endl; + intStack.printStack(); + + } // end while + + Stack< double > doubleStack; // create Stack of doubles + double value = 1.1, popdouble; + + cout << "processing a double Stack" << endl; + + // push floating-point values onto doubleStack + for ( int j = 0; j< 4; j++ ) { + doubleStack.push( value ); + doubleStack.printStack(); + value += 1.1; + + } // end for + + // pop floating-point values from doubleStack + while ( !doubleStack.isStackEmpty() ) { + doubleStack.pop( popdouble ); + cout << popdouble << " popped from stack" << endl; + doubleStack.printStack(); + + } // end while + + return 0; + +} // end main + +/************************************************************************** + * (C) Copyright 1992-2003 by Deitel & Associates, Inc. and Prentice * + * Hall. All Rights Reserved. * + * * + * DISCLAIMER: The authors and publisher of this book have used their * + * best efforts in preparing the book. These efforts include the * + * development, research, and testing of the theories and programs * + * to determine their effectiveness. The authors and publisher make * + * no warranty of any kind, expressed or implied, with regard to these * + * programs or to the documentation contained in these books. The authors * + * and publisher shall not be liable in any event for incidental or * + * consequential damages in connection with, or arising out of, the * + * furnishing, performance, or use of these programs. * + *************************************************************************/ \ No newline at end of file diff --git a/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/list.h b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/list.h new file mode 100644 index 0000000..c6d2219 --- /dev/null +++ b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/list.h @@ -0,0 +1,216 @@ +// Fig. 15.4: list.h +// Template List class definition. +#ifndef LIST_H +#define LIST_H + +#include + +using std::cout; + +#include +#include "listnode.h" // ListNode class definition + +template< class NODETYPE > +class List { + +public: + List(); // constructor + ~List(); // destructor + void insertAtFront( const NODETYPE & ); + void insertAtBack( const NODETYPE & ); + bool removeFromFront( NODETYPE & ); + bool removeFromBack( NODETYPE & ); + bool isEmpty() const; + void print() const; + +private: + ListNode< NODETYPE > *firstPtr; // pointer to first node + ListNode< NODETYPE > *lastPtr; // pointer to last node + + // utility function to allocate new node + ListNode< NODETYPE > *getNewNode( const NODETYPE & ); + +}; // end class List + +// default constructor +template< class NODETYPE > +List< NODETYPE >::List() + : firstPtr( 0 ), + lastPtr( 0 ) +{ + // empty body + +} // end List constructor + +// destructor +template< class NODETYPE > +List< NODETYPE >::~List() +{ + if ( !isEmpty() ) { // List is not empty + cout << "Destroying nodes ...\n"; + + ListNode< NODETYPE > *currentPtr = firstPtr; + ListNode< NODETYPE > *tempPtr; + + while ( currentPtr != 0 ) { // delete remaining nodes + tempPtr = currentPtr; + cout << tempPtr->data << '\n'; + currentPtr = currentPtr->nextPtr; + delete tempPtr; + + } // end while + + } // end if + + cout << "All nodes destroyed\n\n"; + +} // end ~List destructor + +// insert node at front of list +template< class NODETYPE > +void List< NODETYPE >::insertAtFront( const NODETYPE &value ) +{ + ListNode< NODETYPE > *newPtr = getNewNode( value ); + + if ( isEmpty() ) // List is empty + firstPtr = lastPtr = newPtr; + + else { // List is not empty + newPtr->nextPtr = firstPtr; + firstPtr = newPtr; + + } // end else + +} // end function insertAtFront + +// insert node at back of list +template< class NODETYPE > +void List< NODETYPE >::insertAtBack( const NODETYPE &value ) +{ + ListNode< NODETYPE > *newPtr = getNewNode( value ); + + if ( isEmpty() ) // List is empty + firstPtr = lastPtr = newPtr; + + else { // List is not empty + lastPtr->nextPtr = newPtr; + lastPtr = newPtr; + + } // end else + +} // end function insertAtBack + +// delete node from front of list +template< class NODETYPE > +bool List< NODETYPE >::removeFromFront( NODETYPE &value ) +{ + if ( isEmpty() ) // List is empty + return false; // delete unsuccessful + + else { + ListNode< NODETYPE > *tempPtr = firstPtr; + + if ( firstPtr == lastPtr ) + firstPtr = lastPtr = 0; + else + firstPtr = firstPtr->nextPtr; + + value = tempPtr->data; // data being removed + delete tempPtr; + + return true; // delete successful + + } // end else + +} // end function deleteFromFront + +// delete node from back of list +template< class NODETYPE > +bool List< NODETYPE >::removeFromBack( NODETYPE &value ) +{ + if ( isEmpty() ) + return false; // delete unsuccessful + + else { + ListNode< NODETYPE > *tempPtr = lastPtr; + + if ( firstPtr == lastPtr ) + firstPtr = lastPtr = 0; + else { + ListNode< NODETYPE > *currentPtr = firstPtr; + + // locate second-to-last element + while ( currentPtr->nextPtr != lastPtr ) + currentPtr = currentPtr->nextPtr; + + lastPtr = currentPtr; + currentPtr->nextPtr = 0; + + } // end else + + value = tempPtr->data; + delete tempPtr; + + return true; // delete successful + + } // end else + +} // end function deleteFromBack + +// is List empty? +template< class NODETYPE > +bool List< NODETYPE >::isEmpty() const +{ + return firstPtr == 0; + +} // end function isEmpty + +// return pointer to newly allocated node +template< class NODETYPE > +ListNode< NODETYPE > *List< NODETYPE >::getNewNode( + const NODETYPE &value ) +{ + return new ListNode< NODETYPE >( value ); + +} // end function getNewNode + +// display contents of List +template< class NODETYPE > +void List< NODETYPE >::print() const +{ + if ( isEmpty() ) { + cout << "The list is empty\n\n"; + return; + + } // end if + + ListNode< NODETYPE > *currentPtr = firstPtr; + + cout << "The list is: "; + + while ( currentPtr != 0 ) { + cout << currentPtr->data << ' '; + currentPtr = currentPtr->nextPtr; + + } // end while + + cout << "\n\n"; + +} // end function print + +#endif + +/************************************************************************** + * (C) Copyright 1992-2003 by Deitel & Associates, Inc. and Prentice * + * Hall. All Rights Reserved. * + * * + * DISCLAIMER: The authors and publisher of this book have used their * + * best efforts in preparing the book. These efforts include the * + * development, research, and testing of the theories and programs * + * to determine their effectiveness. The authors and publisher make * + * no warranty of any kind, expressed or implied, with regard to these * + * programs or to the documentation contained in these books. The authors * + * and publisher shall not be liable in any event for incidental or * + * consequential damages in connection with, or arising out of, the * + * furnishing, performance, or use of these programs. * + *************************************************************************/ \ No newline at end of file diff --git a/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/listnode.h b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/listnode.h new file mode 100644 index 0000000..7980786 --- /dev/null +++ b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/listnode.h @@ -0,0 +1,56 @@ +// Fig. 15.3: listnode.h +// Template ListNode class definition. +#ifndef LISTNODE_H +#define LISTNODE_H + +// forward declaration of class List +template< class NODETYPE > class List; + +template< class NODETYPE > +class ListNode { + friend class List< NODETYPE >; // make List a friend + +public: + ListNode( const NODETYPE & ); // constructor + NODETYPE getData() const; // return data in node + +private: + NODETYPE data; // data + ListNode< NODETYPE > *nextPtr; // next node in list + +}; // end class ListNode + +// constructor +template< class NODETYPE > +ListNode< NODETYPE >::ListNode( const NODETYPE &info ) + : data( info ), + nextPtr( 0 ) +{ + // empty body + +} // end ListNode constructor + +// return copy of data in node +template< class NODETYPE > +NODETYPE ListNode< NODETYPE >::getData() const +{ + return data; + +} // end function getData + +#endif + +/************************************************************************** + * (C) Copyright 1992-2003 by Deitel & Associates, Inc. and Prentice * + * Hall. All Rights Reserved. * + * * + * DISCLAIMER: The authors and publisher of this book have used their * + * best efforts in preparing the book. These efforts include the * + * development, research, and testing of the theories and programs * + * to determine their effectiveness. The authors and publisher make * + * no warranty of any kind, expressed or implied, with regard to these * + * programs or to the documentation contained in these books. The authors * + * and publisher shall not be liable in any event for incidental or * + * consequential damages in connection with, or arising out of, the * + * furnishing, performance, or use of these programs. * + *************************************************************************/ \ No newline at end of file diff --git a/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/stackcomposition.h b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/stackcomposition.h new file mode 100644 index 0000000..2a603d7 --- /dev/null +++ b/Bachelor/Prog2/Codebeispiele/6_ch17/fig17_12/stackcomposition.h @@ -0,0 +1,62 @@ +// Fig. 17.12: stackcomposition.h +// Template Stack class definition with composed List object. +#ifndef STACKCOMPOSITION +#define STACKCOMPOSITION + +#include "list.h" // List class definition + +template< class STACKTYPE > +class Stack { + +public: + // no constructor; List constructor does initialization + + // push calls stackList object's insertAtFront function + void push( const STACKTYPE &data ) + { + stackList.insertAtFront( data ); + + } // end function push + + // pop calls stackList object's removeFromFront function + bool pop( STACKTYPE &data ) + { + return stackList.removeFromFront( data ); + + } // end function pop + + // isStackEmpty calls stackList object's isEmpty function + bool isStackEmpty() const + { + return stackList.isEmpty(); + + } // end function isStackEmpty + + // printStack calls stackList object's print function + void printStack() const + { + stackList.print(); + + } // end function printStack + +private: + List< STACKTYPE > stackList; // composed List object + +}; // end class Stack + +#endif + +/************************************************************************** + * (C) Copyright 1992-2003 by Deitel & Associates, Inc. and Prentice * + * Hall. All Rights Reserved. * + * * + * DISCLAIMER: The authors and publisher of this book have used their * + * best efforts in preparing the book. These efforts include the * + * development, research, and testing of the theories and programs * + * to determine their effectiveness. The authors and publisher make * + * no warranty of any kind, expressed or implied, with regard to these * + * programs or to the documentation contained in these books. The authors * + * and publisher shall not be liable in any event for incidental or * + * consequential damages in connection with, or arising out of, the * + * furnishing, performance, or use of these programs. * + *************************************************************************/ \ No newline at end of file -- cgit v1.2.3