Forum: Compiler & IDEs avr-gcc: Warnung bei fehlendem Cast aktivieren?


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Manfred (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Wenn ich sowas schreibe, kriege ich keine Warnung. Ist das so gewollt?
for (uint8_t i = 0; i < 32; i++) {
   uint32_t mask = 1 << i;
   // ...
}

Welcher Kommandozeilenparameter muss angegeben werden, damit eine 
Warnung erscheint?

von Name (Gast)


Bewertung
-2 lesenswert
nicht lesenswert
Anders gefragt. Warum erwartest du eine Warnung?

von Name (Gast)


Bewertung
-2 lesenswert
nicht lesenswert
Lass einmal die for weg. Erwartest du auch hierbei eine Warnung?
uint32_t var = 88

von Jemand (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Name schrieb:
> Anders gefragt. Warum erwartest du eine Warnung?

Ggf. ist int nur 16 Bit groß, dann wäre der Code so fehlerhaft.

von foobar (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ist so gewollt, da mit -Wsign-conversion zu viele Meldungen kommen ;-)

von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
Name schrieb:
> Anders gefragt. Warum erwartest du eine Warnung?

Ich vermute, es geht darum, dass 1 und damit auch 1 << i vom Typ int 
ist. Man müsste eigentlich UINT32_C(1) << i schreiben. Bei einem 
32-Bit-int führt 1 << 31 zu undefiniertem Verhalten. Beim AVR ist int 
sogar nur 16 Bit breit.

: Bearbeitet durch User
von foobar (Gast)


Bewertung
0 lesenswert
nicht lesenswert
> Bei einem 32-Bit-int führt 1 << 31 zu undefiniertem Verhalten.

Ist nicht sogar jeglicher left-shift eines signed Typen undefiniert? 
Eine gcc-Warn-Option dafür ist mir aber nicht bekannt (wäre wohl noch 
unpopulärer als -Wsign-conversion ;-) ).

von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
foobar schrieb:
>> Bei einem 32-Bit-int führt 1 << 31 zu undefiniertem Verhalten.
>
> Ist nicht sogar jeglicher left-shift eines signed Typen undefiniert?

Nein, nur wenn der zu schiebende Wert negativ ist oder das Ergebnis der 
entsprechenden Multiplikation mit 2ᶦ vom Typ nicht repräsentiert werden 
kann.

: Bearbeitet durch User
von Oliver S. (oliverso)


Bewertung
0 lesenswert
nicht lesenswert
Jemand schrieb:
> Name schrieb:
>> Anders gefragt. Warum erwartest du eine Warnung?
>
> Ggf. ist int nur 16 Bit groß, dann wäre der Code so fehlerhaft.

Beim avr-gcc ist das so.

Oliver

: Bearbeitet durch User
von Manfred (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ja, int ist 16 Bit breit, daher ist der Code falsch. Da muss es doch 
eine Warnung geben...

von test (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Manfred schrieb:
> Ja, int ist 16 Bit breit, daher ist der Code falsch. Da muss es
> doch eine Warnung geben...

Da müsste der gcc aber schon sehr clever sein um hier das Problem zu 
sehen. Kann man so etwas heutzutage erwarten?

Ist eigentlich Aufgabe des Programierers derartige Probleme zu erkennen. 
D.h. wenn man mit Bits rummacht sollte man generell wissen was für 
Datentypen man da benutzt.

von Bernd K. (prof7bit)


Bewertung
2 lesenswert
nicht lesenswert
test schrieb:
> Kann man so etwas heutzutage erwarten?
>
> Ist eigentlich Aufgabe des Programierers derartige Probleme zu erkennen.

Darüber kann man gespaltener Meinung sein. Es gibt auch die Theorie 
derzufolge es das Ziel sein sollte eine Sprache (oder in Ermangelung 
einer neuen Sprache dann halt eben einen Compiler für eine existierende) 
so zu entwerfen daß der Programmierer bestimmte (möglichst viele) Arten 
von Fehlern schlichtweg einfach nicht mehr machen kann da man 
mittlerweile gelernt hat daß menschliche Programmierer zwar unglaublich 
clevere Algorithmen ersinnen können aber dennoch immer wieder so blöde 
kleine Flüchtigkeitsfehler machen.

Das resoniert auch gut mit der Utopie daß eigentlich die Maschinen dem 
Menschen dienen sollen und nicht umgekehrt.

: Bearbeitet durch User
von Manfred (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Schaut euch mal die ersten Kommentare an. Ich hatte meine Frage bewusst 
schwammig formuliert, um zu demonstrieren, wie leicht man hier den 
Fehler übersehen kann.
Der Compiler ist schon recht schlau. Wenn ich ein Array einbaue, mit 
Größe 31 und das in der Schleife befülle, kommt ja auch sofort eine 
Warnung.
uint8_t test[31];
for (uint8_t i = 0; i < 32; i++) {
   test[i] = 0;
   // ...
}

von Rolf M. (rmagnus)


Bewertung
1 lesenswert
nicht lesenswert
test schrieb:
> Manfred schrieb:
>> Ja, int ist 16 Bit breit, daher ist der Code falsch. Da muss es
>> doch eine Warnung geben...
>
> Da müsste der gcc aber schon sehr clever sein um hier das Problem zu
> sehen.

Der Compiler müsste etwas Code-Analyse betreiben. Wenn man die Zeile
uint32_t mask = 1 << i;
für sich betrachtet, ist da erstmal nichts falsch dran. Eine 1 wird um 
eine variable Anzahl von Bits geschoben. Solange man den Wert von i 
nicht kennt, ist eine Warnung nicht gerechtfertigt. Jetzt ist es an der 
Stelle aber nicht übermäßig schwer für den Compiler, zu wissen, mit 
welchen Werten von i dieser Code definitiv ausgeführt werden wird. Der 
Optimizer analysiert solche Schleifen sowieso, um z.B. loop-unrolling 
betreiben zu können. Von daher könnte er hier schon merken, dass der 
Code definitiv fehlerhaft ist.

> Kann man so etwas heutzutage erwarten?
>
> Ist eigentlich Aufgabe des Programierers derartige Probleme zu erkennen.

Heutzutage ist es aber Aufgabe des Compilers, nicht nur das Programm 
einfach stur in Maschinencode zu übersetzen, wenn das irgendwie geht, 
sondern auch, dem Programmierer zu helfen, Fehler zu vermeiden.
Er übernimmt heute auch die Rolle eines Lint-Tools.

> D.h. wenn man mit Bits rummacht sollte man generell wissen was für
> Datentypen man da benutzt.

Das sollte man. Wie das aber so bei Menschen ist, macht man dabei auch 
schnell mal einen Flüchtigkeitsfehler.

von test (Gast)


Bewertung
-3 lesenswert
nicht lesenswert
Rolf M. schrieb:
> Das sollte man. Wie das aber so bei Menschen ist, macht man dabei auch
> schnell mal einen Flüchtigkeitsfehler.

Wobei die Tatsache das ein uint32_t offenbar nur 16bit hat (oder auch 
nicht, hängt bei c offenbar auch von der Mondphase und dem Wochentag ab) 
nicht wirklich hilfreich dabei ist den Überblick zu behalten ;-)


Wobei ich da vermutlich auch unfair gegenüber c++ bin, vermutlich gibt 
es geeignete Datentypen und Arten vernünftig zu programmieren. Macht nur 
keiner ;-) Ich meine wenn ich sehe das heutzutage immer noch Bytes in 
Char Arrays gesammelt werden...

von Wilhelm M. (wimalopaan)


Bewertung
2 lesenswert
nicht lesenswert
test schrieb:
> Rolf M. schrieb:
>> Das sollte man. Wie das aber so bei Menschen ist, macht man dabei auch
>> schnell mal einen Flüchtigkeitsfehler.
>
> Wobei die Tatsache das ein uint32_t offenbar nur 16bit hat (oder auch
> nicht, hängt bei c offenbar auch von der Mondphase und dem Wochentag ab)
> nicht wirklich hilfreich dabei ist den Überblick zu behalten ;-)

Ein uint32_t hat auf jeder Plattform 32-Bit. Ein int/unsigned int hat 
mindestens 16-Bit.

von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
test schrieb:
> Wobei die Tatsache das ein uint32_t offenbar nur 16bit hat (oder auch
> nicht, hängt bei c offenbar auch von der Mondphase und dem Wochentag ab)
> nicht wirklich hilfreich dabei ist den Überblick zu behalten ;-)

