From 6659fcdf9bfeaa27fd2102b7141b465594074906 Mon Sep 17 00:00:00 2001 From: Jidong Xiao Date: Mon, 5 Feb 2024 23:19:56 -0500 Subject: [PATCH] remove typedef, m_alloc to capacity --- labs/05_vectors/test_vec.cpp | 4 +-- labs/05_vectors/vec.h | 53 ++++++++++++++++++------------------ 2 files changed, 28 insertions(+), 29 deletions(-) diff --git a/labs/05_vectors/test_vec.cpp b/labs/05_vectors/test_vec.cpp index 2777add..762f0ed 100644 --- a/labs/05_vectors/test_vec.cpp +++ b/labs/05_vectors/test_vec.cpp @@ -9,7 +9,7 @@ int main() { // --------------------------------------------------- // initialize v1 with 10 values... the multiples of 5 Vec v1( 10, 0 ); - Vec::size_type i; + int i; for ( i = 0; i < v1.size(); i++) { v1[i] = 5 * i; } @@ -84,7 +84,7 @@ int main() { for ( i = 0; i<5; ++i ) z.push_back( sqrt( double(10*(i+1)) )); cout << "Contents of vector z: "; - for ( Vec::size_type j = 0; j < z.size(); j++ ) + for (int j = 0; j < z.size(); j++ ) cout << " " << z[j]; cout << endl; diff --git a/labs/05_vectors/vec.h b/labs/05_vectors/vec.h index 529aabf..255d0aa 100644 --- a/labs/05_vectors/vec.h +++ b/labs/05_vectors/vec.h @@ -2,7 +2,7 @@ #define Vec_h_ // Simple implementation of the vector class, revised from Koenig and Moo. This // class is implemented using a dynamically allocated array (of templated type T). -// We ensure that that m_size is always <= m_alloc and when a push_back or resize +// We ensure that that m_size is always <= capacity and when a push_back or resize // call would violate this condition, the data is copied to a larger array. template class Vec { @@ -11,24 +11,23 @@ public: // TYPEDEFS typedef T* iterator; typedef const T* const_iterator; - typedef unsigned int size_type; // CONSTRUCTORS, ASSIGNMNENT OPERATOR, & DESTRUCTOR Vec() { this->create(); } - Vec(size_type n, const T& t = T()) { this->create(n, t); } + Vec(int n, const T& t = T()) { this->create(n, t); } Vec(const Vec& v) { copy(v); } Vec& operator=(const Vec& v); ~Vec() { delete [] m_data; } // MEMBER FUNCTIONS AND OTHER OPERATORS - T& operator[] (size_type i) { return m_data[i]; } - const T& operator[] (size_type i) const { return m_data[i]; } + T& operator[] (int i) { return m_data[i]; } + const T& operator[] (int i) const { return m_data[i]; } void push_back(const T& t); iterator erase(iterator p); - void resize(size_type n, const T& fill_in_value = T()); + void resize(int n, const T& fill_in_value = T()); void clear() { delete [] m_data; create(); } bool empty() const { return m_size == 0; } - size_type size() const { return m_size; } + int size() const { return m_size; } // ITERATOR OPERATIONS iterator begin() { return m_data; } @@ -39,25 +38,25 @@ public: private: // PRIVATE MEMBER FUNCTIONS void create(); - void create(size_type n, const T& val); + void create(int n, const T& val); void copy(const Vec& v); // REPRESENTATION T* m_data; // Pointer to first location in the allocated array - size_type m_size; // Number of elements stored in the vector - size_type m_alloc; // Number of array locations allocated, m_size <= m_alloc + int m_size; // Number of elements stored in the vector + int capacity; // Number of array locations allocated, m_size <= capacity }; // Create an empty vector (null pointers everywhere). template void Vec::create() { m_data = NULL; - m_size = m_alloc = 0; // No memory allocated yet + m_size = capacity = 0; // No memory allocated yet } // Create a vector with size n, each location having the given value -template void Vec::create(size_type n, const T& val) { +template void Vec::create(int n, const T& val) { m_data = new T[n]; - m_size = m_alloc = n; + m_size = capacity = n; for (T* p = m_data; p != m_data + m_size; ++p) *p = val; } @@ -73,27 +72,27 @@ template Vec& Vec::operator=(const Vec& v) { // Create the vector as a copy of the given vector. template void Vec::copy(const Vec& v) { - this->m_alloc = v.m_alloc; + this->capacity = v.capacity; this->m_size = v.m_size; - this->m_data = new T[this->m_alloc]; + this->m_data = new T[this->capacity]; // Copy the data - for (size_type i = 0; i < this->m_size; ++i) + for (int i = 0; i < this->m_size; ++i) this -> m_data[ i ] = v.m_data[ i ]; } // Add an element to the end, resize if necesssary. template void Vec::push_back(const T& val) { - if (m_size == m_alloc) { + if (m_size == capacity) { // Allocate a larger array, and copy the old values // Calculate the new allocation. Make sure it is at least one. - m_alloc *= 2; - if (m_alloc < 1) m_alloc = 1; + capacity *= 2; + if (capacity < 1) capacity = 1; // Allocate and copy the old array - T* new_data = new T[ m_alloc ]; - for (size_type i=0; i typename Vec::iterator Vec::erase(iterator p) { // If n is less than or equal to the current size, just change the size. If n is // greater than the current size, the new slots must be filled in with the given value. // Re-allocation should occur only if necessary. push_back should not be used. -template void Vec::resize(size_type n, const T& fill_in_value) { +template void Vec::resize(int n, const T& fill_in_value) { if (n <= m_size) m_size = n; else { // If necessary, allocate new space and copy the old values - if (n > m_alloc) { - m_alloc = n; - T* new_data = new T[m_alloc]; - for (size_type i=0; i capacity) { + capacity = n; + T* new_data = new T[capacity]; + for (int i=0; i