print git hash in qt as macro created at compile time

This works for me:

.pro File:
DEFINES += GIT_CURRENT_SHA1="\\\"$(shell git rev-parse HEAD)\\\""

C++ File:
std::cout << __DATE__ << " " << __TIME__ << " GIT " << GIT_CURRENT_SHA1 << "\n";

The build directory must be inside the GIT directory of the project.

Nov 2 2019 16:41:22 GIT bf2d25f47afe2c8befcfa6fefb25acbb462d43b3

Steigt das Atomgewicht mit der Ordnungszahl an? Hmmm. Lasst uns das in einem 2D Histogramm überprüfen!

        PSE pse;

        std::vector<double> ordnungszahlen;
        for(uint32_t i=1; i <= pse.nElements(); ++i) {
            ordnungszahlen.push_back(i);
        }
        acpl::HistogramAxis Xaxis("Ordnungszahl", acpl::FixBinSize{50}, acpl::makeDataIntervalClosed(ordnungszahlen));

        std::vector<double> gewicht;
        for(uint32_t ordnungszahl=1; ordnungszahl <= pse.nElements(); ++ordnungszahl) {
            gewicht.push_back(pse.atomgewicht(pse.atomByOrdnungszahl(ordnungszahl)));
        }
        acpl::HistogramAxis Yaxis("Atomgewicht", acpl::FixBinSize{20}, acpl::makeDataIntervalClosed(gewicht));

        acpl::Histogram2D hist(Xaxis, ordnungszahlen, Yaxis, gewicht);
        std::cout << hist;

Vorheriger Post: Search C++ Guns: C++ && Unicode
Vorvorherige Post: Qt && Unicode

es gibt BIG unicodes
das sind die unicodes zahlen mit mehr als 4 digits
und da gibts tolle symbole
wie z.b. die spielkarten 1 2 3... bube könig ass und so
DIE WILL ICH HABEN :D
normal leitet man ein unicode charater mit \u ein
weil wir ja alle utf8 haben brauchen wir für UTF32 halt 8 digits
damit dass der compliler check, gibt es nun auch \U
also
u8"\U0001F0A1"
HELL is near

Endlich.

ND Arrays in std C++ wir kommen

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1161r3.html

Don't forget GCC -Werror=unused-value

array[x]      // Ok
array[(x,y)]  // Ok, uses y as index/key
array[x,y]    // Deprecated, uses y as index/key

Folgender Fetzen Code gibt eine gescheite Fehlermeldung für streams (wann fixen die endlich streams & exceptions?)

    auto fileName = std::string(getenv("HOME")) + "/config/clusterprocessaccounting.dat";
    std::ofstream f(fileName);
    if(not f) throw std::system_error(errno, std::system_category(), "failed to open " + fileName + " ");

terminate called after throwing an instance of 'std::system_error'
what(): failed to open /home/ite/config/clusterprocessaccounting.dat : No such file or directory

Wir bekommen öfter mal große integer Zahlen als double gespeichert in den Daten. Beim konvertieren nach Text (andere story) mit 6 signifikanten Ziffern und wissenschaftlicher Darstellung fallen Ziffern weg. Obwohl die wissenschaftliche Darstellung mit einem Exponent bei ganzen Zahlen nicht nötig wäre.

Fingerübung: Schreibe eine Funktion die true zurück gibt, wenn die übergebene double Zahl in ein 32bit signed integer, ohne Verluste, passt.

Da es UB ist, eine zu große double Zahl einem int zuzuweisen (mit constexpr überprüft), ist die Aufgabe nicht ganz so trivial.

constexpr int xxx = std::numeric_limits<int>::max()+1.0; // error: overflow in constant expression

Noch dazu kann ein Integer mehr negative Zahlen als positive Speichern (Die Null zähl mit). Und es gibt natürlich noch Inf und Nan.
Nach drei Versuchen sieht der Code nun wie folgt aus. constexpr Test inklusive.

#include <limits>
#include <cmath>

constexpr inline bool canConvertToInt(double d) {
  if(std::isnan(d) or std::isinf(d)) return false;
  if(d > 0) {
    return d <= std::numeric_limits<int>::max() and d-int(d)==0;
  } else {
    return d >= std::numeric_limits<int>::min() and d-int(d)==0;
  }
}

  static_assert(canConvertToInt(std::numeric_limits<int>::max()-1));
  static_assert(not canConvertToInt(std::numeric_limits<int>::max()-1 + 0.5));
  static_assert(canConvertToInt(std::numeric_limits<int>::max()));
  static_assert(not canConvertToInt(std::numeric_limits<int>::max()+0.5));

  static_assert(canConvertToInt(std::numeric_limits<int>::min()+1));
  static_assert(not canConvertToInt(std::numeric_limits<int>::min()+1-0.5));
  static_assert(canConvertToInt(std::numeric_limits<int>::min()));
  static_assert(not canConvertToInt(std::numeric_limits<int>::min()-0.5));

  static_assert(not canConvertToInt(std::numeric_limits<double>::infinity()));
  static_assert(not canConvertToInt(std::numeric_limits<double>::quiet_NaN()));
  static_assert(not canConvertToInt(std::numeric_limits<double>::signaling_NaN()));
  static_assert(not canConvertToInt(std::numeric_limits<double>::denorm_min()));

Der Praxistest kann beginnen.

