Sensoren & Aktoren Programmieren in C / C++ - Kurze Wiederholung C-Programmierung - C/C++ Sensoren&Aktoren

Die Seite wird erstellt Rory Mayr
 
WEITER LESEN
Sensoren & Aktoren Programmieren in C / C++ - Kurze Wiederholung C-Programmierung - C/C++ Sensoren&Aktoren
Sensoren & Aktoren
Programmieren in C / C++
     Kurze Wiederholung
     C-Programmierung

     Hochschule Fulda – FB AI
      Sommersemester 2021
        http://c.rz.hs-fulda.de
  Peter Klingebiel, HS Fulda, FB AI
Sensoren & Aktoren Programmieren in C / C++ - Kurze Wiederholung C-Programmierung - C/C++ Sensoren&Aktoren
C-Programmierung

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Java – C 1
• Java ist objektorientiert

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Java – C 2
• Objekte kapseln Daten (Attribute) und
  Operationen auf den Daten (Methoden)
• Attribute = Daten in C
• Methoden = Funktionen in C
• Objekte kommunizieren durch Senden und
  Emfangen von Nachrichten
• Objekte entstehen durch Instantiierung einer
  Objektklasse
• Java aus C abgeleitet
• Daher einige Ähnlichkeiten von Java und C
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Java – C 3
• C ist eine imperative strukturierte Sprache
• Daten werden durch die Mühle von Funk-
  tionen geschickt, um dann zu einem Resultat
  (Ergebnisdaten) zu kommen

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Java – C 4
• Beispiel Java:
    public class HelloWorld {
      public static void main(String args[])
      { // Ausgabe Hello World!
        System.out.println("Hello World!");
      }
    }
• Beispiel C:
    int main(int argc, char *argv[])
    {
      printf("Hello World!\n");
      return(0);
    }
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Woher kommt C?
• 1971-73 Dennis Ritchie entwickelt bei den Bell
  Laboratorien C für die Programmierung des neuen
  UNIX-Betriebssystems
• 1973 Implementierung von UNIX in C
• Vorläufer: B (1969/70) und BCPL (1960er Jahre)
• 1978 Ritchie/Kernighan: „The C Programming Language“
  (dt. „Programmieren in C“)
• 1989 Norm ANSI X3.159-1989 Programming Language C
• 1990 ISO Standard C90
• 1995 erweiterter ISO Standard C95
• 1999 ISO/IEC 9899:1999

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Einsatzgebiete von C
•   CAD-, CAE-, Simulationssysteme
•   Text- und Grafikverarbeitungssysteme
•   Mathematik-, Numerische Systeme
•   Betriebssysteme (Unix, Linux, ...)
•   Systemprogramme (Unix, Linux, Windows, ...)
•   Sprachinterpreter, -compiler (GNU C++, CC)
•   Netz-, Webdienste (Apache Webserver, ...)
•   Steuerungs-, Regelungssysteme
•   Microcontrollerprogramme
•   Aber auch: Mathlab  C-Code
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie entsteht ein C-Programm? 1

• On the fly? Quick and dirty?

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie entsteht ein C-Programm? 2

• Problem analysieren und
  Modell entwerfen
• Algorithmus entwickeln
• Programm kodieren
• Programm übersetzen
  (bis syntaktisch fehlerfrei)
• Programm testen
  (bis semantisch fehlerfrei ?)
• Programm produktiv (??)
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie entsteht ein C-Programm? 3
• Nach Problemanalyse und dem Entwurf
  des Lösungsalgorithmus:
• Entwurf des Programms in Pseudocode, mit
  Hilfe von Programmablaufplänen, Strukto-
  grammen oder anderen Entwurfsverfahren
• Kodieren des Programmtextes mit Editor
  (standalone oder in Programmierumgebung)
• Übersetzen des Programmtextes mit dem
  C-Compiler und Montieren zu einem
  ausführbaren Programm
• Programm testen

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie entsteht ein C-Programm? 4
• Beispiel: Programm Ausgabe eines Textes
    $ cat hallo.c
    /* hallo.c */
    #include 
    int main(void)
    {
      puts(„Hallo Welt!\n“);
      return(0);
    }
    $ gcc –o hallo hallo.c
    $ ./hallo
    Hallo Welt!
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie entsteht ein C-Programm? 5
• Übersetzung passiert in mehreren Schritten
• C-Preprozessor (cpp) - reine Textoperationen
  (include, define, if, ..) im Quelltext
