adding the iterator implementation code

lectures/10_linked_lists/vec.h

@@ -0,0 +1,145 @@
+template <class T>
+class vec {
+public:
+	// default constructor
+	vec(){
+		m_size = 0;
+		m_capacity = 2;
+		m_data = new T[m_capacity];
+		// std::cout << "calling default constructor" << std::endl;
+	}
+
+	// other constructor
+	vec(int number, const T& value){
+		m_size = number;
+		m_capacity = m_size * 2;
+		m_data = new T[m_capacity];
+		for(int i=0; i<m_size; ++i){
+			m_data[i] = value;
+		}
+	}
+
+	// copy constructor
+	vec(const vec& other){
+		m_size = other.m_size;
+		m_capacity = other.m_capacity;
+		m_data = new T[m_capacity];
+		for(int i=0; i<m_size; ++i){
+			m_data[i] = other.m_data[i];
+		}
+	}
+
+	// assignment operator
+	// a = b = c; a = (b = c);
+	// a = b;
+	vec& operator=(const vec& other){
+		// use this if statement here so as to avoid self-assignment.
+		if(this != &other){
+			m_size = other.m_size;
+			m_capacity = other.m_capacity;
+			m_data = new T[m_capacity];
+			for(int i=0; i<m_size; ++i){
+				m_data[i] = other.m_data[i];
+			}
+		}
+		return *this;
+	}
+
+	// destructor
+	~vec(){
+		// std::cout << "calling destructor" << std::endl;
+		delete [] m_data;
+	}
+
+	int size();
+	/*int size(){
+		return m_size;
+	}*/
+
+	T& operator[](int index){
+		return m_data[index];
+	}
+
+	void push_back(const T& element){
+		// if we have space
+		if(m_size < m_capacity){
+			m_data[m_size] = element;
+		}else{
+		// if we don't have space
+			m_capacity = m_capacity* 2;
+			T* new_data = new T[m_capacity];
+			// copy the existing elements to new location
+			for(int i=0; i<m_size; ++i){
+				new_data[i] = m_data[i];
+			}
+			new_data[m_size] = element;
+			delete [] m_data;
+			m_data = new_data;
+		}
+		m_size++;
+	}
+
+	void pop_back(){
+		m_size--;
+	}
+	// nested class
+	class iterator {
+		private:
+			T* ptr;
+		public:
+			// constructor
+			iterator(T* p){
+				ptr = p;
+			}
+			// dereference operator
+			T& operator*(){
+				return *ptr;
+			}
+			T* operator->(){
+				return ptr;
+			}
+			// pre-increment
+			iterator& operator++(){
+				++ptr;
+				return *this;
+			}
+			// post-increment
+			// special syntax here, we must write the int keyword here in the post-increment function.
+			iterator operator++(int){
+				iterator temp = *this;
+				++ptr;
+				return temp;
+			}
+			bool operator!=(const iterator& other){
+				return (ptr != other.ptr);
+			}
+	};
+	iterator begin();
+	//iterator begin(){
+		// we want to have an iterator pointing to the beginning of the vec container.
+	//	return iterator(m_data);
+	//}
+	iterator end(){
+		// we want to have an iterator pointing to the end.
+		return iterator(m_data + m_size);
+	}
+private:
+	T* m_data;
+	int m_capacity;	// whole capacity
+	int m_size;	// current size
+};
+
+// below we demonstrate that member functions can also be written outside of the templated class definition:
+
+// why we need typename here: The compiler does not automatically assume that vec<T>::iterator is a type. 
+// Instead, it first assumes that anything after :: is a member variable or function, not a type.
+// To explicitly tell the compiler that vec<T>::iterator is a type, we must use the typename keyword:
+template <class T>
+typename vec<T>::iterator vec<T>::begin(){
+	return vec<T>::iterator(m_data);
+}
+
+template <class T>
+int vec<T>::size(){
+	return m_size;
+}