# Neuigkeiten in C++

**URL:** <https://forum.arduino.cc/t/neuigkeiten-in-c/931406>\
**Category:** Deutsch\
**Created:** [December 2, 2021, 1:33pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406 "2021-12-02T13:33:19Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 1:33pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/1 "2021-12-02T13:33:19Z")

</div>

Nachdem dieser Thread nur noch aus Meldungen über mehr oder weniger neue C++ Featuers besteht, habe ich den Titel entsprechend angepaßt.

Zur ursprünglichen Frage: Wieviel C++ verträgt ein kleiner Arduino?

Bitte jetzt nicht mit "so viel wie möglich" antworten, mir geht es um die kleinen Dinge(r) mit wenig RAM. Dort sollte man z.B. keinen _String_ verwenden, oder ganz allgemein keine dynamischen Objekte.

Was bleibt dann von C++ noch übrig, das sich gefahrlos benutzen läßt? Gehört die STL dazu?

---

<div class="post-metadata">

**Author:** ![J-M-L](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/j-m-l/32/766245_2.png) [@J-M-L](https://forum.arduino.cc/u/J-M-L)\
**Post date:** [December 2, 2021, 1:44pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/2 "2021-12-02T13:44:47Z")

</div>

Sie müssen also wahrscheinlich qualifizieren, was ein Arduino ist oder was wenig RAM ist (mein Mac hat 32 Go 2667 MHz DDR4, also würde mir alles unter 1 Go klein erscheinen)  
UNO?  
MKR ?  
nicht arduino (ESP32)?

> das sich gefahrlos benutzen läßt

"gefahrlos" muss auch definiert werden

---

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 1:58pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/3 "2021-12-02T13:58:44Z")

</div>

> [@J-M-L](#):
>
> Sie müssen also wahrscheinlich qualifizieren

Können wir nicht beim üblichen **Du** bleiben?

> [@J-M-L](#):
>
> was ein Arduino ist

Sofern im Code nicht anders angegeben sollte ein Programm auch auf einem Uno (328) laufen.

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 2:03pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/4 "2021-12-02T14:03:07Z")

</div>

> [@DrDiettrich](#):
>
> mir geht es um die kleinen Dinge(r) mit wenig RAM. Dort sollte man z.B. keinen _String_ verwenden, oder ganz allgemein keine dynamischen Objekte.

String ist nicht ganz unbedenklich.  
Ist aber problemlos nutzbar, wenn man sich leichten/freiwilligen Beschränkungen unterwirft.  
Das gilt für jegliche dynamische Speicherreservierung.

Größere Prozessoren lindern die Probleme nur.  
Aber schaffen sie nicht aus der Welt.

Vereinfacht:  
Je Kleiner der µC, desto mehr Disziplin, ist wohl nötig.

In manchen Fällen ist notwendig Speicher dynamisch zu reservieren.  
Es gibt also nicht wirklich nur ein gut und böse.

---

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 2:04pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/5 "2021-12-02T14:04:46Z")

</div>

> [@combie](#):
>
> Ist aber problemlos nutzbar, wenn man sich leichten/freiwilligen Beschränkungen unterwirft.

Da fehlt mir jetzt jede Idee, welche Beschränkungen das sein sollten?

---

<div class="post-metadata">

**Author:** ![J-M-L](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/j-m-l/32/766245_2.png) [@J-M-L](https://forum.arduino.cc/u/J-M-L)\
**Post date:** [December 2, 2021, 2:09pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/6 "2021-12-02T14:09:08Z")

</div>

> [@DrDiettrich](#):
>
> Können wir nicht beim üblichen **Du** bleiben?

versuche es sehr, aber ich vergesse es immer wieder 😉

---

<div class="post-metadata">

**Author:** ![J-M-L](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/j-m-l/32/766245_2.png) [@J-M-L](https://forum.arduino.cc/u/J-M-L)\
**Post date:** [December 2, 2021, 2:11pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/7 "2021-12-02T14:11:13Z")

</div>

> [@DrDiettrich](#):
>
> Da fehlt mir jetzt jede Idee, welche Beschränkungen das sein sollten?

für die String-Klasse gab es viele Gedanken. Hier ist ein Beispiel ➜ [https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html) (aber Ich empfehle nicht die blinde Nutzung der Bibliothek, für die der Autor wirbt)

---

<div class="post-metadata">

**Author:** ![michael\_x](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/michael_x/32/628623_2.png) [@michael\_x](https://forum.arduino.cc/u/michael_x)\
**Post date:** [December 2, 2021, 2:12pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/8 "2021-12-02T14:12:26Z")

</div>

Als in den 80er Jahren (des vorigen Jahrhunderts 🙂 ) C seinen Siegeszug begann und später C++ auch objektorientierte Programmierung ermöglichte, war klar dass es eine Super-Sache ist, selbst für kleinste Controller diese Sprache zur Verfügung zu haben, um nicht in einer prozessorabhängigen Assemblersprache rumfummeln zu müssen.

Wie immer, nimmt einem ein Werkzeug nicht die Arbeit ab, sondern erleichtert sie oder ermöglicht Dinge, die ohne das Werkzeug gar nicht möglich wären.

Teil der Arbeit ist, die physikalischen Gegebenheiten im Blick zu halten.  
Nicht umsonst ist in C nicht mal die Größe eines `int` festgelegt.  
Und C++ ist dieselbe Sprache, egal welche Bibliothek in welcher Implementierung für den gewählten Compiler zur Verfügung steht.

> [@DrDiettrich](#):
>
> Da fehlt mir jetzt jede Idee, welche Beschränkungen das sein sollten?

Wie groß muss eine Ganzzahl-Variable sein, wenn man damit die Anzahl der Elektronen im beobachtbaren Universum zählen will? Und was kann ich mit einem `uint8_t` machen?

> [@combie](#):
>
> Größere Prozessoren lindern die Probleme nur.  
> Aber schaffen sie nicht aus der Welt.

Sehr schön, danke.  
Wobei die Frage bleibt, ob ein Problem, das erst später zum Tragen kommt, weniger schwer ist?

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 2:14pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/9 "2021-12-02T14:14:07Z")

</div>

> [@DrDiettrich](#):
>
> Da fehlt mir jetzt jede Idee, welche Beschränkungen das sein sollten?

Die Beschränkungen ergeben sich aus dem Verhalten der String Klasse.

Also erstmal das, was die Stingklasse böse macht:  
Viele global definierte Stringobjekte sind ein Problem, da sie den Speicher/Head fragmentieren können.  
Mildern kann man das mit String::reserve().  
Was aber auch nur geht, wenn man die maximale Größe schon vorher bestimmen kann.

Von mir Empfohlene Beschränkung:

1. Nur eine globale Instanz nutzen
2. String::reserve() nutzen.

Gegen lokale Strings ist nichts einzuwenden(außer der Speicherverbrauch), denn die Klasse folgt dem [RAII Pattern](https://de.wikipedia.org/wiki/Ressourcenbelegung_ist_Initialisierung).

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 2:17pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/10 "2021-12-02T14:17:33Z")

</div>

> [@michael\_x](#):
>
> Sehr schön, danke.  
> Wobei die Frage bleibt, ob ein Problem, das erst später zum Tragen kommt, weniger schwer ist?

**Fehlinterpretation.**

Wenn du heute sorgfältig mit String umgehst, wird die Anwendung auch später keine Probleme machen.

Wenn du allerdings im Laufe der Zeit schlampiger wirst, dann rennst du mit deinen zukünftigen  
Anwendungen in Probleme.

---

<div class="post-metadata">

**Author:** ![michael\_x](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/michael_x/32/628623_2.png) [@michael\_x](https://forum.arduino.cc/u/michael_x)\
**Post date:** [December 2, 2021, 2:24pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/11 "2021-12-02T14:24:15Z")

</div>

> [@combie](#):
>
> Fehlinterpretation.

Schlecht formuliert, sorry. Mit _später_ meinte ich **erst wenn die weiter gesteckten Grenzen doch erreicht werden.**

---

<div class="post-metadata">

**Author:** ![J-M-L](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/j-m-l/32/766245_2.png) [@J-M-L](https://forum.arduino.cc/u/J-M-L)\
**Post date:** [December 2, 2021, 2:30pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/12 "2021-12-02T14:30:50Z")

</div>

> [@combie](#):
>
> Gegen lokale Strings ist nichts einzuwenden(außer der Speicherverbrauch),

dynamische Zuweisung kann ohne Benachrichtigung fehlschlagen ... Sie können also nicht sicher sein, ob das Ergebnis einer solchen Verkettung oder einer substring-Extraktion funktioniert hat ...

Lesen Sie ➜ [Taming Arduino Strings Avoiding Fragementation and Out-of-Memory Issues](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html)

der Autor hat gute Empfehlungen, und sie sind dokumentiert

> Guidelines for Using Arduino Strings
> 
> 1. Do not use the String + operator at all, [C/C++ makes it is easy to get the code wrong](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#stringPlusOp). Avoid using the String(...) constructors as these create short lived temporary Strings. Use = and += operators or concat( ), as in result += “str”; result += 'c'; result += number; etc. See [Minimizing Memory Usage](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#minmem)
> 
> 2. Declare long lived Strings as globals and **reserve( )** space in **setup()** , starting with the smallest to the largest. Check the return from the last largest **reserve( )** to see that you have enough memory for all the Strings
> 
> 3. If you have created Strings in the **loop()** method, they are long lived, move them to Globals and repeat step 1.
> 
> 4. Pass all Strings arguments to methods, as **const String&**. For results pass a **String&** result, that the method can update with the result. i.e. void strProcessing(const String &input1, const String &input2, ,, String &result) {..} See [Using String& for arguments](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#stringargs)
> 
> 5. Set the IDE File → Preferences Compiler Warning to ALL and watch for _**warning: passing 'const String' as 'this' argument discards qualifiers [-fpermissive]**_ messages in the compile window. This says you are trying to modify a **const String&** arg.
> 
> 6. Do string processing in small compact methods. In these methods use local Strings in preference to local char[]. These methods will completely recover all the heap and stack used by their local Strings and other variables on exit. See [String versus char[]](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#stringvchar)
> 
> 7. To monitor for Low Memory and fragmentation, add a **StringReserveCheck** to at least the last largest String **reserve( )**. Add **StringReserveCheck** to other Strings as necessary. See [Using](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#stringreservecheck)**[StringReserveCheck](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#stringreservecheck)** (download and install [StringReserveCheck.zip](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/StringReserveCheck.zip))
> 
> 8. If your Arduino program uses the Web e.g. ESP32 / EPS8266 webserver/httpClient, then the underlying web support libraries already use lots of Strings. If you project is suppose to run for a long time, add a periodic automatic reboot. See [ESP32/ESP8266 Adding Periodic Automatic Reboots](https://www.forward.com.au/pfod/ArduinoProgramming/ArduinoStrings/index.html#reboot)
> 
> 9. Don't call String methods from within an interrupt routine. String uses malloc/realloc to get memory from the heap to store the chars. malloc/realloc on the UNO, Mega2560 etc (AVR processors and others) are not designed to called from the main loop and then interrupted and called again (a reentrant call). The result is a crash due to malloc/realloc loosing track of what is happening unless you add extra 'guard' code to prevent it.

---

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 2:42pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/13 "2021-12-02T14:42:01Z")

</div>

> [@combie](#):
>
> Also erstmal das, was die Stingklasse böse macht:

Mir fehlt da das größte Problem, die unsichtbare Verwendung von Strings in Operatoren, Funktionen und Methoden.

Mir hat von Anfang an so was gefehlt wie:

```arduino
Serial << "Hello" << ' ' << Name << EOL;

```

Heute würde ich mich nicht mehr trauen, solche Operatoren zu benutzen, da ich deren Implementierung nicht kenne. Aber wer kennt die schon so genau, daß er **zuverlässig** vorhersagen kann, wann und wann nicht mit dynamischen Speicherproblemen zu rechnen ist?

Und in Anbetracht der stets länglichen Diskussionen und Tutorials über Strings kann man doch keinem Newbee empfehlen, _String_ zu verwenden - die haben schon mit genug anderen Problemen zu kämpfen.

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 2:55pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/14 "2021-12-02T14:55:35Z")

</div>

> [@DrDiettrich](#):
>
> Mir fehlt da das größte Problem, die unsichtbare Verwendung von Strings in Operatoren, Funktionen und Methoden.

Das verstehe ich nicht.  
Wo findet das statt?

> [@DrDiettrich](#):
>
> Mir hat von Anfang an so was gefehlt wie:
> 
> ```arduino
> Serial << "Hello" << ' ' << Name << EOL;
> 
> ```

Naja. das Konstrukt ist doch recht normales C++  
Und String kommt da gar nicht vor.

> [@DrDiettrich](#):
>
> Heute würde ich mich nicht mehr trauen, solche Operatoren zu benutzen, da ich deren Implementierung nicht kenne.

Hmmm....  
Keine Ahnung welche Sorgen dich da plagen.....  
Sage mir deine Bedenken, und ich werde mir Mühe geben, da etwas Klarheit zu bringen.

> [@DrDiettrich](#):
>
> Aber wer kennt die schon so genau, daß er **zuverlässig** vorhersagen kann, wann und wann nicht mit dynamischen Speicherproblemen zu rechnen ist?

Es gibt nur wenige Operatoren(?) welche was mit dynamischer Speicherverwaltung zu tu haben. z.B. new und delete

> [@DrDiettrich](#):
>
> Und in Anbetracht der stets länglichen Diskussionen und Tutorials über Strings kann man doch keinem Newbee empfehlen, _String_ zu verwenden - die haben schon mit genug anderen Problemen zu kämpfen.

Wenn man den Gedanken konsequent zu ende denkt, darf man überhaupt kein Sprachmittel empfehlen, da man mit wirklich jedem irgendwelche Perversitäten anstellen kann.  
Sich ins eigene Knie schießen.

Am Rande:  
Wenn irgendwer sagt: GOTO verwende ich nicht!  
Oder ich sage: Lokale statische Variablen sind so böse, dass ich sie unbedingt vermeiden will.

Dann betrifft mich das, oder/und den anderen.  
Aber die ganzen anderen lernenden User betrifft das nicht unmittelbar.  
Sie können sich das zu eigen machen oder ablehnen.  
Das ist eine freie Entscheidung.

---

<div class="post-metadata">

**Author:** ![michael\_x](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/michael_x/32/628623_2.png) [@michael\_x](https://forum.arduino.cc/u/michael_x)\
**Post date:** [December 2, 2021, 2:57pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/15 "2021-12-02T14:57:53Z")

</div>

> [@DrDiettrich](#):
>
> Heute würde ich mich nicht mehr trauen, solche Operatoren zu benutzen, da ich deren Implementierung nicht kenne.

Dann mach deine eigene, die natürlich keine String-Objekte braucht, oder schau nach, dass Streaming.h genau dies macht:

```arduino
template<class T> inline Print& operator<< (Print &p, T arg)
                                            { p.print(arg); return p; }
const char EOL = '\n';

```

---

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 3:05pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/16 "2021-12-02T15:05:08Z")

</div>

> [@combie](#):
>
> Es gibt nur wenige Operatore(?) welche was mit dynamischer Speicherverwaltung zu tu haben. z.B. new und delete

Wie wäre es mit '+', um nur mal einen einfachen und vermutlich einfach verständlichen Operator zu nennen. Und wenn der dann in Verbindung mit String-Argumenten in einer Funktion auftaucht, wem fällt das sofort auf?

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 3:16pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/17 "2021-12-02T15:16:34Z")

</div>

> [@DrDiettrich](#):
>
> Wie wäre es mit '+', um nur mal einen einfachen und vermutlich einfach verständlichen Operator zu nennen. Und wenn der dann in Verbindung mit String-Argumenten in einer Funktion auftaucht, wem fällt das sofort auf?

Mir?  
Ok, sicherlich nicht immer sofort.  
Aber wenn ich das selber schreibe, dann sicherlich schon.

Was ist die Alternative?

1. Auf + ganz verzichten
2. Keine eigenen + definieren

Das kann es doch beides nicht sein.

```arduino
ApfelsinenKiste kiste;
int anzahl = 7;

kiste += anzahl ;

```

Wenn man sich klar macht, das + das zusammenfügen von Dingen bedeuten soll. Dann macht es doch in der Vorstellung kein Problem mehr, ob da 2 int addiert, oder 2 Zeichenketten verbunden werden. Oder eben Apfelsinen in eine Kiste geworfen werden.  
Es ist ein Freiheitsgrad im Denken.  
Damit auch im Handeln/Programmieren.

Es bleibt jedem selber überlassen, wie er mit diesen Freiheiten umgeht.

---

<div class="post-metadata">

**Author:** ![DrDiettrich](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/drdiettrich/32/219048_2.png) [@DrDiettrich](https://forum.arduino.cc/u/DrDiettrich)\
**Post date:** [December 2, 2021, 3:24pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/18 "2021-12-02T15:24:28Z")

</div>

> [@michael\_x](#):
>
> schau nach, dass Streaming.h genau dies macht:

Man muß schon ein ganzes Stück tiefer buddeln um herauszubekommen, was bei numerischen Variablen passiert.

Und wenn das wirklich so harmlos wäre, warum empfiehlt man nicht gleich die Verwendung von "\<\<" für Ausgaben? Oder funktioniert das vielleicht garnicht mit _Serial_?

---

<div class="post-metadata">

**Author:** ![combie](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/combie/32/217369_2.png) [@combie](https://forum.arduino.cc/u/combie)\
**Post date:** [December 2, 2021, 3:29pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/19 "2021-12-02T15:29:07Z")

</div>

> [@DrDiettrich](#):
>
> warum empfiehlt man nicht gleich die Verwendung von "\<\<" für Ausgaben?

Ich empfehle das.  
Und nutze es fast ausschließlich.

Es gehört nicht zum Lieferumfang des Arduino AVR Paketes.  
Wie auch der ganze Rest der libc++ (Ausnahme std::new ist neuerdings dabei)

Das Streaming ist in einer Lib implementiert.

> [@DrDiettrich](#):
>
> Oder funktioniert das vielleicht garnicht mit _Serial_?

Doch sicher, sonst könnte ich es ja nicht verwenden!

```arduino
#include <Streaming.h> // die Lib findest du selber ;-)

void setup() 
{
  Serial.begin(9600);
  
  Serial << F("Start: ") << F( __FILE__ ) << endl;
}

void loop() 
{

}

```

---

<div class="post-metadata">

**Author:** ![noiasca](https://dub1.discourse-cdn.com/arduino/user_avatar/forum.arduino.cc/noiasca/32/1126910_2.png) [@noiasca](https://forum.arduino.cc/u/noiasca)\
**Post date:** [December 2, 2021, 3:31pm UTC](https://forum.arduino.cc/t/neuigkeiten-in-c/931406/20 "2021-12-02T15:31:56Z")

</div>

> [@DrDiettrich](#):
>
> [Wieviel C++ verträgt ein Arduino?](https://forum.arduino.cc/t/wieviel-c-vertragt-ein-arduino/931406)

ganz verstehe ich deinen Frage nicht was du wirklich hören willst. Mir scheint der limitierende Faktor ist eher der Mensch der Code für "kleine" AVR schreibst. "String" lässt sich verwenden, dynamsiche Objekte auch - wenn man den Speicher im Blick hält, oder? Ist es nicht einfach so, dass alles geht, was mit den knappen Resourcen machbar ist? Also im Prinzip doch wieder "so viel wie möglich".

[Next page](https://forum.arduino.cc/t/neuigkeiten-in-c/931406.md?page=2)