• C-Compiler übersetzt C-Quelltext in den
  maschinenabhängigen Assemblercode
• Assembler erzeugt noch nicht ausführbaren
  Maschinencode
• Linker montiert den Maschinencode mit
  Funktionen aus Bibliotheken zu einem dann
  ausführbarem Programm

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie wird ein C-Programm ausgeführt? 1

• Ausführung direkt auf dem Prozessor
     –   z.B. Temperaturregelung in Kühltruhe
     –   z.B. Arduino-Sketch
     –   Programm in ROM, EPROM o.ä. gespeichert
     –   alle Funktionalitäten müssen im Programm in
         Maschinencode vorhanden sein
• Ausführung auf einem Betriebssystem
     – Hardware ist durch das BS gekapselt
     – Starten/Beenden des Programms über das BS
     – Unterstützung durch BS bzw. BS-Funktionen,
       z.B. IO, Dateien, Timer, Signale, Threads usw.
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie wird ein C-Programm ausgeführt? 2

• Betriebssystem
                         Anwendungsprogramm
                              Funktionsbibliotheken
                        Systemcalls / Systemaufrufe
             Hardware / Prozessor
• Mikrocontroller
            Anwendungsprogramm
                              (incl. aller Funktionen)
                           Hardware / Prozessor
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie ist ein C-Programm aufgebaut? 1

• Beispiel hallo.c
     /*
      *              hallo.c
      */
     #include 
     int main(void)
     {
         char *text = "Hallo, Welt! ";
         printf("%s\n", text);
         return(0);
     }
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie ist ein C-Programm aufgebaut? 2

• Kommentare, mit /* und */ geklammert,
  keine Schachtelung möglich!!!
• Einzeiliger Kommentar wie bei Java mit //
• Preprozessoranweisungen, beginnen mit #
• Schlüsselwörter, z.B. return
• Bezeichner (Identifier) für Konstanten,
  Variablen, Funktionsnamen usw. fangen mit
  Buchstaben oder Unterstrich _ an, können
  dann weitere Buchstaben, _ und Ziffern
  enthalten. Keine Schlüsselwörter!
• Jede Anweisung wird mit ; beendet!
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie ist ein C-Programm aufgebaut? 3

• Funktionen / Prozeduren
• Funktionskopf gibt Typ des Rückgabewerts an,
  den Namen der Funktion und in Klammern
  ggfs. die Parameter mit Typ und
  Bezeichnername
• Funktionskörper ist mit { und } geklammert,
  enthält Deklaration von Variablen, Konstanten,
  den Programmablauf sowie das return
• Jedes C-Programm hat eine Funktion main()
  (auch ein Arduino-Programm!)
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Reservierte Worte in C

• C kennt nur 33 reservierte Worte
    auto                    break                  case            char
    const                   continue               default         do
    double                  else                   enum            extern
    float                   for                    goto            inline
    if                      int                    long            register
    return                  short                  signed          sizeof
    static                  struct                 switch          typedef
    union                   unsigned               void            volatile
    while
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
C-Preprozessor 1
• C-Preprozessor bearbeitet C-Quelltexte
  vor dem eigentlichen Compilerlauf
•  rein textueller Eingriff in den Quelltext
• CPP hat eigene Syntax
• # leitet CPP-Anweisungen ein
• CPP-Anweisungen nicht mit ; terminiert!
• Wichtige Direktiven von CPP:
     – #include     – Dateien einfügen
     – #define      – Makros definieren
     – #if / #ifdef – Bedingte Compilierung

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
C-Preprozessor 2
• #include – fügt den Inhalt anderer Dateien
  (sog. Headerfiles) in den Quelltext ein
• Includedateien enthalten i.w.
     –   Deklarationen von Funktionen (prototypes)
     –   Deklarationen von Datentypen
     –   Deklarationen von externen/globalen Variablen
     –   Definitionen von Konstanten (const)
     –   Definitionen von Konstanten als CPP-Makro
     –   Definitionen von CPP-Makros
     –   Bedingte Compilierung

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
C-Preprozessor 3
• #define – definiert ein Makro
   Textersatz
  #define makroname
  #define makroname ersatztext
  #undef makroname
