Delete flags and rename variables

Author: eagerbeaver04

CMakeLists.txt

@@ -9,7 +9,5 @@ project ("Calculator")
 add_executable (Calculator "Calculator.cpp" "Calculator.h" "Operator.h" "Loader.h" "Loader.cpp" "Operations.h" "Operations.cpp" "Parser.h" "Parser.cpp")
 
 
-configure_file(${PROJECT_SOURCE_DIR}/plugins/DynamicLib4.dll ${PROJECT_BINARY_DIR}/plugins/DynamicLib4.dll COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/plugins/DynamicLib5.dll ${PROJECT_BINARY_DIR}/plugins/DynamicLib5.dll COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/plugins/DynamicLib6.dll ${PROJECT_BINARY_DIR}/plugins/DynamicLib6.dll COPYONLY)
+file(COPY "${PROJECT_SOURCE_DIR}/plugins" DESTINATION "${CMAKE_BINARY_DIR}")
 # TODO: Добавьте тесты и целевые объекты, если это необходимо.

Calculator.h

@@ -1,5 +1,4 @@
-#ifndef CALCULATOR_H
-#define CALCULATOR_H
+#pragma once
 
 #include "Parser.h"
 
@@ -10,28 +9,20 @@ class Calculator
 	std::string input;
 	std::string output;
 
-
 public:
 	Calculator(const std::string& folder, const std::string& extension) : 
 		parser(std::make_unique<Parser>(folder, extension)), input(""), output("") {};
 
 	~Calculator() = default;
-	Calculator() = default;
-	Calculator(const Calculator&) = default;
-	Calculator(Calculator&&) = default;
-	Calculator& operator=(Calculator const&) = default;
-	Calculator& operator=(Calculator&&) = default;
 
-	void setInput(const std::string& input)
+	void setInput(const std::string& input_)
 	{
-		this->input = input;
+		input = input_;
 	}
 	void calculation()
 	{
-		if (this->parser->shuntingYard(this->input, this->output))
-			this->parser->executionOrder(this->output);
+		if (parser->parse(this->input, this->output))
+			parser->evaluate(this->output);
 	}
 
 };
-
-#endif

Loader.cpp

@@ -27,12 +27,14 @@ void Loader::loadDll(std::map<std::string, std::unique_ptr<Operator>>& operation
 	{
 		widecFileName = path.c_str();
 		load = LoadLibraryW(widecFileName);
-		this->libraries.push_back(load);
-
+		
 		if (load)
+		{
+			this->libraries.push_back(load);
 			getOperatorFromDll(operations, load);
+		}
 		else
-		std::cerr << "Opening dll file " << path << " failure" << std::endl;
+			std::cerr << "Opening dll file " << path << " failure" << std::endl;
 	}
 
 }

Loader.h

@@ -1,5 +1,4 @@
-#ifndef LOADER_H
-#define LOADER_H
+#pragma once
 
 #include <Windows.h>
 #include <map>
@@ -18,10 +17,6 @@ class Loader
 public:
 	Loader(const std::string& folder, const std::string& extension) : libraries({}), folder(folder), extension(extension) {};
 	Loader() = default;
-	Loader(const Loader&) = default;
-	Loader(Loader&&) = default;
-	Loader& operator=(Loader const&) = default;
-	Loader& operator=(Loader&&) = default;
 
 	~Loader()
 	{
@@ -33,5 +28,3 @@ class Loader
 	void loadDll(std::map<std::string, std::unique_ptr<Operator>>& operations, const std::string& folder, const std::string& extension);
 
 };
-
-#endif

Operations.h

@@ -1,29 +1,32 @@
-#ifndef OPERATIONS_H
-#define OPERATIONS_H
+#pragma once
 
 #include "Loader.h"
 
 class Operations
 {
+
+private:
+	std::map<std::string, std::unique_ptr<Operator>> operations;
+	Loader loader;
 public:
 	Operations()
 	{
-		this->operations["+"] = std::make_unique<Operator>("+", 1, true, 2, [](double a, double b) { return a + b; });
-		this->operations["-"] = std::make_unique<Operator>("-", 1, true, 2, [](double a, double b) { return a - b; });
-		this->operations["*"] = std::make_unique<Operator>("*", 2, true, 2, [](double a, double b) { return a * b; });
-		this->operations["/"] = std::make_unique<Operator>("/", 2, true, 2, [](double a, double b) {
+		operations["+"] = std::make_unique<Operator>("+", 1, true, 2, [](double a, double b) { return a + b; });
+		operations["-"] = std::make_unique<Operator>("-", 1, true, 2, [](double a, double b) { return a - b; });
+		operations["*"] = std::make_unique<Operator>("*", 2, true, 2, [](double a, double b) { return a * b; });
+		operations["/"] = std::make_unique<Operator>("/", 2, true, 2, [](double a, double b) {
 			if (b)
 				return a / b;
 			std::cerr << std::endl << "Unavaliable operation: Division by zero" << std::endl;
 			return a; });
-		this->loader = Loader();
+		loader = Loader();
 	};
 	Operations(const std::string& folder, const std::string& extension) : Operations()
 	{
 		if (folder != "" && extension != "")
 		{
-			this->loader = Loader(folder, extension);
-			this->loader.loadDll(this->operations, folder, extension);
+			loader = Loader(folder, extension);
+			loader.loadDll(this->operations, folder, extension);
 		}
 		else
 			std::cerr << std::endl << "Folder for extra operations is not download" << std::endl;
@@ -40,9 +43,4 @@ class Operations
 	Operations& operator = (const Operations& A) = default;
 	Operations& operator=(Operations&&) = default;
 
-private:
-	std::map<std::string, std::unique_ptr<Operator>> operations;
-	Loader loader;
 };
-
-#endif

Operator.h

@@ -1,54 +1,46 @@
 #pragma once
-#ifndef OPERATOR_H
-#define OPERATOR_H
 
 #include <iostream>
 #include <functional>
 
 class Operator
 {
+private:
+	std::string name;
+	int priority;
+	bool associativity;// true - left, false - right
+	int binary;
+	std::function<double(double, double)> operation;
+
 public:
 	Operator(const std::string& name, int priority, bool associativity,
 		int binary, const std::function<double(double, double)>& operation)
 		: name(name), priority(priority), associativity(associativity), binary(binary), operation(operation) {};
-
-	Operator() = default;
 	~Operator() = default;
-	Operator(const Operator& A) = default;
-	Operator(Operator&&) = default;
-	Operator& operator = (const Operator& A) = default;
-	Operator& operator=(Operator&&) = default;
 
 	int getPriority()
 	{
-		return this->priority;
+		return priority;
 	}
 	std::string getName()
 	{
-		return this->name;
+		return name;
 	}
 	int getBinary()
 	{
-		return this->binary;
+		return binary;
 	}
 	bool getAssociativity()
 	{
-		return this->associativity;
+		return associativity;
 	}
 	std::function<double(double, double)> getOperation()
 	{
-		return this->operation;
+		return operation;
 	}
 	double calculation(double a, double b)
 	{
-		return (this->operation)(a, b);
+		return (operation)(a, b);
 	}
-private:
-	std::string name;
-	int priority;
-	bool associativity;// true - left, false - right
-	int binary;
-	std::function<double(double, double)> operation;
-};
 
-#endif
+};