Welche Möglichkeiten der Fehlersuche hat man beim Arduino?

[Mxt]

Ein

case 1:

entspricht etwa einem (Pseudocode)

if (noch_kein_passendes_case_gesehen && (x != 1))
  goto hinter_naechstes_break;  // wo wieder ein if steht
else
  noch_kein_passendes_case_gesehen = false;

[HaWe]

du kannst es analogiemäßig erklären und umschreiben wie du willst, wem oder was immer es pseudocodemäßig entsprechen mag, aber es bleibt dabei, dass bei Erfüllung der Bedingung eine dem Integerwert entsprechende gleichnamige Integer-Sprungmarke angesprungen wird, die genau wie bei goto-labels eine Konstante sein muss und auch genau wie bei Lables von einem Doppelpunkt gefolgt wird:

if(x==1) goto 1;
if(x==2) goto 2;
if(x==3) goto 3;
if(x==4) goto 4;
goto default;
1: ...
2: ...
3: ...
4: ...
default: ...

Es entspricht aber keinesfalls eher oder unmittelbarer einem kaskadierten
if/else if /else if/...
wo dann auch nicht der Rest wie bei if/else-Körpern übersprungen wird, sondern ebenfalls wie bei goto Labels einfach schrittweise weitergearbeitet wird und wo in jedem else-Körper auch wieder Variablen-Ausdrücke, floats oder statements erlaubt wären.

Wie auch immer:
alles ist legaler C Code und hat seine gleichwertige Daseins-Berechtigung.

[Mxt]

Wie es genau aussieht hängt sowohl vom Compiler als auch von der Verteilung der Werte der case ab. Hier hat einer das für einen Compiler mal angeschaut
http://www.codeproject.com/Articles/...-Switch-Statem
Da verwendet der Compiler gleich drei verschiedene Implementierungen, je nach Struktur der cases.

[HaWe]

auch in deinem Link wird mehrfach die Compilierung zu jmp lables erwähnt.
mag jedoch alles im Detail sein wie es will, switch/case ist trotzdem prinzipiell ein goto und kein if/else if, sonst wären nicht nur Integer-Konstanten sondern auch Variablen-Ausdrücke, floats oder statements als Fallunterscheidungen erlaubt.

und wie bereits erwähnt,

Wie auch immer:
alles ist legaler C Code und hat seine gleichwertige Daseins-Berechtigung.

[Mxt]

Erstmal, ja

alles ist legaler C Code und hat seine gleichwertige Daseins-Berechtigung.

Aber, nein

switch/case ist trotzdem prinzipiell ein goto und kein if/else if

es ist eine Tabelle, wenn das kürzer ist, sonst sind es auch if.

Ganz unschuldiges Beispiel

switch(i)
{
  case 1:
    // ...
    break;
  case 2:
    // ...
    break;
  case 3:
    // ...
    break;
}

gibt eine Tabelle.

Aber

switch(i)
{
  case 10:
    // ...
    break;
  case 100:
    // ...
    break;
  case 1000:
    // ...
    break;
}

ups, was machen wir mit den Zwischenwerten ? Eine Tabelle mit 1001 Einträgen in den Speicher vom armen Arduino ?

Nein, da passiert was ganz anderes. Und deshalb überlegt der Compiler so lange ...

[HaWe]

die Frage der Zwischenwerte wird ebenfalls in deinem Link diskutiert. Es bleibt dabei:
switch/case basiert auf goto mit jump labels / jump tables und es entspricht NICHT if/ else if / else if.

[Peter(TOO)]

Wie es genau aussieht hängt sowohl vom Compiler als auch von der Verteilung der Werte der case ab. Hier hat einer das für einen Compiler mal angeschaut

Ursprünglich haben C-Compiler nur geschachtelte if/else erzeugt. Diese Variante funktioniert immer und der passende Code-Generator ist einfach.
Ein grosser Nachteil ist das Laufzeitverhalten bei vielen Labels, um an das letzte Label zu gelangen müssen alle if abgearbeitet werden.
Allerdings haben diese dummen Compiler die Labels nicht sortiert, man konnte nachhelfen indem man die case entsprechend ihrer Wahrscheinlichkeit sortiert hat. Der Code war dann nicht unbedingt wirklich übersichtlicher.

Man darf nicht vergessen, dass in der Zeit als C entstand Hauptspeicher noch in Kilobyte und damalige Festplatten in Megabyte gemessen wurden.

Etwas später hat man dann angefangen die Labels zuerst zu analysieren.

Bei nur ein paar Label erzeugt man immer noch geschachtelte if/else, der Code-Overhead ist kleiner und die Laufzeitdifferenzen spielen auch keine Rolle.

Für Sprungtabellen ist es am einfachsten wenn die case-Werte feste Abstände haben. Bei nur einzelnen fehlenden Werten, werden diese einfach in der Tabelle eingeführt und zeigen auf das default-Label.