• Beispiele:
     – #define UNIX - Makro UNIX definiert, z.B. zur
       Verwendung bei bedingter Compilierung
     – #define EOF (-1) - Makro EOF wird durch
       Ersatztext (-1) ersetzt  wie Konstante
     – #undef TEST - Makro TEST nicht definiert

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
C-Preprozessor 4

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
C-Preprozessor 5

• Bedingte Compilierung  Verändern des
  Quelltextes abhängig von CPP-Makros
• Syntax
    #if    (expr1)
    #elif (expr2)
    #else
    #endif
• und
    #ifdef (symbol)
    #ifndef (symbol)

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Anweisung / Ausdruck 1
• C kennt keine Anweisungen (statements),
  sondern nur Ausdrücke (expressions)
• Ausdruck hat einen Wert (wie in Assembler!)
• Beispiel: Zuweisung in C
        int i;
        i = 4711;
• Zuweisung kann auch ausgewertet werden:
        int a, b, c, i, j;
        a = b = c = 3;
        if(i = 4711)
          ...
        while(j = 1)
          ...

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Anweisung / Ausdruck 2

• Ausdruck  Gültige Kombination von
    Konstanten, Variablen, Operatoren, Funktionen
• Reihenfolge der Auswertung
     – Vorrangregeln der Operatoren legen Reihenfolge
       der Auswertung implizit fest
     – Klammern ( ) legen Vorrangregeln explizit fest
     – Sind Vorrangregeln nicht eindeutig
        Reihenfolge der Auswertung nicht definiert
     – Compiler kann Ausdrücke / Teilausdrücke in
       effizient auswerten / optimieren

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Datentypen 1

• Vordefinierte Grunddatentypen
    char   Zeichen (ASCII-Kode, 8 Bit)
    int    Ganzzahl (maschinenabhängig,
           meist 16 oder 32 Bit)
    float Gleitkommazahl (32 Bit, IEEE,
           etwa auf 6 Stellen genau)
    double doppelt genaue Gleitkommazahl
           (64 Bit, IEEE, etwa auf
            12 Stellen genau)
    void   ohne Wert (z.B. Zeiger)

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Datentypen 2

• Type-Modifier spezifizieren Grunddatentypen
• short int, long int, long long
     – legen Länge der Ganzzahl
     – maschinenabhängig, 16 Bit, 32 Bit
     – int kann auch fehlen
• long double
     – Gleitkommazahl, erw. Genauigkeit
     – oft 96 oder 128 Bit, IEEE
• signed, unsigned
     – char/int mit/ohne Vorzeichen
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Konstanten

• Konstanten haben einen festgelegten und
  damit unveränderbaren Wert
• explizite Definition, z.B.
  const float pi = 3.141;
• implizite Definition, z.B.
  u = 2 * r * 3.141;
• mittels CPP textuelle implizite Ersetzung
  #define PI 3.141
    ...

    u = 2 * PI * r;
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Variablen 1
• Variable sind Platzhalter für Daten
• haben einen festgelegten Speicherort,
  an dem der aktuelle Wert gespeichert wird
• der aktuelle Wert (an seinem Speicherort)
  ist veränderbar
• Eigenschaften von Variablen:
     –   Datentyp
     –   Namen (Bezeichner, Identifier)
     –   Lebensdauer / Speicherklasse
     –   evtl. initialer Wert
     –   Sichtbarkeit (Scope)
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Variablen 2

• Variablen-Definitionen
  typ name und evtl. Initialisierung , z.B.
  double u;
  short int i, tab = 5;
  char *hallo = "Hallo, Welt!";
• Position im Programm:
     – außerhalb von Funktionen
     – in einem Block, also zwischen {                             }
• Wert ist veränderbar (Zuweisung, Operation)
• Programmstruktur  Lebensdauer / Scope
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Wie speichert C?

• Hauptspeicher

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Zeiger / Pointer
• Jede Variable hat einen Speicherort,
  d.h. eine Adresse im Hauptspeicher
• Zeiger (Pointer) sind Variable, die auf eine
  andere Variable verweisen, oder
  exakter: den Speicherort bzw. die Adresse
  dieser Variablen als Wert haben
• Pointerdefinition:    int *ip;
                        int i = 5;
• Adresszuweisung: ip = &i;
• Zugriff auf Wert:     *ip = *ip + *ip;

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionsaufruf und Parameter

• Parameterübergabe als Werte (call by value),
  z.B. bei printf()
• Variable werden als Werte in den
  Adressraum der Funktion kopiert
• Parameterübergabe als Adresse (call by
  reference), z.B. bei scanf()
