Set Implementation Version 1

Transcription

1 Introduction to System Programming Set Implementation Version 1 Masha Nikolski, CS Department, Technion

2 1 // Version // Header file for set class. 3 // In this implementation set is a container of a limited size holding elements 4 // with no repetitions. Elements can be added to the set till it is full. 5 6 // Those two lines and the last one prevent the set header from being 7 // included more than once. 8 #ifndef _SET_H_ 9 #define _SET_H_ // We have to include iostream because we want to implement printing 12 // and scanning operators for the set class. 13 #include <iostream> // We are using those two classes and not the whole std namespace. 16 using std::ostream; 17 using std::istream; class Set { 20 // This part is accessible only by the Set class. 21 private: 22 // the size of the set 23 int dim; 24 // current number of elements in the set 25 int numelems; 26 // buffer holding set's data 27 double* buffer; // When a class has dynamically allocated memory in his fields, its usually 30 // useful to implement those two private functions. They later will be used 31 // in constructors, destructor, operator=. 32 void copy(const Set& s); 33 void clear(); // Returns the index of the element d in the buffer or -1 if not found in 36 // the set. 37 int find(const double& d) const; // This part is accessible by everyone. 40 public: // Constructor with a default parameter for set's size. 43 // Its accentual to define one if we want to allocate an array of vectors. 44 // For example: Set array[5]; 45 Set(int s = 10); // Constructor initializing the set from an array of elements. 48 Set(const double* arr, int n); // Copy constructor. 51 // It is accentual to define one since there are dynamically allocated fields 52 // in this class. 53 // Will be used for: 54 // 1. Creating set from another set: Set s1; Set s2 = s1; 55 // 2. For passing set by value to a function: func(s); 56 // 3. For returning a set by value from a function: 57 // Set f(){ return Set();} 58 Set(const Set& s); // Conversion constructors 61 // We want to be able to do: 62 // Set s; s += 7.4; 63 // Here first a conversion constructor will be called converting 7.4 to a set 64 // with one element, and then operator += will be called for s adding the 65 // element 7.4 to the set. 66 Set(const double& d); // Destructor. 69 // It is accentual to define one since there are dynamically allocated fields 70 // in this class and we need to free this memory. 71 ~Set(); // operator=

3 74 // It is accentual to define one since there are dynamically allocated fields 75 // in this class. The default operator= supplied by the compiler will simply 76 // copy the set field by field, which will be wrong in case of pointers. 77 Set& operator=(const Set& s); // Checks if an element is inside 80 bool is_in(const double& d) const; // Inserts an element 83 bool insert(const double& d); // Erases an element 86 bool erase(const double& d); // Checks if the set is full 89 bool full() const; // Checks if the set is empty 92 bool empty() const; // Erases all the elements from the set 95 void clean(); // Returns the current size of a set 98 int size() const; // Those operators return a reference to allow concatenation of 101 // operations on sets (s1 += s2) -= s3; 102 Set& operator+=(const Set& s); 103 Set& operator-=(const Set& s); // This function will be used in order to implement the comparison operators 106 // without making them friends. 107 bool compare(const Set& s) const; // This function will be used in order to implement operator<< 110 // without making it a friend. 111 void print(ostream& ost) const; // This function will be used in order to implement operator>> 114 // without making it a friend. 115 void scan(istream& ist); }; // All the following operators are global functions and there is no need 120 // to make them friends // Comparison operators 123 bool operator==(const Set& s1, const Set& s2); 124 bool operator!=(const Set& s1, const Set& s2); // I/O operators 127 ostream& operator<<(ostream& ost, const Set& s); 128 istream& operator>>(istream& ist, Set& s); // Union/Substruction 131 Set operator+(const Set& s1, const Set& s2); 132 Set operator-(const Set& s1, const Set& s2); #endif

4 1 // Version // Implementation of the set class. 3 4 // In this file NULL is defined, in C++ it is the constant 0. 5 #include <cstdlib> 6 7 #include "set.h" 8 9 void Set::copy(const Set& s) 10 { 11 dim = s.dim; 12 numelems = s.numelems; 13 buffer = new double[dim]; 14 for (int i = 0; i < numelems; i++) 15 buffer[i] = s.buffer[i]; 16 } void Set::clear() 19 { 20 if (buffer) { 21 delete[] buffer; 22 // make sure there is no garbage there, so we can always check 23 // the value of the fields later 24 buffer = NULL; 25 dim = 0; 26 numelems = 0; 27 } 28 } // Use initialization list to initialize all the fields. 31 Set::Set(int s) 32 : dim(s) 33, numelems(0) 34, buffer(new double[s]) 35 { 36 } // This is an example why the copy function is so useful. 39 Set::Set(const Set& s) 40 { 41 copy(s); 42 } Set::Set(const double& d) 45 { 46 dim = 1; 47 numelems = 1; 48 // Allocate a one double and call its constructor. 49 buffer = new double(d); 50 } Set::Set(const double* arr, int n) 53 { 54 dim = n; 55 numelems = 0; 56 buffer = new double[n]; for (int i = 0; i < n; i++) 59 insert(arr[i]); // numelems will be updated in this function 60 } // All the destructor needs to do is to call the clear function. 63 Set::~Set() 64 { 65 clear(); 66 } Set& Set::operator=(const Set& s) 69 { 70 // Check if we are not doing s = s. 71 // If we do, we can't erase ourselves, otherwise it will be a disaster! 72 if (this == &s) 73 return *this;