P1770R0: On vectors, tensors, matrices, and hypermatrices - Wirklich jeder sollte diese kurze Präsentation einmal durchschauen. Ich habe den Eindruck, als hätte mindestens ein Mensch auf der Welt Ahnung von dem Thema.

P1764R0: ssize Should be Named count - Kurz und kompakt

P0631R7: Math Constants ENDLICH!

P1768R0: Contiguous Containers Should Contain .data() - Ja

P1751R0: Numeric Type Families - Ich weiss nicht ob ich integer will die Overhead mitbringen

P1717R0: Compile­time Metaprogramming in C++ - Zu lang zum lesen jetzt

P1708R0: Simple Statistical Functions - Sehr gut! Im Kontrast zu acpl

P1709R0: Graph Data Structures - Wow, viel Stuff. Das muss ich mal mit acpl::Graph vergleichen

P1682R0: std::to_underlying for enumerations - Siehe auch std::underlying_type

P1680R0: Implementing Contracts in GCC - Nice! Unbedingt zeitnah mal ausprobieren

P1672R0: “Axiom” is a False Friend - !

P1429R2: Contracts That Work

p1744r0: Avoiding Misuse of Contract-Checking - To read

p1743r0: Contracts, Undefined Behavior, and DefensiveProgramming - To read

P1645R0: constexpr for algorithms constexpr ftw

P0037R7: Fixed-Point Real Numbers

P0267R9: A Proposal to Add 2D GraphicsRendering and Display to C++

P1467R1: Extended floating-point types 16bit floats, ARM, GPU

P1331R1: Permitting trivial default initialization in constexpr contexts

P1301R3: [[nodiscard("should have a reason")]] - Warum nicht

P1280R2: Integer Width Literals

P1068R1: Vector API for random number generation

P1050R1: Fractional Numeric Type

P1030R2:std::filesystem::path_view

P1021R4: Filling holes in Class Template Argument Deduction

P0784R6: More constexpr containers

P0533R5: constexpr for and

Mehr...
2019-06 pre-Cologne mailing available (1 of 2)
2019-06 pre-Cologne mailing available (2 of 2)

Heute mache ich die ersten Versuche mit std::filesystem und std::regex. Der GCC 8.1 ist installiert. Die Doku liegt bereit. Es kann los gehen.

std::filesystem

Ich möchte bestimmte "Müll" Dateien im Projekt Verzeichnis auflisten und ihren Speicherplatzverbrauch summieren. Die Handhabung von std::filesystem ist wirklich erstaunlich einfach. Klar strukturiert. Es funktioniert. Etwas, dass böse Zungen von std::chrono ja nicht behaupten.

Eine Schleife über alle Dateien in einem Verzeichnis geht echt fix:

#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
for(auto& p: fs::recursive_directory_iterator("/", fs::directory_options::skip_permission_denied)) {
    if(p.is_regular_file()) {
        std::cout << p.path().filename() << " " << p.file_size() << '\n';
    }
}

Bis GCC 8 muss das Projekt noch explizit mit -lstdc++fs, ab GCC 9 dann nicht mehr.

Achtung: Beim GCC 8.1 und Netzlaufwerke hab ich festgestellt, dass is_regular_file() falsche Werte zurück gibt. Im Vergleich zu fs::is_regular_file(fs::status(p)), was das selbe macht. Ob das im GCC 9.1 auch so ist, muss ich noch prüfen.

Die Fehlerbehandlung ist auch nett gelöst. Man hat diesmal die Auswahl zwischen Exception und Error Code. Viele Funktionen kann ein error_eode Objekt übergeben werden (als Referenz nicht als Pointer woohoo!).

std::error_code ec;
for(auto& p: fs::recursive_directory_iterator("/", fs::directory_options::skip_permission_denied, ec)) {
if(e) {
    std::cout << e.message();

Oder mit Exception.

try {            
    if(fs::is_regular_file(fs::status(p))) {
    }
catch(fs::filesystem_error& err) {
    std::cerr << err.what() << "\n";
}

Als keiner Bonus hier meine std::filesystem::file_type ostream Funktion

std::ostream& operator<<(std::ostream& s, const std::filesystem::file_type type) {
    using std::filesystem::file_type;
    switch (type) {
    case file_type::none:      s << "none"; break;
    case file_type::not_found: s << "not_found"; break;
    case file_type::regular:   s << "regular"; break;
    case file_type::directory: s << "directory"; break;
    case file_type::symlink:   s << "symlink"; break;
    case file_type::block:     s << "block"; break;
    case file_type::character: s << "character"; break;
    case file_type::fifo:      s << "fifo"; break;
    case file_type::socket:    s << "socket"; break;
    case file_type::unknown:   s << "unknown"; break;
    }
    return s;
}

std::regex

Regex ist auch garnicht sooo schwer, wenn man es mal kann. Ich möchte alle Dateien dieser Form finden: dbg_0000 dbg_0001 u.s.w. Das passende Regex Objekt sieht dann so aus:

const std::regex dbg_regex("dbg_[[:digit:]]+");

for(auto& p: fs::recursive_directory_iterator("/", fs::directory_options::skip_permission_denied)) {
    if(p.is_regular_file()) {
       if(std::regex_match(p.path().filename().c_str(), dbg_regex)) {
           // found
       }
    }
}

Als Verbindung zwischen Dateiname und Regex dient C-String. Da es string_view hier (noch?) nicht gibt.