• Adressen der Variablen werden in den
  Adressraum der Funktion kopiert
• In Funktion sind die Parameter  Zeiger

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Felder 1

• ein Feld (array) ist die Zusammenfassung
  von Daten gleichen Typs in einer Variablen
• Felder haben eine oder auch mehrere
  Dimensionen (Vektoren, Matrizen, …)
• Definition von Feldern:
        char sbuf[128];
        int arr[] = { 1, 8, 7, -1, 2 };
        short mat[2][2] = { 11, 12, 21, 22};
• mit der Felddefinition wird der benötigte
  Speicherplatz für die Variable reserviert
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Felder 2
• Zugriff auf Feldelemente mit Index in []:
        char c;
        c = sbuf[32];
        sbuf[0] = 'A';
• die Feldindizierung beginnt immer mit 0!
        short s, mat[3][3];
        s = mat[0][0];
• Felder werden elementweise und Zeile für
  Zeile hintereinander gespeichert
• es gibt beim Zugriff keinerlei Überprüfungen
  auf Bereichsgrenzen von Feldern!

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Zeichenketten 1
• Zeichenketten (strings) sind eine Folge von
  Einzelzeichen char
• String ist terminiert mit '\0'
•  Speicherbedarf: Länge + 1 Byte
• Beispiel:
        char *s;
        char *hallo = "Hallo, Welt!";
• String  Pointer auf Feld von Elementen vom
  Typ char
• Nullstring  NULL (definiert in stdio.h)
• Leerstring  char *leerstr = "";
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Zeichenketten 2
• Beispiel:
        char buffer[128];
        char *bp = buffer;
• Stringpointer bp  erstes Zeichen im Feld
  buffer
•  Ähnlichkeit von Feldern und Pointern!
• Beispiel: String kopieren und ausgeben
     char buffer[64], *bp;
     strcpy(buffer, "Hallo, Welt");
     bp = buffer;
     while(*bp)
       putchar(*bp++);

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Aufzählungsdatentyp
• Aufzählungsdatentyp enum
• Für Datentypen mit diskreten konstanten
  Werten
• Beispiel:
        enum color { rot, gruen, blau } c;
        enum boolean { FALSE, TRUE } b;
        b = FALSE;
        c = blau;
• Darstellung als int beginnend mit 0,
  wenn nicht explizit angegeben:
        enum boolean { TRUE=1, FALSE=0 } b;
        b = TRUE;

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Zusammengesetzte Datentypen 1
• Zusammenfassung von zusammengehörigen
  Daten in eigenen Datentyp struct
• Beispiel: einfaches EA-Gerät mit 8-Bit
  Steuerregister cr und 16-Bit Datenregister dr:
        struct { char cr; int dr; } ea1;
        struct _ea { char cr; int dr; } ea2;
• Zugriff durch Selektor .
        if(ea1.cr & 0x01)
          ea2.dr = 4711;
• bei Pointern durch Selektor ->
        if(ea1->cr & 0x01)
          ea2->dr = 4711;
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Zusammengesetzte Datentypen 2

• Beispiel: Datentyp struct circle für
  Objekt Kreis in einem Zeichenprogramm
    notwendig  Mittelpunkt (x,y) und Radius r
    /* Kreis: Typ */
    struct circle {
      int x; /* Mittelpunktkoordinate x */
      int y; /* Mittelpunktkoordinate y */
      int r; /* Radius */
    };
    struct circle c;
    c.x = 100; c.y = 100; c.r = 50;

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Typdefinitionen
• Oft sinnvoll, eigene Typen oder Untertypen
  zu definieren typedef
• Beispiel:
        typedef unsigned char byte;
• Beispiel:
        typedef struct _ea {
          byte cr;
          int dr;
        } ea;
        ea ea1, ea2;
• eigentlich nur ein neuer Name für den Typ
   besser lesbar, bessere Dokumentation!
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Ausdrücke

• Ausdrücke
     – Definitionen, Zuweisungen, …
     – arithmetische, logische, … Operationen, …
• bei Zuweisungen zu beachten:
  gültiger l-value und r-value
     – l-value (left, location) Variable mit Speicherplatz
     – r-value (right, read) auswertbarer Ausdruck
     – Beispiel:
         int i, j;
         i = 9 / 3;            /* gültiger l-value   */
         45 = j;               /* ungültiger l-value */
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Blöcke 1
• Zusammenfassung mehrerer Anweisungen
• Geklammert mit { }
• v.a. bei Funktionen, Kontrollstrukturen
• aber auch lokale Blöcke (Unterblöcke)
  z.B. zur Definition von lokalen Variablen,
  insbesondere Hilfsvariablen