Ich weiß nicht, wie du auf den Quatsch kommst. Das ist jedenfalls 
falsch.

> Wobei ich da vermutlich auch unfair gegenüber c++ bin, vermutlich gibt
> es geeignete Datentypen und Arten vernünftig zu programmieren. Macht nur
> keiner ;-) Ich meine wenn ich sehe das heutzutage immer noch Bytes in
> Char Arrays gesammelt werden...

Sollte unsigned char sein.

von Wilhelm M. (wimalopaan)


Bewertung
1 lesenswert
nicht lesenswert
test schrieb:

> Wobei ich da vermutlich auch unfair gegenüber c++ bin, vermutlich gibt
> es geeignete Datentypen und Arten vernünftig zu programmieren. Macht nur
> keiner ;-) Ich meine wenn ich sehe das heutzutage immer noch Bytes in
> Char Arrays gesammelt werden...

Das machen nur C-Programmierer. In C++ nimmt man std::byte.

von MaWin (Gast)


Bewertung
0 lesenswert
nicht lesenswert

von Bernd K. (prof7bit)


Bewertung
0 lesenswert
nicht lesenswert
MaWin schrieb:
> Das könnte man wahrscheinlich mit ubsan finden.
> 
https://developers.redhat.com/blog/2014/10/16/gcc-undefined-behavior-sanitizer-ubsan/

