int main() { int maxSize = 5; Deque *dq = new Deque(maxSize); dq->insert(3,1); dq->insert(4,2); dq->insert(10,1); dq->insert(20,1); dq->insert(33,2); dq->insert(333,1); dq->displayDeque(); cout << "First in deque: " << dq->getFirst() << endl; cout << "Last in deque: " << dq->getLast() << endl; cout << "Removed: "; while(!dq->isEmpty()) { cout << dq->remove(1) << " " << dq->remove(2) << " "; } cout << endl; delete dq; return 0; } // end main()
void testQuickSort(){ cout<<"***********************"<<endl; cout<<"******quick sort*******"<<endl; Deque<int> deque; deque.push_front(10); deque.push_back(3); deque.push_back(2); deque.push_front(4); deque.output(); hds::quickSort(deque.begin(),deque.end()); deque.output(); hds::quickSort(deque.begin(),deque.end(),hds::Greater<int>()); deque.output(); deque.clear(); for(int i=0;i < 20;++i){ deque.push_back(i+10); } deque.insert(deque.begin()+10,2); deque.insert(deque.begin()+2,34); deque.insert(deque.begin()+16,6); deque.insert(deque.begin()+13,78); deque.output(); hds::quickSort(deque.begin(),deque.end(),hds::Greater<int>()); deque.output(); cout<<"***********************"<<endl; }
void deal_cards (It, It2 end) { for (int i = 0; i < 5; i++) { current_hand.insert (current_hand.begin (), *end); deck_of_cards.erase (end++); } }
int main(int argc, char *argv[]) { ofstream file; int elems[] = { 1, 2, 3, 4, 5 }; /* input elements */ unordered_set<string> perms; /* permutations of input */ Deque<int> input; input.insert(elems, elems+5); file.open("output.txt"); do { Deque<int> temp; temp.insert(elems, elems+5); perms.insert(temp.str()); } while (next_permutation(elems, elems+5)); find_dequeable(perms, input); for (unordered_set<string>::iterator it = perms.begin(); it != perms.end(); ++it) file << *it << endl; file.close(); return 0; }
void exception_loop (int line /* line number in caller*/, MemberFunction mfun /* deque member function */, const char *fcall /* function call string */, int exceptions /* enabled exceptions */, Deque &deq /* container to call function on */, const Deque::iterator &it /* iterator into container */, int n /* number of elements or offset */, const UserClass *x /* pointer to an element or 0 */, const Iterator &first /* beginning of range */, const Iterator &last /* end of range to insert */, int *n_copy /* number of copy ctors */, int *n_asgn /* number of assignments */) { std::size_t throw_after = 0; // get the initial size of the container and its begin() iterator // to detect illegal changes after an exception (i.e., violations // if the strong exception guarantee) const std::size_t size = deq.size (); const Deque::const_iterator begin = deq.begin (); const Deque::const_iterator end = deq.end (); #ifdef DEFINE_REPLACEMENT_NEW_AND_DELETE rwt_free_store* const pst = rwt_get_free_store (0); #endif // DEFINE_REPLACEMENT_NEW_AND_DELETE // repeatedly call the specified member function until it returns // without throwing an exception for ( ; ; ) { // detect objects constructed but not destroyed after an exception std::size_t x_count = UserClass::count_; _RWSTD_ASSERT (n_copy); _RWSTD_ASSERT (n_asgn); *n_copy = UserClass::n_total_copy_ctor_; *n_asgn = UserClass::n_total_op_assign_; #ifndef _RWSTD_NO_EXCEPTIONS // iterate for `n=throw_after' starting at the next call to operator // new, forcing each call to throw an exception, until the insertion // finally succeeds (i.e, no exception is thrown) # ifdef DEFINE_REPLACEMENT_NEW_AND_DELETE if (exceptions & NewThrows) { *pst->throw_at_calls_ [0] = pst->new_calls_ [0] + throw_after + 1; } # endif // DEFINE_REPLACEMENT_NEW_AND_DELETE if (exceptions & CopyCtorThrows) { UserClass::copy_ctor_throw_count_ = UserClass::n_total_copy_ctor_ + throw_after; } if (exceptions & AssignmentThrows) { UserClass::op_assign_throw_count_ = UserClass::n_total_op_assign_ + throw_after; } #endif // _RWSTD_NO_EXCEPTIONS _TRY { switch (mfun) { case Assign_n: _RWSTD_ASSERT (x); deq.assign (n, *x); break; case AssignRange: deq.assign (first, last); break; case Erase_1: deq.erase (it); break; case EraseRange: { const Deque::iterator erase_end (it + n); deq.erase (it, erase_end); break; } case Insert_1: _RWSTD_ASSERT (x); deq.insert (it, *x); break; case Insert_n: _RWSTD_ASSERT (x); deq.insert (it, n, *x); break; case InsertRange: deq.insert (it, first, last); break; } } _CATCH (...) { // verify that an exception thrown from the member function // didn't cause a change in the state of the container rw_assert (deq.size () == size, 0, line, "line %d: %s: size unexpectedly changed " "from %zu to %zu after an exception", __LINE__, fcall, size, deq.size ()); rw_assert (deq.begin () == begin, 0, line, "line %d: %s: begin() unexpectedly " "changed after an exception by %td", __LINE__, fcall, deq.begin () - begin); rw_assert (deq.end () == end, 0, line, "line %d: %s: end() unexpectedly " "changed after an exception by %td", __LINE__, fcall, deq.end () - end); // count the number of objects to detect leaks x_count = UserClass::count_ - x_count; rw_assert (x_count == deq.size () - size, 0, line, "line %d: %s: leaked %zu objects after an exception", __LINE__, fcall, x_count - (deq.size () - size)); if (exceptions) { // increment to allow this call to operator new to succeed // and force the next one to fail, and try to insert again ++throw_after; } else break; continue; } // count the number of objects to detect leaks x_count = UserClass::count_ - x_count; rw_assert (x_count == deq.size () - size, 0, line, "line %d: %s: leaked %zu objects " "after a successful insertion", __LINE__, fcall, x_count - (deq.size () - size)); break; }