init: init nachos hw01

c++example/templatestack.cc

@@ -0,0 +1,149 @@
+// templatestack.cc
+//	Routines to implement a LIFO stack of arbitrary things.
+//	
+//	The stack is represented as an array; we return an error
+//	if the caller tries to push more things onto the stack than we have
+//	room for.
+//
+// Copyright (c) 1992,1993,1995 The Regents of the University of California.
+// All rights reserved.  See copyright.h for copyright notice and limitation 
+// of liability and disclaimer of warranty provisions.
+
+
+extern "C" {
+#include <assert.h>
+
+#define ASSERT(expression)  assert(expression)
+}
+
+#include <iostream.h>
+#include "copyright.h"
+#include "templatestack.h"
+
+//----------------------------------------------------------------------
+// Stack<T>::Stack
+// 	The constructor for the Stack class.  Note that it doesn't have a
+// 	return type.
+//
+// 	"sz" -- maximum number of elements on the Stack at any time
+//----------------------------------------------------------------------
+
+template <class T>
+Stack<T>::Stack(int sz) {
+
+    ASSERT(sz >= 1);
+
+    // Initialize the data members of the stack object.
+    size = sz;
+    top = 0;
+    stack = new T[size];   // allocate an array of integers.
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::~Stack
+// 	The destructor for the Stack class.  Just get rid of the array we
+// 	allocated in the constructor.
+//----------------------------------------------------------------------
+
+template <class T>
+Stack<T>::~Stack() {
+
+    delete [] stack;
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::Push
+// 	Put a T on the top of the stack; error on overflow.
+//
+//	"value" -- the value to put on the stack
+//----------------------------------------------------------------------
+
+
+template <class T>
+void
+Stack<T>::Push(T value) {
+    ASSERT(!Full());
+    
+    stack[top++] = value;
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::Pop
+// 	Remove a T from the top of the stack, returning its value.
+//	Error if the stack is empty.
+//----------------------------------------------------------------------
+
+template <class T>
+T
+Stack<T>::Pop() {
+
+    ASSERT(!Empty());
+    
+    return (stack[--top]);
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::Full
+// 	Return TRUE if the stack has no more room.
+//----------------------------------------------------------------------
+
+template <class T>
+bool
+Stack<T>::Full() {
+    return (top == size);
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::Empty
+// 	Return TRUE if the stack has nothing on it.
+//----------------------------------------------------------------------
+
+template <class T>
+bool
+Stack<T>::Empty() {
+    return (top == 0);
+}
+
+//----------------------------------------------------------------------
+// Stack<T>::SelfTest
+// 	Test our stack implementation by pushing 10 T's onto the 
+//	stack, and then print them as it pops them off.
+//----------------------------------------------------------------------
+
+template <class T>
+void
+Stack<T>::SelfTest(T start) {
+    T count = start;
+    
+    // Put a bunch of stuff in the stack...
+    while (!Full()) {
+	cout << "pushing " << count << "\n";
+	Push(count++);
+    }
+    
+    // ... and take it out again.
+    while (!Empty()) {
+	cout << "popping " << Pop() << "\n";
+    }
+}
+
+//----------------------------------------------------------------------
+// main
+// 	Run the test code for the stack implementation.
+//----------------------------------------------------------------------
+
+int
+main() {
+    Stack<int> *s1 = new Stack<int>(10);   
+    Stack<char> *s2 = new Stack<char>(10);   
+
+    cout << "Testing Stack<int>\n";
+    s1->SelfTest(17);
+
+    cout << "Testing Stack<char>\n";
+    s2->SelfTest('a');
+
+    delete s1;		   // always delete what you allocate
+    delete s2;		   // always delete what you allocate
+    return 0;
+}