Geht das mit bare-metal targets auch (denn im OP ist von avr-gcc die 
Rede)?

von MaWin (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Bernd K. schrieb:
> Geht das mit bare-metal targets auch (denn im OP ist von avr-gcc die
> Rede)?

Theoretisch schon.
Ich weiß nicht, ob avr-libc da Unterstützung hat (libubsan).
Vermutlich aber eher nicht.

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Noch ein Antwort, weil es mir gerade über die Füße lief:

der UB-sanititer ist in C++ programmiert und benutzt die libstdc++. Da 
aber für das AVR target keine libstdc++ existiert, wird im configure des 
avr-gcc die lubsan deaktiviert.

von Johann L. (gjlayde) Benutzerseite


Bewertung
1 lesenswert
nicht lesenswert
Genau genommen gibt's die Libs schon; sowohl libstdc++-v3 als auch 
libsupc++, wobei letztere Teil der libstdc++-v3 ist und den rudimentären 
C++ Support bereitstellt wie z.B. new und new[].  Müsste halt mal jemand 
die handvoll Anpassungen für AVR machen.  Vorgesehen ist das, müsste nur 
noch ausgefüllt werden.

Die Sanitizer wollen aber noch mehr als libstdc++v3.  Aus 
libsanitizer/configure.ac:
# Common libraries that we need to link against for all sanitizer libs.
link_sanitizer_common='-lpthread -lm'
Will also auch POSIX.

von Christoph Z. (christophz)


Bewertung
0 lesenswert
nicht lesenswert
test schrieb:
> vermutlich gibt es geeignete Datentypen und Arten vernünftig zu
> programmieren. Macht nur keiner ;-)
> Ich meine wenn ich sehe das heutzutage immer noch Bytes in
> Char Arrays gesammelt werden...

Ja, ist leider immer noch sehr verbreitet.

Seit C99 gibt es die stdint.h und stdbool.h (daraus kommt der schon 
erwähnte uint32_t). Damit ist es für einen Programmierer möglich seine 
Algorithmen so zu schreiben, dass sie Chance haben einen 
Plattformwechsel zu überleben und gibt auch den Tools mehr Chance für 
hilfreiche Warnungen.

Wird aus meiner Sicht zu wenig geschult bzw. ist zu selten Bestandteil 
der Firmen Coding-Guidelines.

test schrieb:
> Da müsste der gcc aber schon sehr clever sein um hier das Problem zu
> sehen. Kann man so etwas heutzutage erwarten?

Ja.

