Hier ist die CPP-Date, falls von interresse, das projekt besteht jetzt schon aus 5cpp und 4hpp dateien, aber es geht jetzt nur um diese eine, ich übernehme dass dann wenn nötig in die anderen.

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181

#include "satpos_tle.hpp" #include "satpos_func.hpp" #include <iostream> #include <cstdlib> #include <cstring>   /*########################################################### Funktionsname:      satpos::tle_data::tle_data Übergabewerte:      keine Rückgabewerte:      keine Erstellungsdatum:   29.10.2011 Letzte Änderung:    29.10.2011 Programmierer:      pointhi Beschreibung:       Diese Funktion initialisiert die TLE Variablen der Klasse satpos::tle_data ###########################################################*/ satpos::tle_data::tle_data() {   tle_satname[0]      = '\0';     // Name des Sateliten tle_nr              = 0;        // NORAD-Katalog-Nr.                                        ü tle_klass           = '\0';     // Klassifizierung                                          ü tle_intklass[0]     = '\0';     // Internationale Klassifizierung                           ü tle_intklass[8]     = '\0';     // Internationale Klassifizierung                           ü tle_epoche          = 0;        // Epoche mit Jahr & Tag_Nr. , Tagesbruchteil               ü tle_widspg          = 0;        // Widerstandskoeffizient im SGP-Modell tle_vwidspg         = 0;        // vernachlässigbarer Widerstandskoeffizient im SGP-Modell tle_widspg4         = 0;        // Widerstandskoeffizient im SGP4-Modell tle_eph             = 0;        // Ephemeridentyp                                           ü tle_dnr             = 0;        // laufende Datensatz-Nummer tle_prfs1           = 0;        // Prüfsumme Modulo 10                                      ü tle_prfs2           = 0;        // Prüfsumme Modulo 10 tle_ink             = 0;        // Inklination tle_rek             = 0;        // Rektaszension des aufsteigenden Knotens Ω tle_exz             = 0;        // numerische Exzentrizität der Umlaufbahn tle_per             = 0;        // Argument des Perigäums ω tle_mano            = 0;        // Mittlere Anomalie Μ tle_mbew            = 0;        // Mittlere Bewegung n tle_ulnr            = 0;        // Umlauf Nr. seit dem Start }   /*########################################################### Funktionsname:      satpos::tle::load Übergabewerte:      satpos::tle_data *twrite                     char tle_input[] Rückgabewerte:      0   ... Erfolg                     1   ... Es wurde kein TLE-Datensatz gefunden                     >1  ... Fehler Erstellungsdatum:   29.10.2011 Letzte Änderung:    29.10.2011 Programmierer:      pointhi Beschreibung:       Diese Funktion beschreibt die Klasse satpos::tle_data                     aus einer Char-Array im NORAD-Format (NASA-Format) ###########################################################*/ int satpos::tle::load(satpos::tle_data *tin_write, char tin_tlin[]) { //tin_write->tle_epoche =       06040.85138889l; int tin_pos = -1;    // Aktuelle Position in der char-Array int tin_x = 1;      // Hilfsvariable für schleifen int tin_lengh = 0; char tin_shelp[20]; int tin_ihelp=0; double tin_dhelp=0; tin_lengh = std::strcspn( tin_tlin, "\0" );   // suchen des Datensatzes   while(tin_x)     {     tin_pos = std::strcspn( tin_tlin, "1");     if(tin_pos==-1 || tin_pos > tin_lengh-138){return 1;}   // Gibt einen Fehler zurück wenn kein gültiger TLE-Datensatz gefunden wurde     else if(tin_tlin[tin_pos+1]==32 && tin_tlin[tin_pos+8]==32 && tin_tlin[tin_pos+16]==32 && tin_tlin[tin_pos+69]=='\n' && tin_tlin[tin_pos+70]=='2' && tin_tlin[tin_pos+71]==32){tin_x = 0;}     }     // NORAD-Katalog-Nr. tin_shelp = {(tin_tlin[tin_pos + 2]),(tin_tlin[tin_pos + 3]),(tin_tlin[tin_pos + 4]),(tin_tlin[tin_pos + 5]),(tin_tlin[tin_pos + 6]), '\0'}; tin_write->tle_nr           = std::atoi(tin_shelp); // Klassifizierung tin_write->tle_klass        = tin_tlin[tin_pos + 7]; // Internationale Klassifizierung tin_write->tle_intklass[0]  = tin_tlin[tin_pos + 9]; tin_write->tle_intklass[1]  = tin_tlin[tin_pos + 10]; tin_write->tle_intklass[2]  = tin_tlin[tin_pos + 11]; tin_write->tle_intklass[3]  = tin_tlin[tin_pos + 12]; tin_write->tle_intklass[4]  = tin_tlin[tin_pos + 13]; tin_write->tle_intklass[5]  = tin_tlin[tin_pos + 14]; tin_write->tle_intklass[6]  = tin_tlin[tin_pos + 15]; tin_write->tle_intklass[7]  = tin_tlin[tin_pos + 16]; tin_write->tle_intklass[7]  = '\0'; // Epoche satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 18), 13); tin_write->tle_epoche       = std::atof(tin_shelp); // Widerstandskoeffizient im SGP-Modell satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 33), 9); tin_write->tle_widspg       = std::atof(tin_shelp); // vernachlässigbarer Widerstandskoeffizient im SGP-Modell satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 44), 7); tin_ihelp = ((char)tin_tlin[tin_pos + 51])-48; tin_dhelp = 1;for(;tin_ihelp >0;tin_ihelp --){tin_dhelp *= 0.1;} tin_write->tle_vwidspg      = std::atof(tin_shelp) * tin_dhelp; // Widerstandskoeffizient im SGP4-Modell satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 52), 6); tin_shelp[0] = tin_shelp[1];tin_shelp[1] = '.'; tin_ihelp = ((char)tin_tlin[tin_pos + 60])-48; tin_dhelp = 1;for(;tin_ihelp >0;tin_ihelp --){tin_dhelp *= 0.1;} tin_write->tle_widspg4      = std::atof(tin_shelp) * tin_dhelp; // Ephemeridentyp tin_write->tle_eph          = ((char)tin_tlin[tin_pos + 62])-48; // Laufende Datensatznummer satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 64), 3); tin_write->tle_dnr          = std::atoi(tin_shelp); // Prüfsumme1 Modulo 10 tin_write->tle_prfs1        = ((char)tin_tlin[tin_pos + 68])-48;   // Inklination satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 78), 7); tin_write->tle_ink          = std::atof(tin_shelp); // Rektaszension satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 87), 7); tin_write->tle_rek          = std::atof(tin_shelp); // Exzentritität satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 95), 7); tin_shelp[0] = '.'; tin_write->tle_exz          = std::atof(tin_shelp); // Argument des Perigäums satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 104), 7); tin_write->tle_per          = std::atof(tin_shelp); // Mittlere Anomalie satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 113), 7); tin_write->tle_mano         = std::atof(tin_shelp); // Mittlere Bewegung satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 122), 10); tin_write->tle_mbew         = std::atof(tin_shelp); // Mittlere Bewegung satpos::func::strtls(tin_tlin, tin_shelp, (tin_pos + 133), 4); tin_write->tle_ulnr         = std::atof(tin_shelp); // Prüfsumme2 Modulo 10 tin_write->tle_prfs2        = ((char)tin_tlin[tin_pos + 138])-48;   std::cout << "\ntin_pos: " << tin_pos; std::cout << "\ntin_lengh: " << tin_lengh;tin_write->tle_prfs1     = ((char)tin_tlin[tin_pos + 68])-48;   // Prüfsumme1 Modulo 10 return 0; }   /*########################################################### Funktionsname:      satpos::tle::out Übergabewerte:      satpos::tle_data *tout Rückgabewerte:      0   ... Erfolg Erstellungsdatum:   29.10.2011 Letzte Änderung:    29.10.2011 Programmierer:      pointhi Beschreibung:       Diese Funktion gibt die TLE-Daten der Klasse satpos::tle_data formatiert aus. ###########################################################*/ int satpos::tle::out(satpos::tle_data *tout_out) {   // Hier beginnt die Ausgabe der Werte:     std::cout << "\n-------------------------------------------------------------------\n"; std::cout << "\tTLE-Datensatz:\t" << tout_out->tle_satname << std::fixed; std::cout << "\n-------------------------------------------------------------------\n";; std::cout << "\nNORAD-Katalog-Nr.:\t\t\t"               << tout_out->tle_nr; std::cout << "\nKlassifizierung:\t\t\t"                 << tout_out->tle_klass; std::cout << "\nInternationale Bezeichnung:\t\t"        << tout_out->tle_intklass;      std::cout.precision(8); std::cout << "\nEpoche:\t\t\t\t\t"                      << tout_out->tle_epoche; std::cout << "\nWiderstandskoeffizent SPG-Modell:\t"    << tout_out->tle_widspg;        std::cout.precision(9); std::cout << "\nv. Widerstandskoeffizent SPG-Modell:\t" << tout_out->tle_vwidspg; std::cout << "\nWiderstandskoeffizent SPG4-Modell:\t"   << tout_out->tle_widspg4; std::cout << "\nEphemeridentyp:\t\t\t\t"                << tout_out->tle_eph; std::cout << "\nLaufende Datensatz-Nr.:\t\t\t"          << tout_out->tle_dnr;           std::cout.precision(4); std::cout << "\nInklination:\t\t\t\t"                   << tout_out->tle_ink; std::cout << "\nRektaszension:\t\t\t\t"                 << tout_out->tle_rek;           std::cout.precision(7); std::cout << "\nExzentrizitaet:\t\t\t\t"                << tout_out->tle_exz;           std::cout.precision(4); std::cout << "\nArgument des Perigaeums:\t\t"           << tout_out->tle_per; std::cout << "\nMittlere Anomalie:\t\t\t"               << tout_out->tle_mano;          std::cout.precision(8); std::cout << "\nMittlere Bewegung:\t\t\t"               << tout_out->tle_mbew; std::cout << "\nUmlauf Nr. seit dem Start:\t\t"         << tout_out->tle_ulnr; std::cout << "\nPruefsumme1 Modulo 10:\t\t\t"           << tout_out->tle_prfs1; std::cout << "\nPruefsumme2 Modulo 10:\t\t\t"           << tout_out->tle_prfs2;   std::cout << "\n-------------------------------------------------------------------" << std::endl; return 0;   // Melde Erfolg zurück }

