lehrkraefte:blc:informatik:ffprg2-2020:esp32-io-and-vars

This is an old revision of the document!


Typen

Alles in C++ muss einen Typ haben. Der Typ einer Variablen kann nicht geändert werden.

Die Typen uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t sind in ihrer Bezeichnung klar, ob ohne Vorzeichen (unsigned) und wieviele Bits diese umfassen. Eigentlich sollte ausschliesslich damit gearbeitet werden.

Traditionellerweise gibt es folgende Typen, die aber je nach Platform unterschiedlich gross sind. Bei char ist nicht einmal klar, ob wenn als Zahl interpretiert es mit oder ohne Vorzeichen geschehen soll.

  • int und unsigned int EPS32: 4 Bytes, Arduino Uno: 2 Bytes
  • long und long long: 4 und 8 Bytes.
  • float und double Fliesskommazahlen, 4 bzw. 8 Bytes.
  • bool true oder false
  • char oder byte.

Ist in einem Ausdruck ein float oder double involviert, ist auch das Resultat ein float oder double.

Sind in einem Ausdruck nur ganzzahlige Typen involviert, ist auch das Resultat ganzzahlig, wobei immer gegen Null hin gerundet wird:

void setup() {
  Serial.begin(115200);
  delay(200);
  int a=7;
  int b=6;
  int c = a/b;
  Serial.printf("[int]  %d/%d ist gleich %d\n",a,b,c);
  a = -7;
  c = a/b;
  Serial.printf("[int]  %d/%d ist gleich %d\n",a,b,c);
}
 
void loop() {
  // tu nix
}
  • %d (int)
  • %f (float, double)
  • %l (long)
  • %du, %llu (unsigned int, unsigned long long)
  • %c (char)
  • \n Zeilenumbruch
// Der Preprocessor erlaubt auch Macros:
#define SHOWSIZE(T) Serial.printf(#T " belegt %d Bytes\n", sizeof(T))
 
#define HASSIGN(T) Serial.print("2-3 ergibt in " #T " "); Serial.println((T)(((T)2)-((T)3)))
 
void setup() {
  Serial.begin(115200);
  delay(400);  // So wird nach dem Kompilieren die Ausgabe direkt ohne Reset angezeigt
  Serial.println("\n--------------\nSize of Types:\n--------------");
 
  SHOWSIZE(char);
  SHOWSIZE(byte);
  SHOWSIZE(short);
  SHOWSIZE(int);
  SHOWSIZE(long);
  SHOWSIZE(long long);
  Serial.println("-----------");
  SHOWSIZE(float);
  SHOWSIZE(double);
  Serial.println("-----------");
  HASSIGN(char);
  HASSIGN(byte);
  HASSIGN(signed char);
  HASSIGN(unsigned short);
  HASSIGN(unsigned int);
  unsigned long long a = -1;
  Serial.printf("unsigned long long -1 ist %llu", a);  
}
 
void loop() {
  // nix tun...
}
#define RUN(TYPE, FORMAT) addtest<TYPE>(1000000, #TYPE, FORMAT)
#define RUM(TYPE, FORMAT) multest<TYPE>(1000000, #TYPE, FORMAT)
 
template<typename T>
void addtest(int n, char *t, char *f) {
  long zeit = micros();
  // volatile bezeichnet Variablen, die z.B. von Interrupts verändert werden könnten.
  // Damit kann der Kompiler keine Optimierungen machen, weil sich der Wert ausserhalb
  // des normalen Programmflusses ändern könnte.
  volatile T r = 0;     // Damit das Ding nicht wegoptimiert wird.
  volatile T a = 3456;  // Damit das Ding nicht wegoptimiert wird.
  for (int i=0; i<n; i++) {
    r = r+a;
  }
  zeit = micros()-zeit;
  Serial.printf("%d Additionen mit Typ %s braucht %d us\n", n, t, zeit);
  // Wenn das Resultat nicht gebraucht wird, wird die ganze Schleife
  // gnadenlos wegoptimiert ;-)
  Serial.print("Das Resultat: ");
  Serial.printf(f, r);
  Serial.println();
}
 
template<typename T>
void multest(int n, char *t, char *f) {
  long zeit = micros();
  volatile T b = 27; // Damit das Ding nicht wegoptimiert wird.
  volatile T r = 0;  // Damit das Ding nicht wegoptimiert wird.
  T a = 5234;
  for (int i=0; i<n; i++) {
    r = a*b;
  }
  zeit = micros()-zeit;
  Serial.printf("%d Multiplikationen mit Typ %s braucht %d us\n", n, t, zeit);
  // Wenn das Resultat nicht gebraucht wird, wird die ganze Schleife
  // gnadenlos wegoptimiert ;-)
  Serial.print("Das Resultat: ");
  Serial.printf(f, r);
  Serial.println();
}
 
 
void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.print("------------\n\n");
  RUN(int, "%d");
  RUN(long long, "%llu");
  RUN(float, "%f");
  RUN(double, "%f");
 
  Serial.println();
 
  RUM(int, "%d");
  RUM(long long, "%llu");
  RUM(float, "%f");
  RUM(double, "%f");
 
}
 
void loop() {
  // tu nix
}
  • lehrkraefte/blc/informatik/ffprg2-2020/esp32-io-and-vars.1597239906.txt.gz
  • Last modified: 2020/08/12 15:45
  • by Ivo Blöchliger