C++ und der lange steinige Weg... Einer 'ne Ahnung?

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 :)

Oha, C++ habe zuletzt in der Uni für's Physik-Diplom genutzt, das war 1995 oder so. Eigentlich würde ich heutzutage generell keine Compilersprachen mehr benutzen, es sei denn (du nennst ja gute Gründe), du brauchst das letzte Bißchen Performance und hast zudem einen leichten Hang zum Masochismus :D

Wenn du dich da wirklich reinfuxxen willst, würde ich zunächst kein IDE nutzen, sondern die klassische Route mit einem Texteditor, Makefile und die gute alte console wählen. Cygwin sollte hier unter windows alles Notwendige mitbringen (emacs, GNU make und g++).

Leider kann ich dir programmiertechnisch nicht wirklich helfen, meine Simulation lief zwar unter gnu c++, aber ich habe eigentlich nur den Complex-Datentyp benutzt.

Viele Grüße

Uwe

PS: Um Bjarne zu zitieren:

"C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off."

Na, wenn hier nicht bald unser Wolfman antwortet... ;)

Ja, ich habe schon festgestellt dass man einen guten Hang zum Masochismus braucht. Netbeans ist eigentlich bloß eine schöne Schachtel um Cygwin/ MinGW drum herum, da muss man zum Glück nicht viel fummeln um mal was complilieren zu können.
Aber bei manchen Dingen fragt man sich schon weshalb man sich so eine Grütze ausdenkt, z.B. bei den Sache mit der Breite von gewissen Datentypen. Und dann wundern wir uns warum das Ding nachher abstürzt...

Im Moment bin ich noch dabei, die Grundlagen in der Konsole zu entwickeln, d.h. ich möchte erstmal ein Modul bauen mit dem ich die Dateien lesen kann und die nötigen Berechnungen tätigen kann.
Bis dahin hoffe ich so viel Wissen im Umgang mit C++ angehäuft zu haben um mit einem GUI dieses Modul füttern zu können.

Fein, das hört sich gut an.

Wenn du wirklich Richtung GUI-Entwicklung gehen willst, würde ich Python / QT empfehlen. Prototyping geht damit rattenschnell, damit bist du auch sofort auf allen wichtigen Plattformen unterwegs und per native interface calls kannst du dein C++-Modul nativ ansprechen. Saubere Sache.

Liebe Grüße

Uwe

hmm, ich weiss nicht, warum du von deinem code nicht ueberzeugt bist. tut doch, oder nicht?
ich hab jetzt keine Ahnung wie es in dem .dat file aussieht, kann also nicht sagen, ob es bessere Ansaetze gibt.

Ich bin nur etwas erstaunt, dass du mit Qt was machst, aber den Qt Editor dann nicht weiter nutzt (fuer das obige z.B.).
Ich selber nutz zum Beispiel eclipse und mingw fuer sachen ohne GUI. Mit GUI nehm ich Qt. wxWidgets kann man nehmen, aber ist das so gut dokumentiert wie Qt?

Qt ist in C++ programmiert, also das "fast" kannst du weglassen ;)

und einen Vorschlag hab ich doch noch.
using namespace std;
macht den code lesbarer (weil du dann das std:: im rest vom file weglassen kannst)

Literatur:
Thinking in Cpp, Bruce Eckel
http://www.cplusplus.com/reference/

Cheers

Vielen Dank für eure Hilfe!

Es nimmt nun langsam Form an, nachdem ich alles noch mal umgeschmissen habe... Im Moment habe ich Urlaub, da kann ich mich solchen Sachen noch ein bisschen widmen.
Und aufräumen: C++ macht erst Spaß wenn man wirklich alles OOP- konform aufzieht und das ist für einen Neuling in der Sprache schon etwas mühsam. Irgendwann ging mir dann auf dass ich vielleicht mehrere unterschiedliche Flugzeuge habe... :wee:
Habe mir Qt angeschaut, sieht eigentlich ganz nett aus. Aber ich glaube die grafische Oberfläche wird noch mal ein langer und steiniger Weg...
Qt hat allerdings nicht alles aus C++11 und einige Features daraus wie z.B. std::array nehme ich doch sehr häufig. Aber: Bis jetzt läuft die experimentelle Unterstützung von C++11.

Mal eine ganz andere Frage: Wie ist denn der Drag Index zu behandeln? Mal angenommen, ich habe einen Drag Index von 1. Das entspricht also der F16C clean mit einer Reference area von 300ft². Wenn ich durch Stores nun einen Drag Index von 126 habe, müsste ich einen Drag von 300+126-1 = 425ft² annehmen, richtig?

Hat eh noch Zeit, ich muss erst noch eine Möglichkeit finden von einem gegebenen Auftrieb den zugehörigen AOA zu ermitteln... Das ist nicht ganz so trivial wie ich dachte. Andersherum (lift aus AOA berechnen) ist relativ entspannt. Zudem habe ich hier kein BMS zum Testen, das packt mein uralt- Laptop nicht.

Wenn Interesse besteht kann ich meinen Arbeitsstand auch hochladen- ich hätte keine Schmerzen damit ein Community Projekt draus zu machen. Am Besten habe ich immer noch durch abschauen gelernt... ;)

Drag-Index: Ich vermute eher 300*1.26=378

Weiterhin viel Erfolg beim Projekt!

Hey, das könnte Sinn ergeben... Ich glaube ich baue den Schritt mal zusammen und probiere es mal live aus wenn ich wieder zu Hause bin.