Advertisement
Guest User

Untitled

a guest
Aug 19th, 2019
82
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 2.55 KB | None | 0 0
  1. #include <stdlib.h>
  2. #include <iostream>
  3.  
  4. template <class T>
  5. class Queue {
  6. public:
  7. Queue(void);
  8. Queue(Queue<T>& copyQueue);
  9. bool empty(void) const;
  10. std::size_t size(void) const;
  11. void clear(void);
  12. T front(void) const;
  13. void pop(void);
  14. void push(T& item);
  15. void print(std::ostream& os);
  16. private:
  17. static const std::size_t MAX_SIZE = 50;
  18. T list[MAX_SIZE];
  19. T* frontPtr;
  20. T* backPtr;
  21. std::size_t sizeQ;
  22. };
  23.  
  24. template <class T>
  25. Queue<T>::Queue(void) {
  26. frontPtr = nullptr;
  27. backPtr = nullptr;
  28. sizeQ = 0;
  29. }
  30.  
  31. template <class T>
  32. Queue<T>::Queue(Queue<T>& copyQueue) {
  33. frontPtr = nullptr;
  34. backPtr = nullptr;
  35. sizeQ = 0;
  36. if(copyQueue.backPtr >= copyQueue.frontPtr){
  37. for(T* i = copyQueue.frontPtr; i <= copyQueue.backPtr; i++){
  38. push(*i);
  39. }
  40. }
  41. else {
  42. for(T* i = copyQueue.frontPtr; i <= (copyQueue.list + MAX_SIZE -1); i++){
  43. push(*i);
  44.  
  45. }
  46. for(T* i = copyQueue.list; i <= copyQueue.backPtr; i++) {
  47. push(*i);
  48. }
  49. }
  50. }
  51.  
  52. template <class T>
  53. bool Queue<T>::empty(void) const {
  54. return (sizeQ == 0);
  55. }
  56.  
  57. template <class T>
  58. std::size_t Queue<T>::size(void) const {
  59. return sizeQ;
  60. }
  61.  
  62.  
  63. template <class T>
  64. void Queue<T>::clear(void) {
  65. frontPtr = nullptr;
  66. backPtr = nullptr;
  67. sizeQ = 0;
  68. }
  69.  
  70. template <class T>
  71. T Queue<T>::front(void) const {
  72. if(frontPtr == nullptr) {
  73. std::cerr << "Queue is empty. No front value" << 'n';
  74. }
  75. else {
  76. return *frontPtr;
  77. }
  78. }
  79.  
  80. template <class T>
  81. void Queue<T>::pop(void) {
  82. if(sizeQ == 0) {
  83. std::cerr << "Queue is empty. Can't pop." << 'n';
  84. }
  85. else{
  86. frontPtr = list + ((frontPtr - list + 1) % MAX_SIZE);
  87. sizeQ -= 1;
  88. }
  89. }
  90.  
  91. template <class T>
  92. void Queue<T>::push(T& item) {
  93. if(sizeQ == MAX_SIZE) {
  94. std::cerr << "Queue is full. Can't push" << 'n';
  95. }
  96. else{
  97. if(sizeQ == 0) {
  98. frontPtr = backPtr = list;
  99. }
  100. else {
  101. backPtr = list + ((backPtr - list + 1) % MAX_SIZE);
  102. }
  103. *backPtr = item;
  104. sizeQ += 1;
  105. }
  106. }
  107.  
  108. template <class T>
  109. void Queue<T>::print(std::ostream& os) {
  110. if(backPtr >=frontPtr){
  111. for(T* i = frontPtr; i <= backPtr; i++){
  112. os << *i << 'n';
  113. }
  114. }
  115. else {
  116. for(T* i = frontPtr; i <= (list + MAX_SIZE -1); i++){
  117. os << *i << 'n';
  118. }
  119. for(T* i = list; i <= backPtr; i++) {
  120. os << *i << 'n';
  121. }
  122. }
  123. }
  124.  
  125. ```
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement