From 4a8e3390b9301df4681e29f9315cd314e47d54e8 Mon Sep 17 00:00:00 2001 From: KUchy Date: Thu, 5 Aug 2021 16:25:44 +0200 Subject: [PATCH] Adding all the lab files --- EOOP/Various/currency/currency.cpp | 94 ++++++++ EOOP/Various/currency/currency.hpp | 72 ++++++ EOOP/Various/node/node.cpp | 282 ++++++++++++++++++++++++ EOOP/Various/ringBuffer/ring_buffer.cpp | 161 ++++++++++++++ EOOP/Various/ringBuffer/ring_buffer.hpp | 113 ++++++++++ 5 files changed, 722 insertions(+) create mode 100755 EOOP/Various/currency/currency.cpp create mode 100755 EOOP/Various/currency/currency.hpp create mode 100755 EOOP/Various/node/node.cpp create mode 100755 EOOP/Various/ringBuffer/ring_buffer.cpp create mode 100755 EOOP/Various/ringBuffer/ring_buffer.hpp diff --git a/EOOP/Various/currency/currency.cpp b/EOOP/Various/currency/currency.cpp new file mode 100755 index 00000000..e81d6f02 --- /dev/null +++ b/EOOP/Various/currency/currency.cpp @@ -0,0 +1,94 @@ +/** + Unit tests for 2nd EOOP assignment. + + Currency - aggregate 2 doubles (monetary value, exchange rate to dollars) + CurrencyView - view the given currency with different exchange rate + (e.g. view PLN value in GBP), store the reference to the Currency. + + Note that this is in a big part "code reading" exercise. + Based on this file you should implement two classes mentioned above, + with proper interface, and in the right header file. + + Make sure that you use proper method composition in your code. + + Please make sure that you compile your solution with warnings enabled and that there are no warnings during compilation. You can do this via the following command: + g++ -Wall -Wextra -Werror -pedantic lab_2.cpp currency.hpp + */ + +#include "currency2.hpp" +#include + +int main() { + double monetary_value = 8; + double usd_exchange_rate = 0.23; + + Currency pln(monetary_value, usd_exchange_rate); + + if (pln.getValue() != 8) { + std::cerr << "Error in getValue()" << std::endl; + } + if (pln.getUSDExchangeRate() != 0.23) { + std::cerr << pln.getUSDExchangeRate() << std::endl; + std::cerr << "Error in getUSDExchangeRate()" << std::endl; + } + + pln.setValue(42); + pln.setUSDExchangeRate(0.24); + if (pln.getValue() != 42) { + std::cerr << "Error in setValue()" << std::endl; + } + if (pln.getUSDExchangeRate() != 0.24) { + std::cerr << "Error in setUSDExchangeRate()" << std::endl; + } + + Currency gbp(1336, 1.2); + Currency usd(78, 1); + + if (gbp.toDollars() != 1603.2) { + std::cerr << "Error in toDollars() 1" << std::endl; + } + if (usd.toDollars() != 78) { + std::cerr << "Error in toDollars() 2" << std::endl; + } + + gbp.setValueFromDollars(1800); + usd.setValueFromDollars(120); + pln.setValueFromDollars(180); + if (gbp.getValue() != 1500) { + std::cerr << "Error in setValueFromDollars() 1" << std::endl; + } + if (usd.getValue() != 120) { + std::cerr << "Error in setValueFromDollars() 2" << std::endl; + } + if (pln.getValue() != 750) { + std::cerr << "Error in setValueFromDollars() 3" << std::endl; + } + + + usd.addValue(gbp); + if (usd.getValue() != 1920) { + std::cerr << "Error in addValue() 1" << std::endl; + } + gbp.addValue(pln); + if (gbp.getValue() != 1650) { + std::cerr << "Error in addValue() 2" << std::endl; + } + pln.addValue(usd); + if (pln.getValue() != 8750) { + std::cerr << "Error in addValue() 3" << std::endl; + } + + + CurrencyView in_gbp(pln, 1.2); + if (in_gbp.getValue() != 1750) { + std::cerr << "Error in CurrencyView::getValue() 1" << std::endl; + } + pln.setValue(100); + if (in_gbp.getValue() != 20) { + std::cerr << "Error in CurrencyView::getValue() 2" << std::endl; + } + + + std::cerr << "End of tests." << std::endl; + return 0; +} diff --git a/EOOP/Various/currency/currency.hpp b/EOOP/Various/currency/currency.hpp new file mode 100755 index 00000000..9d802a8f --- /dev/null +++ b/EOOP/Various/currency/currency.hpp @@ -0,0 +1,72 @@ +#include + + +class Currency +{ + private: + double monetary_value; + double usd_exchange_rate; + public: + Currency() + { + monetary_value = 0; + usd_exchange_rate = 1; + } + + Currency(double value, double rate) + { + monetary_value = value; + usd_exchange_rate = rate; + } + + double getValue() const { return monetary_value; }; + + double getUSDExchangeRate() const { return usd_exchange_rate; }; + + void setValue(double value) + { + monetary_value = value; + return; + }; + + void setUSDExchangeRate(double rate) + { + usd_exchange_rate = rate; + return; + }; + + double toDollars() const { return monetary_value * usd_exchange_rate; }; + + void setValueFromDollars(double dollarsValue) + { + monetary_value = dollarsValue / usd_exchange_rate; + return; + } + + void addValue(Currency whichWeAdd) + { + monetary_value = (toDollars() + whichWeAdd.toDollars()) / usd_exchange_rate; + } +}; + +class CurrencyView +{ + private: + Currency& original; + double exchangeRate; + public: + CurrencyView(Currency& og, double rate); + + double getValue() const; +}; + +CurrencyView::CurrencyView(Currency& reference, double rate) : original(reference) +{ + exchangeRate = rate; +} + +double CurrencyView::getValue() const +{ + return original.toDollars() / exchangeRate; +} + diff --git a/EOOP/Various/node/node.cpp b/EOOP/Various/node/node.cpp new file mode 100755 index 00000000..7d225465 --- /dev/null +++ b/EOOP/Various/node/node.cpp @@ -0,0 +1,282 @@ +#include + +struct list_node +{ + int value; + list_node *next; + + list_node(int v, list_node* nxt = nullptr) + { + value = v; + next = nxt; + } +}; + +class list +{ + list_node *head; + int listSize; +public: + list() + { + head = nullptr; + listSize = 0; + } + bool is_empty() const; + int size() const; + void push_front(int val); + void pop_front(); + void clear(); + // removes first occurence of `val` in the list + // returns true if removal occured + bool remove(int val); + list_node *get_head(); + void printValues() const; +}; + +bool list::is_empty() const +{ + return head == nullptr; +} + +int list::size() const +{ + return listSize; +} + +void list::push_front(int val) +{ + list_node *pNewNode = new list_node(val); + pNewNode -> next = head; + head = pNewNode; + listSize++; + return; +} + +void list::pop_front() +{ + if(is_empty()) + { + std::cout << "There are no elements to be popped!" << std::endl; + return; + } + + list_node *pTemp = head; + pTemp = pTemp -> next; + delete head; + head = pTemp; + listSize--; + return; +} + +void list::printValues() const +{ + if(head == nullptr) + { + std::cout << "There are no values to be printed!" << std::endl; + return; + } + list_node *pNodes = head; + int i = 1; + while(pNodes) + { + std::cout << i << " value is: " << pNodes -> value << std::endl; + pNodes = pNodes -> next; + i++; + } + return; +} + +void list::clear() +{ + if(head == nullptr) + { + std::cout << "The list is already empty! " << std::endl; + return; + } + while(head) pop_front(); + listSize = 0; + return; +} + +bool list::remove(int val) +{ + list_node *current = head; + list_node *previous = nullptr; + bool valueFound = 0; + while (current != nullptr) + { + if(current -> value == val) + { + valueFound = 1; + break; + } + + previous = current; + current = current -> next; + } + + if(!valueFound) return false; + if(previous == nullptr) head = head -> next; // THIS ELEMENT IS FIRST ELEMENT + else previous -> next = current -> next; + delete current; + listSize--; + return true; +} + +list_node *list::get_head() +{ + return head; +} + +void printIsEmptyValue(list printedList) +{ + std::cout << "is_empty() method value: " << printedList.is_empty() << std::endl; + return; +} + +void isEmptyTest() +{ + std::cout << "TESTING is_empty() METHOD" << std::endl; + list testIsEmpty; + std::cout << "Testing for 0 elements" << std::endl; + printIsEmptyValue(testIsEmpty); + std::cout << "Testing for 1 element" << std::endl; + testIsEmpty.push_front(1); + printIsEmptyValue(testIsEmpty); + std::cout <<"Testing after deleting 1 element" << std::endl; + testIsEmpty.pop_front(); + printIsEmptyValue(testIsEmpty); + return; +} + +void printSize(list printList) +{ + std::cout << "Size of this list is: " << printList.size() << std::endl; + return; +} + +void sizeTest() +{ + std::cout << "TESTING size() METHOD" << std::endl; + list testSize; + std::cout << "Testing for empty list: " << std::endl; + printSize(testSize); + std::cout << "Testing for 1 element list: " << std::endl; + testSize.push_front(1); + printSize(testSize); + std::cout << "Testing after removing one element from 1 element list: " << std::endl; + testSize.pop_front(); + printSize(testSize); + std::cout << "Testing for 5 elements list: " << std::endl; + for(int i = 0; i < 5; i++) testSize.push_front(i); + printSize(testSize); + return; +} + +void pop_frontTest() +{ + std::cout << "TESTING pop_front() METHOD" << std::endl; + list testPopFront; + std::cout << "Trying to pop empty list" << std::endl; + testPopFront.pop_front(); + printIsEmptyValue(testPopFront); + printSize(testPopFront); + testPopFront.push_front(2137); + std::cout << "Poping one element list" << std::endl; + testPopFront.pop_front(); + printIsEmptyValue(testPopFront); + printSize(testPopFront); + std::cout << "Poping two element list" << std::endl; + testPopFront.push_front(1); + testPopFront.push_front(2); + testPopFront.pop_front(); + printIsEmptyValue(testPopFront); + printSize(testPopFront); + testPopFront.printValues(); + return; +} + + void clearTest() + { + std::cout << "TESTING clear() METHOD" << std::endl; + list testClear; + std::cout << "Trying to clear empty list: " << std::endl; + testClear.clear(); + printIsEmptyValue(testClear); + printSize(testClear); + testClear.printValues(); + std::cout << "Clearing one element list: " << std::endl; + testClear.push_front(1); + testClear.clear(); + printIsEmptyValue(testClear); + printSize(testClear); + testClear.printValues(); + std::cout << "Clearing two element list: " << std::endl; + testClear.push_front(1); + testClear.push_front(2); + testClear.clear(); + printIsEmptyValue(testClear); + printSize(testClear); + testClear.printValues(); + std::cout << "Clearing five element list: " << std::endl; + for(int i = 0; i < 5; i++) testClear.push_front(i); + testClear.clear(); + printIsEmptyValue(testClear); + printSize(testClear); + testClear.printValues(); + return; + } + + void printRemoveResult(list fromWhichRemove, int value) + { + if(fromWhichRemove.remove(value)) std::cout << "Removal of value: " << value << " Successful!" << std::endl; + else std::cout << "Removal of value: " << value << " Failed! " << std::endl; + } + + void removeTest() + { + std::cout << "TESTING remove() METHOD " << std::endl; + list testRemove; + std::cout << "Trying to remove element from empty list: " << std::endl; + printRemoveResult(testRemove, 0); + + std::cout << "Trying to remove wrong element from 1 element list: " << std::endl; + testRemove.push_front(1); + printRemoveResult(testRemove, 2); + std::cout << "Trying to remove right element from 1 element list: " << std::endl; + testRemove.push_front(1); + printRemoveResult(testRemove, 1); + + return; + + } + +void getHeadTest() +{ + list testHead; + std::cout << "Testing getHead for empty list: " << std::endl; + std::cout << "getHead value: " << testHead.get_head() << std::endl; + testHead.push_front(5); + std::cout << "Testing getHead for non empty list: " << std::endl; + std::cout << "getHead value: " << testHead.get_head() << std::endl; + return; +} + + +void runTests() +{ + isEmptyTest(); + sizeTest(); + pop_frontTest(); + clearTest(); + removeTest(); + getHeadTest(); + return; +} + +int main() +{ + runTests(); + return 0; +} diff --git a/EOOP/Various/ringBuffer/ring_buffer.cpp b/EOOP/Various/ringBuffer/ring_buffer.cpp new file mode 100755 index 00000000..075d45d8 --- /dev/null +++ b/EOOP/Various/ringBuffer/ring_buffer.cpp @@ -0,0 +1,161 @@ + + +#include "ring_buffer.hpp" +#include +#include +#include + +void error_message(const std::string& message, int value, int expected) { + std::cerr << "Error - " << message << ", got: " << value << " expected " << expected << std::endl; +} + +void error_message(const std::string& message) { + std::cerr << "Error - " << message << "!" << std::endl; +} + +void check_buffer(const RingBuffer& buffer, unsigned int expected_size, unsigned int expected_capacity) { + bool is_empty = buffer.isEmpty(); + bool is_full = buffer.isFull(); + if (expected_size == 0) { + if (!is_empty) { + error_message("buffer should be empty"); + } + if (is_full) { + error_message("buffer shouldn't be full"); + } + } else { + if (is_empty) { + error_message("buffer shouldn't be empty"); + } + if ((expected_size == expected_capacity) && !is_full) { + error_message("buffer should be full"); + } + } + unsigned int size = buffer.size(); + if (size != expected_size) { + error_message("wrong buffer size", static_cast(size), static_cast(expected_size)); + } + unsigned int capacity = buffer.capacity(); + if (capacity != expected_capacity) { + error_message("wrong buffer capacity", static_cast(capacity), static_cast(expected_capacity)); + } +} + +void check_empty_buffer() { + unsigned int capacity = 4; + RingBuffer buffer(capacity); + check_buffer(buffer, 0, capacity); +} + +void check_write_without_overwriting() { + unsigned int capacity = 6; + RingBuffer buffer(capacity); + buffer.write(7); + check_buffer(buffer, 1, capacity); + + buffer.write(42); + check_buffer(buffer, 2, capacity); +} + +void check_read_without_overwriting() { + RingBuffer buffer(3); + + buffer.write(7); + buffer.write(42); + + int read_number = buffer.read(); + if (read_number != 7) { + error_message("read", read_number, 7); + } + read_number = buffer.read(); + if (read_number != 42) { + error_message("read", read_number, 42); + } + check_buffer(buffer, 0, 3); +} + +void _check_reading_after_overwrite(RingBuffer& buffer, unsigned int capacity) { + for ( unsigned int i = 2; i <= capacity + 1; ++i ) { + int read_number = buffer.read(); + if (read_number != static_cast(i)) { + error_message("read with overwrite", read_number, static_cast(i)); + } + } + + check_buffer(buffer, 0, capacity); +} + +void check_overwriting() { + unsigned int capacity = 4; + RingBuffer buffer(capacity); + + for (unsigned int i = 0; i <= capacity + 1; ++i) { + buffer.write(static_cast(i)); + } + check_buffer(buffer, capacity, capacity); + + _check_reading_after_overwrite(buffer, capacity); +} + +void check_copy_constructor() { + unsigned int capacity = 5; + RingBuffer buffer(capacity); + + for (unsigned int i = 0; i <= capacity + 1; ++i) { + buffer.write(static_cast(i)); + } + check_buffer(buffer, capacity, capacity); + + RingBuffer copied(buffer); + + check_buffer(copied, capacity, capacity); + + _check_reading_after_overwrite(buffer, capacity); + _check_reading_after_overwrite(copied, capacity); +} + +void check_assignment_operator() { + unsigned int capacity = 5; + RingBuffer buffer(capacity); + RingBuffer other(capacity); + + for (unsigned int i = 0; i <= capacity + 1; ++i) { + buffer.write(static_cast(i)); + } + check_buffer(buffer, capacity, capacity); + check_buffer(other, 0, capacity); + + other = buffer; + check_buffer(other, capacity, capacity); + + _check_reading_after_overwrite(buffer, capacity); + _check_reading_after_overwrite(other, capacity); +} + +void check_exceptions() { + unsigned int capacity = 5; + RingBuffer buffer(capacity); + RingBuffer other(capacity - 1); + + try { + buffer.read(); + error_message("missing exception while reading from empty buffer"); + } catch(std::exception& e) { } + + try { + buffer = other; + error_message("missing exception in copy constructor"); + } catch(std::exception& e) { } +} + +int main() { + check_empty_buffer(); + check_write_without_overwriting(); + check_read_without_overwriting(); + check_overwriting(); + check_copy_constructor(); + check_assignment_operator(); + check_exceptions(); + std::cout << "End of tests." << std::endl; + return 0; +} diff --git a/EOOP/Various/ringBuffer/ring_buffer.hpp b/EOOP/Various/ringBuffer/ring_buffer.hpp new file mode 100755 index 00000000..8e7a4101 --- /dev/null +++ b/EOOP/Various/ringBuffer/ring_buffer.hpp @@ -0,0 +1,113 @@ +#ifndef RINGBUFFER_HPP +#define RINGBUFFER_HPP +#include +#include + +class RingBuffer { + public: + explicit RingBuffer(unsigned int capacity): capacity_ (capacity) + { + head_ = 0; + tail_ = 0; + size_ = 0; + overwritten = 0; + data_ = (int *)malloc(capacity_); + } + RingBuffer(const RingBuffer& other); + + RingBuffer& operator=(const RingBuffer& other) + { + if(capacity_ != other.capacity_) throw std::exception(); + head_ = other.head_; + tail_ = other.tail_; + size_ = other.size_; + overwritten = other.overwritten; + data_ = (int *)malloc(capacity_); + for(unsigned int i = 0; i < other.size_; i++) + { + data_[head_] = other.data_[head_]; + if(overwritten) + { + tail_ = (tail_ + 1) % capacity_; + size_ = capacity_ - 1; + } + head_ = (head_ + 1) % capacity_; + overwritten = (head_ == tail_); + size_++; + } + } + ~RingBuffer(); + + unsigned int size() const { return size_; } + unsigned int capacity() const { return capacity_; } + bool isEmpty() const { return size_ == 0; } + bool isFull() const { return size_ == capacity_; } + + int& read(); + + void write(int value); + + private: + const unsigned int capacity_; + unsigned int size_; + unsigned int head_; + unsigned int tail_; + int* data_; + bool overwritten; +}; + +RingBuffer::~RingBuffer() +{ + if(data_) + { + delete data_; + data_ = nullptr; + } +} + +void RingBuffer::write(int value) +{ + data_[head_] = value; + if(overwritten) + { + tail_ = (tail_ + 1) % capacity_; + size_ = capacity_ - 1; + } + head_ = (head_ + 1) % capacity_; + overwritten = (head_ == tail_); + size_++; +} + +int& RingBuffer::read() +{ + if(size_ == 0) throw std::exception(); + + int& answer = data_[tail_]; + overwritten = false; + tail_ = (tail_ + 1) % capacity_; + size_--; + return answer; +} + +RingBuffer::RingBuffer(const RingBuffer& other): capacity_ (other.capacity_) +{ + head_ = other.head_; + tail_ = other.tail_; + size_ = other.size_; + overwritten = other.overwritten; + data_ = (int *)malloc(capacity_); + for(unsigned int i = 0; i < other.size_; i++) + { + data_[head_] = other.data_[head_]; + if(overwritten) + { + tail_ = (tail_ + 1) % capacity_; + size_ = capacity_ - 1; + } + head_ = (head_ + 1) % capacity_; + overwritten = (head_ == tail_); + size_++; + } +} + +#endif // RINGBUFFER_HPP