• legt Lebensdauer von Variablen fest
• legt Sichtbarkeit (Scope) von Variablen fest
• bei Namensgleichheit ist Variable des
  innersten Blocks sichtbar
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Blöcke 2

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Kontrollstrukturen
• Kontrolle des Programmablaufs abhängig
  von Ergebnis von Ausdrücken
• Selektionen / bedingte Anweisungen
     – Einfache Alternative if … else
     – Mehrfache Alternative if … else if … else
     – Fallunterscheidung switch
• Iterationen / Schleifen
     – Abweisende Schleife while
     – Laufanweisung for
     – Annehmende Schleife do … while

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Selektionen 1

• Bedingte Anweisung if
• Syntax:
    if (ausdruck)
        anweisung
• Bedingte Anweisung if … else
• Syntax:
    if (ausdruck)
        anweisung
    else
        anweisung

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Selektionen 2
• Mehrfache Alternative if…else if…else
    if (ausdruck_1)
        anweisung_1
    else if(ausdruck_2)
        anweisung_2
    else if(ausdruck_3)
        anweisung_3
    else if (ausdruck_n)
        anweisung_n
    ...
    ...
    else             /* kann auch fehlen */
        anweisung_else
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Selektionen 3
• Mehrfachauswahl oder Fallunterscheidung
  bei konstanten Alternativen
    switch
    switch(ausdruck){
      case k1:    // k1  Konstante
        anweisung_1;
        break;
      case k2:    // k2  Konstante
        anweisung_2;
        break;
      . . .
      default:
        anweisung_default;
    }

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Iterationen 1

• Abweisende Schleife while, manchmal auch
  kopfgesteuerte Schleife genannt
• Syntax
  while (ausdruck)
    anweisung
• Bedingung ausdruck wird vor Ausführung
  vom Schleifenkörper anweisung geprüft
• Schleifenkörper wird nur ausgeführt, wenn
  Bedingung ausdruck wahr ist

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Iterationen 2

• Laufanweisung oder abweisende Schleife mit
  for
• Syntax
    for(ausdruck1; ausdruck2; ausdruck3)
      anweisung
• Kann durch while-Schleife ersetzt werden:
    ausdruck1;
    while(ausdruck2) {
      anweisung;
      ausdruck3;
    }
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Iterationen 3
• Nicht-annehmende Schleife do while,
  machmal auch: fußgesteuerte Schleife
• Syntax
  do
     anweisung
  while (ausdruck)
• Bedingung ausdruck wird erst am Ende des
  Schleifenkörperts geprüft
•  Schleife wird mindestens einmal
  durchlaufen

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Iterationen 4

• Schleifensteuerung
• break
     – bricht die Ausführung der aktuellen Schleife bzw.
       switch-Anweisung ab und verlässt diese
• continue
     – bricht den aktuellen Schleifendurchlauf ab
     – setzt mit Ausführung des Schleifenkopfes fort
• Endlosschleife
    while(1) ...
    for(;;) ...

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 1

• Funktionen sind Programmteile (Blöcke) mit
  Namen, ggfs. Parametern und ggfs. einem
  Rückgabewert
• elementare Bausteine für Programme
     – gliedern umfangreiche Aufgaben in kleinere
       Komponenten
     – reduzieren Komplexität
     – Wiederverwendung von Komponenten
     – verbergen Details der Implementierung vor
       anderen Programmteilen (black box)

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 2

• Funktionsdefinition
    typ name(parameter)
• Typ
     – Datentyp, der von Funktion zurückgeliefert wird
     – void  kein Rückgabewert (Prozedur)
• Name
     – Bezeichner kann beliebig gewählt sein
     – Regeln für Identifier, keine Schlüsselworte
• Parameter
     – Liste von typ name der Parameter in Klammern
     – keine Parameter: () oder (void)
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 3

• Body  Block mit {} geklammert
• zusätzliche Anweisung return(ausdruck)
   Rückkehr aus der Funktion
• Bei void-Funktion: nur return
• nach Rückkehr aus Funktion  Programm
  wird nach Funktionsaufruf fortgesetzt
• Typ von Ausdruck und Funktion müssen
  übereinstimmen