5 74 clear(); 75 copy(s); 76 return *this; 77 } Set& Set::operator+=(const Set& s) 80 { 81 // No need to do anything in this case, since the set holds only unique 82 // values. 83 if (this == &s) 84 return *this; Set new_set(dim + s.dim); new_set.numelems = numelems; 89 for (int i = 0; i < numelems; i++) 90 new_set.buffer[i] = buffer[i]; for (int i = 0; i < s.numelems; i++) 93 new_set.insert(s.buffer[i]); // Note that operator= will also call to clear(), 96 // hence preventing a memory leak. 97 *this = new_set; 98 return *this; 99 } // You can always implement global operator+ with method operator+= 102 Set operator+(const Set& s1, const Set& s2) 103 { 104 Set s = s1; 105 s += s2; 106 return s; 107 } Set& Set::operator-=(const Set& s) 110 { 111 // In this case just remove all the elements. 112 if (this == &s) 113 clean(); for (int i = 0; i < s.numelems; i++) 116 erase(s.buffer[i]); 117 return *this; 118 } // You can always implement global operator- with method operator-= 121 Set operator-(const Set& s1, const Set& s2) 122 { 123 Set s = s1; 124 s -= s2; 125 return s; 126 } int Set::size() const 129 { 130 return numelems; 131 } bool Set::compare(const Set& s) const 134 { 135 // for s.compare(s) case 136 if (this == &s) 137 return true; if (numelems!= s.numelems) 140 return false; for (int i = 0; i < numelems; i++) { 143 if (!is_in(s.buffer[i])) 144 return false; 145 } 146 return true;

6 147 } // You can always implement global operator== with method compare 150 bool operator==(const Set& s1, const Set& s2) 151 { 152 return s1.compare(s2); 153 } bool operator!=(const Set& s1, const Set& s2) 156 { 157 return!(s1 == s2); 158 } void Set::print(ostream& ost) const 161 { 162 ost << "( "; 163 for (int i = 0; i < numelems; i++) 164 ost << buffer[i] << " "; 165 ost << ")"; 166 } ostream& operator<<(ostream& ost, const Set& v) 169 { 170 // Here we can just use the set method print and no need to make this 171 // function a friend. 172 v.print(ost); 173 return ost; 174 } void Set::scan(istream& ist) 177 { 178 double d; while (!ist.eof() &&!full()) { 181 ist >> d; 182 insert(d); 183 } 184 } istream& operator>>(istream& ist, Set& v) 187 { 188 // Here we can just use the set method scan and no need to make this 189 // function a friend. 190 v.scan(ist); 191 return ist; 192 } bool Set::is_in(const double& d) const 196 { 197 for (int i = 0; i < numelems; i++) 198 if (buffer[i] == d) 199 return true; 200 return false; 201 } bool Set::full() const 204 { 205 return (numelems == dim); 206 } bool Set::empty() const 209 { 210 return (numelems == 0); 211 } bool Set::insert(const double& d) 214 { 215 if (!is_in(d) &&!full()) { 216 buffer[numelems++] = d; 217 return true; 218 } 219 return false;

7 220 } bool Set::erase(const double& d) 223 { 224 if (is_in(d)) { 225 int i = find(d); 226 for (int j = i; j < numelems; j++) 227 buffer[j] = buffer[j + 1]; 228 numelems--; 229 return true; 230 } 231 return false; 232 } void Set::clean() 235 { 236 numelems = 0; 237 } int Set::find(const double& d) const 240 { 241 for (int i = 0; i < numelems; i++) 242 if (buffer[i] == d) 243 return i; 244 return -1; 245 }

8 1 #include "set.h" 2 3 // Include <iostream> and not <iostream.h> (see the tutorial for explanation). 4 #include <iostream> 5 6 // Using for printing/scanning purposes. 7 using std::cout; 8 using std::endl; 9 using std::cin; int main() 12 { 13 double arr[6] = {4.8, 9.5, 8.3, 9.5, 1.2, 4.8}; Set s1; // Constructor with default size = Set s2(3); // Constructor with size = Set s3(arr, 6); cout << "s1 = " << s1 << endl; 20 cout << "s2 = " << s2 << endl; 21 cout << "s3 = " << s3 << endl; s2.insert(4.7); 24 s2.insert(8.2); 25 s2.insert(8.2); 26 s2.insert(9.3); 27 s2.insert(7.1); 28 cout << "s2 = " << s2 << endl; s1 = s2; // s1.operator=(s2) 31 cout << "s1 = " << s1 << endl; s1 = s2 + s3; // operator+(s2, s3), then s1.operator=. 34 cout << "s1 = " << s1 << endl; s3 += 6.8; // Conversion constructor Set(6.8), then s3.operator+=. 37 cout << "s3 = " << s3 << endl; Set s4 = s3; // Copy constructor. 40 cout << "s4 = " << s4 << endl; return 0; 43 // Destructors. 44 }