Buch: Realtime C++

Arduino Fanboy D. schrieb:
> A. B. schrieb:
>> Unter welcher Umgebung compilierst du das?
> In dem Punkt ist Wilhelm steif.
> Von seinem Elfenbeintürmchen aus, interessiert ihn das Fußvolk schlicht
> nicht.

Für etwa die AVRs mit:

1

avr-gcc (GCC) 11.0.0 20200818 (experimental)

2

Copyright (C) 2020 Free Software Foundation, Inc.

3

This is free software; see the source for copying conditions.  There is NO

4

warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Allerdings gehört da natürlich eine libstdc++ dazu. Diese existiert 
nicht, und ich kann die Sourcen zu meiner Implementierung nicht 
öffentlich machen.

Soweit, so schlecht.
Doch, Leute, worum geht es hier? Erstmal um std::array<>. Dafür finden 
sich zahlreiche Implementierungen im Netz oder man schaut einfach in die 
libstdc++ des gcc.
Und so ist das mit den anderen Sachen auch. Da wäre meine 
Implementierung auch nicht mehr von Hilfe.

Allerdings lernt man doch generische Programmierung, Erstellen von 
templates und TMP nicht auf einem Arduino! Das macht man ganz normal auf 
dem PC.

Daher:

1

gcc (GCC) 11.0.0 20201009 (experimental)

2

Copyright (C) 2020 Free Software Foundation, Inc.

3

Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es

4

gibt KEINE Garantie; auch nicht für MARKTGÄNGIGKEIT oder FÜR SPEZIELLE ZWECKE.

Und mit etwas Kreativität kann man das obige Beispiel einfach auf dem PC 
oder im Godbolt-CE laufen lassen:

1

#include <cstdint>

2

#include <array>

3

#include <algorithm>

4

#include <numeric>

5

6

namespace UC {

7

    volatile uint8_t portb;

8

}

9

10

#define PORTB UC::portb

11

12

template<size_t N>

13

using Iterations = std::integral_constant<size_t, N>;

14

15

template<typename> struct StaticFor;

16

17

template<size_t N>

18

struct StaticFor<std::integral_constant<size_t, N>> {

19

    static inline constexpr void call(const auto f) {

20

        call_impl(std::make_index_sequence<N>{}, f);

21

    }

22

private:

23

    template<size_t... II>

24

    static inline constexpr void call_impl(std::index_sequence<II...>, const auto f) {

25

        (f(II), ...);

26

    }

27

};

28

29

template<size_t N = 20>

30

class Setup {

31

    using MeinArray = std::array<uint16_t, N>;

32

    using MeinContainer = MeinArray;

33

    static inline constexpr auto a = []{

34

        MeinArray data;

35

        std::iota(std::begin(data), std::end(data), 0);

36

        return data;

37

    }();

38

    static inline constexpr auto b = []{

39

        MeinArray data;

40

        std::iota(std::begin(data), std::end(data), 0);

41

        return data;

42

    }();

43

    static inline constexpr auto c = []{

44

        MeinContainer data;

45

        std::transform(std::begin(a), std::end(a), std::begin(b), std::begin(data), 

46

                       [](const auto ai, const auto bi){return ai + bi;});

47

        return data;

48

    }();

49

public:

50

    static inline void init() {

51

        StaticFor<Iterations<20>>::call([](const auto i){

52

            PORTB = c[i];

53

        });

54

//        [&]<auto... II>(std::index_sequence<II...>) {

55

//            ((PORTB = c[II]), ...);

56

//        }(std::make_index_sequence<std::size(c)>{});

57

    }

58

};

59

60

int main() {

61

    Setup<>::init();

62

}

Arduino Fanboy D. schrieb:
> Ich danke Euch auch für diese Herabwürdigung.

Das ist doch keine Herabwürdigung von Dir. Es ist lediglich die Aussage, 
dass man das nicht auf einem Arduino richtig lernen kann. Abgesehen von 
der fehlenden libstdc++ ist es doch viel zu umständlich und völlig 
spaßbefreit.

Wilhelm M. schrieb:
....
> Das beruhigt mich. Dann habe ich wohl
> falsch verstanden.

Du musst nur das ganze lesen...

Wilhelm M. schrieb:
...
> Für etwa die AVRs mit:
> avr-gcc (GCC) 11.0.0 20200818 (experimental)
...
> Allerdings gehört da natürlich eine libstdc++ dazu.

Es macht nicht viel Sinn einen Compiler Version zu verwenden die 
"realer" kein AVR Entwickler benutzt.
...

> Allerdings lernt man doch generische Programmierung, Erstellen von
> templates und TMP nicht auf einem Arduino! Das macht man ganz normal auf
> dem PC.

Aber nicht den "embedded" Teil und auch nicht was du auf einem 
"schwachbrüstigen" MC gefälligst unterlassen solltest

...
> namespace UC {
>     volatile uint8_t portb;
> }
>
> #define PORTB UC::portb
...
>//            ((PORTB = c[II]), ...);