test schrieb:
> Ist eigentlich Aufgabe des Programierers derartige Probleme zu erkennen.
> D.h. wenn man mit Bits rummacht sollte man generell wissen was für
> Datentypen man da benutzt.

Ja. Darum sollten auch anständig definierte Datentypen (wie z. B. aus 
stdint.h) verwendet werden. So ist gleichzeitig auch der Code besser 
dokumentiert ohne Mehraufwand.

Rolf M. schrieb:
> Er übernimmt heute auch die Rolle eines Lint-Tools.

Ein heutiger Compiler soll heutzutage viele Prüfungen eines Linters 
(Statisches Codeanalyse Werkzeug) übernehmen, so weit wie er das halt 
kann. Zusätzlich kann der Compiler Dinge prüfen, die abhängig von der 
Zielplattform sind, was nicht in den Bereich eines Linters passt.

Da dazu noch keine Namen genannt wurden, hier zwei OpenSource Linter für 
C/C++:

http://splint.org/

http://cppcheck.sourceforge.net/

Spielt mal damit herum, ist sehr spannend was die Tools so finden 
können.
Hatte mir mal in einem Firmenprojekt (durfte ein Projekt von einem 
Kollegen übernehmen) massiv Zeit eingespart.

von Oliver S. (oliverso)


Bewertung
0 lesenswert
nicht lesenswert
Christoph Z. schrieb:
> http://splint.org/

Splint Release 3.1.2
12 July 2007

Wer mit Compilern unterwegs ist oder sein muß, die auch aus dieser Zeit 
stammen, für den mag sowas hilfreich sein.

Aktuelle Compiler können bzgl. statischer Codeanalyse inzwischen sehr 
viel mehr.

Oliver

von ~Mercedes~  . (lolita)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:

> Das machen nur C-Programmierer. In C++ nimmt man std::byte.
Das is ein Ding. ;-O

Was ist denn jetzt besser für Geschwindigkeit, Sicherheit
und Größe?

Bit Funktionen als Makro / Inline zu schreiben oder
die Byte-Klasse zu nehmen?


mfg

von Μαtthias W. (matthias) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Oliver S. schrieb:
> Christoph Z. schrieb:
>> http://splint.org/
>
> Splint Release 3.1.2
> 12 July 2007
>
> Wer mit Compilern unterwegs ist oder sein muß, die auch aus dieser Zeit
> stammen, für den mag sowas hilfreich sein.
>
> Aktuelle Compiler können bzgl. statischer Codeanalyse inzwischen sehr
> viel mehr.

Ist zwar kein Compiler aber https://clang.llvm.org/extra/clang-tidy/ 
sollte auch nicht im eigenen Werkzeugkasten fehlen.

Matthias

von Oliver S. (oliverso)


Bewertung
0 lesenswert
nicht lesenswert
Dazu alle verfügbaren sanitizer, dazu valgrind. Das sind dann zwar nicht 
nur statische, sondern auch run-time-Analysen, hilft aber trotzdem.

Oliver

von Μαtthias W. (matthias) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Und verschiedene Compiler in möglichst aktueller Version. gcc und clang 
finden viel und viel unterschiedliches.

Und da wir hier bei µC.net sind: Die "Geschäftslogik" einer Anwendung 
sollte sich nicht nur für den µC übersetzen lassen. Denn nur so kann man 
die Laufzeitchecker (asan, ubsan, valgrind) richtig einsetzen.

Matthias

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Der TO wollte sicher keine Laufzeitlösung mit sanitizern, etc., sondern 
eine Compilezeitlösung für sein Problem.

Abgesehen davon, dass es "richtiger" wäre zu schreiben
    for(uint8_t i{}; i < 32; i++) {
        uint32_t mask = uint32_t{1} << i;
    }

liegt die Wurzel des Übels aber an anderer Stelle:

- eine Ganzzahl vom Type uint32_t wird als Bitmaske missbraucht
- der Datentyp für den Bit-Shift (uint8_t) steht in keiner Relation zu 
dem Typ der Bitmaske

Eine simple Laufzeitlösung wäre korrekterweise folgendes:
    for(uint8_t i{}; i < 33; i++) {
        assert(i < (sizeof(uint32_t) * 8));
        uint32_t mask = uint32_t{1} << i;
    }