• Klammern bei return können entfallen

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 4

• Die Ausdrücke in der Parameterliste werden
  vor dem Sprung in die Funktion ausgewertet
   aktuelle Parameter
• Anzahl und Typen der Ausdrücke der
  aktuellen Parameter müssen mit denen der
  formalen Parameter in der Definition der
  Funktion übereinstimmen
• Die Auswertungsreihenfolge der Parameter-
  ausdrücke ist nicht festgelegt

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 5
• Funktionen werden global definiert
   keine lokalen Funktionen möglich
• static beschränkt Funktion auf Modul
• main() ist normale Funktion, die aber beim
  Programmstart automatisch aufgerufen wird
• Rekursion ist möglich:
    int fak(int n)
    {
      if(n == 1) return(1);
      else return(n * fak(n-1));
    }

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 6
• Funktionen müssen deklariert sein, bevor sie
  aufgerufen werden können
• Name, Rückgabetyp und Parametertypen
  müssen dem Compiler bekannt sein
• Funktionsdefinition  Funktion ist
  automatisch deklariert und bekannt
• sonst Prototype, z.B. in Headerdatei
    typ name ( liste der parametertypen );
• Beispiele:
    double sin(double);
    double cos(double x);
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Funktionen 7

• Parameterübergabe an Funktionen
• call by value
     – aktuelle Parameter werden in Speicherbereich der
       Funktion kopiert
     – in Funktion: Änderungen nur lokal in Funktion
• call by reference
     – In C nur über Zeiger realisierbar
     – Adresse der Parameter werden in Funktion kopiert
     – Änderungen an Parametern  Änderungen an
       den originalen Variablen
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Speicherklassen 1

• Funktionen können nur global, d.h.
  ausserhalb von Blöcken definiert werden
     – Sichtbarkeit global
     – static  Sichtbarkeit im Quelldateikontext
• Variablen können ausserhalb von Blöcken,
  d.h. global definiert werden
     – Sichtbarkeit global
     – static  Sichtbarkeit im Quelldateikontext
• Variablen können innerhalb von Blöcken,
  d.h. lokal oder automatisch definiert werden
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Speicherklassen 2
• auto
     – nur innerhalb eines Blocks, Standardklasse
     – Variable existiert / ist sichtbar nur im Block
• static
     – in Block: Variable erhält ihren Wert
     – sonst: Variable/Funktion nur in C-Quelle sichtbar
• extern
     – Variable ist in anderer C-Quelle definiert
• volatile
     – Variable kann außerhalb des Programms beeinflußt werden, z.B. in
       Interruptroutine, daher nicht optimieren, immer laden u.ä.
• register
     – Variable  CPU-Register, hat keine Adresse!

Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Lebensdauer

• Lebensdauer einer Variablen ist die Zeit,
  in der diese Variable Speicherplatz belegt
• lokale / automatische Variable
     – „lebt“, d.h. hat einen Speicherort vom Anfang bis
       zum Ende des Blocks, in dem sie definiert ist
     – Speicherplatz wird bei Verlassen des Blocks
       wieder freigegeben  Variable ist ungültig!
     – Zugriff darauf ist dann undefiniert
• globale oder statische Variable
     – „lebt“ vom Anfang bis zum Ende des Programms
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Sichtbarkeit 1

• der Sichtbarkeitsbereich (Scope) einer
  Variablen  Programmabschnitt, in dem die
  Variable sichtbar / nutzbar / gültig ist
• der Scope wird durch den Ort der Definition
  bzw. Deklaration der Variablen festgelegt
     – innerhalb eines Blocks  sichtbar von der Stelle der
       Definition bis zum Blockende
     – ausserhalb  sichtbar von Stelle der Definition bzw.
       Deklaration bis zum Ende der Quelldatei
     – mit static definierte Variablen sind nur im Modul
       (= C-Quelldatei) sichtbar
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Sichtbarkeit 2

• globale Variable müssen ausserhalb von
  Blöcken definiert sein
• Variablen aus anderen Modulen (globale
  Variable) müssen explizit als extern
  deklariert werden
• Scope einer Funktion: Bereich auf Ebene des
  Programms, in der die Funktion nutzbar ist
     – global
     – sollte dann vor Nutzung bekannt sein (Prototype)
     – lokal nur im Modul bei Definition als static
Sensoren&Aktoren - C / C++ - Peter Klingebiel - HS Fulda - FB AI
Sie können auch lesen