Move to C++17 from C++14

* Use std::string_view where appropriate
* Utilize move to string_view to make tokenizer constexpr
* Use std::gcd to simplify RationalNumbers as they are computed
* Enable fuzz testing
* Fix empty string parsing bug
* Utilize [[nodiscard]] and [[maybe_unused]]

TODO:

* Add error handling for bad parse cases

Author: lefticus

CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.21)
 
 # Only set the cxx_standard if it is not set by someone else
 if (NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 14)
+  set(CMAKE_CXX_STANDARD 17)
 endif()
 
 # strongly encouraged to enable this globally to avoid conflicts between

fuzz_test/CMakeLists.txt

@@ -8,7 +8,7 @@ target_link_libraries(
   fuzz_tester
   PRIVATE infiz_options
           infiz_warnings
-          fmt::fmt
+          libinfiz
           -coverage
           -fsanitize=fuzzer)
 target_compile_options(fuzz_tester PRIVATE -fsanitize=fuzzer)

fuzz_test/fuzz_tester.cpp

@@ -1,22 +1,11 @@
-#include <fmt/format.h>
-#include <iterator>
-#include <utility>
 
-[[nodiscard]] auto sum_values(const uint8_t *Data, size_t Size)
-{
-  constexpr auto scale = 1000;
-
-  int value = 0;
-  for (std::size_t offset = 0; offset < Size; ++offset) {
-    value += static_cast<int>(*std::next(Data, static_cast<long>(offset))) * scale;
-  }
-  return value;
-}
+#include "../src/libinfiz/Evaluator.hpp"
+#include <cstdint>
 
 // Fuzzer that attempts to invoke undefined behavior for signed integer overflow
 // cppcheck-suppress unusedFunction symbolName=LLVMFuzzerTestOneInput
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
+extern "C" auto LLVMFuzzerTestOneInput(const std::uint8_t *Data, std::size_t Size) -> int
 {
-  fmt::print("Value sum: {}, len{}\n", sum_values(Data, Size), Size);
+  [[maybe_unused]] const auto result = evaluate(std::string_view(reinterpret_cast<const char *>(Data), Size));// NOLINT
   return 0;
 }

src/infiz/infiz.cpp

@@ -14,8 +14,7 @@ auto main(int /*argc*/, char * /*args*/[]) -> int
   std::cin.getline(input.data(), max_line - 1, '\n');
 
   while (std::cin.good()) {
-    StringTokenizer tokenizer(input.data());
-    const auto answer = evaluateExpression(tokenizer);
+    const auto answer = evaluate(input.data());
     std::cout << "answer: ";
 
     if (answer.getDenominator() == 1) {

src/libinfiz/CMakeLists.txt

@@ -3,7 +3,7 @@ include(GenerateExportHeader)
 
 add_library(libinfiz
         Evaluator.cpp
-        StringTokenizer.cpp)
+)
 
 
 

src/libinfiz/Evaluator.cpp

@@ -1,7 +1,6 @@
 
 #include "Evaluator.hpp"
-#include <cstdlib>
-
+#include <charconv>
 
 constexpr auto precedence(Operators input) noexcept -> int
 {
@@ -123,7 +122,9 @@ auto evaluateExpression(StringTokenizer &tokenizer) -> RationalNumber
 
       default:
         operation = false;
-        numbers.emplace(atoi(next.c_str()), 1);// NOLINT
+        int parsed= 0;
+        std::from_chars(next.begin(), next.end(), parsed);
+        numbers.emplace(parsed, 1);
         break;
       }
 
@@ -155,3 +156,9 @@ auto evaluateExpression(StringTokenizer &tokenizer) -> RationalNumber
     return { 0, 0 };
   }
 }
+
+auto evaluate(std::string_view input) -> RationalNumber
+{
+  StringTokenizer tokenizer(input);
+  return evaluateExpression(tokenizer);
+}

src/libinfiz/Evaluator.hpp

@@ -4,11 +4,12 @@
 #include "RationalNumber.hpp"
 #include "Stack.hpp"
 #include "StringTokenizer.hpp"
+#include <string_view>
 
 enum struct Operators { PLUS_SIGN, CLOSE_PAREN, OPEN_PAREN, MINUS_SIGN, DIVIDE_SIGN, MULTIPLY_SIGN };
 
 