Das schreibt zwar so keiner hin, wäre aber der korrekte Ansatz, denn der 
gültige Wertebereich für den BitShift kann durch den Datentyp uint8_t 
nicht eingehalten werden. Also trägt der Programmierer die Verantwortung 
das zuzusichern: eine klassische Vorbedingung.

Für eine "richtige" Lösung braucht man

- einen (generischen) Datentyp (etwa: mask_t<>) für eine Bitmaske mit N 
Bits
- einen Shiftoperator für mask_t<>,
- einen ganzzahligen Datentyp, der nur den Wertebereich des Shifts der 
Maske abdeckt.

Damit hätten wir eine Lösung der Form:
    using m_t = mask_t<32>;
    for(m_t::shift_type i; i; ++i) {
        m_t mask = m_t{0x0001} << i;
    }

Die obigen Fehlerquellen sind ausgeschlossen.

Ist nicht schwer umzusetzen (std::byte ist da nur ein erster Schritt in 
diese Richtung), genauso wie etwa bounded_integer (ein ganzzahliger 
Datentyp mit beliebigen Grenzen und einstellbarer overrun-policy).

Das lässt sich mal wieder in das Thema strong types einordnen bzw. "Die 
eingebauten Datentypen sind dazu da, nicht benutzt zu werden".

von ppc (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Das lässt sich mal wieder in das Thema strong types einordnen bzw. "Die
> eingebauten Datentypen sind dazu da, nicht benutzt zu werden".

Genau so ist es.

von nur malso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
in diesem Falle hilft eine statische code analyse

wie z.B. cppcheck, hier eine onlinedemo 
http://cppcheck.sourceforge.net/demo/

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
nur malso schrieb:
> in diesem Falle hilft eine statische code analyse

cppcheck --enable=all findet das Problem nicht ...

von nur malso (Gast)


Bewertung
0 lesenswert
nicht lesenswert
also bei mir führt (in der onlinedemo)
void f()
{
  for (uint8_t i = 0; i < 32; i++) {
    uint32_t mask = 1 << i;
  }
}

zu folgender Ausgabe
Cppcheck 1.86

[test.cpp:4]: (error) Shifting signed 32-bit value by 31 bits is undefined behaviour

Done!

von Wilhelm M. (wimalopaan)


Bewertung
1 lesenswert
nicht lesenswert
Hier aber wieder nicht:
bool bad0() {
    for(uint8_t i{}; i < 33; i++) {
        uint32_t mask = 1 << i;
    }
    return true;
}

von Wilhelm M. (wimalopaan)


Bewertung
1 lesenswert
nicht lesenswert
Ohne zusätzliche Tools schreibt man seine Tests einfach in 
constexpr-Kontexte, und alles UB wird erkannt.

von Oliver S. (oliverso)


Bewertung
-1 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Hier aber wieder nicht:

Wenn du das (an der Stelle) fürchterliche i{} durch ein übliches i=0 
ersetzt, dann doch.

Oliver

: Bearbeitet durch User
von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Oliver S. schrieb:
> Wilhelm M. schrieb:
>> Hier aber wieder nicht:
>
> Wenn du das (an der Stelle) fürchterliche i{} durch ein übliches i=0
> ersetzt, dann doch.

Ich finde es sehr praktisch und gar nicht fürchterlich.

Das ist uniform-initialization-syntax seit C++11 und cppcheck sollte das 
so langsam mal mitbekommen haben.

Dies zeigt aber das grundsätzliche Problem bei der Verwendung externer 
Werkzeuge.

von Yalu X. (yalu) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Dies zeigt aber das grundsätzliche Problem bei der Verwendung externer
> Werkzeuge.

Stimmt, deswegen schreibe ich inzwischen auch wieder
  if (x < 0) ...

statt
  if (x < int{}) ...

obwohl letzteres natürlich viel cooler ist ;-)

Beitrag #6130982 wurde von einem Moderator gelöscht.
von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Oliver S. schrieb:
>> Wilhelm M. schrieb:
>>> Hier aber wieder nicht:
>>
>> Wenn du das (an der Stelle) fürchterliche i{} durch ein übliches i=0
>> ersetzt, dann doch.
>
> Ich finde es sehr praktisch und gar nicht fürchterlich.