Bei einer zufälligen Verteilung der Werte bleibt dann nur noch die Möglichkeit eine Suchtabelle, welche wieder das selbe laufzeitverhalten wie verschachtelte if/else hat.

Bei der Frage nach dem Stack-Handling in C++ ist zu Bedenken, dass C++ ursprünglich als Pre-Prozessor konzipiert wurde. Im ersten Schritt wurde C++ einfach in ein C-Programm übersetzt und dann ging es mit dem normalen C-Compiler weiter.
Normalerweise kann man den C++-Compiler anweisen eine Datei mit diesem C-Code zu erstellen.
Dieser Schritt über C ist auch der Grund für die decorated names in C++. Es musste eine Lösung gefunden werden, damit C-Compiler und Linker mit identischen Funktions-Namen aber unterschiedlichen Parametern umgehen können. Also bastelt man sich aus den Parameter-Typen eine Codierung zusammen und bastelt diese an den Funktionsnamen dran. Für C und den Linker sind dies dann komplett unterschiedliche Funktionen.

MfG Peter(TOO)

[Mxt]

Um endlich wieder bei

Frage: Wie kriegt der Stack diesen Ablauf gebacken ?

weiterzumachen:

In C++ kommt noch eine weitere Komplexität hinzu. Das ist auch der Grund, warum gotos unerwartete Nebeneffekte haben können, die man nicht gut sieht, wenn über mehrere Bildschirmseiten gesprungen wird.

Nehmen wir mal an, man verwendet Dinge aus einer Arduino Lib, hier zur Demonstration mal mit Debug-Ausgaben

struct Ding
{
  ~Ding()
  {
    Serial.printf("Fertig");
  }
}

Wenn sowas jetzt in Code auftaucht, ein switch ist hier nur ein Beispiel

switch(i)
{
  case 1:
  {
     Ding a;
     // ....
     break;
  }
  case 2:
    /...
}

Serial.printf("Test");

Dann ist die Ausgabe
Fertig
Test

Sowas kann auch passieren, wenn ein goto über { oder } hinwegspringt, vorwärts oder rückwärts.

- - - Aktualisiert - - -

die Frage der Zwischenwerte wird ebenfalls in deinem Link diskutiert. Es bleibt dabei:
switch/case basiert auf goto mit jump labels / jump tables und es entspricht NICHT if/ else if / else if.

Dazu reicht es einfach aus dem Link zu zitieren

...
Next, how do we jump to these calling targets?
...
The logic is not too hard to understand. ...Rewrite the snippet like this:
...
i2 = i;
if i2 > 700 goto LN14;
if i2 == 700 goto LN5;
if i2 > 250 goto LN15;
if i2 == 250 goto LN7;
if i2 == 100 goto LN9;
if i2 == 200 goto LN8;
goto LN1;
LN15:
if i2 == 500 goto LN6;
goto LN1;
LN14:
if i2 == 750 goto LN4;
if i2 == 800 goto LN3;
if i2 == 900 goto LN2;
goto LN1;

[HaWe]

und siehe da...:
goto's, wer hätte das gedacht?
Und keine if /else if/else if/... sondern nur hintereinander geschriebene if's.

Natürlich kann man auch Fehler mit goto's machen, aber C ist ja gerade dafür entwickelt worden, um alles möglich zu machen - gehen tut alles mit C, der Programmierer ist für alles verantwortlich, auch für seine Fehler, und eben nicht die Programmiersprache oder der Compiler.

Whatever -
mein Standpunkt war ja nichts anderes als das gerade hier Beschriebene, goto's sind eben auch nicht viel anders als switch/case und keines ist schöner, besser oder vielseitiger oder mächtiger.

Für if /else if/else if/ gilt das allerdings schon, was das besser oder vielseitiger oder mächtiger anbelangt. Ich denke, auf diesen Standpunkt können wir uns ohne weiteres einigen.

[Mxt]

Für if /else if/else if/ gilt das allerdings schon, was das besser oder vielseitiger oder mächtiger anbelangt. Ich denke, auf diesen Standpunkt können wir uns ohne weiteres einigen.

Ja sicher.

Und ja, in Assembler wird if else zu einer Art if goto, ein else gibt es da nicht.

Übrigens ist ein switch mittlerweile auch schon recht mächtig. Zwar noch nicht in der Arduino IDE, aber neuere C++ Compiler erlauben sowas

constexpr int quadrat(int n) noexcept
{
	return n * n;
}

int main()
{
	for (int i = 0; i < 10; i++)
	{
		switch (i)
		{
		case quadrat(1):
			printf("i ist 1\r\n");
			break;
		case quadrat(2):
			printf("i ist 4\r\n");
			break;
		case quadrat(3):
			printf("i ist 9\r\n");
			break;
		default:
			break;
		}
	}
    return 0;
}

Gerade in Visual Studio getestet.