Hallo zusammen,

ich hatte ja schon länger vor C++ zu lernen. C++ aus folgenden Gründen:
- Beruflich programmiere ich SPS/CNC-Technik, C/C++ ist sehr hardwarenah und wir setzen Qt teilweise auf unseren Steuerungen ein was auch fast schon C++ ist.
- C++ ist plattformübergreifend
- Beruflich setze ich mich auf ein weiteres Standbein ohne nur auf SPS/CNC-Technik angewiesen zu sein
- Keine Tools programmieren zu können ist doof.

Nun denn. Als Entwicklungsumgebung habe ich NetBeans gewählt, UI möchte ich mit WxWidgets machen. Erstmal. Ob WxWidgets so eine gute Entscheidung als Neuling war wird sich zeigen. Mittlerweile habe ich festgestellt dass nicht alles unter MinGW/ NetBeans so unterstützt wird (std::vector mit .at(x) zugreifen geht z.B. trotz C++11 Deklaration nicht) und installiere gerade Visual Studio (zumindest probiere ich es, Microsoft KB2999226 möchte nicht).
Egal. C++ lernen ohne Projekt geht ja eh nicht. Also möchte ich ein kleines Tool bauen, das die FM-Dateien ausliest und mit vorgebbarem Drag und Gewicht den Spritverbrauch berechnet.
Im finalen Schritt wäre es natürlich toll, diese Daten von der Kampagne/ TE zu lesen, aber so könnte man es auch auf Falcon Online nutzen.
Außerdem möchte ich damit prüfen können ob die gewählten Parameter mit diesem Loadout überhaupt möglich sind.
Prinzipielle Idee:
1. Lesen aller Stützpunkt der FM.dat und überführen in Variablen
2. Berechnen des notwendigen Schubs (Thrust <-> Drag) und somit ermitteln der notwendigen RPM in %.
3. Berechnung des Fuel Flows basierend auf den Fuel flow breakpoints in der Dreierbeziehung Altitude<->Mach<->RPM.
4. Berechnung aller Streckenabschnitte unter der Angabe Altitude + Mach bzw. KIAS und unter Berücksichtigung bereits verbrauchten Sprits
5. Möglichkeit auf Wegpunkten Gewicht + Drag index ändern zu können (Waffeneinsatz)
Anschließend kann ich solche Sachen wie Bingo, Joker und Playtime rechnen.

Kernknackpunkt im Moment: Als C++ Neuling weiß ich nicht recht wie ich die Breakpoints alle lese. Im Moment suche ich nach einem Keyword (Fuelflow1) dann nach einer Zeilenkennzeichnung (Alt: 0), suche dann # und lese dann Stützpunkte bis # kommt.
Zur Diagnose drücke ich erstmal alles was ich lese auf std::cout raus. DataFile_as_Text ist einfach die FM.dat als std::string.

Code:
int read_breakpoints(std::string DataFile_as_Text, std::string keyword_start, std::string identifier, Breakpoints &Breakpoint){
    
       char breakpoint_string[10];
       std::size_t pos_breakpoint;
       std::size_t pos_end_of_breakpoints;
       //std::cout << DataFile_as_Text << std::endl; //include if needed
       double breakpoint_double{0.0};
       std::size_t length_breakpoint;
       std::size_t pos_fuel_flow_keyword;
       int array_count{0};
       
       /*todo
       * - Get number of breakpoints
       * - Get mach of breakpoints
       * - Store everything in C++ array
       */
       
        //get keyword position
        pos_fuel_flow_keyword = DataFile_as_Text.find(keyword_start);
       
       if(pos_fuel_flow_keyword != std::string::npos) //if keyword is found
       {
        //find first breakpoint and next "#" which marks the end
        pos_breakpoint = DataFile_as_Text.find("+",pos_fuel_flow_keyword+1);         
        pos_end_of_breakpoints = DataFile_as_Text.find("#",pos_breakpoint+1);
        //std::cout << "found first"<<keyword_start<<"breakpoint at position " << pos_breakpoint << std::endl;
          while (pos_breakpoint < pos_end_of_breakpoints) {
          //get breakpoint Positions
          //std::cout << "found"<<keyword_start<<"at position " << pos_fuel_flow_keyword << std::endl;
          //get length of first breakpoint + copy string to breakpoint_string
          length_breakpoint = DataFile_as_Text.copy(breakpoint_string,11,pos_breakpoint);
          //create a "good" string by adding \0 at the end
          breakpoint_string[length_breakpoint]='\0';
          //std::cout << "Breakpoint is " <<breakpoint_string<<std::endl;
          //convert string to double and store breakpoint
          breakpoint_double = std::stod(breakpoint_string);
          //save to array
          Breakpoint.breakpoint[array_count]= breakpoint_double;
          std::cout << "Breakpoint is " <<breakpoint_double<<std::endl;
          //increase
          array_count++;
          pos_breakpoint=pos_breakpoint+14;          
          }
       }
       else
       {
        std::cout << "\"Keyword\" not found" << std::endl;
        return(0);
       } 
        
        return(1);
Aufruf:
Code:
      
       auto Filename = ("./f16bk52.dat");
      
       //define variables
       DataFile_as_Text = read_FM_file_as_string(Filename); //read_FM_file.cpp
       //std::cout << DataFile_as_Text << std::endl; //include if needed
       int retval;
       //int count;
       std::string keyword_start="FUELFLOW1";
       std::string identifier="Alt: 0";
       
       Breakpoints Fuelflow0_breakpoints;
       
       retval = read_breakpoints(DataFile_as_Text,keyword_start,identifier,Fuelflow0_breakpoints);
       std::cout << "Breakpoint class is " <<Fuelflow0_breakpoints.breakpoint[0]<<std::endl;
Breakpoints ist eine Klasse:
Code:
class Breakpoints { 
public:
    int number_of_breakpoints;
    std::array <double,50> breakpoint;
private:
Der std::cout im Aufruf zeigt dass das Prinzip funktioniert.
Ich fürchte allerdings dass das wenig zielführend ist selbst wenn es jetzt funktioniert:
- fixe Identifier (Alt: 0) sind nicht flexibel. Damit geht es vielleicht bei der F-16 aber bei anderen geht das nicht mehr. Zeichenketten in Abhängigkeit von den gelesenen Altitude Breakpoints wären mindestens nötig, aber mir kommt es nicht wie der Königsweg vor.
- irgendwie glaube ich nicht dass die festen Zeilenbreiten so sinnig sind.

So würde es funktionieren. Erstmal. Aber ich glaube dass das was ich hier programmiert habe vom Programmierstil her unterirdisch ist. Es gibt bestimmt einen besseren Weg.

Irgendjemand irgendeine Idee?

Ehrliches Feedback wird erwünscht Vielen Dank