Ich finde, dass man den Wert, den man da in den Integer rein schreibt, 
durchaus sehen sollte, und das nicht nur, wenn er von 0 verschieden ist.

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Stimmt, deswegen schreibe ich inzwischen auch wieder
>   if (x < 0) ...

... würde ich jetzt bei std::is_same_v<decltype(x), std::string> == true 
nicht machen.

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Das ist uniform-initialization-syntax seit C++11 und cppcheck sollte das
> so langsam mal mitbekommen haben.

Sorry, schon seit C++03.

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Rolf M. schrieb:
> Ich finde, dass man den Wert, den man da in den Integer rein schreibt,
> durchaus sehen sollte, und das nicht nur, wenn er von 0 verschieden ist.

Nennt sich value-initialization und ist in der generischen 
Programmierung sehr praktisch.

Aber selbst mit dem redundanten bzw. manchmal nicht möglichem 
Initialwert (hier bspw: 0) findet cppcheck das Problem nicht.

von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Rolf M. schrieb:
>> Ich finde, dass man den Wert, den man da in den Integer rein schreibt,
>> durchaus sehen sollte, und das nicht nur, wenn er von 0 verschieden ist.
>
> Nennt sich value-initialization und ist in der generischen
> Programmierung sehr praktisch.

Mir ist schon bewusst, dass das praktisch sein kann. An dieser Stelle 
ist es aber fehl am Platz. Hier haben wir auch keine generische 
Programmierung, sondern eine ganz simple Zählschleife, deren Zähler am 
Anfang mit einem Wert vorbelegt wird. Und den Wert an dieser Stelle nur 
deshalb zu verstecken, weil er zufälligerweise mit dem dem Default für 
die Initialisierung übereinstimmt, finde ich nicht sinnvoll. Man muss 
nicht jedes Feature überall nutzen, nur weil's halt geht.

> Aber selbst mit dem redundanten bzw. manchmal nicht möglichem
> Initialwert (hier bspw: 0) findet cppcheck das Problem nicht.

Das ist ein anderes Problem.

: Bearbeitet durch User
von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Rolf M. schrieb:
> Hier haben wir auch keine generische
> Programmierung, sondern eine ganz simple Zählschleife, deren Zähler am
> Anfang mit einem Wert vorbelegt wird.

Warum sollte man da einen Unterschied machen? Initialisierung immer mit 
{} und man muss sich nicht umstellen.

Rolf M. schrieb:
> weil er zufälligerweise mit dem dem Default für
> die Initialisierung übereinstimmt,

Zufällig ist hier nichts.

Rolf M. schrieb:
>> Aber selbst mit dem redundanten bzw. manchmal nicht möglichem
>> Initialwert (hier bspw: 0) findet cppcheck das Problem nicht.
>
> Das ist ein anderes Problem.

Sicher. Bedeutet aber, dass mir cppcheck nichts bringt.

Wie schon oben erläutert, halte ich das Vorgehen des TO bzw. das 
"übliche" Vorgehen für falsch.

