blank

[Axon727]

blank

[thmm]

You could try and implement std::optional yourself.
An extremely simple demo.

#include <iostream>

template<class T>
class Optional
{
public:
  explicit Optional(T value): mValue(value), mHasValue(true)
  {
  }
  bool hasValue() const noexcept
  {
    return mValue;    
  }
  T getValue() noexcept
  {
      return mValue;
  }
private:
  T mValue; 
  bool mHasValue = false;
};
int main()
{
    Optional<int> oi(10);
    if(oi.hasValue())
      std::cout << "Value of oi: " << oi.getValue();
    
}

On L71 you need to replace the structural binding with std::pair

[Axon727]

If you can clarify what else to add from the demo that you've given to me? Its clear that there is more to it than just running it as it is and I'm still confused as to what to initialize, what must be considered and included, and I have no experience in implementing template classes in a while as far as I know. I'm still trying to find workarounds of the original code as it is, I'll keep your suggestion as noted.

[mbozzi]

Here is a direct backport from C++17 to C++11.

#include <deque>
#include <iostream>
#include <tuple>
#include <unordered_set>
#include <vector>

struct State;

struct Transition {
  char symbol;
  State *successor;
};

struct State {
  std::vector<State *> epsilon_transitions;
  std::vector<Transition> transitions;
  std::unordered_set<std::string> visited_strings;
};

struct Automaton {
  State *initial_state;
  State *final_state;
};

Automaton Eps() {
  Automaton c;
  c.initial_state = c.final_state = new State;
  return c;
}

Automaton Sym(char symbol) {
  Automaton c;
  c.initial_state = new State;
  c.final_state = new State;
  c.initial_state->transitions.push_back({symbol, c.final_state});
  return c;
}

Automaton Star(Automaton a) {
  Automaton c;
  c.initial_state = c.final_state = new State;
  c.final_state->epsilon_transitions.push_back(a.initial_state);
  a.final_state->epsilon_transitions.push_back(c.final_state);
  return c;
}

Automaton Cat(Automaton a, Automaton b) {
  Automaton c;
  c.initial_state = a.initial_state;
  c.final_state = b.final_state;
  a.final_state->epsilon_transitions.push_back(b.initial_state);
  return c;
}

Automaton Alt(Automaton a, Automaton b) {
  Automaton c;
  c.initial_state = new State;
  c.final_state = new State;
  c.initial_state->epsilon_transitions.push_back(a.initial_state);
  c.initial_state->epsilon_transitions.push_back(b.initial_state);
  a.final_state->epsilon_transitions.push_back(c.final_state);
  b.final_state->epsilon_transitions.push_back(c.final_state);
  return c;
}

void Enumerate(Automaton a, std::size_t size_limit = 4) // Kleene-Star operator, manages limited size to avoid infinity
{
  std::deque<std::pair<State *, std::string>> queue = {
      {a.initial_state, std::string()}};
  do {
    auto state = queue.front().first;
    auto string = queue.front().second;
    if (string.size() > size_limit) {
      std::cout << "...\n";
      break;
    }
    queue.pop_front();
    if (!state->visited_strings.insert(string).second) {
      continue;
    }
    if (state == a.final_state) {
      std::cout << "\"" << string << "\"\n";
    }
    for (State *successor : state->epsilon_transitions) {
      queue.push_front({successor, string});
    }
    for (auto transition : state->transitions) {
      auto symbol = transition.symbol;
      auto successor = transition.successor;
      queue.push_back({successor, string + std::string(1, symbol)});
    }
  } while (!queue.empty());
  std::cout << "\n";
}

#include <cctype>
#include <cstdio>
#include <istream>
#include <sstream>

char Peek(std::istream &input) {
  input >> std::ws;
  return input.peek();
}

bool Match(std::istream &input, char c) {
  if (Peek(input) == c) {
    input.get();
    return true;
  }
  return false;
}

bool ParseSymbol(std::istream &input, char& result) {
  if (std::isalpha(Peek(input))) {
    result = input.get();
    return true;
  }
  return false;
}

bool Parse(std::istream &input, Automaton& result);

bool ParsePrimitive(std::istream &input, Automaton& result) {
  char symbol;
  if (ParseSymbol(input, symbol)) {
    result = Sym(symbol);
    return true;
  }
  if (Match(input, '(')) {
    Automaton a;
    if (Parse(input, a)) {
      if (Match(input, ')')) {
        result = a;
        return true;
      }
    }
  }
  return false;
}

bool ParseFactor(std::istream &input, Automaton& result) {
  Automaton a;
  if (ParsePrimitive(input, a)) {
    if (Match(input, '*')) {
      result = Star(a);
      return true;
    }
    result = a;
    return true;
  }
  return false;
}

bool ParseTerm(std::istream &input, Automaton& result) {
  Automaton a;
  if (ParseFactor(input, a)) {
    while (Match(input, '.')) {
      Automaton b;
      if (ParseFactor(input, b)) {
        a = Cat(a, b);
      } else {
        return false;
      }
    }
    result = a;
    return true;
  }
  return false;
}

bool Parse(std::istream &input, Automaton& result) {
  Automaton a;
  if (ParseTerm(input, a)) {
    while (Match(input, '|')) {
      Automaton b;
      if (ParseTerm(input, b)) {
        a = Alt(a, b);
      } else {
        return false;
      }
    }
    result = a;
    return true;
  }
  return false;
}

bool Parse(const std::string &input, Automaton& result) {
  std::stringstream stream(input);
  Automaton a;
  if (Parse(stream, a)) {
    if (Peek(stream) == EOF) {
      result = a;
      return true;
    }
  }
  return false;
}

int main() {
  // Parse parameters won't allow number chars, how so?
  Automaton result;
  if (Parse("a", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("a|b", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("a.b", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("(a|b).c", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("(c|d).(a|b)", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("a*", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
  if (Parse("(a|b)*", result)) { Enumerate(result); } else std::cout << "Failed to parse\n";
}

[Axon727]

Your're genuinely a life-savior @mbozzi, thank you, your credentials are in place.