mfg. pointhi

Hi.

Wenn du nur erbst weil du auf geschützte bzw. private Attribute zugreifen willst ist das vom Design mies.

Entweder du verwendest friend Deklarationen oder du definierst Getter wie es bei OOP üblich ist, oder beides (geschützte Getter und friend class).

\edit: Namensräume solltest du nicht bei der Definition von Methoden einer Klasse angeben, sondern so:

Code cpp:

1 2 3 4 5

namespace satpos {   int tle::load(satpos::tle_data *tin_write, char tin_tlin[]) {   ... }

\edit2:

Zitat von pointhi

Gehört jetzt nicht zum Thema, aber:

Um die TLE-Daten von einem Textfile in die richtigen Variablen zu schreiben benötige ich einen speziellen Befehl, um auch nicht standard TLE-Dateien einlesen zu können.

Es handelt sich um einem Befehl der ein bestimmtes zeichen ab einer bestimmten position sucht. Als rückgabewert benötige ich dann die position, wenn das zeichen gefunden wurde. Wisst ihr wie die funktion heißt? std::strcspn hat leider keinen übergabewert für die niedrigste zeilennummer und gefunden hab ich auch nichts das so funktioniert.

Gibt es auch nicht. Du mußt schon die Datei selbst zeilenweise durchsuchen.

Gruß

Namensräume solltest du nicht bei der Definition von Methoden einer Klasse angeben, sondern so:

Warum soll ich das so machen?, ich will einfach nur bei solchen sachen eine begründung haben.
Das mit namspace, class in der header-datei hab ich von einer website übernommen wo das erklärt wurde.

Da werd ich wohl getter benutzen, jetzt mach ich einfach mal alles public, wenn man eine Bibliotek anwendet sollte man sowieso wissen was man da macht.

Ein kleines Problem habe ich noch, dabei geht es um zeiger auf zeiger. Ich hoffe mal das ist jetzt mal das letzte Problem dass ich mit Google nicht lösen konnte.

Hier der wichtige CPP-Code:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

/*########################################################### Funktionsname:      satpos::umlb::tle_to_umlb Übergabewerte:      satpos::tle_data *ttu_tlein                     satpos::umlb_data *ttu_umlbout Rückgabewerte:      0   ... Erfolg                     >0  ... Fehler Erstellungsdatum:   29.10.2011 Letzte Änderung:    29.10.2011 Programmierer:      pointhi Beschreibung:       Diese Funktion wandelt die TLE-Daten in die UMLB-Daten um ###########################################################*/ int satpos::umlb::tle_to_umlb(satpos::tle_data *ttu_tlein, satpos::umlb_data *ttu_umlbout) {   // einfaches Kopieren aller Daten die schon vorhanden sind. ttu_umlbout->umlb_epoche    =   ttu_tlein->tle_epoche;  // Epoche mit Jahr & Tag_Nr. , Tagesbruchteil ttu_umlbout->umlb_ink       =   ttu_tlein->tle_ink;     // Inklination ttu_umlbout->umlb_rek       =   ttu_tlein->tle_rek;     // Rektaszension des aufsteigenden Knotens Ω ttu_umlbout->umlb_per       =   ttu_tlein->tle_per;     // Argument des Perigäums ω ttu_umlbout->umlb_mbew      =   ttu_tlein->tle_mbew;    // Mittlere Bewegung n ttu_umlbout->umlb_exz       =   ttu_tlein->tle_exz;     // numerische Exzentrizität der Umlaufbahn ttu_umlbout->umlb_mano      =   ttu_tlein->tle_mano;    // Mittlere Anomalie Μ ttu_umlbout->umlb_widspg    =   ttu_tlein->tle_widspg;  // Widerstandskoeffizient im SGP-Modell ttu_umlbout->umlb_widspg4   =   ttu_tlein->tle_widspg4; // Widerstandskoeffizient im SGP4-Modell   // Umlaufzeit T ttu_umlbout->umlb_umlz      =   (2*M_PI)/(ttu_umlbout->umlb_mbew); //       satpos::umlb::ttu_hse(&ttu_tlein,&ttu_umlbout);   return 0; }   /*########################################################### Funktionsname:      satpos::umlb::ttu_hse Übergabewerte:      satpos::tle_data *tuhse_tlein                     satpos::umlb_data *tuhse_umlbout Rückgabewerte:      0   ... Erfolg                     >0  ... Fehler Erstellungsdatum:   29.10.2011 Letzte Änderung:    29.10.2011 Programmierer:      pointhi Beschreibung:       Berechnen der großen und kleinen Halbachse ###########################################################*/ int satpos::umlb::ttu_hse(satpos::tle_data **tuhse_tlein, satpos::umlb_data **tuhse_umlbout) {   //tuhse_umlbout->umlb_epochejr = 1; return 0; }

Ich rufe dabei die Funktion so auf:

Code cpp:

1	satpos::umlb::tle_to_umlb(&tle_track, &umlb_track);

Die berechnungen möchte ich dann in weiteren Funktionen untergliedern, wo die beiden pointer wieder übergeben werden. Es funktioniert solange ich keinen code in der

Code cpp:

1	int satpos::umlb::ttu_hse(satpos::tle_data **tuhse_tlein, satpos::umlb_data **tuhse_umlbout)

ausführe, wenn ich doch auf den pointer zugreife kommt folgende Fehlermeldung:

Code :

1	C:\Users\User\Programmieren\C++\satelitentracking\satelite_tracking\satpos\satpos_umlb.cpp|93|error: request for member 'umlb_epochejr' in '* tuhse_umlbout', which is of non-class type 'satpos::umlb_data*'|

wenn das Problem gelöst ist sollte programmtechnisch nichts mehr im wege stehen. Dann müssen nur noch die Formeln passen und alles richtig vernetzt sein.

mfg. pointhi

Hi

gibt es einen speziellen Grund, warum es ein Zweifach-Pointer sein soll?
Wenn du es mit einem einfachen machst, sollte das auch gehen.

Der Fehler ist deswegen, weil -> nur einen * auflöst.

Code cpp:

1

a->b

ist ja nur eine andere Schreibweise für

Code cpp:

1

(*a).b

Hier brauchst du aber

Code cpp:

1

(**a).b

der grund für den doppelten zeiger ist da ich so viel wie möglich mit zeigern machen möchte, kopieren dauert zeit, ist unnötig bei meiner anwendung, braucht speicher und ich muss sowieso die daten irgendwie übergeben. und wenn ich nur einen zeiger mache gibt der compiler mir eine Fehlermeldung.

Danke es funkt mit

Code cpp:

1

(**a).b

.

Jetzt sollte ich programmtechnisch alles richtig programmieren können. Fehlen nur noch die richtigen Formeln und Algorithmen.

mfg. pointhi

Mit einem einfachen Zeiger wird auch nicht mehr kopiert als mit einem doppelten
(solange es um Einzelvariablen geht, nicht Pointerarrays etc).

Du machst dir das Ganze unnötig schwer.

Zwei * "auflösen" dauert übrigens auch länger als einen.

ich übergebe aber auch keine einzel-variable sondern eine ganze klasse.

mfg. pointhi

Eine Instanz einer Klasse ist auch nur eine Variable.
Mit einer Adresse.

hab die fehlerquelle gefunden, bei einem zeiger darf ich natürlich nicht noch einmal ein & beim funktionsaufruf mitgeben.

mfg. pointhi