Man kann es aber recht einfach lösen. Für eine Laufzeitlösung s.o. und 
eine Compilezeit-Lösung ist auch einfach:
    using m_t = mask_t<32>;

    m_t m{0b0000'00001};
    m <<= 33_c; // compiletime-error
    
    while(m.any()) {
        m <<= 1_c; // ok
    }

BTW: std::bitmask löst zwar das Vokabularproblem, aber hat sonst die 
übliche Semantik bzw. Möglichkeiten.

von Oliver S. (oliverso)


Bewertung
0 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Nennt sich value-initialization und ist in der generischen
> Programmierung sehr praktisch.

Da gehört das auch hin, in eine for-Schleife mit int aber nicht.

Allerdings ist das hier alles OT, für das Thema gibt ja einen eigenen 
Thread (in dem schon alles gesagt wurde).

Oliver

von Wilhelm M. (wimalopaan)


Bewertung
0 lesenswert
nicht lesenswert
Oliver S. schrieb:
> Da gehört das auch hin, in eine for-Schleife mit int aber nicht.

Dein Argument ist: weil es immer so war, soll es so bleiben.

Mein Argument ist: Vereinheitlichung und damit Vereinfachung der 
Notation.

von Yalu X. (yalu) (Moderator)


Bewertung
1 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Mein Argument ist: Vereinheitlichung und damit Vereinfachung der
> Notation.

Meine Kritik (und wohl auch die anderer Diskussionsteilnehmer hier)
bezieht sich nicht primär auf die Verwendung der geschweiften Klammern¹,
sondern auf das Weglassen der 0.

Einheitlich wäre es deswegen, wenn man wie bei

for(uint8_t i{1}; i < 32; i++)

auch beim Start mit 0 den Startwert explizit hinschreibt, also so:

for(uint8_t i{0}; i < 32; i++)


und nicht so:

for(uint8_t i{}; i < 32; i++)

Ich bin ja prinzipiell auch ein Freund knapper Schreibweisen, aber nur
dann, wenn man sie auch halbwegs durchgängig verwenden kann. Warum
sollte man bei den 4294967296 möglichden Initialisierungswerten für ein
int in einem einzigen Fall (nämlich für die 0) eine andere Schreibweise
verwenden?

Bei der generischen Programmierung sieht das natürlich anders aus. Dort
stehen die leeren geschweiften Klammern i.Allg. nicht für die numerische
Null, sondern für das neutrale Element eines Monoiden. Da dieses Element
etwas ganz Besonderes ist, darf auch seine Initialisierung etwas anders
aussehen.

―――――――――――――
¹) Dennoch empfinde ich sie als häßlich, weil sie keinerlei Bezug nur
   mathematischen Notation haben, wo eine Variablenbelegung immer und
   unabhängig vom Typ mit einem Gleichheitszeichen erfolgt.

von Rolf M. (rmagnus)


Bewertung
0 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Wilhelm M. schrieb:
>> Mein Argument ist: Vereinheitlichung und damit Vereinfachung der
>> Notation.
>
> Meine Kritik (und wohl auch die anderer Diskussionsteilnehmer hier)
> bezieht sich nicht primär auf die Verwendung der geschweiften Klammern¹,
> sondern auf das Weglassen der 0.

Ja, zumindest meine auch. Daher passt diese Frage eigentlich genau dazu:

Wilhelm M. schrieb:
> Warum sollte man da einen Unterschied machen?

Genau das ist eben auch mein Gedanke: Warum sollte man einen Unterschied 
machen, ob die Schleife jetzt bei 0 oder z.B. bei 42 beginnt?

von Wilhelm M. (wimalopaan)


Bewertung
-2 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Einheitlich wäre es deswegen, wenn man wie bei
> auch beim Start mit 0 den Startwert explizit hinschreibt, also so:

Meine Aussage bezieht sich nicht (nur) auf die Schreibweise, sondern 
eben auf die Semantik:
template<typename T>
void bar() {
    T v; // default-initialization: non-class type -> indeterminate value
    T v1{}; // value-initialization: non-class type -> zero-initialization
    T v2{0}; // direct-initialization: non-class type -> no narrowing; class-type -> need ctor callable with one argument
    T v3 = 0; // copy-initialization: non-class-type -> narrowing; class-type -> need conversion-ctor
    T v4(); // function declaration
    while(!end(v)) {
        ++v;
    }
}

Im Beispiel oben sieht man eben den Unterschied: ggf. ist es für einen 
Datentyp T gar nicht möglich. Die geringste implizite 
template-Typanforderung ist die default-Konstruktion über die 
value-initialization. Und bei primitiven DT resultiert 
zero-initialization. Das ist ganz eindeutig und klar.

Yalu X. schrieb:
> Dennoch empfinde ich sie als häßlich, weil sie keinerlei Bezug nur
>    mathematischen Notation haben, wo eine Variablenbelegung immer und
>    unabhängig vom Typ mit einem Gleichheitszeichen erfolgt.

Mathematische Variablen und benannte Objekte aka Variablen im Kontext 
einer imperativen Programmiersprache sind zwei unterschiedliche Dinge.

von Oliver S. (oliverso)


