Wie am besten Java in C++ Programm umwandeln?

[Lennox]

Nabend, bevor ich noch lange herumraten muss oder bei der KI nachfrage... Wie sähe das Pendant in C++ zu dieser Main-Methode in Java aus?

  private enum Symbol {
    SLEEP1,
    TARGET1,
    ACTION1,
    ACTION2
  }

  public static void main(String[] args) {
    if (args.length == 0) {
      exitApp();
    }

    long sleep = 100;
    String target1 = "127.0.0.1";

    Map<Integer, Map<Symbol, Integer>> fsm = new HashMap<>();
    fsm.put(
        0,
        Map.of(
            Symbol.SLEEP1, 1,
            Symbol.TARGET1, 2,
            Symbol.ACTION1, 3,
            Symbol.ACTION2, 3));
    fsm.put(
        1,
        Map.of(
            Symbol.TARGET1, 3,
            Symbol.ACTION1, 3,
            Symbol.ACTION2, 3));
    fsm.put(
        2,
        Map.of(
            Symbol.SLEEP1, 3,
            Symbol.ACTION1, 3,
            Symbol.ACTION2, 3));
    fsm.put(
        3,
        Map.of(
            Symbol.ACTION1, 3,
            Symbol.ACTION2, 3));
    List<Runnable> runnables = new LinkedList<>();
    int state = 0;
    for (String arg : args) {
      String[] parts = arg.split("=", 2);
      if (parts.length != 2) {
        exitApp();
      }
      String key = parts[0];
      String value = parts[1];
      switch (key) {
        case "target1" -> {
          if (!fsm.get(state).containsKey(Symbol.TARGET1)) {
            exitApp();
          }
          target1 = value;
          state = fsm.get(state).get(Symbol.TARGET1);
        }
        case "sleep" -> {
          if (!fsm.get(state).containsKey(Symbol.SLEEP1)) {
            exitApp();
          }
          sleep = checkAndParse1(value);
          state = fsm.get(state).get(Symbol.SLEEP1);
        }
        case "a", "b" -> {
          switch (key) {
            case "a" -> {
              if (!fsm.get(state).containsKey(Symbol.ACTION1)) {
                exitApp();
              }
              String finalTarget = target1;
              int finalNum = checkAndParse2(value);
              long finalSleep = sleep;
              runnables.add(() -> action1(finalTarget, finalNum));
              runnables.add(() -> action3(finalSleep));
              state = fsm.get(state).get(Symbol.ACTION1);
            }
            case "b" -> {
              if (!fsm.get(state).containsKey(Symbol.ACTION2)) {
                exitApp();
              }
              String finalTarget = target1;
              int finalNum = checkAndParse2(value);
              long finalSleep = sleep;
              runnables.add(() -> action2(finalTarget, finalNum, 1000));
              runnables.add(() -> action3(finalSleep));
              state = fsm.get(state).get(Symbol.ACTION2);
            }
            default -> exitApp();
          }
        }
        default -> exitApp();
      }
    }
    if (runnables.isEmpty()) {
      exitApp();
    }
    runnables.remove(runnables.size() - 1); // Remove last action

    // Run all actions
    runnables.forEach(Runnable::run);
  }

Vermutlich ginge es (viel) einfacher, da C++ ja Funktionspointer kennt?

[Schlangenmensch]

@Lennox Wie wäre es, wenn du es erstmal selbst versuchst?