-auto evaluateExpression(StringTokenizer &tokenizer) -> RationalNumber;
-void evaluateStacks(Stack<RationalNumber> &numbers, Stack<Operators> &operators);
+[[nodiscard]] auto evaluate(std::string_view input) -> RationalNumber;
+
 
 #endif

src/libinfiz/RationalNumber.hpp

@@ -2,6 +2,7 @@
 #define INFIZ_RATIONAL_NUMBER_H
 
 // RationalNumber.h
+#include <numeric>
 
 /**
  * A Class that stores the numerator and denominator
@@ -15,40 +16,46 @@ class RationalNumber
     : numerator(num), denominator(den)
   {}
 
-  constexpr auto operator/(const RationalNumber &rhs) const noexcept -> RationalNumber
+  [[nodiscard]] constexpr auto simplify() const noexcept -> RationalNumber
   {
-    return { numerator * rhs.getDenominator(), denominator * rhs.getNumerator() };
+    const auto gcd = std::gcd(numerator, denominator);
+    return {numerator / gcd, denominator / gcd};
   }
 
-  constexpr auto operator*(const RationalNumber &rhs) const noexcept -> RationalNumber
+  [[nodiscard]] constexpr auto operator/(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
-    return { numerator * rhs.getNumerator(), denominator * rhs.getDenominator() };
+    return RationalNumber{ numerator * rhs.getDenominator(), denominator * rhs.getNumerator() }.simplify();
   }
 
-  constexpr auto operator+(const RationalNumber &rhs) const noexcept -> RationalNumber
+  [[nodiscard]] constexpr auto operator*(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
-    return { numerator * rhs.getDenominator() + (rhs.getNumerator() * denominator),
-      denominator * rhs.getDenominator() };
+    return RationalNumber{ numerator * rhs.getNumerator(), denominator * rhs.getDenominator() }.simplify();
   }
 
-  constexpr auto operator-(const RationalNumber &rhs) const noexcept -> RationalNumber
+  [[nodiscard]] constexpr auto operator+(const RationalNumber &rhs) const noexcept -> RationalNumber
   {
-    return { numerator * rhs.getDenominator() - (rhs.getNumerator() * denominator),
-      denominator * rhs.getDenominator() };
+    return RationalNumber{ numerator * rhs.getDenominator() + (rhs.getNumerator() * denominator),
+      denominator * rhs.getDenominator() }.simplify();
   }
 
-  constexpr auto getDenominator() const noexcept -> int { return denominator; }
+  [[nodiscard]] constexpr auto operator-(const RationalNumber &rhs) const noexcept -> RationalNumber
+  {
+    return RationalNumber{ numerator * rhs.getDenominator() - (rhs.getNumerator() * denominator),
+      denominator * rhs.getDenominator() }.simplify();
+  }
+
+  [[nodiscard]] constexpr auto getDenominator() const noexcept -> int { return denominator; }
 
-  constexpr auto operator-() const -> RationalNumber { return { numerator * -1, denominator }; }
+  [[nodiscard]] constexpr auto operator-() const -> RationalNumber { return { numerator * -1, denominator }; }
 
-  constexpr auto getNumerator() const noexcept -> int { return numerator; }
+  [[nodiscard]] constexpr auto getNumerator() const noexcept -> int { return numerator; }
 
-  constexpr auto getFloat() const noexcept -> float
+  [[nodiscard]] constexpr auto getFloat() const noexcept -> float
   {
     return ((static_cast<float>(numerator)) / (static_cast<float>(denominator)));
   }
 
-  constexpr auto operator==(const RationalNumber &rhs) const noexcept -> bool {
+  [[nodiscard]] constexpr auto operator==(const RationalNumber &rhs) const noexcept -> bool {
     return numerator == rhs.numerator && denominator == rhs.denominator;
   }
 

src/libinfiz/Stack.hpp

@@ -17,7 +17,7 @@ template<typename Contained> class Stack
 public:
   Stack() = default;
 
-  auto empty() const noexcept -> bool { return data.empty(); }
+  [[nodiscard]] auto empty() const noexcept -> bool { return data.empty(); }
 
   auto pop() -> Contained
   {
@@ -36,7 +36,7 @@ template<typename Contained> class Stack
 
   void push(const Contained &newElem) { data.push_back(newElem); }
 
-  auto peek() const -> const Contained *
+  [[nodiscard]] auto peek() const -> const Contained *
   {
     if (data.empty()) {
       return nullptr;