Bewertung
1 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> Im Beispiel oben sieht man eben den Unterschied: ggf. ist es für einen
> Datentyp T gar nicht möglich.

Das ist aber genau der Punkt.

Wilhelm M. schrieb:
> for(uint8_t i{}; i < 33; i++) {

Da gibt es kein T und keine semantisch erforderliche 
default-Initialisierung.

Da steht ein POD uint8_t, und dessen Semantik ist "Startwert der 
Schleifenvariablen". Da nicht die 0 hinzuschreiben, geht am Ziel vorbei.

Oliver

: Bearbeitet durch User
von Yalu X. (yalu) (Moderator)


Bewertung
1 lesenswert
nicht lesenswert
Wilhelm M. schrieb:
> T v1{}; // value-initialization: non-class type -> zero-initialization
> T v2{0}; // direct-initialization: non-class type -> no narrowing;
> class-type -> need ctor callable with

Und was spricht jetzt genau dagegen, für die Laufvariable mit dem festen
Typ uint8_t die direct-initialization statt der value-initialization zu
verwenden?

Das kostet zwar einen Tastendruck mehr, dafür hätten aber alle
Zählschleifen unabhängig von ihrem Startwert ein einheitliches Aussehen,
und Vereinheitlichung scheint ja auch dir wichtig zu sein:

Wilhelm M. schrieb:
> Mein Argument ist: Vereinheitlichung und damit Vereinfachung der
> Notation.


Wilhelm M. schrieb:
> Im Beispiel oben sieht man eben den Unterschied: ggf. ist es für einen
> Datentyp T gar nicht möglich. Die geringste implizite
> template-Typanforderung ist die default-Konstruktion über die
> value-initialization.

Dass die value-initialization in der generischen Programmierung sinnvoll
sein kann, habe ich ja oben bereits geschrieben. Im konkreten Beispiel
mit der Schleife ist aber nichts generisch, sondern wir haben es mit
einem klar festgelegten Typ (uint8_t) zu tun.


Wilhelm M. schrieb:
> Yalu X. schrieb:
>> Dennoch empfinde ich sie als häßlich, weil sie keinerlei Bezug nur
>>    mathematischen Notation haben, wo eine Variablenbelegung immer und
>>    unabhängig vom Typ mit einem Gleichheitszeichen erfolgt.
>
> Mathematische Variablen und benannte Objekte aka Variablen im Kontext
> einer imperativen Programmiersprache sind zwei unterschiedliche Dinge.

Das ist klar. Trotzdem finde ich es praktisch, wenn sich die Syntax
einer Programmiersprache an bereits bekannte Schreibweisen anlehnt, die
bspw. von

- der natürlichen Sprache (wie bspw. bei "if", "while" und "return"),

- der Mathematik (wie bspw. "+", "-", "sin") oder

- anderen bereits verbreiteten Programmiersprachen

übernommen werden können.

In den allermeisten Programmiersprachen (insbesondere auch den
imperativen) wird nun mal mit einem Gleichheitszeichen initialisiert.
Nur C++ entfernt sich immer mehr von dieser Konvention.

von Rolf Magnus (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Wilhelm M. schrieb:
>> Im Beispiel oben sieht man eben den Unterschied: ggf. ist es für einen
>> Datentyp T gar nicht möglich. Die geringste implizite
>> template-Typanforderung ist die default-Konstruktion über die
>> value-initialization.
>
> Dass die value-initialization in der generischen Programmierung sinnvoll
> sein kann, habe ich ja oben bereits geschrieben. Im konkreten Beispiel
> mit der Schleife ist aber nichts generisch, sondern wir haben es mit
> einem klar festgelegten Typ (uint8_t) zu tun.

Wobei das hier nicht mal eine Rolle spielt. Selbst wenn es generisch 
wäre: Wenn ich eine Zählschleife habe und die explizit bei 0 starten 
lassen will, schreibe ich 0 als Startwert hin, egal von welchem Typ mein 
Zähler ist. Und ich schreibe den Wert hin, egal ob er 0 oder 1 oder 
11149 ist.
Die Semantik ist eben "ich möchte bei 0 anfangen zu zählen" und nicht 
"ich möchte bei dem default-Wert des Datentyps anfangen".

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.