Das ist "embedded" an dem ganzen ...
Der Rest ist doch nur Verwirrspiel und du überzeugst keinen damit ;-)

Arduino Fanboy D. schrieb:
> Einen AVR-GCC 10.1 baue ich mir ja noch und integriere diesen in die
> Arduino IDE,  um deiner Brotkrumenspur zu folgen...
> Aber "experimental"?
> Das hat dann keine Praxisrelevanz mehr.
> Hier endet es!

Du kannst dafür genauso gut einen 10.1 nehmen. Es war die Frage, was ich 
verwende, und nicht, was man mindestens nehmen muss. Ein Blick in die 
Feature-List von cppreference lohnt sich.

Hans-Georg L. schrieb:
> Es macht nicht viel Sinn einen Compiler Version zu verwenden die
> "realer" kein AVR Entwickler benutzt.

Das ist ein Scheinargument, denn es geht ja auch mit älteren Versionen 
vom g++.

Hans-Georg L. schrieb:
> Aber nicht den "embedded" Teil und auch nicht was du auf einem
> "schwachbrüstigen" MC gefälligst unterlassen solltest

Auch das ist hier kein Argument, denn es geht um ein konkretes Beispiel. 
Und all das kann man am PC oder im GB-CE sehr schön nachvollziehen. 
Warum sollte das nur für einen AVR möglich sein?

Das Buch ist m.E. gar nicht schlecht, weist es doch in die richtige 
Richtung: compile-computation, type-reflection, meta-functions, ...

Der Nachteil des Buches liegt m.E. darin, das es zu früh erschienen ist. 
Denn ein ganz wichtiger Baustein darin fehlt, und dass sind "concepts". 
Die sind als "concepts-ts" zwar schon eine ganze Weile im g++ enthalten, 
jedoch in einer Form, die vor der Einbringung in C++20 nochmal verändert 
wurde (keine function-style concepts mehr, einige Erweiterungen). Dies 
ist zwar nicht besonders kritisch, weil es zwar die Syntax und wenige 
features betrifft, aber nicht das Grundkonzept fallen lässt. Und 
concepts sind ein wesentlicher Bestandteil der statischen Polymorphie. 
M.E. hätte der Autor darauf hinweisen müssen, denn bekannt und verfügbar 
waren concepts schon lange vor Erscheinen des Buches. Vielleicht kommt 
ja eine neue Auflage ;-)

Wilhelm M. schrieb:
> Der Nachteil des Buches liegt m.E. darin, das es zu früh erschienen ist.

Das haben Bücher auch dem Computerbereich und anderen ständig
voranschreitenden Wissensgebieten so an sich. Wenn der Autor mit der
Veröffentlichung des Buchs auf den absolut finalen C++-Standard warten
würde, könnte er davon nur wenige Exemplare verkaufen, da zu diesem
Zeitpunkt kaum noch jemand C++ nutzen wird.

Wilhelm M. schrieb:
> M.E. hätte der Autor darauf hinweisen müssen, denn bekannt und verfügbar
> waren concepts schon lange vor Erscheinen des Buches.

Warum sollte der Autor seine Leser mit neuen Features belästigen, die
noch weit von der Verabschiedung durch das Normungsgremium entfernt sind
und damit noch auf recht wackeligen Beinen stehen? Die Concepts wurden
erstmalig im Juli 2017 in den C++20-Draft aufgenommen, da hat Kormanyos
sein Buch, das im Mai 2018 veröffentlicht wurde, vermutlich schon zu 98%
fertiggestellt. Technisch finalisiert wurde der C++20-Standard Anfang
dieses Jahres (das wäre IMHO der früheste Zeitpunkt gewesen, seine
Inhalte in Lehrbücher aufzunehmen). Offiziell veröffentlicht wird er
voraussichtlich erst Ende dieses Jahres.

Natürlich gibt es immer Leute (wie bspw. du), denen das alles nicht
schnell genug geht. Diese kaufen aber keine solchen Bücher, sondern
informieren sich in den Vorabveröffentlichungen des ISO-Gremiums.
Kormanyos wäre somit ziemlich dumm, wenn er sein Buch auf diese Leute
zuschneiden würde.

> Vielleicht kommt ja eine neue Auflage ;-)

Vielleicht. Aber auch diese wird für dich viel zu spät erscheinen, da
das ISO-Gremium schon längst an an C++23 arbeitet ;-)

IJustWannaKnow schrieb:
> ne ernsthaft. meine Erfahrung in dem Gebiet reicht nicht aus um zu
> beurteilen ob das Buch gut ist.

wenn du es durch hast und keine Fragen offen sind war es gut, bis jetzt 
wurde ich aber oft enttäuscht hatte viel Geld versenkt in schlechte 
Bücher.
Das letzte C++ Buch noch nicht durchgearbeitet, ja in dem Wort steckt 
Arbeit!