C ++ Best Practices für den Umgang mit vielen Konstanten und Variablen in wissenschaftlichen Codes

Ich entwickle einen Code zur Simulation des Flüssigkeitsflusses mit im Fluss vorhandenen biologischen Substanzen. Dies beinhaltet die standardmäßigen Navier-Stokes-Gleichungen, die mit einigen zusätzlichen biologischen Modellen gekoppelt sind. Es gibt viele Parameter / Konstanten.

Ich habe Funktionen geschrieben, um die Hauptberechnungen zu handhaben, aber ein Problem, das ich habe, ist die große Anzahl von Konstanten / Parametern, von denen diese Berechnungen abhängen. Es scheint umständlich, 10-20 Argumente an eine Funktion zu übergeben.

Eine Alternative besteht darin, alle Konstanten zu globalen Variablen zu machen, aber ich weiß, dass dies in C ++ verpönt ist.

Wie werden normalerweise viele Eingaben für eine Funktion verarbeitet? Soll ich stattdessen eine Struktur erstellen und diese übergeben?

Vielen Dank

Wenn Sie Konstanten haben, die sich vor dem Ausführen nicht ändern, deklarieren Sie diese in einer Header-Datei:

//constants.hpp
#ifndef PROJECT_NAME_constants_hpp
#define PROJECT_NAME_constants_hpp
namespace constants {
  constexpr double G        = 6.67408e-11;
  constexpr double M_EARTH  = 5.972e24;
  constexpr double GM_EARTH = G*M_EARTH; 
}
#endif

//main.cpp
using namespace constants;
auto f_earth = GM_EARTH*m/r/r;  //Good
auto f_earth = G*M_EARTH*m/r/r; //Also good: compiler probably does math here too

Der Grund, warum Sie dies tun möchten, besteht darin, dass der Compiler vor der Laufzeit konstante Werte berechnen kann. Dies ist gut, wenn Sie viele davon haben.

Sie können auch eine einfache Klasse verwenden, um Werte weiterzugeben:

class Params {
 public:
  double a,b,c,d;
  Params(std::string config_file_name){
    //Load configuration here
  }
};

void Foo(const Params &params) {
  ...
}

int main(int argc, char **argv){
  Params params(argv[1]);
  Foo(params);
}

Eine andere Alternative, die Ihrem Gedankengang entsprechen könnte, besteht darin, einen Namespace (oder verschachtelte Namespaces) zu verwenden, um Konstanten richtig zu gruppieren. Ein Beispiel könnte sein:

namespace constants {
   namespace earth {
      constexpr double G = 6.67408e-11;
      constexpr double Mass_Earth = 5.972e24;
      constexpr double GM = G*Mass_Earth;
   }// constant properties about Earth

   namespace fluid {
      constexpr double density = 0.999; // g/cm^3
      constexpr double dyn_viscosity = 1.6735; //mPa * s
   }// constants about fluid at 2C

   // ... 

} // end namespace for constants

Mit der oben beschriebenen Technik können Sie Referenzkonstanten in einigen gewünschten Dateien und Namespaces lokalisieren, um sie kontrollierter als globale Variablen zu machen und einige ähnliche Vorteile zu erzielen. Wenn Sie die Konstanten verwenden, ist das ganz einfach:

constexpr double G_times_2 = 2.0*constants::earth::G;

Wenn Sie lange Ketten verschachtelter Namespaces nicht mögen, können Sie die Dinge bei Bedarf jederzeit verkürzen, indem Sie einen Namespace-Alias ​​verwenden:

namespace const_earth = constants::earth;
constexpr double G_times_2 = 2.0*const_earth::G;

Eine Möglichkeit, die ich tue, ist die Verwendung von Singleton.

Wenn Sie Ihr Programm starten, initiieren Sie Ihren Singleton und füllen ihn mit den konstanten Daten (wahrscheinlich aus einer Eigenschaftendatei, die Sie für den Lauf haben). Sie erhalten dies in jeder Klasse, die Sie die Werte benötigen und verwenden Sie es einfach.